diff --git a/.agents/workflows/pull.md b/.agents/workflows/pull.md index 506fe306..5df7a72c 100644 --- a/.agents/workflows/pull.md +++ b/.agents/workflows/pull.md @@ -50,10 +50,10 @@ Fetches unresolved review comments and findings posted by CodeRabbit on the bran } }' -f threadId="" -f body="" ``` - - If **Accepted**: Format reply starting with `Accepted. `. - *(Note: This format signals CodeRabbit's GitHub App bot to confirm the remediation and manage thread auto-resolution according to its native workflow).* + - If **Remediated**: Format reply starting with `Remediated locally (pending push): `. + *(Note: Omitting the trigger word `Accepted.` keeps the thread open on GitHub until the commit is pushed. Upon git push, CodeRabbit automatically inspects the commit diff, verifies the fix, and auto-resolves the thread).* - If **Skipped**: Format reply starting with `Skipped. `. - - **Do NOT call `resolveReviewThread` directly**: The agent never manually executes thread resolution mutations; thread resolution is handled natively by CodeRabbit's bot confirmation or left for the user's manual review. + - **Do NOT call `resolveReviewThread` directly**: The agent never manually executes thread resolution mutations; thread resolution is handled natively by CodeRabbit's bot after verifying the pushed commit, or left for the user's manual review. 7. **Summary & User Handoff**: - Provide a concise summary table or list detailing: diff --git a/.coderabbit.yaml b/.coderabbit.yaml index ca1cf5e2..02e38f37 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -16,12 +16,12 @@ reviews: - "!**/public/providers.v1.*" # Ignore static provider definitions (.json and .jsonc) - "!**/doc/api/**" # Ignore legacy TypeDoc API documentation - "!**/public/api/**" # Ignore generated TypeDoc API documentation + - "!**/public/v4/**" # Ignore frozen v4 documentation site - "!**/coverage/**" # Ignore test coverage reports and HTML fixtures - "!**/.vitepress/cache/**" # Ignore VitePress cache - "!**/.vitepress/dist/**" # Ignore VitePress build output - "!**/dist/**" # Ignore all build artifacts - "!**/plan/**" # Ignore internal planning and roadmap RFCs - "!**/vendor/**" # Ignore third-party code - - "!**/*.md" # Temporarily ignore markdown documentation for v5 release diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index f4d67198..0c7bff83 100644 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -1,16 +1,18 @@ name: Deploy Documentation on: - push: - branches: [main] - # Trigger on changes to documentation-producing packages or this workflow - paths: - - 'packages/tempo/**' - - 'packages/functions/**' - - 'packages/plugins/**' - - 'packages/library/**' - - '.github/workflows/deploy-docs.yml' - - 'package.json' - - 'package-lock.json' + workflow_dispatch: + # Temporarily paused during v5 active development to prevent premature GH Pages updates. + # Re-enable upon official v5 release. + # push: + # branches: [main] + # paths: + # - 'packages/tempo/**' + # - 'packages/functions/**' + # - 'packages/plugins/**' + # - 'packages/library/**' + # - '.github/workflows/deploy-docs.yml' + # - 'package.json' + # - 'package-lock.json' permissions: contents: read diff --git a/packages/functions/src/celestial/solar.ts b/packages/functions/src/celestial/solar.ts index dde104fe..4dddfc26 100644 --- a/packages/functions/src/celestial/solar.ts +++ b/packages/functions/src/celestial/solar.ts @@ -1,3 +1,4 @@ +import { ValueOf } from '@magmacomputing/tempo/plugin/plugin.sdk'; import { SolarOptions, SolarTwilightWindow, @@ -20,6 +21,7 @@ export const SOLAR_PHASE_STATES = Object.freeze([ 'civil-twilight', 'daylight' ] as const); +type SOLAR_PHASE_STATES = ValueOf export type SolarPhaseName = | 'Daylight' @@ -29,7 +31,7 @@ export type SolarPhaseName = | 'Astronomical Twilight'; /** Maps solar phase state keys to their human-readable display names */ -export const SOLAR_PHASE_NAMES: Record = Object.freeze({ +export const SOLAR_PHASE_NAMES: Record = Object.freeze({ 'daylight': 'Daylight', 'night': 'Night', 'civil-twilight': 'Civil Twilight', diff --git a/packages/library/src/common/runtime/international.library.ts b/packages/library/src/common/runtime/international.library.ts index 1cb4ea05..0a474006 100644 --- a/packages/library/src/common/runtime/international.library.ts +++ b/packages/library/src/common/runtime/international.library.ts @@ -106,12 +106,10 @@ export interface LocaleWeekInfo { } export interface ResolvedLocaleInfo { - readonly locale?: Intl.Locale | undefined; readonly baseName: string; readonly language?: string | undefined; readonly region?: string | undefined; readonly script?: string | undefined; - readonly weekInfo: LocaleWeekInfo; readonly firstDay: number; readonly minimalDays: number; readonly weekend: readonly number[]; @@ -121,11 +119,13 @@ export interface ResolvedLocaleInfo { readonly numberingSystem: string; readonly numberingSystems: readonly string[]; readonly timeZones: readonly string[]; + readonly calendar: string; + readonly calendars: readonly string[]; } export interface TempoIntlNamespace { /** - * Resolved cultural and regional calendar metadata (firstDay, weekend, direction, hourCycle, etc.) + * Resolved cultural and regional calendar metadata (firstDay, weekend, direction, hourCycle, calendars, etc.) * via the host engine's CLDR / Intl.Locale Info database. */ readonly info: ResolvedLocaleInfo; @@ -178,52 +178,6 @@ export interface TempoIntlNamespace { * Returns a globally memoized native Intl.NumberFormat instance pre-bound to the active locale. */ nf(options?: Intl.NumberFormatOptions): Intl.NumberFormat; - - // ========================================================================= - // Backward Compatibility Fallbacks (@deprecated for v4.x, removed in v5.0.0) - // ========================================================================= - - /** @deprecated Use `intl.info.firstDay` instead. To be removed in v5.0.0. */ - readonly firstDay: number; - - /** Minimum days required in the first week of the year */ - readonly minimalDays: number; - - /** @deprecated Use `intl.info.weekend` instead. To be removed in v5.0.0. */ - readonly weekend: readonly number[]; - - /** @deprecated Use `intl.info.direction` instead. To be removed in v5.0.0. */ - readonly direction: 'ltr' | 'rtl'; - - /** @deprecated Use `intl.info.hourCycle` instead. To be removed in v5.0.0. */ - readonly hourCycle: string; - - /** @deprecated Use `intl.info.hourCycles` instead. To be removed in v5.0.0. */ - readonly hourCycles: readonly string[]; - - /** @deprecated Use `intl.info.numberingSystem` instead. To be removed in v5.0.0. */ - readonly numberingSystem: string; - - /** @deprecated Use `intl.info.numberingSystems` instead. To be removed in v5.0.0. */ - readonly numberingSystems: readonly string[]; - - /** @deprecated Use `intl.info.region` instead. To be removed in v5.0.0. */ - readonly region?: string | undefined; - - /** @deprecated Use `intl.info.script` instead. To be removed in v5.0.0. */ - readonly script?: string | undefined; - - /** @deprecated Use `intl.info.language` instead. To be removed in v5.0.0. */ - readonly language?: string | undefined; - - /** @deprecated Use `intl.info.timeZones` instead. To be removed in v5.0.0. */ - readonly timeZones: readonly string[]; - - /** @deprecated Use `intl.info.baseName` instead. To be removed in v5.0.0. */ - readonly baseName: string; - - /** @deprecated Use `intl.info.weekInfo` instead. To be removed in v5.0.0. */ - readonly weekInfo: LocaleWeekInfo; } /** @@ -362,24 +316,34 @@ export const getLI = memoizeFunction((localeTag?: LocaleInput): ResolvedLocaleIn ? Object.freeze([...rawTimeZones]) : Object.freeze([]); - const weekInfo: LocaleWeekInfo = Object.freeze({ firstDay, minimalDays, weekend }); + // 6. Calendars (getCalendars() or .calendars or legacy .calendar) + const rawCalendars = getPropOrCall(loc, 'getCalendars', 'calendars') ?? loc?.calendar; + const resolvedCalendar = hasIntl('DateTimeFormat') + ? getDTF(loc ?? baseName).resolvedOptions().calendar + : undefined; + const calendars = Array.isArray(rawCalendars) && rawCalendars.length > 0 + ? Object.freeze([...rawCalendars]) + : (isString(rawCalendars) + ? Object.freeze([rawCalendars]) + : (isString(resolvedCalendar) ? Object.freeze([resolvedCalendar]) : Object.freeze(['gregory']))); + const calendar = calendars[0] ?? 'gregory'; return Object.freeze({ - locale: loc, baseName, language, region, script, - weekInfo, firstDay, minimalDays, weekend, - hourCycle: hourCycles[0], + hourCycle: hourCycles[0] ?? 'h23', hourCycles, direction, - numberingSystem: numberingSystems[0], + numberingSystem: numberingSystems[0] ?? 'latn', numberingSystems, timeZones, + calendar, + calendars, }); }); @@ -421,20 +385,6 @@ export const getIntlNamespace = memoizeFunction((localeTag?: LocaleInput, timeZo nf(options?: Intl.NumberFormatOptions): Intl.NumberFormat { return getNF(targetLocale, options); }, - firstDay: info.firstDay, - minimalDays: info.minimalDays, - weekend: info.weekend, - direction: info.direction, - hourCycle: info.hourCycle, - hourCycles: info.hourCycles, - numberingSystem: info.numberingSystem, - numberingSystems: info.numberingSystems, - region: info.region, - script: info.script, - language: info.language, - timeZones: info.timeZones, - baseName: info.baseName, - weekInfo: info.weekInfo, }); }); diff --git a/packages/library/test/common/runtime/international.library.test.ts b/packages/library/test/common/runtime/international.library.test.ts index 54f24010..eb23e302 100644 --- a/packages/library/test/common/runtime/international.library.test.ts +++ b/packages/library/test/common/runtime/international.library.test.ts @@ -73,9 +73,9 @@ describe('International Library', () => { expect(info.direction).toBe('ltr'); expect(info.numberingSystem).toBe('latn'); expect(info.firstDay).toBe(7); // Sunday - expect(info.weekInfo.firstDay).toBe(7); expect(info.weekend).toEqual([6, 7]); - expect(info.weekInfo.weekend).toEqual([6, 7]); + expect(info.calendar).toBe('gregory'); + expect(info.calendars).toContain('gregory'); }); it('should resolve en-GB with Monday firstDay', () => { @@ -94,7 +94,6 @@ describe('International Library', () => { const info = getLI('invalid!locale#tag'); expect(info.baseName).toBe('en-US'); expect(info.firstDay).toBe(7); - expect(info.locale?.baseName).toBe('en-US'); }); it('should memoize results returning identical references', () => { @@ -106,11 +105,11 @@ describe('International Library', () => { it('should return frozen immutable objects', () => { const info = getLI('en-US'); expect(Object.isFrozen(info)).toBe(true); - expect(Object.isFrozen(info.weekInfo)).toBe(true); expect(Object.isFrozen(info.weekend)).toBe(true); expect(Object.isFrozen(info.hourCycles)).toBe(true); expect(Object.isFrozen(info.numberingSystems)).toBe(true); expect(Object.isFrozen(info.timeZones)).toBe(true); + expect(Object.isFrozen(info.calendars)).toBe(true); }); it('should expose language on ResolvedLocaleInfo', () => { @@ -123,11 +122,12 @@ describe('International Library', () => { const withScript = getLI('zh-Hans-CN'); expect(withScript.baseName).toBe('zh-Hans-CN'); expect(withScript.language).toBe('zh'); - expect(withScript.locale?.region).toBe('CN'); + expect(withScript.region).toBe('CN'); const noRegion = getLI('zh-Hans'); expect(noRegion.baseName).toBe('zh-Hans'); - expect(noRegion.locale?.region).toBeUndefined(); + expect(noRegion.language).toBe('zh'); + expect(noRegion.script).toBe('Hans'); }); it('should not derive region from extension subtags', () => { diff --git a/packages/library/test/common/runtime/reactive.class.test.ts b/packages/library/test/common/runtime/reactive.class.test.ts index 27689edc..79755782 100644 --- a/packages/library/test/common/runtime/reactive.class.test.ts +++ b/packages/library/test/common/runtime/reactive.class.test.ts @@ -534,33 +534,39 @@ describe('common/runtime/reactive.class', () => { }); it('propagates getter errors in Reactive.fromSignal to stream.error', async () => { - // 1. Initial getter error - const faultySignal = () => { - throw new Error('Initial evaluation exploded'); - }; - const stream = Reactive.fromSignal(faultySignal); - await expect(stream.pull()).rejects.toThrow('Initial evaluation exploded'); - - // 2. Dynamic getter error upon signal mutation - const num = new Signify.State(10); - const dynamicStream = Reactive.fromSignal(() => { - if (num.get() === 20) throw new Error('Dynamic evaluation exploded'); - return num.get(); - }); - - let dynamicError: Error | undefined; - dynamicStream.on('error', (err) => { - dynamicError = err; - }); - - // Pull initial value from buffer - expect(await dynamicStream.pull()).toBe(10); - - // Mutate signal to trigger error in effect callback - num.set(20); - await new Promise((r) => queueMicrotask(() => r())); - expect(dynamicError?.message).toBe('Dynamic evaluation exploded'); - await expect(dynamicStream.pull()).rejects.toThrow('Dynamic evaluation exploded'); + const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { }); + try { + // 1. Initial getter error + const faultySignal = () => { + throw new Error('Initial evaluation exploded'); + }; + const stream = Reactive.fromSignal(faultySignal); + await expect(stream.pull()).rejects.toThrow('Initial evaluation exploded'); + expect(errSpy).toHaveBeenCalledWith('Unhandled Reactive error:', expect.any(Error)); + + // 2. Dynamic getter error upon signal mutation + const num = new Signify.State(10); + const dynamicStream = Reactive.fromSignal(() => { + if (num.get() === 20) throw new Error('Dynamic evaluation exploded'); + return num.get(); + }); + + let dynamicError: Error | undefined; + dynamicStream.on('error', (err) => { + dynamicError = err; + }); + + // Pull initial value from buffer + expect(await dynamicStream.pull()).toBe(10); + + // Mutate signal to trigger error in effect callback + num.set(20); + await new Promise((r) => queueMicrotask(() => r())); + expect(dynamicError?.message).toBe('Dynamic evaluation exploded'); + await expect(dynamicStream.pull()).rejects.toThrow('Dynamic evaluation exploded'); + } finally { + errSpy.mockRestore(); + } }); }); diff --git a/packages/plugins/dialects/doc/token-specification.md b/packages/plugins/dialects/doc/token-specification.md index aeea9c7f..294e8a19 100644 --- a/packages/plugins/dialects/doc/token-specification.md +++ b/packages/plugins/dialects/doc/token-specification.md @@ -59,7 +59,7 @@ For a high-level overview across the most common date-formatting paradigms, the | **Microseconds** | 6-digit fractional seconds (`123456`) | `SSSSSS` | `SSSSSS`* | `%f`* | `ffffff` | `{ff:6}` | | **Timezone Offset** | Fixed offset with colon (`+08:00`) | `ZZZZZ` / `XXX` | `Z` | N/A | `zzz` | `{tz:offset}` | | **Timezone (Kind-based)** | Dynamic offset or Z based on `DateTime.Kind` | N/A | N/A | N/A | `K`* | `{tz:offset:utc}` | -| **Compact Offset** | Portable offset without colon (`+0800`) | `ZZ` | `ZZ` | `%z` | N/A | `{tz:offsetcompact}` | +| **Compact Offset** | Portable offset without colon (`+0800`) | `ZZ` | `ZZ` | `%z` | N/A | `{tz:offset:compact}` | | **Timezone Abbreviation** | Localized abbreviation (`CET`) | `z` | `z` | `%Z` | N/A | `{tz:short}` | | **Unix Epoch** | Seconds since Unix epoch | N/A | `X` | `%s`* | N/A | `{ts}` | diff --git a/packages/plugins/dialects/src/compiler/dotnet.compiler.ts b/packages/plugins/dialects/src/compiler/dotnet.compiler.ts index 5dd00c53..c4ca088d 100644 --- a/packages/plugins/dialects/src/compiler/dotnet.compiler.ts +++ b/packages/plugins/dialects/src/compiler/dotnet.compiler.ts @@ -1,5 +1,4 @@ -import { pad, WeakCache, Enum, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { pad, WeakCache, Enum, enums, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import type { FormatterFn, DialectOptions } from './shared.compiler.js'; import { escapeRegex, @@ -29,8 +28,7 @@ export const DOTNET_TOKENS = [ 'K', 'gg', 'g', ] as const; -export type DotNetSpecifier = (typeof DOTNET_TOKENS)[number]; - +export type DotNetSpecifier = ValueOf /** * Unescapes backslash-escaped characters within .NET quoted string literals. */ diff --git a/packages/plugins/dialects/src/compiler/go.compiler.ts b/packages/plugins/dialects/src/compiler/go.compiler.ts index 70e86d83..1bd4b9e0 100644 --- a/packages/plugins/dialects/src/compiler/go.compiler.ts +++ b/packages/plugins/dialects/src/compiler/go.compiler.ts @@ -1,5 +1,4 @@ -import { WeakCache, Enum, resolveDayOfYear, resolveFractionalSeconds } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { WeakCache, Enum, enums, resolveDayOfYear, resolveFractionalSeconds } from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, diff --git a/packages/plugins/dialects/src/compiler/ldml.compiler.ts b/packages/plugins/dialects/src/compiler/ldml.compiler.ts index c3153c13..f7780abe 100644 --- a/packages/plugins/dialects/src/compiler/ldml.compiler.ts +++ b/packages/plugins/dialects/src/compiler/ldml.compiler.ts @@ -1,5 +1,4 @@ -import { pad, suffix, WeakCache, Enum, resolveTwoDigitYear, resolveDayOfYear, resolveFractionalSeconds, getIsoWeek, fromIsoWeek, ValueOf } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { pad, suffix, WeakCache, Enum, enums, resolveTwoDigitYear, resolveDayOfYear, resolveFractionalSeconds, getIsoWeek, fromIsoWeek, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, @@ -26,7 +25,7 @@ export const LDML_TOKENS = [ 'a', 'c', 'e', 'E', 'w', 'W', 'Q', 'q', 'Z', 'z', 'I', ] as const; -export type LdmlToken = ValueOf; +export type LdmlToken = ValueOf const LDML_TOKEN_REGEX = new RegExp(`'(''|[^'])*'|(${LDML_TOKENS.join('|')})`, 'g'); diff --git a/packages/plugins/dialects/src/compiler/mysql.compiler.ts b/packages/plugins/dialects/src/compiler/mysql.compiler.ts index a1712336..b8cc2430 100644 --- a/packages/plugins/dialects/src/compiler/mysql.compiler.ts +++ b/packages/plugins/dialects/src/compiler/mysql.compiler.ts @@ -1,5 +1,4 @@ -import { pad, suffix, WeakCache, Enum, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear, getIsoWeek, fromIsoWeek } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { pad, suffix, WeakCache, Enum, enums, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear, getIsoWeek, fromIsoWeek, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, @@ -27,7 +26,7 @@ export const MYSQL_SPECIFIERS = [ 'V', 'X', ] as const; -export type MysqlSpecifier = (typeof MYSQL_SPECIFIERS)[number]; +export type MysqlSpecifier = ValueOf export const MYSQL_SPECIFIER_REGEX = new RegExp(`%([${MYSQL_SPECIFIERS.join('')}])`, 'g'); diff --git a/packages/plugins/dialects/src/compiler/oracle.compiler.ts b/packages/plugins/dialects/src/compiler/oracle.compiler.ts index 161c541e..8218a25f 100644 --- a/packages/plugins/dialects/src/compiler/oracle.compiler.ts +++ b/packages/plugins/dialects/src/compiler/oracle.compiler.ts @@ -1,5 +1,7 @@ -import { pad, suffix, WeakCache, resolveDayOfYear, getIsoWeek, fromIsoWeek, resolveIsoCalendarYear, resolveFractionalSeconds } from '@magmacomputing/tempo/library'; -import { enums, Enum } from '@magmacomputing/tempo/support'; +import { + pad, suffix, WeakCache, resolveDayOfYear, getIsoWeek, fromIsoWeek, + resolveIsoCalendarYear, resolveFractionalSeconds, Enum, enums, type ValueOf +} from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, @@ -24,7 +26,7 @@ export const ORACLE_TOKENS = [ 'D', 'W', 'Q', 'Y', 'I', 'J', ] as const; -export type OracleToken = (typeof ORACLE_TOKENS)[number]; +export type OracleToken = ValueOf const oracleEscaped = ORACLE_TOKENS.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')); const dddIdx = oracleEscaped.indexOf('DDD'); diff --git a/packages/plugins/dialects/src/compiler/php.compiler.ts b/packages/plugins/dialects/src/compiler/php.compiler.ts index 52fa9d37..36f3ddd6 100644 --- a/packages/plugins/dialects/src/compiler/php.compiler.ts +++ b/packages/plugins/dialects/src/compiler/php.compiler.ts @@ -1,5 +1,4 @@ -import { WeakCache, suffix, Enum, getISOWeekOfYear, getIsoWeek, fromIsoWeek, resolveIsoCalendarYear, resolveTwoDigitYear, resolveDayOfYear } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { WeakCache, suffix, Enum, enums, getISOWeekOfYear, getIsoWeek, fromIsoWeek, resolveIsoCalendarYear, resolveTwoDigitYear, resolveDayOfYear, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, @@ -27,7 +26,7 @@ export const PHP_TOKENS = [ 'c', 'r', ] as const; -export type PhpToken = (typeof PHP_TOKENS)[number]; +export type PhpToken = ValueOf /** * Compiles a PHP date format mask into a high-performance formatter function. diff --git a/packages/plugins/dialects/src/compiler/shared.compiler.ts b/packages/plugins/dialects/src/compiler/shared.compiler.ts index 951402ee..6f603647 100644 --- a/packages/plugins/dialects/src/compiler/shared.compiler.ts +++ b/packages/plugins/dialects/src/compiler/shared.compiler.ts @@ -1,9 +1,9 @@ import { Enum, + enums, isNumber, getIsoWeek, -} from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +} from '@magmacomputing/tempo/plugin/sdk'; export type FormatterFn = (zdt: Temporal.ZonedDateTime) => string; diff --git a/packages/plugins/dialects/src/compiler/sheet.compiler.ts b/packages/plugins/dialects/src/compiler/sheet.compiler.ts index d8e1a383..c323a162 100644 --- a/packages/plugins/dialects/src/compiler/sheet.compiler.ts +++ b/packages/plugins/dialects/src/compiler/sheet.compiler.ts @@ -1,5 +1,4 @@ -import { pad, WeakCache, Enum, resolveTwoDigitYear, resolveFractionalSeconds } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { pad, WeakCache, Enum, enums, resolveTwoDigitYear, resolveFractionalSeconds, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import type { FormatterFn, DialectOptions } from './shared.compiler.js'; import { escapeRegex, @@ -26,7 +25,7 @@ export const SHEET_TOKENS = [ '[h]', '[m]', '[s]', ] as const; -export type SheetSpecifier = (typeof SHEET_TOKENS)[number]; +export type SheetSpecifier = ValueOf const RE_SHEET_TOKEN = /"([^"]*)"|\\(.)|_[^\s]|[*][^\s]|\[(?:red|green|blue|yellow|magenta|cyan|white|black)\]|(\[(?:h+|m+|s+)\]|\.000|\.00|\.0|am\/pm|a\/p|yyyy|yy|mmmmm|mmmm|mmm|mm|m|dddd|ddd|dd|d|hh|h|ss|s)/gi; diff --git a/packages/plugins/dialects/src/compiler/strftime.compiler.ts b/packages/plugins/dialects/src/compiler/strftime.compiler.ts index 79afacbb..b0b06391 100644 --- a/packages/plugins/dialects/src/compiler/strftime.compiler.ts +++ b/packages/plugins/dialects/src/compiler/strftime.compiler.ts @@ -1,5 +1,4 @@ -import { pad, WeakCache, Enum, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear, getIsoWeek, fromIsoWeek } from '@magmacomputing/tempo/library'; -import { enums } from '@magmacomputing/tempo/support'; +import { pad, WeakCache, Enum, enums, resolveTwoDigitYear, resolveFractionalSeconds, resolveDayOfYear, getIsoWeek, fromIsoWeek, ValueOf } from '@magmacomputing/tempo/plugin/sdk'; import { type FormatterFn, type DialectOptions, @@ -30,7 +29,7 @@ export const STRFTIME_SPECIFIERS = [ 'F', 'T', 'R', 's', ] as const; -export type StrftimeSpecifier = (typeof STRFTIME_SPECIFIERS)[number]; +export type StrftimeSpecifier = ValueOf const STRFTIME_SPECIFIER_REGEX = /%(-)?(\d+)?([a-zA-Z%])/g; diff --git a/packages/plugins/dialects/src/engine/explain.ts b/packages/plugins/dialects/src/engine/explain.ts index 4afa5e83..93d0a00f 100644 --- a/packages/plugins/dialects/src/engine/explain.ts +++ b/packages/plugins/dialects/src/engine/explain.ts @@ -86,9 +86,9 @@ const LDML_EXPLAIN_MAP: Readonly> = { @@ -121,7 +121,7 @@ const STRFTIME_EXPLAIN_MAP: Readonly> = { @@ -348,12 +348,12 @@ const GO_EXPLAIN_MAP: Readonly> = { 'tz:short': { ldml: 'z', strftime: '%Z', oracle: 'TZD', moment: 'zz', php: 'T', go: 'MST', desc: 'Time zone daylight / short abbreviation' }, 'tz:offset': { ldml: 'ZZZZZ', oracle: 'TZH:TZM', moment: 'Z', php: 'P', go: '-07:00', dotnet: 'zzz', desc: 'ISO-8601 time zone offset (e.g. +08:00)' }, 'tz:longoffset': { ldml: 'ZZZZ', desc: 'Long localized GMT offset (e.g. GMT+08:00)' }, - 'tz:offsetcompact': { ldml: 'ZZ', strftime: '%z', oracle: 'TZHTZM', moment: 'ZZ', php: 'O', go: '-0700', desc: 'Compact time zone offset (e.g. +0800)' }, + 'tz:offset:compact': { ldml: 'ZZ', strftime: '%z', oracle: 'TZHTZM', moment: 'ZZ', php: 'O', go: '-0700', desc: 'Compact time zone offset (e.g. +0800)' }, 'tz:offset:hh': { oracle: 'TZH', go: '-07', dotnet: 'zz', desc: 'Time zone offset hours with sign (e.g. +08, -05)' }, 'tz:offset:mi': { oracle: 'TZM', desc: 'Time zone offset minutes without sign (e.g. 00, 30)' }, 'tz:offset:ss': { go: '-07:00:00', desc: 'ISO-8601 time zone offset with seconds (e.g. +08:00:00)' }, - 'tz:offsetcompact:ss': { go: '-070000', desc: 'Compact time zone offset with seconds (e.g. +080000)' }, + 'tz:offset:compact:ss': { go: '-070000', desc: 'Compact time zone offset with seconds (e.g. +080000)' }, 'tz:offset:utc': { go: 'Z07:00', dotnet: 'K', desc: 'UTC Z or ISO-8601 offset' }, 'tz:offset:short:utc': { go: 'Z07', desc: 'UTC Z or hour-only numeric offset' }, - 'tz:offsetcompact:utc': { go: 'Z0700', desc: 'UTC Z or compact offset' }, + 'tz:offset:compact:utc': { go: 'Z0700', desc: 'UTC Z or compact offset' }, 'tz:offset:ss:utc': { go: 'Z07:00:00', desc: 'UTC Z or ISO-8601 offset with seconds' }, - 'tz:offsetcompact:ss:utc': { go: 'Z070000', desc: 'UTC Z or compact offset with seconds' }, + 'tz:offset:compact:ss:utc': { go: 'Z070000', desc: 'UTC Z or compact offset with seconds' }, 'tz:offset:z': { go: 'Z07:00', desc: 'UTC Z or ISO-8601 offset' }, // @internal alias for :utc 'tz:offset:short:z': { go: 'Z07', desc: 'UTC Z or hour-only numeric offset' }, - 'tz:offsetcompact:z': { go: 'Z0700', desc: 'UTC Z or compact offset' }, + 'tz:offset:compact:z': { go: 'Z0700', desc: 'UTC Z or compact offset' }, 'tz:offset:ss:z': { go: 'Z07:00:00', desc: 'UTC Z or ISO-8601 offset with seconds' }, - 'tz:offsetcompact:ss:z': { go: 'Z070000', desc: 'UTC Z or compact offset with seconds' }, + 'tz:offset:compact:ss:z': { go: 'Z070000', desc: 'UTC Z or compact offset with seconds' }, // Specialized & Scoped Tokens jj: { oracle: 'J', desc: 'Astronomical Julian day number' }, @@ -196,23 +196,30 @@ const V4_EXPORT_ALIASES: Readonly> = { 'ff:6': 'ff', 'tz:name': 'tz', 'tz:long': 'tz', - 'tz:offset:basic': 'tz:offsetcompact', + 'tz:offset:basic': 'tz:offset:compact', + 'tz:offsetcompact': 'tz:offset:compact', 'tz:offset:hour': 'tz:offset:hh', 'tz:offset:min': 'tz:offset:mi', 'tz:offset:sec': 'tz:offset:ss', 'tz:offset:second': 'tz:offset:ss', - 'tz:offset:compact': 'tz:offsetcompact', - 'tz:offset:compact:ss': 'tz:offsetcompact:ss', - 'tz:offset:compact:sec': 'tz:offsetcompact:ss', - 'tz:offsetcompact:sec': 'tz:offsetcompact:ss', - 'tz:offset:compact:utc': 'tz:offsetcompact:utc', - 'tz:offset:compact:ss:utc': 'tz:offsetcompact:ss:utc', + 'tz:offset:ss:compact': 'tz:offset:compact:ss', + 'tz:offset:compact:sec': 'tz:offset:compact:ss', + 'tz:offsetcompact:ss': 'tz:offset:compact:ss', + 'tz:offsetcompact:sec': 'tz:offset:compact:ss', + 'tz:offset:utc:compact': 'tz:offset:compact:utc', + 'tz:offsetcompact:utc': 'tz:offset:compact:utc', + 'tz:offset:ss:utc:compact': 'tz:offset:compact:ss:utc', + 'tz:offset:compact:ss:utc': 'tz:offset:compact:ss:utc', 'tz:offset:sec:utc': 'tz:offset:ss:utc', - 'tz:offsetcompact:sec:utc': 'tz:offsetcompact:ss:utc', - 'tz:offset:compact:z': 'tz:offsetcompact:z', - 'tz:offset:compact:ss:z': 'tz:offsetcompact:ss:z', + 'tz:offsetcompact:ss:utc': 'tz:offset:compact:ss:utc', + 'tz:offsetcompact:sec:utc': 'tz:offset:compact:ss:utc', + 'tz:offset:z:compact': 'tz:offset:compact:z', + 'tz:offsetcompact:z': 'tz:offset:compact:z', + 'tz:offset:ss:z:compact': 'tz:offset:compact:ss:z', + 'tz:offset:compact:ss:z': 'tz:offset:compact:ss:z', 'tz:offset:sec:z': 'tz:offset:ss:z', - 'tz:offsetcompact:sec:z': 'tz:offsetcompact:ss:z', + 'tz:offsetcompact:ss:z': 'tz:offset:compact:ss:z', + 'tz:offsetcompact:sec:z': 'tz:offset:compact:ss:z', }; const RE_SINGLE_QUOTE = /'/g; diff --git a/packages/plugins/dialects/src/index.ts b/packages/plugins/dialects/src/index.ts index bc0cdd84..ec60b038 100644 --- a/packages/plugins/dialects/src/index.ts +++ b/packages/plugins/dialects/src/index.ts @@ -1,6 +1,5 @@ -import { definePlugin, deepFreeze, hasOwn, type TempoPlugin } from '@magmacomputing/tempo/plugin/sdk'; +import { definePlugin, deepFreeze, hasOwn, isFunction, isObject, type TempoPlugin } from '@magmacomputing/tempo/plugin/sdk'; import { getRuntime } from '@magmacomputing/tempo/support'; -import { isNull, isFunction, isObject } from '@magmacomputing/tempo/library'; import type { Tempo } from '@magmacomputing/tempo/core'; import { DIALECT, DIALECT_ALIAS, normalizeDialect, type Dialect, type DialectAlias } from './constants.js'; diff --git a/packages/plugins/dialects/test/explain.test.ts b/packages/plugins/dialects/test/explain.test.ts index 68fc067d..edc5825d 100644 --- a/packages/plugins/dialects/test/explain.test.ts +++ b/packages/plugins/dialects/test/explain.test.ts @@ -153,15 +153,15 @@ describe('Dialect Explain & Migration Helper', () => { expect(daySpace?.tempo).toBe('{dd:space}'); const z0700 = tokens.find(t => t.source === 'Z0700'); - expect(z0700?.tempo).toBe('{tz:offsetcompact:utc}'); + expect(z0700?.tempo).toBe('{tz:offset:compact:utc}'); expect(z0700?.desc).toContain('UTC Z or basic numeric offset'); const z070000 = tokens.find(t => t.source === 'Z070000'); - expect(z070000?.tempo).toBe('{tz:offsetcompact:ss:utc}'); + expect(z070000?.tempo).toBe('{tz:offset:compact:ss:utc}'); expect(z070000?.desc).toContain('offset with seconds'); const m070000 = tokens.find(t => t.source === '-070000'); - expect(m070000?.tempo).toBe('{tz:offsetcompact:ss}'); + expect(m070000?.tempo).toBe('{tz:offset:compact:ss}'); expect(m070000?.desc).toContain('offset with seconds'); const m07 = tokens.find(t => t.source === '-07'); diff --git a/packages/plugins/dialects/test/export.test.ts b/packages/plugins/dialects/test/export.test.ts index 06ebfa2b..9bcf8c76 100644 --- a/packages/plugins/dialects/test/export.test.ts +++ b/packages/plugins/dialects/test/export.test.ts @@ -202,8 +202,8 @@ describe('Dialect Export', () => { expect(resPhpUnpaddedIso.unsupported).toContain('{woy:raw}'); // .NET unsupported compact offset - const resDotNetOffsetCompact = Tempo.dialects.export('{tz:offsetcompact}', 'dotnet'); - expect(resDotNetOffsetCompact.unsupported).toContain('{tz:offsetcompact}'); + const resDotNetOffsetCompact = Tempo.dialects.export('{tz:offset:compact}', 'dotnet'); + expect(resDotNetOffsetCompact.unsupported).toContain('{tz:offset:compact}'); }); it('works seamlessly from instance namespace t.dialects.export', () => { @@ -226,17 +226,17 @@ describe('Dialect Export', () => { // Also verify alias tz:offset:min expect(Tempo.dialects.export('{tz:offset:min}', 'oracle').pattern).toBe('TZM'); - const resGo = Tempo.dialects.export('{tz:offset:utc} {tz:offsetcompact:utc} {tz:offset:ss:utc} {tz:offsetcompact:ss:utc} {tz:offset:ss} {tz:offsetcompact:ss} {tz:offset:hh}', 'go'); + const resGo = Tempo.dialects.export('{tz:offset:utc} {tz:offset:compact:utc} {tz:offset:ss:utc} {tz:offset:compact:ss:utc} {tz:offset:ss} {tz:offset:compact:ss} {tz:offset:hh}', 'go'); expect(resGo.pattern).toBe('Z07:00 Z0700 Z07:00:00 Z070000 -07:00:00 -070000 -07'); expect(resGo.unsupported).toHaveLength(0); // Also verify alias :z - const resGoAlias = Tempo.dialects.export('{tz:offset:z} {tz:offsetcompact:z} {tz:offset:ss:z} {tz:offsetcompact:ss:z}', 'go'); + const resGoAlias = Tempo.dialects.export('{tz:offset:z} {tz:offset:compact:z} {tz:offset:ss:z} {tz:offset:compact:ss:z}', 'go'); expect(resGoAlias.pattern).toBe('Z07:00 Z0700 Z07:00:00 Z070000'); expect(resGoAlias.unsupported).toHaveLength(0); // Also verify aliases :sec - expect(Tempo.dialects.export('{tz:offset:sec:utc} {tz:offset:sec:z} {tz:offsetcompact:sec}', 'go').pattern).toBe('Z07:00:00 Z07:00:00 -070000'); + expect(Tempo.dialects.export('{tz:offset:sec:utc} {tz:offset:sec:z} {tz:offset:compact:sec}', 'go').pattern).toBe('Z07:00:00 Z07:00:00 -070000'); }); it('exports Phase 4 specialized and scoped tokens to target dialects', () => { diff --git a/packages/plugins/holidays/doc/business-days.md b/packages/plugins/holidays/doc/business-days.md index fe4c8175..c6d93756 100644 --- a/packages/plugins/holidays/doc/business-days.md +++ b/packages/plugins/holidays/doc/business-days.md @@ -13,7 +13,7 @@ The **Regional Holidays Plugin** extends Tempo with robust business day operatio ## Determining Working Business Days A date is considered a **business day** if: -1. It does not fall on a weekend day (according to the cultural locale weekend definition in `tempo.intl.weekend`, defaulting to Saturday/Sunday). +1. It does not fall on a weekend day (according to the cultural locale weekend definition in `tempo.intl.info.weekend`, defaulting to Saturday/Sunday). 2. It does not fall on a recognized public holiday in the active country/region. 3. It does not match any date in `options.customHolidays`. @@ -136,7 +136,7 @@ const hours = opened.holidays.workingHoursUntil(resolved, { Different countries have different working weeks. For example, in Saudi Arabia (`ar-SA`) and other Middle Eastern jurisdictions, the weekend is Friday and Saturday, and Sunday is a working business day. -Tempo automatically respects the active locale's weekend definition via `tempo.intl.weekend`: +Tempo automatically respects the active locale's weekend definition via `tempo.intl.info.weekend`: ```typescript // Saudi Arabia (ar-SA) diff --git a/packages/plugins/holidays/doc/index.md b/packages/plugins/holidays/doc/index.md index 22e4caad..692c2f32 100644 --- a/packages/plugins/holidays/doc/index.md +++ b/packages/plugins/holidays/doc/index.md @@ -13,7 +13,7 @@ The **Regional Holidays Plugin** provides bank holiday resolution, weekend obser ## Key Features - **Zero-Latency Built-in Calendars**: Instant synchronous holiday calculation for US, Australia, United Kingdom, Canada, Germany, France, Japan, and New Zealand. -- **`t.geo.country` Resolution Cascade**: Automatically resolves national calendars via explicit option, `tempo.geo.country`, `tempo.intl.region`, or BCP-47 `tempo.locale`. +- **`t.geo.country` Resolution Cascade**: Automatically resolves national calendars via explicit option, `tempo.geo.country`, `tempo.intl.info.region`, or BCP-47 `tempo.locale`. - **Global Long-Tail Coverage (100+ Countries)**: Dynamic async preloading via `@magmacomputing/tempo-fns` with automatic 24-hour TTL caching in runtime storage. - **SLA Working Hours Calculation**: `t.holidays.workingHoursUntil(deadline)` calculates business hours between dates, taking into account working hour windows, weekends, and regional holidays. - **Cultural Weekend Awareness**: Automatically respects cultural workweeks (e.g. Friday/Saturday weekend in Middle Eastern locales like `ar-SA`). diff --git a/packages/plugins/holidays/doc/regional-calendars.md b/packages/plugins/holidays/doc/regional-calendars.md index 1c081775..be0beef3 100644 --- a/packages/plugins/holidays/doc/regional-calendars.md +++ b/packages/plugins/holidays/doc/regional-calendars.md @@ -33,7 +33,7 @@ When evaluating a holiday or business day, Tempo resolves the effective country 1. **Explicit Option**: `t.holidays.isHoliday({ country: 'GB', region: 'SCT' })` 2. **Instance Geolocation**: `t.geo.country` (and `t.geo.region` / `t.geo.state`) -3. **Instance Internationalization**: `tempo.intl.region` +3. **Instance Internationalization**: `tempo.intl.info.region` 4. **Instance Locale**: BCP-47 tag (e.g. `en-AU` → `'AU'`, `fr-CA` → `'CA'`, `ja-JP` → `'JP'`) 5. **Default Fallback**: `'US'` diff --git a/packages/plugins/holidays/test/holidays.test.ts b/packages/plugins/holidays/test/holidays.test.ts index a7f7aed6..483ef8b8 100644 --- a/packages/plugins/holidays/test/holidays.test.ts +++ b/packages/plugins/holidays/test/holidays.test.ts @@ -271,7 +271,7 @@ describe('@magmacomputing/tempo-plugin-holidays', () => { expect(regularDay.holidays.isHoliday({ customHolidays: ['2026-05-13'] })).toBe(true); }); - it('respects cultural locale weekend days via tempo.intl.weekend', () => { + it('respects cultural locale weekend days via tempo.intl.info.weekend', () => { // In Saudi Arabia (ar-SA), weekend is Friday (5) and Saturday (6); Sunday (7) is a business day // 2026-05-15 is Friday (dow = 5) // 2026-05-17 is Sunday (dow = 7) diff --git a/packages/plugins/ntp/src/engine.ts b/packages/plugins/ntp/src/engine.ts index 61125609..a1da5917 100644 --- a/packages/plugins/ntp/src/engine.ts +++ b/packages/plugins/ntp/src/engine.ts @@ -1,5 +1,5 @@ -import { isFunction, Finalizer } from '@magmacomputing/tempo/plugin/sdk'; -import type { ClockDriftState, NtpSyncOptions } from './types.js'; +import { isFunction, Finalizer, Signify } from '@magmacomputing/tempo/plugin/sdk'; +import type { ClockDriftState, NtpSyncOptions, NtpSignalsNamespace } from './types.js'; const RE_SERVER_TIMING = /(?:clock|server_time|epoch)=(\d+(?:\.\d+)?)/i; @@ -23,6 +23,15 @@ export class ClockDriftEngine { #isSyncing = false; #baselineNtpMs = 0; #baselinePerfNow = 0; + #offsetSignal: Signify.State = new Signify.State(0); + #isCalibratedSignal: Signify.State = new Signify.State(false); + #driftSignal: Signify.State = new Signify.State({ + offsetMs: 0, + uncertaintyMs: 0, + lastSyncedAt: 0, + sampleCount: 0, + }); + #cachedSignalsNamespace?: NtpSignalsNamespace; constructor(options: NtpSyncOptions = {}) { this.#options = { @@ -60,6 +69,17 @@ export class ClockDriftEngine { return this.#state.sampleCount > 0; } + /** + * Returns the reactive signals namespace for drift, offset, and calibration state. + */ + get signals(): NtpSignalsNamespace { + return this.#cachedSignalsNamespace ??= Object.freeze({ + offset: Signify.computed(() => this.#offsetSignal.get()), + isCalibrated: Signify.computed(() => this.#isCalibratedSignal.get()), + drift: Signify.computed(() => this.#driftSignal.get()), + }); + } + /** * Calculates the current calibrated epoch time in milliseconds. */ @@ -81,6 +101,9 @@ export class ClockDriftEngine { lastSyncedAt: 0, sampleCount: 0, }; + this.#offsetSignal.set(0); + this.#isCalibratedSignal.set(false); + this.#driftSignal.set(this.drift); } /** @@ -189,6 +212,9 @@ export class ClockDriftEngine { this.#baselineNtpMs = (localBefore + rttMs) + finalOffset; this.#baselinePerfNow = isFunction(globalThis.performance?.now) ? performance.now() : 0; + this.#offsetSignal.set(this.#state.offsetMs); + this.#isCalibratedSignal.set(true); + this.#driftSignal.set(this.drift); } /** diff --git a/packages/plugins/ntp/src/index.ts b/packages/plugins/ntp/src/index.ts index a78a05d0..e286c30b 100644 --- a/packages/plugins/ntp/src/index.ts +++ b/packages/plugins/ntp/src/index.ts @@ -1,10 +1,10 @@ -import { definePlugin, type TempoPlugin, deepFreeze, isString, isNumber, isObject, isFunction } from '@magmacomputing/tempo/plugin/sdk'; +import { definePlugin, type TempoPlugin, deepFreeze, isString, isNumber, isObject, isFunction, Finalizer, Signify, type ReadonlySignal } from '@magmacomputing/tempo/plugin/sdk'; import type { Tempo } from '@magmacomputing/tempo'; import { ClockDriftEngine } from './engine.js'; -import type { ClockDriftState, NtpNamespace, NtpSyncOptions, NtpOriginMatcher, NtpFetchFilter } from './types.js'; +import type { ClockDriftState, NtpNamespace, NtpSyncOptions, NtpOriginMatcher, NtpFetchFilter, NtpSignalsNamespace } from './types.js'; export { ClockDriftEngine }; -export type { ClockDriftState, NtpNamespace, NtpSyncOptions, NtpOriginMatcher, NtpFetchFilter }; +export type { ClockDriftState, NtpNamespace, NtpSyncOptions, NtpOriginMatcher, NtpFetchFilter, NtpSignalsNamespace }; declare module '@magmacomputing/tempo' { namespace Tempo { @@ -189,6 +189,75 @@ export const NtpPlugin: TempoPlugin = definePlugin({ get isCalibrated(): boolean { return getEngine().isCalibrated; }, + get signals(): NtpSignalsNamespace { + return getEngine().signals; + }, + signal(options?: { interval?: number | string; timeZone?: string }): ReadonlySignal & Disposable { + const interval = options?.interval ?? 1; + const timeZone = options?.timeZone; + const tzOpt = isString(timeZone) ? { timeZone } : timeZone; + const getCurrent = () => new TempoClass(getEngine().nowMs(), tzOpt); + const state = new Signify.State(getCurrent()); + + let disposeCadence: () => void; + if (isFunction((TempoClass as any).ticker?.signal)) { + const tickerInterval = isString(interval) ? (parseIntervalMs(interval) / 1000 || 1) : interval; + const tickerSig = (TempoClass as any).ticker.signal({ + interval: tickerInterval, + timeZone, + }); + const subEffect = Signify.effect(() => { + tickerSig(); + state.set(getCurrent()); + }); + disposeCadence = () => { + subEffect.dispose(); + tickerSig.dispose?.(); + }; + } else { + const intervalMs = isNumber(interval) ? interval * 1000 : (parseIntervalMs(interval) || 1000); + const timer = setInterval(() => { + state.set(getCurrent()); + }, intervalMs); + disposeCadence = () => { + clearInterval(timer); + }; + } + + // Rebase signal immediately whenever NTP calibration or offset updates + const calibrationWatch = Signify.effect(() => { + getEngine().signals.offset(); + getEngine().signals.isCalibrated(); + state.set(getCurrent()); + }); + + const dispose = () => { + calibrationWatch.dispose(); + disposeCadence(); + }; + const accessor = function (this: any) { + return state.get(); + }; + const proxy = new Proxy(accessor as any, { + get(_, prop) { + if (prop === 'dispose' || prop === Symbol.dispose) return dispose; + if (prop === 'get') return () => state.get(); + if (prop === 'value') return state.get(); + if (prop === 'epoch') return state.epoch; + if (prop === 'addConsumer') return (c: any) => state.addConsumer(c); + if (prop === 'removeConsumer') return (c: any) => state.removeConsumer(c); + if (prop === 'poll') return () => state.poll(); + return (state as any)[prop]; + }, + apply(_, thisArg, argArray) { + return state.get(); + } + }); + Finalizer.register(proxy, () => { + dispose(); + }); + return proxy; + }, reset(): void { getEngine().reset(); }, diff --git a/packages/plugins/ntp/src/types.ts b/packages/plugins/ntp/src/types.ts index 4b646d5e..8fea8a02 100644 --- a/packages/plugins/ntp/src/types.ts +++ b/packages/plugins/ntp/src/types.ts @@ -1,4 +1,5 @@ import type { Tempo } from '@magmacomputing/tempo'; +import type { ReadonlySignal } from '@magmacomputing/tempo/library'; /** * Origin, URL prefix, regex, or predicate function used to filter passive fetch requests. @@ -146,4 +147,30 @@ export interface NtpNamespace { * Explicit deterministic disposal (Dual-Layer Lifecycle Model). */ [Symbol.dispose](): void; + + /** + * Reactive signals namespace for clock drift offset, calibration status, and telemetry. + */ + readonly signals: NtpSignalsNamespace; + + /** + * Spawns an auto-ticking ReadonlySignal calibrated to network time. + * Supports explicit disposal via `using clock = Tempo.ntp.signal(...)`. + */ + signal(options?: { interval?: number | string; timeZone?: string }): ReadonlySignal & Disposable; +} + +/** + * ## NtpSignalsNamespace + * Fine-grained reactive TC39 signals namespace for NTP telemetry and calibrated offset. + */ +export interface NtpSignalsNamespace { + /** Reactive signal containing the current clock drift offset in milliseconds */ + readonly offset: ReadonlySignal; + + /** Reactive signal indicating whether clock synchronization has completed at least one valid calibration */ + readonly isCalibrated: ReadonlySignal; + + /** Reactive signal emitting the complete ClockDriftState snapshot (RTT, jitter, confidence) */ + readonly drift: ReadonlySignal; } diff --git a/packages/plugins/ntp/test/ntp.signals.test.ts b/packages/plugins/ntp/test/ntp.signals.test.ts new file mode 100644 index 00000000..b5707f45 --- /dev/null +++ b/packages/plugins/ntp/test/ntp.signals.test.ts @@ -0,0 +1,140 @@ +import { Tempo } from '@magmacomputing/tempo'; +import { Signify } from '@magmacomputing/tempo/library'; +import { NtpPlugin, ClockDriftEngine } from '../src/index.js'; +import { TickerPlugin } from '../../ticker/src/index.js'; + +Tempo.use(NtpPlugin); +Tempo.use(TickerPlugin); + +describe('NTP Plugin Signify Reactivity', () => { + let originalFetch: typeof globalThis.fetch; + + beforeEach(() => { + originalFetch = globalThis.fetch; + Tempo.init(); + if (Tempo.ntp) { + Tempo.ntp.reset(); + } + }); + + afterEach(() => { + globalThis.fetch = originalFetch; + if (Tempo.ntp) { + Tempo.ntp.reset(); + } + }); + + test('Tempo.ntp.signals exposes fine-grained TC39 signals', () => { + const signals = Tempo.ntp.signals; + expect(signals).toBeDefined(); + + expect(typeof signals.offset).toBe('function'); + expect(signals.offset.value).toBe(0); + expect(signals.offset.get()).toBe(0); + + expect(typeof signals.isCalibrated).toBe('function'); + expect(signals.isCalibrated.value).toBe(false); + + expect(typeof signals.drift).toBe('function'); + expect(signals.drift.value.sampleCount).toBe(0); + }); + + test('ingesting samples updates signals and triggers Signify.computed / Signify.effect', async () => { + const engine = new ClockDriftEngine({ maxAcceptableRttMs: 1000 }); + const signals = engine.signals; + + const observedOffsets: number[] = []; + const sub = Signify.effect(() => { + observedOffsets.push(signals.offset.value); + }); + + expect(observedOffsets).toEqual([0]); + + // Ingest single sample: offset = 1550 - (1000 + 50) = +500 + engine.ingestSample(1550, 100, 1000); + + expect(signals.offset.value).toBe(500); + expect(signals.isCalibrated.value).toBe(true); + expect(signals.drift.value.sampleCount).toBe(1); + + // Allow effect microtask to flush + await new Promise(r => queueMicrotask(() => r())); + + // Signify effect re-evaluated + expect(observedOffsets).toContain(500); + + // Test reset() restores reactive signals + engine.reset(); + expect(signals.offset.value).toBe(0); + expect(signals.isCalibrated.value).toBe(false); + + sub.dispose(); + }); + + test('computed wall clock derives calibrated time from Tempo.ntp.signals.offset', () => { + const engine = new ClockDriftEngine(); + const offsetSig = engine.signals.offset; + + const localTimeMs = 1_000_000; + const calibratedTime = Signify.computed(() => localTimeMs + offsetSig.value); + + expect(calibratedTime.value).toBe(1_000_000); + + engine.ingestSample(1_000_250, 100, localTimeMs); + // measuredOffset = 1_000_250 - (1_000_000 + 50) = 200 + expect(engine.offset).toBe(200); + expect(calibratedTime.value).toBe(1_000_200); + }); + + test('Tempo.ntp.signal() returns ticking calibrated ReadonlySignal with auto-disposal', async () => { + const ntpClock = Tempo.ntp.signal({ interval: 0.05 }); + + expect(ntpClock.value).toBeInstanceOf(Tempo); + const initialMs = ntpClock.value.epoch.ms; + + await new Promise(r => setTimeout(r, 120)); + expect(ntpClock.value.epoch.ms).toBeGreaterThan(initialMs); + + ntpClock[Symbol.dispose](); + + const stoppedMs = ntpClock.value.epoch.ms; + await new Promise(r => setTimeout(r, 120)); + expect(ntpClock.value.epoch.ms).toBe(stoppedMs); + }); + + test('Tempo.ntp.signal() rebases timestamp immediately when calibration changes mid-flight', async () => { + const clock = Tempo.ntp.signal({ interval: 10 }); + const beforeSyncMs = clock.value.epoch.ms; + + const mockServerMs = Date.now() + 50000; + globalThis.fetch = vi.fn().mockImplementation(async () => { + return { + status: 200, + headers: new Headers({ + 'Server-Timing': `clock=${mockServerMs}`, + }), + } as any; + }); + + await Tempo.ntp.sync('/api/mock-time'); + expect(Tempo.ntp.isCalibrated).toBe(true); + + // Allow microtask to process reactive effect + await new Promise(r => queueMicrotask(() => r())); + + // Clock signal must immediately reflect calibrated offset (~50s ahead) without waiting for 10s tick + expect(clock.value.epoch.ms).toBeGreaterThanOrEqual(beforeSyncMs + 45000); + + clock[Symbol.dispose](); + }); + + test('cross-plugin synergy: Tempo.ticker({ ntp: true }).signal reflects NTP calibrated state', () => { + const ticker = Tempo.ticker({ seconds: 1, ntp: true }); + const sig = ticker.signal; + + expect(sig.value).toBeInstanceOf(Tempo); + expect(sig.get()).toBeInstanceOf(Tempo); + + ticker.stop(); + }); +}); diff --git a/packages/plugins/ticker/doc/reactive-clocks-and-events.md b/packages/plugins/ticker/doc/reactive-clocks-and-events.md index 3e62d8a9..f507c2d9 100644 --- a/packages/plugins/ticker/doc/reactive-clocks-and-events.md +++ b/packages/plugins/ticker/doc/reactive-clocks-and-events.md @@ -89,26 +89,24 @@ When building multi-timezone clocks or financial dashboards, **never instantiate Instead, use a single **Master Ticker** to drive all derivative clocks. -### A. Reactive UI Signals (Preact, Solid, Vue) +### A. Reactive TC39 Signals (Signify, Vue, Solid, Preact, Svelte 5) + +With Tempo v5 and `Signify`, tickers natively expose fine-grained TC39 `ReadonlySignal` without requiring third-party signal libraries: ```typescript -import { signal, computed } from '@preact/signals-core'; import { Tempo } from '@magmacomputing/tempo'; +import { Signify } from '@magmacomputing/tempo/library'; import '@magmacomputing/tempo-plugin-ticker/install'; -// 1. Single Master Source of Truth -const masterTime = signal(new Tempo()); - -// 2. Drive the master clock from a master ticker instance (persisted in app scope) -const masterTicker = Tempo.ticker(1, (t) => { - masterTime.value = t; -}); +// 1. Single Master Source of Truth (via native ticker.signal or Tempo.ticker.signal) +using masterTicker = Tempo.ticker({ seconds: 1 }); +const masterClock = masterTicker.signal; -// 3. Derived multi-timezone views update simultaneously with zero drift -const sydneyTime = computed(() => masterTime.value.set({ timeZone: 'Australia/Sydney' })); -const londonTime = computed(() => masterTime.value.set({ timeZone: 'Europe/London' })); -const nyTime = computed(() => masterTime.value.set({ timeZone: 'America/New_York' })); -const tokyoTime = computed(() => masterTime.value.set({ timeZone: 'Asia/Tokyo' })); +// 2. Derived multi-timezone views update simultaneously with zero drift +const sydneyTime = Signify.computed(() => masterClock.value.set({ timeZone: 'Australia/Sydney' })); +const londonTime = Signify.computed(() => masterClock.value.set({ timeZone: 'Europe/London' })); +const nyTime = Signify.computed(() => masterClock.value.set({ timeZone: 'America/New_York' })); +const tokyoTime = Signify.computed(() => masterClock.value.set({ timeZone: 'Asia/Tokyo' })); // Sydney, London, New York, and Tokyo will tick on the exact same millisecond ``` diff --git a/packages/plugins/ticker/src/index.ts b/packages/plugins/ticker/src/index.ts index 7dd31b38..42929132 100644 --- a/packages/plugins/ticker/src/index.ts +++ b/packages/plugins/ticker/src/index.ts @@ -5,6 +5,7 @@ import { instant, normaliseFractionalDurations, isRRuleString, getNextRRuleEpoch, isCronString, getNextCronEpoch, isUndefined, Finalizer, Reactive, cast, logError, hasKey, + type ReadonlySignal, } from '@magmacomputing/tempo/plugin/sdk'; export { isCronString }; @@ -28,6 +29,14 @@ declare module '@magmacomputing/tempo' { function ticker(interval: Ticker.Interval, options: Ticker.Options): Ticker.Instance; function ticker(options: Ticker.Options, callback: Ticker.Callback): Ticker.Instance; function ticker(options: Ticker.Options, extraOptions: Ticker.Options): Ticker.Instance; + + namespace ticker { + /** + * Spawns an auto-ticking ReadonlySignal ticking at the specified interval. + * Supports explicit disposal via `using clock = Tempo.ticker.signal(...)`. + */ + function signal(interval?: number | string | Ticker.Options): ReadonlySignal & Disposable; + } } } @@ -100,6 +109,9 @@ export namespace Ticker { until(notifier: AbortSignal | Promise | Reactive): Reactive; on(event: 'pulse' | 'catch' | 'stop', cb: (t: Tempo, stop: () => void) => void): this; stop(terminalValue?: Tempo): void; + readonly signal: ReadonlySignal; + toSignal(): ReadonlySignal; + toSignal(initialValue: D): ReadonlySignal; readonly info: { label: string | undefined; next: Tempo; @@ -153,6 +165,7 @@ class TickerInstance implements Ticker.Descriptor { #options: any; #selfRef!: WeakRef; #activeEntry: ActiveTickerEntry | undefined = undefined; + #cachedSignal: WeakRef> | undefined = undefined; constructor(TempoClass: typeof Tempo, arg1: any, arg2?: any) { this.#TempoClass = TempoClass; @@ -481,6 +494,50 @@ class TickerInstance implements Ticker.Descriptor { return stream; } + toSignal(): ReadonlySignal; + toSignal(initialValue: D): ReadonlySignal; + toSignal(...args: [D?]): ReadonlySignal { + const initial = args.length > 0 ? args[0]! : (this.#next as any); + const sig = this.#reactive.toSignal(initial); + this.#runBootstrap(); + + const tickerProxy = this.#selfRef?.deref(); + const dispose = () => { + sig.dispose?.(); + }; + + const accessor = function (this: any) { + return sig(); + }; + + const wrapper = new Proxy(accessor as any, { + get(_, prop) { + if (prop === 'dispose' || prop === Symbol.dispose) return dispose; + if (prop === 'get') return () => sig.get(); + if (prop === Symbol.for('Tempo.ticker.instance')) return tickerProxy; + return (sig as any)[prop]; + }, + apply(_, thisArg, argArray) { + if (tickerProxy) { /* retain reference in closure */ } + return (sig as any).apply(thisArg, argArray); + } + }); + + Finalizer.register(wrapper, () => { + sig.dispose?.(); + }); + + return wrapper; + } + + get signal(): ReadonlySignal { + const cached = this.#cachedSignal?.deref(); + if (cached) return cached; + const sig = this.toSignal(); + this.#cachedSignal = new WeakRef(sig); + return sig; + } + async next(): Promise> { if (this.#stopped || this.#isInstant) return { done: true, value: undefined }; @@ -554,6 +611,8 @@ function createTicker(TempoClass: typeof Tempo, arg1: any, arg2?: any): Ticker.I }; } if (prop === 'stop') return instance.stop.bind(instance); + if (prop === 'signal') return instance.signal; + if (prop === 'toSignal') return instance.toSignal.bind(instance); if (prop === 'next') return instance.next.bind(instance); if (prop === 'return') return instance.return.bind(instance); if (prop === 'throw') return instance.throw.bind(instance); @@ -566,8 +625,9 @@ function createTicker(TempoClass: typeof Tempo, arg1: any, arg2?: any): Ticker.I apply: (target) => target(), }); + const instanceRef = new WeakRef(instance); Finalizer.register(proxy, () => { - instance.stop(); + instanceRef.deref()?.stop(); }); return instance.bootstrap(cast(proxy)); @@ -608,6 +668,33 @@ export const TickerPlugin = definePlugin({ return createTicker(cls, arg1, arg2); }; + tickerFactory.signal = function (interval?: number | string | Ticker.Options): ReadonlySignal & Disposable { + const ticker = tickerFactory(interval); + const sig = ticker.signal; + const dispose = () => { + ticker.stop(); + sig.dispose?.(); + }; + const accessor = function (this: any) { + return sig(); + }; + const proxy = new Proxy(accessor as any, { + get(_, prop) { + if (prop === 'dispose' || prop === Symbol.dispose) return dispose; + if (prop === 'get') return () => sig.get(); + return (sig as any)[prop]; + }, + apply(_, thisArg, argArray) { + return (sig as any).apply(thisArg, argArray); + } + }); + const tickerRef = new WeakRef(ticker); + Finalizer.register(proxy, () => { + tickerRef.deref()?.stop(); + }); + return proxy; + }; + attachStatics(installedClass, { ticker: tickerFactory, tickers: tickersDescriptor, diff --git a/packages/plugins/ticker/test/ticker.signal.test.ts b/packages/plugins/ticker/test/ticker.signal.test.ts new file mode 100644 index 00000000..35a89560 --- /dev/null +++ b/packages/plugins/ticker/test/ticker.signal.test.ts @@ -0,0 +1,116 @@ +import { Tempo } from '@magmacomputing/tempo'; +import { Signify } from '@magmacomputing/tempo/library'; +import { TickerPlugin } from '../src/index.js'; + +Tempo.use(TickerPlugin); + +describe('Ticker Signal & TC39 Signify Reactivity', () => { + beforeEach(() => { + Tempo.init(); + }); + + test('ticker.signal exposes ReadonlySignal initialized to seed Tempo', () => { + const ticker = Tempo.ticker({ seconds: 1 }); + const sig = ticker.signal; + + expect(sig).toBeDefined(); + expect(typeof sig).toBe('function'); + expect(sig.value).toBeInstanceOf(Tempo); + expect(sig.get()).toBeInstanceOf(Tempo); + expect(sig.epoch).toBeGreaterThanOrEqual(0); + + // Cached reference identity + expect(ticker.signal).toBe(sig); + + ticker.stop(); + }); + + test('manual pulse() updates ticker.signal synchronously', () => { + const ticker = Tempo.ticker({ seconds: 1 }); + const sig = ticker.signal; + const initialMs = sig.value.epoch.ms; + const initialEpoch = sig.epoch; + + const pulsed = ticker.pulse(); + expect(sig.value.epoch.ms).toBe(pulsed.epoch.ms); + expect(sig.value.epoch.ms).toBeGreaterThan(initialMs); + expect(sig.epoch).toBeGreaterThan(initialEpoch); + + ticker.stop(); + }); + + test('Signify.computed reacts dynamically to ticker.signal pulses', () => { + const ticker = Tempo.ticker({ seconds: 60 }); + const sig = ticker.signal; + + const formatted = Signify.computed(() => sig.value.format('{yyyy}')); + expect(formatted.value).toBe(sig.value.format('{yyyy}')); + + // Computed tracking epoch changes + const initialFormatted = formatted.value; + expect(initialFormatted).toBeDefined(); + + ticker.stop(); + }); + + test('Signify.effect tracks pulses from ticker.signal', async () => { + const ticker = Tempo.ticker({ seconds: 0.05, limit: 3 }); + const sig = ticker.signal; + const observed: number[] = []; + + const sub = Signify.effect(() => { + observed.push(sig.value.epoch.ms); + }); + + expect(observed.length).toBe(1); // Immediate execution upon registration + + // Wait for pulses to fire + await new Promise(r => setTimeout(r, 200)); + + expect(observed.length).toBeGreaterThanOrEqual(2); + sub.dispose(); + ticker.stop(); + }); + + test('toSignal(fallback) accepts explicit fallback value before first tick', () => { + const ticker = Tempo.ticker({ seed: new Tempo().add({ minutes: 5 }) }); + const fallbackSig = ticker.toSignal('PENDING'); + + expect(fallbackSig.value).toBe('PENDING'); + + const pulsed = ticker.pulse(); + expect(fallbackSig.value).toBe(pulsed); + + ticker.stop(); + }); + + test('Tempo.ticker.signal() static constructor creates auto-disposable signal', async () => { + const clock = Tempo.ticker.signal(0.05); + + expect(clock.value).toBeInstanceOf(Tempo); + const initialMs = clock.value.epoch.ms; + + await new Promise(r => setTimeout(r, 120)); + expect(clock.value.epoch.ms).toBeGreaterThan(initialMs); + + // Explicit disposal + clock[Symbol.dispose](); + + const stoppedMs = clock.value.epoch.ms; + await new Promise(r => setTimeout(r, 120)); + expect(clock.value.epoch.ms).toBe(stoppedMs); + }); + + test('ticker.stop() halts updates while retaining terminal Tempo snapshot', () => { + const ticker = Tempo.ticker({ seconds: 1 }); + const sig = ticker.signal; + + ticker.pulse(); + const lastValue = sig.value; + + ticker.stop(); + + // Reading terminal value remains safe and unchanged + expect(sig.value).toBe(lastValue); + }); +}); diff --git a/packages/tempo/.vitepress/config.ts b/packages/tempo/.vitepress/config.ts index ced2cd14..f4419dab 100644 --- a/packages/tempo/.vitepress/config.ts +++ b/packages/tempo/.vitepress/config.ts @@ -48,6 +48,14 @@ export default withMermaid(defineConfig({ ] } ] + }, + { + text: 'v5.0 (Next)', + items: [ + { text: 'v5.0 (Next / Dev)', link: '/README' }, + { text: 'v4.7.0 (Latest ↗)', link: '/v4/index.html', target: '_self' }, + { text: 'Migration Guide (v4 → v5)', link: '/doc/8-project-and-support/migration-guide' } + ] } ], sidebar: { diff --git a/packages/tempo/.vitepress/theme/data/snippets.manifest.js b/packages/tempo/.vitepress/theme/data/snippets.manifest.js index 38a8606e..853a87f5 100644 --- a/packages/tempo/.vitepress/theme/data/snippets.manifest.js +++ b/packages/tempo/.vitepress/theme/data/snippets.manifest.js @@ -36,14 +36,14 @@ console.log('ISO Day of Week (1..7):', today.dow); const isIsoWeekend = today.dow >= 6; console.log('Is ISO Weekend?', isIsoWeekend); -// 2. Locale-Aware check using t.intl.weekend +// 2. Locale-Aware check using t.intl.info.weekend const us = new Tempo({ locale: 'en-US' }); const sa = new Tempo({ locale: 'ar-SA' }); -console.log('en-US Weekend Days:', JSON.stringify(us.intl.weekend)); // [6, 7] (Saturday, Sunday) -console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.weekend)); // [5, 6] (Friday, Saturday) +console.log('en-US Weekend Days:', JSON.stringify(us.intl.info.weekend)); // [6, 7] (Saturday, Sunday) +console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.info.weekend)); // [5, 6] (Friday, Saturday) -return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.weekend.includes(today.dow)}\`;`, +return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.info.weekend.includes(today.dow)}\`;`, }, quarters: { diff --git a/packages/tempo/doc/1-getting-started/tempo.cookbook.md b/packages/tempo/doc/1-getting-started/tempo.cookbook.md index f3f31d94..572d27db 100644 --- a/packages/tempo/doc/1-getting-started/tempo.cookbook.md +++ b/packages/tempo/doc/1-getting-started/tempo.cookbook.md @@ -178,15 +178,15 @@ const t = new Tempo(); const isWeekend = t.dow >= 6; // Saturday = 6, Sunday = 7 ``` -For international applications, use the locale-aware `t.intl.weekend` array (backed by `Intl.Locale.prototype.getWeekInfo()` and its fallback resolver), which reflects regional weekend days (e.g. `[5, 6]` for Friday & Saturday in Middle Eastern locales like `ar-SA`): +For international applications, use the locale-aware `t.intl.info.weekend` array (backed by `Intl.Locale.prototype.getWeekInfo()` and its fallback resolver), which reflects regional weekend days (e.g. `[5, 6]` for Friday & Saturday in Middle Eastern locales like `ar-SA`): ```typescript // Standard weekend ([6, 7] for Saturday and Sunday in en-US) const us = new Tempo({ locale: 'en-US' }); -const isUsWeekend = us.intl.weekend.includes(us.dow); +const isUsWeekend = us.intl.info.weekend.includes(us.dow); // Regional weekend ([5, 6] for Friday and Saturday in ar-SA) const sa = new Tempo({ locale: 'ar-SA' }); -const isSaWeekend = sa.intl.weekend.includes(sa.dow); +const isSaWeekend = sa.intl.info.weekend.includes(sa.dow); ``` ### What Fiscal Quarter are we in? diff --git a/packages/tempo/doc/2-core-concepts/tempo.format.md b/packages/tempo/doc/2-core-concepts/tempo.format.md index 98af9054..95742065 100644 --- a/packages/tempo/doc/2-core-concepts/tempo.format.md +++ b/packages/tempo/doc/2-core-concepts/tempo.format.md @@ -162,7 +162,7 @@ You can append modifiers to any token using a colon (`:`) to transform its outpu | `:short` | Universal / String | Yields a short or abbreviated style (e.g. `{mon:short}` → `Oct`, `{yow:short}` → `26`, `{dmy:short}` → `241026`) | `{mon:short}` → `Oct`, `{yow:short}` → `26` | | `:long` | String | Yields a full-length style | `{mon:long}` → `October` | | `:compact` | String | Yields a delimiter-free, compact representation | `{tz:offset:compact}` → `+1000` | -| `:offset` | `{tz}` | Converts timezone identifier to numeric UTC offset. Supports granular sub-modifiers (`:hh`, `:mi`, `:ss`, `:z`) | `{tz:offset}` → `+10:00`, `{tz:offset:hh}` → `+10` | +| `:offset` | `{tz}` | Converts timezone identifier to numeric UTC offset. Supports granular sub-modifiers (`:hh`, `:mi`, `:ss`) | `{tz:offset}` → `+10:00`, `{tz:offset:hh}` → `+10` | | `:zero` / `:0` | Number | Shifts 1-based counters to zero-indexed (`{doy:zero}` → `000`–`365`, `{dow:zero}` → `0`–`6` Sunday=0, `{dow:locale:0}` → `0`–`6` locale week start=0, `{mm:zero}` → `00`–`11`, `{woy:zero}` → `00`–`52`, `{wom:zero}` → `0`–`4`) | `{dow:0}` → `6`, `{dow:locale:0}` → `0`, `{mm:raw:0}` → `9` | | `:day` | Unit Scope | Expresses time units cumulatively over the day (`{ss:day}` → `0`–`86399`, `{mi:day}` → `0`–`1439`, `{ms:day}`, `{ns:day}`) | `{ss:day}` → `55845` | | `:week` | Unit Scope | Expresses time units cumulatively over the week (`{hh:week}` → `0`–`167`, `{mi:week}`, `{ss:week}`) or day within the week (`{dd:week}` → `1`–`7`) | `{hh:week}` → `135`, `{dd:week}` → `6` | @@ -179,8 +179,8 @@ You can append modifiers to any token using a colon (`:`) to transform its outpu > * `{tz:offset:mi}` (and alias `:min`) → Minutes without sign (e.g. `00`, `30`). > * `{tz:offset:ss}` (and alias `:sec`) → Offset including seconds (e.g. `+10:00:00`, compact `{tz:offset:compact:ss}` → `+100000`). > * `{tz:offset:utc}` / `{tz:offset:compact:utc}` → UTC `Z` indicator: emits `Z` for UTC (`+00:00`), else ISO offset `+10:00` (or compact `+1000`). -> * **Canonical Naming**: Sub-modifiers `:hh`, `:mi`, `:ss`, and `:utc` match Tempo's core time tokens. Modifiers `:hour`, `:min`, `:sec`, and `:z` are supported synonyms. -> * **Shorthands & Aliases**: LDML aliases (`{tz:z}`, `{tz:zz}`, `{tz:zzz}`) are supported as drop-in shorthands. +> * **Canonical Naming**: Sub-modifiers `:hh`, `:mi`, `:ss`, and `:utc` match Tempo's core time tokens. Modifiers `:hour`, `:min`, and `:sec` are supported synonyms. +> * **Dialect Compatibility**: For LDML and Moment-style timezone masks (`z`, `zz`, `zzz`), use `@magmacomputing/tempo-plugin-dialects`. > [!TIP] > **Numeric Zero-Fill Padding, Tail-Slicing & Fractional Precision** diff --git a/packages/tempo/doc/2-core-concepts/tempo.getters.md b/packages/tempo/doc/2-core-concepts/tempo.getters.md index d9caa278..c792f7e3 100644 --- a/packages/tempo/doc/2-core-concepts/tempo.getters.md +++ b/packages/tempo/doc/2-core-concepts/tempo.getters.md @@ -6,95 +6,84 @@ The `Tempo` class provides an extensive array of zero-cost getters that allow yo > **Zero-Cost Lazy Evaluation** > Tempo uses a sophisticated proxy-based lazy-evaluation pattern. Accessing a getter (like `t.yy`) resolves the property on demand, and then overwrites the getter with a static literal. This means the first access is $O(1)$ and every subsequent access is raw property access ($O(0)$ cost). -## ⚡ Native Temporal Gateway +## ⚡ Native Temporal Gateway (`.zdt`) + +The **`.zdt`** getter provides direct, zero-overhead access to the underlying native `Temporal.ZonedDateTime` instance. All tables below cross-reference Tempo's ergonomic shorthand getters with their underlying native `zdt.*` properties or namespace sources: | Getter | Type | Description | Example | | :--- | :--- | :--- | :--- | -| `.zdt` | `Temporal.ZonedDateTime` | Direct zero-overhead access to the underlying native Temporal instance | `t.zdt.daysInMonth` | +| **`.zdt`** | `Temporal.ZonedDateTime` | Direct zero-overhead access to the underlying native Temporal instance | `t.zdt.inLeapYear` | -The `.zdt` getter provides direct, zero-overhead access to the underlying `Temporal.ZonedDateTime` instance, enabling native Temporal inspections and properties without method call ceremony: +## 📅 Date Properties -```typescript -const t = new Tempo('2026-10-24T15:30:00[Australia/Sydney]'); +| Getter / Temporal | Type | Description | Example | +| :--- | :--- | :--- | :--- | +| **`.yy`**
`zdt.year` | `number` | 4-digit Year | `2026` | +| **`.mm`**
`zdt.month` | `number` | Month number (1 = Jan, 12 = Dec) | `10` | +| **`.dd`**
`zdt.day` | `number` | Day of the month (1–31) | `24` | +| **`.dim`**
`zdt.daysInMonth` | `number` | Total days in the month (28–31) | `31` | +| **`.era`**
`zdt.era` | `string \| undefined` | Calendar era identifier | `'ce'`, `'bce'`, `'ad'`, `'bc'` | +| **`.eon`**
`zdt.eraYear` | `number \| undefined` | Positive integer year within current `.era` [[1]](#fn-eon) | `2026`, `4` | +| **`.jj`** | `number` | Integer Julian Day number for the local ISO date (ignoring time of day) [[2]](#fn-jj) | `2461331` | -console.log(t.zdt.daysInMonth); // 31 -console.log(t.zdt.inLeapYear); // false -console.log(t.zdt.offset); // '+11:00' -console.log(t.zdt.hoursInDay); // 24 -console.log(t.zdt.monthCode); // 'M10' -``` + -## 📅 Date Properties +1. **Era Year (`.eon`) vs. Calendar Year (`.yy`)**: While `.yy` returns the signed astronomical year (e.g. `2026` or `-3`), `.eon` returns the positive integer year within the active `.era` (e.g. `2026` in CE, `4` in 4 BCE, or `4` in Reiwa 4 when using the Japanese calendar). +2. **Astronomical Julian Day (`.jj`) vs. Day of Year (`.doy`)**: `.jj` provides the integer Julian Day Number for the instance's local ISO date (an integer day count elapsed since noon UT on January 1, 4713 BC, in the proleptic Julian calendar, ignoring time of day, e.g. `2461331` for 2026-10-17). If you need the calendar day within the current year (`1`–`366`), use `.doy`. -| Getter | Type | Description | Example | -| :--- | :--- | :--- | :--- | -| `.yy` | `number` | 4-digit Year | `2026` | -| `.mm` | `number` | Month number (1 = Jan, 12 = Dec) | `10` | -| `.dd` | `number` | Day of the month (1-31) | `24` | -| `.dim` | `number` | Total days in the month (28-31; convenience alias for `.zdt.daysInMonth`) | `31` | -| `.jj` | `number` | Astronomical Julian Day number since 4713 BC | `2461331` | -| `.era` | `string` | Localized era string | `'ce'`, `'bce'`, `'ad'`, `'bc'` | -| `.eon` | `number` | Positive integer year within the current `.era` | `2026`, `4` | - -> [!NOTE] -> **Days in Month (`.dim`) vs. Native `.zdt.daysInMonth`** -> While `.dim` is provided as a zero-cost convenience property returning the number of days in the current month (`28`–`31`, matching format token `{dim}` and PHP `t`), `t.zdt.daysInMonth` is the native standard property directly available on the underlying `Temporal.ZonedDateTime` instance. - -> [!NOTE] -> **Astronomical Julian Day (`.jj`) vs. Day of Year (`.doy`)** -> `.jj` provides the true astronomical Julian Day Number (an integer day count elapsed since noon UT on January 1, 4713 BC in the proleptic Julian calendar, e.g. `2461331` for 2026-10-17), matching Oracle `J` and token `{jj}`. If you need the calendar day within the current year (`1`–`366`), use `.doy` (or format token `{doy}` / `{dd:year}`). + ## ⏱️ Time Properties -| Getter | Type | Description | Example | +| Getter / Temporal | Type | Description | Example | | :--- | :--- | :--- | :--- | -| `.hh` | `number` | Hour of the day (0-23) | `15` | -| `.mi` | `number` | Minutes of the hour (0-59) | `30` | -| `.ss` | `number` | Seconds of the minute (0-59) | `45` | -| `.ms` | `number` | Milliseconds of the second (0-999) | `123` | -| `.us` | `number` | Microseconds of the millisecond (0-999) | `456` | -| `.ns` | `number` | Nanoseconds of the microsecond (0-999) | `789` | -| `.ff` | `number` | Fractional seconds representation | `0.123456789` | +| **`.hh`**
`zdt.hour` | `number` | Hour of the day (0–23) | `15` | +| **`.mi`**
`zdt.minute` | `number` | Minutes of the hour (0–59) | `30` | +| **`.ss`**
`zdt.second` | `number` | Seconds of the minute (0–59) | `45` | +| **`.ms`**
`zdt.millisecond` | `number` | Milliseconds of the second (0–999) | `123` | +| **`.us`**
`zdt.microsecond` | `number` | Microseconds of the millisecond (0–999) | `456` | +| **`.ns`**
`zdt.nanosecond` | `number` | Nanoseconds of the microsecond (0–999) | `789` | +| **`.ff`** | `number` | Fractional seconds representation | `0.123456789` | ## 🗓️ ISO Week & Day Alignments -| Getter | Type | Description | Example | +| Getter / Temporal | Type | Description | Example | | :--- | :--- | :--- | :--- | -| `.yow` | `number` | 4-digit ISO week-numbering year | `2026` | -| `.woy` | `number` | ISO week number of the year (1-53; canonical, supersedes legacy `.ww`) | `43` | -| `.dow` | `number` | ISO weekday number (1 = Mon, 7 = Sun) | `6` | -| `.doy` | `number` | Day of the year (1-366) | `297` | - -> [!NOTE] -> **Canonical Getters & v5 Deprecation Path** -> To establish a clean, predictable, and collision-free API surface across getters and format tokens: -> * **`.woy`** is canonical for ISO week of the year. The legacy `.ww` getter is marked `@deprecated` and will be removed in v5.0.0. -> * **`.eon`** is canonical for the positive integer year within the era (supersedes `@deprecated` `.eraYear`). -> * **`.dd`** is canonical for the day of the month (supersedes `@deprecated` `.day`). +| **`.yow`**
`zdt.yearOfWeek` | `number` | 4-digit ISO week-numbering year | `2026` | +| **`.woy`**
`zdt.weekOfYear` | `number` | ISO week number of the year (1–53; canonical, supersedes legacy `.ww`) | `43` | +| **`.dow`**
`zdt.dayOfWeek` | `number` | ISO weekday number (1 = Mon, 7 = Sun) | `6` | +| **`.doy`**
`zdt.dayOfYear` | `number` | Day of the year (1–366) | `297` | ## 🔤 Named String Representations -| Getter | Type | Description | Example | +| Getter / Path | Type | Description | Example | | :--- | :--- | :--- | :--- | -| `.mon` | `string` | Full English month name | `'October'` | -| `.mmm` | `string` | Short English month name | `'Oct'` | -| `.wkd` | `string` | Full English weekday name | `'Saturday'` | -| `.www` | `string` | Short English weekday name | `'Sat'` | +| **`.mon`**
`Tempo.MONTHS.keyOf(zdt.month)` | `string` | Full English month name (Gregorian registry label) | `'October'` | +| **`.mmm`**
`Tempo.MONTH.keyOf(zdt.month)` | `string` | Short English month name (Gregorian registry label) | `'Oct'` | +| **`.wkd`**
`Tempo.WEEKDAYS.keyOf(zdt.dayOfWeek)` | `string` | Full English weekday name | `'Saturday'` | +| **`.www`**
`Tempo.WEEKDAY.keyOf(zdt.dayOfWeek)` | `string` | Short English weekday name | `'Sat'` | ## 🌍 Regional, Timezone & System Properties -| Getter | Type | Description | Example | +| Getter / Path | Type | Description | Example | | :--- | :--- | :--- | :--- | -| `.tz` | `string` | IANA Time Zone ID | `'Australia/Sydney'` | -| `.cal` | `string` | Temporal Calendar ID | `'iso8601'` | -| `.locale` | `string \| string[]` | Resolved BCP 47 locale | `'en-AU'`, `['en-US', 'fr-FR']` | -| `.intl` | `TempoIntlNamespace` | Structured internationalization namespace (`.info` for cultural metadata, `.locale` for native `Intl.Locale`) | `t.intl.info.firstDay`, `t.intl.locale` | -| `.geo` | `object \| undefined` | Resolved geographic coordinates (`latitude`, `longitude`, `elevation`, `sphere`) | `{ latitude: -33.8688, longitude: 151.2093 }` | -| `.sphere` | `'north' \| 'south' \| undefined` | Resolved hemisphere configuration | `'south'` | -| `.ts` | `number \| bigint` | Unix timestamp (`number` for `ss`/`ms`/`us`, `bigint` for `ns`) | `1792843200000` | -| `.nano` | `bigint` | Nanoseconds since Unix epoch | `1792843200000000000n` | -| `.iso` | `string` | Standard ISO 8601 string (RFC 3339) in UTC | `'2026-10-24T04:30:00Z'` | -| `.isValid`| `boolean`| `true` if the underlying date-time is valid | `true` | +| **`.tz`**
`zdt.timeZoneId` | `string` | IANA Time Zone ID | `'Australia/Sydney'` | +| **`.cal`**
`zdt.calendarId` | `string` | Calendar identifier [[3]](#fn-cal) | `'iso8601'`, `'gregory'` | +| **`.locale`**
`intl.locale?.toString()` | `string` | Resolved canonical BCP 47 language tag | `'en-AU'`, `'en-US'` | +| **`.intl`** | `TempoIntlNamespace` | Structured internationalization namespace (`.info` for cultural metadata, `.locale` for native `Intl.Locale`) | `t.intl.info.firstDay`
`t.intl.locale` | +| **`.geo`** | `object \| undefined` | Resolved geographic coordinates (`latitude`, `longitude`, `elevation`, `sphere`) | `{ latitude: -33.87,`
`longitude: 151.21 }` | +| **`.sphere`**
`geo?.sphere` | `Tempo.COMPASS \|`
`undefined` | Resolved terrestrial hemisphere or compass orientation (`'north'`, `'south'`, `'equator'`, `'east'`, `'west'`) | `'south'` | +| **`.ts`**
`t.epoch[timeStamp ?? 'ms']` | `number \| bigint` | Unix timestamp using configured epoch unit (defaults to `'ms'`; `number` for `ss`/`ms`/`us`, `bigint` for `ns`) [[4]](#fn-ts) | `1792843200000` | +| **`.nano`**
`zdt.epochNanoseconds` | `bigint` | Nanoseconds since Unix epoch | `1792843200000000000n` | +| **`.iso`**
`zdt.toInstant()`
⤷ `.toString()` | `string` | Standard ISO 8601 string (RFC 3339) in UTC | `'2026-10-24T04:30:45`
`.123456789Z'` | +| **`.isValid`** | `boolean` | `true` if the underlying date-time is valid | `true` | + + + +3. **Active Calendar (`.cal`) vs. Locale Calendar Preference (`.intl.info.calendar`)**: `.cal` returns the instance's active calendar identifier (`zdt.calendarId`), which controls arithmetic and date representation. To inspect the cultural default calendar associated with the resolved locale (e.g. `'gregory'` for `en-US`, or `'buddhist'` for `th-TH`), use `t.intl.info.calendar`. +4. **Configured Epoch Timestamp (`.ts`)**: `.ts` resolves its value using the configured `timeStamp` unit (defaults to `'ms'`). Only `'ms'` maps directly to native `zdt.epochMilliseconds`. When configured to `'ss'`, `'us'`, or `'ns'`, `.ts` maps to their respective epoch values (`'ss'` seconds, `'us'` microseconds, or `'ns'` `zdt.epochNanoseconds`). For an unconditional nanosecond timestamp regardless of instance configuration, use `.nano`. + + --- @@ -104,7 +93,7 @@ Beyond date-time properties, the `Tempo` class also provides read-only getters i | Getter | Type | Description | | :--- | :--- | :--- | -| `.config` | `object` | Returns a proxy to the active configuration, including all resolved inheritance and local overrides. | -| `.terms` | `object` | Returns a dictionary of all registered `TermPlugins` and their available `ranges`. | -| `.ranges` | `object` | Returns a dictionary of the *currently active* range key for every registered term (e.g., `{ 'season': 'summer' }`). | -| `.parse` | `object` | Returns a shadowed view of the internal parsing state (including `anchor`, `mode`, and the AST-like `match` output). | +| **`.config`** | `object` | Returns a proxy to the active configuration, including all resolved inheritance and local overrides. | +| **`.terms`** | `object` | Returns a dictionary of all registered `TermPlugins` and their available `ranges`. | +| **`.ranges`** | `object` | Returns a dictionary of the *currently active* range key for every registered term (e.g., `{ 'season': 'summer' }`). | +| **`.parse`** | `object` | Returns a shadowed view of the internal parsing state (including `anchor`, `mode`, and the AST-like `match` output). | diff --git a/packages/tempo/doc/4-advanced-reference/tempo.intl.md b/packages/tempo/doc/4-advanced-reference/tempo.intl.md index efa71450..29fb81d6 100644 --- a/packages/tempo/doc/4-advanced-reference/tempo.intl.md +++ b/packages/tempo/doc/4-advanced-reference/tempo.intl.md @@ -110,6 +110,8 @@ console.log(t.intl.info.script); // 'Latn' console.log(t.intl.info.direction); // 'ltr' console.log(t.intl.info.hourCycle); // 'h12' console.log(t.intl.info.numberingSystem); // 'latn' +console.log(t.intl.info.calendar); // 'gregory' +console.log(t.intl.info.calendars); // ['gregory'] console.log(t.intl.info.baseName); // 'en-US' // Native Intl.Locale instance via t.intl.locale (use optional chaining): @@ -120,9 +122,6 @@ console.log(t.intl.locale?.maximize().baseName); // 'en-Latn-US' > [!NOTE] > **Type Safety & Environment Portability**: While `t.intl.info.*` properties are guaranteed non-nullish across all platforms, `t.intl.locale` directly exposes the host engine's native `Intl.Locale`. TypeScript strict checking encourages optional chaining (`t.intl.locale?....`) when directly interacting with the native instance prototype. -> [!TIP] -> **Backward Compatibility**: Direct access via `t.intl.firstDay`, `t.intl.weekend`, etc., remains supported as a deprecated fallback during v4.x, but new code should target `t.intl.info.*`. - ### Opt-in Regional Calendar Math (`localeInfo: true`) By default, Tempo protects your backend and machine logic with strict ISO 8601 invariants (`t.set({ week: 'start' })` always snaps to Monday). diff --git a/packages/tempo/doc/8-project-and-support/migration-guide.md b/packages/tempo/doc/8-project-and-support/migration-guide.md index b2e1fa22..58e79044 100644 --- a/packages/tempo/doc/8-project-and-support/migration-guide.md +++ b/packages/tempo/doc/8-project-and-support/migration-guide.md @@ -1,3 +1,105 @@ +# 💥 Migrating to Tempo v5.x + +Tempo v5.x focuses on modern ECMAScript standards alignment, streamlined API ergonomics, removal of deprecated getters, static enums, legacy format tokens, and first-class integration with TC39 Signals across the reactive plugin ecosystem. + +--- + +## 🛑 Deprecation Removals & Breaking Changes in v5.0.0 + +### 1. Static Enum Accessors (`Tempo.enums.*`) +The top-level static enum accessors on `Tempo` have been removed in favor of the unified `Tempo.enums` namespace. + +* **Removed:** `Tempo.ELEMENT`, `Tempo.FORMAT`, `Tempo.NUMBER`, `Tempo.ORDINAL`, `Tempo.TIMEZONE`, `Tempo.MONTH_DAY`, `Tempo.MODE`, `Tempo.CACHE`, `Tempo.LIMIT` +* **Replacement:** Use `Tempo.enums.` (for example, `Tempo.enums.FORMAT`, `Tempo.enums.MODE`, `Tempo.enums.TIMEZONE`, `Tempo.enums.ELEMENT`). + +```typescript +// ❌ v4.x (Deprecated) +const formatEnum = Tempo.FORMAT; + +// ✅ v5.0.0 +const formatEnum = Tempo.enums.FORMAT; +``` + +--- + +### 2. Static Extension Method (`Tempo.use`) +The legacy static `Tempo.extend(...)` method has been removed. + +* **Removed:** `Tempo.extend(...)` +* **Replacement:** Use `Tempo.use(...)` (or `sandbox.use(...)`). + +```typescript +// ❌ v4.x (Deprecated) +Tempo.extend(MyPlugin); + +// ✅ v5.0.0 +Tempo.use(MyPlugin); +``` + +--- + +### 3. Instance Properties and Getters +Several legacy and ambiguous instance getters have been removed in favor of canonical ISO / temporal properties: + +| Removed Getter | Canonical Replacement | Description | +| :--- | :--- | :--- | +| `t.eraYear` | `t.eon` | Year within era (eon / astronomical era calendar alignment). | +| `t.ww` | `t.woy` | Week of year (ISO 8601 week number `1`..`53`). | +| `t.day` | `t.dd` | Day of the month (`1`–`31` number). Use `t.format('{dd}')` when zero-padded text is needed. For day-of-week use `t.dow`, and for day-of-year use `t.doy`. | +| `t.clone()` | `Tempo.from(t, t.config)` | Canonical instance cloning constructor (preserves instance-local configuration). | + +```typescript +// ❌ v4.x (Deprecated) +const week = t.ww; +const eraY = t.eraYear; +const dayVal = t.day; +const copy = t.clone(); + +// ✅ v5.0.0 +const week = t.woy; +const eraY = t.eon; +const dayVal = t.dd; +const copy = Tempo.from(t, t.config); +``` + +--- + +### 4. Format Tokens and Modifiers +To reduce token ambiguity and eliminate redundant aliases, format tokens and modifier definitions have been rationalized: + +* **Timezone Token (`{tzd}` → `{tz}`):** + * The legacy `{tzd}` (timezone delimiter / descriptor) token has been removed. + * Use the canonical `{tz}` token instead. +* **Composite Week-Year Tokens (`{yyww}`, `{yywy}`, `{yywoy}`):** + * Composite week-and-year tokens have been removed in favor of composable standard tokens. + * Replace `{yywoy}` or `{yyww}` with `{yow}{woy}` (or localized `{yow:locale}{woy:locale}`). +* **Year Modifier Aliases (`:yy` and `:year`):** + * The `:yy` and `:year` sub-modifier aliases on year tokens have been removed. + * Use the canonical `{yy}` token (or `{yyyy}` for 4-digit years). +* **Legacy Offset Modifiers on `{tz}`:** + * Legacy modifier cases (`offsetshort`, `offsetcompact`, `z`, `zz`, `zzz`, `zzzz`, `zzzzz`) on `{tz}` have been removed from the core formatter. + * Use canonical `{tz:offset}`, composable `{tz:offset:compact}`, `{tz:short}`, or `{tz:long}` in core (`{tz:offset:compact}` replaces legacy `{tz:offsetcompact}` and v4.7 `{tz:zzz}` for unpunctuated offsets like `+0530`), or load `@magmacomputing/tempo-plugin-dialects` if LDML / Moment-style pattern emulation is required. + +```typescript +// ❌ v4.x (Deprecated) +t.format('{tzd}'); +t.format('{yywoy}'); +t.format('{year:yy}'); + +// ✅ v5.0.0 +t.format('{tz}'); +t.format('{yow}{woy}'); +t.format('{yy}'); +``` + +--- + +### 5. Utility & Support Exports +* **`Enum` export removed:** The legacy `Enum` class export from `@magmacomputing/tempo` has been removed. Use native TypeScript enums, `as const` object literals, or the `@magmacomputing/library` enumerator utilities (`enumify`). +* **`hasOwn` helper removed:** The internal re-export `hasOwn` from support utils has been removed. Use standard ECMAScript `Object.hasOwn(target, property)`. + +--- + # ⚠️ Migrating to Tempo v4.x Tempo v4.x introduces a standardized plugin & registry architecture, strict configuration namespaces, cascading configuration inheritance, and deterministic resource disposal while excising legacy v3.x deprecated interfaces. diff --git a/packages/tempo/plan/bleeding-edge-technologies.md b/packages/tempo/plan/bleeding-edge-technologies.md index ffa2a806..87ebe592 100644 --- a/packages/tempo/plan/bleeding-edge-technologies.md +++ b/packages/tempo/plan/bleeding-edge-technologies.md @@ -96,20 +96,20 @@ Tempo already leverages several cutting-edge platform primitives: --- -### E. TC39 Signals Integration (`Tempo.signal()`) -**Target**: *Dedicated Plugin (`@magmacomputing/tempo-plugin-signals`)* +### E. TC39 Signals Integration (`Tempo.ticker.signal()`, `ticker.signal`, `Tempo.ntp.signals`) +**Target**: *Native Core Utility (`#library/signify.library.js`), `@magmacomputing/tempo-plugin-ticker`, `@magmacomputing/tempo-plugin-ntp`* +**Status**: **Delivered (v5.0.0 via Signify)** -* **The Problem**: Modern UI frameworks (Preact, Solid, Vue, Angular, Svelte) are converging on TC39 Signals for fine-grained reactivity. +* **The Problem**: Modern UI frameworks (Preact, Solid, Vue, Angular, Svelte runes) are converging on TC39 Signals for fine-grained synchronous reactivity, but developers previously had to wire external signal libraries to async streams manually. * **The Solution**: - - Provide reactive time signals backed by `WeakCache`: - ```typescript - const currentSecond = Tempo.signal({ interval: 1 }); - // Components reading currentSecond.value automatically re-render on pulse - ``` + - Implemented memory-safe, zero-dependency, frozen TC39 Signals proposal in `#library/signify.library.ts` (`Signify.State`, `Signify.computed`, `Signify.effect`, `Watcher`). + - Integrated native signals directly into `Reactive` via `.signal` and `.toSignal()`. + - Exposed `ticker.signal`, `ticker.toSignal()`, and `Tempo.ticker.signal()` in `@magmacomputing/tempo-plugin-ticker`. + - Exposed `Tempo.ntp.signals` and `Tempo.ntp.signal()` in `@magmacomputing/tempo-plugin-ntp`. * **Cross-Platform Caveats & Ethos Alignment**: - - **Early TC39 Stage 1**: Specification is evolving with no native engine implementation in V8, SpiderMonkey, or JSC. Polyfills add non-trivial bundle weight. - - **Framework Fragmentation**: Frameworks use incompatible reactive graph schedulers. - - **Architectural Fit**: **Hold off**. Tempo delivers universal, zero-dependency async reactivity across all runtimes via `Reactive` (`Symbol.asyncIterator`, `Symbol.dispose`, `.on()`, `.pull()`, `.cast()`, and `.until()`) in `#library` and the Plugin SDK. Re-evaluate TC39 Signals when the specification reaches Stage 3. + - Adheres 100% to the TC39 Signals contract while eliminating external polyfill bundle bloat. + - Zero-cost lazy evaluation ensures unused signal accessors incur zero allocations. + - Automatic memory cleanup via `WeakRef` and `Finalizer` prevents listener leaks across component unmounts. --- diff --git a/packages/tempo/plan/signal-aware-ticker-and-ntp.md b/packages/tempo/plan/signal-aware-ticker-and-ntp.md deleted file mode 100644 index 730e6e3b..00000000 --- a/packages/tempo/plan/signal-aware-ticker-and-ntp.md +++ /dev/null @@ -1,271 +0,0 @@ -# Implementation Plan: Signal-Aware Reactivity for Ticker & NTP Plugins - -**Target Packages**: -- `@magmacomputing/tempo-plugin-ticker` (`packages/plugins/ticker`) -- `@magmacomputing/tempo-plugin-ntp` (`packages/plugins/ntp`) -- `@magmacomputing/tempo` (`packages/tempo`) - -**Status**: Proposal / Ready for Review -**Date**: October 2026 -**Context**: Modernizing Tempo's time-varying plugins with first-class TC39 Signal reactivity powered by `#library/signify.library.js`. - ---- - -## 1. Executive Summary & Motivation - -Tempo's primary reactivity mechanism has historically been the asynchronous stream primitive [`Reactive`](file:///home/michael/Project/magma/packages/library/src/common/runtime/reactive.class.ts), which powers push/pull iteration (`for await (const t of ticker)`), event hooks (`.on('pulse')`), and explicit resource cancellation (`using ticker = Tempo.ticker(...)`). - -However, modern frontend UI architectures (React 19+, Solid, Vue 3.5+, Svelte 5 runes, Preact, Lit, Angular 17+) have converged on **fine-grained, synchronous reactive signals**. Prior to the introduction of `signify.library`, developers building live UI dashboards or synchronized clocks were instructed to install third-party dependencies (such as `@preact/signals-core`) and manually wire ticker callbacks to signal updates. - -With the delivery of **`Signify`** in [`#library/signify.library.ts`](file:///home/michael/Project/magma/packages/library/src/common/runtime/signify.library.ts)—a zero-dependency, memory-safe (`WeakRef` + `Finalizer`), frozen implementation of the TC39 Signals proposal—Tempo now possesses native fine-grained reactivity. - -This Implementation Plan (IP) details the architecture, API design, lifecycle semantics, and phased rollout for making **`@magmacomputing/tempo-plugin-ticker`** and **`@magmacomputing/tempo-plugin-ntp`** natively signal-aware. - ---- - -## 2. Core Architectural Philosophy - -### "Async Stream at the Core, Synchronous Signal at the Edge" - -```mermaid -graph TD - subgraph Engine Core [Asynchronous Scheduling Engine] - Timer[Event Loop / rAF / Interval] --> ReactiveStream["Reactive<Tempo> (Stream Engine)"] - NtpEngine[ClockDriftEngine] --> CalibratedEpoch[Calibrated Epoch Offset] - end - - subgraph Reactive Boundary [Bridging Layer via Signify] - ReactiveStream -->|.toSignal()| TickerSignal["ticker.signal (ReadonlySignal<Tempo>)"] - CalibratedEpoch -->|State.set()| NtpSignals["Tempo.ntp.signals.offset / drift"] - end - - subgraph Consumer Edge [Fine-Grained UI & Computed DAG] - TickerSignal --> CompFmt["Signify.computed(() => clock.format('HH:mm:ss'))"] - NtpSignals --> CompClock["Signify.computed(() => wallClock + offset)"] - CompFmt --> DOMNode[Fine-Grained DOM Text Node] - CompClock --> TradingDashboard[Trading / Real-Time Dashboard] - end -``` - -1. **Preserve `Reactive` Internals**: Stateful plugins will not abandon `Reactive`. `Reactive` remains the single source of truth for scheduling, interval drift calculation, pause/resume, error containment, and stream cancellation. -2. **Zero-Cost Lazy Evaluation**: Signal objects (`Signify.State` / `Signify.Computed`) are only created when the developer accesses `.signal` or calls `.toSignal()`. Unused signal functionality incurs zero memory or allocation overhead. -3. **Leak-Proof Automatic Lifecycle**: Signals are bound to underlying streams via `WeakRef` and registered with [`Finalizer`](file:///home/michael/Project/magma/packages/library/src/common/runtime/finalizer.class.ts). If a UI component unmounts and abandons its signal reference, the internal listener unregisters automatically. -4. **TC39 Forward Compatibility**: All exposed signals adhere to the standard `Signal.State` / `Signal.Computed` contract (`.get()`, `.value`, `.epoch`) and auto-delegate to `globalThis.Signal` when native runtime support arrives. - ---- - -## 3. Specification: `@magmacomputing/tempo-plugin-ticker` - -### 3.1 Instance Signal Accessors (`ticker.signal` & `ticker.toSignal()`) - -Every [`TickerInstance`](file:///home/michael/Project/magma/packages/plugins/ticker/src/index.ts#L129) maintains an internal `Reactive` stream. We expose: - -1. **`ticker.signal`**: A cached, lazy `ReadonlySignal` representing the current tick value: - ```typescript - export interface TickerInstanceDescriptor { - /** - * Readonly TC39 Signal emitting the latest Tempo instance on each tick. - * Reading `.value` or `.get()` within an effect or computed graph registers a reactive dependency. - */ - readonly signal: ReadonlySignal; - - /** - * Explicit signal factory allowing an initial fallback value before the first tick. - */ - toSignal(initialValue?: D): ReadonlySignal; - } - ``` - -2. **Usage Example (Vanilla & Frameworks)**: - ```typescript - import { Tempo } from '@magmacomputing/tempo'; - import '@magmacomputing/tempo-plugin-ticker/install'; - - // Create a 1-second ticking clock - using ticker = Tempo.ticker({ seconds: 1 }); - - // Access the native signal directly - const clock = ticker.signal; - - // In fine-grained frameworks (e.g. Solid, Preact Signals, Vue 3.5, Angular Signals): - console.log(clock.value.format('{h12}:{mi}:{ss} {mer:upper}')); - ``` - -### 3.2 Static Convenience Helper: `Tempo.ticker.signal()` - -Provides a one-line constructor for standalone reactive clocks without requiring explicit instance management: - -```typescript -// Creates, starts, and returns a ReadonlySignal ticking at the specified interval -const currentSecond = Tempo.ticker.signal(1); -const currentMinute = Tempo.ticker.signal({ interval: '1m' }); -const businessPulse = Tempo.ticker.signal({ cron: '*/5 9-17 * * 1-5' }); -``` - -#### Lifecycle Semantics: -- **Auto-Disposal with `using`**: - ```typescript - { - using clock = Tempo.ticker.signal(1); - // Runs while in scope; automatically stops timer on block exit - } - ``` -- **Terminal States**: When a ticker reaches its configured `limit` or `until` date, or when `.stop()` is called, the signal retains its terminal `Tempo` snapshot and halts updates; downstream computations are not dirtied again. - ---- - -## 4. Specification: `@magmacomputing/tempo-plugin-ntp` - -### 4.1 Reactive State Namespace: `Tempo.ntp.signals` - -Currently, [`Tempo.ntp`](file:///home/michael/Project/magma/packages/plugins/ntp/src/index.ts#L176) exposes static getters: `offset`, `drift`, and `isCalibrated`. These reflect point-in-time values. - -We add `Tempo.ntp.signals` as a frozen namespace of reactive signal properties: - -```typescript -export interface NtpSignalsNamespace { - /** Reactive signal containing the current clock drift offset in milliseconds */ - readonly offset: ReadonlySignal; - - /** Reactive signal indicating whether clock synchronization has completed at least one valid calibration */ - readonly isCalibrated: ReadonlySignal; - - /** Reactive signal emitting the complete ClockDriftState snapshot (RTT, jitter, confidence) */ - readonly drift: ReadonlySignal; -} -``` - -#### Engine Integration Hook: -Inside [`ClockDriftEngine`](file:///home/michael/Project/magma/packages/plugins/ntp/src/engine.ts), when calibration updates state (either via active `sync()` or passive HTTP `fetch` header interception): -```typescript -// Inside ClockDriftEngine state update routine: -#offsetState.set(newOffset); -#isCalibratedState.set(true); -#driftState.set(this.drift); -``` - -### 4.2 Calibrated Live Clock Signal: `Tempo.ntp.signal()` - -Exposes an auto-updating live clock that incorporates real-time network drift compensation: - -```typescript -/** - * Creates a ReadonlySignal that ticks on an interval and automatically - * accounts for calibrated NTP drift. - */ -const ntpClock = Tempo.ntp.signal({ interval: 1 }); - -// Reading ntpClock.value returns an accurate Tempo instance: -// epochMs = Date.now() + Tempo.ntp.offset -``` - -If background recalibration occurs while the application is running, `ntpClock` automatically adjusts its next tick calculation, ensuring zero phase shift across long-running browser sessions. - ---- - -## 5. Cross-Plugin Synergy: NTP-Calibrated Reactive Ticker - -A primary benefit of native signal awareness is composability between `Ticker` and `NTP`: - -```typescript -import { Tempo } from '@magmacomputing/tempo'; -import '@magmacomputing/tempo-plugin-ticker/install'; -import '@magmacomputing/tempo-plugin-ntp/install'; - -// 1. Ticker automatically binds to NTP when { ntp: true } is supplied -const atomicTicker = Tempo.ticker({ - interval: 1, - ntp: true // Computes ticks against Tempo.ntp calibrated time -}); - -// 2. Extract signal -const liveAtomicClock = atomicTicker.signal; - -// 3. Derive global market clocks with zero drift -import { Signify } from '@magmacomputing/tempo/library'; - -const nyseTime = Signify.computed(() => - liveAtomicClock.value.set({ timeZone: 'America/New_York' }).format('{h12}:{mi}:{ss} {mer:upper}') -); - -const tokyoTime = Signify.computed(() => - liveAtomicClock.value.set({ timeZone: 'Asia/Tokyo' }).format('{h12}:{mi}:{ss} {mer:upper}') -); -``` - ---- - -## 6. TypeScript Interface Augmentations - -### Ticker Module (`packages/plugins/ticker/src/index.ts`) - -```typescript -import type { ReadonlySignal } from '@magmacomputing/tempo/library'; - -declare module '@magmacomputing/tempo' { - namespace Tempo { - namespace ticker { - /** Spawns an auto-ticking ReadonlySignal */ - function signal(interval?: number | string | Ticker.Options): ReadonlySignal & Disposable; - } - } - - namespace Ticker { - interface Instance { - /** Native TC39 ReadonlySignal emitting on every tick */ - readonly signal: ReadonlySignal; - toSignal(initialValue?: D): ReadonlySignal; - } - } -} -``` - -### NTP Module (`packages/plugins/ntp/src/index.ts`) - -```typescript -import type { ReadonlySignal } from '@magmacomputing/tempo/library'; -import type { ClockDriftState } from './types.js'; - -export interface NtpSignalsNamespace { - readonly offset: ReadonlySignal; - readonly isCalibrated: ReadonlySignal; - readonly drift: ReadonlySignal; -} - -declare module '@magmacomputing/tempo' { - namespace Tempo { - namespace ntp { - /** Reactive signals namespace for drift, offset, and calibration state */ - const signals: NtpSignalsNamespace; - - /** Spawns an NTP-calibrated ticking clock signal */ - function signal(options?: { interval?: number | string; timeZone?: string }): ReadonlySignal & Disposable; - } - } -} -``` - ---- - -## 7. Phased Implementation Roadmap - -| Phase | Milestone | Scope / Deliverables | Risk / Complexity | -| :--- | :--- | :--- | :---: | -| **Phase 1** | **Ticker Signal Core** | 1. Expose `ticker.signal` on `TickerInstance` by leveraging existing `this.#reactive.signal`.
2. Implement `ticker.toSignal(fallback)`.
3. Implement static helper `Tempo.ticker.signal(...)`.
4. Add unit test suite in `packages/plugins/ticker/test/ticker.signal.test.ts`. | **Low** | -| **Phase 2** | **NTP Reactive Engine** | 1. Add `Signify.State` instances inside `ClockDriftEngine` for `offset`, `isCalibrated`, and `drift`.
2. Update states in `sync()` and `fetch` interception response handlers.
3. Expose `Tempo.ntp.signals` getter namespace.
4. Add unit tests in `packages/plugins/ntp/test/ntp.signals.test.ts`. | **Low-Medium** | -| **Phase 3** | **Calibrated NTP Signal & Ticker Interop** | 1. Implement `Tempo.ntp.signal({ interval })` composing NTP offset with timer ticks.
2. Verify dynamic phase realignment when recalibration occurs mid-stream.
3. Add integration tests verifying `Tempo.ticker({ ntp: true }).signal`. | **Medium** | -| **Phase 4** | **Docs & Modernization** | 1. Update [`packages/plugins/ticker/doc/reactive-clocks-and-events.md`](file:///home/michael/Project/magma/packages/plugins/ticker/doc/reactive-clocks-and-events.md) to replace `@preact/signals-core` with native `ticker.signal`.
2. Update [`bleeding-edge-technologies.md`](file:///home/michael/Project/magma/packages/tempo/plan/bleeding-edge-technologies.md#L99-L113) status from "Hold off" to "Integrated via Signify".
3. Add interactive REPL showcase example demonstrating zero-drift live dashboards. | **Low** | - ---- - -## 8. Verification & Test Plan - -1. **Reactivity & Epoch Verification**: - - Verify that reading `.signal.value` within `Signify.effect()` or `Signify.computed()` registers dependencies and triggers effects on every timer pulse. - - Verify that when the timer is stopped via `.stop()`, downstream effects cease firing. -2. **Memory Leak Protection**: - - Run memory stress test with 10,000 transient ticker signals without explicit disposal to confirm `Finalizer` and `WeakRef` successfully release unreferenced consumer nodes. - - Verify `using` operator cleanly invokes `[Symbol.dispose]()` and shuts down underlying timers. -3. **NTP Drift Reaction**: - - Mock network fetch response with an adjusted `Server-Timing: clock=...` header. - - Verify that `Tempo.ntp.signals.offset` updates its epoch and immediately re-evaluates all dependent computed clocks without a page refresh or polling loop. diff --git a/packages/tempo/plan/tempo-plugin-roman.md b/packages/tempo/plan/tempo-plugin-roman.md deleted file mode 100644 index 1a4e2937..00000000 --- a/packages/tempo/plan/tempo-plugin-roman.md +++ /dev/null @@ -1,71 +0,0 @@ -# Plan: `@magmacomputing/tempo-plugin-roman` (Classical Roman Calendar & Latin Mechanics) - -## 1. Overview & Motivation - -While **Tempo core** natively supports modern and archival Roman numeral representations—such as European day-RomanMonth-year dates (`14.X.2026`), monument inscription years (`MMXXVI`, `Anno Domini MCMXCIV`), and round-trip format mask modifiers (`{yyyy:roman}`)—it intentionally does not implement ancient Roman calendar mechanics. - -Ancient Roman timekeeping (*Fasti*) operated on principles completely distinct from modern ISO 8601 and Gregorian calendar arithmetic: -- Days were not numbered sequentially $1 \dots 31$; they were calculated backwards from three lunar anchor points: **Kalends** (*Kalendae*), **Nones** (*Nonae*), and **Ides** (*Idus*). -- Years were recorded by **Presiding Consuls** (e.g., *"In the consulship of Cicero and Antonius"*) or reckoned **AUC** (*Ab Urbe Condita* — from the traditional founding of Rome in 753 BC). -- Neither ECMAScript Intl nor TC39 `Temporal` support Roman calendar systems. - -To preserve the lean footprint and deterministic $O(1)$ performance of Tempo core while providing complete fidelity for historians, legal scholars, genealogists, classicists, and numismatists, classical Roman calendar mechanics will be housed in a dedicated plugin: **`@magmacomputing/tempo-plugin-roman`**. - ---- - -## 2. Core Capabilities & Scope - -### A. Classical Date Calculation & Declensions -- **Anchor Calculations**: - - **Kalends** (*Kalendae*): Always the 1st of the month. - - **Nones** (*Nonae*): 7th in "MOM-J" months (March, October, May, July); 5th in all other months. - - **Ides** (*Idus*): 15th in "MOM-J" months; 13th in all other months. - - **Pridie**: The day immediately preceding an anchor (e.g., *Pridie Idus Octobres* = October 14). - - **Ante Diem**: Inclusive backward counting from an anchor (e.g., *Ante diem XVII Kalendas Novembres* = October 16). -- **Leap Year Intercalation (*Bissextile Day*)**: - - Classical handling of leap years by doubling the 6th day before the March Kalends (*ante diem bis sextum Kalendas Martias*). -- **Latin Grammar Support**: - - Full Latin declensions for formal Latin inscriptions (Accusative for *ante diem*, Ablative for exact dates). - - Standard Latin abbreviations (e.g., `a.d. XVII Kal. Nov.`). - -### B. Year Reckoning Systems -1. **AUC (*Ab Urbe Condita*)**: - - Astronomical Gregorian/Julian conversion: - - For $\text{Year} \ge 1$: $\text{AUC} = \text{Year} + 753$ (e.g., $2026 \text{ CE} \implies 2779 \text{ AUC}$). - - For historical BCE: $\text{AUC} = 754 - \text{Year}_{\text{BCE}}$ (e.g., $44 \text{ BCE} \implies 710 \text{ AUC}$). -2. **Consular Dating**: - - Built-in historical catalog of Roman Consuls from 509 BCE through 541 CE. - - Conversion of astronomical years into consular pairs (e.g., $63 \text{ BCE} \implies \text{"M. Tullio Cicerone, C. Antonio Hybrida coss."}$). - -### C. Formatting & Parsing Tokens -- **Formatting Tokens**: - - `{roman:classical}` $\rightarrow$ Full Latin date (*"Ante diem XVII Kalendas Novembres"*). - - `{roman:short}` $\rightarrow$ Abbreviated Latin date (*"a.d. XVII Kal. Nov."*). - - `{roman:auc}` $\rightarrow$ Year AUC (*"AUC MMDCCLXXIX"*). - - `{roman:consul}` $\rightarrow$ Consular pair. -- **Parsing Engine**: - - Natural parsing of classical Latin expressions: - ```ts - const t = Tempo.roman.parse('a.d. IV Id. Mart. 710 AUC'); - // Resolves to March 12, 44 BCE - ``` - ---- - -## 3. Architecture & Integration - -Following the standard Tempo plugin architecture: -- **Module Registration**: Installed via `Tempo.use(RomanPlugin)` or imported as tree-shakable utilities. -- **Namespace Encapsulation**: All classical Roman calculations, parsing, formatting, and conversion functions are cleanly grouped under the static `Tempo.roman` namespace and the instance `tempo.roman` property. -- **Zero Core Dependency Bloat**: All Latin vocabulary, grammar declension tables, and consular catalog remain entirely within the plugin package. - ---- - -## 4. Phased Implementation Roadmap - -| Phase | Milestone | Deliverables | -| :--- | :--- | :--- | -| **Phase 1** | Mathematical Foundations | **Delivered (v1.0.0)**: Kalends/Nones/Ides calculator, Leap year/bissextile handling, AUC year converter. | -| **Phase 2** | Formatting Engine | **Delivered (v1.1.0)**: Full Latin and abbreviated format tokens (`{roman:classical}`, `{roman:short}`, `{roman:auc}`, `{roman:nominative}`, `{roman:accusative}`, `{roman:ablative}`), grammatical case switches (nominative, accusative, ablative), `.formatRoman()` method, Latin ordinal words. | -| **Phase 3** | Classical Parser | **Delivered (v1.2.0)**: NLP pattern recognition for Latin date strings (`Tempo.roman.parse()`, `parseClassicalRomanDate()`), Latin ordinal words, AUC/BCE/CE year resolution, bissextile validation. | -| **Phase 4** | Consular Catalog & Docs | **Delivered (v1.2.0)**: Historical consular database (509 BCE–541 CE), `{roman:consul}` format token, `tempo.consuls` getter, Latin ablative/nominative dating formulas (`Tempo.roman.formatConsuls()`), Fasti search (`Tempo.roman.findConsuls()`), and consular year parsing. | diff --git a/packages/tempo/plan/tempojs-scope-migration.md b/packages/tempo/plan/tempojs-scope-migration.md deleted file mode 100644 index 4ab1ced1..00000000 --- a/packages/tempo/plan/tempojs-scope-migration.md +++ /dev/null @@ -1,193 +0,0 @@ -# Plan: `@tempo-dev` npm Scope Adoption & v5.0.0 Migration Strategy - -## 1. Executive Summary & Value Proposition - -Currently, the Tempo ecosystem is published under the corporate organization scope: -- `@magmacomputing/tempo` -- `@magmacomputing/tempo-fns` -- `@magmacomputing/tempo-plugin-*` (13+ plugins) - -### Why Transition to `@tempo-dev` in v5.0.0? -1. **Developer Experience (DX) & Modern Branding**: Adopting the **`@tempo-dev`** scope (aligned with a `tempo.dev` domain identity) reflects modern, developer-first ecosystem standards (mirroring top-tier tools like `@sst-dev`, `@payload-dev`, and `@livekit-dev`). -2. **Zero Brand & Search Collision**: Completely sidesteps market and SEO confusion with `@formkit/tempo` (which relies on legacy `Date` helpers) by establishing a distinct, future-looking Temporal API identity. -3. **Clean Non-Stuttering Architecture (Pattern 1)**: By using `@tempo-dev/core` as the anchor package with modern subpath exports (`@tempo-dev/core/parse`, `@tempo-dev/core/format`), we eliminate import path repetition (`@tempojs/tempo`) while providing single-package atomic versioning. -4. **Clean Major Version Boundary (v5.0.0)**: Package name changes represent breaking changes for consumer imports, making the upcoming major release (`v5.0.0`) the ideal milestone. - -> [!NOTE] -> **Abandonment of `@tempojs` Scope**: While outreach was previously initiated to the owner of the dormant `@tempojs` npm namespace, this path has been officially abandoned in favor of the cleaner, collision-free, and modern `@tempo-dev` scope. - ---- - -## 2. npm Organization Setup & Domain Alignment - -### Step 1: Claim `@tempo-dev` on npm -- Register the **`@tempo-dev`** organization on npm directly under the organization administrator account. -- Configure team permissions, 2FA, and automated GitHub Actions publishing tokens (`NPM_TOKEN`). - -### Step 2: Align Domain & Repository Assets -- **Documentation Domain**: Target `tempo.dev` (or `tempodev.io`) for the VitePress documentation and interactive playground. -- **GitHub Organization**: Establish `github.com/tempo-dev` (or maintain within `github.com/magmacomputing/magma`). - ---- - -## 3. Ecosystem Architecture & Package Mapping for v5.0.0 - -The v5.0.0 release implements **Pattern 1 (`@tempo-dev/core` with Subpath Exports)** alongside modular satellite packages: - -| Current Scope (`@magmacomputing/*`) | Target v5.0.0 Package (`@tempo-dev/*`) | Architecture & Subpaths | -| :--- | :--- | :--- | -| `@magmacomputing/tempo` | **`@tempo-dev/core`** | Main fluent engine (`.`) with tree-shakeable subpath exports (`./parse`, `./format`, `./mutate`, `./duration`, `./library`, `./plugin/sdk`) | -| `@magmacomputing/tempo-fns` | **`@tempo-dev/fns`** | Standalone functional date math & celestial calculations | -| `@magmacomputing/tempo-plugin-ai` | **`@tempo-dev/plugin-ai`** | AI calendar reasoning & smart extraction | -| `@magmacomputing/tempo-plugin-celestial` | **`@tempo-dev/plugin-celestial`** | Sun/Moon ephemeris, solar events, & tidal predictions | -| `@magmacomputing/tempo-plugin-holidays` | **`@tempo-dev/plugin-holidays`** | Regional public holidays & business day scheduling | -| `@magmacomputing/tempo-plugin-geo` | **`@tempo-dev/plugin-geo`** | Reverse geocoding & timezone resolution | -| `@magmacomputing/tempo-plugin-spatial` | **`@tempo-dev/plugin-spatial`** | Geofencing, spatial distance, bearing, & velocity | -| `@magmacomputing/tempo-plugin-dialects` | **`@tempo-dev/plugin-dialects`** | Moment/Dayjs/Python format compatibility | -| `@magmacomputing/tempo-plugin-sync` | **`@tempo-dev/plugin-sync`** | High-precision atomic clock & drift correction | -| `@magmacomputing/tempo-plugin-ticker` | **`@tempo-dev/plugin-ticker`** | Reactive time ticker & pulse triggers | -| `@magmacomputing/tempo-plugin-batch` | **`@tempo-dev/plugin-batch`** | High-throughput web worker batch processing | -| `@magmacomputing/tempo-plugin-finance` | **`@tempo-dev/plugin-finance`** | Financial quarters, fiscal calendars, & trading days | -| `@magmacomputing/tempo-plugin-ntp` | **`@tempo-dev/plugin-ntp`** | Network Time Protocol socket client | -| `@magmacomputing/tempo-plugin-snap` | **`@tempo-dev/plugin-snap`** | Snap-to-grid rounding & quantization | - ---- - -## 4. Consumer Developer Experience (DX) - -### Subpath Exports on `@tempo-dev/core` -Consumers install a single package (`@tempo-dev/core`) and import either the full fluent class or tree-shakeable individual functions: - -```typescript -// 1. Full Fluent Class -import { Tempo } from '@tempo-dev/core'; - -// 2. Tree-shakeable Subpaths (Zero release overhead; bundled in @tempo-dev/core) -import { parse } from '@tempo-dev/core/parse'; -import { format } from '@tempo-dev/core/format'; -import { mutate } from '@tempo-dev/core/mutate'; - -// 3. Functional Utility Helpers (Standalone package) -import { isWeekend, daysInMonth, getLunarPhase } from '@tempo-dev/fns'; - -// 4. Domain Plugins -import { CelestialPlugin } from '@tempo-dev/plugin-celestial'; -import { AIPlugin } from '@tempo-dev/plugin-ai'; - -Tempo.use(CelestialPlugin); -``` - -#### Example `package.json` Subpath Configuration (`@tempo-dev/core`): -```json -{ - "name": "@tempo-dev/core", - "version": "5.0.0", - "exports": { - ".": { - "types": "./dist/tempo.index.d.ts", - "import": "./dist/tempo.index.js" - }, - "./parse": { - "types": "./dist/module/module.parse.d.ts", - "import": "./dist/module/module.parse.js" - }, - "./format": { - "types": "./dist/module/module.format.d.ts", - "import": "./dist/module/module.format.js" - }, - "./mutate": { - "types": "./dist/module/module.mutate.d.ts", - "import": "./dist/module/module.mutate.js" - }, - "./duration": { - "types": "./dist/module/module.duration.d.ts", - "import": "./dist/module/module.duration.js" - }, - "./library": { - "types": "./dist/library.index.d.ts", - "import": "./dist/library.index.js" - }, - "./plugin/sdk": { - "types": "./dist/plugin/plugin.sdk.d.ts", - "import": "./dist/plugin/plugin.sdk.js" - } - } -} -``` - ---- - -## 5. Seamless Backward-Compatibility Strategy - -To avoid breaking existing v4.x projects upon release of v5.0.0: - -1. **Publish Bridge Stubs under `@magmacomputing/*`**: - - For v5.0.0, publish lightweight wrapper packages under `@magmacomputing/tempo` and `@magmacomputing/tempo-plugin-*`. - - The wrapper re-exports from `@tempo-dev/*`: - ```typescript - // @magmacomputing/tempo index.ts - export * from '@tempo-dev/core'; - export { Tempo as default } from '@tempo-dev/core'; - ``` -2. **Issue Deprecation Notices**: - - Mark `@magmacomputing/tempo` on npm: - ```bash - npm deprecate @magmacomputing/tempo "Package moved to @tempo-dev/core. Please update your dependencies." - ``` - ---- - -## 6. Monorepo Execution Checklist (For v5.0.0 Release) - -- [ ] Claim npm organization `@tempo-dev`. -- [ ] Configure GitHub Secrets with `NPM_TOKEN` granting publish access to `@tempo-dev`. -- [ ] Update `package.json` in `packages/tempo` to name `"@tempo-dev/core"`. -- [ ] Configure `exports` in `packages/tempo/package.json` for subpaths (`./parse`, `./format`, etc.). -- [ ] Update `package.json` in `packages/functions` to `"@tempo-dev/fns"`. -- [ ] Update `package.json` in `packages/plugins/*` to `"@tempo-dev/plugin-*"`. -- [ ] Update documentation examples across `packages/tempo/doc/` and `README.md`. -- [ ] Update VitePress theme headers and installation snippets (`npm install @tempo-dev/core`). -- [ ] Create stub bridge packages for `@magmacomputing/*` v5.0.0 re-exports. -- [ ] Run full test matrix across Node 22, 24, and 26. -- [ ] Tag `v5.0.0` and publish with `npm publish --access public --workspaces`. - ---- - -## 7. Strategic Differentiation Summary - -| Dimension | `@formkit/tempo` | `@tempo-dev/core` (Tempo) | -| :--- | :--- | :--- | -| **Foundational Standard** | Legacy JavaScript `Date` | Modern ECMAScript **`Temporal`** architecture | -| **API Philosophy** | Functional helper library | Rich fluent class (`Tempo`) + Subpaths + Functional bundle (`@tempo-dev/fns`) | -| **Architecture** | Single-purpose date formatting | Extensible engine: AI, Celestial, Geo, Spatial, Ticker, Holidays | -| **Target Audience** | Day.js / date-fns migration projects | Future-proof TypeScript applications transitioning to native `Temporal` | -| **Ecosystem Identity** | Component within FormKit forms | Independent developer platform (`tempo.dev` / `@tempo-dev`) | - ---- - -## 8.Version 5.0.0 Considerations - -### 8.1 Node.js LTS Lifecycle & Compatibility Policy -- **OpenJS Foundation Release Cadence**: Even-numbered Node.js releases follow a 30-month lifecycle (Current $\to$ Active LTS $\to$ Maintenance LTS). -- **SemVer Major Bump Boundary**: Dropping support for an older Node runtime is a breaking change scheduled specifically for the **v5.0.0** release. - -### 8.2 Testing Matrix Across Node Versions -1. **Current `engines` Contract (v4.x)**: - The root `package.json` specifies: - ```json - "engines": { - "node": ">=20.0.0" - } - ``` -2. **Recommended CI Matrix**: - - **Node 20**: Maintained in CI matrix for the `v4.x` series to support enterprise environments and CI runners. - - **Node 22**: Essential (Active / Maintenance LTS). - - **Node 24**: Essential (Active LTS). - - **Node 26**: Recommended as `latest` / canary to catch engine changes early. -3. **v5.0.0 Target Baseline**: - - For the **v5.0.0** `@tempo-dev` release, bump `engines.node` to `">=22.0.0"` and sunset Node 20 testing, aligning the modern scope with current LTS standards and Temporal runtime enhancements. - -### 8.3 Producing separate versions of user-docs - -Should we have a user-doc switch to display version 5 vs verion 4 of Tempo ? - diff --git a/packages/tempo/plan/v4-v5-branching-and-release-strategy.md b/packages/tempo/plan/v4-v5-branching-and-release-strategy.md deleted file mode 100644 index 6ed90607..00000000 --- a/packages/tempo/plan/v4-v5-branching-and-release-strategy.md +++ /dev/null @@ -1,175 +0,0 @@ -# Plan: Tempo v4 & v5 Concurrent Branching, Maintenance, and Release Strategy - -## 1. Executive Summary - -As Tempo prepares for the upcoming **v5.0.0** major milestone (including the `@tempo-dev` scope transition and architecture modernization), the ecosystem requires active concurrent maintenance: -- **v5.x (`main`)**: Active development of major breaking features, modern architecture, and `@tempo-dev` packaging. -- **v4.x (`v4.x` / `maintenance/v4`)**: Long-Term Support (LTS) maintenance for bug fixes, security patches, documentation enhancements, and stable community plugin support. - -This document establishes the official procedures for branch topology, conflict-free realignment, multi-branch development via `git worktree`, backporting workflows, and npm release distribution tags. - ---- - -## 2. Branch Topology & Lifecycle - -``` - v4.5.2 v4.5.3 v4.6.0 (Final minor) -v4.x branch --------o------------o------------o-------------------> (LTS / Maintenance) - \ ^ ^ ^ - (cut point)\ / (cherry-pick backports) / - \ / / -main branch ---o--o-------------------------o----------------------> (v5.0.0 breaking work) - v4.5.1 -``` - -### Branch Roles -1. **`main`**: The primary development branch. - - Prior to v5.0.0 cut: Tracks v4.6.0 finalization. - - After v5.0.0 branch point: Becomes the home for v5 breaking changes. -2. **`v4.x` (or `maintenance/v4`)**: The stable LTS branch. - - Cut from the stable release commit of v4. - - Receives only patch fixes (`4.5.x`), security patches, and doc updates. - - Never receives breaking changes. - ---- - -## 3. Resolving Squash-Merge Divergence (Clean Feature Realignment) - -### The Problem -When feature branches (e.g. `feature/evaluate`) are **squash-merged** onto `main`, Git condenses all intermediate commits into a single new commit hash. If another concurrent branch (e.g. `feature/term-lifecycle-hooks`) branched from an intermediate commit of that feature branch, running a standard `git merge main` causes: -1. False conflicts across files touched by intermediate commits (e.g. `#library` runtime utilities). -2. Re-introduction of already-squashed duplicate commits into the branch history. - -### The Realignment Procedure (Step-by-Step) - -When an in-flight feature branch needs to sync with `main` after a squash-merge: - -1. **Ensure local `main` is fresh**: - ```bash - git checkout main - git pull origin main - ``` - -2. **Create a fresh alignment branch based on latest `main`**: - ```bash - git checkout -b feature/my-feature-aligned main - ``` - -3. **Check out only the specific package/directories modified in the feature branch**: - ```bash - # Replaces only the feature files without touching shared packages - git checkout feature/my-feature-original -- packages/tempo - ``` - -4. **Verify tests and linting**: - ```bash - npm test - npm run lint # or review:agent - ``` - -5. **Commit the clean feature changes**: - ```bash - git commit -m "feat(tempo): " - ``` - -6. **Replace the old branch pointer and push**: - ```bash - git branch -D feature/my-feature-original - git branch -m feature/my-feature-original - git push -u origin feature/my-feature-original --force-with-lease - ``` - ---- - -## 4. Concurrent Multi-Branch Management via `git worktree` - -Switching branches back and forth in a single working directory triggers frequent dependency churn, cache invalidation, and slow `npm install` cycles. Industry standard practice is to use **`git worktree`**. - -### Creating Worktrees for v4 and v5 - -```bash -# From inside the magma repository root: -# 1. Ensure you have the maintenance branch created -git branch v4.x origin/v4.x - -# 2. Add an isolated worktree folder alongside magma -git worktree add ../magma-v4 v4.x -``` - -Your filesystem structure now looks like: -```text -Project/ -├── magma/ # Active on 'main' (v5.0.0 development) -└── magma-v4/ # Active on 'v4.x' (LTS / v4 maintenance) -``` - -### Advantages of Worktrees -- **Independent `node_modules`**: No need to reinstall dependencies when switching between v4 and v5. -- **Side-by-Side IDE Windows**: Keep both versions open simultaneously to compare behavior, run tests, or debug. -- **Shared Git Database**: Commits, branches, and stashes are instantly shared between both directories without extra fetching. - -### Worktree Housekeeping -When a maintenance branch is retired: -```bash -git worktree remove ../magma-v4 -``` - ---- - -## 5. Backporting & Forward-Porting Workflows - -To prevent divergence and maintain stability across active versions: - -### Pattern A: "Fix on Oldest Supported" (Recommended) -1. Fix bugs on the **`v4.x`** maintenance branch first. -2. Verify tests on v4. -3. Switch to `main` (or worktree) and cherry-pick the fix: - ```bash - git checkout main - git cherry-pick -x - ``` - *The `-x` flag automatically records `(cherry picked from commit ...)` in the commit message for auditable traceability.* - -### Pattern B: Forward Backporting with PR Automation -If a bug fix is originally implemented and reviewed on `main`: -1. Merge the PR on `main`. -2. Apply the label `backport:v4` to the GitHub PR. -3. A GitHub Action (e.g. `korthout/backport-action`) automatically cherry-picks the merged commit and opens a PR against the `v4.x` branch. - ---- - -## 6. npm Distribution Tags & Release Safeguards - -To prevent accidentally breaking consumer installs or overwriting production versions, npm distribution tags must be strictly isolated. - -### Phase 1: Pre-v5.0.0 Release (v4 is Production) - -| Package Version | npm Tag | Command | Result | -| :--- | :--- | :--- | :--- | -| **`v4.5.x` / `v4.6.0`** | `latest` (Default) | `npm publish` | Installed by `npm install @magmacomputing/tempo` | -| **`v5.0.0-alpha.x`** | `next` | `npm publish --tag next` | Installed only via `npm install @magmacomputing/tempo@next` | - -### Phase 2: Post-v5.0.0 Release (v5 is Production) - -| Package Version | npm Tag | Command | Result | -| :--- | :--- | :--- | :--- | -| **`v5.x.x`** | `latest` (Default) | `npm publish` | Installed by `npm install @tempo-dev/core` | -| **`v4.x.x` (LTS Patches)** | `legacy` or `v4` | `npm publish --tag legacy` | Installed only via `@magmacomputing/tempo@legacy` | - -> [!CAUTION] -> **Never run bare `npm publish` on a `v4.x` branch after `v5.0.0` is published to `latest`!** Bare `npm publish` defaults to the `latest` dist-tag and would downgrade consumers from v5 back to v4. - -### Release Script Verification Gate -Ensure publishing scripts (in `package.json` or `.bin/publish.mjs`) validate the version number before setting `--tag`: -```javascript -const version = semver.parse(packageJson.version); -const isV4 = semver.major(version) === 4; -const isV5 = semver.major(version) >= 5; - -let distTag = 'latest'; -if (isV4 && v5AlreadyReleased) { - distTag = 'legacy'; -} else if (isV5 && semver.prerelease(version)) { - distTag = 'next'; -} -``` diff --git a/packages/tempo/plan/v5-master-plan.md b/packages/tempo/plan/v5-master-plan.md new file mode 100644 index 00000000..5e3928b3 --- /dev/null +++ b/packages/tempo/plan/v5-master-plan.md @@ -0,0 +1,200 @@ +# Tempo v5.0.0 Master Plan & Phase Roadmap + +## 1. Executive Summary & Vision + +Tempo **v5.0.0** represents the definitive modern milestone for the Tempo date-time engine. Unlike minor releases (`v4.x`), v5 establishes a clean break from legacy and suboptimal API conventions, establishes a dedicated, developer-friendly npm namespace (**`@tempo-js`** with defensive perimeter coverage for **`@tempojs`**), optimizes the core bundle size for greenfield and serverless/edge environments, and introduces reactive signals. + +This Master Plan consolidates all prior RFCs, breaking change analyses, and architectural proposals into a unified, phase-based execution checklist. + +--- + +## 2. Phase-Based Execution Roadmap + +```mermaid +graph TD + P1["Phase 1: Core Modernization & Signals
(PR #110 — In Progress)"] --> P2["Phase 2: Scope & Namespace Defense
(@tempo-js & @tempojs)"] + P2 --> P3["Phase 3: Plugin Ecosystem Modularization
(Dialects Standalone, Core Superpowers)"] + P3 --> P4["Phase 4: Library & Code Standards
(isNonNull, Strict isDefined, Semicolons)"] + P4 --> P5["Phase 5: Multi-Version Docs & AI Context
(VitePress /v4/ & llms.txt)"] + P5 --> P6["Phase 6: Release Engineering & Dual Publishing
(CI/CD, npm Tags, GA Launch)"] +``` + +--- + +### Phase 1: Core Modernization, Deprecations & Signals (PR #110) +*Status: Nearly Complete (Uncommitted working tree / PR review stage)* + +- [x] **`Tempo.now()` Transition to Instance Factory**: + - `Tempo.now()` returns an immutable `Tempo` instance (supports options like `{ timeZone, sphere }`) instead of primitive `bigint` nanoseconds. + - Raw epoch numbers cleanly moved to `Tempo.epoch.ns`, `Tempo.epoch.ms`, `Tempo.epoch.us`, and `Tempo.epoch.ss`. +- [x] **Format Token Rationalization**: + - Deprecate legacy `{ww}` and `{wy}` in favor of canonical ISO `{yow}` and `{woy}`. + - Canonicalize orthogonal `:compact` modifier across parser, format, and explain, completely eliminating legacy fused modifiers (e.g. `{tz:offsetcompact}`). + - Standardize offset sub-components on canonical `:hh`, `:mi`, `:ss`. +- [x] **Signal-Aware Ticker & NTP Architecture**: + - Add reactive signal getters (`ticker.signal`, `Tempo.ticker.signal()`, `Tempo.ntp.signal()`). + - Eliminate circular GC retention in `Finalizer.register` closures using `WeakRef` handles. + - Ensure individual `toSignal()` consumer disposal only detaches that reactive subscription without stopping shared ticker instances. +- [x] **Plugin Cross-Version Compatibility**: + - Split `getRuntime` import in `@magmacomputing/tempo-plugin-dialects` to preserve dual `^4.7.0 || ^5.0.0` peer dependency support. +- [x] **Review Remediation**: + - Resolve all 7 CodeRabbit review findings on PR #110 with localized unit test and monorepo build verification. + +--- + +### Phase 2: Package Scope & Namespace Defense (`@tempo-js` & `@tempojs`) +*Status: Ready to Execute* + +Following the industry precedent established by Vite (`@vitejs/*`), Svelte (`@sveltejs/*`), and Discord (`@discordjs/*`), Tempo v5 will migrate from the corporate `@magmacomputing` prefix to a dedicated, community-facing JavaScript/TypeScript scope: + +- [ ] **Step 1: Claim `@tempo-js` Organization on npm**: + - Claim and initialize the **`@tempo-js`** organization on npm under organization admin. + - Configure 2FA, team permissions, and automated GitHub Actions publishing secrets (`NPM_TOKEN`). +- [ ] **Step 2: File npm Name Dispute for `@tempojs` (Defensive Anti-Squatting)**: + - File a formal npm Name Dispute / transfer request with npm Support for the dormant `@tempojs` scope (abandoned by the Bebop RPC project). + - Once secured, maintain `@tempojs` defensively alongside `@tempo-js` to eliminate typosquatting and supply-chain confusion. +- [ ] **Step 3: Establish Canonical Package Mapping**: + | Current v4 Scope (`@magmacomputing/*`) | Target v5 Scope (`@tempo-js/*`) | Role / Exports | + | :--- | :--- | :--- | + | `@magmacomputing/tempo` | **`@tempo-js/core`** | Fluent engine with subpath exports (`./parse`, `./format`, `./mutate`, `./duration`, `./library`, `./plugin/sdk`) | + | `@magmacomputing/tempo-fns` | **`@tempo-js/fns`** | Standalone functional date math & algorithms | + | `@magmacomputing/tempo-plugin-dialects` | **`@tempo-js/plugin-dialects`** | Moment / Day.js / Luxon / SQL format compatibility | + | `@magmacomputing/tempo-plugin-ticker` | **`@tempo-js/plugin-ticker`** | High-precision reactive scheduler & pulse engine | + | `@magmacomputing/tempo-plugin-ntp` | **`@tempo-js/plugin-ntp`** | Network Time Protocol clock drift synchronization | + | `@magmacomputing/tempo-plugin-ai` | **`@tempo-js/plugin-ai`** | AI calendar reasoning & natural extraction | + | `@magmacomputing/tempo-plugin-geo` | **`@tempo-js/plugin-geo`** | Reverse geocoding & timezone resolution | + | `@magmacomputing/tempo-plugin-holidays` | **`@tempo-js/plugin-holidays`** | International public holidays & business schedules | + | `@magmacomputing/tempo-plugin-celestial`| **`@tempo-js/plugin-celestial`** | Sun/Moon ephemeris, solar events, & tides | + | `@magmacomputing/tempo-plugin-spatial` | **`@tempo-js/plugin-spatial`** | Geofencing, coordinate distance, bearing, velocity | + | `@magmacomputing/tempo-plugin-sync` | **`@tempo-js/plugin-sync`** | High-precision atomic clock & drift correction | + | `@magmacomputing/tempo-plugin-batch` | **`@tempo-js/plugin-batch`** | High-throughput batch date-time processing | + | `@magmacomputing/tempo-plugin-roman` | **`@tempo-js/plugin-roman`** | Roman calendar & consular dating | + | `@magmacomputing/tempo-plugin-snap` | **`@tempo-js/plugin-snap`** | Quantization & temporal snap grids | + +--- + +### Phase 3: Plugin Ecosystem Modularization & Greenfield Optimization +*Status: Planned* + +To ensure Core Tempo remains clean, modern, and unburdened by legacy runtime shims or non-essential domain data, ecosystem plugins are modularized while preserving core signature superpowers: + +- [ ] **Civic vs. Cultural Terms Split (Option B)**: + - **Civic Terms in Core**: Retain `QuarterTerm` (`#quarter`, `#qtr`) and `SeasonTerm` (`#season`) directly in Core Tempo (~2.7 KB minified, ~0.8 KB gzipped). These represent universal, uncontroversial business and calendar concepts used across reporting, fiscal cycles, and scheduling. + - **Cultural & Domain Terms Opt-In (`@tempo-js/std`)**: Decouple `ZodiacTerm` (Western astrology), `EasternTerm` (Chinese zodiac / lunar signs), and `TimelineTerm` (geological/cosmic epochs) from Core's automatic startup loader into `@tempo-js/std` (or `@tempo-js/core/std`). + - *Impact*: Saves **~7.4 KB minified (~2.4 KB gzipped)** from every Core Tempo bundle and completely eliminates enterprise/business skepticism around astrological horoscopes in a core date library. + - *Consumption*: Available on-demand via `import { ZodiacTerm } from '@tempo-js/std'; Tempo.use(ZodiacTerm);` or zero-config `import '@tempo-js/std';`. Serves in documentation as the flagship showcase of Tempo's custom terminology extensibility. +- [ ] **Retain Slick Shorthand Syntax as Core Superpower**: + - Keep intuitive term navigation (`t.set('#qtr.>q1')`, `t.add('#season.>summer')`), directional operators (`>`, `<`, `+`, `-`), and shorthand shifters (`t.set({ mm: '>2', wkd: '>Fri' })`) natively built into Core. + - Evaluation confirmed that saving ~3–4 KB gzipped does not justify fracturing Tempo's signature ergonomics or requiring extra plugin boilerplate for fundamental shorthand. +- [ ] **Standalone Dialects Architecture (`@tempo-js/plugin-dialects`)**: + - Keep legacy format compilers (Moment, Day.js, Luxon, POSIX `strftime`, Go, PHP, Oracle SQL) out of Core Tempo. + - Provide 4-tier consumption: + 1. Zero-config drop-in: `import '@tempo-js/plugin-dialects';` + 2. Explicit registration: `Tempo.use(DialectsPlugin);` + 3. Granular single-dialect imports: `import '@tempo-js/plugin-dialects/luxon';` + 4. Migration AST introspection: `import { explain, convert } from '@tempo-js/plugin-dialects/migrate';` +- [ ] **Reclaim `{ww}` for Calendar Week**: + - Free `{ww}` from being an ISO week alias; reassign it to represent calendar week of year (Jan 1 basis, matching Oracle SQL `WW`). + - Add `{wom}` (week of month, `1`–`5`). + +--- + +### Phase 4: Library & Code Standards Harmonization +*Status: Planned* + +- [ ] **Type-Guard Semantics Correction (`isNonNull` vs. Strict `isDefined`)**: + - *Problem*: In v4, `isDefined(null)` returned `false`, trapping `null` in a semantic void where it was neither defined nor undefined. + - *Step 1*: Introduce `isNonNull(val): val is NonNullable` in `@magmacomputing/library`. + - *Step 2*: Perform monorepo sweep migrating existing call sites from `isDefined` to `isNonNull` to ensure 100% behavioral preservation. + - *Step 3*: Redefine `isDefined(val): val is Exclude` (`val !== undefined`), creating strict logical symmetry: `!isDefined(x) <=> isUndefined(x)`. +- [ ] **ECMAScript Standards Compliance: Repository-Wide Semicolon Policy**: + - Adopt explicit statement termination across all monorepo TypeScript files (`semi: true`) per ECMA-262 § 16.2.2. + - Add standard semicolons to VitePress theme files to eliminate one-off style anomalies. + - Configure automated linter/formatter rule (`biome.json` / `.prettierrc`). + +--- + +### Phase 5: Multi-Version Docs, Playground & AI Context (`llms.txt`) +*Status: Planned* + +- [ ] **Archival `/v4/` Route Snapshotting in VitePress**: + - Freeze final `v4.7.0` documentation under `/v4/` route in VitePress. + - Deploy documentation strictly from `main` to prevent branch deployment collisions on GitHub Pages. + - Add top-level version selector in VitePress navbar: + ```text + [ v5.0.0 (latest) ▼ ] + • v5.0.0 (latest) -> / + • v4.7.0 (LTS) -> /v4/ + ``` +- [ ] **Version-Segregated AI Context Files (`llms.txt`)**: + - Prevent RAG context contamination between v4 (primitive timestamps, `@magmacomputing`) and v5 (instance factories, `@tempo-js`). + - Route layout: + ```text + tempo.dev/ + ├── llms.txt <-- v5 AI Index & Quick Reference (Latest) + ├── llms-full.txt <-- v5 Complete Concatenated Context + └── v4/ + ├── llms.txt <-- v4 AI Index & Quick Reference (Frozen LTS) + └── llms-full.txt <-- v4 Complete Concatenated Context (Frozen LTS) + ``` + - Prominent warning banners on all `/v4/` AI bundles directing modern developers to v5. +- [ ] **Update Core Documentation**: + - Update all code snippets in `packages/tempo/doc/` to use `@tempo-js/core`. + - Provide comprehensive **v4 $\rightarrow$ v5 Migration Guide**. + +--- + +### Phase 6: Release Engineering & Dual-Publishing Pipeline +*Status: Planned* + +- [ ] **Automated Dual-Scope Publishing Pipeline (`publish.yml`)**: + - Build and publish canonical packages under `@tempo-js/*`. + - Dual-publish backward-compatibility stubs under `@magmacomputing/*` that re-export `@tempo-js/*` with deprecation notices. +- [ ] **npm Distribution Tag Architecture**: + | Package Scope | Target Version | npm dist-tag | Target Audience | + | :--- | :--- | :--- | :--- | + | `@tempo-js/core` | `v5.0.0-rc.x` | `next` | Early adopters & release candidate testing | + | `@tempo-js/core` | `v5.0.0` (GA) | `latest` | All modern greenfield and upgraded v5 installations | + | `@magmacomputing/tempo` | `v4.7.x` | `latest-v4` (or `legacy`) | Long-term support for existing v4 codebases | + | `@magmacomputing/tempo` | `v5.0.0` | `latest` | Dual-published bridge re-exporting `@tempo-js/core` | +- [ ] **Release Milestones**: + - `5.0.0-alpha.x`: Internal integration. + - `5.0.0-rc.x`: Public release candidates and ecosystem testing. + - `5.0.0`: Official General Availability (GA). + +--- + +## 3. Future Horizons / Exploratory Proposals (Post-v5.0 GA) + +For features and architectural investigations targeted beyond the initial v5.0 General Availability release, refer to active exploratory RFCs: + +* **[Signals in Core Tempo](file:///home/michael/Project/magma/packages/tempo/plan/signals-core-discussion.md)** (`signals-core-discussion.md`): + Explores deep reactive integrations for future minor releases (v5.1+): + 1. `Tempo.live()` / `Tempo.clock()` (fine-grained continuous live clocks for UI). + 2. `tempo.relativeSignal()` (adaptive reactive relative time strings like *"3 minutes ago"* that self-adjust update frequencies). + 3. `interval.toSignal()` (reactive temporal window and progression tracking). + 4. `Tempo.locale` reactive signal (dynamic locale/theme propagation across UI signal graphs). + +--- + +## 4. Operational Appendix: Git Squash-Merge Realignment Procedure + +When long-running feature branches diverge after squash-merges onto `main`, follow this standard procedure to synchronize without false conflict churn: + +1. **Ensure local `main` is up to date**: + ```bash + git checkout main + git pull origin main + ``` +2. **Rebase feature branch using `--onto`**: + Identify the base commit where the feature branch originally split from the previous feature branch, and rebase onto current `main`: + ```bash + git checkout feature/my-branch + git rebase --onto main feature/my-branch + ``` +3. **Verify and Force-Push**: + Run local test suites to confirm clean alignment: + ```bash + npm test + git push origin feature/my-branch --force-with-lease + ``` diff --git a/packages/tempo/plan/v5-release-considerations.md b/packages/tempo/plan/v5-release-considerations.md deleted file mode 100644 index 8c2e7a81..00000000 --- a/packages/tempo/plan/v5-release-considerations.md +++ /dev/null @@ -1,635 +0,0 @@ -# Plan: Tempo v5.0.0 Release Considerations & Breaking Changes - -## 1. Overview - -As part of the upcoming **v5.0.0** major milestone, several key architectural and developer-experience improvements are being planned. Unlike minor releases (`v4.x`), v5 allows clean breaks from legacy or suboptimal API choices without backward-compatibility compromises. - -This document tracks breaking changes, architectural rationales, migration pathways, and blast-radius analyses slated for v5.0.0. - ---- - -## 2. Breaking Change: `Tempo.now()` Transition to Instance Factory - -### Classification -* **Type:** Breaking API Change (Not a soft deprecation; clean replacement in v5.0.0). -* **Target Milestone:** `v5.0.0` -* **Affected API:** `Tempo.now()` - ---- - -### Behavior Comparison - -| Aspect | Current Behavior (`v4.x`) | New Behavior (`v5.0.0`) | -| :--- | :--- | :--- | -| **Return Type** | `bigint` (nanoseconds) or `number` (if unit specified) | `Tempo` instance | -| **Signature** | `Tempo.now(unit?: 'ss' \| 'ms' \| 'us' \| 'ns')` | `Tempo.now(options?: t.Options)` | -| **Fluent Chaining** | ❌ Throws `TypeError` on `.format()`, `.add()`, etc. | Fully chainable (`Tempo.now().format(...)`) | -| **Raw Timestamp Path** | `Tempo.now()` or `Tempo.epoch.ns` | [`Tempo.epoch.ns`](file:///home/michael/Project/magma/packages/tempo/src/tempo.class.ts#L1370) (and `.ms`, `.us`, `.ss`) | - ---- - -### Architectural & Design Reasoning - -1. **Modern Date Library Expectations (Luxon / Temporal Parity)** - - In modern date libraries such as Luxon (`DateTime.now()`), developers expect `.now()` to produce a fluent date-time object representing the current moment. - - Developers frequently write `Tempo.now().format('{yyyy}-{mm}-{dd}')` or `Tempo.now().add({ days: 1 })`. In v4.x, returning a primitive `bigint` causes a runtime `TypeError: Tempo.now(...).format is not a function`. - -2. **Elimination of `Date.now()` Semantic Confusion** - - While native JavaScript's `Date.now()` returns an epoch timestamp, it returns **milliseconds as a `number`**. - - Returning **nanoseconds as a `bigint`** in `Tempo.now()` creates friction: developers expecting `Date.now()` parity often run into unit mismatches (nanoseconds vs milliseconds) or JSON serialization errors (`TypeError: Do not know how to serialize a BigInt`). - -3. **Complete Redundancy with `Tempo.epoch`** - - Tempo already provides a dedicated, unit-safe static property: - - `Tempo.epoch.ns` (`bigint`) - - `Tempo.epoch.ms` (`number`) - - `Tempo.epoch.us` (`number`) - - `Tempo.epoch.ss` (`number`) - - Having primitives under `Tempo.epoch` cleanly separates raw telemetry numbers from date-time instance creation, making `Tempo.now()` free to serve as the instance factory. - -4. **First-Class Factory Method with Options Support** - - Developers who prefer functional/factory syntax over `new Tempo()` gain a clean entry point. - - Accepting `options?: t.Options` enables instant configuration (e.g. timezone or hemisphere) at construction: - ```typescript - // Current time in UTC - const utcNow = Tempo.now({ timeZone: 'UTC' }); - - // Current time with custom configuration - const sydneyNow = Tempo.now({ timeZone: 'Australia/Sydney', sphere: 'south' }); - ``` - ---- - -### Migration Path - -#### For Consumers Needing Epoch Timestamps: -```typescript -// Before (v4.x) -const epochNano = Tempo.now(); -const epochMs = Tempo.now('ms'); - -// After (v5.0.0) -const epochNano = Tempo.epoch.ns; -const epochMs = Tempo.epoch.ms; -``` - -#### For Consumers Needing the Current Moment: -```typescript -// v5.0.0 -const current = Tempo.now(); -const formatted = Tempo.now().format('{hh}:{mi}'); -``` - ---- - -### Blast-Radius Analysis - -#### Monorepo Internal Call Sites -1. **Internal Helper (`tempo.class.ts`):** - - [`packages/tempo/src/tempo.class.ts:L1380`](file:///home/michael/Project/magma/packages/tempo/src/tempo.class.ts#L1380): - ```typescript - // Update: - static get instant() { return Temporal.Instant.fromEpochNanoseconds(Tempo.epoch.ns); } - ``` -2. **Community Plugins (`AtomicClock.ts`):** - - [`packages/plugins/sync/src/AtomicClock.ts:L68,L100`](file:///home/michael/Project/magma/packages/plugins/sync/src/AtomicClock.ts#L68): - ```typescript - // Update: - const nowNano = Tempo.epoch.ns; - ``` -3. **Core Test Suites:** - - [`packages/tempo/test/core/static.methods.test.ts:L228-L248`](file:///home/michael/Project/magma/packages/tempo/test/core/static.methods.test.ts#L228-L248): - - Update test to verify `Tempo.now()` returns `instanceof Tempo`. - - Verify `Tempo.now({ timeZone: 'UTC' })` configures the instance timezone. - - Move primitive unit assertions (`'bigint'`, `'ms'`, magnitude comparisons) to `Tempo.epoch`. -4. **Documentation Alignment:** - - [`packages/tempo/doc/2-core-concepts/tempo.interval.md:L41,L85`](file:///home/michael/Project/magma/packages/tempo/doc/2-core-concepts/tempo.interval.md#L41): - Existing examples like `new Tempo.Interval(Tempo.now(), null)` and `businessHours.contains(Tempo.now())` were already written assuming `Tempo.now()` yields an instance; with this change, they become valid and idiomatic. - -#### External Consumer Impact -* **Severity:** Low to Moderate. -* **Risk Mitigation:** - - Standard SemVer major version bump (`5.0.0`). - - Clear entry in CHANGELOG and v5 Migration Guide directing timestamp users to `Tempo.epoch.ns`. - - TypeScript compilation immediately catches type mismatches where `bigint` arithmetic was performed directly on `Tempo.now()`. - ---- - -## 3. npm Distribution & Scope Isolation Strategy - -### Independent Package Namespaces -Because v5 introduces the `@tempo-dev` scope transition (anchored by `@tempo-dev/core`), npm distribution tags are **completely isolated per-package**: -* `npm install @magmacomputing/tempo@latest` installs the latest stable **v4** release. -* `npm install @tempo-dev/core@latest` installs the latest stable **v5** release. - -Neither package name conflicts with or overwrites the other on the npm registry. - -### Automated Dist-Tag Resolution (`publish.yml`) -The [`.github/workflows/publish.yml`](file:///.github/workflows/publish.yml) workflow provides an optional `tag` input in `workflow_dispatch` (`auto | latest | next | legacy`, defaulting to `auto`): -1. **Prerelease detection:** Versions containing pre-release identifiers (e.g. `5.0.0-alpha.1`) automatically publish with `--tag next`. -2. **Major version precedence:** When publishing a `v4.x` patch from `maintenance/v4`: - - While v4 is the highest published major on npm, it publishes with `--tag latest`. - - Once a package has published a version with a higher major (e.g. `>= 5.0.0`), subsequent v4 releases automatically publish with `--tag legacy`. -3. **Manual Override:** Developers can explicitly choose a tag (e.g. `legacy`, `next`, `latest`) at execution time in GitHub Actions. Dist-tags are validated to ensure they are URL-safe and cannot be interpreted by npm as a SemVer version or range (such as strings starting with digits or 'v'). - ---- - -## 4. Documentation & GitHub Pages Multi-Version Strategy - -### The Single-Artifact Constraint -GitHub Pages deploys a single build artifact per repository. If pushes to `maintenance/v4` triggered documentation builds, they would overwrite the active documentation deployed from `main`. - -### The Multi-Version Architecture -1. **Deployment Branch Isolation:** - - Keep [`deploy-docs.yml`](file:///.github/workflows/deploy-docs.yml) strictly triggered by pushes to `main`. Pushes to `maintenance/v4` will not trigger live Pages deployments. -2. **Archival `/v4/` Route Snapshotting:** - - The final `v4.6.0` documentation build will be preserved under a `/v4/` route within VitePress. - - The VitePress navigation bar will provide a top-level version switcher: - ```text - [ v5.0.0 (latest) ▼ ] - • v5.0.0 (latest) -> / - • v4.6.0 (LTS) -> /v4/ - ``` -3. **Domain Isolation (`tempo.dev`):** - - As `@tempo-dev` matures, `tempo.dev` will serve the primary v5 documentation and interactive playground, while `magmacomputing.github.io/magma/` can continue serving the legacy v4 docs or redirect seamlessly. - ---- - -## 5. Dialects Strategy: Standalone Plugin with Zero-Config Opt-In Separation (`@tempo-dev/plugin-dialects`) - -### Strategic Context: Preserving Core Purity Without the "Greenfield Tax" -After deep architectural evaluation, Tempo v5 will **not** embed the dialects engine directly into Core Tempo. Instead, Dialects will remain a dedicated, first-class standalone plugin published as `@tempo-dev/plugin-dialects` (with `@magmacomputing/tempo-plugin-dialects` maintained for backwards compatibility). - -#### Why Dialects Remain Standalone -1. **No "Greenfield Tax" on Modern Codebases**: - Tempo's native braced syntax (`{YYYY}-{MM}-{DD}`, `{HH}:{mm}:{ss}`) is modern, unambiguous, and fast. Embedding legacy layout compilers and regex tables for Oracle `TO_CHAR`, PHP `date()`, and Go reference formats into core would penalize new greenfield projects that never need legacy ecosystem shims. -2. **Edge & Serverless Runtime Efficiency**: - In modern edge isolates (Cloudflare Workers, V8 isolates, AWS Lambda@Edge), bundle size and cold-start execution times are critical. Keeping dialects opt-in guarantees that Core Tempo remains hyper-lean and competitive with ultra-light alternatives. -3. **Separation of Core Identity vs. Migration Bridging**: - Core Tempo's mission is "Humanizing Temporal" through clean, immutable primitives. Dialects serve primarily as a transition bridge for teams migrating from **Moment.js, Day.js, Luxon, date-fns, and POSIX `strftime`**. A standalone plugin honors both concerns without conflating them. - ---- - -### The "Zero-Config Import, Opt-In Separation" Architecture -To eliminate onboarding friction while keeping Core Tempo completely pristine, `@tempo-dev/plugin-dialects` implements a 4-tier modular consumption model: - -#### 1. Zero-Config Drop-In (Side-Effect Auto-Registration) -For maximum developer ergonomic convenience during migrations, a simple side-effect import automatically mounts shims and registers all 5 compilers onto global `Tempo` and instance prototypes without configuration boilerplate: - -```typescript -import { Tempo } from '@tempo-dev/core'; -import '@tempo-dev/plugin-dialects'; // Zero-config drop-in - -// Immediately available across the application: -const t = Tempo.now(); - -// 1. Luxon / Moment convenience shims -t.toFormat('yyyy-MM-dd HH:mm:ss'); -Tempo.fromFormat('2026-10-15', 'YYYY-MM-DD'); - -// 2. Direct dialect instance methods -t.dialects.sql('YYYY-MM-DD HH24:MI:SS'); // Oracle / SQL TO_CHAR -t.dialects.php('Y-m-d H:i:s'); // PHP date() -t.dialects.go('2006-01-02 15:04:05'); // Go reference layout -``` - -#### 2. Explicit Registration for Scoped / Containerized Lifecycles -For enterprise applications, micro-frontends, or environments enforcing strict dependency injection without global prototype augmentation: - -```typescript -import { Tempo } from '@tempo-dev/core'; -import { DialectsPlugin } from '@tempo-dev/plugin-dialects'; - -Tempo.use(DialectsPlugin); -``` - -#### 3. Granular Sub-Dialect Imports (Maximum Tree-Shaking) -Developers migrating from a single ecosystem (e.g., only Luxon or only Moment) can import specific compilers, incurring only ~1–2 KB rather than the full dialect suite: - -```typescript -// Only imports and registers the LDML compiler and .toFormat() shim: -import '@tempo-dev/plugin-dialects/luxon'; -``` - -#### 4. Introspection & Migration Tooling Separation (`/migrate`) -Developer introspection and egress utilities are kept in a dedicated subpath to avoid bundling ~28 KB minified (~8.4 KB gzipped) of human-readable AST tokens and egress translation dictionaries into production runtimes: - -```typescript -import { explain, exportDialect, convert } from '@tempo-dev/plugin-dialects/migrate'; - -// AST breakdown: -const breakdown = explain('YYYY-MM-DD HH:mm:ss', 'moment'); - -// Cross-dialect transpilation: -const ldmlMask = convert('YYYY-MM-DD', 'moment', 'ldml'); -``` - ---- - -### Monorepo Architecture & Long-Term Support -* **Workspace Status**: `packages/plugins/dialects/` remains an active, first-class workspace package in the monorepo and will **not** be deprecated upon v5. -* **Dual Publishing**: The package will be dual-published under `@tempo-dev/plugin-dialects` and `@magmacomputing/tempo-plugin-dialects`. -* **TypeScript Types**: Automated type augmentation via `declare module '@tempo-dev/core'` ensures seamless autocomplete on `t.dialects`, `t.toFormat()`, and `Tempo.fromFormat()`. - ---- - -## 6. Core Byte-Budget Optimization: Extracting Low-Use Features - -### Strategic Context: Maximizing Core Leanliness -Because format dialects will remain a standalone plugin rather than being embedded into Core Tempo, Core Tempo does not need to absorb any compiler or regex overhead. By additionally auditing and extracting niche, high-complexity features into opt-in plugins, Tempo v5 achieves a **substantial net-negative byte impact** compared to v4. - ---- - -### Prime Candidate: The Slick Shorthand Engine (`@tempo-dev/plugin-slick`) - -#### What the Slick Engine Encompasses -The "Slick" engine is a domain-specific mini-language inside Tempo designed for navigating and shifting across custom Terminology cycles: -1. **String Navigation Shorthand**: Shifting to dynamic term boundaries via string expressions (`t.set('#qtr.>q1')`, `t.add('#timeOfDay.>afternoon')`, `#zodiac.<`). -2. **Directional Operator Grammar**: Parsing and executing momentum modifiers (`>`, `<`, `>=`, `<=`, `+`, `-`, `this`). -3. **Cycle-Preservation Mathematics**: Calculating relative percentage offsets (e.g. remaining 45% of the way through an uneven cycle when shifting to the next Term). -4. **Slick Object Mutation Shifters**: Value-level shorthand in `.set()` and `.add()` (e.g. `t.set({ mm: '>2', wkd: '>Fri' })`). -5. **Core Footprint**: - - Complex parser regexes in [`support.default.ts`](file:///home/michael/Project/magma/packages/tempo/src/support/support.default.ts) (`Match.slick`, `Match.slickValue`, `Match.shorthand`, `SLICK_KEYS`). - - Extensive branching in [`engine.term.ts`](file:///home/michael/Project/magma/packages/tempo/src/engine/engine.term.ts#L134-L245) (~300+ lines). - - Dedicated mutation handlers in [`module.mutate.ts`](file:///home/michael/Project/magma/packages/tempo/src/module/module.mutate.ts#L120-L175). - - Early normalizer checks in [`engine.normalizer.ts`](file:///home/michael/Project/magma/packages/tempo/src/engine/engine.normalizer.ts#L131). - - **Estimated Core Size:** ~8–12 KB minified. - -#### Proposed Extraction to Plugin -* **New Package:** `@tempo-dev/plugin-slick` (or `@magmacomputing/tempo-plugin-slick`). -* **Consumption Model:** - ```typescript - import { Tempo } from '@magmacomputing/tempo'; - import { SlickPlugin } from '@tempo-dev/plugin-slick'; - - Tempo.use(SlickPlugin); - - // Enables string shorthand and relative cycle preservation: - t.set('#qtr.>q1'); - t.set({ wkd: '>Fri' }); - ``` -* **Net Byte Savings**: - - Extracting Slick saves **~8–12 KB**. - - Dialects remains a standalone plugin (**0 KB added to Core**). - - **Net Result for Core Tempo v5:** **~8–12 KB reduction in total package bundle size**, with significantly simpler core mutation and term resolution code paths. - ---- - -### Additional Candidates for Byte-Savings Auditing in v5 - -| Feature Area | Current Location | Rationale for Extraction | Proposed Destination | -| :--- | :--- | :--- | :--- | -| **Astrological Terms** | `src/term/term.zodiac.ts` | Astrological signs (`#zodiac.aries`) are bundled in standard Tempo. Enterprise/business users rarely require horoscope cycles. | Move to `@magmacomputing/tempo-plugin-celestial` or `@tempo-dev/plugin-astrology`. | -| **Macro Epochs / Timelines** | `src/term/term.timeline.ts` | Geological and cosmological epochs (`#timeline.cenozoic`) are niche domain terms. | Move to community plugin `@tempo-dev/plugin-geology`. | -| **Complex Bidi Isolation** | `international.library.ts` | Bi-directional text isolation wrapper (`isolateBidi`) for formatting. | Audit whether standard `Intl` options suffice without custom wrappers. | - ---- - -## 7. AI & LLM Context Architecture (`llms.txt` & `llms-full.txt`) Across Multi-Version Builds - -### The Risk: Context Contamination & RAG Hallucinations -When a documentation build hosts both the latest v5 docs at root `/` and archived legacy docs at `/v4/`, naive documentation bundling presents a severe hazard for automated AI tooling: -1. **Contradictory Paradigm Ingestion**: - If the full-text bundle ([`llms-full.txt`](file:///home/michael/Project/magma/packages/tempo/public/llms-full.txt)) recursively merges all Markdown documents across the site, an AI model (in Cursor, VS Code / GitHub Copilot, Antigravity, Claude, or ChatGPT) ingests conflicting rules side-by-side: - - **`Tempo.now()`**: Returns a `bigint` nanosecond timestamp in v4 vs. a `Tempo` instance in v5. - - **Package Scopes**: `@magmacomputing/tempo` in v4 vs. `@tempo-dev/core` in v5. - - **Dialects**: Legacy plugin setup with manual registration in v4 vs. first-class standalone plugin with zero-config drop-in import (`import '@tempo-dev/plugin-dialects'`) in v5. - - **Slick Syntax**: Built-in core grammar (`#qtr.>q1`, `{ mm: '>2' }`) in v4 vs. external `@tempo-dev/plugin-slick` in v5. -2. **Degraded AI Output Quality**: - An AI assistant ingesting mixed-version documentation cannot reliably deduce which paradigm the developer's project targets, leading to subtle bugs, broken imports, and hallucinated hybrid syntax. - ---- - -### Segmented Route Architecture - -To maintain crystal-clear context boundaries for AI assistants, the documentation build must provide dedicated, version-segregated files: - -```text -tempo.dev/ -├── llms.txt <-- v5 AI Index & Quick Reference (Latest) -├── llms-full.txt <-- v5 Complete Concatenated Documentation Set -└── v4/ - ├── llms.txt <-- v4 AI Index & Quick Reference (Frozen LTS) - └── llms-full.txt <-- v4 Complete Concatenated Documentation Set (Frozen LTS) -``` - -#### 1. Root Files (`/llms.txt` and `/llms-full.txt`) -* **Target Audience**: New projects and teams upgrading to v5. -* **Scope**: Exclusively documents v5 syntax, `@tempo-dev/core` imports, `Tempo.now()` as an instance factory, and first-class standalone plugins (such as `@tempo-dev/plugin-dialects`). -* **Header Metadata**: - ```markdown - # Tempo: Immutable Date-Time Engine & AI Syntax Rules (v5.x - Latest) - > Targeted for @tempo-dev/core v5.x. For legacy v4 documentation, refer to: - > https://tempo.dev/v4/llms.txt - ``` -* **Links**: All markdown documentation URLs resolve to root paths (e.g. `https://tempo.dev/1-getting-started/...`). - -#### 2. Archived Route Files (`/v4/llms.txt` and `/v4/llms-full.txt`) -* **Target Audience**: Teams maintaining legacy v4 codebases. -* **Scope**: A frozen snapshot of the final `v4.6.0` documentation, preserving `@magmacomputing/tempo` package names, `bigint` timestamps, and separate dialect plugin instructions. -* **Prominent Warning Headline & Banner**: - Anyone browsing directly to the `/v4/` sub-path—as well as any AI crawler or IDE ingesting `/v4/llms.txt` or `/v4/llms-full.txt` directly—must immediately encounter an unmissable headline and warning banner establishing the legacy context before any API documentation appears: - ```markdown - # ⚠️ ARCHIVED DOCUMENTATION: Tempo v4.x (v4.6.0 LTS) - - > [!WARNING] - > **YOU ARE VIEWING ARCHIVED DOCUMENTATION FOR TEMPO v4.x (`@magmacomputing/tempo`).** - > If you are starting a new project or maintaining modern code, use **Tempo v5.x (`@tempo-dev/core`)**: - > - **v5 AI Rules & Index:** https://tempo.dev/llms.txt - > - **v5 Full Documentation Context:** https://tempo.dev/llms-full.txt - > - **v5 Web Documentation:** https://tempo.dev/ - > - > **Key Breaking Differences in this v4.x Archive:** - > 1. `Tempo.now()` returns primitive `bigint` nanoseconds (in v5, `Tempo.now()` returns an immutable `Tempo` instance). - > 2. Package namespace is `@magmacomputing/tempo` (in v5, core is `@tempo-dev/core`). - > 3. Dialects require external plugin `@magmacomputing/tempo-plugin-dialects` (in v5, streamlined via `@tempo-dev/plugin-dialects` zero-config import). - > 4. Slick shorthand syntax (`#qtr.>q1`) is built-in (in v5, extracted to `@tempo-dev/plugin-slick`). - ``` -* **Full-Text Bundle Headline (`/v4/llms-full.txt`)**: - The concatenated archive must also lead with this banner before concatenating any legacy markdown documents, ensuring RAG chunks at the document root prominently reflect the v4 boundary. -* **Links**: All markdown documentation URLs in `/v4/` resolve to preserved `/v4/` paths (e.g. `https://tempo.dev/v4/1-getting-started/...`). - ---- - -### Build Pipeline Updates ([`generate-llms-txt.mjs`](file:///home/michael/Project/magma/packages/tempo/bin/generate-llms-txt.mjs)) - -1. **Path Filtering in Doc Crawlers**: - The recursive file collector in [`generate-llms-txt.mjs`](file:///home/michael/Project/magma/packages/tempo/bin/generate-llms-txt.mjs#L11-L23) must filter out archival and internal directories: - ```javascript - const IGNORED_DIRS = new Set(['v4', 'plan', 'archive', 'drafts']); - - async function getMarkdownFiles(dir) { - const entries = await readdir(dir, { withFileTypes: true }); - let files = []; - for (const entry of entries) { - if (entry.isDirectory() && !IGNORED_DIRS.has(entry.name)) { - files = files.concat(await getMarkdownFiles(join(dir, entry.name))); - } else if (entry.isFile() && entry.name.endsWith('.md')) { - files.push(join(dir, entry.name)); - } - } - return files.sort(); - } - ``` -2. **Archival Snapshot Generation**: - - As part of the v5 branching / release cut, the existing `public/llms.txt` and generated `public/llms-full.txt` from `v4.6.0` will be frozen into `public/v4/llms.txt` and `public/v4/llms-full.txt`. - - The VitePress build will copy the `/public` directory assets directly into the distribution output root, ensuring `/v4/llms.txt` is served under the `/v4/` route without additional server configuration. - ---- - -### IDE Prompting & Rule Configuration Guidance - -Documentation and developer onboarding guides should instruct users on how to configure their AI tooling according to project version: - -| Target Version | Recommended Ingestion URL | IDE Rule / Prompt Snippet | -| :--- | :--- | :--- | -| **Tempo v5.x (Latest)** | `https://tempo.dev/llms.txt` | `@https://tempo.dev/llms.txt Use modern Tempo v5 syntax with @tempo-dev/core` | -| **Tempo v4.x (Legacy LTS)** | `https://tempo.dev/v4/llms.txt` | `@https://tempo.dev/v4/llms.txt Use legacy Tempo v4 syntax with @magmacomputing/tempo` | - ---- - -## 7. Format Token Architecture: Revisit and Rationalize `{tz}` & Remove Fused Modifiers - -### Classification -* **Type:** Architectural Rationalization & Deprecation of Fused Modifiers. -* **Target Milestone:** `v5.0.0` -* **Affected API:** Format engine `{tz:...}` token resolution (`packages/tempo/src/module/module.format.ts`) - ---- - -### Problem Statement & Architectural Flaws in `v4.x` - -1. **Violation of Orthogonal Modifier Chaining (Fused Words)**: - - In early `v4.x`, concatenated modifier keywords like `{tz:offsetcompact}` and `{tz:offsetshort}` were introduced. - - Fused keywords violate Tempo's core design philosophy: **independent, orthogonal modifier composition** (e.g., `{token:mod1:mod2:...}`). - - Having both `{tz:offset:compact}` and `{tz:offsetcompact}` creates cognitive friction, redundant switch branches in the format engine, and inconsistent user expectations. - -2. **Inconsistent Component Token Naming**: - - Throughout Tempo Core, hour, minute, and second time components are standardized on `{hh}`, `{mi}`, and `{ss}` (`{mm}` is reserved exclusively for month numbers). - - Early implementations of offset sub-components loosely allowed `:mm` and `:sec`. This conflicts with Tempo's standard time tokens. - -3. **Ad-Hoc LDML Shorthand Pollution (`{tz:z}`, `{tz:zz}`, `{tz:zzz}`)**: - - Single-letter pseudo-modifiers borrowed from LDML UTS #35 (`z`, `zz`, `zzz`, `zzzz`) were grafted directly into `{tz}` handling in Core. - - This creates syntactic ambiguity and collisions: for example, `:z` as an LDML shorthand meant "short offset", while in ISO-8601 / RFC-3339 `:z` means "emit 'Z' if UTC". - - External dialect conventions belong in `@magmacomputing/tempo-plugin-dialects`, while native Tempo Core tokens must remain clean, explicit, and self-documenting. - ---- - -### Planned Architecture for `v5.0.0` - -#### 1. Canonical Base Token & Roles -* `{tz}` strictly represents the time zone identifier or localized name: - * `{tz}` → IANA time zone identifier (e.g. `'Australia/Sydney'`, `'UTC'`). - * `{tz:short}` → Short localized time zone abbreviation (e.g. `'AEST'`). - * `{tz:long}` / `{tz:name}` → Full localized time zone name (e.g. `'Australian Eastern Standard Time'`). - -#### 2. Orthogonal Composition for Offsets (`{tz:offset:...}`) -All numeric time zone offsets are rooted in the single `:offset` modifier, with fully orthogonal chained sub-modifiers: - -| Sub-Modifier | Category | Role | Example Output | -| :--- | :--- | :--- | :--- | -| **(none)** | Default | Full standard ISO-8601 offset (`±HH:MM`) | `+10:00`, `-05:00`, `+00:00` | -| **`:hh`** | Component | Signed hour component only (`±HH`) | `+10`, `-05`, `+00` | -| **`:mi`** | Component | Unsigned minute component only (`MM`) | `00`, `30`, `45` | -| **`:ss`** | Component | Include seconds component (`±HH:MM:SS`) | `+10:00:00`, `+05:30:00` | -| **`:compact`**| Formatting | Strip colon separators | `+1000`, `+100000` | -| **`:short`** | Formatting | Omit `:00` when minutes and seconds are zero | `+10` (if `+10:00`), `+10:30` | -| **`:z`** | Indicator | Emit `'Z'` when UTC, else standard offset | `'Z'` (if `+00:00`), else `+10:00` | - -#### 3. Seamless Chained Composition in v5 -Developers can compose these modifiers orthogonally in any logical combination: -```typescript -t.format('{tz:offset}'); // "+10:00" -t.format('{tz:offset:compact}'); // "+1000" (replaces legacy {tz:offsetcompact}) -t.format('{tz:offset:short}'); // "+10" (replaces legacy {tz:offsetshort}) -t.format('{tz:offset:ss}'); // "+10:00:00" (replaces legacy {tz:offset:sec}) -t.format('{tz:offset:compact:ss}'); // "+100000" -t.format('{tz:offset:z}'); // "Z" (if UTC) or "+10:00" -t.format('{tz:offset:compact:z}'); // "Z" (if UTC) or "+1000" -t.format('{tz:offset:short:z}'); // "Z" (if UTC) or "+10" -t.format('{tz:offset:compact:ss:z}');// "Z" (if UTC) or "+100000" -``` - ---- - -### Removal & Migration Pathway for v5.0.0 - -1. **Remove Fused Modifier Words**: - - `offsetcompact` → Migrate to `{tz:offset:compact}`. - - `offsetshort` → Migrate to `{tz:offset:short}`. -2. **Remove Raw LDML Shorthands from Core**: - - `{tz:z}` → Migrate to `{tz:offset:short}`. - - `{tz:zz}` → Migrate to `{tz:offset}`. - - `{tz:zzz}` → Migrate to `{tz:offset:compact}`. - - Codebases requiring raw LDML masks (`z`, `ZZ`, `ZZZZZ`) use `@magmacomputing/tempo-plugin-dialects`. -3. **Deprecate Sub-Modifier Aliases**: - - `:sec` → Normalized to canonical `:ss`. - - `:mm` (in offset context) → Normalized to canonical `:mi` to eliminate confusion with month `{mm}`. - ---- - -## 8. Week Token Architecture: Formalizing `{woy}` (ISO Week) and Reclaiming `{ww}` for Calendar Week - -### Classification -* **Type:** Semantic Reassignment of Legacy Token Alias & Getter Cleanup. -* **Target Milestone:** `v5.0.0` -* **Affected API:** `{ww}` format token and `t.ww` instance getter. - ---- - -### Problem Statement & Architectural Flaws in `v4.x` - -1. **Redundant Aliasing of ISO Week in v4**: - - In `v4.x`, `{woy}`, `{wy}`, and `{ww}` all point to the same ISO 8601 week calculation (`getISOWeekOfYear`). - - The instance getter `t.ww` was already deprecated in `tempo.class.ts` with the notice: - `@deprecated Use woy (Tempo canonical) or zdt.weekOfYear instead. To be removed in v5.0.0.` -2. **Missing Native Token for Calendar Week (Jan 1 Basis)**: - - Non-ISO database engines (such as Oracle SQL `WW`) define week of year where Week 1 begins on January 1st and ends on January 7th (`Math.ceil(doy / 7)`). - - In v4, this is temporarily provided via `{woy:cal}` with a deprecation notice. - ---- - -### Planned Architecture for `v5.0.0` - -| Token / API | Role in `v4.x` | Role in `v5.0.0` | -| :--- | :--- | :--- | -| **`{woy}`** | Canonical ISO Week of Year (`01`–`53`) | Canonical ISO Week of Year (`01`–`53`) | -| **`t.woy`** | Canonical ISO Week instance getter | Canonical ISO Week instance getter | -| **`{ww}`** | Legacy alias for `{woy}` (ISO week) | **Reclaimed for Calendar Week (Jan 1 Basis, Oracle `WW`)** | -| **`t.ww`** | Deprecated getter | Removed (or remapped to calendar week) | -| **`{woy:cal}`** | Transitory format token in v4.7.0 | Deprecated in favor of native `{ww}` | -| **`{wom}`** | Week of Month (`1`–`5`, Oracle `W`, LDML `W`) | Week of Month (`1`–`5`) | - ---- - -## 9. Code Formatting Standards & Semicolon Policy Evaluation (ECMAScript Standards Compliance) - -### Classification -* **Type:** Tooling, Code Formatting & Syntactic Consistency Policy. -* **Target Milestone:** `v5.0.0` (evaluated and executed on the v5 development branch). -* **Affected Scope:** All monorepo packages, documentation themes, and configuration files. - ---- - -### Context & Problem Statement - -During v4 maintenance, discrepancies were noted where VitePress documentation theme files (e.g. `.vitepress/theme/index.ts`) omitted semicolons on `import` statements following Vue/Vite defaults, whereas Tempo core, utility library, and dialect plugin source code consistently terminated statements with semicolons. - -This raised the question of whether to alter import statement punctuation across the monorepo to align with community conventions or formal language standards. - ---- - -### Technical & Standards Analysis - -1. **Formal ECMAScript Grammar (ECMA-262 § 16.2.2)**: - - In the official ECMAScript language specification, `ImportDeclaration` formally terminates with a semicolon: - $$\text{ImportDeclaration} : \text{import}\ \text{ImportClause}\ \text{FromClause}\ \mathbf{;}$$ - $$\text{ImportDeclaration} : \text{import}\ \text{ModuleSpecifier}\ \mathbf{;}$$ - - Omitting semicolons relies on Automatic Semicolon Insertion (ASI), which serves as an error-correction mechanism in the grammar rather than the primary syntactic specification. - - Major standards references (TC39 proposals, official TypeScript Handbook, MDN Web Docs, Google TypeScript Style Guide) terminate `import` declarations with semicolons. - -2. **Rejection of Mixed Punctuation ("Imports without semicolons, statements with semicolons")**: - - Having `import` lines without semicolons while regular statements (`const`, function calls, returns) use semicolons within the same file creates an inconsistent anti-pattern flagged by ESLint, Biome, and CodeRabbit. - - Punctuation policy must be uniform file-wide and repository-wide. - -3. **Blast Radius on Maintenance Branches**: - - Over 600 files currently use standard semicolons on `import` statements. - - Bulk formatting sweeps on `maintenance/v4` would generate excessive `git blame` churn and merge friction. Bulk syntactic adjustments are therefore deferred to the `v5.0.0` milestone. - ---- - -### Decision Pathways for the v5 Branch - -When work begins on the v5 branch, a formal decision will be selected and automated via tooling: - -* **Option A (Formal ECMAScript Compliance - Recommended)**: - - Enforce explicit semicolons on all statements (including `import` and `export` declarations) across the entire monorepo (`semi: true`). - - Add missing semicolons to VitePress documentation theme files to eliminate one-off style anomalies. - - Aligns with standard TypeScript, Prettier defaults, and ECMA-262 grammar. - -* **Option B (Full "No-Semi" Style)**: - - If transitioning to an omission style (Vue / Vite / StandardJS style), enforce `semi: false` uniformly across *all* statements and files via an automated formatter (Prettier / Biome), avoiding half-and-half styling. - -### Action Items for v5 Execution -- [ ] Adopt repository-wide formatter configuration (`.prettierrc` or `biome.json`) enforcing the chosen semicolon rule. -- [ ] Run automated formatting in an isolated, dedicated commit on the v5 branch. -- [ ] Update [`.agents/rules/styleGuide.md`](file:///home/michael/Project/magma/.agents/rules/styleGuide.md) to codify the policy. - ---- - -## 10. Type-Guard Semantics: Renaming `isDefined` to `isNonNull` and Introducing Strict `isDefined` - -### Classification -* **Type:** Breaking API & Type-Guard Semantic Correction. -* **Target Milestone:** `v5.0.0` -* **Affected API:** `@magmacomputing/library` (`#library/assertion.library.js`), `@magmacomputing/tempo/library` - ---- - -### Behavior Comparison - -| Aspect | Current Behavior (`v4.x`) | New Behavior (`v5.0.0`) | -| :--- | :--- | :--- | -| **`isDefined(undefined)`** | `false` | `false` | -| **`isDefined(null)`** | `false` ⚠️ (Narrows to `NonNullable`) | `true` (Narrows to `Exclude`) | -| **`isDefined(0)` / `isDefined('')`** | `true` | `true` | -| **`isUndefined(null)`** | `false` | `false` | -| **`isNonNull(null)`** | *N/A (Did not exist)* | `false` (Narrows to `NonNullable`) | -| **Logical Symmetry** | `isDefined` is **NOT** the opposite of `isUndefined` | `!isDefined(x)` $\iff$ `isUndefined(x)` (Strict symmetry) | - ---- - -### Context & Problem Statement - -In the v4.x utility stack (`packages/library/src/common/primitives/assertion.library.ts:L153-L154`): -```typescript -export const isUndefined = (obj: unknown): obj is undefined => obj === undefined || isType(obj, 'Void', 'Empty'); -export const isDefined = (obj: T): obj is NonNullable => obj !== null && obj !== undefined && !isNullish(obj); -``` - -While `isUndefined(val)` checks purely whether `val` is undefined, `isDefined(val)` checks whether `val` is neither `null` nor `undefined` (`NonNullable`). - -This asymmetry creates counter-intuitive behavior: -* For `val = null`, `isUndefined(null)` returns `false`, yet `isDefined(null)` *also* returns `false`. -* `null` is trapped in a semantic void where it is neither defined nor undefined. -* Developers checking if an optional configuration property was explicitly passed (even as `null`) get false negatives when using `isDefined()`. - ---- - -### Migration Strategy & Phasing for v5 - -To eliminate this semantic mismatch without subtle regressions across the codebase: - -1. **Step 1: Introduce `isNonNull`** - - Add `isNonNull` (and/or `isNonNullish`) to `assertion.library.ts`: - ```typescript - export const isNonNull = (obj: T): obj is NonNullable => - obj !== null && obj !== undefined && !isNullish(obj); - ``` - - This explicitly captures the contract `val !== null && val !== undefined`. - -2. **Step 2: Monorepo-Wide Global Replacement (`isDefined` $\to$ `isNonNull`)** - - Perform a global replacement of `isDefined` $\to$ `isNonNull` across all existing call sites in Tempo Core, plugins, and tests. - - Because existing code was authored under the assumption that `null` is rejected, migrating call sites to `isNonNull` guarantees 100% behavioral equivalence and zero regression risk. - -3. **Step 3: Introduce Strict `isDefined`** - - Redefine `isDefined` to be the exact logical inverse of `isUndefined`: - ```typescript - export const isDefined = (obj: T): obj is Exclude => - obj !== undefined && !isType(obj, 'Void', 'Empty'); - ``` - - Now, `isDefined(null)` evaluates to `true`, and `!isDefined(x)` strictly matches `isUndefined(x)`. - ---- - -### Action Items for v5 Execution -- [ ] Export `isNonNull` from `packages/library/src/common/primitives/assertion.library.ts` and re-export via `#library/assertion.library.js`. -- [ ] Perform monorepo sweep: replace existing `isDefined` usage with `isNonNull`. -- [ ] Redefine `isDefined` as `Exclude` (`obj !== undefined`). -- [ ] Add unit test assertions in `packages/library/test` verifying `isDefined(null) === true` and `isNonNull(null) === false`. -- [ ] Document the type-guard migration in the v5 Upgrade Guide. - - - - - - diff --git a/packages/tempo/public/repl/snippets.manifest.js b/packages/tempo/public/repl/snippets.manifest.js index 40991a74..49a5d07e 100644 --- a/packages/tempo/public/repl/snippets.manifest.js +++ b/packages/tempo/public/repl/snippets.manifest.js @@ -41,14 +41,14 @@ console.log('ISO Day of Week (1..7):', today.dow); const isIsoWeekend = today.dow >= 6; console.log('Is ISO Weekend?', isIsoWeekend); -// 2. Locale-Aware check using t.intl.weekend +// 2. Locale-Aware check using t.intl.info.weekend const us = new Tempo({ locale: 'en-US' }); const sa = new Tempo({ locale: 'ar-SA' }); -console.log('en-US Weekend Days:', JSON.stringify(us.intl.weekend)); // [6, 7] (Saturday, Sunday) -console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.weekend)); // [5, 6] (Friday, Saturday) +console.log('en-US Weekend Days:', JSON.stringify(us.intl.info.weekend)); // [6, 7] (Saturday, Sunday) +console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.info.weekend)); // [5, 6] (Friday, Saturday) -return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.weekend.includes(today.dow)}\`;`, +return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.info.weekend.includes(today.dow)}\`;`, }, quarters: { diff --git a/packages/tempo/public/v4/404.html b/packages/tempo/public/v4/404.html new file mode 100644 index 00000000..97fc5e55 --- /dev/null +++ b/packages/tempo/public/v4/404.html @@ -0,0 +1,23 @@ + + + + + + 404 | Tempo + + + + + + + + + + + + +
+ + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/CONTRIBUTING.html b/packages/tempo/public/v4/CONTRIBUTING.html new file mode 100644 index 00000000..adc162f9 --- /dev/null +++ b/packages/tempo/public/v4/CONTRIBUTING.html @@ -0,0 +1,70 @@ + + + + + + Contributing to Tempo | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Tempo

Appearance

Contributing to Tempo ​

Thank you for your interest in contributing to Tempo! This project is a professional-grade date-time utility built on top of the native Temporal API. To maintain the high performance and architectural integrity of the library, please follow these guidelines.

🏗️ Project Architecture ​

Tempo uses several advanced JavaScript patterns that contributors should be familiar with:

🛠️ Local Development ​

Prerequisites ​

  • Node.js 20+ (Tempo requires native Temporal support or a robust environment; Node 22.0.x native Temporal has known instabilities, so a polyfill like @js-temporal/polyfill is highly recommended).
  • npm v9+ (For monorepo workspace support).

Setup ​

bash
git clone https://github.com/magmacomputing/magma.git
+cd magma
+npm install

Building ​

Tempo is a TypeScript project that compiles to ES2022.

bash
npm run build -w @magmacomputing/tempo

🧪 Testing ​

We use Vitest for our test suite. All new features or bug fixes must include corresponding tests.

  • Run all tests: npm run test
  • Run distribution tests: npm run test:dist (Tests the compiled dist/ bundles)
  • Run CI environment tests: npm run test:ci (Runs with fixed timezone America/New_York)
  • Interactive Watch mode: npx vitest

IMPORTANT

Zero State Contamination: Tests must be idempotent. If your test modifies a global registry (e.g., Tempo.use), ensure you use the using keyword or manually call Tempo[Symbol.dispose]() to reset the engine for the next test.

📜 Coding Standards ​

  1. Private Fields: Use native #private fields for internal state that should not be accessible via Proxies.
  2. Internal Symbols: Use the symbols exported from tempo.symbol.ts for cross-module internal communication.
  3. Immutability: Tempo instances are strictly immutable. Any method that changes state must return a new instance.
  4. Documentation: If you change a public API, please update the corresponding .md file in the doc/ directory.

🚀 Pull Request Process ​

  1. Create a new branch for your feature or fix.
  2. Ensure the test suite passes at 100%.
  3. Update the CHANGELOG.md with a brief description of your changes.
  4. Open a Pull Request and describe the problem you are solving and your technical approach.

Tempo is maintained by Magma Computing. For commercial support or architectural consulting, please reach out via the Contact Page.

Released under the MIT License.

Copyright © 2026-present Magma Computing

+ + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/README.html b/packages/tempo/public/v4/README.html new file mode 100644 index 00000000..79115759 --- /dev/null +++ b/packages/tempo/public/v4/README.html @@ -0,0 +1,109 @@ + + + + + + Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Tempo

Appearance

Tempo Logo

Tempo

The Professional Date-Time Library for the Temporal API

Tempo is a premium, high-performance wrapper for the ECMAScript Temporal API. Designed for professionals, it combines immutable state-management with a fluent, natural-language engine. It is the modern, type-safe successor to legacy libraries like Moment.js and Luxon.

Our Mission: Humanizing Temporal. Bringing developer intuition, cultural awareness, and expressive natural-language ergonomics to JavaScript dates—anchored in a rock-solid ISO 8601 baseline. Read our vision & architecture →

npm version Socket Security Temporal Documentation Live Interactive REPL

⚡ Quick Start ​

javascript
import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+// 🔌 Instantly Extensible (with deterministic defaults)
+Tempo.init({ 
+  plugins: [CelestialPlugin],
+  timeZone: 'America/New_York'
+});
+
+// 🎯 Natural Language Parsing (Deterministic anchor)
+const event = new Tempo('next Friday 3pm', { anchor: '2026-10-15' });
+
+// 🔄 Fluent Mutations (Immutable)
+const reminder = event.add({ hours: 2 }).set({ minute: 0 });
+
+// ⏳ Comparative Durations
+const diff = event.until('2026-12-25');
+console.log(diff.iso); // P2M2D
+
+// 📝 Beautiful Formatting
+console.log(event.format('{mon} {dd:ord}, {yyyy}')); // October 23rd, 2026
+
+// 🌌 Domain Logic (via Plugin)
+console.log(event.term.astronomy.season); // 'Autumn'

📦 Installation ​

bash
npm install @magmacomputing/tempo       # npm
+yarn add @magmacomputing/tempo          # yarn
+pnpm add @magmacomputing/tempo          # pnpm
+bun add @magmacomputing/tempo           # bun
+deno add npm:@magmacomputing/tempo      # deno

Runtime Support: Requires Node.js >= 20.0.0 (Recommended: Node 24 LTS or Node >= 26.10.0 with full native Temporal support).

🌐 Browser & Native Environments

For standard usage natively in the browser, use the pre-optimized Global ESM Bundle. It includes the entire core engine in a single file:

html
<script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.esm.js"
+  }
+}
+</script>
+
+<script type="module">
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  
+  const t = new Tempo('next Friday');
+</script>

Advanced Usage (Tempo Plugins & CDNs) If you need to use Tempo Plugins natively in the browser, require granular module resolution, or want to use on-the-fly bundling CDNs (like esm.sh), please see our comprehensive Installation Guide for detailed import map configurations.

⏳ Why Tempo? ​

While the native Temporal API gives you perfect primitives (ZonedDateTime, PlainDate), it doesn't give you business logic. Tempo bridges that gap.

FeatureNative Temporal APIThe Tempo Ecosystem
PrimitivesPerfect (Instant, ZonedDateTime)Powered by Native Primitives ✨
TimezonesIANA String SupportAdvanced fallback & auto-syncing
Domain Logic❌ Build it yourself✅ Plugins (astro, sync)
Natural Language❌ Manual parsing✅ "next Friday 3pm"

The Missing Domain Layer ​

  • 🗣️ Natural Language & Smart Parsing: Parse natural language phrases (e.g. "next Friday 3pm", "two days ago") with zero-cost lazy evaluation and functional aliases.
  • 🌍 Zero-Bundle Localization: Multi-language date parsing and formatting powered natively by ECMAScript Intl—no heavy static locale dictionaries required.
  • 🧩 Extensible & AI-Ready: Modular plugin ecosystem for astronomical cycles (astro), financial quarters (finance), schedulers (ticker), and LLM-powered parsing (ai).
  • 🏗️ Future-Proof & Ultra-Lightweight: Built natively on the TC39 Stage 4 Temporal foundation with zero legacy runtime baggage and full tree-shaking support.

📚 Documentation ​

For a deeper dive into the API, architecture, and advanced features:

🧰 The Tempo Ecosystem ​

Tempo is the core library, but the ecosystem extends further:

PackageDescriptionDocs
@magmacomputing/tempoCore library — parsing, formatting, natural-language engineDocumentation
@magmacomputing/tempo-fnsPure functional utilities built on native Temporal & Tempo — tree-shakeable helpersDocumentation
@magmacomputing/tempo-plugin-*Official & community plugins — AI, Ticker, Astro, Finance, Sync, Snap, and morePlugin Ecosystem Catalog

💬 Contact & Support ​

  1. Bug Reports & Features: Please open an Issue.
  2. Questions & Ideas: Start a thread in Discussions.
  3. Direct Contact: You can reach us at hello@magmacomputing.com.au.

🗳️ Feedback & Reactions ​

🚀 Premium!   |   ⭐ Loving it!   |   💡 Needs work   |   🐞 Found a bug

⚖️ License ​

Distributed under the MIT License. See LICENSE for more information.

Released under the MIT License.

Copyright © 2026-present Magma Computing

+ + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/SECURITY.html b/packages/tempo/public/v4/SECURITY.html new file mode 100644 index 00000000..40047b78 --- /dev/null +++ b/packages/tempo/public/v4/SECURITY.html @@ -0,0 +1,68 @@ + + + + + + Security Policy | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Tempo

Appearance

Security Policy ​

Supported Versions ​

The following table lists the versions of Magma projects that currently receive security updates:

VersionSupported
4.x✅
< 4.0❌

Reporting a Vulnerability ​

We take the security of Magma Computing projects and @magmacomputing/tempo seriously. If you believe you have discovered a security vulnerability, please follow responsible disclosure guidelines.

How to Report ​

Do NOT report security vulnerabilities through public GitHub issues.

Instead, please report security issues by emailing our security team at: security@magmacomputing.com.au

Alternatively, you may submit a private security advisory through the Security tab of our GitHub repository: Submit Security Advisory.

What to Include ​

To help us investigate and resolve the issue quickly, please include:

  • A detailed description of the vulnerability and potential impact.
  • Step-by-step instructions or proof-of-concept (PoC) code to reproduce the issue.
  • The package name and version affected (e.g. @magmacomputing/tempo@4.0.1).
  • Any potential mitigations or suggested fixes.

Response Timeline ​

  • Acknowledgement: We will acknowledge receipt of your vulnerability report within 48 hours.
  • Assessment & Fix: We aim to assess and patch verified vulnerabilities within 7 business days.
  • Public Disclosure: Public advisories and patched releases will be coordinated with the reporter after a fix is verified and deployed.

Thank you for helping keep the open-source ecosystem secure!

Released under the MIT License.

Copyright © 2026-present Magma Computing

+ + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/api/.nojekyll b/packages/tempo/public/v4/api/.nojekyll new file mode 100644 index 00000000..e2ac6616 --- /dev/null +++ b/packages/tempo/public/v4/api/.nojekyll @@ -0,0 +1 @@ +TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false. \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/hierarchy.js b/packages/tempo/public/v4/api/assets/hierarchy.js new file mode 100644 index 00000000..8180d109 --- /dev/null +++ b/packages/tempo/public/v4/api/assets/hierarchy.js @@ -0,0 +1 @@ +window.hierarchyData = "eJyNj7EKwjAURf/lzqlSobHkCxwcHNykQ0lfbehrAnnpICX/LlkUnTrd5RwOd0MMIQnMoz7rU6cQaWSyyQUvMBtq3bRlfb8QDO4UlxuvT+ehMDs/wJwarbBGhoHzieLYW5LjFzxMaWEoWO5FYJBkqIpZfWhkhVL/61zdSPZlmS4hzLKj9yvs6CrYyfEQyZf/umm7nPMbaN1bpQ==" \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/highlight.css b/packages/tempo/public/v4/api/assets/highlight.css new file mode 100644 index 00000000..ee78b951 --- /dev/null +++ b/packages/tempo/public/v4/api/assets/highlight.css @@ -0,0 +1,120 @@ +:root { + --light-hl-0: #AF00DB; + --dark-hl-0: #C586C0; + --light-hl-1: #000000; + --dark-hl-1: #D4D4D4; + --light-hl-2: #001080; + --dark-hl-2: #9CDCFE; + --light-hl-3: #A31515; + --dark-hl-3: #CE9178; + --light-hl-4: #008000; + --dark-hl-4: #6A9955; + --light-hl-5: #795E26; + --dark-hl-5: #DCDCAA; + --light-hl-6: #0000FF; + --dark-hl-6: #569CD6; + --light-hl-7: #0070C1; + --dark-hl-7: #4FC1FF; + --light-hl-8: #098658; + --dark-hl-8: #B5CEA8; + --light-hl-9: #800000; + --dark-hl-9: #808080; + --light-hl-10: #800000; + --dark-hl-10: #569CD6; + --light-hl-11: #000000FF; + --dark-hl-11: #D4D4D4; + --light-hl-12: #E50000; + --dark-hl-12: #9CDCFE; + --light-hl-13: #0000FF; + --dark-hl-13: #CE9178; + --light-code-background: #FFFFFF; + --dark-code-background: #1E1E1E; +} + +@media (prefers-color-scheme: light) { :root { + --hl-0: var(--light-hl-0); + --hl-1: var(--light-hl-1); + --hl-2: var(--light-hl-2); + --hl-3: var(--light-hl-3); + --hl-4: var(--light-hl-4); + --hl-5: var(--light-hl-5); + --hl-6: var(--light-hl-6); + --hl-7: var(--light-hl-7); + --hl-8: var(--light-hl-8); + --hl-9: var(--light-hl-9); + --hl-10: var(--light-hl-10); + --hl-11: var(--light-hl-11); + --hl-12: var(--light-hl-12); + --hl-13: var(--light-hl-13); + --code-background: var(--light-code-background); +} } + +@media (prefers-color-scheme: dark) { :root { + --hl-0: var(--dark-hl-0); + --hl-1: var(--dark-hl-1); + --hl-2: var(--dark-hl-2); + --hl-3: var(--dark-hl-3); + --hl-4: var(--dark-hl-4); + --hl-5: var(--dark-hl-5); + --hl-6: var(--dark-hl-6); + --hl-7: var(--dark-hl-7); + --hl-8: var(--dark-hl-8); + --hl-9: var(--dark-hl-9); + --hl-10: var(--dark-hl-10); + --hl-11: var(--dark-hl-11); + --hl-12: var(--dark-hl-12); + --hl-13: var(--dark-hl-13); + --code-background: var(--dark-code-background); +} } + +:root[data-theme='light'] { + --hl-0: var(--light-hl-0); + --hl-1: var(--light-hl-1); + --hl-2: var(--light-hl-2); + --hl-3: var(--light-hl-3); + --hl-4: var(--light-hl-4); + --hl-5: var(--light-hl-5); + --hl-6: var(--light-hl-6); + --hl-7: var(--light-hl-7); + --hl-8: var(--light-hl-8); + --hl-9: var(--light-hl-9); + --hl-10: var(--light-hl-10); + --hl-11: var(--light-hl-11); + --hl-12: var(--light-hl-12); + --hl-13: var(--light-hl-13); + --code-background: var(--light-code-background); +} + +:root[data-theme='dark'] { + --hl-0: var(--dark-hl-0); + --hl-1: var(--dark-hl-1); + --hl-2: var(--dark-hl-2); + --hl-3: var(--dark-hl-3); + --hl-4: var(--dark-hl-4); + --hl-5: var(--dark-hl-5); + --hl-6: var(--dark-hl-6); + --hl-7: var(--dark-hl-7); + --hl-8: var(--dark-hl-8); + --hl-9: var(--dark-hl-9); + --hl-10: var(--dark-hl-10); + --hl-11: var(--dark-hl-11); + --hl-12: var(--dark-hl-12); + --hl-13: var(--dark-hl-13); + --code-background: var(--dark-code-background); +} + +.hl-0 { color: var(--hl-0); } +.hl-1 { color: var(--hl-1); } +.hl-2 { color: var(--hl-2); } +.hl-3 { color: var(--hl-3); } +.hl-4 { color: var(--hl-4); } +.hl-5 { color: var(--hl-5); } +.hl-6 { color: var(--hl-6); } +.hl-7 { color: var(--hl-7); } +.hl-8 { color: var(--hl-8); } +.hl-9 { color: var(--hl-9); } +.hl-10 { color: var(--hl-10); } +.hl-11 { color: var(--hl-11); } +.hl-12 { color: var(--hl-12); } +.hl-13 { color: var(--hl-13); } +pre, code, math[display='block'] { background: var(--code-background); } diff --git a/packages/tempo/public/v4/api/assets/icons.js b/packages/tempo/public/v4/api/assets/icons.js new file mode 100644 index 00000000..4fbadc5a --- /dev/null +++ b/packages/tempo/public/v4/api/assets/icons.js @@ -0,0 +1,18 @@ +(function() { + addIcons(); + function addIcons() { + if (document.readyState === "loading") return document.addEventListener("DOMContentLoaded", addIcons); + const svg = document.body.appendChild(document.createElementNS("http://www.w3.org/2000/svg", "svg")); + svg.innerHTML = `MMNEPVFCICPMFPCPTTAAATR`; + svg.style.display = "none"; + if (location.protocol === "file:") updateUseElements(); + } + + function updateUseElements() { + document.querySelectorAll("use").forEach(el => { + if (el.getAttribute("href").includes("#icon-")) { + el.setAttribute("href", el.getAttribute("href").replace(/.*#/, "#")); + } + }); + } +})() \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/icons.svg b/packages/tempo/public/v4/api/assets/icons.svg new file mode 100644 index 00000000..be7798fc --- /dev/null +++ b/packages/tempo/public/v4/api/assets/icons.svg @@ -0,0 +1 @@ +MMNEPVFCICPMFPCPTTAAATR \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/main.js b/packages/tempo/public/v4/api/assets/main.js new file mode 100644 index 00000000..b0eda9ed --- /dev/null +++ b/packages/tempo/public/v4/api/assets/main.js @@ -0,0 +1,60 @@ +"use strict"; +window.translations={"copy":"Copy","copied":"Copied!","normally_hidden":"This member is normally hidden due to your filter settings.","hierarchy_expand":"Expand","hierarchy_collapse":"Collapse","folder":"Folder","search_index_not_available":"The search index is not available","search_no_results_found_for_0":"No results found for {0}","kind_1":"Project","kind_2":"Module","kind_4":"Namespace","kind_8":"Enumeration","kind_16":"Enumeration Member","kind_32":"Variable","kind_64":"Function","kind_128":"Class","kind_256":"Interface","kind_512":"Constructor","kind_1024":"Property","kind_2048":"Method","kind_4096":"Call Signature","kind_8192":"Index Signature","kind_16384":"Constructor Signature","kind_32768":"Parameter","kind_65536":"Type Literal","kind_131072":"Type Parameter","kind_262144":"Accessor","kind_524288":"Get Signature","kind_1048576":"Set Signature","kind_2097152":"Type Alias","kind_4194304":"Reference","kind_8388608":"Document"}; +(()=>{var Ke=Object.create;var he=Object.defineProperty;var Ge=Object.getOwnPropertyDescriptor;var Ze=Object.getOwnPropertyNames;var Xe=Object.getPrototypeOf,Ye=Object.prototype.hasOwnProperty;var et=(t,e)=>()=>{try{return e||t((e={exports:{}}).exports,e),e.exports}catch(n){throw e=0,n}};var tt=(t,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of Ze(e))!Ye.call(t,i)&&i!==n&&he(t,i,{get:()=>e[i],enumerable:!(r=Ge(e,i))||r.enumerable});return t};var nt=(t,e,n)=>(n=t!=null?Ke(Xe(t)):{},tt(e||!t||!t.__esModule?he(n,"default",{value:t,enumerable:!0}):n,t));var ye=et((me,ge)=>{(function(){var t=function(e){var n=new t.Builder;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),n.searchPipeline.add(t.stemmer),e.call(n,n),n.build()};t.version="2.3.9";t.utils={},t.utils.warn=(function(e){return function(n){e.console&&console.warn&&console.warn(n)}})(this),t.utils.asString=function(e){return e==null?"":e.toString()},t.utils.clone=function(e){if(e==null)return e;for(var n=Object.create(null),r=Object.keys(e),i=0;i0){var d=t.utils.clone(n)||{};d.position=[a,l],d.index=s.length,s.push(new t.Token(r.slice(a,o),d))}a=o+1}}return s},t.tokenizer.separator=/[\s\-]+/;t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions=Object.create(null),t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn(`Function is not registered with pipeline. This may cause problems when serialising the index. +`,e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(r){var i=t.Pipeline.registeredFunctions[r];if(i)n.add(i);else throw new Error("Cannot load unregistered function: "+r)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(n){t.Pipeline.warnIfFunctionNotRegistered(n),this._stack.push(n)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");r=r+1,this._stack.splice(r,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");this._stack.splice(r,0,n)},t.Pipeline.prototype.remove=function(e){var n=this._stack.indexOf(e);n!=-1&&this._stack.splice(n,1)},t.Pipeline.prototype.run=function(e){for(var n=this._stack.length,r=0;r1&&(oe&&(r=s),o!=e);)i=r-n,s=n+Math.floor(i/2),o=this.elements[s*2];if(o==e||o>e)return s*2;if(oc?d+=2:a==c&&(n+=r[l+1]*i[d+1],l+=2,d+=2);return n},t.Vector.prototype.similarity=function(e){return this.dot(e)/this.magnitude()||0},t.Vector.prototype.toArray=function(){for(var e=new Array(this.elements.length/2),n=1,r=0;n0){var o=s.str.charAt(0),a;o in s.node.edges?a=s.node.edges[o]:(a=new t.TokenSet,s.node.edges[o]=a),s.str.length==1&&(a.final=!0),i.push({node:a,editsRemaining:s.editsRemaining,str:s.str.slice(1)})}if(s.editsRemaining!=0){if("*"in s.node.edges)var c=s.node.edges["*"];else{var c=new t.TokenSet;s.node.edges["*"]=c}if(s.str.length==0&&(c.final=!0),i.push({node:c,editsRemaining:s.editsRemaining-1,str:s.str}),s.str.length>1&&i.push({node:s.node,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)}),s.str.length==1&&(s.node.final=!0),s.str.length>=1){if("*"in s.node.edges)var l=s.node.edges["*"];else{var l=new t.TokenSet;s.node.edges["*"]=l}s.str.length==1&&(l.final=!0),i.push({node:l,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)})}if(s.str.length>1){var d=s.str.charAt(0),f=s.str.charAt(1),p;f in s.node.edges?p=s.node.edges[f]:(p=new t.TokenSet,s.node.edges[f]=p),s.str.length==1&&(p.final=!0),i.push({node:p,editsRemaining:s.editsRemaining-1,str:d+s.str.slice(2)})}}}return r},t.TokenSet.fromString=function(e){for(var n=new t.TokenSet,r=n,i=0,s=e.length;i=e;n--){var r=this.uncheckedNodes[n],i=r.child.toString();i in this.minimizedNodes?r.parent.edges[r.char]=this.minimizedNodes[i]:(r.child._str=i,this.minimizedNodes[i]=r.child),this.uncheckedNodes.pop()}};t.Index=function(e){this.invertedIndex=e.invertedIndex,this.fieldVectors=e.fieldVectors,this.tokenSet=e.tokenSet,this.fields=e.fields,this.pipeline=e.pipeline},t.Index.prototype.search=function(e){return this.query(function(n){var r=new t.QueryParser(e,n);r.parse()})},t.Index.prototype.query=function(e){for(var n=new t.Query(this.fields),r=Object.create(null),i=Object.create(null),s=Object.create(null),o=Object.create(null),a=Object.create(null),c=0;c1?this._b=1:this._b=e},t.Builder.prototype.k1=function(e){this._k1=e},t.Builder.prototype.add=function(e,n){var r=e[this._ref],i=Object.keys(this._fields);this._documents[r]=n||{},this.documentCount+=1;for(var s=0;s=this.length)return t.QueryLexer.EOS;var e=this.str.charAt(this.pos);return this.pos+=1,e},t.QueryLexer.prototype.width=function(){return this.pos-this.start},t.QueryLexer.prototype.ignore=function(){this.start==this.pos&&(this.pos+=1),this.start=this.pos},t.QueryLexer.prototype.backup=function(){this.pos-=1},t.QueryLexer.prototype.acceptDigitRun=function(){var e,n;do e=this.next(),n=e.charCodeAt(0);while(n>47&&n<58);e!=t.QueryLexer.EOS&&this.backup()},t.QueryLexer.prototype.more=function(){return this.pos1&&(e.backup(),e.emit(t.QueryLexer.TERM)),e.ignore(),e.more())return t.QueryLexer.lexText},t.QueryLexer.lexEditDistance=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.EDIT_DISTANCE),t.QueryLexer.lexText},t.QueryLexer.lexBoost=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.BOOST),t.QueryLexer.lexText},t.QueryLexer.lexEOS=function(e){e.width()>0&&e.emit(t.QueryLexer.TERM)},t.QueryLexer.termSeparator=t.tokenizer.separator,t.QueryLexer.lexText=function(e){for(;;){var n=e.next();if(n==t.QueryLexer.EOS)return t.QueryLexer.lexEOS;if(n.charCodeAt(0)==92){e.escapeCharacter();continue}if(n==":")return t.QueryLexer.lexField;if(n=="~")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexEditDistance;if(n=="^")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexBoost;if(n=="+"&&e.width()===1||n=="-"&&e.width()===1)return e.emit(t.QueryLexer.PRESENCE),t.QueryLexer.lexText;if(n.match(t.QueryLexer.termSeparator))return t.QueryLexer.lexTerm}},t.QueryParser=function(e,n){this.lexer=new t.QueryLexer(e),this.query=n,this.currentClause={},this.lexemeIdx=0},t.QueryParser.prototype.parse=function(){this.lexer.run(),this.lexemes=this.lexer.lexemes;for(var e=t.QueryParser.parseClause;e;)e=e(this);return this.query},t.QueryParser.prototype.peekLexeme=function(){return this.lexemes[this.lexemeIdx]},t.QueryParser.prototype.consumeLexeme=function(){var e=this.peekLexeme();return this.lexemeIdx+=1,e},t.QueryParser.prototype.nextClause=function(){var e=this.currentClause;this.query.clause(e),this.currentClause={}},t.QueryParser.parseClause=function(e){var n=e.peekLexeme();if(n!=null)switch(n.type){case t.QueryLexer.PRESENCE:return t.QueryParser.parsePresence;case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expected either a field or a term, found "+n.type;throw n.str.length>=1&&(r+=" with value '"+n.str+"'"),new t.QueryParseError(r,n.start,n.end)}},t.QueryParser.parsePresence=function(e){var n=e.consumeLexeme();if(n!=null){switch(n.str){case"-":e.currentClause.presence=t.Query.presence.PROHIBITED;break;case"+":e.currentClause.presence=t.Query.presence.REQUIRED;break;default:var r="unrecognised presence operator'"+n.str+"'";throw new t.QueryParseError(r,n.start,n.end)}var i=e.peekLexeme();if(i==null){var r="expecting term or field, found nothing";throw new t.QueryParseError(r,n.start,n.end)}switch(i.type){case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expecting term or field, found '"+i.type+"'";throw new t.QueryParseError(r,i.start,i.end)}}},t.QueryParser.parseField=function(e){var n=e.consumeLexeme();if(n!=null){if(e.query.allFields.indexOf(n.str)==-1){var r=e.query.allFields.map(function(o){return"'"+o+"'"}).join(", "),i="unrecognised field '"+n.str+"', possible fields: "+r;throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.fields=[n.str];var s=e.peekLexeme();if(s==null){var i="expecting term, found nothing";throw new t.QueryParseError(i,n.start,n.end)}if(s.type===t.QueryLexer.TERM)return t.QueryParser.parseTerm;var i="expecting term, found '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}},t.QueryParser.parseTerm=function(e){var n=e.consumeLexeme();if(n!=null){e.currentClause.term=n.str.toLowerCase(),n.str.indexOf("*")!=-1&&(e.currentClause.usePipeline=!1);var r=e.peekLexeme();if(r==null){e.nextClause();return}switch(r.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+r.type+"'";throw new t.QueryParseError(i,r.start,r.end)}}},t.QueryParser.parseEditDistance=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="edit distance must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.editDistance=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseBoost=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="boost must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.boost=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},(function(e,n){typeof define=="function"&&define.amd?define(n):typeof me=="object"?ge.exports=n():e.lunr=n()})(this,function(){return t})})()});var M,G={getItem(){return null},setItem(){}},K;try{K=localStorage,M=K}catch{K=G,M=G}var S={getItem:t=>M.getItem(t),setItem:(t,e)=>M.setItem(t,e),disableWritingLocalStorage(){M=G},disable(){localStorage.clear(),M=G},enable(){M=K}};window.TypeDoc||={disableWritingLocalStorage(){S.disableWritingLocalStorage()},disableLocalStorage:()=>{S.disable()},enableLocalStorage:()=>{S.enable()}};window.translations||={copy:"Copy",copied:"Copied!",normally_hidden:"This member is normally hidden due to your filter settings.",hierarchy_expand:"Expand",hierarchy_collapse:"Collapse",search_index_not_available:"The search index is not available",search_no_results_found_for_0:"No results found for {0}",folder:"Folder",kind_1:"Project",kind_2:"Module",kind_4:"Namespace",kind_8:"Enumeration",kind_16:"Enumeration Member",kind_32:"Variable",kind_64:"Function",kind_128:"Class",kind_256:"Interface",kind_512:"Constructor",kind_1024:"Property",kind_2048:"Method",kind_4096:"Call Signature",kind_8192:"Index Signature",kind_16384:"Constructor Signature",kind_32768:"Parameter",kind_65536:"Type Literal",kind_131072:"Type Parameter",kind_262144:"Accessor",kind_524288:"Get Signature",kind_1048576:"Set Signature",kind_2097152:"Type Alias",kind_4194304:"Reference",kind_8388608:"Document"};var pe=[];function X(t,e){pe.push({selector:e,constructor:t})}var Z=class{alwaysVisibleMember=null;constructor(){this.createComponents(document.body),this.ensureFocusedElementVisible(),this.listenForCodeCopies(),window.addEventListener("hashchange",()=>this.ensureFocusedElementVisible()),document.body.style.display||(this.ensureFocusedElementVisible(),this.updateIndexVisibility(),this.scrollToHash())}createComponents(e){pe.forEach(n=>{e.querySelectorAll(n.selector).forEach(r=>{r.dataset.hasInstance||(new n.constructor({el:r,app:this}),r.dataset.hasInstance=String(!0))})})}filterChanged(){this.ensureFocusedElementVisible()}showPage(){document.body.style.display&&(document.body.style.removeProperty("display"),this.ensureFocusedElementVisible(),this.updateIndexVisibility(),this.scrollToHash())}scrollToHash(){if(location.hash){let e=document.getElementById(location.hash.substring(1));if(!e)return;e.scrollIntoView({behavior:"instant",block:"start"})}}ensureActivePageVisible(){let e=document.querySelector(".tsd-navigation .current"),n=e?.parentElement;for(;n&&!n.classList.contains(".tsd-navigation");)n instanceof HTMLDetailsElement&&(n.open=!0),n=n.parentElement;if(e&&!rt(e)){let r=e.getBoundingClientRect().top-document.documentElement.clientHeight/4;document.querySelector(".site-menu").scrollTop=r,document.querySelector(".col-sidebar").scrollTop=r}}updateIndexVisibility(){let e=document.querySelector(".tsd-index-content"),n=e?.open;e&&(e.open=!0),document.querySelectorAll(".tsd-index-section").forEach(r=>{r.style.display="block";let i=Array.from(r.querySelectorAll(".tsd-index-link")).every(s=>s.offsetParent==null);r.style.display=i?"none":"block"}),e&&(e.open=n)}ensureFocusedElementVisible(){if(this.alwaysVisibleMember&&(this.alwaysVisibleMember.classList.remove("always-visible"),this.alwaysVisibleMember.firstElementChild.remove(),this.alwaysVisibleMember=null),!location.hash)return;let e=document.getElementById(location.hash.substring(1));if(!e)return;let n=e.parentElement;for(;n&&n.tagName!=="SECTION";)n=n.parentElement;if(!n)return;let r=n.offsetParent==null,i=n;for(;i!==document.body;)i instanceof HTMLDetailsElement&&(i.open=!0),i=i.parentElement;if(n.offsetParent==null){this.alwaysVisibleMember=n,n.classList.add("always-visible");let s=document.createElement("p");s.classList.add("warning"),s.textContent=window.translations.normally_hidden,n.prepend(s)}r&&e.scrollIntoView()}listenForCodeCopies(){document.querySelectorAll("pre > button").forEach(e=>{let n;e.addEventListener("click",()=>{e.previousElementSibling instanceof HTMLElement&&navigator.clipboard.writeText(e.previousElementSibling.innerText.trim()),e.textContent=window.translations.copied,e.classList.add("visible"),clearTimeout(n),n=setTimeout(()=>{e.classList.remove("visible"),n=setTimeout(()=>{e.textContent=window.translations.copy},100)},1e3)})})}};function rt(t){let e=t.getBoundingClientRect(),n=Math.max(document.documentElement.clientHeight,window.innerHeight);return!(e.bottom<0||e.top-n>=0)}var fe=(t,e=100)=>{let n;return()=>{clearTimeout(n),n=setTimeout(()=>t(),e)}};var Ie=nt(ye(),1);async function R(t){let e=Uint8Array.from(atob(t),s=>s.charCodeAt(0)),r=new Blob([e]).stream().pipeThrough(new DecompressionStream("deflate")),i=await new Response(r).text();return JSON.parse(i)}var Y="closing",ae="tsd-overlay";function it(){let t=Math.abs(window.innerWidth-document.documentElement.clientWidth);document.body.style.overflow="hidden",document.body.style.paddingRight=`${t}px`}function st(){document.body.style.removeProperty("overflow"),document.body.style.removeProperty("padding-right")}function Ee(t,e){t.addEventListener("animationend",()=>{t.classList.contains(Y)&&(t.classList.remove(Y),document.getElementById(ae)?.remove(),t.close(),st())}),t.addEventListener("cancel",n=>{n.preventDefault(),ve(t)}),e?.closeOnClick&&document.addEventListener("click",n=>{t.open&&!t.contains(n.target)&&ve(t)},!0)}function xe(t){if(t.open)return;let e=document.createElement("div");e.id=ae,document.body.appendChild(e),t.showModal(),it()}function ve(t){if(!t.open)return;document.getElementById(ae)?.classList.add(Y),t.classList.add(Y)}var I=class{el;app;constructor(e){this.el=e.el,this.app=e.app}};var be=document.head.appendChild(document.createElement("style"));be.dataset.for="filters";var le={};function Le(t){for(let e of t.split(/\s+/))if(le.hasOwnProperty(e)&&!le[e])return!0;return!1}var ee=class extends I{key;value;constructor(e){super(e),this.key=`filter-${this.el.name}`,this.value=this.el.checked,this.el.addEventListener("change",()=>{this.setLocalStorage(this.el.checked)}),this.setLocalStorage(this.fromLocalStorage()),be.innerHTML+=`html:not(.${this.key}) .tsd-is-${this.el.name} { display: none; } +`,this.app.updateIndexVisibility()}fromLocalStorage(){let e=S.getItem(this.key);return e?e==="true":this.el.checked}setLocalStorage(e){S.setItem(this.key,e.toString()),this.value=e,this.handleValueChange()}handleValueChange(){this.el.checked=this.value,document.documentElement.classList.toggle(this.key,this.value),le[`tsd-is-${this.el.name}`]=this.value,this.app.filterChanged(),this.app.updateIndexVisibility()}};var we=0;async function Se(t,e){if(!window.searchData)return;let n=await R(window.searchData);t.data=n,t.index=Ie.Index.load(n.index),e.innerHTML=""}function _e(){let t=document.getElementById("tsd-search-trigger"),e=document.getElementById("tsd-search"),n=document.getElementById("tsd-search-input"),r=document.getElementById("tsd-search-results"),i=document.getElementById("tsd-search-script"),s=document.getElementById("tsd-search-status");if(!(t&&e&&n&&r&&i&&s))throw new Error("Search controls missing");let o={base:document.documentElement.dataset.base};o.base.endsWith("/")||(o.base+="/"),i.addEventListener("error",()=>{let a=window.translations.search_index_not_available;Pe(s,a)}),i.addEventListener("load",()=>{Se(o,s)}),Se(o,s),ot({trigger:t,searchEl:e,results:r,field:n,status:s},o)}function ot(t,e){let{field:n,results:r,searchEl:i,status:s,trigger:o}=t;Ee(i,{closeOnClick:!0});function a(){xe(i),n.setSelectionRange(0,n.value.length)}o.addEventListener("click",a),n.addEventListener("input",fe(()=>{at(r,n,s,e)},200)),n.addEventListener("keydown",l=>{if(r.childElementCount===0||l.ctrlKey||l.metaKey||l.altKey)return;let d=n.getAttribute("aria-activedescendant"),f=d?document.getElementById(d):null;if(f){let p=!1,v=!1;switch(l.key){case"Home":case"End":case"ArrowLeft":case"ArrowRight":v=!0;break;case"ArrowDown":case"ArrowUp":p=l.shiftKey;break}(p||v)&&ke(n)}if(!l.shiftKey)switch(l.key){case"Enter":f?.querySelector("a")?.click();break;case"ArrowUp":Te(r,n,f,-1),l.preventDefault();break;case"ArrowDown":Te(r,n,f,1),l.preventDefault();break}});function c(){ke(n)}n.addEventListener("change",c),n.addEventListener("blur",c),n.addEventListener("click",c),document.body.addEventListener("keydown",l=>{if(l.altKey||l.metaKey||l.shiftKey)return;let d=l.ctrlKey&&l.key==="k",f=!l.ctrlKey&&!ut()&&l.key==="/";(d||f)&&(l.preventDefault(),a())})}function at(t,e,n,r){if(!r.index||!r.data)return;t.innerHTML="",n.innerHTML="",we+=1;let i=e.value.trim(),s;if(i){let a=i.split(" ").map(c=>c.length?`*${c}*`:"").join(" ");s=r.index.search(a).filter(({ref:c})=>{let l=r.data.rows[Number(c)].classes;return!l||!Le(l)})}else s=[];if(s.length===0&&i){let a=window.translations.search_no_results_found_for_0.replace("{0}",` "${te(i)}" `);Pe(n,a);return}for(let a=0;ac.score-a.score);let o=Math.min(10,s.length);for(let a=0;a`,f=Ce(c.name,i);globalThis.DEBUG_SEARCH_WEIGHTS&&(f+=` (score: ${s[a].score.toFixed(2)})`),c.parent&&(f=` + ${Ce(c.parent,i)}.${f}`);let p=document.createElement("li");p.id=`tsd-search:${we}-${a}`,p.role="option",p.ariaSelected="false",p.classList.value=c.classes??"";let v=document.createElement("a");v.tabIndex=-1,v.href=r.base+c.url,v.innerHTML=d+`${f}`,p.append(v),t.appendChild(p)}}function Te(t,e,n,r){let i;if(r===1?i=n?.nextElementSibling||t.firstElementChild:i=n?.previousElementSibling||t.lastElementChild,i!==n){if(!i||i.role!=="option"){console.error("Option missing");return}i.ariaSelected="true",i.scrollIntoView({behavior:"smooth",block:"nearest"}),e.setAttribute("aria-activedescendant",i.id),n?.setAttribute("aria-selected","false")}}function ke(t){let e=t.getAttribute("aria-activedescendant");(e?document.getElementById(e):null)?.setAttribute("aria-selected","false"),t.setAttribute("aria-activedescendant","")}function Ce(t,e){if(e==="")return t;let n=t.toLocaleLowerCase(),r=e.toLocaleLowerCase(),i=[],s=0,o=n.indexOf(r);for(;o!=-1;)i.push(te(t.substring(s,o)),`${te(t.substring(o,o+r.length))}`),s=o+r.length,o=n.indexOf(r,s);return i.push(te(t.substring(s))),i.join("")}var lt={"&":"&","<":"<",">":">","'":"'",'"':"""};function te(t){return t.replace(/[&<>"'"]/g,e=>lt[e])}function Pe(t,e){t.innerHTML=e?`
${e}
`:""}var ct=["button","checkbox","file","hidden","image","radio","range","reset","submit"];function ut(){let t=document.activeElement;return t?t.isContentEditable||t.tagName==="TEXTAREA"||t.tagName==="SEARCH"?!0:t.tagName==="INPUT"&&!ct.includes(t.type):!1}var D="mousedown",Me="mousemove",$="mouseup",ne={x:0,y:0},Qe=!1,ce=!1,dt=!1,F=!1,Oe=/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);document.documentElement.classList.add(Oe?"is-mobile":"not-mobile");Oe&&"ontouchstart"in document.documentElement&&(dt=!0,D="touchstart",Me="touchmove",$="touchend");document.addEventListener(D,t=>{ce=!0,F=!1;let e=D=="touchstart"?t.targetTouches[0]:t;ne.y=e.pageY||0,ne.x=e.pageX||0});document.addEventListener(Me,t=>{if(ce&&!F){let e=D=="touchstart"?t.targetTouches[0]:t,n=ne.x-(e.pageX||0),r=ne.y-(e.pageY||0);F=Math.sqrt(n*n+r*r)>10}});document.addEventListener($,()=>{ce=!1});document.addEventListener("click",t=>{Qe&&(t.preventDefault(),t.stopImmediatePropagation(),Qe=!1)});var re=class extends I{active;className;constructor(e){super(e),this.className=this.el.dataset.toggle||"",this.el.addEventListener($,n=>this.onPointerUp(n)),this.el.addEventListener("click",n=>n.preventDefault()),document.addEventListener(D,n=>this.onDocumentPointerDown(n)),document.addEventListener($,n=>this.onDocumentPointerUp(n))}setActive(e){if(this.active==e)return;this.active=e,document.documentElement.classList.toggle("has-"+this.className,e),this.el.classList.toggle("active",e);let n=(this.active?"to-has-":"from-has-")+this.className;document.documentElement.classList.add(n),setTimeout(()=>document.documentElement.classList.remove(n),500)}onPointerUp(e){F||(this.setActive(!0),e.preventDefault())}onDocumentPointerDown(e){if(this.active){if(e.target.closest(".col-sidebar, .tsd-filter-group"))return;this.setActive(!1)}}onDocumentPointerUp(e){if(!F&&this.active&&e.target.closest(".col-sidebar")){let n=e.target.closest("a");if(n){let r=window.location.href;r.indexOf("#")!=-1&&(r=r.substring(0,r.indexOf("#"))),n.href.substring(0,r.length)==r&&setTimeout(()=>this.setActive(!1),250)}}}};var ue=new Map,de=class{open;accordions=[];key;constructor(e,n){this.key=e,this.open=n}add(e){this.accordions.push(e),e.open=this.open,e.addEventListener("toggle",()=>{this.toggle(e.open)})}toggle(e){for(let n of this.accordions)n.open=e;S.setItem(this.key,e.toString())}},ie=class extends I{constructor(e){super(e);let n=this.el.querySelector("summary"),r=n.querySelector("a");r&&r.addEventListener("click",()=>{location.assign(r.href)});let i=`tsd-accordion-${n.dataset.key??n.textContent.trim().replace(/\s+/g,"-").toLowerCase()}`,s;if(ue.has(i))s=ue.get(i);else{let o=S.getItem(i),a=o?o==="true":this.el.open;s=new de(i,a),ue.set(i,s)}s.add(this.el)}};function He(t){let e=S.getItem("tsd-theme")||"os";t.value=e,Ae(e),t.addEventListener("change",()=>{S.setItem("tsd-theme",t.value),Ae(t.value)})}function Ae(t){document.documentElement.dataset.theme=t}var se;function Ne(){let t=document.getElementById("tsd-nav-script");t&&(t.addEventListener("load",Re),Re())}async function Re(){let t=document.getElementById("tsd-nav-container");if(!t||!window.navigationData)return;let e=await R(window.navigationData);se=document.documentElement.dataset.base,se.endsWith("/")||(se+="/"),t.innerHTML="";for(let n of e)Ve(n,t,[]);window.app.createComponents(t),window.app.showPage(),window.app.ensureActivePageVisible()}function Ve(t,e,n){let r=e.appendChild(document.createElement("li"));if(t.children){let i=[...n,t.text],s=r.appendChild(document.createElement("details"));s.className=t.class?`${t.class} tsd-accordion`:"tsd-accordion";let o=s.appendChild(document.createElement("summary"));o.className="tsd-accordion-summary",o.dataset.key=i.join("$"),o.innerHTML='',De(t,o);let a=s.appendChild(document.createElement("div"));a.className="tsd-accordion-details";let c=a.appendChild(document.createElement("ul"));c.className="tsd-nested-navigation";for(let l of t.children)Ve(l,c,i)}else De(t,r,t.class)}function De(t,e,n){if(t.path){let r=e.appendChild(document.createElement("a"));if(r.href=se+t.path,n&&(r.className=n),location.pathname===r.pathname&&!r.href.includes("#")&&(r.classList.add("current"),r.ariaCurrent="page"),t.kind){let i=window.translations[`kind_${t.kind}`].replaceAll('"',""");r.innerHTML=``}r.appendChild(Fe(t.text,document.createElement("span")))}else{let r=e.appendChild(document.createElement("span")),i=window.translations.folder.replaceAll('"',""");r.innerHTML=``,r.appendChild(Fe(t.text,document.createElement("span")))}}function Fe(t,e){let n=t.split(/(?<=[^A-Z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[_-])(?=[^_-])/);for(let r=0;r{let i=r.target;for(;i.parentElement&&i.parentElement.tagName!="LI";)i=i.parentElement;i.dataset.dropdown&&(i.dataset.dropdown=String(i.dataset.dropdown!=="true"))});let t=new Map,e=new Set;for(let r of document.querySelectorAll(".tsd-full-hierarchy [data-refl]")){let i=r.querySelector("ul");t.has(r.dataset.refl)?e.add(r.dataset.refl):i&&t.set(r.dataset.refl,i)}for(let r of e)n(r);function n(r){let i=t.get(r).cloneNode(!0);i.querySelectorAll("[id]").forEach(s=>{s.removeAttribute("id")}),i.querySelectorAll("[data-dropdown]").forEach(s=>{s.dataset.dropdown="false"});for(let s of document.querySelectorAll(`[data-refl="${r}"]`)){let o=gt(),a=s.querySelector("ul");s.insertBefore(o,a),o.dataset.dropdown=String(!!a),a||s.appendChild(i.cloneNode(!0))}}}function pt(){let t=document.getElementById("tsd-hierarchy-script");t&&(t.addEventListener("load",Be),Be())}async function Be(){let t=document.querySelector(".tsd-panel.tsd-hierarchy:has(h4 a)");if(!t||!window.hierarchyData)return;let e=+t.dataset.refl,n=await R(window.hierarchyData),r=t.querySelector("ul"),i=document.createElement("ul");if(i.classList.add("tsd-hierarchy"),ft(i,n,e),r.querySelectorAll("li").length==i.querySelectorAll("li").length)return;let s=document.createElement("span");s.classList.add("tsd-hierarchy-toggle"),s.textContent=window.translations.hierarchy_expand,t.querySelector("h4 a")?.insertAdjacentElement("afterend",s),s.insertAdjacentText("beforebegin",", "),s.addEventListener("click",()=>{s.textContent===window.translations.hierarchy_expand?(r.insertAdjacentElement("afterend",i),r.remove(),s.textContent=window.translations.hierarchy_collapse):(i.insertAdjacentElement("afterend",r),i.remove(),s.textContent=window.translations.hierarchy_expand)})}function ft(t,e,n){let r=e.roots.filter(i=>mt(e,i,n));for(let i of r)t.appendChild(je(e,i,n))}function je(t,e,n,r=new Set){if(r.has(e))return;r.add(e);let i=t.reflections[e],s=document.createElement("li");if(s.classList.add("tsd-hierarchy-item"),e===n){let o=s.appendChild(document.createElement("span"));o.textContent=i.name,o.classList.add("tsd-hierarchy-target")}else{for(let a of i.uniqueNameParents||[]){let c=t.reflections[a],l=s.appendChild(document.createElement("a"));l.textContent=c.name,l.href=oe+c.url,l.className=c.class+" tsd-signature-type",s.append(document.createTextNode("."))}let o=s.appendChild(document.createElement("a"));o.textContent=t.reflections[e].name,o.href=oe+i.url,o.className=i.class+" tsd-signature-type"}if(i.children){let o=s.appendChild(document.createElement("ul"));o.classList.add("tsd-hierarchy");for(let a of i.children){let c=je(t,a,n,r);c&&o.appendChild(c)}}return r.delete(e),s}function mt(t,e,n){if(e===n)return!0;let r=new Set,i=[t.reflections[e]];for(;i.length;){let s=i.pop();if(!r.has(s)){r.add(s);for(let o of s.children||[]){if(o===n)return!0;i.push(t.reflections[o])}}}return!1}function gt(){let t=document.createElementNS("http://www.w3.org/2000/svg","svg");return t.setAttribute("width","20"),t.setAttribute("height","20"),t.innerHTML='',t}X(re,"a[data-toggle]");X(ie,".tsd-accordion");X(ee,".tsd-filter-item input[type=checkbox]");var qe=document.getElementById("tsd-theme");qe&&He(qe);var yt=new Z;Object.defineProperty(window,"app",{value:yt});_e();Ne();$e();"virtualKeyboard"in navigator&&(navigator.virtualKeyboard.overlaysContent=!0);})(); +/*! Bundled license information: + +lunr/lunr.js: + (** + * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9 + * Copyright (C) 2020 Oliver Nightingale + * @license MIT + *) + (*! + * lunr.utils + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Set + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.tokenizer + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Pipeline + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Vector + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.stemmer + * Copyright (C) 2020 Oliver Nightingale + * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt + *) + (*! + * lunr.stopWordFilter + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.trimmer + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.TokenSet + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Index + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Builder + * Copyright (C) 2020 Oliver Nightingale + *) +*/ diff --git a/packages/tempo/public/v4/api/assets/navigation.js b/packages/tempo/public/v4/api/assets/navigation.js new file mode 100644 index 00000000..7ff8c7bf --- /dev/null +++ b/packages/tempo/public/v4/api/assets/navigation.js @@ -0,0 +1 @@ +window.navigationData = "eJyNmG9v2jAQxr9L9pathdJu5R1r2VqtFARU01T1hZs4YDV2osShQ1O/+5T/Jr7z8TbPPb/4HPt8zvM/T/O/2pt4Gy6T2Bt4CdM7b+LJOMgjnp2Vj7/stIy8gfcmVOBNxgPP34koSLnyJs8t4DvL+CLRIlZZhxFK8zRkfksyoo6po8urj0EL+xGnkmkadxTnAi5ZyqSLVAW4ENMg6Pz6kLTWaRD0fOfXX4eXI8N7s5gvp+s17K9FinHLNN8IyWFIo5KUPGXFbCGUWiUpT6vp5n7xiFBq9fPwVA4yM61McWYRl1xpmFKLJONhNp89bhBGJdIZVSsShlTaaYQV34pMpwcXqYk5jZi5UP2VbzF+pnGeIIhKowi7Heze7SjnQ7wVPmwuJcovBWyWgnRKxCkp5zwORCh4CvsblaYojUxbKZH+xePmDvEXEr2eyzBke1YaOYfIqrGqrf3uXDON1LtKowgKebd1WFhO6+wx7fCBYzGWTCDfv1Bot9Y8RQp1LVKMFY+YFntkDhuVoqxn0zVW6yuNJHCkJK45WQ8z5CNk5PwX5+FaM5nAgFamOE9KIMMvFNqtRYTZtYgof47kn5P5/+b8LWDIEVKLJGM2+3U7/YMwKpGuInUgUkcalaK8I6m8k1kEVtcT5sovN3HNCMDO52rsauLsJvmTH8uElSu2HsrVaDg2IXbnBFCM4RIY92gajmM8VtcDYHjbXSGQ3jEDIGR9kLkA7lxKgiORfpECEBlnmWtSrbUOMN7bPeWGuJOpKVY6Lwbovrii7JlROvyIZRnPzhrleK0OR9/M2nd8n2uswH0O8G14Ku0GtH9nMqNcF6ci7kGE3D/4Eb+L4zfsHtYPo6BLlmb8JlblIwxpBpHAKN8KhaNK2QVZMbW1DtvyIX1SZ3G05wFMMEXy1OOpLKbPrpXV81P964N8jYGDy1RPvW3Oyy3QsfYsFey12BTHEce8CxPFVW52kh2hFBzGUOreZui8jeawV/cjPAFTd2C2XPdakQ7RaG47mkSjOexVt4wnYeoOTLmXZmorFEgxZAqCD8WQHRB7kXcEeKFb9gwfgyE7IAEPhSpKSyi2UGNh6o62ogrr7fs+Bdj5AKQYN84oVAci7P256Owh8N/iyJoU3wxyloLDmFaFrczuVoQhxOjHnIjr/4iBgdAvGRS5SAOhzAMZZtZh7q/F8khbLULdtbVq/cN1eD2+OB9/vPwHF+sa6A==" \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/search.js b/packages/tempo/public/v4/api/assets/search.js new file mode 100644 index 00000000..9b0cf442 --- /dev/null +++ b/packages/tempo/public/v4/api/assets/search.js @@ -0,0 +1 @@ +window.searchData = "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"; \ No newline at end of file diff --git a/packages/tempo/public/v4/api/assets/style.css b/packages/tempo/public/v4/api/assets/style.css new file mode 100644 index 00000000..ec257d51 --- /dev/null +++ b/packages/tempo/public/v4/api/assets/style.css @@ -0,0 +1,1648 @@ +@layer typedoc { + :root { + --dim-toolbar-contents-height: 2.5rem; + --dim-toolbar-border-bottom-width: 1px; + --dim-header-height: calc( + var(--dim-toolbar-border-bottom-width) + + var(--dim-toolbar-contents-height) + ); + + /* 0rem For mobile; unit is required for calculation in `calc` */ + --dim-container-main-margin-y: 0rem; + + --dim-footer-height: 3.5rem; + + --modal-animation-duration: 0.2s; + } + + :root { + /* Light */ + --light-color-background: #f2f4f8; + --light-color-background-secondary: #eff0f1; + /* Not to be confused with [:active](https://developer.mozilla.org/en-US/docs/Web/CSS/:active) */ + --light-color-background-active: #d6d8da; + --light-color-background-warning: #e6e600; + --light-color-warning-text: #222; + --light-color-accent: #c5c7c9; + --light-color-active-menu-item: var(--light-color-background-active); + --light-color-text: #222; + --light-color-contrast-text: #000; + --light-color-text-aside: #5e5e5e; + + --light-color-icon-background: var(--light-color-background); + --light-color-icon-text: var(--light-color-text); + + --light-color-comment-tag-text: var(--light-color-text); + --light-color-comment-tag: var(--light-color-background); + + --light-color-link: #1f70c2; + --light-color-focus-outline: #3584e4; + + --light-color-ts-keyword: #056bd6; + --light-color-ts-project: #b111c9; + --light-color-ts-module: var(--light-color-ts-project); + --light-color-ts-namespace: var(--light-color-ts-project); + --light-color-ts-enum: #7e6f15; + --light-color-ts-enum-member: var(--light-color-ts-enum); + --light-color-ts-variable: #4760ec; + --light-color-ts-function: #572be7; + --light-color-ts-class: #1f70c2; + --light-color-ts-interface: #108024; + --light-color-ts-constructor: var(--light-color-ts-class); + --light-color-ts-property: #9f5f30; + --light-color-ts-method: #be3989; + --light-color-ts-reference: #ff4d82; + --light-color-ts-call-signature: var(--light-color-ts-method); + --light-color-ts-index-signature: var(--light-color-ts-property); + --light-color-ts-constructor-signature: var( + --light-color-ts-constructor + ); + --light-color-ts-parameter: var(--light-color-ts-variable); + /* type literal not included as links will never be generated to it */ + --light-color-ts-type-parameter: #a55c0e; + --light-color-ts-accessor: #c73c3c; + --light-color-ts-get-signature: var(--light-color-ts-accessor); + --light-color-ts-set-signature: var(--light-color-ts-accessor); + --light-color-ts-type-alias: #d51270; + /* reference not included as links will be colored with the kind that it points to */ + --light-color-document: #000000; + + --light-color-alert-note: #0969d9; + --light-color-alert-tip: #1a7f37; + --light-color-alert-important: #8250df; + --light-color-alert-warning: #9a6700; + --light-color-alert-caution: #cf222e; + + --light-external-icon: url("data:image/svg+xml;utf8,"); + --light-color-scheme: light; + } + + :root { + /* Dark */ + --dark-color-background: #2b2e33; + --dark-color-background-secondary: #1e2024; + /* Not to be confused with [:active](https://developer.mozilla.org/en-US/docs/Web/CSS/:active) */ + --dark-color-background-active: #5d5d6a; + --dark-color-background-warning: #bebe00; + --dark-color-warning-text: #222; + --dark-color-accent: #9096a2; + --dark-color-active-menu-item: var(--dark-color-background-active); + --dark-color-text: #f5f5f5; + --dark-color-contrast-text: #ffffff; + --dark-color-text-aside: #dddddd; + + --dark-color-icon-background: var(--dark-color-background-secondary); + --dark-color-icon-text: var(--dark-color-text); + + --dark-color-comment-tag-text: var(--dark-color-text); + --dark-color-comment-tag: var(--dark-color-background); + + --dark-color-link: #00aff4; + --dark-color-focus-outline: #4c97f2; + + --dark-color-ts-keyword: #3399ff; + --dark-color-ts-project: #e358ff; + --dark-color-ts-module: var(--dark-color-ts-project); + --dark-color-ts-namespace: var(--dark-color-ts-project); + --dark-color-ts-enum: #f4d93e; + --dark-color-ts-enum-member: var(--dark-color-ts-enum); + --dark-color-ts-variable: #798dff; + --dark-color-ts-function: #a280ff; + --dark-color-ts-class: #8ac4ff; + --dark-color-ts-interface: #6cff87; + --dark-color-ts-constructor: var(--dark-color-ts-class); + --dark-color-ts-property: #ff984d; + --dark-color-ts-method: #ff4db8; + --dark-color-ts-reference: #ff4d82; + --dark-color-ts-call-signature: var(--dark-color-ts-method); + --dark-color-ts-index-signature: var(--dark-color-ts-property); + --dark-color-ts-constructor-signature: var(--dark-color-ts-constructor); + --dark-color-ts-parameter: var(--dark-color-ts-variable); + /* type literal not included as links will never be generated to it */ + --dark-color-ts-type-parameter: #e07d13; + --dark-color-ts-accessor: #ff6060; + --dark-color-ts-get-signature: var(--dark-color-ts-accessor); + --dark-color-ts-set-signature: var(--dark-color-ts-accessor); + --dark-color-ts-type-alias: #ff6492; + /* reference not included as links will be colored with the kind that it points to */ + --dark-color-document: #ffffff; + + --dark-color-alert-note: #0969d9; + --dark-color-alert-tip: #1a7f37; + --dark-color-alert-important: #8250df; + --dark-color-alert-warning: #9a6700; + --dark-color-alert-caution: #cf222e; + + --dark-external-icon: url("data:image/svg+xml;utf8,"); + --dark-color-scheme: dark; + } + + @media (prefers-color-scheme: light) { + :root { + --color-background: var(--light-color-background); + --color-background-secondary: var( + --light-color-background-secondary + ); + --color-background-active: var(--light-color-background-active); + --color-background-warning: var(--light-color-background-warning); + --color-warning-text: var(--light-color-warning-text); + --color-accent: var(--light-color-accent); + --color-active-menu-item: var(--light-color-active-menu-item); + --color-text: var(--light-color-text); + --color-contrast-text: var(--light-color-contrast-text); + --color-text-aside: var(--light-color-text-aside); + + --color-icon-background: var(--light-color-icon-background); + --color-icon-text: var(--light-color-icon-text); + + --color-comment-tag-text: var(--light-color-text); + --color-comment-tag: var(--light-color-background); + + --color-link: var(--light-color-link); + --color-focus-outline: var(--light-color-focus-outline); + + --color-ts-keyword: var(--light-color-ts-keyword); + --color-ts-project: var(--light-color-ts-project); + --color-ts-module: var(--light-color-ts-module); + --color-ts-namespace: var(--light-color-ts-namespace); + --color-ts-enum: var(--light-color-ts-enum); + --color-ts-enum-member: var(--light-color-ts-enum-member); + --color-ts-variable: var(--light-color-ts-variable); + --color-ts-function: var(--light-color-ts-function); + --color-ts-class: var(--light-color-ts-class); + --color-ts-interface: var(--light-color-ts-interface); + --color-ts-constructor: var(--light-color-ts-constructor); + --color-ts-property: var(--light-color-ts-property); + --color-ts-method: var(--light-color-ts-method); + --color-ts-reference: var(--light-color-ts-reference); + --color-ts-call-signature: var(--light-color-ts-call-signature); + --color-ts-index-signature: var(--light-color-ts-index-signature); + --color-ts-constructor-signature: var( + --light-color-ts-constructor-signature + ); + --color-ts-parameter: var(--light-color-ts-parameter); + --color-ts-type-parameter: var(--light-color-ts-type-parameter); + --color-ts-accessor: var(--light-color-ts-accessor); + --color-ts-get-signature: var(--light-color-ts-get-signature); + --color-ts-set-signature: var(--light-color-ts-set-signature); + --color-ts-type-alias: var(--light-color-ts-type-alias); + --color-document: var(--light-color-document); + + --color-alert-note: var(--light-color-alert-note); + --color-alert-tip: var(--light-color-alert-tip); + --color-alert-important: var(--light-color-alert-important); + --color-alert-warning: var(--light-color-alert-warning); + --color-alert-caution: var(--light-color-alert-caution); + + --external-icon: var(--light-external-icon); + --color-scheme: var(--light-color-scheme); + } + } + + @media (prefers-color-scheme: dark) { + :root { + --color-background: var(--dark-color-background); + --color-background-secondary: var( + --dark-color-background-secondary + ); + --color-background-active: var(--dark-color-background-active); + --color-background-warning: var(--dark-color-background-warning); + --color-warning-text: var(--dark-color-warning-text); + --color-accent: var(--dark-color-accent); + --color-active-menu-item: var(--dark-color-active-menu-item); + --color-text: var(--dark-color-text); + --color-contrast-text: var(--dark-color-contrast-text); + --color-text-aside: var(--dark-color-text-aside); + + --color-icon-background: var(--dark-color-icon-background); + --color-icon-text: var(--dark-color-icon-text); + + --color-comment-tag-text: var(--dark-color-text); + --color-comment-tag: var(--dark-color-background); + + --color-link: var(--dark-color-link); + --color-focus-outline: var(--dark-color-focus-outline); + + --color-ts-keyword: var(--dark-color-ts-keyword); + --color-ts-project: var(--dark-color-ts-project); + --color-ts-module: var(--dark-color-ts-module); + --color-ts-namespace: var(--dark-color-ts-namespace); + --color-ts-enum: var(--dark-color-ts-enum); + --color-ts-enum-member: var(--dark-color-ts-enum-member); + --color-ts-variable: var(--dark-color-ts-variable); + --color-ts-function: var(--dark-color-ts-function); + --color-ts-class: var(--dark-color-ts-class); + --color-ts-interface: var(--dark-color-ts-interface); + --color-ts-constructor: var(--dark-color-ts-constructor); + --color-ts-property: var(--dark-color-ts-property); + --color-ts-method: var(--dark-color-ts-method); + --color-ts-reference: var(--dark-color-ts-reference); + --color-ts-call-signature: var(--dark-color-ts-call-signature); + --color-ts-index-signature: var(--dark-color-ts-index-signature); + --color-ts-constructor-signature: var( + --dark-color-ts-constructor-signature + ); + --color-ts-parameter: var(--dark-color-ts-parameter); + --color-ts-type-parameter: var(--dark-color-ts-type-parameter); + --color-ts-accessor: var(--dark-color-ts-accessor); + --color-ts-get-signature: var(--dark-color-ts-get-signature); + --color-ts-set-signature: var(--dark-color-ts-set-signature); + --color-ts-type-alias: var(--dark-color-ts-type-alias); + --color-document: var(--dark-color-document); + + --color-alert-note: var(--dark-color-alert-note); + --color-alert-tip: var(--dark-color-alert-tip); + --color-alert-important: var(--dark-color-alert-important); + --color-alert-warning: var(--dark-color-alert-warning); + --color-alert-caution: var(--dark-color-alert-caution); + + --external-icon: var(--dark-external-icon); + --color-scheme: var(--dark-color-scheme); + } + } + + :root[data-theme="light"] { + --color-background: var(--light-color-background); + --color-background-secondary: var(--light-color-background-secondary); + --color-background-active: var(--light-color-background-active); + --color-background-warning: var(--light-color-background-warning); + --color-warning-text: var(--light-color-warning-text); + --color-icon-background: var(--light-color-icon-background); + --color-accent: var(--light-color-accent); + --color-active-menu-item: var(--light-color-active-menu-item); + --color-text: var(--light-color-text); + --color-contrast-text: var(--light-color-contrast-text); + --color-text-aside: var(--light-color-text-aside); + --color-icon-text: var(--light-color-icon-text); + + --color-comment-tag-text: var(--light-color-text); + --color-comment-tag: var(--light-color-background); + + --color-link: var(--light-color-link); + --color-focus-outline: var(--light-color-focus-outline); + + --color-ts-keyword: var(--light-color-ts-keyword); + --color-ts-project: var(--light-color-ts-project); + --color-ts-module: var(--light-color-ts-module); + --color-ts-namespace: var(--light-color-ts-namespace); + --color-ts-enum: var(--light-color-ts-enum); + --color-ts-enum-member: var(--light-color-ts-enum-member); + --color-ts-variable: var(--light-color-ts-variable); + --color-ts-function: var(--light-color-ts-function); + --color-ts-class: var(--light-color-ts-class); + --color-ts-interface: var(--light-color-ts-interface); + --color-ts-constructor: var(--light-color-ts-constructor); + --color-ts-property: var(--light-color-ts-property); + --color-ts-method: var(--light-color-ts-method); + --color-ts-reference: var(--light-color-ts-reference); + --color-ts-call-signature: var(--light-color-ts-call-signature); + --color-ts-index-signature: var(--light-color-ts-index-signature); + --color-ts-constructor-signature: var( + --light-color-ts-constructor-signature + ); + --color-ts-parameter: var(--light-color-ts-parameter); + --color-ts-type-parameter: var(--light-color-ts-type-parameter); + --color-ts-accessor: var(--light-color-ts-accessor); + --color-ts-get-signature: var(--light-color-ts-get-signature); + --color-ts-set-signature: var(--light-color-ts-set-signature); + --color-ts-type-alias: var(--light-color-ts-type-alias); + --color-document: var(--light-color-document); + + --color-note: var(--light-color-note); + --color-tip: var(--light-color-tip); + --color-important: var(--light-color-important); + --color-warning: var(--light-color-warning); + --color-caution: var(--light-color-caution); + + --external-icon: var(--light-external-icon); + --color-scheme: var(--light-color-scheme); + } + + :root[data-theme="dark"] { + --color-background: var(--dark-color-background); + --color-background-secondary: var(--dark-color-background-secondary); + --color-background-active: var(--dark-color-background-active); + --color-background-warning: var(--dark-color-background-warning); + --color-warning-text: var(--dark-color-warning-text); + --color-icon-background: var(--dark-color-icon-background); + --color-accent: var(--dark-color-accent); + --color-active-menu-item: var(--dark-color-active-menu-item); + --color-text: var(--dark-color-text); + --color-contrast-text: var(--dark-color-contrast-text); + --color-text-aside: var(--dark-color-text-aside); + --color-icon-text: var(--dark-color-icon-text); + + --color-comment-tag-text: var(--dark-color-text); + --color-comment-tag: var(--dark-color-background); + + --color-link: var(--dark-color-link); + --color-focus-outline: var(--dark-color-focus-outline); + + --color-ts-keyword: var(--dark-color-ts-keyword); + --color-ts-project: var(--dark-color-ts-project); + --color-ts-module: var(--dark-color-ts-module); + --color-ts-namespace: var(--dark-color-ts-namespace); + --color-ts-enum: var(--dark-color-ts-enum); + --color-ts-enum-member: var(--dark-color-ts-enum-member); + --color-ts-variable: var(--dark-color-ts-variable); + --color-ts-function: var(--dark-color-ts-function); + --color-ts-class: var(--dark-color-ts-class); + --color-ts-interface: var(--dark-color-ts-interface); + --color-ts-constructor: var(--dark-color-ts-constructor); + --color-ts-property: var(--dark-color-ts-property); + --color-ts-method: var(--dark-color-ts-method); + --color-ts-reference: var(--dark-color-ts-reference); + --color-ts-call-signature: var(--dark-color-ts-call-signature); + --color-ts-index-signature: var(--dark-color-ts-index-signature); + --color-ts-constructor-signature: var( + --dark-color-ts-constructor-signature + ); + --color-ts-parameter: var(--dark-color-ts-parameter); + --color-ts-type-parameter: var(--dark-color-ts-type-parameter); + --color-ts-accessor: var(--dark-color-ts-accessor); + --color-ts-get-signature: var(--dark-color-ts-get-signature); + --color-ts-set-signature: var(--dark-color-ts-set-signature); + --color-ts-type-alias: var(--dark-color-ts-type-alias); + --color-document: var(--dark-color-document); + + --color-note: var(--dark-color-note); + --color-tip: var(--dark-color-tip); + --color-important: var(--dark-color-important); + --color-warning: var(--dark-color-warning); + --color-caution: var(--dark-color-caution); + + --external-icon: var(--dark-external-icon); + --color-scheme: var(--dark-color-scheme); + } + + html { + color-scheme: var(--color-scheme); + @media (prefers-reduced-motion: no-preference) { + scroll-behavior: smooth; + } + } + + *:focus-visible, + .tsd-accordion-summary:focus-visible svg { + outline: 2px solid var(--color-focus-outline); + } + + .always-visible, + .always-visible .tsd-signatures { + display: inherit !important; + } + + h1, + h2, + h3, + h4, + h5, + h6 { + line-height: 1.2; + } + + h1 { + font-size: 1.875rem; + margin: 0.67rem 0; + } + + h2 { + font-size: 1.5rem; + margin: 0.83rem 0; + } + + h3 { + font-size: 1.25rem; + margin: 1rem 0; + } + + h4 { + font-size: 1.05rem; + margin: 1.33rem 0; + } + + h5 { + font-size: 1rem; + margin: 1.5rem 0; + } + + h6 { + font-size: 0.875rem; + margin: 2.33rem 0; + } + + dl, + menu, + ol, + ul { + margin: 1em 0; + } + + dd { + margin: 0 0 0 34px; + } + + .container { + max-width: 1700px; + padding: 0 2rem; + } + + /* Footer */ + footer { + border-top: 1px solid var(--color-accent); + padding-top: 1rem; + padding-bottom: 1rem; + max-height: var(--dim-footer-height); + } + footer > p { + margin: 0 1em; + } + + .container-main { + margin: var(--dim-container-main-margin-y) auto; + /* toolbar, footer, margin */ + min-height: calc( + 100svh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + } + + @keyframes fade-in { + from { + opacity: 0; + } + to { + opacity: 1; + } + } + @keyframes fade-out { + from { + opacity: 1; + visibility: visible; + } + to { + opacity: 0; + } + } + @keyframes pop-in-from-right { + from { + transform: translate(100%, 0); + } + to { + transform: translate(0, 0); + } + } + @keyframes pop-out-to-right { + from { + transform: translate(0, 0); + visibility: visible; + } + to { + transform: translate(100%, 0); + } + } + body { + background: var(--color-background); + font-family: + -apple-system, + BlinkMacSystemFont, + "Segoe UI", + "Noto Sans", + Helvetica, + Arial, + sans-serif, + "Apple Color Emoji", + "Segoe UI Emoji"; + font-size: 16px; + color: var(--color-text); + margin: 0; + } + + a { + color: var(--color-link); + text-decoration: none; + } + a:hover { + text-decoration: underline; + } + a.external[target="_blank"] { + background-image: var(--external-icon); + background-position: top 3px right; + background-repeat: no-repeat; + padding-right: 13px; + } + a.tsd-anchor-link { + color: var(--color-text); + } + :target { + scroll-margin-block: calc(var(--dim-header-height) + 0.5rem); + } + + math[display="block"] { + position: relative; + padding: 10px; + border: 1px solid var(--color-accent); + border-radius: 0.8em; + margin-bottom: 8px; + } + + code, + pre { + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; + padding: 0.2em; + margin: 0; + font-size: 0.875rem; + border-radius: 0.8em; + } + + pre { + position: relative; + white-space: pre-wrap; + word-wrap: break-word; + padding: 10px; + border: 1px solid var(--color-accent); + margin-bottom: 8px; + } + pre code { + padding: 0; + font-size: 100%; + } + pre > button { + position: absolute; + top: 10px; + right: 10px; + opacity: 0; + transition: opacity 0.1s; + box-sizing: border-box; + } + pre:hover > button, + pre > button.visible, + pre > button:focus-visible { + opacity: 1; + } + + blockquote { + margin: 1em 0; + padding-left: 1em; + border-left: 4px solid gray; + } + + img { + max-width: 100%; + } + + * { + scrollbar-width: thin; + scrollbar-color: var(--color-accent) var(--color-icon-background); + } + + *::-webkit-scrollbar { + width: 0.75rem; + } + + *::-webkit-scrollbar-track { + background: var(--color-icon-background); + } + + *::-webkit-scrollbar-thumb { + background-color: var(--color-accent); + border-radius: 999rem; + border: 0.25rem solid var(--color-icon-background); + } + + dialog { + border: none; + outline: none; + padding: 0; + background-color: var(--color-background); + } + dialog::backdrop { + display: none; + } + #tsd-overlay { + background-color: rgba(0, 0, 0, 0.5); + position: fixed; + z-index: 9999; + top: 0; + left: 0; + right: 0; + bottom: 0; + animation: fade-in var(--modal-animation-duration) forwards; + } + #tsd-overlay.closing { + animation-name: fade-out; + } + + .tsd-typography { + line-height: 1.333em; + } + .tsd-typography ul { + list-style: square; + padding: 0 0 0 20px; + margin: 0; + } + .tsd-typography .tsd-index-panel h3, + .tsd-index-panel .tsd-typography h3, + .tsd-typography h4, + .tsd-typography h5, + .tsd-typography h6 { + font-size: 1em; + } + .tsd-typography h5, + .tsd-typography h6 { + font-weight: normal; + } + .tsd-typography p, + .tsd-typography ul, + .tsd-typography ol { + margin: 1em 0; + } + .tsd-typography table { + border-collapse: collapse; + border: none; + } + .tsd-typography td, + .tsd-typography th { + padding: 6px 13px; + border: 1px solid var(--color-accent); + } + .tsd-typography thead, + .tsd-typography tr:nth-child(even) { + background-color: var(--color-background-secondary); + } + + .tsd-alert { + padding: 8px 16px; + margin-bottom: 16px; + border-left: 0.25em solid var(--alert-color); + } + .tsd-alert blockquote > :last-child, + .tsd-alert > :last-child { + margin-bottom: 0; + } + .tsd-alert-title { + color: var(--alert-color); + display: inline-flex; + align-items: center; + } + .tsd-alert-title span { + margin-left: 4px; + } + + .tsd-alert-note { + --alert-color: var(--color-alert-note); + } + .tsd-alert-tip { + --alert-color: var(--color-alert-tip); + } + .tsd-alert-important { + --alert-color: var(--color-alert-important); + } + .tsd-alert-warning { + --alert-color: var(--color-alert-warning); + } + .tsd-alert-caution { + --alert-color: var(--color-alert-caution); + } + + .tsd-breadcrumb { + margin: 0; + margin-top: 1rem; + padding: 0; + color: var(--color-text-aside); + } + .tsd-breadcrumb a { + color: var(--color-text-aside); + text-decoration: none; + } + .tsd-breadcrumb a:hover { + text-decoration: underline; + } + .tsd-breadcrumb li { + display: inline; + } + .tsd-breadcrumb li:after { + content: " / "; + } + + .tsd-comment-tags { + display: flex; + flex-direction: column; + } + dl.tsd-comment-tag-group { + display: flex; + align-items: center; + overflow: hidden; + margin: 0.5em 0; + } + dl.tsd-comment-tag-group dt { + display: flex; + margin-right: 0.5em; + font-size: 0.875em; + font-weight: normal; + } + dl.tsd-comment-tag-group dd { + margin: 0; + } + code.tsd-tag { + padding: 0.25em 0.4em; + border: 0.1em solid var(--color-accent); + margin-right: 0.25em; + font-size: 70%; + } + h1 code.tsd-tag:first-of-type { + margin-left: 0.25em; + } + + dl.tsd-comment-tag-group dd:before, + dl.tsd-comment-tag-group dd:after { + content: " "; + } + dl.tsd-comment-tag-group dd pre, + dl.tsd-comment-tag-group dd:after { + clear: both; + } + dl.tsd-comment-tag-group p { + margin: 0; + } + + .tsd-panel.tsd-comment .lead { + font-size: 1.1em; + line-height: 1.333em; + margin-bottom: 2em; + } + .tsd-panel.tsd-comment .lead:last-child { + margin-bottom: 0; + } + + .tsd-filter-visibility h4 { + font-size: 1rem; + padding-top: 0.75rem; + padding-bottom: 0.5rem; + margin: 0; + } + .tsd-filter-item:not(:last-child) { + margin-bottom: 0.5rem; + } + .tsd-filter-input { + display: flex; + width: -moz-fit-content; + width: fit-content; + align-items: center; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + } + .tsd-filter-input input[type="checkbox"] { + cursor: pointer; + position: absolute; + width: 1.5em; + height: 1.5em; + opacity: 0; + } + .tsd-filter-input input[type="checkbox"]:disabled { + pointer-events: none; + } + .tsd-filter-input svg { + cursor: pointer; + width: 1.5em; + height: 1.5em; + margin-right: 0.5em; + border-radius: 0.33em; + /* Leaving this at full opacity breaks event listeners on Firefox. + Don't remove unless you know what you're doing. */ + opacity: 0.99; + } + .tsd-filter-input input[type="checkbox"]:focus-visible + svg { + outline: 2px solid var(--color-focus-outline); + } + .tsd-checkbox-background { + fill: var(--color-accent); + } + input[type="checkbox"]:checked ~ svg .tsd-checkbox-checkmark { + stroke: var(--color-text); + } + .tsd-filter-input input:disabled ~ svg > .tsd-checkbox-background { + fill: var(--color-background); + stroke: var(--color-accent); + stroke-width: 0.25rem; + } + .tsd-filter-input input:disabled ~ svg > .tsd-checkbox-checkmark { + stroke: var(--color-accent); + } + + .settings-label { + font-weight: bold; + text-transform: uppercase; + display: inline-block; + } + + .tsd-filter-visibility .settings-label { + margin: 0.75rem 0 0.5rem 0; + } + + .tsd-theme-toggle .settings-label { + margin: 0.75rem 0.75rem 0 0; + } + + .tsd-hierarchy h4 label:hover span { + text-decoration: underline; + } + + .tsd-hierarchy { + list-style: square; + margin: 0; + } + .tsd-hierarchy-target { + font-weight: bold; + } + .tsd-hierarchy-toggle { + color: var(--color-link); + cursor: pointer; + } + + .tsd-full-hierarchy:not(:last-child) { + margin-bottom: 1em; + padding-bottom: 1em; + border-bottom: 1px solid var(--color-accent); + } + .tsd-full-hierarchy, + .tsd-full-hierarchy ul { + list-style: none; + margin: 0; + padding: 0; + } + .tsd-full-hierarchy ul { + padding-left: 1.5rem; + } + .tsd-full-hierarchy a { + padding: 0.25rem 0 !important; + font-size: 1rem; + display: inline-flex; + align-items: center; + color: var(--color-text); + } + .tsd-full-hierarchy svg[data-dropdown] { + cursor: pointer; + } + .tsd-full-hierarchy svg[data-dropdown="false"] { + transform: rotate(-90deg); + } + .tsd-full-hierarchy svg[data-dropdown="false"] ~ ul { + display: none; + } + + .tsd-panel-group.tsd-index-group { + margin-bottom: 0; + } + .tsd-index-panel .tsd-index-list { + list-style: none; + line-height: 1.333em; + margin: 0; + padding: 0.25rem 0 0 0; + overflow: hidden; + display: grid; + grid-template-columns: repeat(3, 1fr); + column-gap: 1rem; + grid-template-rows: auto; + } + @media (max-width: 1024px) { + .tsd-index-panel .tsd-index-list { + grid-template-columns: repeat(2, 1fr); + } + } + @media (max-width: 768px) { + .tsd-index-panel .tsd-index-list { + grid-template-columns: repeat(1, 1fr); + } + } + .tsd-index-panel .tsd-index-list li { + -webkit-page-break-inside: avoid; + -moz-page-break-inside: avoid; + -ms-page-break-inside: avoid; + -o-page-break-inside: avoid; + page-break-inside: avoid; + } + + .tsd-flag { + display: inline-block; + padding: 0.25em 0.4em; + border-radius: 4px; + color: var(--color-comment-tag-text); + background-color: var(--color-comment-tag); + text-indent: 0; + font-size: 75%; + line-height: 1; + font-weight: normal; + } + + .tsd-anchor { + position: relative; + top: -100px; + } + + .tsd-member { + position: relative; + } + .tsd-member .tsd-anchor + h3 { + display: flex; + align-items: center; + margin-top: 0; + margin-bottom: 0; + border-bottom: none; + } + + .tsd-navigation.settings { + margin: 0; + margin-bottom: 1rem; + } + .tsd-navigation > a, + .tsd-navigation .tsd-accordion-summary { + width: calc(100% - 0.25rem); + display: flex; + align-items: center; + } + .tsd-navigation a, + .tsd-navigation summary > span, + .tsd-page-navigation a { + display: flex; + width: calc(100% - 0.25rem); + align-items: center; + padding: 0.25rem; + color: var(--color-text); + text-decoration: none; + box-sizing: border-box; + } + .tsd-navigation a.current, + .tsd-page-navigation a.current { + background: var(--color-active-menu-item); + color: var(--color-contrast-text); + } + .tsd-navigation a:hover, + .tsd-page-navigation a:hover { + text-decoration: underline; + } + .tsd-navigation ul, + .tsd-page-navigation ul { + margin-top: 0; + margin-bottom: 0; + padding: 0; + list-style: none; + } + .tsd-navigation li, + .tsd-page-navigation li { + padding: 0; + max-width: 100%; + } + .tsd-navigation .tsd-nav-link { + display: none; + } + .tsd-nested-navigation { + margin-left: 3rem; + } + .tsd-nested-navigation > li > details { + margin-left: -1.5rem; + } + .tsd-small-nested-navigation { + margin-left: 1.5rem; + } + .tsd-small-nested-navigation > li > details { + margin-left: -1.5rem; + } + + .tsd-page-navigation-section > summary { + padding: 0.25rem; + } + .tsd-page-navigation-section > summary > svg { + margin-right: 0.25rem; + } + .tsd-page-navigation-section > div { + margin-left: 30px; + } + .tsd-page-navigation ul { + padding-left: 1.75rem; + } + + #tsd-sidebar-links a { + margin-top: 0; + margin-bottom: 0.5rem; + line-height: 1.25rem; + } + #tsd-sidebar-links a:last-of-type { + margin-bottom: 0; + } + + a.tsd-index-link { + padding: 0.25rem 0 !important; + font-size: 1rem; + line-height: 1.25rem; + display: inline-flex; + align-items: center; + color: var(--color-text); + } + .tsd-accordion-summary { + list-style-type: none; /* hide marker on non-safari */ + outline: none; /* broken on safari, so just hide it */ + display: flex; + align-items: center; + gap: 0.25rem; + box-sizing: border-box; + } + .tsd-accordion-summary::-webkit-details-marker { + display: none; /* hide marker on safari */ + } + .tsd-accordion-summary, + .tsd-accordion-summary a { + -moz-user-select: none; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; + + cursor: pointer; + } + .tsd-accordion-summary > a { + width: calc(100% - 1.5rem); + } + .tsd-accordion-summary > * { + margin-top: 0; + margin-bottom: 0; + padding-top: 0; + padding-bottom: 0; + } + /* + * We need to be careful to target the arrow indicating whether the accordion + * is open, but not any other SVGs included in the details element. + */ + .tsd-accordion:not([open]) > .tsd-accordion-summary > svg:first-child { + transform: rotate(-90deg); + } + .tsd-index-content > :not(:first-child) { + margin-top: 0.75rem; + } + .tsd-index-summary { + margin-top: 1.5rem; + margin-bottom: 0.75rem; + display: flex; + align-content: center; + } + + .tsd-no-select { + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + } + .tsd-kind-icon { + margin-right: 0.5rem; + width: 1.25rem; + height: 1.25rem; + min-width: 1.25rem; + min-height: 1.25rem; + } + .tsd-signature > .tsd-kind-icon { + margin-right: 0.8rem; + } + + .tsd-panel { + margin-bottom: 2.5rem; + } + .tsd-panel.tsd-member { + margin-bottom: 4rem; + } + .tsd-panel:empty { + display: none; + } + .tsd-panel > h1, + .tsd-panel > h2, + .tsd-panel > h3 { + margin: 1.5rem -1.5rem 0.75rem -1.5rem; + padding: 0 1.5rem 0.75rem 1.5rem; + } + .tsd-panel > h1.tsd-before-signature, + .tsd-panel > h2.tsd-before-signature, + .tsd-panel > h3.tsd-before-signature { + margin-bottom: 0; + border-bottom: none; + } + + .tsd-panel-group { + margin: 2rem 0; + } + .tsd-panel-group.tsd-index-group { + margin: 2rem 0; + } + .tsd-panel-group.tsd-index-group details { + margin: 2rem 0; + } + .tsd-panel-group > .tsd-accordion-summary { + margin-bottom: 1rem; + } + + #tsd-search[open] { + animation: fade-in var(--modal-animation-duration) ease-out forwards; + } + #tsd-search[open].closing { + animation-name: fade-out; + } + + /* Avoid setting `display` on closed dialog */ + #tsd-search[open] { + display: flex; + flex-direction: column; + padding: 1rem; + width: 32rem; + max-width: 90vw; + max-height: calc(100vh - env(keyboard-inset-height, 0px) - 25vh); + /* Anchor dialog to top */ + margin-top: 10vh; + border-radius: 6px; + will-change: max-height; + } + #tsd-search-input { + box-sizing: border-box; + width: 100%; + padding: 0 0.625rem; /* 10px */ + outline: 0; + border: 2px solid var(--color-accent); + background-color: transparent; + color: var(--color-text); + border-radius: 4px; + height: 2.5rem; + flex: 0 0 auto; + font-size: 0.875rem; + transition: border-color 0.2s, background-color 0.2s; + } + #tsd-search-input:focus-visible { + background-color: var(--color-background-active); + border-color: transparent; + color: var(--color-contrast-text); + } + #tsd-search-input::placeholder { + color: inherit; + opacity: 0.8; + } + #tsd-search-results { + margin: 0; + padding: 0; + list-style: none; + flex: 1 1 auto; + display: flex; + flex-direction: column; + overflow-y: auto; + } + #tsd-search-results:not(:empty) { + margin-top: 0.5rem; + } + #tsd-search-results > li { + background-color: var(--color-background); + line-height: 1.5; + box-sizing: border-box; + border-radius: 4px; + } + #tsd-search-results > li:nth-child(even) { + background-color: var(--color-background-secondary); + } + #tsd-search-results > li:is(:hover, [aria-selected="true"]) { + background-color: var(--color-background-active); + color: var(--color-contrast-text); + } + /* It's important that this takes full size of parent `li`, to capture a click on `li` */ + #tsd-search-results > li > a { + display: flex; + align-items: center; + padding: 0.5rem 0.25rem; + box-sizing: border-box; + width: 100%; + } + #tsd-search-results > li > a > .text { + flex: 1 1 auto; + min-width: 0; + overflow-wrap: anywhere; + } + #tsd-search-results > li > a .parent { + color: var(--color-text-aside); + } + #tsd-search-results > li > a mark { + color: inherit; + background-color: inherit; + font-weight: bold; + } + #tsd-search-status { + flex: 1; + display: grid; + place-content: center; + text-align: center; + overflow-wrap: anywhere; + } + #tsd-search-status:not(:empty) { + min-height: 6rem; + } + + .tsd-signature { + margin: 0 0 1rem 0; + padding: 1rem 0.5rem; + border: 1px solid var(--color-accent); + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; + font-size: 14px; + overflow-x: auto; + } + + .tsd-signature-keyword { + color: var(--color-ts-keyword); + font-weight: normal; + } + + .tsd-signature-symbol { + color: var(--color-text-aside); + font-weight: normal; + } + + .tsd-signature-type { + font-style: italic; + font-weight: normal; + } + + .tsd-signatures { + padding: 0; + margin: 0 0 1em 0; + list-style-type: none; + } + .tsd-signatures .tsd-signature { + margin: 0; + border-color: var(--color-accent); + border-width: 1px 0; + transition: background-color 0.1s; + } + .tsd-signatures .tsd-index-signature:not(:last-child) { + margin-bottom: 1em; + } + .tsd-signatures .tsd-index-signature .tsd-signature { + border-width: 1px; + } + .tsd-description .tsd-signatures .tsd-signature { + border-width: 1px; + } + + ul.tsd-parameter-list, + ul.tsd-type-parameter-list { + list-style: square; + margin: 0; + padding-left: 20px; + } + ul.tsd-parameter-list > li.tsd-parameter-signature, + ul.tsd-type-parameter-list > li.tsd-parameter-signature { + list-style: none; + margin-left: -20px; + } + ul.tsd-parameter-list h5, + ul.tsd-type-parameter-list h5 { + font-size: 16px; + margin: 1em 0 0.5em 0; + } + .tsd-sources { + margin-top: 1rem; + font-size: 0.875em; + } + .tsd-sources a { + color: var(--color-text-aside); + text-decoration: underline; + } + .tsd-sources ul { + list-style: none; + padding: 0; + } + + .tsd-page-toolbar { + position: sticky; + z-index: 1; + top: 0; + left: 0; + width: 100%; + color: var(--color-text); + background: var(--color-background-secondary); + border-bottom: var(--dim-toolbar-border-bottom-width) + var(--color-accent) solid; + transition: transform 0.3s ease-in-out; + } + .tsd-page-toolbar a { + color: var(--color-text); + } + .tsd-toolbar-contents { + display: flex; + align-items: center; + height: var(--dim-toolbar-contents-height); + margin: 0 auto; + } + .tsd-toolbar-contents > .title { + font-weight: bold; + margin-right: auto; + } + #tsd-toolbar-links { + display: flex; + align-items: center; + gap: 1.5rem; + margin-right: 1rem; + } + + .tsd-widget { + box-sizing: border-box; + display: inline-block; + opacity: 0.8; + height: 2.5rem; + width: 2.5rem; + transition: opacity 0.1s, background-color 0.1s; + text-align: center; + cursor: pointer; + border: none; + background-color: transparent; + } + .tsd-widget:hover { + opacity: 0.9; + } + .tsd-widget:active { + opacity: 1; + background-color: var(--color-accent); + } + #tsd-toolbar-menu-trigger { + display: none; + } + + .tsd-member-summary-name { + display: inline-flex; + align-items: center; + padding: 0.25rem; + text-decoration: none; + } + + .tsd-anchor-icon { + display: inline-flex; + align-items: center; + margin-left: 0.5rem; + color: var(--color-text); + vertical-align: middle; + } + + .tsd-anchor-icon svg { + width: 1em; + height: 1em; + visibility: hidden; + } + + .tsd-member-summary-name:hover > .tsd-anchor-icon svg, + .tsd-anchor-link:hover > .tsd-anchor-icon svg, + .tsd-anchor-icon:focus-visible svg { + visibility: visible; + } + + .deprecated { + text-decoration: line-through !important; + } + + .warning { + padding: 1rem; + color: var(--color-warning-text); + background: var(--color-background-warning); + } + + .tsd-kind-project { + color: var(--color-ts-project); + } + .tsd-kind-module { + color: var(--color-ts-module); + } + .tsd-kind-namespace { + color: var(--color-ts-namespace); + } + .tsd-kind-enum { + color: var(--color-ts-enum); + } + .tsd-kind-enum-member { + color: var(--color-ts-enum-member); + } + .tsd-kind-variable { + color: var(--color-ts-variable); + } + .tsd-kind-function { + color: var(--color-ts-function); + } + .tsd-kind-class { + color: var(--color-ts-class); + } + .tsd-kind-interface { + color: var(--color-ts-interface); + } + .tsd-kind-constructor { + color: var(--color-ts-constructor); + } + .tsd-kind-property { + color: var(--color-ts-property); + } + .tsd-kind-method { + color: var(--color-ts-method); + } + .tsd-kind-reference { + color: var(--color-ts-reference); + } + .tsd-kind-call-signature { + color: var(--color-ts-call-signature); + } + .tsd-kind-index-signature { + color: var(--color-ts-index-signature); + } + .tsd-kind-constructor-signature { + color: var(--color-ts-constructor-signature); + } + .tsd-kind-parameter { + color: var(--color-ts-parameter); + } + .tsd-kind-type-parameter { + color: var(--color-ts-type-parameter); + } + .tsd-kind-accessor { + color: var(--color-ts-accessor); + } + .tsd-kind-get-signature { + color: var(--color-ts-get-signature); + } + .tsd-kind-set-signature { + color: var(--color-ts-set-signature); + } + .tsd-kind-type-alias { + color: var(--color-ts-type-alias); + } + + /* if we have a kind icon, don't color the text by kind */ + .tsd-kind-icon ~ span { + color: var(--color-text); + } + + /* mobile */ + @media (max-width: 769px) { + #tsd-toolbar-menu-trigger { + display: inline-block; + /* temporary fix to vertically align, for compatibility */ + line-height: 2.5; + } + #tsd-toolbar-links { + display: none; + } + + .container-main { + display: flex; + } + .col-content { + float: none; + max-width: 100%; + width: 100%; + } + .col-sidebar { + position: fixed !important; + overflow-y: auto; + -webkit-overflow-scrolling: touch; + z-index: 1024; + top: 0 !important; + bottom: 0 !important; + left: auto !important; + right: 0 !important; + padding: 1.5rem 1.5rem 0 0; + width: 75vw; + visibility: hidden; + background-color: var(--color-background); + transform: translate(100%, 0); + } + .col-sidebar > *:last-child { + padding-bottom: 20px; + } + .overlay { + content: ""; + display: block; + position: fixed; + z-index: 1023; + top: 0; + left: 0; + right: 0; + bottom: 0; + background-color: rgba(0, 0, 0, 0.75); + visibility: hidden; + } + + .to-has-menu .overlay { + animation: fade-in 0.4s; + } + + .to-has-menu .col-sidebar { + animation: pop-in-from-right 0.4s; + } + + .from-has-menu .overlay { + animation: fade-out 0.4s; + } + + .from-has-menu .col-sidebar { + animation: pop-out-to-right 0.4s; + } + + .has-menu body { + overflow: hidden; + } + .has-menu .overlay { + visibility: visible; + } + .has-menu .col-sidebar { + visibility: visible; + transform: translate(0, 0); + display: flex; + flex-direction: column; + gap: 1.5rem; + max-height: 100vh; + padding: 1rem 2rem; + } + .has-menu .tsd-navigation { + max-height: 100%; + } + .tsd-navigation .tsd-nav-link { + display: flex; + } + } + + /* one sidebar */ + @media (min-width: 770px) { + .container-main { + display: grid; + grid-template-columns: minmax(0, 1fr) minmax(0, 2fr); + grid-template-areas: "sidebar content"; + --dim-container-main-margin-y: 2rem; + } + + .tsd-breadcrumb { + margin-top: 0; + } + + .col-sidebar { + grid-area: sidebar; + } + .col-content { + grid-area: content; + padding: 0 1rem; + } + } + @media (min-width: 770px) and (max-width: 1399px) { + .col-sidebar { + max-height: calc( + 100vh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + overflow: auto; + position: sticky; + top: calc( + var(--dim-header-height) + var(--dim-container-main-margin-y) + ); + } + .site-menu { + margin-top: 1rem; + } + } + + /* two sidebars */ + @media (min-width: 1200px) { + .container-main { + grid-template-columns: + minmax(0, 1fr) minmax(0, 2.5fr) minmax( + 0, + 20rem + ); + grid-template-areas: "sidebar content toc"; + } + + .col-sidebar { + display: contents; + } + + .page-menu { + grid-area: toc; + padding-left: 1rem; + } + .site-menu { + grid-area: sidebar; + } + + .site-menu { + margin-top: 0rem; + } + + .page-menu, + .site-menu { + max-height: calc( + 100vh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + overflow: auto; + position: sticky; + top: calc( + var(--dim-header-height) + var(--dim-container-main-margin-y) + ); + } + } +} diff --git a/packages/tempo/public/v4/api/classes/Interval.html b/packages/tempo/public/v4/api/classes/Interval.html new file mode 100644 index 00000000..dc569af9 --- /dev/null +++ b/packages/tempo/public/v4/api/classes/Interval.html @@ -0,0 +1,227 @@ +Interval | Tempo API
+
Tempo API + +
    +
    +
    Preparing search index...
    +
    +
    +
    + +

    Class Interval<T>

    +
    +

    Represents a continuous span of time with optional start and end boundaries, supporting set operations.

    +
    +
    +

    Type Parameters

    +
      +
    • T extends TemporalPoint = TemporalPoint
    +
    +
    +
    +
    Index
     +
    +
    + +
    constructor +
    +
    + +
    end +endNs +start +startNs +
    +
    + +
    abuts +contains +intersection +overlaps +union +
    +
    + +
    +
    + +
      +
    • + +
      +
      +

      Type Parameters

      +
        +
      • T extends unknown = any
      +
      +

      Parameters

      +
        +
      • start: T | null
        • +
      • end: T | null
      +

      Returns Interval<T>

    +
    + +
    +
    + +
      +
    • +
      get end(): T | null
      +
      +

      The end point of the interval, or null for unbounded end

      +
      +

      Returns T | null

    +
    + +
      +
    • +
      get endNs(): number | bigint
      +
      +

      The end time in nanoseconds since epoch, or Infinity for unbounded end

      +
      +

      Returns number | bigint

    +
    + +
      +
    • +
      get start(): T | null
      +
      +

      The start point of the interval, or null for unbounded start

      +
      +

      Returns T | null

    +
    + +
      +
    • +
      get startNs(): number | bigint
      +
      +

      The start time in nanoseconds since epoch, or -Infinity for unbounded start

      +
      +

      Returns number | bigint

    +
    + +
    +
    + +
      +
    • + +
      +

      Returns true if this interval starts exactly when the other ends, or vice versa

      +
      +
      +

      Parameters

      +
      +

      Returns boolean

    +
    + +
      +
    • + +
      +

      Returns true if the specified temporal point is within this interval

      +
      +
      +

      Parameters

      +
        +
      • point: any
      +

      Returns boolean

    +
    + +
      +
    • + +
      +

      Returns the intersection of this interval and another, or null if they do not overlap

      +
      +
      +

      Type Parameters

      +
        +
      • U extends unknown = T
      +
      +

      Parameters

      +
      +

      Returns Interval<T | U> | null

    +
    + +
      +
    • + +
      +

      Returns true if this interval overlaps with another interval

      +
      +
      +

      Parameters

      +
      +

      Returns boolean

    +
    + +
      +
    • + +
      +

      Returns the union of this interval and another, or null if they do not overlap/abut

      +
      +
      +

      Type Parameters

      +
        +
      • U extends unknown = T
      +
      +

      Parameters

      +
      +

      Returns Interval<T | U> | null

    +
    +
    +
    +
    +

    Settings

     +
    +
    Member Visibility +
      +
      • +
      • +
    +
    +
    +

    On This Page

     +
    +
    Constructors +
    +
    Accessors +
    +
    Methods +
    +
    + +
    +
    diff --git a/packages/tempo/public/v4/api/classes/Tempo.html b/packages/tempo/public/v4/api/classes/Tempo.html new file mode 100644 index 00000000..c8566720 --- /dev/null +++ b/packages/tempo/public/v4/api/classes/Tempo.html @@ -0,0 +1,2079 @@ +Tempo | Tempo API
    +
    Tempo API + +
      +
      +
      Preparing search index...
      +
      +
      +
      + +

      Class Tempo

      +
      +

      A powerful wrapper around Temporal.ZonedDateTime for flexible parsing and intuitive manipulation of date-time objects. +Bridges the gap between raw string/number inputs and the strict requirements of the ECMAScript Temporal API.

      +
      +
      +
      +
      +
      Index
       +
      +
      + +
      constructor +
      +
      + +
      Interval +
      +
      + +
      cal +config +day +dd +dim +dow +doy +eon +epoch +era +eraYear +ff +fmt +geo +hh +intl +iso +isValid +jj +locale +mi +mm +mmm +mon +ms +nano +ns +parse +ranges +sphere +ss +term +terms +ts +tz +us +wkd +woy +ww +www +yow +yy +zdt +cache +CACHE +config +default +discovery +enums +epoch +FORMAT +ignores +instant +intl +LIMIT +MODE +MONTH_DAY +NUMBER +options +ORDINAL +parse +properties +registry +terms +TIMEZONE +version +versions +weakCache +
      +
      + +
      [iterator] +[toPrimitive] +add +clone +format +nextOccurrence +set +setCatchMode +since +subtract +toDate +toDateTime +toInstant +toJSON +toNow +toPlainDate +toPlainDateTime +toPlainTime +toString +until +[dispose] +[hasInstance] +[iterator] +bootstrap +compare +create +extend +from +init +isTempo +now +ready +regexp +setCatchMode +use +
      +
      + +
      +
      + +
        +
      • + +
        +

        Instantiates a new Tempo object with configuration only.

        +
        +
        +

        Parameters

        +
          +
        • Optionaloptions: Options +

          Configuration options for this specific instance.

          +
        +

        Returns Tempo

        • +
      • + +
        +

        Instantiates a new Tempo object with a value.

        +
        +
        +

        Parameters

        +
          +
        • tempo: DateTime +

          The date-time value to parse.

          +
          • +
        • Optionaloptions: Options +

          Configuration options for this specific instance.

          +
        +

        Returns Tempo

      +
      + +
      +
      + +
      Interval: IntervalConstructor = ...
      +

      Interval class for checking overlaps and bounds between Temporal points

      +
      +
      + +
      +
      + +
        +
      • +
        get cal(): string
        +
        +

        Temporal Calendar ID (e.g., 'iso8601' | 'gregory')

        +
        +

        Returns string

      +
      + +
        +
      • +
        get config(): Readonly<t.Internal.Config>
        +
        +

        current Tempo configuration

        +
        +

        Returns Readonly<t.Internal.Config>

      +
      + +
        +
      • +
        get day(): dd
        +
        +

        Day of the month (1-31).

        +
        +

        Returns dd

        +
        +
        +

        Use dd (Tempo canonical) or zdt.day instead. To be removed in v5.0.0.

        +
      +
      + +
        +
      • +
        get dd(): dd
        +
        +

        Day of the month (1-31)

        +
        +

        Returns dd

      +
      + +
        +
      • +
        get dim(): number
        +
        +

        Total days in the current month, using the instance calendar.

        +
        +

        Returns number

      +
      + +
        +
      • +
        get dow(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
        +
        +

        iso weekday number: Mon=1, Sun=7

        +
        +

        Returns 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

      +
      + +
        +
      • +
        get doy(): number
        +
        +

        Day of year: 1-366

        +
        +

        Returns number

      +
      + +
        +
      • +
        get eon(): number | undefined
        +
        +

        Year within the era (positive integer)

        +
        +

        Returns number | undefined

      +
      + +
        +
      • +
        get epoch(): Readonly<{ ms: number; ns: bigint; ss: number; us: number }>
        +
        +

        units since epoch for this date-time instance

        +
        +

        Returns Readonly<{ ms: number; ns: bigint; ss: number; us: number }>

      +
      + +
        +
      • +
        get era(): string | undefined
        +
        +

        Era string for the calendar (e.g., 'ce', 'bce')

        +
        +

        Returns string | undefined

      +
      + +
        +
      • +
        get eraYear(): number | undefined
        +
        +

        Year within the era (positive integer).

        +
        +

        Returns number | undefined

        +
        +
        +

        Use eon (Tempo canonical) or zdt.eraYear instead. To be removed in v5.0.0.

        +
      +
      + +
        +
      • +
        get ff(): number
        +
        +

        Fractional seconds (e.g., 0.123456789)

        +
        +

        Returns number

      +
      + +
        +
      • +
        get fmt(): Record<string, string | undefined>
        +
        +

        Formatted results for all pre-defined format codes

        +
        +

        Returns Record<string, string | undefined>

      +
      + +
        +
      • +
        get geo(): Readonly<GeoConfig> | undefined
        +
        +

        Resolved geographic coordinates object ({ latitude, longitude, ... })

        +
        +

        Returns Readonly<GeoConfig> | undefined

      +
      + +
        +
      • +
        get hh(): hh
        +
        +

        Hour of the day (0-23)

        +
        +

        Returns hh

      +
      + +
        +
      • +
        get intl(): TempoIntlNamespace
        +
        +

        Internationalization namespace (info, locale, and cultural metadata)

        +
        +

        Returns TempoIntlNamespace

      +
      + +
        +
      • +
        get iso(): string
        +
        +

        Standard ISO 8601 string in UTC

        +
        +

        Returns string

      +
      + +
        +
      • +
        get isValid(): boolean | ZonedDateTime
        +
        +

        true if the underlying date-time is valid.

        +
        +

        Returns boolean | ZonedDateTime

      +
      + +
        +
      • +
        get jj(): number
        +
        +

        Integer Julian day number for the local ISO calendar date, ignoring time of day (1970-01-01 = 2440588).

        +
        +

        Returns number

      +
      + +
        +
      • +
        get locale(): string
        +
        +

        Resolved BCP 47 locale (e.g., 'en-US')

        +
        +

        Returns string

      +
      + +
        +
      • +
        get mi(): mi
        +
        +

        Minutes of the hour (0-59)

        +
        +

        Returns mi

      +
      + +
        +
      • +
        get mm(): mm
        +
        +

        Month number: Jan=1, Dec=12

        +
        +

        Returns mm

      +
      + +
        +
      • +
        get mmm(): | "All"
        | "Jan"
        | "Feb"
        | "Mar"
        | "Apr"
        | "May"
        | "Jun"
        | "Jul"
        | "Aug"
        | "Sep"
        | "Oct"
        | "Nov"
        | "Dec"
        +
        +

        Short month name (e.g., 'Jan')

        +
        +

        Returns
            | "All"
            | "Jan"
            | "Feb"
            | "Mar"
            | "Apr"
            | "May"
            | "Jun"
            | "Jul"
            | "Aug"
            | "Sep"
            | "Oct"
            | "Nov"
            | "Dec"

      +
      + +
        +
      • +
        get mon(): | "May"
        | "Every"
        | "January"
        | "February"
        | "March"
        | "April"
        | "June"
        | "July"
        | "August"
        | "September"
        | "October"
        | "November"
        | "December"
        +
        +

        Full month name (e.g., 'January')

        +
        +

        Returns
            | "May"
            | "Every"
            | "January"
            | "February"
            | "March"
            | "April"
            | "June"
            | "July"
            | "August"
            | "September"
            | "October"
            | "November"
            | "December"

      +
      + +
        +
      • +
        get ms(): ms
        +
        +

        Milliseconds of the second (0-999)

        +
        +

        Returns ms

      +
      + +
        +
      • +
        get nano(): bigint
        +
        +

        Nanoseconds since Unix epoch (BigInt)

        +
        +

        Returns bigint

      +
      + +
        +
      • +
        get ns(): ns
        +
        +

        Nanoseconds of the microsecond (0-999)

        +
        +

        Returns ns

      +
      + +
        +
      • +
        get parse(): Parse
        +
        +

        Instance-specific parse rules (merged with global)

        +
        +

        Returns Parse

      +
      + +
        +
      • +
        get ranges(): Readonly<Record<string, string>>
        +
        +

        current range key for every registered term

        +
        +

        Returns Readonly<Record<string, string>>

      +
      + +
        +
      • +
        get sphere(): "north" | "south" | "east" | "west" | "equator" | undefined
        +
        +

        Resolved hemisphere ('north' | 'south' | undefined)

        +
        +

        Returns "north" | "south" | "east" | "west" | "equator" | undefined

      +
      + +
        +
      • +
        get ss(): ss
        +
        +

        Seconds of the minute (0-59)

        +
        +

        Returns ss

      +
      + +
      +
      + +
        +
      • +
        get terms(): Readonly<Record<string, readonly string[]>>
        +
        +

        list of registered terms and their available range keys

        +
        +

        Returns Readonly<Record<string, readonly string[]>>

      +
      + +
        +
      • +
        get ts(): number | bigint
        +
        +

        Unix timestamp (defaults to milliseconds)

        +
        +

        Returns number | bigint

      +
      + +
        +
      • +
        get tz(): string
        +
        +

        IANA Time Zone ID (e.g., 'Australia/Sydney')

        +
        +

        Returns string

      +
      + +
        +
      • +
        get us(): us
        +
        +

        Microseconds of the millisecond (0-999)

        +
        +

        Returns us

      +
      + +
        +
      • +
        get wkd(): | "Everyday"
        | "Monday"
        | "Tuesday"
        | "Wednesday"
        | "Thursday"
        | "Friday"
        | "Saturday"
        | "Sunday"
        +
        +

        Full weekday name (e.g., 'Monday')

        +
        +

        Returns
            | "Everyday"
            | "Monday"
            | "Tuesday"
            | "Wednesday"
            | "Thursday"
            | "Friday"
            | "Saturday"
            | "Sunday"

      +
      + +
        +
      • +
        get woy(): woy
        +
        +

        ISO week number of the year

        +
        +

        Returns woy

      +
      + +
        +
      • +
        get ww(): woy
        +
        +

        ISO week number of the year.

        +
        +

        Returns woy

        +
        +
        +

        Use woy (Tempo canonical) or zdt.weekOfYear instead. To be removed in v5.0.0.

        +
      +
      + +
        +
      • +
        get www(): "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"
        +
        +

        Short weekday name (e.g., 'Mon')

        +
        +

        Returns "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"

      +
      + +
        +
      • +
        get yow(): number
        +
        +

        4-digit ISO week-numbering year

        +
        +

        Returns number

      +
      + +
        +
      • +
        get yy(): number
        +
        +

        4-digit year (e.g., 2024)

        +
        +

        Returns number

      +
      + +
        +
      • +
        get zdt(): ZonedDateTime
        +
        +

        returns the underlying Temporal.ZonedDateTime

        +
        +

        Returns ZonedDateTime

      +
      + +
        +
      • +
        get cache(): SecureObject<
            {
                weak: SecureObject<
                    {
                        get isWeakCache(): boolean;
                        clear(): void;
                        delete(key: string): boolean;
                        get(key: string): any;
                        getOrSet<V extends WeakKey>(key: string, factory: (key: string) => V): V;
                        has(key: string): boolean;
                        set<V extends WeakKey>(
                            key: string,
                            value: V,
                        ): { readonly get: (key: string) => any; readonly has: (key: string) => boolean; readonly set: <V extends WeakKey>(key: string, value: V) => ...; readonly getOrSet: <V extends WeakKey>(key: string, factory: (key: string) => V) => V; readonly delete: (key: string) => boolean; readonly clear: () => void; readonly isWeakC...;
                    },
                >;
                clear(count?: number): void;
                delete(key: string): boolean;
                deletePrefix(prefix: string): number;
                entries(): MapIterator<[string, string]>;
                fromEntries(
                    entries: Iterable<readonly [string, string]>,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                get(key: string): string | undefined;
                has(key: string): boolean;
                set(
                    key: string,
                    value: string,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                setStatic(
                    key: string,
                    value: string,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                toJSON(): Record<string, string>;
            },
        >
        +
        +

        high-performance in-memory cache facade for glossary and dynamic parse results

        +
        +

        Returns SecureObject<
            {
                weak: SecureObject<
                    {
                        get isWeakCache(): boolean;
                        clear(): void;
                        delete(key: string): boolean;
                        get(key: string): any;
                        getOrSet<V extends WeakKey>(key: string, factory: (key: string) => V): V;
                        has(key: string): boolean;
                        set<V extends WeakKey>(
                            key: string,
                            value: V,
                        ): { readonly get: (key: string) => any; readonly has: (key: string) => boolean; readonly set: <V extends WeakKey>(key: string, value: V) => ...; readonly getOrSet: <V extends WeakKey>(key: string, factory: (key: string) => V) => V; readonly delete: (key: string) => boolean; readonly clear: () => void; readonly isWeakC...;
                    },
                >;
                clear(count?: number): void;
                delete(key: string): boolean;
                deletePrefix(prefix: string): number;
                entries(): MapIterator<[string, string]>;
                fromEntries(
                    entries: Iterable<readonly [string, string]>,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                get(key: string): string | undefined;
                has(key: string): boolean;
                set(
                    key: string,
                    value: string,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                setStatic(
                    key: string,
                    value: string,
                ): { readonly get: (key: string) => string | undefined; readonly has: (key: string) => boolean; readonly set: (key: string, value: string) => ...; readonly setStatic: (key: string, value: string) => ...; ... 6 more ...; readonly weak: SecureObject<...>; };
                toJSON(): Record<string, string>;
            },
        >

      +
      + +
        +
      • +
        get CACHE(): EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>
        +
        +

        Returns EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>

        +
        +
        +

        Use Tempo.enums.CACHE

        +
      +
      + +
        +
      • +
        get config(): Config
        +
        +

        global Tempo configuration

        +
        +

        Returns Config

      +
      + +
        +
      • +
        get default(): Readonly<t.Config>
        +
        +

        Tempo initial default settings

        +
        +

        Returns Readonly<t.Config>

      +
      + +
        +
      • +
        get discovery(): Readonly<any>
        +
        +

        global discovery configuration

        +
        +

        Returns Readonly<any>

      +
      + +
        +
      • +
        get enums(): {
            CACHE: EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>;
            COMPASS: Extend<
                EnumifyType<
                    {
                        East: "east";
                        Equator: "equator";
                        North: "north";
                        South: "south";
                        West: "west";
                    },
                >,
                string,
                string,
            >;
            CONFIG: EnumifyType<
                Index<
                    readonly [
                        "config",
                        "parse",
                        "value",
                        "intl",
                        "localeInfo",
                        "store",
                        "discovery",
                        "debug",
                        "catch",
                        "silent",
                        "timeZone",
                        "calendar",
                        "locale",
                        "sphere",
                        "geo",
                        "latitude",
                        "lat",
                        "longitude",
                        "lng",
                        "timeStamp",
                        "registry",
                        "plugins",
                        "extends",
                        "cache",
                    ],
                >,
            >;
            DURATION: EnumifyType<
                {
                    day: 86400;
                    hour: 3600;
                    microsecond: 0.000001;
                    millisecond: 0.001;
                    minute: 60;
                    month: 2628000;
                    nanosecond: 1e-9;
                    second: 1;
                    week: 604800;
                    year: 31536000;
                },
            >;
            DURATIONS: EnumifyType<
                {
                    days: 86400000;
                    hours: 3600000;
                    microseconds: 0.001;
                    milliseconds: 1;
                    minutes: 60000;
                    months: 2628000000;
                    nanoseconds: 0.000001;
                    seconds: 1000;
                    weeks: 604800000;
                    years: 31536000000;
                },
            >;
            ELEMENT: EnumifyType<
                {
                    dd: "day";
                    hh: "hour";
                    mi: "minute";
                    mm: "month";
                    ms: "millisecond";
                    ns: "nanosecond";
                    ss: "second";
                    us: "microsecond";
                    woy: "week";
                    ww: "week";
                    yy: "year";
                },
            >;
            Enum: Readonly<
                {
                    "[hasInstance]"(instance: any): boolean;
                    count<T extends Property<any>>(enumObj: T): number;
                    entries<T extends Property<any>>(
                        enumObj: T,
                    ): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                    extend<const E extends any[] | Property<any>>(
                        enumObj: any,
                        list: E,
                        frozen?: boolean,
                    ): EnumifyType<any>;
                    get<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): ValueOf<T> | undefined;
                    has<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): key is KeyOf<T>;
                    hasOwn<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): key is KeyOf<T>;
                    includes<T extends Property<any>>(enumObj: T, search: any): boolean;
                    invert<T extends Property<any>>(enumObj: T): Readonly<Invert<T>>;
                    keyOf<T extends Property<any>>(
                        enumObj: T,
                        search: any,
                    ): KeyOf<T> | undefined;
                    keys<T extends Property<any>>(enumObj: T): readonly KeyOf<T>[];
                    values<T extends Property<any>>(enumObj: T): readonly ValueOf<T>[];
                },
            >;
            FORMAT: Extend<
                EnumifyType<
                    {
                        date: "{yyyy}-{mm}-{dd}";
                        dayDate: "{dd}-{mmm}-{yyyy}";
                        dayMonth: "{dd}-{mmm}";
                        dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                        display: "{www}, {dd} {mmm} {yyyy}";
                        logStamp: "{ymd}T{hms}.{ff}";
                        sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                        time: "{hh}:{mi}:{ss}";
                        weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                        weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                        weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                        yearMonth: "{yyyy}{mm}";
                        yearMonthDay: "{ymd}";
                        yearWeek: "{yw}{wy}";
                    },
                >,
                string,
                string,
            >;
            LIMIT: Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>;
            LOCALE: Readonly<Record<string, Record<string, any>>>;
            MODE: EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>;
            MONTH: EnumifyType<
                Index<
                    readonly [
                        "All",
                        "Jan",
                        "Feb",
                        "Mar",
                        "Apr",
                        "May",
                        "Jun",
                        "Jul",
                        "Aug",
                        "Sep",
                        "Oct",
                        "Nov",
                        "Dec",
                    ],
                >,
            >;
            MONTH_DAY: Readonly<
                {
                    layouts: readonly [
                        readonly ["dayMonthYearShort", "monthDayYearShort"],
                        readonly ["dayMonthYear", "monthDayYear"],
                    ];
                    locales: readonly ["en-US", "en-AS"];
                    timezones: {
                        "en-AS": readonly ["Pacific/Pago_Pago"];
                        "en-US": readonly [
                            "America/Adak",
                            "America/Anchorage",
                            "America/Boise",
                            "America/Chicago",
                            "America/Denver",
                            "America/Detroit",
                            "America/Indiana/Indianapolis",
                            "America/Indiana/Knox",
                            "America/Indiana/Marengo",
                            "America/Indiana/Petersburg",
                            "America/Indiana/Tell_City",
                            "America/Indiana/Vevay",
                            "America/Indiana/Vincennes",
                            "America/Indiana/Winamac",
                            "America/Indianapolis",
                            "America/Juneau",
                            "America/Kentucky/Louisville",
                            "America/Kentucky/Monticello",
                            "America/Los_Angeles",
                            "America/Louisville",
                            "America/Menominee",
                            "America/Metlakatla",
                            "America/New_York",
                            "America/Nome",
                            "America/North_Dakota/Beulah",
                            "America/North_Dakota/Center",
                            "America/North_Dakota/New_Salem",
                            "America/Phoenix",
                            "America/Sitka",
                            "America/Yakutat",
                            "Pacific/Honolulu",
                            "US/Aleutian",
                            "US/Alaska",
                            "US/Arizona",
                            "US/Central",
                            "US/Eastern",
                            "US/Mountain",
                            "US/Pacific",
                        ];
                    };
                },
            >;
            MONTHS: EnumifyType<
                Index<
                    readonly [
                        "Every",
                        "January",
                        "February",
                        "March",
                        "April",
                        "May",
                        "June",
                        "July",
                        "August",
                        "September",
                        "October",
                        "November",
                        "December",
                    ],
                >,
            >;
            MUTATION: EnumifyType<
                Index<
                    readonly [
                        "yy",
                        "mm",
                        "wy",
                        "ww",
                        "woy",
                        "dd",
                        "hh",
                        "mi",
                        "ss",
                        "ms",
                        "us",
                        "ns",
                        "yw",
                        "yow",
                        "isoYear",
                        "isoyear",
                        "isoWeek",
                        "isoweek",
                        "event",
                        "period",
                        "clock",
                        "time",
                        "date",
                        "start",
                        "mid",
                        "end",
                    ],
                >,
            >;
            NUMBER: Extend<
                EnumifyType<
                    {
                        eight: 8;
                        five: 5;
                        four: 4;
                        nine: 9;
                        one: 1;
                        seven: 7;
                        six: 6;
                        ten: 10;
                        three: 3;
                        two: 2;
                        zero: 0;
                    },
                >,
                string,
                number,
            >;
            ORDINAL: Extend<
                EnumifyType<
                    {
                        current: 0;
                        eighth: 8;
                        fifth: 5;
                        first: 1;
                        fourth: 4;
                        last: -1;
                        ninth: 9;
                        second: 2;
                        seventh: 7;
                        sixth: 6;
                        tenth: 10;
                        third: 3;
                    },
                >,
                string,
                number,
            >;
            PARSE: EnumifyType<
                Index<
                    readonly [
                        "monthDay",
                        "planner",
                        "layoutOrder",
                        "preFilter",
                        "mode",
                        "pivot",
                        "snippet",
                        "layout",
                        "event",
                        "period",
                        "anchor",
                    ],
                >,
            >;
            SEASON: EnumifyType<
                {
                    Autumn: "autumn";
                    Spring: "spring";
                    Summer: "summer";
                    Winter: "winter";
                },
            >;
            TIMEZONE: Extend<
                Readonly<
                    {
                        acdt: "Australia/Adelaide";
                        acst: "Australia/Adelaide";
                        aedt: "Australia/Sydney";
                        aest: "Australia/Sydney";
                        awst: "Australia/Perth";
                        cdt: "America/Chicago";
                        cest: "Europe/Paris";
                        cet: "Europe/Paris";
                        cst: "America/Chicago";
                        edt: "America/New_York";
                        eest: "Europe/Helsinki";
                        eet: "Europe/Helsinki";
                        est: "America/New_York";
                        gmt: "UTC";
                        ist: "Asia/Kolkata";
                        jst: "Asia/Tokyo";
                        mdt: "America/Denver";
                        mst: "America/Denver";
                        npt: "Asia/Kathmandu";
                        nzdt: "Pacific/Auckland";
                        nzst: "Pacific/Auckland";
                        nzt: "Pacific/Auckland";
                        pdt: "America/Los_Angeles";
                        pst: "America/Los_Angeles";
                        utc: "UTC";
                    },
                >,
                string,
                string,
            >;
            WEEKDAY: EnumifyType<
                Index<
                    readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
                >,
            >;
            WEEKDAYS: EnumifyType<
                Index<
                    readonly [
                        "Everyday",
                        "Monday",
                        "Tuesday",
                        "Wednesday",
                        "Thursday",
                        "Friday",
                        "Saturday",
                        "Sunday",
                    ],
                >,
            >;
            ZONED_DATE_TIME: EnumifyType<
                Index<
                    readonly [
                        "value",
                        "timeZoneId",
                        "calendarId",
                        "monthCode",
                        "offset",
                        "timeZone",
                        "calendar",
                        "year",
                        "month",
                        "day",
                        "hour",
                        "minute",
                        "second",
                        "yy",
                        "mm",
                        "wy",
                        "ww",
                        "woy",
                        "dd",
                        "hh",
                        "mi",
                        "ss",
                        "ms",
                        "us",
                        "ns",
                    ],
                >,
            >;
        }
        +
        +

        Live registry enumerations

        +
        +

        Returns {
            CACHE: EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>;
            COMPASS: Extend<
                EnumifyType<
                    {
                        East: "east";
                        Equator: "equator";
                        North: "north";
                        South: "south";
                        West: "west";
                    },
                >,
                string,
                string,
            >;
            CONFIG: EnumifyType<
                Index<
                    readonly [
                        "config",
                        "parse",
                        "value",
                        "intl",
                        "localeInfo",
                        "store",
                        "discovery",
                        "debug",
                        "catch",
                        "silent",
                        "timeZone",
                        "calendar",
                        "locale",
                        "sphere",
                        "geo",
                        "latitude",
                        "lat",
                        "longitude",
                        "lng",
                        "timeStamp",
                        "registry",
                        "plugins",
                        "extends",
                        "cache",
                    ],
                >,
            >;
            DURATION: EnumifyType<
                {
                    day: 86400;
                    hour: 3600;
                    microsecond: 0.000001;
                    millisecond: 0.001;
                    minute: 60;
                    month: 2628000;
                    nanosecond: 1e-9;
                    second: 1;
                    week: 604800;
                    year: 31536000;
                },
            >;
            DURATIONS: EnumifyType<
                {
                    days: 86400000;
                    hours: 3600000;
                    microseconds: 0.001;
                    milliseconds: 1;
                    minutes: 60000;
                    months: 2628000000;
                    nanoseconds: 0.000001;
                    seconds: 1000;
                    weeks: 604800000;
                    years: 31536000000;
                },
            >;
            ELEMENT: EnumifyType<
                {
                    dd: "day";
                    hh: "hour";
                    mi: "minute";
                    mm: "month";
                    ms: "millisecond";
                    ns: "nanosecond";
                    ss: "second";
                    us: "microsecond";
                    woy: "week";
                    ww: "week";
                    yy: "year";
                },
            >;
            Enum: Readonly<
                {
                    "[hasInstance]"(instance: any): boolean;
                    count<T extends Property<any>>(enumObj: T): number;
                    entries<T extends Property<any>>(
                        enumObj: T,
                    ): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                    extend<const E extends any[] | Property<any>>(
                        enumObj: any,
                        list: E,
                        frozen?: boolean,
                    ): EnumifyType<any>;
                    get<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): ValueOf<T> | undefined;
                    has<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): key is KeyOf<T>;
                    hasOwn<T extends Property<any>>(
                        enumObj: T,
                        key: string | number | symbol | KeyOf<T>,
                    ): key is KeyOf<T>;
                    includes<T extends Property<any>>(enumObj: T, search: any): boolean;
                    invert<T extends Property<any>>(enumObj: T): Readonly<Invert<T>>;
                    keyOf<T extends Property<any>>(
                        enumObj: T,
                        search: any,
                    ): KeyOf<T> | undefined;
                    keys<T extends Property<any>>(enumObj: T): readonly KeyOf<T>[];
                    values<T extends Property<any>>(enumObj: T): readonly ValueOf<T>[];
                },
            >;
            FORMAT: Extend<
                EnumifyType<
                    {
                        date: "{yyyy}-{mm}-{dd}";
                        dayDate: "{dd}-{mmm}-{yyyy}";
                        dayMonth: "{dd}-{mmm}";
                        dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                        display: "{www}, {dd} {mmm} {yyyy}";
                        logStamp: "{ymd}T{hms}.{ff}";
                        sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                        time: "{hh}:{mi}:{ss}";
                        weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                        weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                        weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                        yearMonth: "{yyyy}{mm}";
                        yearMonthDay: "{ymd}";
                        yearWeek: "{yw}{wy}";
                    },
                >,
                string,
                string,
            >;
            LIMIT: Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>;
            LOCALE: Readonly<Record<string, Record<string, any>>>;
            MODE: EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>;
            MONTH: EnumifyType<
                Index<
                    readonly [
                        "All",
                        "Jan",
                        "Feb",
                        "Mar",
                        "Apr",
                        "May",
                        "Jun",
                        "Jul",
                        "Aug",
                        "Sep",
                        "Oct",
                        "Nov",
                        "Dec",
                    ],
                >,
            >;
            MONTH_DAY: Readonly<
                {
                    layouts: readonly [
                        readonly ["dayMonthYearShort", "monthDayYearShort"],
                        readonly ["dayMonthYear", "monthDayYear"],
                    ];
                    locales: readonly ["en-US", "en-AS"];
                    timezones: {
                        "en-AS": readonly ["Pacific/Pago_Pago"];
                        "en-US": readonly [
                            "America/Adak",
                            "America/Anchorage",
                            "America/Boise",
                            "America/Chicago",
                            "America/Denver",
                            "America/Detroit",
                            "America/Indiana/Indianapolis",
                            "America/Indiana/Knox",
                            "America/Indiana/Marengo",
                            "America/Indiana/Petersburg",
                            "America/Indiana/Tell_City",
                            "America/Indiana/Vevay",
                            "America/Indiana/Vincennes",
                            "America/Indiana/Winamac",
                            "America/Indianapolis",
                            "America/Juneau",
                            "America/Kentucky/Louisville",
                            "America/Kentucky/Monticello",
                            "America/Los_Angeles",
                            "America/Louisville",
                            "America/Menominee",
                            "America/Metlakatla",
                            "America/New_York",
                            "America/Nome",
                            "America/North_Dakota/Beulah",
                            "America/North_Dakota/Center",
                            "America/North_Dakota/New_Salem",
                            "America/Phoenix",
                            "America/Sitka",
                            "America/Yakutat",
                            "Pacific/Honolulu",
                            "US/Aleutian",
                            "US/Alaska",
                            "US/Arizona",
                            "US/Central",
                            "US/Eastern",
                            "US/Mountain",
                            "US/Pacific",
                        ];
                    };
                },
            >;
            MONTHS: EnumifyType<
                Index<
                    readonly [
                        "Every",
                        "January",
                        "February",
                        "March",
                        "April",
                        "May",
                        "June",
                        "July",
                        "August",
                        "September",
                        "October",
                        "November",
                        "December",
                    ],
                >,
            >;
            MUTATION: EnumifyType<
                Index<
                    readonly [
                        "yy",
                        "mm",
                        "wy",
                        "ww",
                        "woy",
                        "dd",
                        "hh",
                        "mi",
                        "ss",
                        "ms",
                        "us",
                        "ns",
                        "yw",
                        "yow",
                        "isoYear",
                        "isoyear",
                        "isoWeek",
                        "isoweek",
                        "event",
                        "period",
                        "clock",
                        "time",
                        "date",
                        "start",
                        "mid",
                        "end",
                    ],
                >,
            >;
            NUMBER: Extend<
                EnumifyType<
                    {
                        eight: 8;
                        five: 5;
                        four: 4;
                        nine: 9;
                        one: 1;
                        seven: 7;
                        six: 6;
                        ten: 10;
                        three: 3;
                        two: 2;
                        zero: 0;
                    },
                >,
                string,
                number,
            >;
            ORDINAL: Extend<
                EnumifyType<
                    {
                        current: 0;
                        eighth: 8;
                        fifth: 5;
                        first: 1;
                        fourth: 4;
                        last: -1;
                        ninth: 9;
                        second: 2;
                        seventh: 7;
                        sixth: 6;
                        tenth: 10;
                        third: 3;
                    },
                >,
                string,
                number,
            >;
            PARSE: EnumifyType<
                Index<
                    readonly [
                        "monthDay",
                        "planner",
                        "layoutOrder",
                        "preFilter",
                        "mode",
                        "pivot",
                        "snippet",
                        "layout",
                        "event",
                        "period",
                        "anchor",
                    ],
                >,
            >;
            SEASON: EnumifyType<
                {
                    Autumn: "autumn";
                    Spring: "spring";
                    Summer: "summer";
                    Winter: "winter";
                },
            >;
            TIMEZONE: Extend<
                Readonly<
                    {
                        acdt: "Australia/Adelaide";
                        acst: "Australia/Adelaide";
                        aedt: "Australia/Sydney";
                        aest: "Australia/Sydney";
                        awst: "Australia/Perth";
                        cdt: "America/Chicago";
                        cest: "Europe/Paris";
                        cet: "Europe/Paris";
                        cst: "America/Chicago";
                        edt: "America/New_York";
                        eest: "Europe/Helsinki";
                        eet: "Europe/Helsinki";
                        est: "America/New_York";
                        gmt: "UTC";
                        ist: "Asia/Kolkata";
                        jst: "Asia/Tokyo";
                        mdt: "America/Denver";
                        mst: "America/Denver";
                        npt: "Asia/Kathmandu";
                        nzdt: "Pacific/Auckland";
                        nzst: "Pacific/Auckland";
                        nzt: "Pacific/Auckland";
                        pdt: "America/Los_Angeles";
                        pst: "America/Los_Angeles";
                        utc: "UTC";
                    },
                >,
                string,
                string,
            >;
            WEEKDAY: EnumifyType<
                Index<
                    readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
                >,
            >;
            WEEKDAYS: EnumifyType<
                Index<
                    readonly [
                        "Everyday",
                        "Monday",
                        "Tuesday",
                        "Wednesday",
                        "Thursday",
                        "Friday",
                        "Saturday",
                        "Sunday",
                    ],
                >,
            >;
            ZONED_DATE_TIME: EnumifyType<
                Index<
                    readonly [
                        "value",
                        "timeZoneId",
                        "calendarId",
                        "monthCode",
                        "offset",
                        "timeZone",
                        "calendar",
                        "year",
                        "month",
                        "day",
                        "hour",
                        "minute",
                        "second",
                        "yy",
                        "mm",
                        "wy",
                        "ww",
                        "woy",
                        "dd",
                        "hh",
                        "mi",
                        "ss",
                        "ms",
                        "us",
                        "ns",
                    ],
                >,
            >;
        }

        +
          +
        • +
          CACHE: EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>
          +

          cache operation modes

          +
          • +
        • +
          COMPASS: Extend<
              EnumifyType<
                  {
                      East: "east";
                      Equator: "equator";
                      North: "north";
                      South: "south";
                      West: "west";
                  },
              >,
              string,
              string,
          >
          +

          cardinal directions

          +
          • +
        • +
          CONFIG: EnumifyType<
              Index<
                  readonly [
                      "config",
                      "parse",
                      "value",
                      "intl",
                      "localeInfo",
                      "store",
                      "discovery",
                      "debug",
                      "catch",
                      "silent",
                      "timeZone",
                      "calendar",
                      "locale",
                      "sphere",
                      "geo",
                      "latitude",
                      "lat",
                      "longitude",
                      "lng",
                      "timeStamp",
                      "registry",
                      "plugins",
                      "extends",
                      "cache",
                  ],
              >,
          >
          • +
        • +
          DURATION: EnumifyType<
              {
                  day: 86400;
                  hour: 3600;
                  microsecond: 0.000001;
                  millisecond: 0.001;
                  minute: 60;
                  month: 2628000;
                  nanosecond: 1e-9;
                  second: 1;
                  week: 604800;
                  year: 31536000;
              },
          >
          +

          number of seconds in a time unit

          +
          • +
        • +
          DURATIONS: EnumifyType<
              {
                  days: 86400000;
                  hours: 3600000;
                  microseconds: 0.001;
                  milliseconds: 1;
                  minutes: 60000;
                  months: 2628000000;
                  nanoseconds: 0.000001;
                  seconds: 1000;
                  weeks: 604800000;
                  years: 31536000000;
              },
          >
          +

          number of milliseconds in a time unit

          +
          • +
        • +
          ELEMENT: EnumifyType<
              {
                  dd: "day";
                  hh: "hour";
                  mi: "minute";
                  mm: "month";
                  ms: "millisecond";
                  ns: "nanosecond";
                  ss: "second";
                  us: "microsecond";
                  woy: "week";
                  ww: "week";
                  yy: "year";
              },
          >
          • +
        • +
          Enum: Readonly<
              {
                  "[hasInstance]"(instance: any): boolean;
                  count<T extends Property<any>>(enumObj: T): number;
                  entries<T extends Property<any>>(
                      enumObj: T,
                  ): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                  extend<const E extends any[] | Property<any>>(
                      enumObj: any,
                      list: E,
                      frozen?: boolean,
                  ): EnumifyType<any>;
                  get<T extends Property<any>>(
                      enumObj: T,
                      key: string | number | symbol | KeyOf<T>,
                  ): ValueOf<T> | undefined;
                  has<T extends Property<any>>(
                      enumObj: T,
                      key: string | number | symbol | KeyOf<T>,
                  ): key is KeyOf<T>;
                  hasOwn<T extends Property<any>>(
                      enumObj: T,
                      key: string | number | symbol | KeyOf<T>,
                  ): key is KeyOf<T>;
                  includes<T extends Property<any>>(enumObj: T, search: any): boolean;
                  invert<T extends Property<any>>(enumObj: T): Readonly<Invert<T>>;
                  keyOf<T extends Property<any>>(
                      enumObj: T,
                      search: any,
                  ): KeyOf<T> | undefined;
                  keys<T extends Property<any>>(enumObj: T): readonly KeyOf<T>[];
                  values<T extends Property<any>>(enumObj: T): readonly ValueOf<T>[];
              },
          >
          • +
        • +
          FORMAT: Extend<
              EnumifyType<
                  {
                      date: "{yyyy}-{mm}-{dd}";
                      dayDate: "{dd}-{mmm}-{yyyy}";
                      dayMonth: "{dd}-{mmm}";
                      dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                      display: "{www}, {dd} {mmm} {yyyy}";
                      logStamp: "{ymd}T{hms}.{ff}";
                      sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                      time: "{hh}:{mi}:{ss}";
                      weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                      weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                      weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                      yearMonth: "{yyyy}{mm}";
                      yearMonthDay: "{ymd}";
                      yearWeek: "{yw}{wy}";
                  },
              >,
              string,
              string,
          >
          +

          common format aliases

          +
          • +
        • +
          LIMIT: Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>
          +

          Temporal limits (min/max date bounds)

          +
          • +
        • +
          LOCALE: Readonly<Record<string, Record<string, any>>>
          +

          localized dictionary translations

          +
          • +
        • +
          MODE: EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>
          +

          initialization strategies

          +
          • +
        • +
          MONTH: EnumifyType<
              Index<
                  readonly [
                      "All",
                      "Jan",
                      "Feb",
                      "Mar",
                      "Apr",
                      "May",
                      "Jun",
                      "Jul",
                      "Aug",
                      "Sep",
                      "Oct",
                      "Nov",
                      "Dec",
                  ],
              >,
          >
          +

          Gregorian calendar months (short-form)

          +
          • +
        • +
          MONTH_DAY: Readonly<
              {
                  layouts: readonly [
                      readonly ["dayMonthYearShort", "monthDayYearShort"],
                      readonly ["dayMonthYear", "monthDayYear"],
                  ];
                  locales: readonly ["en-US", "en-AS"];
                  timezones: {
                      "en-AS": readonly ["Pacific/Pago_Pago"];
                      "en-US": readonly [
                          "America/Adak",
                          "America/Anchorage",
                          "America/Boise",
                          "America/Chicago",
                          "America/Denver",
                          "America/Detroit",
                          "America/Indiana/Indianapolis",
                          "America/Indiana/Knox",
                          "America/Indiana/Marengo",
                          "America/Indiana/Petersburg",
                          "America/Indiana/Tell_City",
                          "America/Indiana/Vevay",
                          "America/Indiana/Vincennes",
                          "America/Indiana/Winamac",
                          "America/Indianapolis",
                          "America/Juneau",
                          "America/Kentucky/Louisville",
                          "America/Kentucky/Monticello",
                          "America/Los_Angeles",
                          "America/Louisville",
                          "America/Menominee",
                          "America/Metlakatla",
                          "America/New_York",
                          "America/Nome",
                          "America/North_Dakota/Beulah",
                          "America/North_Dakota/Center",
                          "America/North_Dakota/New_Salem",
                          "America/Phoenix",
                          "America/Sitka",
                          "America/Yakutat",
                          "Pacific/Honolulu",
                          "US/Aleutian",
                          "US/Alaska",
                          "US/Arizona",
                          "US/Central",
                          "US/Eastern",
                          "US/Mountain",
                          "US/Pacific",
                      ];
                  };
              },
          >
          +

          regional month-day-year parsing settings

          +
          • +
        • +
          MONTHS: EnumifyType<
              Index<
                  readonly [
                      "Every",
                      "January",
                      "February",
                      "March",
                      "April",
                      "May",
                      "June",
                      "July",
                      "August",
                      "September",
                      "October",
                      "November",
                      "December",
                  ],
              >,
          >
          +

          Gregorian calendar months (long-form)

          +
          • +
        • +
          MUTATION: EnumifyType<
              Index<
                  readonly [
                      "yy",
                      "mm",
                      "wy",
                      "ww",
                      "woy",
                      "dd",
                      "hh",
                      "mi",
                      "ss",
                      "ms",
                      "us",
                      "ns",
                      "yw",
                      "yow",
                      "isoYear",
                      "isoyear",
                      "isoWeek",
                      "isoweek",
                      "event",
                      "period",
                      "clock",
                      "time",
                      "date",
                      "start",
                      "mid",
                      "end",
                  ],
              >,
          >
          • +
        • +
          NUMBER: Extend<
              EnumifyType<
                  {
                      eight: 8;
                      five: 5;
                      four: 4;
                      nine: 9;
                      one: 1;
                      seven: 7;
                      six: 6;
                      ten: 10;
                      three: 3;
                      two: 2;
                      zero: 0;
                  },
              >,
              string,
              number,
          >
          +

          number names (0-10)

          +
          • +
        • +
          ORDINAL: Extend<
              EnumifyType<
                  {
                      current: 0;
                      eighth: 8;
                      fifth: 5;
                      first: 1;
                      fourth: 4;
                      last: -1;
                      ninth: 9;
                      second: 2;
                      seventh: 7;
                      sixth: 6;
                      tenth: 10;
                      third: 3;
                  },
              >,
              string,
              number,
          >
          +

          ordinal names

          +
          • +
        • +
          PARSE: EnumifyType<
              Index<
                  readonly [
                      "monthDay",
                      "planner",
                      "layoutOrder",
                      "preFilter",
                      "mode",
                      "pivot",
                      "snippet",
                      "layout",
                      "event",
                      "period",
                      "anchor",
                  ],
              >,
          >
          • +
        • +
          SEASON: EnumifyType<
              {
                  Autumn: "autumn";
                  Spring: "spring";
                  Summer: "summer";
                  Winter: "winter";
              },
          >
          +

          calendar seasons

          +
          • +
        • +
          TIMEZONE: Extend<
              Readonly<
                  {
                      acdt: "Australia/Adelaide";
                      acst: "Australia/Adelaide";
                      aedt: "Australia/Sydney";
                      aest: "Australia/Sydney";
                      awst: "Australia/Perth";
                      cdt: "America/Chicago";
                      cest: "Europe/Paris";
                      cet: "Europe/Paris";
                      cst: "America/Chicago";
                      edt: "America/New_York";
                      eest: "Europe/Helsinki";
                      eet: "Europe/Helsinki";
                      est: "America/New_York";
                      gmt: "UTC";
                      ist: "Asia/Kolkata";
                      jst: "Asia/Tokyo";
                      mdt: "America/Denver";
                      mst: "America/Denver";
                      npt: "Asia/Kathmandu";
                      nzdt: "Pacific/Auckland";
                      nzst: "Pacific/Auckland";
                      nzt: "Pacific/Auckland";
                      pdt: "America/Los_Angeles";
                      pst: "America/Los_Angeles";
                      utc: "UTC";
                  },
              >,
              string,
              string,
          >
          +

          common time-zone aliases

          +
          • +
        • +
          WEEKDAY: EnumifyType<
              Index<readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]>,
          >
          +

          Gregorian calendar week-days (short-form)

          +
          • +
        • +
          WEEKDAYS: EnumifyType<
              Index<
                  readonly [
                      "Everyday",
                      "Monday",
                      "Tuesday",
                      "Wednesday",
                      "Thursday",
                      "Friday",
                      "Saturday",
                      "Sunday",
                  ],
              >,
          >
          +

          Gregorian calendar week-days (long-form)

          +
          • +
        • +
          ZONED_DATE_TIME: EnumifyType<
              Index<
                  readonly [
                      "value",
                      "timeZoneId",
                      "calendarId",
                      "monthCode",
                      "offset",
                      "timeZone",
                      "calendar",
                      "year",
                      "month",
                      "day",
                      "hour",
                      "minute",
                      "second",
                      "yy",
                      "mm",
                      "wy",
                      "ww",
                      "woy",
                      "dd",
                      "hh",
                      "mi",
                      "ss",
                      "ms",
                      "us",
                      "ns",
                  ],
              >,
          >
      +
      + +
        +
      • +
        get epoch(): Readonly<{ ms: number; ns: bigint; ss: number; us: number }>
        +
        +

        static units since Unix epoch

        +
        +

        Returns Readonly<{ ms: number; ns: bigint; ss: number; us: number }>

      +
      + +
        +
      • +
        get FORMAT(): Extend<
            EnumifyType<
                {
                    date: "{yyyy}-{mm}-{dd}";
                    dayDate: "{dd}-{mmm}-{yyyy}";
                    dayMonth: "{dd}-{mmm}";
                    dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                    display: "{www}, {dd} {mmm} {yyyy}";
                    logStamp: "{ymd}T{hms}.{ff}";
                    sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                    time: "{hh}:{mi}:{ss}";
                    weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                    weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                    weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                    yearMonth: "{yyyy}{mm}";
                    yearMonthDay: "{ymd}";
                    yearWeek: "{yw}{wy}";
                },
            >,
            string,
            string,
        >
        +
        +

        Returns Extend<
            EnumifyType<
                {
                    date: "{yyyy}-{mm}-{dd}";
                    dayDate: "{dd}-{mmm}-{yyyy}";
                    dayMonth: "{dd}-{mmm}";
                    dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                    display: "{www}, {dd} {mmm} {yyyy}";
                    logStamp: "{ymd}T{hms}.{ff}";
                    sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                    time: "{hh}:{mi}:{ss}";
                    weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                    weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                    weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                    yearMonth: "{yyyy}{mm}";
                    yearMonthDay: "{ymd}";
                    yearWeek: "{yw}{wy}";
                },
            >,
            string,
            string,
        >

        +
        +
        +

        Use Tempo.enums.FORMAT

        +
      +
      + +
        +
      • +
        get ignores(): Secure<Ignore>
        +
        +

        static Tempo.ignores (registry)

        +
        +

        Returns Secure<Ignore>

      +
      + +
        +
      • +
        get instant(): Instant
        +
        +

        get the current system Instant

        +
        +

        Returns Instant

      +
      + +
        +
      • +
        get intl(): TempoIntlNamespace
        +
        +

        Internationalization namespace (info, locale, and cultural metadata) for the global locale

        +
        +

        Returns TempoIntlNamespace

      +
      + +
        +
      • +
        get LIMIT(): Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>
        +
        +

        Returns Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>

        +
        +
        +

        Use Tempo.enums.LIMIT

        +
      +
      + +
        +
      • +
        get MODE(): EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>
        +
        +

        Returns EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>

        +
        +
        +

        Use Tempo.enums.MODE

        +
      +
      + +
        +
      • +
        get MONTH_DAY(): Readonly<
            {
                layouts: readonly [
                    readonly ["dayMonthYearShort", "monthDayYearShort"],
                    readonly ["dayMonthYear", "monthDayYear"],
                ];
                locales: readonly ["en-US", "en-AS"];
                timezones: {
                    "en-AS": readonly ["Pacific/Pago_Pago"];
                    "en-US": readonly [
                        "America/Adak",
                        "America/Anchorage",
                        "America/Boise",
                        "America/Chicago",
                        "America/Denver",
                        "America/Detroit",
                        "America/Indiana/Indianapolis",
                        "America/Indiana/Knox",
                        "America/Indiana/Marengo",
                        "America/Indiana/Petersburg",
                        "America/Indiana/Tell_City",
                        "America/Indiana/Vevay",
                        "America/Indiana/Vincennes",
                        "America/Indiana/Winamac",
                        "America/Indianapolis",
                        "America/Juneau",
                        "America/Kentucky/Louisville",
                        "America/Kentucky/Monticello",
                        "America/Los_Angeles",
                        "America/Louisville",
                        "America/Menominee",
                        "America/Metlakatla",
                        "America/New_York",
                        "America/Nome",
                        "America/North_Dakota/Beulah",
                        "America/North_Dakota/Center",
                        "America/North_Dakota/New_Salem",
                        "America/Phoenix",
                        "America/Sitka",
                        "America/Yakutat",
                        "Pacific/Honolulu",
                        "US/Aleutian",
                        "US/Alaska",
                        "US/Arizona",
                        "US/Central",
                        "US/Eastern",
                        "US/Mountain",
                        "US/Pacific",
                    ];
                };
            },
        >
        +
        +

        Returns Readonly<
            {
                layouts: readonly [
                    readonly ["dayMonthYearShort", "monthDayYearShort"],
                    readonly ["dayMonthYear", "monthDayYear"],
                ];
                locales: readonly ["en-US", "en-AS"];
                timezones: {
                    "en-AS": readonly ["Pacific/Pago_Pago"];
                    "en-US": readonly [
                        "America/Adak",
                        "America/Anchorage",
                        "America/Boise",
                        "America/Chicago",
                        "America/Denver",
                        "America/Detroit",
                        "America/Indiana/Indianapolis",
                        "America/Indiana/Knox",
                        "America/Indiana/Marengo",
                        "America/Indiana/Petersburg",
                        "America/Indiana/Tell_City",
                        "America/Indiana/Vevay",
                        "America/Indiana/Vincennes",
                        "America/Indiana/Winamac",
                        "America/Indianapolis",
                        "America/Juneau",
                        "America/Kentucky/Louisville",
                        "America/Kentucky/Monticello",
                        "America/Los_Angeles",
                        "America/Louisville",
                        "America/Menominee",
                        "America/Metlakatla",
                        "America/New_York",
                        "America/Nome",
                        "America/North_Dakota/Beulah",
                        "America/North_Dakota/Center",
                        "America/North_Dakota/New_Salem",
                        "America/Phoenix",
                        "America/Sitka",
                        "America/Yakutat",
                        "Pacific/Honolulu",
                        "US/Aleutian",
                        "US/Alaska",
                        "US/Arizona",
                        "US/Central",
                        "US/Eastern",
                        "US/Mountain",
                        "US/Pacific",
                    ];
                };
            },
        >

        +
        +
        +

        Use Tempo.enums.MONTH_DAY

        +
      +
      + +
        +
      • +
        get NUMBER(): Extend<
            EnumifyType<
                {
                    eight: 8;
                    five: 5;
                    four: 4;
                    nine: 9;
                    one: 1;
                    seven: 7;
                    six: 6;
                    ten: 10;
                    three: 3;
                    two: 2;
                    zero: 0;
                },
            >,
            string,
            number,
        >
        +
        +

        Returns Extend<
            EnumifyType<
                {
                    eight: 8;
                    five: 5;
                    four: 4;
                    nine: 9;
                    one: 1;
                    seven: 7;
                    six: 6;
                    ten: 10;
                    three: 3;
                    two: 2;
                    zero: 0;
                },
            >,
            string,
            number,
        >

        +
        +
        +

        Use Tempo.enums.NUMBER

        +
      +
      + +
        +
      • +
        get options(): any
        +
        +

        Retrieves the merged options for this Tempo class, combining defaults, storage, discovery, and config.

        +
        +

        Returns any

        The complete options object for Tempo initialization

        +
      +
      + +
        +
      • +
        get ORDINAL(): Extend<
            EnumifyType<
                {
                    current: 0;
                    eighth: 8;
                    fifth: 5;
                    first: 1;
                    fourth: 4;
                    last: -1;
                    ninth: 9;
                    second: 2;
                    seventh: 7;
                    sixth: 6;
                    tenth: 10;
                    third: 3;
                },
            >,
            string,
            number,
        >
        +
        +

        Returns Extend<
            EnumifyType<
                {
                    current: 0;
                    eighth: 8;
                    fifth: 5;
                    first: 1;
                    fourth: 4;
                    last: -1;
                    ninth: 9;
                    second: 2;
                    seventh: 7;
                    sixth: 6;
                    tenth: 10;
                    third: 3;
                },
            >,
            string,
            number,
        >

        +
        +
        +

        Use Tempo.enums.ORDINAL

        +
      +
      + +
        +
      • +
        get parse(): SecureObject<
            {
                anchor?: ZonedDateTime;
                event: {
                    christmas: "25 Dec";
                    "christmas ?eve": "24 Dec";
                    fortnight: (this: AliasContext) => AliasContext;
                    "new.?years? ?eve": "31 Dec";
                    "new.?years?(?: ?day)?": "01 Jan";
                    now: (this: AliasContext) => AliasContext;
                    ny: "01 Jan";
                    nye: "31 Dec";
                    today: (this: AliasContext) => ZonedDateTime;
                    tomorrow: (this: AliasContext) => AliasContext;
                    xmas: "25 Dec";
                    "xmas ?eve": "24 Dec";
                    yesterday: (this: AliasContext) => AliasContext;
                    readonly [key: string]: string | Function;
                };
                ignore: { readonly [key: string]: string };
                isAnchored?: boolean;
                layout: { readonly [key: symbol]: string };
                mode: "auto" | "strict" | "defer";
                monthDay: MonthDay;
                pattern: Registry;
                period: {
                    "after[ -]?noon": "3:00pm";
                    evening: "18:00";
                    "half[ -]?hour": (this: AliasContext) => string;
                    "mid[ -]?day": "12:00";
                    "mid[ -]?morning": "10:00";
                    "mid[ -]?night": "24:00";
                    morning: "8:00";
                    night: "20:00";
                    noon: "12:00";
                    readonly [key: string]: string | Function;
                };
                pivot: number;
                planner: { layoutOrder: (string | symbol)[]; preFilter: boolean };
                result: Match[];
                snippet: { readonly [key: symbol]: RegExp };
                token: Extend;
            },
        >
        +
        +

        configuration governing the static 'rules' used when parsing t.DateTime argument

        +
        +

        Returns SecureObject<
            {
                anchor?: ZonedDateTime;
                event: {
                    christmas: "25 Dec";
                    "christmas ?eve": "24 Dec";
                    fortnight: (this: AliasContext) => AliasContext;
                    "new.?years? ?eve": "31 Dec";
                    "new.?years?(?: ?day)?": "01 Jan";
                    now: (this: AliasContext) => AliasContext;
                    ny: "01 Jan";
                    nye: "31 Dec";
                    today: (this: AliasContext) => ZonedDateTime;
                    tomorrow: (this: AliasContext) => AliasContext;
                    xmas: "25 Dec";
                    "xmas ?eve": "24 Dec";
                    yesterday: (this: AliasContext) => AliasContext;
                    readonly [key: string]: string | Function;
                };
                ignore: { readonly [key: string]: string };
                isAnchored?: boolean;
                layout: { readonly [key: symbol]: string };
                mode: "auto" | "strict" | "defer";
                monthDay: MonthDay;
                pattern: Registry;
                period: {
                    "after[ -]?noon": "3:00pm";
                    evening: "18:00";
                    "half[ -]?hour": (this: AliasContext) => string;
                    "mid[ -]?day": "12:00";
                    "mid[ -]?morning": "10:00";
                    "mid[ -]?night": "24:00";
                    morning: "8:00";
                    night: "20:00";
                    noon: "12:00";
                    readonly [key: string]: string | Function;
                };
                pivot: number;
                planner: { layoutOrder: (string | symbol)[]; preFilter: boolean };
                result: Match[];
                snippet: { readonly [key: symbol]: RegExp };
                token: Extend;
            },
        >

      +
      + +
        +
      • +
        get properties(): SecureArray<string>
        +
        +

        static Tempo properties getter

        +
        +

        Returns SecureArray<string>

      +
      + +
        +
      • +
        get registry(): Readonly<
            {
                dialects?: Readonly<Record<string, any>>;
                formats: EnumifyType;
                locales: Readonly<Record<string, Readonly<Record<string, any>>>>;
                modifiers?: Readonly<Record<string, string | readonly string[]>>;
                numbers?: Readonly<Record<string, number>>;
                ordinals?: Readonly<Record<string, number>>;
                tokens?: Readonly<Record<string, TokenEvaluator>>;
            },
        >
        +
        +

        static Tempo.registry

        +
        +

        Returns Readonly<
            {
                dialects?: Readonly<Record<string, any>>;
                formats: EnumifyType;
                locales: Readonly<Record<string, Readonly<Record<string, any>>>>;
                modifiers?: Readonly<Record<string, string | readonly string[]>>;
                numbers?: Readonly<Record<string, number>>;
                ordinals?: Readonly<Record<string, number>>;
                tokens?: Readonly<Record<string, TokenEvaluator>>;
            },
        >

      +
      + +
        +
      • +
        get terms(): SecureArray<Omit<TermPlugin, "resolve" | "define">> & Readonly<
            Record<string, Omit<TermPlugin, "resolve" | "define">>,
        >
        +
        +

        static Tempo.terms (registry)

        +
        +

        Returns SecureArray<Omit<TermPlugin, "resolve" | "define">> & Readonly<
            Record<string, Omit<TermPlugin, "resolve" | "define">>,
        >

      +
      + +
        +
      • +
        get TIMEZONE(): Extend<
            Readonly<
                {
                    acdt: "Australia/Adelaide";
                    acst: "Australia/Adelaide";
                    aedt: "Australia/Sydney";
                    aest: "Australia/Sydney";
                    awst: "Australia/Perth";
                    cdt: "America/Chicago";
                    cest: "Europe/Paris";
                    cet: "Europe/Paris";
                    cst: "America/Chicago";
                    edt: "America/New_York";
                    eest: "Europe/Helsinki";
                    eet: "Europe/Helsinki";
                    est: "America/New_York";
                    gmt: "UTC";
                    ist: "Asia/Kolkata";
                    jst: "Asia/Tokyo";
                    mdt: "America/Denver";
                    mst: "America/Denver";
                    npt: "Asia/Kathmandu";
                    nzdt: "Pacific/Auckland";
                    nzst: "Pacific/Auckland";
                    nzt: "Pacific/Auckland";
                    pdt: "America/Los_Angeles";
                    pst: "America/Los_Angeles";
                    utc: "UTC";
                },
            >,
            string,
            string,
        >
        +
        +

        Returns Extend<
            Readonly<
                {
                    acdt: "Australia/Adelaide";
                    acst: "Australia/Adelaide";
                    aedt: "Australia/Sydney";
                    aest: "Australia/Sydney";
                    awst: "Australia/Perth";
                    cdt: "America/Chicago";
                    cest: "Europe/Paris";
                    cet: "Europe/Paris";
                    cst: "America/Chicago";
                    edt: "America/New_York";
                    eest: "Europe/Helsinki";
                    eet: "Europe/Helsinki";
                    est: "America/New_York";
                    gmt: "UTC";
                    ist: "Asia/Kolkata";
                    jst: "Asia/Tokyo";
                    mdt: "America/Denver";
                    mst: "America/Denver";
                    npt: "Asia/Kathmandu";
                    nzdt: "Pacific/Auckland";
                    nzst: "Pacific/Auckland";
                    nzt: "Pacific/Auckland";
                    pdt: "America/Los_Angeles";
                    pst: "America/Los_Angeles";
                    utc: "UTC";
                },
            >,
            string,
            string,
        >

        +
        +
        +

        Use Tempo.enums.TIMEZONE

        +
      +
      + +
        +
      • +
        get version(): string
        +
        +

        the version of this Tempo build (stamped at build-time from package.json)

        +
        +

        Returns string

      +
      + +
        +
      • +
        get versions(): Readonly<Record<string, string>>
        +
        +

        the active versions of Tempo and any registered plugins or modules

        +
        +

        Returns Readonly<Record<string, string>>

      +
      + +
        +
      • +
        get weakCache(): SecureObject<
            SecureObject<
                {
                    get isWeakCache(): boolean;
                    clear(): void;
                    delete(key: string): boolean;
                    get(key: string): any;
                    getOrSet<V extends WeakKey>(key: string, factory: (key: string) => V): V;
                    has(key: string): boolean;
                    set<V extends WeakKey>(
                        key: string,
                        value: V,
                    ): { readonly get: (key: string) => any; readonly has: (key: string) => boolean; readonly set: <V extends WeakKey>(key: string, value: V) => ...; readonly getOrSet: <V extends WeakKey>(key: string, factory: (key: string) => V) => V; readonly delete: (key: string) => boolean; readonly clear: () => void; readonly isWeakC...;
                },
            >,
        >
        +
        +

        weakly-retained object cache facade for domain objects, ASTs, and plugin instances

        +
        +

        Returns SecureObject<
            SecureObject<
                {
                    get isWeakCache(): boolean;
                    clear(): void;
                    delete(key: string): boolean;
                    get(key: string): any;
                    getOrSet<V extends WeakKey>(key: string, factory: (key: string) => V): V;
                    has(key: string): boolean;
                    set<V extends WeakKey>(
                        key: string,
                        value: V,
                    ): { readonly get: (key: string) => any; readonly has: (key: string) => boolean; readonly set: <V extends WeakKey>(key: string, value: V) => ...; readonly getOrSet: <V extends WeakKey>(key: string, factory: (key: string) => V) => V; readonly delete: (key: string) => boolean; readonly clear: () => void; readonly isWeakC...;
                },
            >,
        >

      +
      + +
      +
      + +
        +
      • + +
        +

        iterate over instance formats

        +
        +

        Returns ArrayIterator<[string, string | undefined]>

      +
      + +
        +
      • + +
        +

        allow for auto-convert of Tempo to BigInt, Number or String

        +
        +
        +

        Parameters

        +
          +
        • Optionalhint: "string" | "number" | "default"
        +

        Returns string | number | bigint

      +
      + +
        +
      • + +
        +

        returns a new Tempo with specific duration added.

        +
        +
        +

        Parameters

        +
          +
        • Optionaltempo: MutateAdd
          • +
        • Optionaloptions: Options
        +

        Returns Tempo

      +
      + +
        +
      • + +
        +

        Returns a clone of the current Tempo instance.

        +
        +

        Returns Tempo

        +
        +
        +

        Tempo instances are immutable. Use Tempo.from(instance) instead.

        +
      +
      + +
        +
      • + +
        +

        apply a custom format.

        +
        +
        +

        Parameters

        +
          +
        • Optionalfmt: any
          • +
        • Optionaloptions: any
        +

        Returns string

        • +
      • + +
        +

        applies a format to the instance.

        +
        +
        +

        Parameters

        +
          +
        • options: FormatOptions
        +

        Returns string

        • +
      • + +
        +

        Applies a format to the instance. +Format strings are validated at compile time — any unrecognised {token} +will produce an IDE error showing the bad token name.

        +
        +
        +

        Type Parameters

        +
          +
        • S extends string
        +
        +

        Parameters

        +
          +
        • fmt: string extends S ? S : string extends ValidateFormat<S> ? S : ValidateFormat<S>
          • +
        • Optionaloptions: any
        +

        Returns string

        +
        +
        +

        TempoFormatTokens to extend the token set.

        +
        • +
      • + +
        +

        applies a format to the instance (zero-argument — returns a pre-built format proxy).

        +
        +

        Returns string

      +
      + +
        +
      • + +
        +

        Computes the next occurrence of a recurrence rule (RRULE string) after this instant.

        +
        +
        +

        Parameters

        +
          +
        • rrule: string | { rrule: string } +

          The RFC 5545 RRULE string or object with an rrule property

          +
        +

        Returns Tempo | null

        A new Tempo instance at the next occurrence, or null if no further occurrences exist

        +
      +
      + +
        +
      • + +
        +

        returns a new Tempo with specific offsets.

        +
        +
        +

        Parameters

        +
          +
        • Optionaltempo: MutateSet
          • +
        • Optionaloptions: Options
        +

        Returns Tempo

      +
      + +
        +
      • + +
        +

        explicitly enable/disable "catch" mode for this instance

        +
        +
        +

        Parameters

        +
          +
        • catchMode: boolean
        +

        Returns this

      +
      + +
        +
      • + +
        +

        time elapsed since another date-time

        +
        +
        +

        Parameters

        +
          +
        • OptionaldateTimeOrOpts: Options | DateTime
          • +
        • Optionalopts: Options
        +

        Returns Duration

        • +
      • + +
        +

        time elapsed since another date-time

        +
        +
        +

        Parameters

        +
          +
        • unit: Unit
          • +
        • Optionalopts: Options
        +

        Returns number

        • +
      • + +
        +

        time elapsed since another date-time

        +
        +
        +

        Parameters

        +
          +
        • dateTimeOrOpts: Options | DateTime
          • +
        • unit: Unit
        +

        Returns number

        • +
      • + +
        +

        time elapsed since (with unit)

        +
        +
        +

        Parameters

        +
          +
        • until: Until
          • +
        • Optionalopts: Options
        +

        Returns string

        • +
      • + +
        +

        time elapsed since another date-time (with unit)

        +
        +
        +

        Parameters

        +
          +
        • dateTimeOrOpts: Options | DateTime
          • +
        • until: Until
        +

        Returns string

        • +
      • + +
        +

        time elapsed since another date-time (w'out unit)

        +
        +
        +

        Parameters

        +
          +
        • OptionaldateTimeOrOpts: Options | DateTime
          • +
        • Optionalopts: Options
        +

        Returns string

        • +
      • + +
        +

        time elapsed since another date-time

        +
        +
        +

        Parameters

        +
          +
        • OptionaloptsOrDate: any
          • +
        • OptionaloptsOrUntil: any
        +

        Returns string

      +
      + +
        +
      • + +
        +

        returns a new Tempo with specific duration subtracted.

        +
        +
        +

        Parameters

        +
          +
        • Optionaltempo: MutateAdd
          • +
        • Optionaloptions: Options
        +

        Returns Tempo

      +
      + +
        +
      • + +
        +

        the date-time as a standard Date object.

        +
        +

        Returns Date

      +
      + +
        +
      • + +
        +

        returns the underlying Temporal.ZonedDateTime

        +
        +

        Returns ZonedDateTime

      +
      + +
        +
      • + +
        +

        returns the underlying Temporal.Instant

        +
        +

        Returns Instant

      +
      + +
        +
      • + +
        +

        Custom JSON serialization for JSON.stringify.

        +
        +

        Returns {
            calendar: CalendarLike;
            catch?: boolean;
            debug?: DebugLevel;
            dialect?: Evaluable<string>;
            discovery?: string | symbol | Discovery;
            format?: Evaluable<string | readonly string[]>;
            geo?: Readonly<GeoConfig>;
            intl?: Readonly<IntlOptions>;
            locale: string | readonly string[];
            mode?: "auto" | "strict" | "defer";
            planner?: Readonly<PlannerOptions>;
            pluginOptions?: Record<string, any>;
            plugins?: any;
            registry: Readonly<
                {
                    dialects?: Readonly<Record<string, any>>;
                    formats: FormatRegistry;
                    locales: Readonly<Record<string, Readonly<Record<string, any>>>>;
                    modifiers?: Readonly<Record<string, string | readonly string[]>>;
                    numbers?: Readonly<Record<string, number>>;
                    ordinals?: Readonly<Record<string, number>>;
                    tokens?: Readonly<Record<string, TokenEvaluator>>;
                },
            >;
            scope: "global"
            | "local";
            silent?: boolean;
            sphere: "north" | "south" | "east" | "west" | "equator" | undefined;
            store?: string;
            timeStamp?: TimeStamp;
            timeZone: TimeZoneLike;
            value: string;
        }

        +
          +
        • +
          Readonlycalendar: CalendarLike
          +

          Temporal calendar

          +
          • +
        • +
          Optionalcatch?: boolean
          +

          catch or throw Errors

          +
          • +
        • +
          Optionaldebug?: DebugLevel
          +

          additional console.log for tracking

          +
          • +
        • +
          Optionaldialect?: Evaluable<string>
          +

          Format dialect or dynamic dialect resolver (e.g. 'ldml', 'strftime', 'moment')

          +
          • +
        • +
          Optionaldiscovery?: string | symbol | Discovery
          +

          globalThis Discovery Symbol

          +
          • +
        • +
          Optionalformat?: Evaluable<string | readonly string[]>
          +

          Format mask, array of format masks, or dynamic mask resolver

          +
          • +
        • +
          Optional Readonlygeo?: Readonly<GeoConfig>
          +

          Geolocation coordinates configuration

          +
          • +
        • +
          Optional Readonlyintl?: Readonly<IntlOptions>
          +

          internationalization configuration (relativeTime, etc.)

          +
          • +
        • +
          Readonlylocale: string | readonly string[]
          +

          locale (e.g. en-AU)

          +
          • +
        • +
          Optionalmode?: "auto" | "strict" | "defer"
          +

          initialization strategy ('auto'|'strict'|'defer')

          +
          • +
        • +
          Optional Readonlyplanner?: Readonly<PlannerOptions>
          +

          parse planner configuration (layoutOrder, etc.)

          +
          • +
        • +
          OptionalpluginOptions?: Record<string, any>
          +

          Plugin configuration defaults and dictionaries keyed by plugin name

          +
          • +
        • +
          Optionalplugins?: any
          +

          Plugins or terms to extend onto Tempo.

          +
          +
          +
          +

          To provide configuration options or defaults for plugins, use pluginOptions instead.

          +
          • +
        • +
          Readonlyregistry: Readonly<
              {
                  dialects?: Readonly<Record<string, any>>;
                  formats: FormatRegistry;
                  locales: Readonly<Record<string, Readonly<Record<string, any>>>>;
                  modifiers?: Readonly<Record<string, string | readonly string[]>>;
                  numbers?: Readonly<Record<string, number>>;
                  ordinals?: Readonly<Record<string, number>>;
                  tokens?: Readonly<Record<string, TokenEvaluator>>;
              },
          >
          +

          custom data augmentation registries

          +
          • +
        • +
          Readonlyscope: "global" | "local"
          +

          scope for configuration mutations

          +
          • +
        • +
          Optionalsilent?: boolean
          +

          suppress console output during catch

          +
          • +
        • +
          Readonlysphere: "north" | "south" | "east" | "west" | "equator" | undefined
          +

          hemisphere for term.qtr or term.szn

          +
          • +
        • +
          Optionalstore?: string
          +

          localStorage key

          +
          • +
        • +
          OptionaltimeStamp?: TimeStamp
          +

          Precision to measure timestamps (ms | us)

          +
          • +
        • +
          ReadonlytimeZone: TimeZoneLike
          +

          Temporal timeZone

          +
          • +
        • +
          value: string
      +
      + +
        +
      • + +
        +

        the current system time localized to this instance.

        +
        +

        Returns ZonedDateTime

      +
      + +
        +
      • + +
        +

        returns a Temporal.PlainDate representation

        +
        +

        Returns PlainDate

      +
      + +
        +
      • + +
        +

        returns a Temporal.PlainDateTime representation

        +
        +

        Returns PlainDateTime

      +
      + +
        +
      • + +
        +

        returns a Temporal.PlainTime representation

        +
        +

        Returns PlainTime

      +
      + +
        +
      • + +
        +

        iso8601 string representation of the date-time.

        +
        +

        Returns string

      +
      + +
        +
      • + +
        +

        time duration until another date-time

        +
        +
        +

        Parameters

        +
          +
        • OptionaldateTimeOrOpts: Options | DateTime
          • +
        • Optionalopts: Options
        +

        Returns Duration

        • +
      • + +
        +

        time duration until another date-time

        +
        +
        +

        Parameters

        +
          +
        • unit: Unit
          • +
        • Optionalopts: Options
        +

        Returns number

        • +
      • + +
        +

        time duration until another date-time

        +
        +
        +

        Parameters

        +
          +
        • dateTimeOrOpts: Options | DateTime
          • +
        • unit: Unit
        +

        Returns number

        • +
      • + +
        +

        time duration until (returns Duration)

        +
        +
        +

        Parameters

        +
          +
        • OptionaldateTimeOrOpts: Options | DateTime
          • +
        • Optionalopts: Options
        +

        Returns Duration

        • +
      • + +
        +

        time duration until (with unit, returns number)

        +
        +
        +

        Parameters

        +
          +
        • unit: Unit
          • +
        • Optionalopts: Options
        +

        Returns number

        • +
      • + +
        +

        time duration until another date-time (with unit)

        +
        +
        +

        Parameters

        +
          +
        • dateTimeOrOpts: Options | DateTime
          • +
        • unit: Unit
        +

        Returns number

        • +
      • + +
        +

        fallback: union of possible returns

        +
        +
        +

        Parameters

        +
          +
        • OptionaloptsOrDate:
              | string
              | number
              | bigint
              | TempoBrand
              | ZonedDateTime
              | Instant
              | Options
              | PlainDate
              | PlainDateTime
              | PlainMonthDay
              | PlainYearMonth
              | Date
              | ZonedDateTimeLikeObject
              | ISOString
              | Tempo
              | PlainTime
              | Duration
              | DurationLikeObject
              | Options & { unit?: Unit }
              | null
          • +
        • OptionaloptsOrUntil: Options | Until
        +

        Returns number | Duration

      +
      + +
        +
      • + +
        +

        release global config and reset library to defaults

        +
        +

        Returns void

      +
      + +
        +
      • + +
        +

        Checks if an instance is a Tempo object using the brand symbol. +Allows instanceof to work across module boundaries.

        +
        +
        +

        Parameters

        +
          +
        • instance: any +

          The instance to check

          +
        +

        Returns boolean

        True if the instance is a Tempo object

        +
      +
      + +
        +
      • + +
        +

        iterate over Tempo properties

        +
        +

        Returns ArrayIterator<string>

      +
      + +
        +
      • + +
        +

        Automatically discovers and loads configuration from tempo.config.* +before initializing the engine.

        +
        +
        +

        Parameters

        +
          +
        • Optionaloptions: { configFile?: string; cwd?: string }
        +

        Returns Promise<typeof Tempo>

      +
      + +
        +
      • + +
        +

        Compares two Tempo instances or date-time values. Returns -1 (earlier), 0 (equal), or 1 (later).

        +
        +
        +

        Parameters

        +
          +
        • Optionaltempo1: Options | DateTime
          • +
        • Optionaltempo2: Options | DateTime
        +

        Returns number

      +
      + +
        +
      • + +
        +

        🏭 Sandbox Factory & Scoped Execution Mode

        +
          +
        1. +

          Factory Mode: Creates a fresh, isolated Tempo subclass with its own configuration and registries. +The returned class implements Disposable ([Symbol.dispose]()), allowing deterministic cleanup via using.

          +
          2. +
        2. +

          Scoped Execution Mode: When provided a callback, creates an isolated sandbox, executes the callback, +and automatically disposes the sandbox upon completion (supporting both synchronous and Promise returns).

          +
          3. +
        +
        +
        +

        Parameters

        +
          +
        • Optionaloptions: Options
        +

        Returns typeof Tempo

        +
        +
        +
        // Factory mode with `using`
        {
          using sb = Tempo.create({ discovery: 'test' });
          sb.use(MyPlugin);
        }

        // Scoped callback mode
        const result = Tempo.create((sb) => {
          sb.use(MyPlugin);
          return sb('2026-05-10').format();
        });
+
        + +
        • +
      • + +
        +

        🏭 Sandbox Factory & Scoped Execution Mode

        +
          +
        1. +

          Factory Mode: Creates a fresh, isolated Tempo subclass with its own configuration and registries. +The returned class implements Disposable ([Symbol.dispose]()), allowing deterministic cleanup via using.

          +
          2. +
        2. +

          Scoped Execution Mode: When provided a callback, creates an isolated sandbox, executes the callback, +and automatically disposes the sandbox upon completion (supporting both synchronous and Promise returns).

          +
          3. +
        +
        +
        +

        Type Parameters

        +
          +
        • R
        +
        +

        Parameters

        +
          +
        • fn: (sandbox: typeof Tempo) => R
        +

        Returns R

        +
        +
        +
        // Factory mode with `using`
        {
          using sb = Tempo.create({ discovery: 'test' });
          sb.use(MyPlugin);
        }

        // Scoped callback mode
        const result = Tempo.create((sb) => {
          sb.use(MyPlugin);
          return sb('2026-05-10').format();
        });
+
        + +
        • +
      • + +
        +

        🏭 Sandbox Factory & Scoped Execution Mode

        +
          +
        1. +

          Factory Mode: Creates a fresh, isolated Tempo subclass with its own configuration and registries. +The returned class implements Disposable ([Symbol.dispose]()), allowing deterministic cleanup via using.

          +
          2. +
        2. +

          Scoped Execution Mode: When provided a callback, creates an isolated sandbox, executes the callback, +and automatically disposes the sandbox upon completion (supporting both synchronous and Promise returns).

          +
          3. +
        +
        +
        +

        Type Parameters

        +
          +
        • R
        +
        +

        Parameters

        +
          +
        • options: Options
          • +
        • fn: (sandbox: typeof Tempo) => R
        +

        Returns R

        +
        +
        +
        // Factory mode with `using`
        {
          using sb = Tempo.create({ discovery: 'test' });
          sb.use(MyPlugin);
        }

        // Scoped callback mode
        const result = Tempo.create((sb) => {
          sb.use(MyPlugin);
          return sb('2026-05-10').format();
        });
+
        + +
      +
      + +
        +
      • + +
        +
        +

        Parameters

        +
          +
        • discovery: Discovery
          • +
        • Optionalsymbol: symbol
        +

        Returns typeof Tempo

        +
        +
        +

        Use Tempo.use(...) instead.

        +
        • +
      • + +
        +
        +

        Parameters

        +
          +
        • plugin: TempoPlugin
          • +
        • Optionaloptions: Options
        +

        Returns typeof Tempo

        +
        +
        +

        Use Tempo.use(...) instead.

        +
        • +
      • + +
        +
        +

        Parameters

        +
          +
        • plugins: any[]
          • +
        • Optionaloptions: Options
        +

        Returns typeof Tempo

        +
        +
        +

        Use Tempo.use(...) instead.

        +
        • +
      • + +
        +
        +

        Parameters

        +
          +
        • ...args: any[]
        +

        Returns typeof Tempo

        +
        +
        +

        Use Tempo.use(...) instead.

        +
      +
      + +
        +
      • + +
        +

        Creates a new Tempo instance.

        +
        +
        +

        Parameters

        +
          +
        • Optionaloptions: Options
        +

        Returns Tempo

        • +
      • + +
        +

        Creates a new Tempo instance.

        +
        +
        +

        Parameters

        +
          +
        • tempo: DateTime
          • +
        • Optionaloptions: Options
        +

        Returns Tempo

      +
      + +
        +
      • + +
        +

        Reset Tempo to its default, built-in registration state

        +
        +
        +

        Parameters

        +
          +
        • options: Options = {}
        +

        Returns typeof Tempo

      +
      + +
        +
      • + +
        +

        check if a supplied variable is a valid Tempo instance

        +
        +
        +

        Parameters

        +
          +
        • Optionalinstance: any
        +

        Returns instance is Tempo

      +
      + +
        +
      • + +
        +

        Gets the current timestamp in the specified unit.

        +
        +
        +

        Parameters

        +
          +
        • unit: "ss" | "ms" | "us" +

          The time unit ('ss', 'ms', 'us').

          +
        +

        Returns number

        The current timestamp as a number (for 'ss', 'ms', 'us')

        +
        • +
      • + +
        +

        Gets the current timestamp in the specified unit.

        +
        +
        +

        Parameters

        +
          +
        • Optionalunit: "ns" +

          The time unit ('ss', 'ms', 'us', 'ns'). Defaults to 'ns' (nanoseconds).

          +
        +

        Returns bigint

        The current timestamp as a number (for 'ss', 'ms', 'us') or bigint (for 'ns')

        +
      +
      + +
        +
      • + +
        +

        Wait for engine readiness.

        +
        +

        Returns Promise<string>

        The final status ('none' in Community Tempo)

        +
      +
      + +
        +
      • + +
        +

        translates {layout} into an anchored, case-insensitive RegExp.

        +
        +
        +

        Parameters

        +
          +
        • layout: string | RegExp
          • +
        • Optionalsnippet: Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
        +

        Returns RegExp

      +
      + +
        +
      • + +
        +

        explicitly enable/disable "catch" mode for internal errors

        +
        +
        +

        Parameters

        +
          +
        • catchMode: boolean
        +

        Returns typeof Tempo

      +
      + +
        +
      • + +
        +

        Register discovery configuration with an optional discovery symbol.

        +
        +
        +

        Parameters

        +
          +
        • discovery: Discovery +

          Discovery object defining options, formats, periods, or terms.

          +
          • +
        • Optionalsymbol: symbol +

          Optional symbol identifier under globalThis to attach discovery data.

          +
        +

        Returns typeof Tempo

        • +
      • + +
        +

        Register an individual plugin or plugin factory.

        +
        +
        +

        Type Parameters

        +
          +
        • T extends TempoPlugin = TempoPlugin
          • +
        • Opts = any
        +
        +

        Parameters

        +
          +
        • plugin: any +

          The plugin function or definition to register.

          +
          • +
        • Optionaloptions: Options +

          Optional configuration for the plugin.

          +
        +

        Returns typeof Tempo

        • +
      • + +
        +

        Register an array of plugins, terms, factories, or tuples.

        +
        +
        +

        Parameters

        +
          +
        • plugins: any[] +

          An array of plugins, terms, factories, or tuples to register.

          +
          • +
        • Optionaloptions: Options +

          Optional configuration for the plugins.

          +
        +

        Returns typeof Tempo

        • +
      • + +
        +

        Register multiple plugins or term extensions.

        +
        +
        +

        Parameters

        +
          +
        • ...args: any[] +

          A plugin, term, or list of extensions to register.

          +
        +

        Returns typeof Tempo

      +
      +
      +
      +
      +

      Settings

       +
      +
      Member Visibility +
        +
        • +
        • +
      +
      +
      +

      On This Page

       +
      +
      Constructors +
      +
      Properties +
      +
      Accessors +
      +
      Methods +
      +
      + +
      +
      diff --git a/packages/tempo/public/v4/api/functions/Tempo.duration.html b/packages/tempo/public/v4/api/functions/Tempo.duration.html new file mode 100644 index 00000000..d4c0fb65 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/Tempo.duration.html @@ -0,0 +1,46 @@ +duration | Tempo API
      +
      Tempo API + +
        +
        +
        Preparing search index...
        +
        +
        +
        + +

        Function duration

        +
        +
          +
        • + +
          +

          returns a full Tempo Duration object (EDO) for the given input

          +
          +
          +

          Parameters

          +
            +
          • input: any
          +

          Returns Duration

        +
        +
        +
        +
        +

        Settings

         +
        +
        Member Visibility +
          +
          • +
          • +
        +
        +
        + +
        +
        diff --git a/packages/tempo/public/v4/api/functions/defineConfig.html b/packages/tempo/public/v4/api/functions/defineConfig.html new file mode 100644 index 00000000..7dc2be31 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/defineConfig.html @@ -0,0 +1,45 @@ +defineConfig | Tempo API
        +
        Tempo API + +
          +
          +
          Preparing search index...
          +
          +
          +
          + +

          Function defineConfig

          +
          +
            +
          • + +
            +

            Identity function to provide TypeScript autocomplete for Tempo configurations.

            +
            +
            +

            Parameters

            +
              +
            • config: Options
            +

            Returns Options

          +
          +
          +
          +
          +

          Settings

           +
          +
          Member Visibility +
            +
            • +
            • +
          +
          +
          + +
          +
          diff --git a/packages/tempo/public/v4/api/functions/defineRange.html b/packages/tempo/public/v4/api/functions/defineRange.html new file mode 100644 index 00000000..2f3eff36 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/defineRange.html @@ -0,0 +1,60 @@ +defineRange | Tempo API
          +
          Tempo API + +
            +
            +
            Preparing search index...
            +
            +
            +
            + +

            Function defineRange

            +
            +

            Term Plugin API

            +

            Exports the framework utilities and types required for authoring custom Term plugins. +This barrel is utilized by external developers building natural-language components.

            +
            +
            +
              +
            • + +
              +

              Groups and secures term ranges for efficient lookup.

              +
              +
              +

              Type Parameters

              +
              +
              +

              Parameters

              +
                +
              • ranges: T[] +

                The ranges to group

                +
                • +
              • ...keys: (keyof T)[] +

                Range properties used as grouping keys

                +
              +

              Returns SecureObject<Record<PropertyKey, T[]>>

              A secured collection of grouped ranges

              +
            +
            +
            +
            +
            +

            Settings

             +
            +
            Member Visibility +
              +
              • +
              • +
            +
            +
            + +
            +
            diff --git a/packages/tempo/public/v4/api/functions/defineTerm.html b/packages/tempo/public/v4/api/functions/defineTerm.html new file mode 100644 index 00000000..b0307663 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/defineTerm.html @@ -0,0 +1,54 @@ +defineTerm | Tempo API
            +
            Tempo API + +
              +
              +
              Preparing search index...
              +
              +
              +
              + +

              Function defineTerm

              +
              +
                +
              • + +
                +
                +

                Helper to register a Term plugin.

                +
                +
                +

                Type Parameters

                +
                +
                +

                Parameters

                +
                  +
                • term: T
                +

                Returns TermFactory<T, Opts>

              +
              +
              +
              +
              +

              Settings

               +
              +
              Member Visibility +
                +
                • +
                • +
              +
              +
              +

              On This Page

               +
              defineTerm
              +
              + +
              +
              diff --git a/packages/tempo/public/v4/api/functions/format.html b/packages/tempo/public/v4/api/functions/format.html new file mode 100644 index 00000000..05c3aba6 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/format.html @@ -0,0 +1,116 @@ +format | Tempo API
              +
              Tempo API + +
                +
                +
                Preparing search index...
                +
                +
                +
                + +

                Function format

                +
                +

                Formats a supported date-time value using a named format, template, or internationalization options. +Scoped day/week time fields count wall-clock units from local midnight or Monday, independent of offset transitions. +The roman modifier converts integers 1-3999 and leaves other values unchanged.

                +
                +
                +
                +

                The value to format; omitted values use the current date and time.

                +
                +
                +

                A registered format name or literal format template.

                +
                +
                +

                Formatting and configuration overrides.

                +
                +
                +

                The formatted date-time string, a format proxy when no format or options are supplied, or an empty string +when a format is supplied and the resolved value is not a ZonedDateTime.

                +
                +
                +

                Error when a requested dialect formatter is unavailable. Temporal input conversion errors, +formatter or custom token callback errors, and Intl errors when no fallback succeeds also propagate.

                +
                +
                +
                  +
                • + +
                  +

                  Standalone Formatter +Returns a formatted string from a Temporal.ZonedDateTime or Tempo instance.

                  +
                  +
                  +

                  Parameters

                  +
                    +
                  • Optionalobj: any
                  +

                  Returns any

                  +
                  +
                  +
                  import { format } from '@magmacomputing/tempo/format';
                  const str = format(Temporal.Now.zonedDateTimeISO(), '{yyyy}-{mm}-{dd}');

                  // Proxy usage (zero or one argument)
                  const weekDate = format(zdt).weekDate;
                  const stamp = format().logStamp; // defaults to 'Now'
+
                  + +
                  • +
                • + +
                  +

                  Standalone Formatter +Returns a formatted string from a Temporal.ZonedDateTime or Tempo instance.

                  +
                  +
                  +

                  Parameters

                  +
                    +
                  • obj: any
                    • +
                  • options: FormatOptions
                  +

                  Returns string

                  +
                  +
                  +
                  import { format } from '@magmacomputing/tempo/format';
                  const str = format(Temporal.Now.zonedDateTimeISO(), '{yyyy}-{mm}-{dd}');

                  // Proxy usage (zero or one argument)
                  const weekDate = format(zdt).weekDate;
                  const stamp = format().logStamp; // defaults to 'Now'
+
                  + +
                  • +
                • + +
                  +

                  Standalone Formatter +Returns a formatted string from a Temporal.ZonedDateTime or Tempo instance.

                  +
                  +
                  +

                  Parameters

                  +
                    +
                  • obj: any
                    • +
                  • fmt: string | symbol
                    • +
                  • Optionaloptions: any
                  +

                  Returns string

                  +
                  +
                  +
                  import { format } from '@magmacomputing/tempo/format';
                  const str = format(Temporal.Now.zonedDateTimeISO(), '{yyyy}-{mm}-{dd}');

                  // Proxy usage (zero or one argument)
                  const weekDate = format(zdt).weekDate;
                  const stamp = format().logStamp; // defaults to 'Now'
+
                  + +
                +
                +
                +
                +
                +

                Settings

                 +
                +
                Member Visibility +
                  +
                  • +
                  • +
                +
                +
                + +
                +
                diff --git a/packages/tempo/public/v4/api/functions/parse.html b/packages/tempo/public/v4/api/functions/parse.html new file mode 100644 index 00000000..b145e4c9 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/parse.html @@ -0,0 +1,52 @@ +parse | Tempo API
                +
                Tempo API + +
                  +
                  +
                  Preparing search index...
                  +
                  +
                  +
                  + +

                  Function parse

                  +
                  +
                    +
                  • + +
                    +

                    Parses a date-time value using an isolated parser configuration.

                    +

                    Standalone parsing defaults to strict mode and applies the supplied configuration overrides.

                    +
                    +
                    +

                    Parameters

                    +
                      +
                    • value: DateTime +

                      The date-time value to parse.

                      +
                      • +
                    • options: Options = {} +

                      Configuration overrides for this parse operation.

                      +
                    +

                    Returns ZonedDateTime

                    The parsed date-time as a Temporal.ZonedDateTime.

                    +
                  +
                  +
                  +
                  +
                  +

                  Settings

                   +
                  +
                  Member Visibility +
                    +
                    • +
                    • +
                  +
                  +
                  + +
                  +
                  diff --git a/packages/tempo/public/v4/api/functions/resolveRangeDiff.html b/packages/tempo/public/v4/api/functions/resolveRangeDiff.html new file mode 100644 index 00000000..7750e590 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/resolveRangeDiff.html @@ -0,0 +1,63 @@ +resolveRangeDiff | Tempo API
                  +
                  Tempo API + +
                    +
                    +
                    Preparing search index...
                    +
                    +
                    +
                    + +

                    Function resolveRangeDiff

                    +
                    +

                    Term Plugin API

                    +

                    Exports the framework utilities and types required for authoring custom Term plugins. +This barrel is utilized by external developers building natural-language components.

                    +
                    +
                    +
                      +
                    • + +
                      +

                      Resolves the difference between two Tempo instances in terms of a range-based Term plugin. +(e.g. t1.until(t2, '#qtr'), t2.since(t1, '#szn'))

                      +
                      +
                      +

                      Parameters

                      +
                        +
                      • termObj: any +

                        The term plugin instance providing ranges via define()

                        +
                        • +
                      • other: Tempo +

                        The target Tempo instance

                        +
                        • +
                      • _unit: string +

                        The unit string (e.g. "#qtr")

                        +
                        • +
                      • tempo: Tempo +

                        The origin Tempo instance

                        +
                      +

                      Returns number | undefined

                      The signed count of ranges between tempo and other, or undefined

                      +
                    +
                    +
                    +
                    +
                    +

                    Settings

                     +
                    +
                    Member Visibility +
                      +
                      • +
                      • +
                    +
                    +
                    + +
                    +
                    diff --git a/packages/tempo/public/v4/api/functions/resolveRangeFormat.html b/packages/tempo/public/v4/api/functions/resolveRangeFormat.html new file mode 100644 index 00000000..00b1fca3 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/resolveRangeFormat.html @@ -0,0 +1,60 @@ +resolveRangeFormat | Tempo API
                    +
                    Tempo API + +
                      +
                      +
                      Preparing search index...
                      +
                      +
                      +
                      + +

                      Function resolveRangeFormat

                      +
                      +

                      Term Plugin API

                      +

                      Exports the framework utilities and types required for authoring custom Term plugins. +This barrel is utilized by external developers building natural-language components.

                      +
                      +
                      +
                        +
                      • + +
                        +

                        Resolves formatted term tokens (e.g. "{#qtr}", "{#qtr.label}", "{#szn.symbol}") +by delegating to the range definition of the term.

                        +
                        +
                        +

                        Parameters

                        +
                          +
                        • termObj: any +

                          The term plugin instance providing ranges via define()

                          +
                          • +
                        • token: string +

                          The format token (e.g. "#qtr", "#qtr.label")

                          +
                          • +
                        • tempo: Tempo +

                          The reference Tempo instance being formatted

                          +
                        +

                        Returns string | undefined

                        The resolved string value, or undefined when not resolvable

                        +
                      +
                      +
                      +
                      +
                      +

                      Settings

                       +
                      +
                      Member Visibility +
                        +
                        • +
                        • +
                      +
                      +
                      + +
                      +
                      diff --git a/packages/tempo/public/v4/api/functions/resolveRangeOrdinal.html b/packages/tempo/public/v4/api/functions/resolveRangeOrdinal.html new file mode 100644 index 00000000..ae32a8d8 --- /dev/null +++ b/packages/tempo/public/v4/api/functions/resolveRangeOrdinal.html @@ -0,0 +1,60 @@ +resolveRangeOrdinal | Tempo API
                      +
                      Tempo API + +
                        +
                        +
                        Preparing search index...
                        +
                        +
                        +
                        + +

                        Function resolveRangeOrdinal

                        +
                        +

                        Term Plugin API

                        +

                        Exports the framework utilities and types required for authoring custom Term plugins. +This barrel is utilized by external developers building natural-language components.

                        +
                        +
                        +
                          +
                        • + +
                          +

                          Resolves an anchored ordinal expression (e.g. "3rd day of #qtr.2", "last day of #szn.summer") +relative to a range-based Term plugin.

                          +
                          +
                          +

                          Parameters

                          +
                            +
                          • termObj: any +

                            The term plugin instance providing ranges via define()

                            +
                            • +
                          • groups: Record<string, any> +

                            Capture groups from the ordinal expression (e.g. ord, term, value)

                            +
                            • +
                          • anchor: Tempo +

                            The reference Tempo instance

                            +
                          +

                          Returns Tempo | undefined

                          The resolved Tempo instance, or undefined when not resolvable

                          +
                        +
                        +
                        +
                        +
                        +

                        Settings

                         +
                        +
                        Member Visibility +
                          +
                          • +
                          • +
                        +
                        +
                        + +
                        +
                        diff --git a/packages/tempo/public/v4/api/hierarchy.html b/packages/tempo/public/v4/api/hierarchy.html new file mode 100644 index 00000000..96ab0b51 --- /dev/null +++ b/packages/tempo/public/v4/api/hierarchy.html @@ -0,0 +1,34 @@ +Tempo API
                        +
                        Tempo API + +
                          +
                          +
                          Preparing search index...
                          +
                          +
                          +
                          +

                          Tempo API

                          +

                          Hierarchy Summary

                          +
                          +
                          +
                          +
                          +
                          +

                          Settings

                           +
                          +
                          Member Visibility +
                            +
                            • +
                            • +
                          +
                          +
                          + +
                          +
                          diff --git a/packages/tempo/public/v4/api/index.html b/packages/tempo/public/v4/api/index.html new file mode 100644 index 00000000..08a6bcf5 --- /dev/null +++ b/packages/tempo/public/v4/api/index.html @@ -0,0 +1,172 @@ +Tempo API
                          +
                          Tempo API + +
                            +
                            +
                            Preparing search index...
                            +
                            +
                            +
                            +

                            Tempo API

                            +
                            + + + + + + +
                            + Tempo Logo + +

                            Tempo

                            +

                            The Professional Date-Time Library for the Temporal API

                            +
                            +

                            Tempo is a premium, high-performance wrapper for the ECMAScript Temporal API. Designed for professionals, it combines immutable state-management with a fluent, natural-language engine. It is the modern, type-safe successor to legacy libraries like Moment.js and Luxon.

                            +
                            +

                            Our Mission: Humanizing Temporal. Bringing developer intuition, cultural awareness, and expressive natural-language ergonomics to JavaScript dates—anchored in a rock-solid ISO 8601 baseline. Read our vision & architecture →

                            +
                            +

                            + npm version Socket Security Temporal Documentation Live Interactive REPL +

                            +
                            + +
                            import { Tempo } from '@magmacomputing/tempo';
                            import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';

                            // 🔌 Instantly Extensible (with deterministic defaults)
                            Tempo.init({ 
                              plugins: [CelestialPlugin],
                              timeZone: 'America/New_York'
                            });

                            // 🎯 Natural Language Parsing (Deterministic anchor)
                            const event = new Tempo('next Friday 3pm', { anchor: '2026-10-15' });

                            // 🔄 Fluent Mutations (Immutable)
                            const reminder = event.add({ hours: 2 }).set({ minute: 0 });

                            // ⏳ Comparative Durations
                            const diff = event.until('2026-12-25');
                            console.log(diff.iso); // P2M2D

                            // 📝 Beautiful Formatting
                            console.log(event.format('{mon} {dd:ord}, {yyyy}')); // October 23rd, 2026

                            // 🌌 Domain Logic (via Plugin)
                            console.log(event.term.astronomy.season); // 'Autumn'
+
                            + +
                            + +
                            npm install @magmacomputing/tempo       # npm
                            yarn add @magmacomputing/tempo          # yarn
                            pnpm add @magmacomputing/tempo          # pnpm
                            bun add @magmacomputing/tempo           # bun
                            deno add npm:@magmacomputing/tempo      # deno
+
                            + +
                            +

                            Runtime Support: Requires Node.js >= 20.0.0 (Recommended: Node 24 LTS or Node >= 26.10.0 with full native Temporal support).

                            +
                            +
                            +🌐 Browser & Native Environments +

                            For standard usage natively in the browser, use the pre-optimized Global ESM Bundle. It includes the entire core engine in a single file:

                            +
                            <script type="importmap">
                            {
                              "imports": {
                                "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
                                "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.esm.js"
                              }
                            }
                            </script>

                            <script type="module">
                              import '@js-temporal/polyfill';
                              import { Tempo } from '@magmacomputing/tempo';
                              
                              const t = new Tempo('next Friday');
                            </script>
+
                            + +
                            +

                            Advanced Usage (Tempo Plugins & CDNs) +If you need to use Tempo Plugins natively in the browser, require granular module resolution, or want to use on-the-fly bundling CDNs (like esm.sh), please see our comprehensive Installation Guide for detailed import map configurations.

                            +
                            +
                            +
                            + +

                            While the native Temporal API gives you perfect primitives (ZonedDateTime, PlainDate), it doesn't give you business logic. Tempo bridges that gap.

                            + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                            FeatureNative Temporal APIThe Tempo Ecosystem
                            PrimitivesPerfect (Instant, ZonedDateTime)Powered by Native Primitives ✨
                            TimezonesIANA String SupportAdvanced fallback & auto-syncing
                            Domain Logic❌ Build it yourself✅ Plugins (astro, sync)
                            Natural Language❌ Manual parsing✅ "next Friday 3pm"
                            + +
                              +
                            • 🗣️ Natural Language & Smart Parsing: Parse natural language phrases (e.g. "next Friday 3pm", "two days ago") with zero-cost lazy evaluation and functional aliases.
                              • +
                            • 🌍 Zero-Bundle Localization: Multi-language date parsing and formatting powered natively by ECMAScript Intl—no heavy static locale dictionaries required.
                              • +
                            • 🧩 Extensible & AI-Ready: Modular plugin ecosystem for astronomical cycles (astro), financial quarters (finance), schedulers (ticker), and LLM-powered parsing (ai).
                              • +
                            • 🏗️ Future-Proof & Ultra-Lightweight: Built natively on the TC39 Stage 4 Temporal foundation with zero legacy runtime baggage and full tree-shaking support.
                              • +
                            +
                            + +

                            For a deeper dive into the API, architecture, and advanced features:

                            + +
                            + +

                            Tempo is the core library, but the ecosystem extends further:

                            + + + + + + + + + + + + + + + + + + + + + + + + + +
                            PackageDescriptionDocs
                            @magmacomputing/tempoCore library — parsing, formatting, natural-language engineDocumentation
                            @magmacomputing/tempo-fnsPure functional utilities built on native Temporal & Tempo — tree-shakeable helpersDocumentation
                            @magmacomputing/tempo-plugin-*Official & community plugins — AI, Ticker, Astro, Finance, Sync, Snap, and morePlugin Ecosystem Catalog
                            +
                            + +
                              +
                            1. Bug Reports & Features: Please open an Issue.
                              2. +
                            2. Questions & Ideas: Start a thread in Discussions.
                              3. +
                            3. Direct Contact: You can reach us at hello@magmacomputing.com.au.
                              4. +
                            +
                            + +

                            🚀 Premium!   |   +⭐ Loving it!   |   +💡 Needs work   |   +🐞 Found a bug

                            +
                            + +

                            Distributed under the MIT License. See LICENSE for more information.

                            +
                            +
                            +
                            +
                            +
                            +

                            Settings

                             +
                            +
                            Member Visibility +
                              +
                              • +
                              • +
                            +
                            +
                            +

                            On This Page

                             +
                            ⚡ Quick Start📦 Installation⏳ Why Tempo? +📚 Documentation🧰 The Tempo Ecosystem💬 Contact & Support🗳️ Feedback & Reactions⚖️ License
                            +
                            + +
                            +
                            diff --git a/packages/tempo/public/v4/api/interfaces/Tempo.BaseOptions.html b/packages/tempo/public/v4/api/interfaces/Tempo.BaseOptions.html new file mode 100644 index 00000000..e521b3ff --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/Tempo.BaseOptions.html @@ -0,0 +1,340 @@ +BaseOptions | Tempo API
                            +
                            Tempo API + +
                              +
                              +
                              Preparing search index...
                              +
                              +
                              +
                              + +

                              Interface BaseOptions

                              +
                              +

                              Base configuration options for Tempo

                              +
                              +
                              interface BaseOptions {
                                  calendar?: Evaluable<CalendarLike>;
                                  catch?: boolean;
                                  debug?: DebugLevel;
                                  dialect?: Evaluable<string>;
                                  discovery?: string | symbol | Discovery;
                                  error?: "catch" | "silent" | "log" | "throw";
                                  extends?: string | string[];
                                  format?: Evaluable<string | readonly string[]>;
                                  geo?: GeoOptions;
                                  intl?: IntlOptions;
                                  locale?: Evaluable<string | readonly string[]>;
                                  mode?: "auto" | "strict" | "defer";
                                  monthDay?: boolean | MonthDay;
                                  pivot?: number;
                                  planner?: PlannerOptions;
                                  pluginOptions?: Record<string, any>;
                                  plugins?: any;
                                  registry?: {
                                      dialects?: Record<string, any>;
                                      events?:
                                          | Extend<
                                              {
                                                  christmas: "25 Dec";
                                                  "christmas ?eve": "24 Dec";
                                                  fortnight: (this: AliasContext) => AliasContext;
                                                  "new.?years? ?eve": "31 Dec";
                                                  "new.?years?(?: ?day)?": "01 Jan";
                                                  now: (this: AliasContext) => AliasContext;
                                                  ny: "01 Jan";
                                                  nye: "31 Dec";
                                                  today: (this: AliasContext) => ZonedDateTime;
                                                  tomorrow: (this: AliasContext) => AliasContext;
                                                  xmas: "25 Dec";
                                                  "xmas ?eve": "24 Dec";
                                                  yesterday: (this: AliasContext) => AliasContext;
                                              },
                                              string,
                                              string
                                              | Function,
                                          >
                                          | RegistryOption<Logic>;
                                      formats?: Property<any>;
                                      ignores?: Ignore;
                                      layouts?:
                                          | Extend<{ readonly [key: symbol]: string }, symbol, string>
                                          | RegistryOption<Pattern>;
                                      locales?: Record<
                                          string,
                                          Record<string, string | Function | Record<string, any>>,
                                      >;
                                      modifiers?: Record<string, string | string[] | readonly string[]>;
                                      numbers?: Record<string, number>;
                                      ordinals?: Record<string, number>;
                                      periods?:
                                          | Extend<
                                              {
                                                  "after[ -]?noon": "3:00pm";
                                                  evening: "18:00";
                                                  "half[ -]?hour": (this: AliasContext) => string;
                                                  "mid[ -]?day": "12:00";
                                                  "mid[ -]?morning": "10:00";
                                                  "mid[ -]?night": "24:00";
                                                  morning: "8:00";
                                                  night: "20:00";
                                                  noon: "12:00";
                                              },
                                              string,
                                              string
                                              | Function,
                                          >
                                          | RegistryOption<Logic>;
                                      snippets?:
                                          | Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
                                          | RegistryOption<Pattern>;
                                      tokens?: Record<string, TokenEvaluator>;
                                  };
                                  silent?: boolean;
                                  sphere?: Evaluable<
                                      "north"
                                      | "south"
                                      | "east"
                                      | "west"
                                      | "equator"
                                      | undefined,
                                  >;
                                  store?: string;
                                  timestamp?: TimeStamp;
                                  timeStamp?: TimeStamp;
                                  timeZone?: Evaluable<TimeZoneLike>;
                                  value?: DateTime;
                              }
                              +
                              +

                              Hierarchy

                              +
                                +
                              • BaseOptions +
                                  +
                                • BaseOptions
                              +
                              +
                              +
                              +
                              Index
                               +
                              +
                              + +
                              calendar? +catch? +debug? +dialect? +discovery? +error? +extends? +format? +geo? +intl? +locale? +mode? +monthDay? +pivot? +planner? +pluginOptions? +plugins? +registry? +silent? +sphere? +store? +timestamp? +timeStamp? +timeZone? +value? +
                              +
                              + +
                              +
                              + +
                              calendar?: Evaluable<CalendarLike>
                              +

                              Temporal calendar

                              +
                              +
                              + +
                              catch?: boolean
                              +

                              catch or throw Errors

                              +
                              +
                              + +
                              debug?: DebugLevel
                              +

                              additional console.log for tracking

                              +
                              +
                              + +
                              dialect?: Evaluable<string>
                              +

                              Format dialect or dynamic dialect resolver (e.g. 'ldml', 'strftime', 'moment')

                              +
                              +
                              + +
                              discovery?: string | symbol | Discovery
                              +

                              globalThis Discovery Symbol

                              +
                              +
                              + +
                              error?: "catch" | "silent" | "log" | "throw"
                              +

                              convenience error handling policy preset

                              +
                              +
                              + +
                              extends?: string | string[]
                              +

                              URLs or file paths to inherit configuration from

                              +
                              +
                              + +
                              format?: Evaluable<string | readonly string[]>
                              +

                              Format mask, array of format masks, or dynamic mask resolver

                              +
                              +
                              + +
                              geo?: GeoOptions
                              +

                              Geolocation coordinates configuration for location-aware plugins

                              +
                              +
                              + +
                              intl?: IntlOptions
                              +

                              internationalization configuration (relativeTime, etc.)

                              +
                              +
                              + +
                              locale?: Evaluable<string | readonly string[]>
                              +

                              locale (e.g. en-AU)

                              +
                              +
                              + +
                              mode?: "auto" | "strict" | "defer"
                              +

                              initialization strategy ('auto'|'strict'|'defer')

                              +
                              +
                              + +
                              monthDay?: boolean | MonthDay
                              +

                              regional date-parsing configuration

                              +
                              +
                              + +
                              pivot?: number
                              +

                              pivot year for two-digit years

                              +
                              +
                              + +
                              planner?: PlannerOptions
                              +

                              parse planner configuration (layoutOrder, etc.)

                              +
                              +
                              + +
                              pluginOptions?: Record<string, any>
                              +

                              Plugin configuration defaults and dictionaries keyed by plugin name

                              +
                              +
                              + +
                              plugins?: any
                              +

                              Plugins or terms to extend onto Tempo.

                              +
                              +
                              +
                              +

                              To provide configuration options or defaults for plugins, use pluginOptions instead.

                              +
                              +
                              + +
                              registry?: {
                                  dialects?: Record<string, any>;
                                  events?:
                                      | Extend<
                                          {
                                              christmas: "25 Dec";
                                              "christmas ?eve": "24 Dec";
                                              fortnight: (this: AliasContext) => AliasContext;
                                              "new.?years? ?eve": "31 Dec";
                                              "new.?years?(?: ?day)?": "01 Jan";
                                              now: (this: AliasContext) => AliasContext;
                                              ny: "01 Jan";
                                              nye: "31 Dec";
                                              today: (this: AliasContext) => ZonedDateTime;
                                              tomorrow: (this: AliasContext) => AliasContext;
                                              xmas: "25 Dec";
                                              "xmas ?eve": "24 Dec";
                                              yesterday: (this: AliasContext) => AliasContext;
                                          },
                                          string,
                                          string
                                          | Function,
                                      >
                                      | RegistryOption<Logic>;
                                  formats?: Property<any>;
                                  ignores?: Ignore;
                                  layouts?:
                                      | Extend<{ readonly [key: symbol]: string }, symbol, string>
                                      | RegistryOption<Pattern>;
                                  locales?: Record<
                                      string,
                                      Record<string, string | Function | Record<string, any>>,
                                  >;
                                  modifiers?: Record<string, string | string[] | readonly string[]>;
                                  numbers?: Record<string, number>;
                                  ordinals?: Record<string, number>;
                                  periods?:
                                      | Extend<
                                          {
                                              "after[ -]?noon": "3:00pm";
                                              evening: "18:00";
                                              "half[ -]?hour": (this: AliasContext) => string;
                                              "mid[ -]?day": "12:00";
                                              "mid[ -]?morning": "10:00";
                                              "mid[ -]?night": "24:00";
                                              morning: "8:00";
                                              night: "20:00";
                                              noon: "12:00";
                                          },
                                          string,
                                          string
                                          | Function,
                                      >
                                      | RegistryOption<Logic>;
                                  snippets?:
                                      | Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
                                      | RegistryOption<Pattern>;
                                  tokens?: Record<string, TokenEvaluator>;
                              }
                              +

                              custom data augmentation registries

                              +
                              +
                              +

                              Type Declaration

                              +
                                +
                              • +
                                Optionaldialects?: Record<string, any>
                                +

                                Dialect formatting/parsing engines

                                +
                                • +
                              • +
                                Optionalevents?:
                                    | Extend<
                                        {
                                            christmas: "25 Dec";
                                            "christmas ?eve": "24 Dec";
                                            fortnight: (this: AliasContext) => AliasContext;
                                            "new.?years? ?eve": "31 Dec";
                                            "new.?years?(?: ?day)?": "01 Jan";
                                            now: (this: AliasContext) => AliasContext;
                                            ny: "01 Jan";
                                            nye: "31 Dec";
                                            today: (this: AliasContext) => ZonedDateTime;
                                            tomorrow: (this: AliasContext) => AliasContext;
                                            xmas: "25 Dec";
                                            "xmas ?eve": "24 Dec";
                                            yesterday: (this: AliasContext) => AliasContext;
                                        },
                                        string,
                                        string
                                        | Function,
                                    >
                                    | RegistryOption<Logic>
                                +

                                Event registry for special dates

                                +
                                • +
                              • +
                                Optionalformats?: Property<any>
                                +

                                Format string templates

                                +
                                • +
                              • +
                                Optionalignores?: Ignore
                                +

                                Noise words to ignore during parsing

                                +
                                • +
                              • +
                                Optionallayouts?:
                                    | Extend<{ readonly [key: symbol]: string }, symbol, string>
                                    | RegistryOption<Pattern>
                                +

                                Layout registry for date/time patterns

                                +
                                • +
                              • +
                                Optionallocales?: Record<string, Record<string, string | Function | Record<string, any>>>
                                +

                                Locale-specific configurations

                                +
                                • +
                              • +
                                Optionalmodifiers?: Record<string, string | string[] | readonly string[]>
                                +

                                Temporal modifiers for relative dates

                                +
                                • +
                              • +
                                Optionalnumbers?: Record<string, number>
                                +

                                Number name mappings

                                +
                                • +
                              • +
                                Optionalordinals?: Record<string, number>
                                +

                                Ordinal name mappings

                                +
                                • +
                              • +
                                Optionalperiods?:
                                    | Extend<
                                        {
                                            "after[ -]?noon": "3:00pm";
                                            evening: "18:00";
                                            "half[ -]?hour": (this: AliasContext) => string;
                                            "mid[ -]?day": "12:00";
                                            "mid[ -]?morning": "10:00";
                                            "mid[ -]?night": "24:00";
                                            morning: "8:00";
                                            night: "20:00";
                                            noon: "12:00";
                                        },
                                        string,
                                        string
                                        | Function,
                                    >
                                    | RegistryOption<Logic>
                                +

                                Period registry for time-of-day aliases

                                +
                                • +
                              • +
                                Optionalsnippets?:
                                    | Extend<{ readonly [key: symbol]: RegExp }, symbol, RegExp>
                                    | RegistryOption<Pattern>
                                +

                                Snippet registry for parsing shortcuts

                                +
                                • +
                              • +
                                Optionaltokens?: Record<string, TokenEvaluator>
                                +

                                Token evaluators for custom parsing patterns

                                +
                              +
                              + +
                              silent?: boolean
                              +

                              suppress console output during catch

                              +
                              +
                              + +
                              sphere?: Evaluable<"north" | "south" | "east" | "west" | "equator" | undefined>
                              +

                              hemisphere for term.qtr or term.szn

                              +
                              +
                              + +
                              store?: string
                              +

                              localStorage key

                              +
                              +
                              + +
                              timestamp?: TimeStamp
                              +

                              Precision to measure timestamps alias

                              +
                              +
                              + +
                              timeStamp?: TimeStamp
                              +

                              Precision to measure timestamps (ms | us)

                              +
                              +
                              + +
                              timeZone?: Evaluable<TimeZoneLike>
                              +

                              Temporal timeZone

                              +
                              +
                              + +
                              value?: DateTime
                              +

                              supplied value to parse

                              +
                              +
                              +
                              +
                              +
                              +

                              Settings

                               +
                              +
                              Member Visibility +
                                +
                                • +
                                • +
                              +
                              +
                              +

                              On This Page

                               +
                              +
                              Properties +
                              +
                              + +
                              +
                              diff --git a/packages/tempo/public/v4/api/interfaces/Tempo.FormatOptions.html b/packages/tempo/public/v4/api/interfaces/Tempo.FormatOptions.html new file mode 100644 index 00000000..f08daa24 --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/Tempo.FormatOptions.html @@ -0,0 +1,235 @@ +FormatOptions | Tempo API
                              +
                              Tempo API + +
                                +
                                +
                                Preparing search index...
                                +
                                +
                                +
                                + +

                                Interface FormatOptions

                                +
                                +

                                Formatting options for date/time display

                                +
                                +
                                interface FormatOptions {
                                    calendar?: string;
                                    dateStyle?: "long" | "short" | "full" | "medium";
                                    day?: "numeric" | "2-digit";
                                    dayPeriod?: "long" | "short" | "narrow";
                                    dialect?: string;
                                    era?: "long" | "short" | "narrow";
                                    format?: string | readonly string[];
                                    formatMatcher?: "best fit" | "basic";
                                    fractionalSecondDigits?: 1 | 2 | 3;
                                    hour?: "numeric" | "2-digit";
                                    hour12?: boolean;
                                    hourCycle?: "h24" | "h12" | "h11" | "h23";
                                    locale?: string | readonly string[];
                                    localeMatcher?: "best fit" | "lookup";
                                    minute?: "numeric" | "2-digit";
                                    month?: "numeric" | "long" | "short" | "narrow" | "2-digit";
                                    numberingSystem?: string;
                                    second?: "numeric" | "2-digit";
                                    timeStyle?: "long" | "short" | "full" | "medium";
                                    timeZone?: string;
                                    timeZoneName?:
                                        | "long"
                                        | "short"
                                        | "shortOffset"
                                        | "longOffset"
                                        | "shortGeneric"
                                        | "longGeneric";
                                    weekday?: "long"
                                    | "short"
                                    | "narrow";
                                    year?: "numeric" | "2-digit";
                                }
                                +
                                +

                                Hierarchy

                                +
                                  +
                                • FormatOptions +
                                    +
                                  • FormatOptions
                                +
                                +
                                +
                                +
                                Index
                                 +
                                +
                                + +
                                calendar? +dateStyle? +day? +dayPeriod? +dialect? +era? +format? +formatMatcher? +fractionalSecondDigits? +hour? +hour12? +hourCycle? +locale? +localeMatcher? +minute? +month? +numberingSystem? +second? +timeStyle? +timeZone? +timeZoneName? +weekday? +year? +
                                +
                                + +
                                +
                                + +
                                calendar?: string
                                +

                                Calendar system for formatting

                                +
                                +
                                + +
                                dateStyle?: "long" | "short" | "full" | "medium"
                                +
                                + +
                                day?: "numeric" | "2-digit"
                                +
                                + +
                                dayPeriod?: "long" | "short" | "narrow"
                                +
                                + +
                                dialect?: string
                                +

                                Formatting dialect (e.g. 'ldml', 'strftime', 'moment')

                                +
                                +
                                + +
                                era?: "long" | "short" | "narrow"
                                +
                                + +
                                format?: string | readonly string[]
                                +

                                Format mask or array of format masks

                                +
                                +
                                + +
                                formatMatcher?: "best fit" | "basic"
                                +
                                + +
                                fractionalSecondDigits?: 1 | 2 | 3
                                +
                                + +
                                hour?: "numeric" | "2-digit"
                                +
                                + +
                                hour12?: boolean
                                +
                                + +
                                hourCycle?: "h24" | "h12" | "h11" | "h23"
                                +
                                + +
                                locale?: string | readonly string[]
                                +

                                Locale or array of locales for formatting

                                +
                                +
                                + +
                                localeMatcher?: "best fit" | "lookup"
                                +
                                + +
                                minute?: "numeric" | "2-digit"
                                +
                                + +
                                month?: "numeric" | "long" | "short" | "narrow" | "2-digit"
                                +
                                + +
                                numberingSystem?: string
                                +
                                + +
                                second?: "numeric" | "2-digit"
                                +
                                + +
                                timeStyle?: "long" | "short" | "full" | "medium"
                                +
                                + +
                                timeZone?: string
                                +

                                Timezone for formatting

                                +
                                +
                                + +
                                timeZoneName?:
                                    | "long"
                                    | "short"
                                    | "shortOffset"
                                    | "longOffset"
                                    | "shortGeneric"
                                    | "longGeneric"
                                +
                                + +
                                weekday?: "long" | "short" | "narrow"
                                +
                                + +
                                year?: "numeric" | "2-digit"
                                +
                                +
                                +
                                +
                                +

                                Settings

                                 +
                                +
                                Member Visibility +
                                  +
                                  • +
                                  • +
                                +
                                +
                                +

                                On This Page

                                 +
                                +
                                Properties +
                                +
                                + +
                                +
                                diff --git a/packages/tempo/public/v4/api/interfaces/Tempo.Params.html b/packages/tempo/public/v4/api/interfaces/Tempo.Params.html new file mode 100644 index 00000000..b3abc24d --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/Tempo.Params.html @@ -0,0 +1,70 @@ +Params | Tempo API
                                +
                                Tempo API + +
                                  +
                                  +
                                  Preparing search index...
                                  +
                                  +
                                  +
                                  + +

                                  Interface Params<T>

                                  +
                                  +

                                  Helper function signature for creating Tempo instances with flexible parameter order.

                                  +
                                  +
                                  +

                                  Type Parameters

                                  +
                                    +
                                  • T +

                                    Return type

                                    +
                                  +
                                  +

                                  Hierarchy

                                  +
                                    +
                                  • Params<T> +
                                      +
                                    • Params
                                  +
                                  +
                                    +
                                  • + +
                                    +
                                    +

                                    Parameters

                                    +
                                      +
                                    • Optionaltempo: DateTime
                                      • +
                                    • Optionaloptions: Options
                                    +

                                    Returns T

                                    • +
                                  • + +
                                    +
                                    +

                                    Parameters

                                    +
                                      +
                                    • options: Options
                                    +

                                    Returns T

                                  +
                                  +
                                  +
                                  +
                                  +

                                  Settings

                                   +
                                  +
                                  Member Visibility +
                                    +
                                    • +
                                    • +
                                  +
                                  +
                                  + +
                                  +
                                  diff --git a/packages/tempo/public/v4/api/interfaces/TempoTermRegistry.html b/packages/tempo/public/v4/api/interfaces/TempoTermRegistry.html new file mode 100644 index 00000000..8500c476 --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/TempoTermRegistry.html @@ -0,0 +1,41 @@ +TempoTermRegistry | Tempo API
                                  +
                                  Tempo API + +
                                    +
                                    +
                                    Preparing search index...
                                    +
                                    +
                                    +
                                    + +

                                    Interface TempoTermRegistry

                                    +
                                    +

                                    Keyed lookup surface for resolved term values returned by Tempo.term.

                                    +
                                    +
                                    +

                                    Indexable

                                    +
                                      +
                                    • +
                                      [key: string]: any
                                    +
                                    +
                                    +
                                    +
                                    +

                                    Settings

                                     +
                                    +
                                    Member Visibility +
                                      +
                                      • +
                                      • +
                                    +
                                    +
                                    + +
                                    +
                                    diff --git a/packages/tempo/public/v4/api/interfaces/TermLifecycleHooks.html b/packages/tempo/public/v4/api/interfaces/TermLifecycleHooks.html new file mode 100644 index 00000000..7c5a7640 --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/TermLifecycleHooks.html @@ -0,0 +1,47 @@ +TermLifecycleHooks | Tempo API
                                    +
                                    Tempo API + +
                                      +
                                      +
                                      Preparing search index...
                                      +
                                      +
                                      +
                                      + +

                                      Interface TermLifecycleHooks

                                      +
                                      +

                                      Protocol contract for Term Plugins implementing lifecycle hooks.

                                      +
                                      +
                                      +

                                      Hierarchy (View Summary)

                                      +
                                      +
                                      +

                                      Indexable

                                      +
                                        +
                                      • +
                                        [key: symbol]:
                                            | (
                                                (
                                                    input: string,
                                                    context?: TermParseContext,
                                                ) => ZonedDateTime | Tempo | undefined
                                            )
                                            | (
                                                (
                                                    groups: Record<string, any>,
                                                    anchor: Tempo,
                                                    context?: TermParseContext,
                                                ) => ZonedDateTime | Tempo | undefined
                                            )
                                            | (
                                                (
                                                    unit: string,
                                                    count: number,
                                                    tempo: Tempo,
                                                ) => ZonedDateTime | Tempo | undefined
                                            )
                                            | ((other: Tempo, unit: string, tempo: Tempo) => number | undefined)
                                            | (
                                                (
                                                    boundary: "start" | "mid" | "end",
                                                    unit: string,
                                                    tempo: Tempo,
                                                ) => ZonedDateTime | Tempo | undefined
                                            )
                                            | ((token: string, tempo: Tempo) => string | undefined)
                                            | undefined
                                      +
                                      +
                                      +
                                      +
                                      +

                                      Settings

                                       +
                                      +
                                      Member Visibility +
                                        +
                                        • +
                                        • +
                                      +
                                      +
                                      + +
                                      +
                                      diff --git a/packages/tempo/public/v4/api/interfaces/TermParseContext.html b/packages/tempo/public/v4/api/interfaces/TermParseContext.html new file mode 100644 index 00000000..84e5cb50 --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/TermParseContext.html @@ -0,0 +1,82 @@ +TermParseContext | Tempo API
                                      +
                                      Tempo API + +
                                        +
                                        +
                                        Preparing search index...
                                        +
                                        +
                                        +
                                        + +

                                        Interface TermParseContext

                                        +
                                        +

                                        Context provided during onTermParse hook evaluation.

                                        +
                                        +
                                        interface TermParseContext {
                                            anchor?: Tempo;
                                            calendar?: string;
                                            locale?: string;
                                            timeZone?: string;
                                            [key: string]: any;
                                        }
                                        +
                                        +

                                        Indexable

                                        +
                                          +
                                        • +
                                          [key: string]: any
                                        +
                                        +
                                        +
                                        +
                                        Index
                                         +
                                        +
                                        + +
                                        anchor? +calendar? +locale? +timeZone? +
                                        +
                                        + +
                                        +
                                        + +
                                        anchor?: Tempo
                                        +
                                        + +
                                        calendar?: string
                                        +
                                        + +
                                        locale?: string
                                        +
                                        + +
                                        timeZone?: string
                                        +
                                        +
                                        +
                                        +
                                        +

                                        Settings

                                         +
                                        +
                                        Member Visibility +
                                          +
                                          • +
                                          • +
                                        +
                                        +
                                        +

                                        On This Page

                                         +
                                        +
                                        Properties +
                                        +
                                        + +
                                        +
                                        diff --git a/packages/tempo/public/v4/api/interfaces/TermPlugin.html b/packages/tempo/public/v4/api/interfaces/TermPlugin.html new file mode 100644 index 00000000..f8d9d59c --- /dev/null +++ b/packages/tempo/public/v4/api/interfaces/TermPlugin.html @@ -0,0 +1,155 @@ +TermPlugin | Tempo API
                                        +
                                        Tempo API + +
                                          +
                                          +
                                          Preparing search index...
                                          +
                                          +
                                          +
                                          + +

                                          Interface TermPlugin

                                          +
                                          +
                                          +

                                          Interface for term-driven parsing and resolution.

                                          +
                                          +
                                          interface TermPlugin {
                                              aliases?: string[] | readonly string[];
                                              define: (
                                                  this: Tempo,
                                                  keyOnly?: boolean,
                                                  anchor?: any,
                                                  alias?: string,
                                              ) => string | Range | readonly Range[] | Range[] | null | undefined;
                                              description?: string;
                                              groups?: any;
                                              key: string;
                                              locale?: Record<string, string | Function>;
                                              options?: any;
                                              ranges?: any[] | readonly any[];
                                              resolve?: (
                                                  this: Tempo,
                                                  anchor?: any,
                                                  alias?: string,
                                              ) => readonly Range[] | Range[];
                                              scope?: string;
                                              version?: string;
                                              [key: string]: any;
                                              [key: symbol]:
                                                  | (
                                                      (
                                                          input: string,
                                                          context?: TermParseContext,
                                                      ) => ZonedDateTime | Tempo | undefined
                                                  )
                                                  | (
                                                      (
                                                          groups: Record<string, any>,
                                                          anchor: Tempo,
                                                          context?: TermParseContext,
                                                      ) => ZonedDateTime | Tempo | undefined
                                                  )
                                                  | (
                                                      (
                                                          unit: string,
                                                          count: number,
                                                          tempo: Tempo,
                                                      ) => ZonedDateTime | Tempo | undefined
                                                  )
                                                  | ((other: Tempo, unit: string, tempo: Tempo) => number | undefined)
                                                  | (
                                                      (
                                                          boundary: "start" | "mid" | "end",
                                                          unit: string,
                                                          tempo: Tempo,
                                                      ) => ZonedDateTime | Tempo | undefined
                                                  )
                                                  | ((token: string, tempo: Tempo) => string | undefined)
                                                  | undefined;
                                          }
                                          +
                                          +

                                          Hierarchy (View Summary)

                                          +
                                          +
                                          +

                                          Indexable

                                          +
                                            +
                                          • +
                                            [key: string]: any
                                            • +
                                          • +
                                            [key: symbol]:
                                                | (
                                                    (
                                                        input: string,
                                                        context?: TermParseContext,
                                                    ) => ZonedDateTime | Tempo | undefined
                                                )
                                                | (
                                                    (
                                                        groups: Record<string, any>,
                                                        anchor: Tempo,
                                                        context?: TermParseContext,
                                                    ) => ZonedDateTime | Tempo | undefined
                                                )
                                                | (
                                                    (
                                                        unit: string,
                                                        count: number,
                                                        tempo: Tempo,
                                                    ) => ZonedDateTime | Tempo | undefined
                                                )
                                                | ((other: Tempo, unit: string, tempo: Tempo) => number | undefined)
                                                | (
                                                    (
                                                        boundary: "start" | "mid" | "end",
                                                        unit: string,
                                                        tempo: Tempo,
                                                    ) => ZonedDateTime | Tempo | undefined
                                                )
                                                | ((token: string, tempo: Tempo) => string | undefined)
                                                | undefined
                                          +
                                          +
                                          +
                                          +
                                          Index
                                           +
                                          +
                                          + +
                                          aliases? +define +description? +groups? +key +locale? +options? +ranges? +resolve? +scope? +version? +
                                          +
                                          + +
                                          +
                                          + +
                                          aliases?: string[] | readonly string[]
                                          +

                                          Optional secondary alias keys for the term

                                          +
                                          +
                                          + +
                                          define: (
                                              this: Tempo,
                                              keyOnly?: boolean,
                                              anchor?: any,
                                              alias?: string,
                                          ) => string | Range | readonly Range[] | Range[] | null | undefined
                                          +

                                          Defines the term's value or range

                                          +
                                          +
                                          + +
                                          description?: string
                                          +

                                          Human-readable description of the term

                                          +
                                          +
                                          + +
                                          groups?: any
                                          +

                                          Grouping information for the term

                                          +
                                          +
                                          + +
                                          key: string
                                          +

                                          Unique identifier for the term

                                          +
                                          +
                                          + +
                                          locale?: Record<string, string | Function>
                                          +

                                          Locale-specific term translations

                                          +
                                          +
                                          + +
                                          options?: any
                                          +

                                          Colocated or runtime configuration options

                                          +
                                          +
                                          + +
                                          ranges?: any[] | readonly any[]
                                          +

                                          Array of time ranges this term represents

                                          +
                                          +
                                          + +
                                          resolve?: (
                                              this: Tempo,
                                              anchor?: any,
                                              alias?: string,
                                          ) => readonly Range[] | Range[]
                                          +

                                          Resolves the term to concrete time ranges

                                          +
                                          +
                                          + +
                                          scope?: string
                                          +

                                          Scope or category of the term

                                          +
                                          +
                                          + +
                                          version?: string
                                          +

                                          Version of the term plugin

                                          +
                                          +
                                          +
                                          +
                                          +
                                          +

                                          Settings

                                           +
                                          +
                                          Member Visibility +
                                            +
                                            • +
                                            • +
                                          +
                                          +
                                          +

                                          On This Page

                                           +
                                          TermPlugin +
                                          Properties +
                                          +
                                          + +
                                          +
                                          diff --git a/packages/tempo/public/v4/api/library/.nojekyll b/packages/tempo/public/v4/api/library/.nojekyll new file mode 100644 index 00000000..e2ac6616 --- /dev/null +++ b/packages/tempo/public/v4/api/library/.nojekyll @@ -0,0 +1 @@ +TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false. \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/hierarchy.js b/packages/tempo/public/v4/api/library/assets/hierarchy.js new file mode 100644 index 00000000..73005522 --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/hierarchy.js @@ -0,0 +1 @@ +window.hierarchyData = "eJydkbFqwzAQht/lnxW3cWOTaCseWgpd2iFD8CCscyIq34GkhkLQuwctJpQOcaeDO767j/svCCIpQh+eHutWrbebtlcINHoakhOO0BeUbqlsJoLG2/7zlYylAIUvxxa6blqF7+Ch4ThRGM1A8WGQaRKuHFv6qWaoOqXJQ2HwJkZopGhXZctqJsvw5LwNxNCH9bap+6xQ6i+J9+fufyIzeIdMVqh3u+bm9AdF8WeynUiwjk2iuETgD/w+jZLQjcYLSSc8uuOS4zO0NIbygz7nfAVCMLmo" \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/highlight.css b/packages/tempo/public/v4/api/library/assets/highlight.css new file mode 100644 index 00000000..18148acb --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/highlight.css @@ -0,0 +1,106 @@ +:root { + --light-hl-0: #AF00DB; + --dark-hl-0: #C586C0; + --light-hl-1: #000000; + --dark-hl-1: #D4D4D4; + --light-hl-2: #001080; + --dark-hl-2: #9CDCFE; + --light-hl-3: #A31515; + --dark-hl-3: #CE9178; + --light-hl-4: #795E26; + --dark-hl-4: #DCDCAA; + --light-hl-5: #008000; + --dark-hl-5: #6A9955; + --light-hl-6: #0000FF; + --dark-hl-6: #569CD6; + --light-hl-7: #098658; + --dark-hl-7: #B5CEA8; + --light-hl-8: #0070C1; + --dark-hl-8: #4FC1FF; + --light-hl-9: #811F3F; + --dark-hl-9: #D16969; + --light-hl-10: #267F99; + --dark-hl-10: #4EC9B0; + --light-hl-11: #EE0000; + --dark-hl-11: #D7BA7D; + --light-code-background: #FFFFFF; + --dark-code-background: #1E1E1E; +} + +@media (prefers-color-scheme: light) { :root { + --hl-0: var(--light-hl-0); + --hl-1: var(--light-hl-1); + --hl-2: var(--light-hl-2); + --hl-3: var(--light-hl-3); + --hl-4: var(--light-hl-4); + --hl-5: var(--light-hl-5); + --hl-6: var(--light-hl-6); + --hl-7: var(--light-hl-7); + --hl-8: var(--light-hl-8); + --hl-9: var(--light-hl-9); + --hl-10: var(--light-hl-10); + --hl-11: var(--light-hl-11); + --code-background: var(--light-code-background); +} } + +@media (prefers-color-scheme: dark) { :root { + --hl-0: var(--dark-hl-0); + --hl-1: var(--dark-hl-1); + --hl-2: var(--dark-hl-2); + --hl-3: var(--dark-hl-3); + --hl-4: var(--dark-hl-4); + --hl-5: var(--dark-hl-5); + --hl-6: var(--dark-hl-6); + --hl-7: var(--dark-hl-7); + --hl-8: var(--dark-hl-8); + --hl-9: var(--dark-hl-9); + --hl-10: var(--dark-hl-10); + --hl-11: var(--dark-hl-11); + --code-background: var(--dark-code-background); +} } + +:root[data-theme='light'] { + --hl-0: var(--light-hl-0); + --hl-1: var(--light-hl-1); + --hl-2: var(--light-hl-2); + --hl-3: var(--light-hl-3); + --hl-4: var(--light-hl-4); + --hl-5: var(--light-hl-5); + --hl-6: var(--light-hl-6); + --hl-7: var(--light-hl-7); + --hl-8: var(--light-hl-8); + --hl-9: var(--light-hl-9); + --hl-10: var(--light-hl-10); + --hl-11: var(--light-hl-11); + --code-background: var(--light-code-background); +} + +:root[data-theme='dark'] { + --hl-0: var(--dark-hl-0); + --hl-1: var(--dark-hl-1); + --hl-2: var(--dark-hl-2); + --hl-3: var(--dark-hl-3); + --hl-4: var(--dark-hl-4); + --hl-5: var(--dark-hl-5); + --hl-6: var(--dark-hl-6); + --hl-7: var(--dark-hl-7); + --hl-8: var(--dark-hl-8); + --hl-9: var(--dark-hl-9); + --hl-10: var(--dark-hl-10); + --hl-11: var(--dark-hl-11); + --code-background: var(--dark-code-background); +} + +.hl-0 { color: var(--hl-0); } +.hl-1 { color: var(--hl-1); } +.hl-2 { color: var(--hl-2); } +.hl-3 { color: var(--hl-3); } +.hl-4 { color: var(--hl-4); } +.hl-5 { color: var(--hl-5); } +.hl-6 { color: var(--hl-6); } +.hl-7 { color: var(--hl-7); } +.hl-8 { color: var(--hl-8); } +.hl-9 { color: var(--hl-9); } +.hl-10 { color: var(--hl-10); } +.hl-11 { color: var(--hl-11); } +pre, code, math[display='block'] { background: var(--code-background); } diff --git a/packages/tempo/public/v4/api/library/assets/icons.js b/packages/tempo/public/v4/api/library/assets/icons.js new file mode 100644 index 00000000..4fbadc5a --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/icons.js @@ -0,0 +1,18 @@ +(function() { + addIcons(); + function addIcons() { + if (document.readyState === "loading") return document.addEventListener("DOMContentLoaded", addIcons); + const svg = document.body.appendChild(document.createElementNS("http://www.w3.org/2000/svg", "svg")); + svg.innerHTML = `MMNEPVFCICPMFPCPTTAAATR`; + svg.style.display = "none"; + if (location.protocol === "file:") updateUseElements(); + } + + function updateUseElements() { + document.querySelectorAll("use").forEach(el => { + if (el.getAttribute("href").includes("#icon-")) { + el.setAttribute("href", el.getAttribute("href").replace(/.*#/, "#")); + } + }); + } +})() \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/icons.svg b/packages/tempo/public/v4/api/library/assets/icons.svg new file mode 100644 index 00000000..be7798fc --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/icons.svg @@ -0,0 +1 @@ +MMNEPVFCICPMFPCPTTAAATR \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/main.js b/packages/tempo/public/v4/api/library/assets/main.js new file mode 100644 index 00000000..b0eda9ed --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/main.js @@ -0,0 +1,60 @@ +"use strict"; +window.translations={"copy":"Copy","copied":"Copied!","normally_hidden":"This member is normally hidden due to your filter settings.","hierarchy_expand":"Expand","hierarchy_collapse":"Collapse","folder":"Folder","search_index_not_available":"The search index is not available","search_no_results_found_for_0":"No results found for {0}","kind_1":"Project","kind_2":"Module","kind_4":"Namespace","kind_8":"Enumeration","kind_16":"Enumeration Member","kind_32":"Variable","kind_64":"Function","kind_128":"Class","kind_256":"Interface","kind_512":"Constructor","kind_1024":"Property","kind_2048":"Method","kind_4096":"Call Signature","kind_8192":"Index Signature","kind_16384":"Constructor Signature","kind_32768":"Parameter","kind_65536":"Type Literal","kind_131072":"Type Parameter","kind_262144":"Accessor","kind_524288":"Get Signature","kind_1048576":"Set Signature","kind_2097152":"Type Alias","kind_4194304":"Reference","kind_8388608":"Document"}; +(()=>{var Ke=Object.create;var he=Object.defineProperty;var Ge=Object.getOwnPropertyDescriptor;var Ze=Object.getOwnPropertyNames;var Xe=Object.getPrototypeOf,Ye=Object.prototype.hasOwnProperty;var et=(t,e)=>()=>{try{return e||t((e={exports:{}}).exports,e),e.exports}catch(n){throw e=0,n}};var tt=(t,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of Ze(e))!Ye.call(t,i)&&i!==n&&he(t,i,{get:()=>e[i],enumerable:!(r=Ge(e,i))||r.enumerable});return t};var nt=(t,e,n)=>(n=t!=null?Ke(Xe(t)):{},tt(e||!t||!t.__esModule?he(n,"default",{value:t,enumerable:!0}):n,t));var ye=et((me,ge)=>{(function(){var t=function(e){var n=new t.Builder;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),n.searchPipeline.add(t.stemmer),e.call(n,n),n.build()};t.version="2.3.9";t.utils={},t.utils.warn=(function(e){return function(n){e.console&&console.warn&&console.warn(n)}})(this),t.utils.asString=function(e){return e==null?"":e.toString()},t.utils.clone=function(e){if(e==null)return e;for(var n=Object.create(null),r=Object.keys(e),i=0;i0){var d=t.utils.clone(n)||{};d.position=[a,l],d.index=s.length,s.push(new t.Token(r.slice(a,o),d))}a=o+1}}return s},t.tokenizer.separator=/[\s\-]+/;t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions=Object.create(null),t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn(`Function is not registered with pipeline. This may cause problems when serialising the index. +`,e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(r){var i=t.Pipeline.registeredFunctions[r];if(i)n.add(i);else throw new Error("Cannot load unregistered function: "+r)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(n){t.Pipeline.warnIfFunctionNotRegistered(n),this._stack.push(n)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");r=r+1,this._stack.splice(r,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var r=this._stack.indexOf(e);if(r==-1)throw new Error("Cannot find existingFn");this._stack.splice(r,0,n)},t.Pipeline.prototype.remove=function(e){var n=this._stack.indexOf(e);n!=-1&&this._stack.splice(n,1)},t.Pipeline.prototype.run=function(e){for(var n=this._stack.length,r=0;r1&&(oe&&(r=s),o!=e);)i=r-n,s=n+Math.floor(i/2),o=this.elements[s*2];if(o==e||o>e)return s*2;if(oc?d+=2:a==c&&(n+=r[l+1]*i[d+1],l+=2,d+=2);return n},t.Vector.prototype.similarity=function(e){return this.dot(e)/this.magnitude()||0},t.Vector.prototype.toArray=function(){for(var e=new Array(this.elements.length/2),n=1,r=0;n0){var o=s.str.charAt(0),a;o in s.node.edges?a=s.node.edges[o]:(a=new t.TokenSet,s.node.edges[o]=a),s.str.length==1&&(a.final=!0),i.push({node:a,editsRemaining:s.editsRemaining,str:s.str.slice(1)})}if(s.editsRemaining!=0){if("*"in s.node.edges)var c=s.node.edges["*"];else{var c=new t.TokenSet;s.node.edges["*"]=c}if(s.str.length==0&&(c.final=!0),i.push({node:c,editsRemaining:s.editsRemaining-1,str:s.str}),s.str.length>1&&i.push({node:s.node,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)}),s.str.length==1&&(s.node.final=!0),s.str.length>=1){if("*"in s.node.edges)var l=s.node.edges["*"];else{var l=new t.TokenSet;s.node.edges["*"]=l}s.str.length==1&&(l.final=!0),i.push({node:l,editsRemaining:s.editsRemaining-1,str:s.str.slice(1)})}if(s.str.length>1){var d=s.str.charAt(0),f=s.str.charAt(1),p;f in s.node.edges?p=s.node.edges[f]:(p=new t.TokenSet,s.node.edges[f]=p),s.str.length==1&&(p.final=!0),i.push({node:p,editsRemaining:s.editsRemaining-1,str:d+s.str.slice(2)})}}}return r},t.TokenSet.fromString=function(e){for(var n=new t.TokenSet,r=n,i=0,s=e.length;i=e;n--){var r=this.uncheckedNodes[n],i=r.child.toString();i in this.minimizedNodes?r.parent.edges[r.char]=this.minimizedNodes[i]:(r.child._str=i,this.minimizedNodes[i]=r.child),this.uncheckedNodes.pop()}};t.Index=function(e){this.invertedIndex=e.invertedIndex,this.fieldVectors=e.fieldVectors,this.tokenSet=e.tokenSet,this.fields=e.fields,this.pipeline=e.pipeline},t.Index.prototype.search=function(e){return this.query(function(n){var r=new t.QueryParser(e,n);r.parse()})},t.Index.prototype.query=function(e){for(var n=new t.Query(this.fields),r=Object.create(null),i=Object.create(null),s=Object.create(null),o=Object.create(null),a=Object.create(null),c=0;c1?this._b=1:this._b=e},t.Builder.prototype.k1=function(e){this._k1=e},t.Builder.prototype.add=function(e,n){var r=e[this._ref],i=Object.keys(this._fields);this._documents[r]=n||{},this.documentCount+=1;for(var s=0;s=this.length)return t.QueryLexer.EOS;var e=this.str.charAt(this.pos);return this.pos+=1,e},t.QueryLexer.prototype.width=function(){return this.pos-this.start},t.QueryLexer.prototype.ignore=function(){this.start==this.pos&&(this.pos+=1),this.start=this.pos},t.QueryLexer.prototype.backup=function(){this.pos-=1},t.QueryLexer.prototype.acceptDigitRun=function(){var e,n;do e=this.next(),n=e.charCodeAt(0);while(n>47&&n<58);e!=t.QueryLexer.EOS&&this.backup()},t.QueryLexer.prototype.more=function(){return this.pos1&&(e.backup(),e.emit(t.QueryLexer.TERM)),e.ignore(),e.more())return t.QueryLexer.lexText},t.QueryLexer.lexEditDistance=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.EDIT_DISTANCE),t.QueryLexer.lexText},t.QueryLexer.lexBoost=function(e){return e.ignore(),e.acceptDigitRun(),e.emit(t.QueryLexer.BOOST),t.QueryLexer.lexText},t.QueryLexer.lexEOS=function(e){e.width()>0&&e.emit(t.QueryLexer.TERM)},t.QueryLexer.termSeparator=t.tokenizer.separator,t.QueryLexer.lexText=function(e){for(;;){var n=e.next();if(n==t.QueryLexer.EOS)return t.QueryLexer.lexEOS;if(n.charCodeAt(0)==92){e.escapeCharacter();continue}if(n==":")return t.QueryLexer.lexField;if(n=="~")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexEditDistance;if(n=="^")return e.backup(),e.width()>0&&e.emit(t.QueryLexer.TERM),t.QueryLexer.lexBoost;if(n=="+"&&e.width()===1||n=="-"&&e.width()===1)return e.emit(t.QueryLexer.PRESENCE),t.QueryLexer.lexText;if(n.match(t.QueryLexer.termSeparator))return t.QueryLexer.lexTerm}},t.QueryParser=function(e,n){this.lexer=new t.QueryLexer(e),this.query=n,this.currentClause={},this.lexemeIdx=0},t.QueryParser.prototype.parse=function(){this.lexer.run(),this.lexemes=this.lexer.lexemes;for(var e=t.QueryParser.parseClause;e;)e=e(this);return this.query},t.QueryParser.prototype.peekLexeme=function(){return this.lexemes[this.lexemeIdx]},t.QueryParser.prototype.consumeLexeme=function(){var e=this.peekLexeme();return this.lexemeIdx+=1,e},t.QueryParser.prototype.nextClause=function(){var e=this.currentClause;this.query.clause(e),this.currentClause={}},t.QueryParser.parseClause=function(e){var n=e.peekLexeme();if(n!=null)switch(n.type){case t.QueryLexer.PRESENCE:return t.QueryParser.parsePresence;case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expected either a field or a term, found "+n.type;throw n.str.length>=1&&(r+=" with value '"+n.str+"'"),new t.QueryParseError(r,n.start,n.end)}},t.QueryParser.parsePresence=function(e){var n=e.consumeLexeme();if(n!=null){switch(n.str){case"-":e.currentClause.presence=t.Query.presence.PROHIBITED;break;case"+":e.currentClause.presence=t.Query.presence.REQUIRED;break;default:var r="unrecognised presence operator'"+n.str+"'";throw new t.QueryParseError(r,n.start,n.end)}var i=e.peekLexeme();if(i==null){var r="expecting term or field, found nothing";throw new t.QueryParseError(r,n.start,n.end)}switch(i.type){case t.QueryLexer.FIELD:return t.QueryParser.parseField;case t.QueryLexer.TERM:return t.QueryParser.parseTerm;default:var r="expecting term or field, found '"+i.type+"'";throw new t.QueryParseError(r,i.start,i.end)}}},t.QueryParser.parseField=function(e){var n=e.consumeLexeme();if(n!=null){if(e.query.allFields.indexOf(n.str)==-1){var r=e.query.allFields.map(function(o){return"'"+o+"'"}).join(", "),i="unrecognised field '"+n.str+"', possible fields: "+r;throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.fields=[n.str];var s=e.peekLexeme();if(s==null){var i="expecting term, found nothing";throw new t.QueryParseError(i,n.start,n.end)}if(s.type===t.QueryLexer.TERM)return t.QueryParser.parseTerm;var i="expecting term, found '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}},t.QueryParser.parseTerm=function(e){var n=e.consumeLexeme();if(n!=null){e.currentClause.term=n.str.toLowerCase(),n.str.indexOf("*")!=-1&&(e.currentClause.usePipeline=!1);var r=e.peekLexeme();if(r==null){e.nextClause();return}switch(r.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+r.type+"'";throw new t.QueryParseError(i,r.start,r.end)}}},t.QueryParser.parseEditDistance=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="edit distance must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.editDistance=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},t.QueryParser.parseBoost=function(e){var n=e.consumeLexeme();if(n!=null){var r=parseInt(n.str,10);if(isNaN(r)){var i="boost must be numeric";throw new t.QueryParseError(i,n.start,n.end)}e.currentClause.boost=r;var s=e.peekLexeme();if(s==null){e.nextClause();return}switch(s.type){case t.QueryLexer.TERM:return e.nextClause(),t.QueryParser.parseTerm;case t.QueryLexer.FIELD:return e.nextClause(),t.QueryParser.parseField;case t.QueryLexer.EDIT_DISTANCE:return t.QueryParser.parseEditDistance;case t.QueryLexer.BOOST:return t.QueryParser.parseBoost;case t.QueryLexer.PRESENCE:return e.nextClause(),t.QueryParser.parsePresence;default:var i="Unexpected lexeme type '"+s.type+"'";throw new t.QueryParseError(i,s.start,s.end)}}},(function(e,n){typeof define=="function"&&define.amd?define(n):typeof me=="object"?ge.exports=n():e.lunr=n()})(this,function(){return t})})()});var M,G={getItem(){return null},setItem(){}},K;try{K=localStorage,M=K}catch{K=G,M=G}var S={getItem:t=>M.getItem(t),setItem:(t,e)=>M.setItem(t,e),disableWritingLocalStorage(){M=G},disable(){localStorage.clear(),M=G},enable(){M=K}};window.TypeDoc||={disableWritingLocalStorage(){S.disableWritingLocalStorage()},disableLocalStorage:()=>{S.disable()},enableLocalStorage:()=>{S.enable()}};window.translations||={copy:"Copy",copied:"Copied!",normally_hidden:"This member is normally hidden due to your filter settings.",hierarchy_expand:"Expand",hierarchy_collapse:"Collapse",search_index_not_available:"The search index is not available",search_no_results_found_for_0:"No results found for {0}",folder:"Folder",kind_1:"Project",kind_2:"Module",kind_4:"Namespace",kind_8:"Enumeration",kind_16:"Enumeration Member",kind_32:"Variable",kind_64:"Function",kind_128:"Class",kind_256:"Interface",kind_512:"Constructor",kind_1024:"Property",kind_2048:"Method",kind_4096:"Call Signature",kind_8192:"Index Signature",kind_16384:"Constructor Signature",kind_32768:"Parameter",kind_65536:"Type Literal",kind_131072:"Type Parameter",kind_262144:"Accessor",kind_524288:"Get Signature",kind_1048576:"Set Signature",kind_2097152:"Type Alias",kind_4194304:"Reference",kind_8388608:"Document"};var pe=[];function X(t,e){pe.push({selector:e,constructor:t})}var Z=class{alwaysVisibleMember=null;constructor(){this.createComponents(document.body),this.ensureFocusedElementVisible(),this.listenForCodeCopies(),window.addEventListener("hashchange",()=>this.ensureFocusedElementVisible()),document.body.style.display||(this.ensureFocusedElementVisible(),this.updateIndexVisibility(),this.scrollToHash())}createComponents(e){pe.forEach(n=>{e.querySelectorAll(n.selector).forEach(r=>{r.dataset.hasInstance||(new n.constructor({el:r,app:this}),r.dataset.hasInstance=String(!0))})})}filterChanged(){this.ensureFocusedElementVisible()}showPage(){document.body.style.display&&(document.body.style.removeProperty("display"),this.ensureFocusedElementVisible(),this.updateIndexVisibility(),this.scrollToHash())}scrollToHash(){if(location.hash){let e=document.getElementById(location.hash.substring(1));if(!e)return;e.scrollIntoView({behavior:"instant",block:"start"})}}ensureActivePageVisible(){let e=document.querySelector(".tsd-navigation .current"),n=e?.parentElement;for(;n&&!n.classList.contains(".tsd-navigation");)n instanceof HTMLDetailsElement&&(n.open=!0),n=n.parentElement;if(e&&!rt(e)){let r=e.getBoundingClientRect().top-document.documentElement.clientHeight/4;document.querySelector(".site-menu").scrollTop=r,document.querySelector(".col-sidebar").scrollTop=r}}updateIndexVisibility(){let e=document.querySelector(".tsd-index-content"),n=e?.open;e&&(e.open=!0),document.querySelectorAll(".tsd-index-section").forEach(r=>{r.style.display="block";let i=Array.from(r.querySelectorAll(".tsd-index-link")).every(s=>s.offsetParent==null);r.style.display=i?"none":"block"}),e&&(e.open=n)}ensureFocusedElementVisible(){if(this.alwaysVisibleMember&&(this.alwaysVisibleMember.classList.remove("always-visible"),this.alwaysVisibleMember.firstElementChild.remove(),this.alwaysVisibleMember=null),!location.hash)return;let e=document.getElementById(location.hash.substring(1));if(!e)return;let n=e.parentElement;for(;n&&n.tagName!=="SECTION";)n=n.parentElement;if(!n)return;let r=n.offsetParent==null,i=n;for(;i!==document.body;)i instanceof HTMLDetailsElement&&(i.open=!0),i=i.parentElement;if(n.offsetParent==null){this.alwaysVisibleMember=n,n.classList.add("always-visible");let s=document.createElement("p");s.classList.add("warning"),s.textContent=window.translations.normally_hidden,n.prepend(s)}r&&e.scrollIntoView()}listenForCodeCopies(){document.querySelectorAll("pre > button").forEach(e=>{let n;e.addEventListener("click",()=>{e.previousElementSibling instanceof HTMLElement&&navigator.clipboard.writeText(e.previousElementSibling.innerText.trim()),e.textContent=window.translations.copied,e.classList.add("visible"),clearTimeout(n),n=setTimeout(()=>{e.classList.remove("visible"),n=setTimeout(()=>{e.textContent=window.translations.copy},100)},1e3)})})}};function rt(t){let e=t.getBoundingClientRect(),n=Math.max(document.documentElement.clientHeight,window.innerHeight);return!(e.bottom<0||e.top-n>=0)}var fe=(t,e=100)=>{let n;return()=>{clearTimeout(n),n=setTimeout(()=>t(),e)}};var Ie=nt(ye(),1);async function R(t){let e=Uint8Array.from(atob(t),s=>s.charCodeAt(0)),r=new Blob([e]).stream().pipeThrough(new DecompressionStream("deflate")),i=await new Response(r).text();return JSON.parse(i)}var Y="closing",ae="tsd-overlay";function it(){let t=Math.abs(window.innerWidth-document.documentElement.clientWidth);document.body.style.overflow="hidden",document.body.style.paddingRight=`${t}px`}function st(){document.body.style.removeProperty("overflow"),document.body.style.removeProperty("padding-right")}function Ee(t,e){t.addEventListener("animationend",()=>{t.classList.contains(Y)&&(t.classList.remove(Y),document.getElementById(ae)?.remove(),t.close(),st())}),t.addEventListener("cancel",n=>{n.preventDefault(),ve(t)}),e?.closeOnClick&&document.addEventListener("click",n=>{t.open&&!t.contains(n.target)&&ve(t)},!0)}function xe(t){if(t.open)return;let e=document.createElement("div");e.id=ae,document.body.appendChild(e),t.showModal(),it()}function ve(t){if(!t.open)return;document.getElementById(ae)?.classList.add(Y),t.classList.add(Y)}var I=class{el;app;constructor(e){this.el=e.el,this.app=e.app}};var be=document.head.appendChild(document.createElement("style"));be.dataset.for="filters";var le={};function Le(t){for(let e of t.split(/\s+/))if(le.hasOwnProperty(e)&&!le[e])return!0;return!1}var ee=class extends I{key;value;constructor(e){super(e),this.key=`filter-${this.el.name}`,this.value=this.el.checked,this.el.addEventListener("change",()=>{this.setLocalStorage(this.el.checked)}),this.setLocalStorage(this.fromLocalStorage()),be.innerHTML+=`html:not(.${this.key}) .tsd-is-${this.el.name} { display: none; } +`,this.app.updateIndexVisibility()}fromLocalStorage(){let e=S.getItem(this.key);return e?e==="true":this.el.checked}setLocalStorage(e){S.setItem(this.key,e.toString()),this.value=e,this.handleValueChange()}handleValueChange(){this.el.checked=this.value,document.documentElement.classList.toggle(this.key,this.value),le[`tsd-is-${this.el.name}`]=this.value,this.app.filterChanged(),this.app.updateIndexVisibility()}};var we=0;async function Se(t,e){if(!window.searchData)return;let n=await R(window.searchData);t.data=n,t.index=Ie.Index.load(n.index),e.innerHTML=""}function _e(){let t=document.getElementById("tsd-search-trigger"),e=document.getElementById("tsd-search"),n=document.getElementById("tsd-search-input"),r=document.getElementById("tsd-search-results"),i=document.getElementById("tsd-search-script"),s=document.getElementById("tsd-search-status");if(!(t&&e&&n&&r&&i&&s))throw new Error("Search controls missing");let o={base:document.documentElement.dataset.base};o.base.endsWith("/")||(o.base+="/"),i.addEventListener("error",()=>{let a=window.translations.search_index_not_available;Pe(s,a)}),i.addEventListener("load",()=>{Se(o,s)}),Se(o,s),ot({trigger:t,searchEl:e,results:r,field:n,status:s},o)}function ot(t,e){let{field:n,results:r,searchEl:i,status:s,trigger:o}=t;Ee(i,{closeOnClick:!0});function a(){xe(i),n.setSelectionRange(0,n.value.length)}o.addEventListener("click",a),n.addEventListener("input",fe(()=>{at(r,n,s,e)},200)),n.addEventListener("keydown",l=>{if(r.childElementCount===0||l.ctrlKey||l.metaKey||l.altKey)return;let d=n.getAttribute("aria-activedescendant"),f=d?document.getElementById(d):null;if(f){let p=!1,v=!1;switch(l.key){case"Home":case"End":case"ArrowLeft":case"ArrowRight":v=!0;break;case"ArrowDown":case"ArrowUp":p=l.shiftKey;break}(p||v)&&ke(n)}if(!l.shiftKey)switch(l.key){case"Enter":f?.querySelector("a")?.click();break;case"ArrowUp":Te(r,n,f,-1),l.preventDefault();break;case"ArrowDown":Te(r,n,f,1),l.preventDefault();break}});function c(){ke(n)}n.addEventListener("change",c),n.addEventListener("blur",c),n.addEventListener("click",c),document.body.addEventListener("keydown",l=>{if(l.altKey||l.metaKey||l.shiftKey)return;let d=l.ctrlKey&&l.key==="k",f=!l.ctrlKey&&!ut()&&l.key==="/";(d||f)&&(l.preventDefault(),a())})}function at(t,e,n,r){if(!r.index||!r.data)return;t.innerHTML="",n.innerHTML="",we+=1;let i=e.value.trim(),s;if(i){let a=i.split(" ").map(c=>c.length?`*${c}*`:"").join(" ");s=r.index.search(a).filter(({ref:c})=>{let l=r.data.rows[Number(c)].classes;return!l||!Le(l)})}else s=[];if(s.length===0&&i){let a=window.translations.search_no_results_found_for_0.replace("{0}",` "${te(i)}" `);Pe(n,a);return}for(let a=0;ac.score-a.score);let o=Math.min(10,s.length);for(let a=0;a`,f=Ce(c.name,i);globalThis.DEBUG_SEARCH_WEIGHTS&&(f+=` (score: ${s[a].score.toFixed(2)})`),c.parent&&(f=` + ${Ce(c.parent,i)}.${f}`);let p=document.createElement("li");p.id=`tsd-search:${we}-${a}`,p.role="option",p.ariaSelected="false",p.classList.value=c.classes??"";let v=document.createElement("a");v.tabIndex=-1,v.href=r.base+c.url,v.innerHTML=d+`${f}`,p.append(v),t.appendChild(p)}}function Te(t,e,n,r){let i;if(r===1?i=n?.nextElementSibling||t.firstElementChild:i=n?.previousElementSibling||t.lastElementChild,i!==n){if(!i||i.role!=="option"){console.error("Option missing");return}i.ariaSelected="true",i.scrollIntoView({behavior:"smooth",block:"nearest"}),e.setAttribute("aria-activedescendant",i.id),n?.setAttribute("aria-selected","false")}}function ke(t){let e=t.getAttribute("aria-activedescendant");(e?document.getElementById(e):null)?.setAttribute("aria-selected","false"),t.setAttribute("aria-activedescendant","")}function Ce(t,e){if(e==="")return t;let n=t.toLocaleLowerCase(),r=e.toLocaleLowerCase(),i=[],s=0,o=n.indexOf(r);for(;o!=-1;)i.push(te(t.substring(s,o)),`${te(t.substring(o,o+r.length))}`),s=o+r.length,o=n.indexOf(r,s);return i.push(te(t.substring(s))),i.join("")}var lt={"&":"&","<":"<",">":">","'":"'",'"':"""};function te(t){return t.replace(/[&<>"'"]/g,e=>lt[e])}function Pe(t,e){t.innerHTML=e?`
                                          ${e}
                                          `:""}var ct=["button","checkbox","file","hidden","image","radio","range","reset","submit"];function ut(){let t=document.activeElement;return t?t.isContentEditable||t.tagName==="TEXTAREA"||t.tagName==="SEARCH"?!0:t.tagName==="INPUT"&&!ct.includes(t.type):!1}var D="mousedown",Me="mousemove",$="mouseup",ne={x:0,y:0},Qe=!1,ce=!1,dt=!1,F=!1,Oe=/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);document.documentElement.classList.add(Oe?"is-mobile":"not-mobile");Oe&&"ontouchstart"in document.documentElement&&(dt=!0,D="touchstart",Me="touchmove",$="touchend");document.addEventListener(D,t=>{ce=!0,F=!1;let e=D=="touchstart"?t.targetTouches[0]:t;ne.y=e.pageY||0,ne.x=e.pageX||0});document.addEventListener(Me,t=>{if(ce&&!F){let e=D=="touchstart"?t.targetTouches[0]:t,n=ne.x-(e.pageX||0),r=ne.y-(e.pageY||0);F=Math.sqrt(n*n+r*r)>10}});document.addEventListener($,()=>{ce=!1});document.addEventListener("click",t=>{Qe&&(t.preventDefault(),t.stopImmediatePropagation(),Qe=!1)});var re=class extends I{active;className;constructor(e){super(e),this.className=this.el.dataset.toggle||"",this.el.addEventListener($,n=>this.onPointerUp(n)),this.el.addEventListener("click",n=>n.preventDefault()),document.addEventListener(D,n=>this.onDocumentPointerDown(n)),document.addEventListener($,n=>this.onDocumentPointerUp(n))}setActive(e){if(this.active==e)return;this.active=e,document.documentElement.classList.toggle("has-"+this.className,e),this.el.classList.toggle("active",e);let n=(this.active?"to-has-":"from-has-")+this.className;document.documentElement.classList.add(n),setTimeout(()=>document.documentElement.classList.remove(n),500)}onPointerUp(e){F||(this.setActive(!0),e.preventDefault())}onDocumentPointerDown(e){if(this.active){if(e.target.closest(".col-sidebar, .tsd-filter-group"))return;this.setActive(!1)}}onDocumentPointerUp(e){if(!F&&this.active&&e.target.closest(".col-sidebar")){let n=e.target.closest("a");if(n){let r=window.location.href;r.indexOf("#")!=-1&&(r=r.substring(0,r.indexOf("#"))),n.href.substring(0,r.length)==r&&setTimeout(()=>this.setActive(!1),250)}}}};var ue=new Map,de=class{open;accordions=[];key;constructor(e,n){this.key=e,this.open=n}add(e){this.accordions.push(e),e.open=this.open,e.addEventListener("toggle",()=>{this.toggle(e.open)})}toggle(e){for(let n of this.accordions)n.open=e;S.setItem(this.key,e.toString())}},ie=class extends I{constructor(e){super(e);let n=this.el.querySelector("summary"),r=n.querySelector("a");r&&r.addEventListener("click",()=>{location.assign(r.href)});let i=`tsd-accordion-${n.dataset.key??n.textContent.trim().replace(/\s+/g,"-").toLowerCase()}`,s;if(ue.has(i))s=ue.get(i);else{let o=S.getItem(i),a=o?o==="true":this.el.open;s=new de(i,a),ue.set(i,s)}s.add(this.el)}};function He(t){let e=S.getItem("tsd-theme")||"os";t.value=e,Ae(e),t.addEventListener("change",()=>{S.setItem("tsd-theme",t.value),Ae(t.value)})}function Ae(t){document.documentElement.dataset.theme=t}var se;function Ne(){let t=document.getElementById("tsd-nav-script");t&&(t.addEventListener("load",Re),Re())}async function Re(){let t=document.getElementById("tsd-nav-container");if(!t||!window.navigationData)return;let e=await R(window.navigationData);se=document.documentElement.dataset.base,se.endsWith("/")||(se+="/"),t.innerHTML="";for(let n of e)Ve(n,t,[]);window.app.createComponents(t),window.app.showPage(),window.app.ensureActivePageVisible()}function Ve(t,e,n){let r=e.appendChild(document.createElement("li"));if(t.children){let i=[...n,t.text],s=r.appendChild(document.createElement("details"));s.className=t.class?`${t.class} tsd-accordion`:"tsd-accordion";let o=s.appendChild(document.createElement("summary"));o.className="tsd-accordion-summary",o.dataset.key=i.join("$"),o.innerHTML='',De(t,o);let a=s.appendChild(document.createElement("div"));a.className="tsd-accordion-details";let c=a.appendChild(document.createElement("ul"));c.className="tsd-nested-navigation";for(let l of t.children)Ve(l,c,i)}else De(t,r,t.class)}function De(t,e,n){if(t.path){let r=e.appendChild(document.createElement("a"));if(r.href=se+t.path,n&&(r.className=n),location.pathname===r.pathname&&!r.href.includes("#")&&(r.classList.add("current"),r.ariaCurrent="page"),t.kind){let i=window.translations[`kind_${t.kind}`].replaceAll('"',""");r.innerHTML=``}r.appendChild(Fe(t.text,document.createElement("span")))}else{let r=e.appendChild(document.createElement("span")),i=window.translations.folder.replaceAll('"',""");r.innerHTML=``,r.appendChild(Fe(t.text,document.createElement("span")))}}function Fe(t,e){let n=t.split(/(?<=[^A-Z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[_-])(?=[^_-])/);for(let r=0;r{let i=r.target;for(;i.parentElement&&i.parentElement.tagName!="LI";)i=i.parentElement;i.dataset.dropdown&&(i.dataset.dropdown=String(i.dataset.dropdown!=="true"))});let t=new Map,e=new Set;for(let r of document.querySelectorAll(".tsd-full-hierarchy [data-refl]")){let i=r.querySelector("ul");t.has(r.dataset.refl)?e.add(r.dataset.refl):i&&t.set(r.dataset.refl,i)}for(let r of e)n(r);function n(r){let i=t.get(r).cloneNode(!0);i.querySelectorAll("[id]").forEach(s=>{s.removeAttribute("id")}),i.querySelectorAll("[data-dropdown]").forEach(s=>{s.dataset.dropdown="false"});for(let s of document.querySelectorAll(`[data-refl="${r}"]`)){let o=gt(),a=s.querySelector("ul");s.insertBefore(o,a),o.dataset.dropdown=String(!!a),a||s.appendChild(i.cloneNode(!0))}}}function pt(){let t=document.getElementById("tsd-hierarchy-script");t&&(t.addEventListener("load",Be),Be())}async function Be(){let t=document.querySelector(".tsd-panel.tsd-hierarchy:has(h4 a)");if(!t||!window.hierarchyData)return;let e=+t.dataset.refl,n=await R(window.hierarchyData),r=t.querySelector("ul"),i=document.createElement("ul");if(i.classList.add("tsd-hierarchy"),ft(i,n,e),r.querySelectorAll("li").length==i.querySelectorAll("li").length)return;let s=document.createElement("span");s.classList.add("tsd-hierarchy-toggle"),s.textContent=window.translations.hierarchy_expand,t.querySelector("h4 a")?.insertAdjacentElement("afterend",s),s.insertAdjacentText("beforebegin",", "),s.addEventListener("click",()=>{s.textContent===window.translations.hierarchy_expand?(r.insertAdjacentElement("afterend",i),r.remove(),s.textContent=window.translations.hierarchy_collapse):(i.insertAdjacentElement("afterend",r),i.remove(),s.textContent=window.translations.hierarchy_expand)})}function ft(t,e,n){let r=e.roots.filter(i=>mt(e,i,n));for(let i of r)t.appendChild(je(e,i,n))}function je(t,e,n,r=new Set){if(r.has(e))return;r.add(e);let i=t.reflections[e],s=document.createElement("li");if(s.classList.add("tsd-hierarchy-item"),e===n){let o=s.appendChild(document.createElement("span"));o.textContent=i.name,o.classList.add("tsd-hierarchy-target")}else{for(let a of i.uniqueNameParents||[]){let c=t.reflections[a],l=s.appendChild(document.createElement("a"));l.textContent=c.name,l.href=oe+c.url,l.className=c.class+" tsd-signature-type",s.append(document.createTextNode("."))}let o=s.appendChild(document.createElement("a"));o.textContent=t.reflections[e].name,o.href=oe+i.url,o.className=i.class+" tsd-signature-type"}if(i.children){let o=s.appendChild(document.createElement("ul"));o.classList.add("tsd-hierarchy");for(let a of i.children){let c=je(t,a,n,r);c&&o.appendChild(c)}}return r.delete(e),s}function mt(t,e,n){if(e===n)return!0;let r=new Set,i=[t.reflections[e]];for(;i.length;){let s=i.pop();if(!r.has(s)){r.add(s);for(let o of s.children||[]){if(o===n)return!0;i.push(t.reflections[o])}}}return!1}function gt(){let t=document.createElementNS("http://www.w3.org/2000/svg","svg");return t.setAttribute("width","20"),t.setAttribute("height","20"),t.innerHTML='',t}X(re,"a[data-toggle]");X(ie,".tsd-accordion");X(ee,".tsd-filter-item input[type=checkbox]");var qe=document.getElementById("tsd-theme");qe&&He(qe);var yt=new Z;Object.defineProperty(window,"app",{value:yt});_e();Ne();$e();"virtualKeyboard"in navigator&&(navigator.virtualKeyboard.overlaysContent=!0);})(); +/*! Bundled license information: + +lunr/lunr.js: + (** + * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9 + * Copyright (C) 2020 Oliver Nightingale + * @license MIT + *) + (*! + * lunr.utils + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Set + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.tokenizer + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Pipeline + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Vector + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.stemmer + * Copyright (C) 2020 Oliver Nightingale + * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt + *) + (*! + * lunr.stopWordFilter + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.trimmer + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.TokenSet + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Index + * Copyright (C) 2020 Oliver Nightingale + *) + (*! + * lunr.Builder + * Copyright (C) 2020 Oliver Nightingale + *) +*/ diff --git a/packages/tempo/public/v4/api/library/assets/navigation.js b/packages/tempo/public/v4/api/library/assets/navigation.js new file mode 100644 index 00000000..753a67f4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/navigation.js @@ -0,0 +1 @@ +window.navigationData = "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" \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/search.js b/packages/tempo/public/v4/api/library/assets/search.js new file mode 100644 index 00000000..b9c4c67c --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/search.js @@ -0,0 +1 @@ +window.searchData = "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"; \ No newline at end of file diff --git a/packages/tempo/public/v4/api/library/assets/style.css b/packages/tempo/public/v4/api/library/assets/style.css new file mode 100644 index 00000000..ec257d51 --- /dev/null +++ b/packages/tempo/public/v4/api/library/assets/style.css @@ -0,0 +1,1648 @@ +@layer typedoc { + :root { + --dim-toolbar-contents-height: 2.5rem; + --dim-toolbar-border-bottom-width: 1px; + --dim-header-height: calc( + var(--dim-toolbar-border-bottom-width) + + var(--dim-toolbar-contents-height) + ); + + /* 0rem For mobile; unit is required for calculation in `calc` */ + --dim-container-main-margin-y: 0rem; + + --dim-footer-height: 3.5rem; + + --modal-animation-duration: 0.2s; + } + + :root { + /* Light */ + --light-color-background: #f2f4f8; + --light-color-background-secondary: #eff0f1; + /* Not to be confused with [:active](https://developer.mozilla.org/en-US/docs/Web/CSS/:active) */ + --light-color-background-active: #d6d8da; + --light-color-background-warning: #e6e600; + --light-color-warning-text: #222; + --light-color-accent: #c5c7c9; + --light-color-active-menu-item: var(--light-color-background-active); + --light-color-text: #222; + --light-color-contrast-text: #000; + --light-color-text-aside: #5e5e5e; + + --light-color-icon-background: var(--light-color-background); + --light-color-icon-text: var(--light-color-text); + + --light-color-comment-tag-text: var(--light-color-text); + --light-color-comment-tag: var(--light-color-background); + + --light-color-link: #1f70c2; + --light-color-focus-outline: #3584e4; + + --light-color-ts-keyword: #056bd6; + --light-color-ts-project: #b111c9; + --light-color-ts-module: var(--light-color-ts-project); + --light-color-ts-namespace: var(--light-color-ts-project); + --light-color-ts-enum: #7e6f15; + --light-color-ts-enum-member: var(--light-color-ts-enum); + --light-color-ts-variable: #4760ec; + --light-color-ts-function: #572be7; + --light-color-ts-class: #1f70c2; + --light-color-ts-interface: #108024; + --light-color-ts-constructor: var(--light-color-ts-class); + --light-color-ts-property: #9f5f30; + --light-color-ts-method: #be3989; + --light-color-ts-reference: #ff4d82; + --light-color-ts-call-signature: var(--light-color-ts-method); + --light-color-ts-index-signature: var(--light-color-ts-property); + --light-color-ts-constructor-signature: var( + --light-color-ts-constructor + ); + --light-color-ts-parameter: var(--light-color-ts-variable); + /* type literal not included as links will never be generated to it */ + --light-color-ts-type-parameter: #a55c0e; + --light-color-ts-accessor: #c73c3c; + --light-color-ts-get-signature: var(--light-color-ts-accessor); + --light-color-ts-set-signature: var(--light-color-ts-accessor); + --light-color-ts-type-alias: #d51270; + /* reference not included as links will be colored with the kind that it points to */ + --light-color-document: #000000; + + --light-color-alert-note: #0969d9; + --light-color-alert-tip: #1a7f37; + --light-color-alert-important: #8250df; + --light-color-alert-warning: #9a6700; + --light-color-alert-caution: #cf222e; + + --light-external-icon: url("data:image/svg+xml;utf8,"); + --light-color-scheme: light; + } + + :root { + /* Dark */ + --dark-color-background: #2b2e33; + --dark-color-background-secondary: #1e2024; + /* Not to be confused with [:active](https://developer.mozilla.org/en-US/docs/Web/CSS/:active) */ + --dark-color-background-active: #5d5d6a; + --dark-color-background-warning: #bebe00; + --dark-color-warning-text: #222; + --dark-color-accent: #9096a2; + --dark-color-active-menu-item: var(--dark-color-background-active); + --dark-color-text: #f5f5f5; + --dark-color-contrast-text: #ffffff; + --dark-color-text-aside: #dddddd; + + --dark-color-icon-background: var(--dark-color-background-secondary); + --dark-color-icon-text: var(--dark-color-text); + + --dark-color-comment-tag-text: var(--dark-color-text); + --dark-color-comment-tag: var(--dark-color-background); + + --dark-color-link: #00aff4; + --dark-color-focus-outline: #4c97f2; + + --dark-color-ts-keyword: #3399ff; + --dark-color-ts-project: #e358ff; + --dark-color-ts-module: var(--dark-color-ts-project); + --dark-color-ts-namespace: var(--dark-color-ts-project); + --dark-color-ts-enum: #f4d93e; + --dark-color-ts-enum-member: var(--dark-color-ts-enum); + --dark-color-ts-variable: #798dff; + --dark-color-ts-function: #a280ff; + --dark-color-ts-class: #8ac4ff; + --dark-color-ts-interface: #6cff87; + --dark-color-ts-constructor: var(--dark-color-ts-class); + --dark-color-ts-property: #ff984d; + --dark-color-ts-method: #ff4db8; + --dark-color-ts-reference: #ff4d82; + --dark-color-ts-call-signature: var(--dark-color-ts-method); + --dark-color-ts-index-signature: var(--dark-color-ts-property); + --dark-color-ts-constructor-signature: var(--dark-color-ts-constructor); + --dark-color-ts-parameter: var(--dark-color-ts-variable); + /* type literal not included as links will never be generated to it */ + --dark-color-ts-type-parameter: #e07d13; + --dark-color-ts-accessor: #ff6060; + --dark-color-ts-get-signature: var(--dark-color-ts-accessor); + --dark-color-ts-set-signature: var(--dark-color-ts-accessor); + --dark-color-ts-type-alias: #ff6492; + /* reference not included as links will be colored with the kind that it points to */ + --dark-color-document: #ffffff; + + --dark-color-alert-note: #0969d9; + --dark-color-alert-tip: #1a7f37; + --dark-color-alert-important: #8250df; + --dark-color-alert-warning: #9a6700; + --dark-color-alert-caution: #cf222e; + + --dark-external-icon: url("data:image/svg+xml;utf8,"); + --dark-color-scheme: dark; + } + + @media (prefers-color-scheme: light) { + :root { + --color-background: var(--light-color-background); + --color-background-secondary: var( + --light-color-background-secondary + ); + --color-background-active: var(--light-color-background-active); + --color-background-warning: var(--light-color-background-warning); + --color-warning-text: var(--light-color-warning-text); + --color-accent: var(--light-color-accent); + --color-active-menu-item: var(--light-color-active-menu-item); + --color-text: var(--light-color-text); + --color-contrast-text: var(--light-color-contrast-text); + --color-text-aside: var(--light-color-text-aside); + + --color-icon-background: var(--light-color-icon-background); + --color-icon-text: var(--light-color-icon-text); + + --color-comment-tag-text: var(--light-color-text); + --color-comment-tag: var(--light-color-background); + + --color-link: var(--light-color-link); + --color-focus-outline: var(--light-color-focus-outline); + + --color-ts-keyword: var(--light-color-ts-keyword); + --color-ts-project: var(--light-color-ts-project); + --color-ts-module: var(--light-color-ts-module); + --color-ts-namespace: var(--light-color-ts-namespace); + --color-ts-enum: var(--light-color-ts-enum); + --color-ts-enum-member: var(--light-color-ts-enum-member); + --color-ts-variable: var(--light-color-ts-variable); + --color-ts-function: var(--light-color-ts-function); + --color-ts-class: var(--light-color-ts-class); + --color-ts-interface: var(--light-color-ts-interface); + --color-ts-constructor: var(--light-color-ts-constructor); + --color-ts-property: var(--light-color-ts-property); + --color-ts-method: var(--light-color-ts-method); + --color-ts-reference: var(--light-color-ts-reference); + --color-ts-call-signature: var(--light-color-ts-call-signature); + --color-ts-index-signature: var(--light-color-ts-index-signature); + --color-ts-constructor-signature: var( + --light-color-ts-constructor-signature + ); + --color-ts-parameter: var(--light-color-ts-parameter); + --color-ts-type-parameter: var(--light-color-ts-type-parameter); + --color-ts-accessor: var(--light-color-ts-accessor); + --color-ts-get-signature: var(--light-color-ts-get-signature); + --color-ts-set-signature: var(--light-color-ts-set-signature); + --color-ts-type-alias: var(--light-color-ts-type-alias); + --color-document: var(--light-color-document); + + --color-alert-note: var(--light-color-alert-note); + --color-alert-tip: var(--light-color-alert-tip); + --color-alert-important: var(--light-color-alert-important); + --color-alert-warning: var(--light-color-alert-warning); + --color-alert-caution: var(--light-color-alert-caution); + + --external-icon: var(--light-external-icon); + --color-scheme: var(--light-color-scheme); + } + } + + @media (prefers-color-scheme: dark) { + :root { + --color-background: var(--dark-color-background); + --color-background-secondary: var( + --dark-color-background-secondary + ); + --color-background-active: var(--dark-color-background-active); + --color-background-warning: var(--dark-color-background-warning); + --color-warning-text: var(--dark-color-warning-text); + --color-accent: var(--dark-color-accent); + --color-active-menu-item: var(--dark-color-active-menu-item); + --color-text: var(--dark-color-text); + --color-contrast-text: var(--dark-color-contrast-text); + --color-text-aside: var(--dark-color-text-aside); + + --color-icon-background: var(--dark-color-icon-background); + --color-icon-text: var(--dark-color-icon-text); + + --color-comment-tag-text: var(--dark-color-text); + --color-comment-tag: var(--dark-color-background); + + --color-link: var(--dark-color-link); + --color-focus-outline: var(--dark-color-focus-outline); + + --color-ts-keyword: var(--dark-color-ts-keyword); + --color-ts-project: var(--dark-color-ts-project); + --color-ts-module: var(--dark-color-ts-module); + --color-ts-namespace: var(--dark-color-ts-namespace); + --color-ts-enum: var(--dark-color-ts-enum); + --color-ts-enum-member: var(--dark-color-ts-enum-member); + --color-ts-variable: var(--dark-color-ts-variable); + --color-ts-function: var(--dark-color-ts-function); + --color-ts-class: var(--dark-color-ts-class); + --color-ts-interface: var(--dark-color-ts-interface); + --color-ts-constructor: var(--dark-color-ts-constructor); + --color-ts-property: var(--dark-color-ts-property); + --color-ts-method: var(--dark-color-ts-method); + --color-ts-reference: var(--dark-color-ts-reference); + --color-ts-call-signature: var(--dark-color-ts-call-signature); + --color-ts-index-signature: var(--dark-color-ts-index-signature); + --color-ts-constructor-signature: var( + --dark-color-ts-constructor-signature + ); + --color-ts-parameter: var(--dark-color-ts-parameter); + --color-ts-type-parameter: var(--dark-color-ts-type-parameter); + --color-ts-accessor: var(--dark-color-ts-accessor); + --color-ts-get-signature: var(--dark-color-ts-get-signature); + --color-ts-set-signature: var(--dark-color-ts-set-signature); + --color-ts-type-alias: var(--dark-color-ts-type-alias); + --color-document: var(--dark-color-document); + + --color-alert-note: var(--dark-color-alert-note); + --color-alert-tip: var(--dark-color-alert-tip); + --color-alert-important: var(--dark-color-alert-important); + --color-alert-warning: var(--dark-color-alert-warning); + --color-alert-caution: var(--dark-color-alert-caution); + + --external-icon: var(--dark-external-icon); + --color-scheme: var(--dark-color-scheme); + } + } + + :root[data-theme="light"] { + --color-background: var(--light-color-background); + --color-background-secondary: var(--light-color-background-secondary); + --color-background-active: var(--light-color-background-active); + --color-background-warning: var(--light-color-background-warning); + --color-warning-text: var(--light-color-warning-text); + --color-icon-background: var(--light-color-icon-background); + --color-accent: var(--light-color-accent); + --color-active-menu-item: var(--light-color-active-menu-item); + --color-text: var(--light-color-text); + --color-contrast-text: var(--light-color-contrast-text); + --color-text-aside: var(--light-color-text-aside); + --color-icon-text: var(--light-color-icon-text); + + --color-comment-tag-text: var(--light-color-text); + --color-comment-tag: var(--light-color-background); + + --color-link: var(--light-color-link); + --color-focus-outline: var(--light-color-focus-outline); + + --color-ts-keyword: var(--light-color-ts-keyword); + --color-ts-project: var(--light-color-ts-project); + --color-ts-module: var(--light-color-ts-module); + --color-ts-namespace: var(--light-color-ts-namespace); + --color-ts-enum: var(--light-color-ts-enum); + --color-ts-enum-member: var(--light-color-ts-enum-member); + --color-ts-variable: var(--light-color-ts-variable); + --color-ts-function: var(--light-color-ts-function); + --color-ts-class: var(--light-color-ts-class); + --color-ts-interface: var(--light-color-ts-interface); + --color-ts-constructor: var(--light-color-ts-constructor); + --color-ts-property: var(--light-color-ts-property); + --color-ts-method: var(--light-color-ts-method); + --color-ts-reference: var(--light-color-ts-reference); + --color-ts-call-signature: var(--light-color-ts-call-signature); + --color-ts-index-signature: var(--light-color-ts-index-signature); + --color-ts-constructor-signature: var( + --light-color-ts-constructor-signature + ); + --color-ts-parameter: var(--light-color-ts-parameter); + --color-ts-type-parameter: var(--light-color-ts-type-parameter); + --color-ts-accessor: var(--light-color-ts-accessor); + --color-ts-get-signature: var(--light-color-ts-get-signature); + --color-ts-set-signature: var(--light-color-ts-set-signature); + --color-ts-type-alias: var(--light-color-ts-type-alias); + --color-document: var(--light-color-document); + + --color-note: var(--light-color-note); + --color-tip: var(--light-color-tip); + --color-important: var(--light-color-important); + --color-warning: var(--light-color-warning); + --color-caution: var(--light-color-caution); + + --external-icon: var(--light-external-icon); + --color-scheme: var(--light-color-scheme); + } + + :root[data-theme="dark"] { + --color-background: var(--dark-color-background); + --color-background-secondary: var(--dark-color-background-secondary); + --color-background-active: var(--dark-color-background-active); + --color-background-warning: var(--dark-color-background-warning); + --color-warning-text: var(--dark-color-warning-text); + --color-icon-background: var(--dark-color-icon-background); + --color-accent: var(--dark-color-accent); + --color-active-menu-item: var(--dark-color-active-menu-item); + --color-text: var(--dark-color-text); + --color-contrast-text: var(--dark-color-contrast-text); + --color-text-aside: var(--dark-color-text-aside); + --color-icon-text: var(--dark-color-icon-text); + + --color-comment-tag-text: var(--dark-color-text); + --color-comment-tag: var(--dark-color-background); + + --color-link: var(--dark-color-link); + --color-focus-outline: var(--dark-color-focus-outline); + + --color-ts-keyword: var(--dark-color-ts-keyword); + --color-ts-project: var(--dark-color-ts-project); + --color-ts-module: var(--dark-color-ts-module); + --color-ts-namespace: var(--dark-color-ts-namespace); + --color-ts-enum: var(--dark-color-ts-enum); + --color-ts-enum-member: var(--dark-color-ts-enum-member); + --color-ts-variable: var(--dark-color-ts-variable); + --color-ts-function: var(--dark-color-ts-function); + --color-ts-class: var(--dark-color-ts-class); + --color-ts-interface: var(--dark-color-ts-interface); + --color-ts-constructor: var(--dark-color-ts-constructor); + --color-ts-property: var(--dark-color-ts-property); + --color-ts-method: var(--dark-color-ts-method); + --color-ts-reference: var(--dark-color-ts-reference); + --color-ts-call-signature: var(--dark-color-ts-call-signature); + --color-ts-index-signature: var(--dark-color-ts-index-signature); + --color-ts-constructor-signature: var( + --dark-color-ts-constructor-signature + ); + --color-ts-parameter: var(--dark-color-ts-parameter); + --color-ts-type-parameter: var(--dark-color-ts-type-parameter); + --color-ts-accessor: var(--dark-color-ts-accessor); + --color-ts-get-signature: var(--dark-color-ts-get-signature); + --color-ts-set-signature: var(--dark-color-ts-set-signature); + --color-ts-type-alias: var(--dark-color-ts-type-alias); + --color-document: var(--dark-color-document); + + --color-note: var(--dark-color-note); + --color-tip: var(--dark-color-tip); + --color-important: var(--dark-color-important); + --color-warning: var(--dark-color-warning); + --color-caution: var(--dark-color-caution); + + --external-icon: var(--dark-external-icon); + --color-scheme: var(--dark-color-scheme); + } + + html { + color-scheme: var(--color-scheme); + @media (prefers-reduced-motion: no-preference) { + scroll-behavior: smooth; + } + } + + *:focus-visible, + .tsd-accordion-summary:focus-visible svg { + outline: 2px solid var(--color-focus-outline); + } + + .always-visible, + .always-visible .tsd-signatures { + display: inherit !important; + } + + h1, + h2, + h3, + h4, + h5, + h6 { + line-height: 1.2; + } + + h1 { + font-size: 1.875rem; + margin: 0.67rem 0; + } + + h2 { + font-size: 1.5rem; + margin: 0.83rem 0; + } + + h3 { + font-size: 1.25rem; + margin: 1rem 0; + } + + h4 { + font-size: 1.05rem; + margin: 1.33rem 0; + } + + h5 { + font-size: 1rem; + margin: 1.5rem 0; + } + + h6 { + font-size: 0.875rem; + margin: 2.33rem 0; + } + + dl, + menu, + ol, + ul { + margin: 1em 0; + } + + dd { + margin: 0 0 0 34px; + } + + .container { + max-width: 1700px; + padding: 0 2rem; + } + + /* Footer */ + footer { + border-top: 1px solid var(--color-accent); + padding-top: 1rem; + padding-bottom: 1rem; + max-height: var(--dim-footer-height); + } + footer > p { + margin: 0 1em; + } + + .container-main { + margin: var(--dim-container-main-margin-y) auto; + /* toolbar, footer, margin */ + min-height: calc( + 100svh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + } + + @keyframes fade-in { + from { + opacity: 0; + } + to { + opacity: 1; + } + } + @keyframes fade-out { + from { + opacity: 1; + visibility: visible; + } + to { + opacity: 0; + } + } + @keyframes pop-in-from-right { + from { + transform: translate(100%, 0); + } + to { + transform: translate(0, 0); + } + } + @keyframes pop-out-to-right { + from { + transform: translate(0, 0); + visibility: visible; + } + to { + transform: translate(100%, 0); + } + } + body { + background: var(--color-background); + font-family: + -apple-system, + BlinkMacSystemFont, + "Segoe UI", + "Noto Sans", + Helvetica, + Arial, + sans-serif, + "Apple Color Emoji", + "Segoe UI Emoji"; + font-size: 16px; + color: var(--color-text); + margin: 0; + } + + a { + color: var(--color-link); + text-decoration: none; + } + a:hover { + text-decoration: underline; + } + a.external[target="_blank"] { + background-image: var(--external-icon); + background-position: top 3px right; + background-repeat: no-repeat; + padding-right: 13px; + } + a.tsd-anchor-link { + color: var(--color-text); + } + :target { + scroll-margin-block: calc(var(--dim-header-height) + 0.5rem); + } + + math[display="block"] { + position: relative; + padding: 10px; + border: 1px solid var(--color-accent); + border-radius: 0.8em; + margin-bottom: 8px; + } + + code, + pre { + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; + padding: 0.2em; + margin: 0; + font-size: 0.875rem; + border-radius: 0.8em; + } + + pre { + position: relative; + white-space: pre-wrap; + word-wrap: break-word; + padding: 10px; + border: 1px solid var(--color-accent); + margin-bottom: 8px; + } + pre code { + padding: 0; + font-size: 100%; + } + pre > button { + position: absolute; + top: 10px; + right: 10px; + opacity: 0; + transition: opacity 0.1s; + box-sizing: border-box; + } + pre:hover > button, + pre > button.visible, + pre > button:focus-visible { + opacity: 1; + } + + blockquote { + margin: 1em 0; + padding-left: 1em; + border-left: 4px solid gray; + } + + img { + max-width: 100%; + } + + * { + scrollbar-width: thin; + scrollbar-color: var(--color-accent) var(--color-icon-background); + } + + *::-webkit-scrollbar { + width: 0.75rem; + } + + *::-webkit-scrollbar-track { + background: var(--color-icon-background); + } + + *::-webkit-scrollbar-thumb { + background-color: var(--color-accent); + border-radius: 999rem; + border: 0.25rem solid var(--color-icon-background); + } + + dialog { + border: none; + outline: none; + padding: 0; + background-color: var(--color-background); + } + dialog::backdrop { + display: none; + } + #tsd-overlay { + background-color: rgba(0, 0, 0, 0.5); + position: fixed; + z-index: 9999; + top: 0; + left: 0; + right: 0; + bottom: 0; + animation: fade-in var(--modal-animation-duration) forwards; + } + #tsd-overlay.closing { + animation-name: fade-out; + } + + .tsd-typography { + line-height: 1.333em; + } + .tsd-typography ul { + list-style: square; + padding: 0 0 0 20px; + margin: 0; + } + .tsd-typography .tsd-index-panel h3, + .tsd-index-panel .tsd-typography h3, + .tsd-typography h4, + .tsd-typography h5, + .tsd-typography h6 { + font-size: 1em; + } + .tsd-typography h5, + .tsd-typography h6 { + font-weight: normal; + } + .tsd-typography p, + .tsd-typography ul, + .tsd-typography ol { + margin: 1em 0; + } + .tsd-typography table { + border-collapse: collapse; + border: none; + } + .tsd-typography td, + .tsd-typography th { + padding: 6px 13px; + border: 1px solid var(--color-accent); + } + .tsd-typography thead, + .tsd-typography tr:nth-child(even) { + background-color: var(--color-background-secondary); + } + + .tsd-alert { + padding: 8px 16px; + margin-bottom: 16px; + border-left: 0.25em solid var(--alert-color); + } + .tsd-alert blockquote > :last-child, + .tsd-alert > :last-child { + margin-bottom: 0; + } + .tsd-alert-title { + color: var(--alert-color); + display: inline-flex; + align-items: center; + } + .tsd-alert-title span { + margin-left: 4px; + } + + .tsd-alert-note { + --alert-color: var(--color-alert-note); + } + .tsd-alert-tip { + --alert-color: var(--color-alert-tip); + } + .tsd-alert-important { + --alert-color: var(--color-alert-important); + } + .tsd-alert-warning { + --alert-color: var(--color-alert-warning); + } + .tsd-alert-caution { + --alert-color: var(--color-alert-caution); + } + + .tsd-breadcrumb { + margin: 0; + margin-top: 1rem; + padding: 0; + color: var(--color-text-aside); + } + .tsd-breadcrumb a { + color: var(--color-text-aside); + text-decoration: none; + } + .tsd-breadcrumb a:hover { + text-decoration: underline; + } + .tsd-breadcrumb li { + display: inline; + } + .tsd-breadcrumb li:after { + content: " / "; + } + + .tsd-comment-tags { + display: flex; + flex-direction: column; + } + dl.tsd-comment-tag-group { + display: flex; + align-items: center; + overflow: hidden; + margin: 0.5em 0; + } + dl.tsd-comment-tag-group dt { + display: flex; + margin-right: 0.5em; + font-size: 0.875em; + font-weight: normal; + } + dl.tsd-comment-tag-group dd { + margin: 0; + } + code.tsd-tag { + padding: 0.25em 0.4em; + border: 0.1em solid var(--color-accent); + margin-right: 0.25em; + font-size: 70%; + } + h1 code.tsd-tag:first-of-type { + margin-left: 0.25em; + } + + dl.tsd-comment-tag-group dd:before, + dl.tsd-comment-tag-group dd:after { + content: " "; + } + dl.tsd-comment-tag-group dd pre, + dl.tsd-comment-tag-group dd:after { + clear: both; + } + dl.tsd-comment-tag-group p { + margin: 0; + } + + .tsd-panel.tsd-comment .lead { + font-size: 1.1em; + line-height: 1.333em; + margin-bottom: 2em; + } + .tsd-panel.tsd-comment .lead:last-child { + margin-bottom: 0; + } + + .tsd-filter-visibility h4 { + font-size: 1rem; + padding-top: 0.75rem; + padding-bottom: 0.5rem; + margin: 0; + } + .tsd-filter-item:not(:last-child) { + margin-bottom: 0.5rem; + } + .tsd-filter-input { + display: flex; + width: -moz-fit-content; + width: fit-content; + align-items: center; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + } + .tsd-filter-input input[type="checkbox"] { + cursor: pointer; + position: absolute; + width: 1.5em; + height: 1.5em; + opacity: 0; + } + .tsd-filter-input input[type="checkbox"]:disabled { + pointer-events: none; + } + .tsd-filter-input svg { + cursor: pointer; + width: 1.5em; + height: 1.5em; + margin-right: 0.5em; + border-radius: 0.33em; + /* Leaving this at full opacity breaks event listeners on Firefox. + Don't remove unless you know what you're doing. */ + opacity: 0.99; + } + .tsd-filter-input input[type="checkbox"]:focus-visible + svg { + outline: 2px solid var(--color-focus-outline); + } + .tsd-checkbox-background { + fill: var(--color-accent); + } + input[type="checkbox"]:checked ~ svg .tsd-checkbox-checkmark { + stroke: var(--color-text); + } + .tsd-filter-input input:disabled ~ svg > .tsd-checkbox-background { + fill: var(--color-background); + stroke: var(--color-accent); + stroke-width: 0.25rem; + } + .tsd-filter-input input:disabled ~ svg > .tsd-checkbox-checkmark { + stroke: var(--color-accent); + } + + .settings-label { + font-weight: bold; + text-transform: uppercase; + display: inline-block; + } + + .tsd-filter-visibility .settings-label { + margin: 0.75rem 0 0.5rem 0; + } + + .tsd-theme-toggle .settings-label { + margin: 0.75rem 0.75rem 0 0; + } + + .tsd-hierarchy h4 label:hover span { + text-decoration: underline; + } + + .tsd-hierarchy { + list-style: square; + margin: 0; + } + .tsd-hierarchy-target { + font-weight: bold; + } + .tsd-hierarchy-toggle { + color: var(--color-link); + cursor: pointer; + } + + .tsd-full-hierarchy:not(:last-child) { + margin-bottom: 1em; + padding-bottom: 1em; + border-bottom: 1px solid var(--color-accent); + } + .tsd-full-hierarchy, + .tsd-full-hierarchy ul { + list-style: none; + margin: 0; + padding: 0; + } + .tsd-full-hierarchy ul { + padding-left: 1.5rem; + } + .tsd-full-hierarchy a { + padding: 0.25rem 0 !important; + font-size: 1rem; + display: inline-flex; + align-items: center; + color: var(--color-text); + } + .tsd-full-hierarchy svg[data-dropdown] { + cursor: pointer; + } + .tsd-full-hierarchy svg[data-dropdown="false"] { + transform: rotate(-90deg); + } + .tsd-full-hierarchy svg[data-dropdown="false"] ~ ul { + display: none; + } + + .tsd-panel-group.tsd-index-group { + margin-bottom: 0; + } + .tsd-index-panel .tsd-index-list { + list-style: none; + line-height: 1.333em; + margin: 0; + padding: 0.25rem 0 0 0; + overflow: hidden; + display: grid; + grid-template-columns: repeat(3, 1fr); + column-gap: 1rem; + grid-template-rows: auto; + } + @media (max-width: 1024px) { + .tsd-index-panel .tsd-index-list { + grid-template-columns: repeat(2, 1fr); + } + } + @media (max-width: 768px) { + .tsd-index-panel .tsd-index-list { + grid-template-columns: repeat(1, 1fr); + } + } + .tsd-index-panel .tsd-index-list li { + -webkit-page-break-inside: avoid; + -moz-page-break-inside: avoid; + -ms-page-break-inside: avoid; + -o-page-break-inside: avoid; + page-break-inside: avoid; + } + + .tsd-flag { + display: inline-block; + padding: 0.25em 0.4em; + border-radius: 4px; + color: var(--color-comment-tag-text); + background-color: var(--color-comment-tag); + text-indent: 0; + font-size: 75%; + line-height: 1; + font-weight: normal; + } + + .tsd-anchor { + position: relative; + top: -100px; + } + + .tsd-member { + position: relative; + } + .tsd-member .tsd-anchor + h3 { + display: flex; + align-items: center; + margin-top: 0; + margin-bottom: 0; + border-bottom: none; + } + + .tsd-navigation.settings { + margin: 0; + margin-bottom: 1rem; + } + .tsd-navigation > a, + .tsd-navigation .tsd-accordion-summary { + width: calc(100% - 0.25rem); + display: flex; + align-items: center; + } + .tsd-navigation a, + .tsd-navigation summary > span, + .tsd-page-navigation a { + display: flex; + width: calc(100% - 0.25rem); + align-items: center; + padding: 0.25rem; + color: var(--color-text); + text-decoration: none; + box-sizing: border-box; + } + .tsd-navigation a.current, + .tsd-page-navigation a.current { + background: var(--color-active-menu-item); + color: var(--color-contrast-text); + } + .tsd-navigation a:hover, + .tsd-page-navigation a:hover { + text-decoration: underline; + } + .tsd-navigation ul, + .tsd-page-navigation ul { + margin-top: 0; + margin-bottom: 0; + padding: 0; + list-style: none; + } + .tsd-navigation li, + .tsd-page-navigation li { + padding: 0; + max-width: 100%; + } + .tsd-navigation .tsd-nav-link { + display: none; + } + .tsd-nested-navigation { + margin-left: 3rem; + } + .tsd-nested-navigation > li > details { + margin-left: -1.5rem; + } + .tsd-small-nested-navigation { + margin-left: 1.5rem; + } + .tsd-small-nested-navigation > li > details { + margin-left: -1.5rem; + } + + .tsd-page-navigation-section > summary { + padding: 0.25rem; + } + .tsd-page-navigation-section > summary > svg { + margin-right: 0.25rem; + } + .tsd-page-navigation-section > div { + margin-left: 30px; + } + .tsd-page-navigation ul { + padding-left: 1.75rem; + } + + #tsd-sidebar-links a { + margin-top: 0; + margin-bottom: 0.5rem; + line-height: 1.25rem; + } + #tsd-sidebar-links a:last-of-type { + margin-bottom: 0; + } + + a.tsd-index-link { + padding: 0.25rem 0 !important; + font-size: 1rem; + line-height: 1.25rem; + display: inline-flex; + align-items: center; + color: var(--color-text); + } + .tsd-accordion-summary { + list-style-type: none; /* hide marker on non-safari */ + outline: none; /* broken on safari, so just hide it */ + display: flex; + align-items: center; + gap: 0.25rem; + box-sizing: border-box; + } + .tsd-accordion-summary::-webkit-details-marker { + display: none; /* hide marker on safari */ + } + .tsd-accordion-summary, + .tsd-accordion-summary a { + -moz-user-select: none; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; + + cursor: pointer; + } + .tsd-accordion-summary > a { + width: calc(100% - 1.5rem); + } + .tsd-accordion-summary > * { + margin-top: 0; + margin-bottom: 0; + padding-top: 0; + padding-bottom: 0; + } + /* + * We need to be careful to target the arrow indicating whether the accordion + * is open, but not any other SVGs included in the details element. + */ + .tsd-accordion:not([open]) > .tsd-accordion-summary > svg:first-child { + transform: rotate(-90deg); + } + .tsd-index-content > :not(:first-child) { + margin-top: 0.75rem; + } + .tsd-index-summary { + margin-top: 1.5rem; + margin-bottom: 0.75rem; + display: flex; + align-content: center; + } + + .tsd-no-select { + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + } + .tsd-kind-icon { + margin-right: 0.5rem; + width: 1.25rem; + height: 1.25rem; + min-width: 1.25rem; + min-height: 1.25rem; + } + .tsd-signature > .tsd-kind-icon { + margin-right: 0.8rem; + } + + .tsd-panel { + margin-bottom: 2.5rem; + } + .tsd-panel.tsd-member { + margin-bottom: 4rem; + } + .tsd-panel:empty { + display: none; + } + .tsd-panel > h1, + .tsd-panel > h2, + .tsd-panel > h3 { + margin: 1.5rem -1.5rem 0.75rem -1.5rem; + padding: 0 1.5rem 0.75rem 1.5rem; + } + .tsd-panel > h1.tsd-before-signature, + .tsd-panel > h2.tsd-before-signature, + .tsd-panel > h3.tsd-before-signature { + margin-bottom: 0; + border-bottom: none; + } + + .tsd-panel-group { + margin: 2rem 0; + } + .tsd-panel-group.tsd-index-group { + margin: 2rem 0; + } + .tsd-panel-group.tsd-index-group details { + margin: 2rem 0; + } + .tsd-panel-group > .tsd-accordion-summary { + margin-bottom: 1rem; + } + + #tsd-search[open] { + animation: fade-in var(--modal-animation-duration) ease-out forwards; + } + #tsd-search[open].closing { + animation-name: fade-out; + } + + /* Avoid setting `display` on closed dialog */ + #tsd-search[open] { + display: flex; + flex-direction: column; + padding: 1rem; + width: 32rem; + max-width: 90vw; + max-height: calc(100vh - env(keyboard-inset-height, 0px) - 25vh); + /* Anchor dialog to top */ + margin-top: 10vh; + border-radius: 6px; + will-change: max-height; + } + #tsd-search-input { + box-sizing: border-box; + width: 100%; + padding: 0 0.625rem; /* 10px */ + outline: 0; + border: 2px solid var(--color-accent); + background-color: transparent; + color: var(--color-text); + border-radius: 4px; + height: 2.5rem; + flex: 0 0 auto; + font-size: 0.875rem; + transition: border-color 0.2s, background-color 0.2s; + } + #tsd-search-input:focus-visible { + background-color: var(--color-background-active); + border-color: transparent; + color: var(--color-contrast-text); + } + #tsd-search-input::placeholder { + color: inherit; + opacity: 0.8; + } + #tsd-search-results { + margin: 0; + padding: 0; + list-style: none; + flex: 1 1 auto; + display: flex; + flex-direction: column; + overflow-y: auto; + } + #tsd-search-results:not(:empty) { + margin-top: 0.5rem; + } + #tsd-search-results > li { + background-color: var(--color-background); + line-height: 1.5; + box-sizing: border-box; + border-radius: 4px; + } + #tsd-search-results > li:nth-child(even) { + background-color: var(--color-background-secondary); + } + #tsd-search-results > li:is(:hover, [aria-selected="true"]) { + background-color: var(--color-background-active); + color: var(--color-contrast-text); + } + /* It's important that this takes full size of parent `li`, to capture a click on `li` */ + #tsd-search-results > li > a { + display: flex; + align-items: center; + padding: 0.5rem 0.25rem; + box-sizing: border-box; + width: 100%; + } + #tsd-search-results > li > a > .text { + flex: 1 1 auto; + min-width: 0; + overflow-wrap: anywhere; + } + #tsd-search-results > li > a .parent { + color: var(--color-text-aside); + } + #tsd-search-results > li > a mark { + color: inherit; + background-color: inherit; + font-weight: bold; + } + #tsd-search-status { + flex: 1; + display: grid; + place-content: center; + text-align: center; + overflow-wrap: anywhere; + } + #tsd-search-status:not(:empty) { + min-height: 6rem; + } + + .tsd-signature { + margin: 0 0 1rem 0; + padding: 1rem 0.5rem; + border: 1px solid var(--color-accent); + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; + font-size: 14px; + overflow-x: auto; + } + + .tsd-signature-keyword { + color: var(--color-ts-keyword); + font-weight: normal; + } + + .tsd-signature-symbol { + color: var(--color-text-aside); + font-weight: normal; + } + + .tsd-signature-type { + font-style: italic; + font-weight: normal; + } + + .tsd-signatures { + padding: 0; + margin: 0 0 1em 0; + list-style-type: none; + } + .tsd-signatures .tsd-signature { + margin: 0; + border-color: var(--color-accent); + border-width: 1px 0; + transition: background-color 0.1s; + } + .tsd-signatures .tsd-index-signature:not(:last-child) { + margin-bottom: 1em; + } + .tsd-signatures .tsd-index-signature .tsd-signature { + border-width: 1px; + } + .tsd-description .tsd-signatures .tsd-signature { + border-width: 1px; + } + + ul.tsd-parameter-list, + ul.tsd-type-parameter-list { + list-style: square; + margin: 0; + padding-left: 20px; + } + ul.tsd-parameter-list > li.tsd-parameter-signature, + ul.tsd-type-parameter-list > li.tsd-parameter-signature { + list-style: none; + margin-left: -20px; + } + ul.tsd-parameter-list h5, + ul.tsd-type-parameter-list h5 { + font-size: 16px; + margin: 1em 0 0.5em 0; + } + .tsd-sources { + margin-top: 1rem; + font-size: 0.875em; + } + .tsd-sources a { + color: var(--color-text-aside); + text-decoration: underline; + } + .tsd-sources ul { + list-style: none; + padding: 0; + } + + .tsd-page-toolbar { + position: sticky; + z-index: 1; + top: 0; + left: 0; + width: 100%; + color: var(--color-text); + background: var(--color-background-secondary); + border-bottom: var(--dim-toolbar-border-bottom-width) + var(--color-accent) solid; + transition: transform 0.3s ease-in-out; + } + .tsd-page-toolbar a { + color: var(--color-text); + } + .tsd-toolbar-contents { + display: flex; + align-items: center; + height: var(--dim-toolbar-contents-height); + margin: 0 auto; + } + .tsd-toolbar-contents > .title { + font-weight: bold; + margin-right: auto; + } + #tsd-toolbar-links { + display: flex; + align-items: center; + gap: 1.5rem; + margin-right: 1rem; + } + + .tsd-widget { + box-sizing: border-box; + display: inline-block; + opacity: 0.8; + height: 2.5rem; + width: 2.5rem; + transition: opacity 0.1s, background-color 0.1s; + text-align: center; + cursor: pointer; + border: none; + background-color: transparent; + } + .tsd-widget:hover { + opacity: 0.9; + } + .tsd-widget:active { + opacity: 1; + background-color: var(--color-accent); + } + #tsd-toolbar-menu-trigger { + display: none; + } + + .tsd-member-summary-name { + display: inline-flex; + align-items: center; + padding: 0.25rem; + text-decoration: none; + } + + .tsd-anchor-icon { + display: inline-flex; + align-items: center; + margin-left: 0.5rem; + color: var(--color-text); + vertical-align: middle; + } + + .tsd-anchor-icon svg { + width: 1em; + height: 1em; + visibility: hidden; + } + + .tsd-member-summary-name:hover > .tsd-anchor-icon svg, + .tsd-anchor-link:hover > .tsd-anchor-icon svg, + .tsd-anchor-icon:focus-visible svg { + visibility: visible; + } + + .deprecated { + text-decoration: line-through !important; + } + + .warning { + padding: 1rem; + color: var(--color-warning-text); + background: var(--color-background-warning); + } + + .tsd-kind-project { + color: var(--color-ts-project); + } + .tsd-kind-module { + color: var(--color-ts-module); + } + .tsd-kind-namespace { + color: var(--color-ts-namespace); + } + .tsd-kind-enum { + color: var(--color-ts-enum); + } + .tsd-kind-enum-member { + color: var(--color-ts-enum-member); + } + .tsd-kind-variable { + color: var(--color-ts-variable); + } + .tsd-kind-function { + color: var(--color-ts-function); + } + .tsd-kind-class { + color: var(--color-ts-class); + } + .tsd-kind-interface { + color: var(--color-ts-interface); + } + .tsd-kind-constructor { + color: var(--color-ts-constructor); + } + .tsd-kind-property { + color: var(--color-ts-property); + } + .tsd-kind-method { + color: var(--color-ts-method); + } + .tsd-kind-reference { + color: var(--color-ts-reference); + } + .tsd-kind-call-signature { + color: var(--color-ts-call-signature); + } + .tsd-kind-index-signature { + color: var(--color-ts-index-signature); + } + .tsd-kind-constructor-signature { + color: var(--color-ts-constructor-signature); + } + .tsd-kind-parameter { + color: var(--color-ts-parameter); + } + .tsd-kind-type-parameter { + color: var(--color-ts-type-parameter); + } + .tsd-kind-accessor { + color: var(--color-ts-accessor); + } + .tsd-kind-get-signature { + color: var(--color-ts-get-signature); + } + .tsd-kind-set-signature { + color: var(--color-ts-set-signature); + } + .tsd-kind-type-alias { + color: var(--color-ts-type-alias); + } + + /* if we have a kind icon, don't color the text by kind */ + .tsd-kind-icon ~ span { + color: var(--color-text); + } + + /* mobile */ + @media (max-width: 769px) { + #tsd-toolbar-menu-trigger { + display: inline-block; + /* temporary fix to vertically align, for compatibility */ + line-height: 2.5; + } + #tsd-toolbar-links { + display: none; + } + + .container-main { + display: flex; + } + .col-content { + float: none; + max-width: 100%; + width: 100%; + } + .col-sidebar { + position: fixed !important; + overflow-y: auto; + -webkit-overflow-scrolling: touch; + z-index: 1024; + top: 0 !important; + bottom: 0 !important; + left: auto !important; + right: 0 !important; + padding: 1.5rem 1.5rem 0 0; + width: 75vw; + visibility: hidden; + background-color: var(--color-background); + transform: translate(100%, 0); + } + .col-sidebar > *:last-child { + padding-bottom: 20px; + } + .overlay { + content: ""; + display: block; + position: fixed; + z-index: 1023; + top: 0; + left: 0; + right: 0; + bottom: 0; + background-color: rgba(0, 0, 0, 0.75); + visibility: hidden; + } + + .to-has-menu .overlay { + animation: fade-in 0.4s; + } + + .to-has-menu .col-sidebar { + animation: pop-in-from-right 0.4s; + } + + .from-has-menu .overlay { + animation: fade-out 0.4s; + } + + .from-has-menu .col-sidebar { + animation: pop-out-to-right 0.4s; + } + + .has-menu body { + overflow: hidden; + } + .has-menu .overlay { + visibility: visible; + } + .has-menu .col-sidebar { + visibility: visible; + transform: translate(0, 0); + display: flex; + flex-direction: column; + gap: 1.5rem; + max-height: 100vh; + padding: 1rem 2rem; + } + .has-menu .tsd-navigation { + max-height: 100%; + } + .tsd-navigation .tsd-nav-link { + display: flex; + } + } + + /* one sidebar */ + @media (min-width: 770px) { + .container-main { + display: grid; + grid-template-columns: minmax(0, 1fr) minmax(0, 2fr); + grid-template-areas: "sidebar content"; + --dim-container-main-margin-y: 2rem; + } + + .tsd-breadcrumb { + margin-top: 0; + } + + .col-sidebar { + grid-area: sidebar; + } + .col-content { + grid-area: content; + padding: 0 1rem; + } + } + @media (min-width: 770px) and (max-width: 1399px) { + .col-sidebar { + max-height: calc( + 100vh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + overflow: auto; + position: sticky; + top: calc( + var(--dim-header-height) + var(--dim-container-main-margin-y) + ); + } + .site-menu { + margin-top: 1rem; + } + } + + /* two sidebars */ + @media (min-width: 1200px) { + .container-main { + grid-template-columns: + minmax(0, 1fr) minmax(0, 2.5fr) minmax( + 0, + 20rem + ); + grid-template-areas: "sidebar content toc"; + } + + .col-sidebar { + display: contents; + } + + .page-menu { + grid-area: toc; + padding-left: 1rem; + } + .site-menu { + grid-area: sidebar; + } + + .site-menu { + margin-top: 0rem; + } + + .page-menu, + .site-menu { + max-height: calc( + 100vh - var(--dim-header-height) - var(--dim-footer-height) - + 2 * var(--dim-container-main-margin-y) + ); + overflow: auto; + position: sticky; + top: calc( + var(--dim-header-height) + var(--dim-container-main-margin-y) + ); + } + } +} diff --git a/packages/tempo/public/v4/api/library/classes/browser.index.Tapper.html b/packages/tempo/public/v4/api/library/classes/browser.index.Tapper.html new file mode 100644 index 00000000..70ce27ba --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/browser.index.Tapper.html @@ -0,0 +1,202 @@ +Tapper | Library API
                                          +
                                          Library API + +
                                            +
                                            +
                                            Preparing search index...
                                            +
                                            +
                                            +
                                            + +

                                            Class Tapper

                                            +
                                            +

                                            A Wrapper Class around HammerJS. +Manages single, double, and triple tap events on a given element.

                                            +
                                            +
                                            +
                                            +
                                            const tapper = new Tapper('#my-button', [Tapper.EVENT.SingleTap, () => console.log('Tapped!')]);
+
                                            + +
                                            +
                                            +
                                            +
                                            +
                                            Index
                                             +
                                            +
                                            + +
                                            constructor +
                                            +
                                            + +
                                            [dispose] +[iterator] +clear +destroy +enable +list +off +on +
                                            +
                                            + +
                                            +
                                            + +
                                              +
                                            • + +
                                              +
                                              +

                                              Parameters

                                              +
                                              +

                                              Returns Tapper

                                            +
                                            + +
                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Returns void

                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Returns { next: () => IteratorResult<{ element: any; handlers: any }, undefined> }

                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Stop all event listeners on this instance.

                                              +
                                              +

                                              Returns Tapper

                                              The Tapper instance for chaining

                                              +
                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Detach and destroy all underlying Hammer instances.

                                              +
                                              +

                                              Returns void

                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Enable or disable specific event listeners (or all if none specified).

                                              +
                                              +
                                              +

                                              Parameters

                                              +
                                                +
                                              • enable: boolean = true +

                                                Whether to enable or disable the events

                                                +
                                                • +
                                              • ...events: ("singleTap" | "doubleTap" | "tripleTap")[] +

                                                Specific events to target

                                                +
                                              +

                                              Returns Tapper

                                              The Tapper instance for chaining

                                              +
                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              List details about the active Hammer instances managed by this Tapper.

                                              +
                                              +

                                              Returns { element: any; handlers: any }[]

                                              Array of Hammer instance details

                                              +
                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Stop event listeners. Defaults to 'all' listeners on this instance if none specified.

                                              +
                                              +
                                              +

                                              Parameters

                                              +
                                                +
                                              • ...events: ("singleTap" | "doubleTap" | "tripleTap")[] +

                                                Specific events to stop listening for

                                                +
                                              +

                                              Returns Tapper

                                              The Tapper instance for chaining

                                              +
                                            +
                                            + +
                                              +
                                            • + +
                                              +

                                              Register a list of callbacks to fire on 'singleTap', or a tuple of events/callbacks to fire.

                                              +
                                              +
                                              +

                                              Parameters

                                              +
                                                +
                                              • ...events: (Callback | Tuple)[] +

                                                Callbacks for singleTap or Tuples of [Event, Callback]

                                                +
                                              +

                                              Returns Tapper

                                              The Tapper instance for chaining

                                              +
                                            +
                                            +
                                            +
                                            +
                                            +

                                            Settings

                                             +
                                            +
                                            Member Visibility +
                                              +
                                              • +
                                              • +
                                            +
                                            +
                                            +

                                            On This Page

                                             +
                                            +
                                            Constructors +
                                            +
                                            Methods +
                                            +
                                            + +
                                            +
                                            diff --git a/packages/tempo/public/v4/api/library/classes/browser.index.WebStore.html b/packages/tempo/public/v4/api/library/classes/browser.index.WebStore.html new file mode 100644 index 00000000..340adef9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/browser.index.WebStore.html @@ -0,0 +1,283 @@ +WebStore | Library API
                                            +
                                            Library API + +
                                              +
                                              +
                                              Preparing search index...
                                              +
                                              +
                                              +
                                              + +

                                              Class WebStore

                                              +
                                              +

                                              Wrapper around local / session Browser Storage. +Refactored for lazy-initialization to ensure side-effect free imports.

                                              +
                                              +
                                              +
                                              +
                                              const store = WebStore.local;
                                              store.set('user', { id: 1, name: 'Alice' });
                                              const user = store.get('user');
+
                                              + +
                                              +
                                              +
                                              +
                                              +
                                              Index
                                               +
                                              +
                                              + +
                                              constructor +
                                              +
                                              + +
                                              local +session +
                                              +
                                              + +
                                              clear +del +entries +from +get +keys +set +values +
                                              +
                                              + +
                                              +
                                              + +
                                                +
                                              • + +
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • storage: "local" | "session" = STORAGE.Local
                                                +

                                                Returns WebStore

                                              +
                                              + +
                                              +
                                              + +
                                                +
                                              • +
                                                get local(): WebStore
                                                +
                                                +

                                                Lazy getter for the localStorage wrapper instance.

                                                +
                                                +

                                                Returns WebStore

                                                The WebStore instance for localStorage

                                                +
                                              +
                                              + +
                                                +
                                              • +
                                                get session(): WebStore
                                                +
                                                +

                                                Lazy getter for the sessionStorage wrapper instance.

                                                +
                                                +

                                                Returns WebStore

                                                The WebStore instance for sessionStorage

                                                +
                                              +
                                              + +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Clear all items from this storage instance.

                                                +
                                                +

                                                Returns WebStore

                                                The WebStore instance for chaining

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Delete specific keys from storage.

                                                +
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • ...keys: PropertyKey[] +

                                                  The keys to remove

                                                  +
                                                +

                                                Returns WebStore

                                                The WebStore instance for chaining

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Get an array of [key, value] entries currently in storage.

                                                +
                                                +
                                                +

                                                Type Parameters

                                                +
                                                  +
                                                • T
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • ...keys: PropertyKey[] +

                                                  Optional keys to filter the entries by

                                                  +
                                                +

                                                Returns [PropertyKey, T][]

                                                An array of key-value tuples

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Populate the storage from an existing object map.

                                                +
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • store: Property<any> +

                                                  The object/dictionary to populate from

                                                  +
                                                +

                                                Returns WebStore

                                                The WebStore instance for chaining

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Retrieve a value from storage, optionally providing a default.

                                                +
                                                +
                                                +

                                                Type Parameters

                                                +
                                                  +
                                                • T
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • key: PropertyKey +

                                                  The property key to retrieve

                                                  +
                                                  • +
                                                • Optionaldflt: T +

                                                  An optional default value if the key does not exist

                                                  +
                                                +

                                                Returns T | null

                                                The parsed object from storage, or the default/null if not found

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Get an array of keys currently in storage. If specific keys are provided, filters by those.

                                                +
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • ...keys: PropertyKey[] +

                                                  Optional keys to filter by

                                                  +
                                                +

                                                Returns PropertyKey[]

                                                An array of string/symbol keys

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Store or merge a value into storage for a given key.

                                                +
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • Optionalkey: PropertyKey +

                                                  The property key to set. If nullish, clears the store.

                                                  +
                                                  • +
                                                • Optionalobj: unknown +

                                                  The value to store

                                                  +
                                                  • +
                                                • opt: { merge: boolean } = ... +

                                                  Options (merge behavior)

                                                  +
                                                +

                                                Returns WebStore

                                                The WebStore instance for chaining

                                                +
                                              +
                                              + +
                                                +
                                              • + +
                                                +

                                                Get an array of values currently in storage.

                                                +
                                                +
                                                +

                                                Type Parameters

                                                +
                                                  +
                                                • T
                                                +
                                                +

                                                Parameters

                                                +
                                                  +
                                                • ...keys: PropertyKey[] +

                                                  Optional keys to retrieve values for

                                                  +
                                                +

                                                Returns T[]

                                                An array of parsed values

                                                +
                                              +
                                              +
                                              +
                                              +
                                              +

                                              Settings

                                               +
                                              +
                                              Member Visibility +
                                                +
                                                • +
                                                • +
                                              +
                                              +
                                              +

                                              On This Page

                                               +
                                              +
                                              Constructors +
                                              +
                                              Accessors +
                                              +
                                              Methods +
                                              +
                                              + +
                                              +
                                              diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Aborter.html b/packages/tempo/public/v4/api/library/classes/common.index.Aborter.html new file mode 100644 index 00000000..93d821f9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Aborter.html @@ -0,0 +1,146 @@ +Aborter | Library API
                                              +
                                              Library API + +
                                                +
                                                +
                                                Preparing search index...
                                                +
                                                +
                                                +
                                                + +

                                                Class Aborter

                                                +
                                                +
                                                +

                                                Disposable AbortController implementing TC39 Disposable. +Automatically aborts the underlying signal upon scope exit via using.

                                                +
                                                +
                                                +

                                                Hierarchy

                                                +
                                                  +
                                                • AbortController +
                                                    +
                                                  • Aborter
                                                +
                                                +

                                                Implements

                                                +
                                                  +
                                                • Disposable
                                                +
                                                +
                                                +
                                                +
                                                Index
                                                 +
                                                +
                                                + +
                                                constructor +
                                                +
                                                + +
                                                signal +
                                                +
                                                + +
                                                [dispose] +abort +create +
                                                +
                                                + +
                                                +
                                                + +
                                                  +
                                                • + +
                                                  +

                                                  Returns Aborter

                                                +
                                                + +
                                                +
                                                + +
                                                signal: AbortSignal
                                                +

                                                The signal read-only property of the AbortController interface returns an AbortSignal object instance, which can be used to communicate with/abort an asynchronous operation as desired.

                                                +

                                                MDN Reference

                                                +
                                                +
                                                + +
                                                +
                                                + +
                                                  +
                                                • + +
                                                  +

                                                  TC39 explicit resource management hook. +Automatically aborts the controller when exiting scope via using.

                                                  +
                                                  +

                                                  Returns void

                                                +
                                                + +
                                                  +
                                                • + +
                                                  +

                                                  The abort() method of the AbortController interface aborts an asynchronous operation before it has completed. This is able to abort fetch requests, the consumption of any response bodies, or streams.

                                                  +

                                                  MDN Reference

                                                  +
                                                  +
                                                  +

                                                  Parameters

                                                  +
                                                    +
                                                  • Optionalreason: any
                                                  +

                                                  Returns void

                                                +
                                                + +
                                                  +
                                                • + +
                                                  +

                                                  Creates a new disposable Aborter controller.

                                                  +
                                                  +

                                                  Returns Aborter

                                                +
                                                +
                                                +
                                                +
                                                +

                                                Settings

                                                 +
                                                +
                                                Member Visibility +
                                                  +
                                                  • +
                                                  • +
                                                +
                                                +
                                                +

                                                On This Page

                                                 +
                                                Aborter +
                                                Constructors +
                                                +
                                                Properties +
                                                +
                                                Methods +
                                                +
                                                + +
                                                +
                                                diff --git a/packages/tempo/public/v4/api/library/classes/common.index.BoundedCache.html b/packages/tempo/public/v4/api/library/classes/common.index.BoundedCache.html new file mode 100644 index 00000000..a550f934 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.BoundedCache.html @@ -0,0 +1,535 @@ +BoundedCache | Library API
                                                +
                                                Library API + +
                                                  +
                                                  +
                                                  Preparing search index...
                                                  +
                                                  +
                                                  +
                                                  + +

                                                  Class BoundedCache<K, V>

                                                  +
                                                  +
                                                  +

                                                  High-performance Map implementation enforcing maximum capacity (LRU) and TTL eviction. +Supports static keys (immortal glossary definitions) and date-salt staleness purging.

                                                  +
                                                  +
                                                  +

                                                  Type Parameters

                                                  +
                                                    +
                                                  • K = string
                                                    • +
                                                  • V = string
                                                  +
                                                  +

                                                  Hierarchy

                                                  +
                                                    +
                                                  • Map<K, V> +
                                                      +
                                                    • BoundedCache
                                                  +
                                                  +
                                                  +
                                                  +
                                                  Index
                                                   +
                                                  +
                                                  + +
                                                  constructor +
                                                  +
                                                  + +
                                                  [toStringTag] +maxSize +ttl +[species] +
                                                  +
                                                  + +
                                                  isBoundedCache +size +
                                                  +
                                                  + +
                                                  [iterator] +clear +delete +deletePrefix +entries +evictExpired +forEach +get +getOrInsert +getOrInsertComputed +has +isStatic +keys +set +setStatic +toJSON +values +fromEntries +groupBy +
                                                  +
                                                  + +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Creates a bounded cache with configurable capacity and entry lifetime.

                                                    +
                                                    +
                                                    +

                                                    Type Parameters

                                                    +
                                                      +
                                                    • K = string
                                                      • +
                                                    • V = string
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • maxSize: number = 1000 +

                                                      Maximum number of non-static entries retained

                                                      +
                                                      • +
                                                    • ttl: number = ... +

                                                      Default time-to-live for entries in milliseconds

                                                      +
                                                    +

                                                    Returns BoundedCache<K, V>

                                                  +
                                                  + +
                                                  +
                                                  + +
                                                  "[toStringTag]": string
                                                  +
                                                  + +
                                                  maxSize: number
                                                  +
                                                  + +
                                                  ttl: number
                                                  +
                                                  + +
                                                  "[species]": MapConstructor
                                                  +
                                                  + +
                                                  +
                                                  + +
                                                    +
                                                  • +
                                                    get isBoundedCache(): boolean
                                                    +
                                                    +

                                                    Returns true to identify this instance as a BoundedCache.

                                                    +
                                                    +

                                                    Returns boolean

                                                  +
                                                  + +
                                                    +
                                                  • +
                                                    get size(): number
                                                    +
                                                    +

                                                    Returns the number of entries in the cache after evicting expired entries.

                                                    +
                                                    +

                                                    Returns number

                                                  +
                                                  + +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns an iterator of cache entries after evicting expired entries, making the cache iterable.

                                                    +
                                                    +

                                                    Returns MapIterator<[K, V]>

                                                    Iterator of [key, value] pairs

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Purges cache entries. +If count is specified, evicts up to count oldest non-static entries. +If omitted, clears all entries, including static entries.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • Optionalcount: number +

                                                      Optional number of entries to evict. If omitted, clears all entries.

                                                      +
                                                    +

                                                    Returns void

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Deletes a key from the cache, removing its expiration and static key markers.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K +

                                                      The cache key to delete

                                                      +
                                                    +

                                                    Returns boolean

                                                    True if the key was deleted, false if it did not exist

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Deletes all cache entries whose keys start with the specified prefix. +The prefix comparison is case-insensitive.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • prefix: string +

                                                      The prefix string to match against cache keys

                                                      +
                                                    +

                                                    Returns number

                                                    The number of entries deleted

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns an iterator of cache entries after evicting expired entries.

                                                    +
                                                    +

                                                    Returns MapIterator<[K, V]>

                                                    Iterator of [key, value] pairs

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Purges TTL-expired entries.

                                                    +
                                                    +

                                                    Returns void

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Executes a callback for each cache entry after evicting expired entries.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • callbackfn: (value: V, key: K, map: Map<K, V>) => void +

                                                      Function to execute for each entry

                                                      +
                                                      • +
                                                    • OptionalthisArg: any +

                                                      Optional value to use as this when executing the callback

                                                      +
                                                    +

                                                    Returns void

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Retrieves a value from the cache by key. Evaluates TTL expiration via #expires +specifically for the requested key, and updates LRU ordering by deleting and re-inserting +the key in the underlying Map. Leaves the expiration deadline unchanged.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K +

                                                      The cache key to retrieve

                                                      +
                                                    +

                                                    Returns V | undefined

                                                    The cached value, or undefined if not found or expired

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns a specified element from the Map object. +If no element is associated with the specified key, a new element with the value defaultValue will be inserted into the Map and returned.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K
                                                      • +
                                                    • defaultValue: V
                                                    +

                                                    Returns V

                                                    The element associated with the specified key, which will be defaultValue if no element previously existed.

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns a specified element from the Map object. +If no element is associated with the specified key, the result of passing the specified key to the callback function will be inserted into the Map and returned.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K
                                                      • +
                                                    • callback: (key: K) => V
                                                    +

                                                    Returns V

                                                    The element associated with the specific key, which will be the newly computed value if no element previously existed.

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Checks if a key exists in the cache and is not expired. +Automatically evicts expired entries on access.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K +

                                                      The cache key to check

                                                      +
                                                    +

                                                    Returns boolean

                                                    True if the key exists and is not expired, false otherwise

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Check if a key is a static key.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K
                                                    +

                                                    Returns boolean

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns an iterator of cache keys after evicting expired entries.

                                                    +
                                                    +

                                                    Returns MapIterator<K>

                                                    Iterator of cache keys

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Sets a key-value pair in the cache, enforcing LRU eviction. +If finite-TTL is configured, entries retain their original absolute expiration deadline +unless an explicit ttl override is passed. +If the cache exceeds maxSize, the oldest non-static entry is removed.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K +

                                                      The cache key to set

                                                      +
                                                      • +
                                                    • value: V +

                                                      The value to store

                                                      +
                                                      • +
                                                    • Optionalttl: number +

                                                      Optional custom time-to-live in milliseconds for this specific entry

                                                      +
                                                    +

                                                    Returns this

                                                    This cache instance for chaining

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Register an immortal static key (e.g. business glossary term). +Static keys bypass TTL expiration and LRU capacity eviction.

                                                    +
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • key: K
                                                      • +
                                                    • value: V
                                                    +

                                                    Returns this

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns a plain key-value object of all active non-expired cache entries. +Filters out non-string keys to prevent lossy key conversions or collisions (e.g. numeric 1 vs string "1").

                                                    +
                                                    +

                                                    Returns Record<string, V>

                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Returns an iterator of cache values after evicting expired entries.

                                                    +
                                                    +

                                                    Returns MapIterator<V>

                                                    Iterator of cache values

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Creates a BoundedCache from an iterable of key-value pairs.

                                                    +
                                                    +
                                                    +

                                                    Type Parameters

                                                    +
                                                      +
                                                    • K = string
                                                      • +
                                                    • V = string
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • entries: Iterable<readonly [K, V]> +

                                                      Iterable of [key, value] pairs to populate the cache

                                                      +
                                                      • +
                                                    • maxSize: number = 1000 +

                                                      Maximum number of entries (default: 1000)

                                                      +
                                                      • +
                                                    • ttl: number = ... +

                                                      Time-to-live in milliseconds (default: 24 hours)

                                                      +
                                                    +

                                                    Returns BoundedCache<K, V>

                                                    A new BoundedCache instance

                                                    +
                                                  +
                                                  + +
                                                    +
                                                  • + +
                                                    +

                                                    Groups members of an iterable according to the return value of the passed callback.

                                                    +
                                                    +
                                                    +

                                                    Type Parameters

                                                    +
                                                      +
                                                    • K
                                                      • +
                                                    • T
                                                    +
                                                    +

                                                    Parameters

                                                    +
                                                      +
                                                    • items: Iterable<T> +

                                                      An iterable.

                                                      +
                                                      • +
                                                    • keySelector: (item: T, index: number) => K +

                                                      A callback which will be invoked for each item in items.

                                                      +
                                                    +

                                                    Returns Map<K, T[]>

                                                  +
                                                  +
                                                  +
                                                  +
                                                  +

                                                  Settings

                                                   +
                                                  +
                                                  Member Visibility +
                                                    +
                                                    • +
                                                    • +
                                                  +
                                                  +
                                                  +

                                                  On This Page

                                                   +
                                                  BoundedCache +
                                                  Constructors +
                                                  +
                                                  Properties +
                                                  +
                                                  Accessors +
                                                  +
                                                  Methods +
                                                  +
                                                  + +
                                                  +
                                                  diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Enumify.html b/packages/tempo/public/v4/api/library/classes/common.index.Enumify.html new file mode 100644 index 00000000..7f97c897 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Enumify.html @@ -0,0 +1,67 @@ +Enumify | Library API
                                                  +
                                                  Library API + +
                                                    +
                                                    +
                                                    Preparing search index...
                                                    +
                                                    +
                                                    +
                                                    + +

                                                    Class Enumify

                                                    +
                                                    +

                                                    create an entry in the Serialization Registry to describe how to rebuild an Enum

                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    Index
                                                     +
                                                    +
                                                    + +
                                                    constructor +
                                                    +
                                                    + +
                                                    +
                                                    + +
                                                      +
                                                    • + +
                                                      +
                                                      +

                                                      Parameters

                                                      +
                                                      +

                                                      Returns Enumify

                                                    +
                                                    +
                                                    +
                                                    +
                                                    +

                                                    Settings

                                                     +
                                                    +
                                                    Member Visibility +
                                                      +
                                                      • +
                                                      • +
                                                    +
                                                    +
                                                    +

                                                    On This Page

                                                     +
                                                    +
                                                    Constructors +
                                                    +
                                                    + +
                                                    +
                                                    diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Finalizer.html b/packages/tempo/public/v4/api/library/classes/common.index.Finalizer.html new file mode 100644 index 00000000..7ab9fd94 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Finalizer.html @@ -0,0 +1,174 @@ +Finalizer | Library API
                                                    +
                                                    Library API + +
                                                      +
                                                      +
                                                      Preparing search index...
                                                      +
                                                      +
                                                      +
                                                      + +

                                                      Class Finalizer<T>

                                                      +
                                                      +
                                                      +

                                                      Wrapper around FinalizationRegistry providing typed, safe resource cleanup +callbacks triggered when objects are reclaimed by the Garbage Collector.

                                                      +
                                                      +
                                                      +

                                                      Type Parameters

                                                      +
                                                        +
                                                      • T = void
                                                      +
                                                      +
                                                      +
                                                      +
                                                      Index
                                                       +
                                                      +
                                                      + +
                                                      constructor +
                                                      +
                                                      + +
                                                      isFinalizer +
                                                      +
                                                      + +
                                                      register +unregister +register +
                                                      +
                                                      + +
                                                      +
                                                      + +
                                                        +
                                                      • + +
                                                        +
                                                        +

                                                        Type Parameters

                                                        +
                                                          +
                                                        • T = void
                                                        +
                                                        +

                                                        Parameters

                                                        +
                                                          +
                                                        • callback: (heldValue: T) => void
                                                        +

                                                        Returns Finalizer<T>

                                                      +
                                                      + +
                                                      +
                                                      + +
                                                        +
                                                      • +
                                                        get isFinalizer(): boolean
                                                        +
                                                        +

                                                        Returns true to identify this instance as a Finalizer.

                                                        +
                                                        +

                                                        Returns boolean

                                                      +
                                                      + +
                                                      +
                                                      + +
                                                        +
                                                      • + +
                                                        +

                                                        Registers a target object with a held value and optional unregister token.

                                                        +
                                                        +
                                                        +

                                                        Parameters

                                                        +
                                                          +
                                                        • target: WeakKey +

                                                          The object to observe for garbage collection

                                                          +
                                                          • +
                                                        • heldValue: T +

                                                          The value passed to the cleanup callback

                                                          +
                                                          • +
                                                        • OptionalunregisterToken: WeakKey +

                                                          Optional token to unregister the callback prior to GC

                                                          +
                                                        +

                                                        Returns void

                                                      +
                                                      + +
                                                        +
                                                      • + +
                                                        +

                                                        Unregisters a previously registered finalizer callback.

                                                        +
                                                        +
                                                        +

                                                        Parameters

                                                        +
                                                          +
                                                        • unregisterToken: WeakKey +

                                                          The token used during registration

                                                          +
                                                        +

                                                        Returns boolean

                                                        True if a registration was found and removed

                                                        +
                                                      +
                                                      + +
                                                        +
                                                      • + +
                                                        +

                                                        Registers an object to execute a cleanup callback when garbage collected. +Returns a function to cancel the finalizer registration prior to GC.

                                                        +
                                                        +
                                                        +

                                                        Parameters

                                                        +
                                                          +
                                                        • target: WeakKey +

                                                          The target object to observe for garbage collection

                                                          +
                                                          • +
                                                        • cleanup: () => void +

                                                          The teardown callback to execute upon GC reclamation

                                                          +
                                                          • +
                                                        • OptionalunregisterToken: WeakKey +

                                                          Optional token used for unregistration (defaults to a unique token object)

                                                          +
                                                        +

                                                        Returns () => boolean

                                                        A teardown function that cancels the finalization registration without retaining target

                                                        +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +

                                                      Settings

                                                       +
                                                      +
                                                      Member Visibility +
                                                        +
                                                        • +
                                                        • +
                                                      +
                                                      +
                                                      +

                                                      On This Page

                                                       +
                                                      Finalizer +
                                                      Constructors +
                                                      +
                                                      Accessors +
                                                      +
                                                      Methods +
                                                      +
                                                      + +
                                                      +
                                                      diff --git a/packages/tempo/public/v4/api/library/classes/common.index.HttpError.html b/packages/tempo/public/v4/api/library/classes/common.index.HttpError.html new file mode 100644 index 00000000..432ead73 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.HttpError.html @@ -0,0 +1,220 @@ +HttpError | Library API
                                                      +
                                                      Library API + +
                                                        +
                                                        +
                                                        Preparing search index...
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        Class HttpError

                                                        +
                                                        +

                                                        Hierarchy

                                                        +
                                                          +
                                                        • Error +
                                                            +
                                                          • HttpError
                                                        +
                                                        +
                                                        +
                                                        +
                                                        Index
                                                         +
                                                        +
                                                        + +
                                                        constructor +
                                                        +
                                                        + +
                                                        body +cause? +message +name +stack? +status +statusText +stackTraceLimit +
                                                        +
                                                        + +
                                                        captureStackTrace +isError +prepareStackTrace +
                                                        +
                                                        + +
                                                        +
                                                        + +
                                                          +
                                                        • + +
                                                          +
                                                          +

                                                          Parameters

                                                          +
                                                            +
                                                          • status: number
                                                            • +
                                                          • statusText: string
                                                            • +
                                                          • body: any
                                                          +

                                                          Returns HttpError

                                                        +
                                                        + +
                                                        +
                                                        +

                                                        body

                                                        +
                                                        body: any
                                                        +
                                                        + +
                                                        cause?: unknown
                                                        +
                                                        + +
                                                        message: string
                                                        +
                                                        + +
                                                        name: string
                                                        +
                                                        + +
                                                        stack?: string
                                                        +
                                                        + +
                                                        status: number
                                                        +
                                                        + +
                                                        statusText: string
                                                        +
                                                        + +
                                                        stackTraceLimit: number
                                                        +

                                                        The Error.stackTraceLimit property specifies the number of stack frames +collected by a stack trace (whether generated by new Error().stack or +Error.captureStackTrace(obj)).

                                                        +

                                                        The default value is 10 but may be set to any valid JavaScript number. Changes +will affect any stack trace captured after the value has been changed.

                                                        +

                                                        If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.

                                                        +
                                                        +
                                                        + +
                                                        +
                                                        + +
                                                          +
                                                        • + +
                                                          +

                                                          Creates a .stack property on targetObject, which when accessed returns +a string representing the location in the code at which +Error.captureStackTrace() was called.

                                                          +
                                                          const myObject = {};
                                                          Error.captureStackTrace(myObject);
                                                          myObject.stack;  // Similar to `new Error().stack`
+
                                                          + +

                                                          The first line of the trace will be prefixed with +${myObject.name}: ${myObject.message}.

                                                          +

                                                          The optional constructorOpt argument accepts a function. If given, all frames +above constructorOpt, including constructorOpt, will be omitted from the +generated stack trace.

                                                          +

                                                          The constructorOpt argument is useful for hiding implementation +details of error generation from the user. For instance:

                                                          +
                                                          function a() {
                                                            b();
                                                          }

                                                          function b() {
                                                            c();
                                                          }

                                                          function c() {
                                                            // Create an error without stack trace to avoid calculating the stack trace twice.
                                                            const { stackTraceLimit } = Error;
                                                            Error.stackTraceLimit = 0;
                                                            const error = new Error();
                                                            Error.stackTraceLimit = stackTraceLimit;

                                                            // Capture the stack trace above function b
                                                            Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
                                                            throw error;
                                                          }

                                                          a();
+
                                                          + +
                                                          +
                                                          +

                                                          Parameters

                                                          +
                                                            +
                                                          • targetObject: object
                                                            • +
                                                          • OptionalconstructorOpt: Function
                                                          +

                                                          Returns void

                                                        +
                                                        + +
                                                          +
                                                        • + +
                                                          +

                                                          Indicates whether the argument provided is a built-in Error instance or not.

                                                          +
                                                          +
                                                          +

                                                          Parameters

                                                          +
                                                            +
                                                          • error: unknown
                                                          +

                                                          Returns error is Error

                                                        +
                                                        + +
                                                          +
                                                        • + +
                                                          +
                                                          +

                                                          Parameters

                                                          +
                                                            +
                                                          • err: Error
                                                            • +
                                                          • stackTraces: CallSite[]
                                                          +

                                                          Returns any

                                                          +
                                                          +
                                                          +

                                                          https://v8.dev/docs/stack-trace-api#customizing-stack-traces

                                                          +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +

                                                        Settings

                                                         +
                                                        +
                                                        Member Visibility +
                                                          +
                                                          • +
                                                          • +
                                                        +
                                                        +
                                                        +

                                                        On This Page

                                                         +
                                                        +
                                                        Constructors +
                                                        +
                                                        Properties +
                                                        +
                                                        Methods +
                                                        +
                                                        + +
                                                        +
                                                        diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Interval.html b/packages/tempo/public/v4/api/library/classes/common.index.Interval.html new file mode 100644 index 00000000..c5ede87f --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Interval.html @@ -0,0 +1,228 @@ +Interval | Library API
                                                        +
                                                        Library API + +
                                                          +
                                                          +
                                                          Preparing search index...
                                                          +
                                                          +
                                                          +
                                                          + +

                                                          Class Interval<T>

                                                          +
                                                          +

                                                          Represents a continuous span of time with optional start and end boundaries, supporting set operations.

                                                          +
                                                          +
                                                          +

                                                          Type Parameters

                                                          +
                                                          +
                                                          +
                                                          +
                                                          +
                                                          Index
                                                           +
                                                          +
                                                          + +
                                                          constructor +
                                                          +
                                                          + +
                                                          end +endNs +start +startNs +
                                                          +
                                                          + +
                                                          abuts +contains +intersection +overlaps +union +
                                                          +
                                                          + +
                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +
                                                            +

                                                            Type Parameters

                                                            +
                                                              +
                                                            • T extends unknown = any
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                              +
                                                            • start: T | null
                                                              • +
                                                            • end: T | null
                                                            +

                                                            Returns Interval<T>

                                                          +
                                                          + +
                                                          +
                                                          + +
                                                            +
                                                          • +
                                                            get end(): T | null
                                                            +
                                                            +

                                                            The end point of the interval, or null for unbounded end

                                                            +
                                                            +

                                                            Returns T | null

                                                          +
                                                          + +
                                                            +
                                                          • +
                                                            get endNs(): number | bigint
                                                            +
                                                            +

                                                            The end time in nanoseconds since epoch, or Infinity for unbounded end

                                                            +
                                                            +

                                                            Returns number | bigint

                                                          +
                                                          + +
                                                            +
                                                          • +
                                                            get start(): T | null
                                                            +
                                                            +

                                                            The start point of the interval, or null for unbounded start

                                                            +
                                                            +

                                                            Returns T | null

                                                          +
                                                          + +
                                                            +
                                                          • +
                                                            get startNs(): number | bigint
                                                            +
                                                            +

                                                            The start time in nanoseconds since epoch, or -Infinity for unbounded start

                                                            +
                                                            +

                                                            Returns number | bigint

                                                          +
                                                          + +
                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +

                                                            Returns true if this interval starts exactly when the other ends, or vice versa

                                                            +
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                            +

                                                            Returns boolean

                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +

                                                            Returns true if the specified temporal point is within this interval

                                                            +
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                              +
                                                            • point: any
                                                            +

                                                            Returns boolean

                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +

                                                            Returns the intersection of this interval and another, or null if they do not overlap

                                                            +
                                                            +
                                                            +

                                                            Type Parameters

                                                            +
                                                              +
                                                            • U extends unknown = T
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                            +

                                                            Returns Interval<T | U> | null

                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +

                                                            Returns true if this interval overlaps with another interval

                                                            +
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                            +

                                                            Returns boolean

                                                          +
                                                          + +
                                                            +
                                                          • + +
                                                            +

                                                            Returns the union of this interval and another, or null if they do not overlap/abut

                                                            +
                                                            +
                                                            +

                                                            Type Parameters

                                                            +
                                                              +
                                                            • U extends unknown = T
                                                            +
                                                            +

                                                            Parameters

                                                            +
                                                            +

                                                            Returns Interval<T | U> | null

                                                          +
                                                          +
                                                          +
                                                          +
                                                          +

                                                          Settings

                                                           +
                                                          +
                                                          Member Visibility +
                                                            +
                                                            • +
                                                            • +
                                                          +
                                                          +
                                                          +

                                                          On This Page

                                                           +
                                                          +
                                                          Constructors +
                                                          +
                                                          Accessors +
                                                          +
                                                          Methods +
                                                          +
                                                          + +
                                                          +
                                                          diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Logger.html b/packages/tempo/public/v4/api/library/classes/common.index.Logger.html new file mode 100644 index 00000000..44ef610c --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Logger.html @@ -0,0 +1,196 @@ +Logger | Library API
                                                          +
                                                          Library API + +
                                                            +
                                                            +
                                                            Preparing search index...
                                                            +
                                                            +
                                                            +
                                                            + +

                                                            Class Logger

                                                            +
                                                            +

                                                            A lightweight, dependency-free namespaced logger. +Decoupled from error handling and boundaries, utilizing standard console methods. +Supports configurable log levels and structured object output.

                                                            +
                                                            +
                                                            +
                                                            +
                                                            const log = new Logger('App', LOG.Debug);
                                                            log.info('Started'); // [App] Started
+
                                                            + +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            Index
                                                             +
                                                            +
                                                            + +
                                                            constructor +
                                                            +
                                                            + +
                                                            level +
                                                            +
                                                            + +
                                                            debug +error +info +log +trace +warn +
                                                            +
                                                            + +
                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • namespace: string
                                                                • +
                                                              • level: 0 | 1 | 2 | 3 | 4 | 5 = LOG.Info
                                                              +

                                                              Returns Logger

                                                            +
                                                            + +
                                                            +
                                                            + +
                                                            level: 0 | 1 | 2 | 3 | 4 | 5
                                                            +

                                                            The current verbosity level

                                                            +
                                                            +
                                                            + +
                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.debug

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.error

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.info

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.log

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.trace

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            + +
                                                              +
                                                            • + +
                                                              +

                                                              console.warn

                                                              +
                                                              +
                                                              +

                                                              Parameters

                                                              +
                                                                +
                                                              • ...msg: any[]
                                                              +

                                                              Returns void

                                                            +
                                                            +
                                                            +
                                                            +
                                                            +

                                                            Settings

                                                             +
                                                            +
                                                            Member Visibility +
                                                              +
                                                              • +
                                                              • +
                                                            +
                                                            +
                                                            +

                                                            On This Page

                                                             +
                                                            +
                                                            Constructors +
                                                            +
                                                            Properties +
                                                            +
                                                            Methods +
                                                            +
                                                            + +
                                                            +
                                                            diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Pledge.html b/packages/tempo/public/v4/api/library/classes/common.index.Pledge.html new file mode 100644 index 00000000..46da4889 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Pledge.html @@ -0,0 +1,311 @@ +Pledge | Library API
                                                            +
                                                            Library API + +
                                                              +
                                                              +
                                                              Preparing search index...
                                                              +
                                                              +
                                                              +
                                                              + +

                                                              Class Pledge<T>

                                                              +
                                                              +

                                                              A lightweight wrapper around Promises (utilizing Promise.withResolvers) +that exposes resolve, reject, and state-tracking methods. +Useful for deferred execution and managing asynchronous lifecycles.

                                                              +
                                                              +
                                                              +
                                                              +
                                                              const p = new Pledge`<string>`('MyPledge');
                                                              p.resolve('Success!');
                                                              await p.promise; // 'Success!'
+
                                                              + +
                                                              +
                                                              +

                                                              Type Parameters

                                                              +
                                                                +
                                                              • T
                                                              +
                                                              +
                                                              +
                                                              +
                                                              Index
                                                               +
                                                              +
                                                              + +
                                                              constructor +
                                                              +
                                                              + +
                                                              isPending +isRejected +isResolved +isSettled +promise +state +status +STATE +status +
                                                              +
                                                              + +
                                                              [dispose] +reject +resolve +then +toString +[dispose] +init +
                                                              +
                                                              + +
                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Creates a new Pledge instance.

                                                                +
                                                                +
                                                                +

                                                                Type Parameters

                                                                +
                                                                  +
                                                                • T
                                                                +
                                                                +

                                                                Parameters

                                                                +
                                                                  +
                                                                • Optionalarg: string | Pledge.Constructor +

                                                                  An optional configuration object or string tag

                                                                  +
                                                                +

                                                                Returns Pledge<T>

                                                              +
                                                              + +
                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get isPending(): boolean
                                                                +
                                                                +

                                                                Returns boolean

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get isRejected(): boolean
                                                                +
                                                                +

                                                                Returns boolean

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get isResolved(): boolean
                                                                +
                                                                +

                                                                Returns boolean

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get isSettled(): boolean
                                                                +
                                                                +

                                                                Returns boolean

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get promise(): Promise<T>
                                                                +
                                                                +

                                                                Returns Promise<T>

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get state(): string | undefined
                                                                +
                                                                +

                                                                Returns string | undefined

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get status(): Record<string, any>
                                                                +
                                                                +

                                                                Returns Record<string, any>

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get STATE(): SecureObject<
                                                                    { Pending: symbol; Rejected: symbol; Resolved: symbol },
                                                                >
                                                                +
                                                                +

                                                                Returns SecureObject<{ Pending: symbol; Rejected: symbol; Resolved: symbol }>

                                                              +
                                                              + +
                                                                +
                                                              • +
                                                                get status(): Status<typeof Pledge>
                                                                +
                                                                +

                                                                Returns Status<typeof Pledge>

                                                              +
                                                              + +
                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Returns void

                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Rejects the underlying promise.

                                                                +
                                                                +
                                                                +

                                                                Parameters

                                                                +
                                                                  +
                                                                • error: any +

                                                                  The reason for rejection

                                                                  +
                                                                +

                                                                Returns Promise<T>

                                                                The internal promise

                                                                +
                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Resolves the underlying promise.

                                                                +
                                                                +
                                                                +

                                                                Parameters

                                                                +
                                                                  +
                                                                • value: T +

                                                                  The value to resolve the promise with

                                                                  +
                                                                +

                                                                Returns Promise<T>

                                                                The internal promise

                                                                +
                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Makes the Pledge 'then-able', allowing it to be directly awaited +or chained like a standard Promise.

                                                                +
                                                                +
                                                                +

                                                                Type Parameters

                                                                +
                                                                  +
                                                                • TResult1 = T
                                                                  • +
                                                                • TResult2 = never
                                                                +
                                                                +

                                                                Parameters

                                                                +
                                                                  +
                                                                • Optionalonfulfilled: ((value: T) => TResult1 | PromiseLike<TResult1>) | null +

                                                                  Callback for when the pledge resolves

                                                                  +
                                                                  • +
                                                                • Optionalonrejected: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null +

                                                                  Callback for when the pledge rejects

                                                                  +
                                                                +

                                                                Returns Promise<TResult1 | TResult2>

                                                                A new promise representing the chained execution

                                                                +
                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Returns string

                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                reset static defaults

                                                                +
                                                                +

                                                                Returns void

                                                              +
                                                              + +
                                                                +
                                                              • + +
                                                                +

                                                                Initializes global defaults for all future Pledge instances.

                                                                +
                                                                +
                                                                +

                                                                Parameters

                                                                +
                                                                +

                                                                Returns Status<typeof Pledge>

                                                                The updated static status configuration

                                                                +
                                                              +
                                                              +
                                                              +
                                                              +
                                                              +

                                                              Settings

                                                               +
                                                              +
                                                              Member Visibility +
                                                                +
                                                                • +
                                                                • +
                                                              +
                                                              +
                                                              +

                                                              On This Page

                                                               +
                                                              +
                                                              Constructors +
                                                              +
                                                              Accessors +
                                                              +
                                                              Methods +
                                                              +
                                                              + +
                                                              +
                                                              diff --git a/packages/tempo/public/v4/api/library/classes/common.index.Reactive.html b/packages/tempo/public/v4/api/library/classes/common.index.Reactive.html new file mode 100644 index 00000000..4344f1f4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.Reactive.html @@ -0,0 +1,585 @@ +Reactive | Library API
                                                              +
                                                              Library API + +
                                                                +
                                                                +
                                                                Preparing search index...
                                                                +
                                                                +
                                                                +
                                                                + +

                                                                Class Reactive<T>

                                                                +
                                                                +
                                                                +

                                                                Universal, zero-dependency async reactive stream combining push-based event emission +and pull-based AsyncIterable iteration with native TC39 resource management +(using / await using) and Garbage Collection finalization safety.

                                                                +
                                                                +
                                                                +
                                                                +
                                                                const stream = new Reactive<number>();

                                                                // Consumer 1: Pull-mode
                                                                queueMicrotask(async () => {
                                                                  const val = await stream.pull(); // 42
                                                                });

                                                                // Producer: Push-mode
                                                                stream.push(42);
+
                                                                + +
                                                                +
                                                                +

                                                                Type Parameters

                                                                +
                                                                  +
                                                                • T
                                                                +
                                                                +

                                                                Implements

                                                                +
                                                                  +
                                                                • AsyncIterable<T>
                                                                  • +
                                                                • AsyncIterator<T, void, unknown>
                                                                  • +
                                                                • Disposable
                                                                  • +
                                                                • AsyncDisposable
                                                                +
                                                                +
                                                                +
                                                                +
                                                                Index
                                                                 +
                                                                +
                                                                + +
                                                                constructor +
                                                                +
                                                                + +
                                                                isReactive +state +
                                                                +
                                                                + +
                                                                [asyncDispose] +[asyncIterator] +[dispose] +broadcast +cast +complete +emit +error +next +off +on +once +pull +push +return +stop +throw +until +from +
                                                                +
                                                                + +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +
                                                                  +

                                                                  Type Parameters

                                                                  +
                                                                    +
                                                                  • T
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                  +

                                                                  Returns Reactive<T>

                                                                +
                                                                + +
                                                                +
                                                                + +
                                                                  +
                                                                • +
                                                                  get isReactive(): boolean
                                                                  +
                                                                  +

                                                                  Identifies this object as a Reactive instance

                                                                  +
                                                                  +

                                                                  Returns boolean

                                                                +
                                                                + +
                                                                  +
                                                                • +
                                                                  get state(): State
                                                                  +
                                                                  +

                                                                  Returns the operational state of this stream

                                                                  +
                                                                  +

                                                                  Returns State

                                                                +
                                                                + +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Asynchronous disposal hook (await using stream = new Reactive())

                                                                  +
                                                                  +

                                                                  Returns Promise<void>

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Returns this instance as an AsyncIterator

                                                                  +
                                                                  +

                                                                  Returns AsyncIterator<T, void, unknown>

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Synchronous disposal hook (using stream = new Reactive())

                                                                  +
                                                                  +

                                                                  Returns void

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Broadcasts a value to ALL pending pull waiters and push listeners simultaneously.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • value: T +

                                                                    The value to broadcast

                                                                    +
                                                                  +

                                                                  Returns boolean

                                                                  True if the value was successfully emitted; false if completed or inactive

                                                                  + +
                                                                  +
                                                                  +

                                                                  cast

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Casts a value to ALL pending pull waiters and push listeners simultaneously (multicast fan-out).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • value: T +

                                                                    The value to cast across all consumers

                                                                    +
                                                                  +

                                                                  Returns boolean

                                                                  True if the value was successfully emitted; false if completed or inactive

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Completes and closes the reactive stream.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • OptionalterminalValue: T +

                                                                    Optional final value to emit prior to closing

                                                                    +
                                                                  +

                                                                  Returns void

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Emits a value to active pull-mode consumers or push-mode listeners.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • value: T +

                                                                    The value to emit

                                                                    +
                                                                  +

                                                                  Returns boolean

                                                                  True if the value was successfully emitted; false if completed or inactive

                                                                  + +
                                                                  +
                                                                  +

                                                                  push

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Emits an error to registered error listeners or rejects pending pull consumers.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • err: Error +

                                                                    The error instance to dispatch

                                                                    +
                                                                  +

                                                                  Returns void

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Advances the async iterator to the next available item.

                                                                  +
                                                                  +

                                                                  Returns Promise<IteratorResult<T, void>>

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Unsubscribes a previously registered event listener.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: EventType +

                                                                    Event name

                                                                    +
                                                                    • +
                                                                  • listener: Function +

                                                                    Listener function to remove

                                                                    +
                                                                  +

                                                                  Returns this

                                                                  this for chaining

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Subscribes to stream events with optional AbortSignal and once configuration. +Returns a disposable Subscription handle for explicit resource management (using sub = ...).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: "data" +

                                                                    'data', 'error', 'end', or 'stop'

                                                                    +
                                                                    • +
                                                                  • listener: Listener<T> +

                                                                    Callback to invoke when the event fires

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: SubscriptionOptions +

                                                                    Subscription options (AbortSignal, once)

                                                                    +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                  • +
                                                                • + +
                                                                  +

                                                                  Subscribes to stream events with optional AbortSignal and once configuration. +Returns a disposable Subscription handle for explicit resource management (using sub = ...).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: "error" +

                                                                    'data', 'error', 'end', or 'stop'

                                                                    +
                                                                    • +
                                                                  • listener: ErrorListener +

                                                                    Callback to invoke when the event fires

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: SubscriptionOptions +

                                                                    Subscription options (AbortSignal, once)

                                                                    +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                  • +
                                                                • + +
                                                                  +

                                                                  Subscribes to stream events with optional AbortSignal and once configuration. +Returns a disposable Subscription handle for explicit resource management (using sub = ...).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: "end" | "stop" +

                                                                    'data', 'error', 'end', or 'stop'

                                                                    +
                                                                    • +
                                                                  • listener: EndListener +

                                                                    Callback to invoke when the event fires

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: SubscriptionOptions +

                                                                    Subscription options (AbortSignal, once)

                                                                    +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Subscribes to a single event occurrence.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: "data" +

                                                                    Event name

                                                                    +
                                                                    • +
                                                                  • listener: Listener<T> +

                                                                    Callback function

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: Omit<SubscriptionOptions, "once"> +

                                                                    Subscription options

                                                                    +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                  • +
                                                                • + +
                                                                  +

                                                                  Subscribes to a single event occurrence.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                  • +
                                                                • + +
                                                                  +

                                                                  Subscribes to a single event occurrence.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • event: "end" | "stop" +

                                                                    Event name

                                                                    +
                                                                    • +
                                                                  • listener: EndListener +

                                                                    Callback function

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: Omit<SubscriptionOptions, "once"> +

                                                                    Subscription options

                                                                    +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  A disposable Subscription handle

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Pulls the next available value directly from the stream.

                                                                  +
                                                                  +

                                                                  Returns Promise<T | undefined>

                                                                  A promise resolving to the next item T, or undefined if completed

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Pushes data into the stream (producer mode) or registers a listener (consumer mode).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • value: T
                                                                  +

                                                                  Returns boolean

                                                                  True if the value was successfully emitted; false if completed or inactive; Reactive.Subscription if registering a listener

                                                                  +
                                                                  • +
                                                                • + +
                                                                  +

                                                                  Pushes data into the stream (producer mode) or registers a listener (consumer mode).

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                  +

                                                                  Returns ReactiveSubscription

                                                                  True if the value was successfully emitted; false if completed or inactive; Reactive.Subscription if registering a listener

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Closes the async iterator and marks the stream as completed.

                                                                  +
                                                                  +

                                                                  Returns Promise<IteratorResult<T, void>>

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Alias for complete().

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • OptionalterminalValue: T +

                                                                    Optional final value to emit prior to closing

                                                                    +
                                                                  +

                                                                  Returns void

                                                                  +
                                                                  +
                                                                  +

                                                                  complete

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Throws an error into the stream, rejecting pending waiters and stopping the stream.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • Optionalerr: any
                                                                  +

                                                                  Returns Promise<IteratorResult<T, void>>

                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Returns a new Reactive stream that mirrors the source but completes automatically +when the given notifier (AbortSignal, Promise, or trigger Reactive stream) fires.

                                                                  +
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • notifier: Promise<any> | AbortSignal | Reactive<any> +

                                                                    An AbortSignal, Promise, or Reactive stream bounding this stream's lifecycle.

                                                                    +
                                                                  +

                                                                  Returns Reactive<T>

                                                                  A new Reactive stream

                                                                  +
                                                                +
                                                                + +
                                                                  +
                                                                • + +
                                                                  +

                                                                  Creates a Reactive stream from an iterable, async iterable, or Promise.

                                                                  +
                                                                  +
                                                                  +

                                                                  Type Parameters

                                                                  +
                                                                    +
                                                                  • V
                                                                  +
                                                                  +

                                                                  Parameters

                                                                  +
                                                                    +
                                                                  • source: Iterable<V, any, any> | AsyncIterable<V, any, any> | Promise<V> +

                                                                    The source collection or promise

                                                                    +
                                                                    • +
                                                                  • Optionaloptions: Options<V> +

                                                                    Optional configuration options

                                                                    +
                                                                  +

                                                                  Returns Reactive<V>

                                                                  A Reactive stream instance

                                                                  +
                                                                +
                                                                +
                                                                +
                                                                +
                                                                +

                                                                Settings

                                                                 +
                                                                +
                                                                Member Visibility +
                                                                  +
                                                                  • +
                                                                  • +
                                                                +
                                                                +
                                                                +

                                                                On This Page

                                                                 +
                                                                Reactive +
                                                                Constructors +
                                                                +
                                                                Accessors +
                                                                +
                                                                Methods +
                                                                +
                                                                + +
                                                                +
                                                                diff --git a/packages/tempo/public/v4/api/library/classes/common.index.ScopedSet.html b/packages/tempo/public/v4/api/library/classes/common.index.ScopedSet.html new file mode 100644 index 00000000..5fabaaf5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.ScopedSet.html @@ -0,0 +1,231 @@ +ScopedSet | Library API
                                                                +
                                                                Library API + +
                                                                  +
                                                                  +
                                                                  Preparing search index...
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  Class ScopedSet<T>

                                                                  +
                                                                  +

                                                                  A lightweight Set-compatible container that delegates has() lookups to a +parent Set/ScopedSet, but confines add() writes to its own-local storage.

                                                                  +

                                                                  This mirrors JavaScript prototype-chain semantics:

                                                                  +
                                                                    +
                                                                  • Values added to the parent are visible to the child via has().
                                                                    • +
                                                                  • Values added to the child are isolated from the parent; +the parent Set is never modified by child add() calls.
                                                                    • +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  const global = new Set(['a']);
                                                                  const sandbox = new ScopedSet(global);
                                                                  sandbox.has('a');   // true  (inherited from parent)
                                                                  sandbox.add('b');
                                                                  sandbox.has('b');   // true  (own-local)
                                                                  global.has('b');    // false (never written to parent)
+
                                                                  + +
                                                                  +
                                                                  +

                                                                  Type Parameters

                                                                  +
                                                                    +
                                                                  • T
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  Index
                                                                   +
                                                                  +
                                                                  + +
                                                                  constructor +
                                                                  +
                                                                  + +
                                                                  size +
                                                                  +
                                                                  + +
                                                                  [iterator] +add +clear +delete +entries +forEach +has +keys +values +
                                                                  +
                                                                  + +
                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +
                                                                    +

                                                                    Type Parameters

                                                                    +
                                                                      +
                                                                    • T
                                                                    +
                                                                    +

                                                                    Parameters

                                                                    +
                                                                    +

                                                                    Returns ScopedSet<T>

                                                                  +
                                                                  + +
                                                                  +
                                                                  + +
                                                                    +
                                                                  • +
                                                                    get size(): number
                                                                    +
                                                                    +

                                                                    Number of own-local entries (does not include parent entries).

                                                                    +
                                                                    +

                                                                    Returns number

                                                                  +
                                                                  + +
                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Returns IterableIterator<T>

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Adds to own-local storage only — never propagates to the parent.

                                                                    +
                                                                    +
                                                                    +

                                                                    Parameters

                                                                    +
                                                                      +
                                                                    • value: T
                                                                    +

                                                                    Returns this

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Clears own-local storage only.

                                                                    +
                                                                    +

                                                                    Returns void

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Removes from own-local storage only.

                                                                    +
                                                                    +
                                                                    +

                                                                    Parameters

                                                                    +
                                                                      +
                                                                    • value: T
                                                                    +

                                                                    Returns boolean

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Returns IterableIterator<[T, T]>

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +
                                                                    +

                                                                    Parameters

                                                                    +
                                                                      +
                                                                    • cb: (value: T, value2: T, set: ScopedSet<T>) => void
                                                                      • +
                                                                    • OptionalthisArg: any
                                                                    +

                                                                    Returns void

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    true if value is in own-local storage OR anywhere in the parent chain.

                                                                    +
                                                                    +
                                                                    +

                                                                    Parameters

                                                                    +
                                                                      +
                                                                    • value: T
                                                                    +

                                                                    Returns boolean

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Returns IterableIterator<T>

                                                                  +
                                                                  + +
                                                                    +
                                                                  • + +
                                                                    +

                                                                    Returns IterableIterator<T>

                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +

                                                                  Settings

                                                                   +
                                                                  +
                                                                  Member Visibility +
                                                                    +
                                                                    • +
                                                                    • +
                                                                  +
                                                                  +
                                                                  +

                                                                  On This Page

                                                                   +
                                                                  +
                                                                  Constructors +
                                                                  +
                                                                  Accessors +
                                                                  +
                                                                  Methods +
                                                                  +
                                                                  + +
                                                                  +
                                                                  diff --git a/packages/tempo/public/v4/api/library/classes/common.index.WeakCache.html b/packages/tempo/public/v4/api/library/classes/common.index.WeakCache.html new file mode 100644 index 00000000..9d333c96 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/common.index.WeakCache.html @@ -0,0 +1,220 @@ +WeakCache | Library API
                                                                  +
                                                                  Library API + +
                                                                    +
                                                                    +
                                                                    Preparing search index...
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    Class WeakCache<K, V>

                                                                    +
                                                                    +
                                                                    +

                                                                    Map-like cache holding values weakly via WeakRef and auto-pruning +collected entries using Finalizer without memory leaks.

                                                                    +

                                                                    Keys must be primitive (string | number | symbol) to ensure the key +does not create a strong reference cycle with the cached value.

                                                                    +
                                                                    +
                                                                    +

                                                                    Type Parameters

                                                                    +
                                                                      +
                                                                    • K extends keyof any = string
                                                                      • +
                                                                    • V extends WeakKey = WeakKey
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    Index
                                                                     +
                                                                    +
                                                                    + +
                                                                    constructor +
                                                                    +
                                                                    + +
                                                                    isWeakCache +
                                                                    +
                                                                    + +
                                                                    clear +delete +get +getOrSet +has +set +
                                                                    +
                                                                    + +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +
                                                                      +

                                                                      Type Parameters

                                                                      +
                                                                        +
                                                                      • K extends string | number | symbol = string
                                                                        • +
                                                                      • V extends WeakKey = WeakKey
                                                                      +

                                                                      Returns WeakCache<K, V>

                                                                    +
                                                                    + +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • +
                                                                      get isWeakCache(): boolean
                                                                      +
                                                                      +

                                                                      Returns true to identify this instance as a WeakCache.

                                                                      +
                                                                      +

                                                                      Returns boolean

                                                                    +
                                                                    + +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Clears all entries from the cache and unregisters all active finalizers.

                                                                      +
                                                                      +

                                                                      Returns void

                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Deletes a key from the cache and unregisters its finalizer.

                                                                      +
                                                                      +
                                                                      +

                                                                      Parameters

                                                                      +
                                                                        +
                                                                      • key: K +

                                                                        The cache key to delete

                                                                        +
                                                                      +

                                                                      Returns boolean

                                                                      True if an entry existed and was deleted, false otherwise

                                                                      +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Retrieves a value from the cache by key. +Returns undefined if the key does not exist or the value has been garbage collected.

                                                                      +
                                                                      +
                                                                      +

                                                                      Parameters

                                                                      +
                                                                        +
                                                                      • key: K +

                                                                        The cache key to retrieve

                                                                        +
                                                                      +

                                                                      Returns V | undefined

                                                                      The cached object or undefined

                                                                      +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Returns the cached value for the key if present, or computes and caches it using the factory.

                                                                      +
                                                                      +
                                                                      +

                                                                      Parameters

                                                                      +
                                                                        +
                                                                      • key: K +

                                                                        The cache key

                                                                        +
                                                                        • +
                                                                      • factory: (key: K) => V +

                                                                        Factory function to create the value if absent

                                                                        +
                                                                      +

                                                                      Returns V

                                                                      The cached or newly computed value

                                                                      +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Checks whether the cache contains a non-collected value for the given key.

                                                                      +
                                                                      +
                                                                      +

                                                                      Parameters

                                                                      +
                                                                        +
                                                                      • key: K +

                                                                        The cache key to check

                                                                        +
                                                                      +

                                                                      Returns boolean

                                                                      True if the key exists and its value has not been collected

                                                                      +
                                                                    +
                                                                    + +
                                                                      +
                                                                    • + +
                                                                      +

                                                                      Sets a key-value pair in the cache. The value is weakly held. +If the key already exists, its previous registration is cleared.

                                                                      +
                                                                      +
                                                                      +

                                                                      Parameters

                                                                      +
                                                                        +
                                                                      • key: K +

                                                                        The cache key

                                                                        +
                                                                        • +
                                                                      • value: V +

                                                                        The object value to weakly retain

                                                                        +
                                                                      +

                                                                      Returns this

                                                                      This cache instance for chaining

                                                                      +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +

                                                                    Settings

                                                                     +
                                                                    +
                                                                    Member Visibility +
                                                                      +
                                                                      • +
                                                                      • +
                                                                    +
                                                                    +
                                                                    +

                                                                    On This Page

                                                                     +
                                                                    WeakCache +
                                                                    Constructors +
                                                                    +
                                                                    Accessors +
                                                                    +
                                                                    Methods +
                                                                    +
                                                                    + +
                                                                    +
                                                                    diff --git a/packages/tempo/public/v4/api/library/classes/server.index.File.html b/packages/tempo/public/v4/api/library/classes/server.index.File.html new file mode 100644 index 00000000..d556b1a0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/classes/server.index.File.html @@ -0,0 +1,193 @@ +File | Library API
                                                                    +
                                                                    Library API + +
                                                                      +
                                                                      +
                                                                      Preparing search index...
                                                                      +
                                                                      +
                                                                      +
                                                                      + +

                                                                      Class File

                                                                      +
                                                                      +

                                                                      A utility class for sandboxed file operations within a temporary directory. +Prevents path traversal and forces all operations to occur in os.tmpdir().

                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      Index
                                                                       +
                                                                      +
                                                                      + +
                                                                      constructor +
                                                                      +
                                                                      + +
                                                                      encoding +tmpDir +
                                                                      +
                                                                      + +
                                                                      exist +read +remove +write +
                                                                      +
                                                                      + +
                                                                      +
                                                                      + +
                                                                      +
                                                                      + +
                                                                      +
                                                                      + +
                                                                      encoding: BufferEncoding = 'utf8'
                                                                      +
                                                                      + +
                                                                      tmpDir: string = ...
                                                                      +
                                                                      + +
                                                                      +
                                                                      + +
                                                                        +
                                                                      • + +
                                                                        +

                                                                        Check if a file exists in the temporary directory.

                                                                        +
                                                                        +
                                                                        +

                                                                        Parameters

                                                                        +
                                                                          +
                                                                        • file: string +

                                                                          The filename to check

                                                                          +
                                                                        +

                                                                        Returns Promise<boolean>

                                                                        A promise resolving to true if the file exists, false otherwise

                                                                        + +
                                                                        +
                                                                        +
                                                                        const hasConfig = await File.exist('config.json');
+
                                                                        + +
                                                                      +
                                                                      + +
                                                                        +
                                                                      • + +
                                                                        +

                                                                        Read a file's contents from the temporary directory.

                                                                        +
                                                                        +
                                                                        +

                                                                        Parameters

                                                                        +
                                                                          +
                                                                        • file: string +

                                                                          The filename to read

                                                                          +
                                                                        +

                                                                        Returns Promise<string | number | bigint>

                                                                        A promise resolving to the file contents (coerced to number/bigint if applicable)

                                                                        + +
                                                                        +
                                                                        +
                                                                        const content = await File.read('data.txt');
+
                                                                        + +
                                                                      +
                                                                      + +
                                                                        +
                                                                      • + +
                                                                        +

                                                                        Remove a file from the temporary directory.

                                                                        +
                                                                        +
                                                                        +

                                                                        Parameters

                                                                        +
                                                                          +
                                                                        • file: string +

                                                                          The filename to remove

                                                                          +
                                                                        +

                                                                        Returns Promise<void>

                                                                        A promise resolving when the file is deleted

                                                                        + +
                                                                        +
                                                                        +
                                                                        await File.remove('temp-data.txt');
+
                                                                        + +
                                                                      +
                                                                      + +
                                                                        +
                                                                      • + +
                                                                        +

                                                                        Write content to a file in the temporary directory.

                                                                        +
                                                                        +
                                                                        +

                                                                        Parameters

                                                                        +
                                                                          +
                                                                        • file: string +

                                                                          The filename to write to

                                                                          +
                                                                          • +
                                                                        • doc: string | ArrayBufferView<ArrayBufferLike> +

                                                                          The content to write

                                                                          +
                                                                        +

                                                                        Returns Promise<string | ArrayBufferView<ArrayBufferLike>>

                                                                        A promise resolving to the written content

                                                                        + +
                                                                        +
                                                                        +
                                                                        await File.write('output.json', '{"status":"ok"}');
+
                                                                        + +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +

                                                                      Settings

                                                                       +
                                                                      +
                                                                      Member Visibility +
                                                                        +
                                                                        • +
                                                                        • +
                                                                      +
                                                                      +
                                                                      +

                                                                      On This Page

                                                                       +
                                                                      +
                                                                      Constructors +
                                                                      +
                                                                      Properties +
                                                                      +
                                                                      Methods +
                                                                      +
                                                                      + +
                                                                      +
                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.alert.html b/packages/tempo/public/v4/api/library/functions/browser.index.alert.html new file mode 100644 index 00000000..8f85a333 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.alert.html @@ -0,0 +1,54 @@ +alert | Library API
                                                                      +
                                                                      Library API + +
                                                                        +
                                                                        +
                                                                        Preparing search index...
                                                                        +
                                                                        +
                                                                        +
                                                                        + +

                                                                        Function alert

                                                                        +
                                                                        +
                                                                          +
                                                                        • + +
                                                                          +

                                                                          Displays a native browser alert dialog with the provided message.

                                                                          +
                                                                          +
                                                                          +

                                                                          Parameters

                                                                          +
                                                                            +
                                                                          • msg: any +

                                                                            The message to display in the alert dialog

                                                                            +
                                                                          +

                                                                          Returns void

                                                                          +
                                                                          +
                                                                          +
                                                                          alert('Operation completed successfully!');
+
                                                                          + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        Settings

                                                                         +
                                                                        +
                                                                        Member Visibility +
                                                                          +
                                                                          • +
                                                                          • +
                                                                        +
                                                                        +
                                                                        + +
                                                                        +
                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.confirm.html b/packages/tempo/public/v4/api/library/functions/browser.index.confirm.html new file mode 100644 index 00000000..215119ff --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.confirm.html @@ -0,0 +1,55 @@ +confirm | Library API
                                                                        +
                                                                        Library API + +
                                                                          +
                                                                          +
                                                                          Preparing search index...
                                                                          +
                                                                          +
                                                                          +
                                                                          + +

                                                                          Function confirm

                                                                          +
                                                                          +
                                                                            +
                                                                          • + +
                                                                            +

                                                                            Displays a native browser confirmation dialog with OK/Cancel buttons.

                                                                            +
                                                                            +
                                                                            +

                                                                            Parameters

                                                                            +
                                                                              +
                                                                            • Optionalmsg: string +

                                                                              The message to display (e.g., 'Are you sure?')

                                                                              +
                                                                            +

                                                                            Returns boolean

                                                                            True if the user clicked OK, false otherwise

                                                                            + +
                                                                            +
                                                                            +
                                                                            const isSure = confirm('Are you sure you want to delete this?');
+
                                                                            + +
                                                                          +
                                                                          +
                                                                          +
                                                                          +
                                                                          +

                                                                          Settings

                                                                           +
                                                                          +
                                                                          Member Visibility +
                                                                            +
                                                                            • +
                                                                            • +
                                                                          +
                                                                          +
                                                                          + +
                                                                          +
                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.geoCoords.html b/packages/tempo/public/v4/api/library/functions/browser.index.geoCoords.html new file mode 100644 index 00000000..9ae34cbd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.geoCoords.html @@ -0,0 +1,55 @@ +geoCoords | Library API
                                                                          +
                                                                          Library API + +
                                                                            +
                                                                            +
                                                                            Preparing search index...
                                                                            +
                                                                            +
                                                                            +
                                                                            + +

                                                                            Function geoCoords

                                                                            +
                                                                            +
                                                                              +
                                                                            • + +
                                                                              +

                                                                              Format coordinates as a GeocoderRequest["location"] object.

                                                                              +
                                                                              +
                                                                              +

                                                                              Parameters

                                                                              +
                                                                                +
                                                                              • Optionalcoords: GeocoderRequest +

                                                                                Optional coordinates to format; defaults to current location

                                                                                +
                                                                              +

                                                                              Returns Promise<GeocoderRequest | null>

                                                                              A promise resolving to a GeocoderRequest

                                                                              + +
                                                                              +
                                                                              +
                                                                              const req = await geoCoords();
+
                                                                              + +
                                                                            +
                                                                            +
                                                                            +
                                                                            +
                                                                            +

                                                                            Settings

                                                                             +
                                                                            +
                                                                            Member Visibility +
                                                                              +
                                                                              • +
                                                                              • +
                                                                            +
                                                                            +
                                                                            + +
                                                                            +
                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.geoLocation.html b/packages/tempo/public/v4/api/library/functions/browser.index.geoLocation.html new file mode 100644 index 00000000..793797c8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.geoLocation.html @@ -0,0 +1,55 @@ +geoLocation | Library API
                                                                            +
                                                                            Library API + +
                                                                              +
                                                                              +
                                                                              Preparing search index...
                                                                              +
                                                                              +
                                                                              +
                                                                              + +

                                                                              Function geoLocation

                                                                              +
                                                                              +
                                                                                +
                                                                              • + +
                                                                                +

                                                                                Attempt geolocation via navigator.getCurrentPosition().

                                                                                +
                                                                                +
                                                                                +

                                                                                Parameters

                                                                                +
                                                                                  +
                                                                                • opts: MapOpts = ... +

                                                                                  Options for the geolocation attempt

                                                                                  +
                                                                                +

                                                                                Returns Promise<GeolocationPosition & { error?: string }>

                                                                                A promise resolving to the device's coordinates

                                                                                + +
                                                                                +
                                                                                +
                                                                                const pos = await geoLocation();
+
                                                                                + +
                                                                              +
                                                                              +
                                                                              +
                                                                              +
                                                                              +

                                                                              Settings

                                                                               +
                                                                              +
                                                                              Member Visibility +
                                                                                +
                                                                                • +
                                                                                • +
                                                                              +
                                                                              +
                                                                              + +
                                                                              +
                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.getOPFSRoot.html b/packages/tempo/public/v4/api/library/functions/browser.index.getOPFSRoot.html new file mode 100644 index 00000000..7cc82d9e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.getOPFSRoot.html @@ -0,0 +1,52 @@ +getOPFSRoot | Library API
                                                                              +
                                                                              Library API + +
                                                                                +
                                                                                +
                                                                                Preparing search index...
                                                                                +
                                                                                +
                                                                                +
                                                                                + +

                                                                                Function getOPFSRoot

                                                                                +
                                                                                +
                                                                                  +
                                                                                • + +
                                                                                  +

                                                                                  Retrieves the root directory handle for the Origin Private File System (OPFS).

                                                                                  +
                                                                                  +
                                                                                  +

                                                                                  Parameters

                                                                                  +
                                                                                    +
                                                                                  • OptionalsubDir: string +

                                                                                    Optional sub-directory path to navigate into

                                                                                    +
                                                                                    • +
                                                                                  • create: boolean = true +

                                                                                    Whether to create sub-directories if they do not exist (default: true)

                                                                                    +
                                                                                  +

                                                                                  Returns Promise<FileSystemDirectoryHandle | null>

                                                                                  The directory handle or null if unsupported/unavailable

                                                                                  +
                                                                                +
                                                                                +
                                                                                +
                                                                                +
                                                                                +

                                                                                Settings

                                                                                 +
                                                                                +
                                                                                Member Visibility +
                                                                                  +
                                                                                  • +
                                                                                  • +
                                                                                +
                                                                                +
                                                                                + +
                                                                                +
                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.isOPFSSupported.html b/packages/tempo/public/v4/api/library/functions/browser.index.isOPFSSupported.html new file mode 100644 index 00000000..745cae4e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.isOPFSSupported.html @@ -0,0 +1,42 @@ +isOPFSSupported | Library API
                                                                                +
                                                                                Library API + +
                                                                                  +
                                                                                  +
                                                                                  Preparing search index...
                                                                                  +
                                                                                  +
                                                                                  +
                                                                                  + +

                                                                                  Function isOPFSSupported

                                                                                  +
                                                                                  +
                                                                                    +
                                                                                  • + +
                                                                                    +

                                                                                    Checks whether the Origin Private File System (OPFS) is supported in the current environment.

                                                                                    +
                                                                                    +

                                                                                    Returns boolean

                                                                                  +
                                                                                  +
                                                                                  +
                                                                                  +
                                                                                  +

                                                                                  Settings

                                                                                   +
                                                                                  +
                                                                                  Member Visibility +
                                                                                    +
                                                                                    • +
                                                                                    • +
                                                                                  +
                                                                                  +
                                                                                  + +
                                                                                  +
                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.mapAddress.html b/packages/tempo/public/v4/api/library/functions/browser.index.mapAddress.html new file mode 100644 index 00000000..0d5665d2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.mapAddress.html @@ -0,0 +1,58 @@ +mapAddress | Library API
                                                                                  +
                                                                                  Library API + +
                                                                                    +
                                                                                    +
                                                                                    Preparing search index...
                                                                                    +
                                                                                    +
                                                                                    +
                                                                                    + +

                                                                                    Function mapAddress

                                                                                    +
                                                                                    +
                                                                                      +
                                                                                    • + +
                                                                                      +

                                                                                      Query google-maps for a best-guess address at supplied {lat,lng} coordinates.

                                                                                      +
                                                                                      +
                                                                                      +

                                                                                      Parameters

                                                                                      +
                                                                                        +
                                                                                      • Optionalcoords: GeocoderRequest +

                                                                                        Optional coordinates; defaults to current location

                                                                                        +
                                                                                        • +
                                                                                      • opts: MapOpts = ... +

                                                                                        Request options

                                                                                        +
                                                                                      +

                                                                                      Returns Promise<Record<string, string | string[]> | null>

                                                                                      A promise resolving to the best-guess address object

                                                                                      + +
                                                                                      +
                                                                                      +
                                                                                      const address = await mapAddress();
+
                                                                                      + +
                                                                                    +
                                                                                    +
                                                                                    +
                                                                                    +
                                                                                    +

                                                                                    Settings

                                                                                     +
                                                                                    +
                                                                                    Member Visibility +
                                                                                      +
                                                                                      • +
                                                                                      • +
                                                                                    +
                                                                                    +
                                                                                    + +
                                                                                    +
                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.mapHemisphere.html b/packages/tempo/public/v4/api/library/functions/browser.index.mapHemisphere.html new file mode 100644 index 00000000..0ab1938c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.mapHemisphere.html @@ -0,0 +1,59 @@ +mapHemisphere | Library API
                                                                                    +
                                                                                    Library API + +
                                                                                      +
                                                                                      +
                                                                                      Preparing search index...
                                                                                      +
                                                                                      +
                                                                                      +
                                                                                      + +

                                                                                      Function mapHemisphere

                                                                                      +
                                                                                      +
                                                                                        +
                                                                                      • + +
                                                                                        +

                                                                                        Get Hemisphere ('north' | 'south' | null) for supplied coordinates +or current geolocation if none supplied.

                                                                                        +
                                                                                        +
                                                                                        +

                                                                                        Parameters

                                                                                        +
                                                                                          +
                                                                                        • Optionalcoords: GeocoderRequest +

                                                                                          Optional coordinates

                                                                                          +
                                                                                          • +
                                                                                        • opts: MapOpts = ... +

                                                                                          Request options

                                                                                          +
                                                                                        +

                                                                                        Returns Promise<"north" | "south" | null | undefined>

                                                                                        A promise resolving to the hemisphere string

                                                                                        + +
                                                                                        +
                                                                                        +
                                                                                        const sphere = await mapHemisphere();
+
                                                                                        + +
                                                                                      +
                                                                                      +
                                                                                      +
                                                                                      +
                                                                                      +

                                                                                      Settings

                                                                                       +
                                                                                      +
                                                                                      Member Visibility +
                                                                                        +
                                                                                        • +
                                                                                        • +
                                                                                      +
                                                                                      +
                                                                                      + +
                                                                                      +
                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.mapQuery.html b/packages/tempo/public/v4/api/library/functions/browser.index.mapQuery.html new file mode 100644 index 00000000..2dd8c6cd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.mapQuery.html @@ -0,0 +1,58 @@ +mapQuery | Library API
                                                                                      +
                                                                                      Library API + +
                                                                                        +
                                                                                        +
                                                                                        Preparing search index...
                                                                                        +
                                                                                        +
                                                                                        +
                                                                                        + +

                                                                                        Function mapQuery

                                                                                        +
                                                                                        +
                                                                                          +
                                                                                        • + +
                                                                                          +

                                                                                          Make a 'maps' request to the Google Geocoding API.

                                                                                          +
                                                                                          +
                                                                                          +

                                                                                          Parameters

                                                                                          +
                                                                                            +
                                                                                          • Optionalcoords: GeocoderRequest +

                                                                                            Coordinates to query

                                                                                            +
                                                                                            • +
                                                                                          • opts: MapOpts = ... +

                                                                                            Request options

                                                                                            +
                                                                                          +

                                                                                          Returns Promise<GeocoderResponse & { error?: string }>

                                                                                          A promise resolving to the geocoder response

                                                                                          + +
                                                                                          +
                                                                                          +
                                                                                          const res = await mapQuery({ location: { lat: 0, lng: 0 } });
+
                                                                                          + +
                                                                                        +
                                                                                        +
                                                                                        +
                                                                                        +
                                                                                        +

                                                                                        Settings

                                                                                         +
                                                                                        +
                                                                                        Member Visibility +
                                                                                          +
                                                                                          • +
                                                                                          • +
                                                                                        +
                                                                                        +
                                                                                        + +
                                                                                        +
                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsDelete.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsDelete.html new file mode 100644 index 00000000..477aeddf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsDelete.html @@ -0,0 +1,49 @@ +opfsDelete | Library API
                                                                                        +
                                                                                        Library API + +
                                                                                          +
                                                                                          +
                                                                                          Preparing search index...
                                                                                          +
                                                                                          +
                                                                                          +
                                                                                          + +

                                                                                          Function opfsDelete

                                                                                          +
                                                                                          +
                                                                                            +
                                                                                          • + +
                                                                                            +

                                                                                            Deletes a file from the browser OPFS.

                                                                                            +
                                                                                            +
                                                                                            +

                                                                                            Parameters

                                                                                            +
                                                                                              +
                                                                                            • path: string +

                                                                                              Virtual path relative to OPFS root

                                                                                              +
                                                                                            +

                                                                                            Returns Promise<boolean>

                                                                                            True if deleted successfully, false if file did not exist

                                                                                            +
                                                                                          +
                                                                                          +
                                                                                          +
                                                                                          +
                                                                                          +

                                                                                          Settings

                                                                                           +
                                                                                          +
                                                                                          Member Visibility +
                                                                                            +
                                                                                            • +
                                                                                            • +
                                                                                          +
                                                                                          +
                                                                                          + +
                                                                                          +
                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsExists.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsExists.html new file mode 100644 index 00000000..9cb294d2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsExists.html @@ -0,0 +1,48 @@ +opfsExists | Library API
                                                                                          +
                                                                                          Library API + +
                                                                                            +
                                                                                            +
                                                                                            Preparing search index...
                                                                                            +
                                                                                            +
                                                                                            +
                                                                                            + +

                                                                                            Function opfsExists

                                                                                            +
                                                                                            +
                                                                                              +
                                                                                            • + +
                                                                                              +

                                                                                              Checks whether a file exists in the browser OPFS.

                                                                                              +
                                                                                              +
                                                                                              +

                                                                                              Parameters

                                                                                              +
                                                                                                +
                                                                                              • path: string +

                                                                                                Virtual path relative to OPFS root

                                                                                                +
                                                                                              +

                                                                                              Returns Promise<boolean>

                                                                                            +
                                                                                            +
                                                                                            +
                                                                                            +
                                                                                            +

                                                                                            Settings

                                                                                             +
                                                                                            +
                                                                                            Member Visibility +
                                                                                              +
                                                                                              • +
                                                                                              • +
                                                                                            +
                                                                                            +
                                                                                            + +
                                                                                            +
                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsList.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsList.html new file mode 100644 index 00000000..5f83b584 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsList.html @@ -0,0 +1,49 @@ +opfsList | Library API
                                                                                            +
                                                                                            Library API + +
                                                                                              +
                                                                                              +
                                                                                              Preparing search index...
                                                                                              +
                                                                                              +
                                                                                              +
                                                                                              + +

                                                                                              Function opfsList

                                                                                              +
                                                                                              +
                                                                                                +
                                                                                              • + +
                                                                                                +

                                                                                                Lists all file and subdirectory names within a given OPFS directory.

                                                                                                +
                                                                                                +
                                                                                                +

                                                                                                Parameters

                                                                                                +
                                                                                                  +
                                                                                                • dir: string = '' +

                                                                                                  Optional subdirectory path (default: root)

                                                                                                  +
                                                                                                +

                                                                                                Returns Promise<string[]>

                                                                                                Array of entry names

                                                                                                +
                                                                                              +
                                                                                              +
                                                                                              +
                                                                                              +
                                                                                              +

                                                                                              Settings

                                                                                               +
                                                                                              +
                                                                                              Member Visibility +
                                                                                                +
                                                                                                • +
                                                                                                • +
                                                                                              +
                                                                                              +
                                                                                              + +
                                                                                              +
                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsRead.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsRead.html new file mode 100644 index 00000000..102befc2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsRead.html @@ -0,0 +1,49 @@ +opfsRead | Library API
                                                                                              +
                                                                                              Library API + +
                                                                                                +
                                                                                                +
                                                                                                Preparing search index...
                                                                                                +
                                                                                                +
                                                                                                +
                                                                                                + +

                                                                                                Function opfsRead

                                                                                                +
                                                                                                +
                                                                                                  +
                                                                                                • + +
                                                                                                  +

                                                                                                  Reads a text file from the browser OPFS virtual filesystem.

                                                                                                  +
                                                                                                  +
                                                                                                  +

                                                                                                  Parameters

                                                                                                  +
                                                                                                    +
                                                                                                  • path: string +

                                                                                                    Virtual path relative to OPFS root (e.g. "keys/openai.json")

                                                                                                    +
                                                                                                  +

                                                                                                  Returns Promise<string | null>

                                                                                                  The string file contents, or null if file not found

                                                                                                  +
                                                                                                +
                                                                                                +
                                                                                                +
                                                                                                +
                                                                                                +

                                                                                                Settings

                                                                                                 +
                                                                                                +
                                                                                                Member Visibility +
                                                                                                  +
                                                                                                  • +
                                                                                                  • +
                                                                                                +
                                                                                                +
                                                                                                + +
                                                                                                +
                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadBuffer.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadBuffer.html new file mode 100644 index 00000000..414dc49d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadBuffer.html @@ -0,0 +1,49 @@ +opfsReadBuffer | Library API
                                                                                                +
                                                                                                Library API + +
                                                                                                  +
                                                                                                  +
                                                                                                  Preparing search index...
                                                                                                  +
                                                                                                  +
                                                                                                  +
                                                                                                  + +

                                                                                                  Function opfsReadBuffer

                                                                                                  +
                                                                                                  +
                                                                                                    +
                                                                                                  • + +
                                                                                                    +

                                                                                                    Reads a binary file as an ArrayBuffer from the browser OPFS.

                                                                                                    +
                                                                                                    +
                                                                                                    +

                                                                                                    Parameters

                                                                                                    +
                                                                                                      +
                                                                                                    • path: string +

                                                                                                      Virtual path relative to OPFS root

                                                                                                      +
                                                                                                    +

                                                                                                    Returns Promise<ArrayBuffer | null>

                                                                                                    ArrayBuffer containing binary data, or null if file not found

                                                                                                    +
                                                                                                  +
                                                                                                  +
                                                                                                  +
                                                                                                  +
                                                                                                  +

                                                                                                  Settings

                                                                                                   +
                                                                                                  +
                                                                                                  Member Visibility +
                                                                                                    +
                                                                                                    • +
                                                                                                    • +
                                                                                                  +
                                                                                                  +
                                                                                                  + +
                                                                                                  +
                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadJSON.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadJSON.html new file mode 100644 index 00000000..19f4a76b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsReadJSON.html @@ -0,0 +1,55 @@ +opfsReadJSON | Library API
                                                                                                  +
                                                                                                  Library API + +
                                                                                                    +
                                                                                                    +
                                                                                                    Preparing search index...
                                                                                                    +
                                                                                                    +
                                                                                                    +
                                                                                                    + +

                                                                                                    Function opfsReadJSON

                                                                                                    +
                                                                                                    +
                                                                                                      +
                                                                                                    • + +
                                                                                                      +

                                                                                                      Reads and deserializes a JSON file from OPFS.

                                                                                                      +
                                                                                                      +
                                                                                                      +

                                                                                                      Type Parameters

                                                                                                      +
                                                                                                        +
                                                                                                      • T = any
                                                                                                      +
                                                                                                      +

                                                                                                      Parameters

                                                                                                      +
                                                                                                        +
                                                                                                      • path: string +

                                                                                                        Virtual path relative to OPFS root

                                                                                                        +
                                                                                                        • +
                                                                                                      • Optionalfallback: T +

                                                                                                        Default value if file not found or invalid

                                                                                                        +
                                                                                                      +

                                                                                                      Returns Promise<T | null>

                                                                                                    +
                                                                                                    +
                                                                                                    +
                                                                                                    +
                                                                                                    +

                                                                                                    Settings

                                                                                                     +
                                                                                                    +
                                                                                                    Member Visibility +
                                                                                                      +
                                                                                                      • +
                                                                                                      • +
                                                                                                    +
                                                                                                    +
                                                                                                    + +
                                                                                                    +
                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsWrite.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsWrite.html new file mode 100644 index 00000000..db87d751 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsWrite.html @@ -0,0 +1,54 @@ +opfsWrite | Library API
                                                                                                    +
                                                                                                    Library API + +
                                                                                                      +
                                                                                                      +
                                                                                                      Preparing search index...
                                                                                                      +
                                                                                                      +
                                                                                                      +
                                                                                                      + +

                                                                                                      Function opfsWrite

                                                                                                      +
                                                                                                      +
                                                                                                        +
                                                                                                      • + +
                                                                                                        +

                                                                                                        Writes text or binary data to a file in the browser OPFS virtual filesystem. +Automatically creates parent directories as needed. +Note: Stored as plaintext readable by same-origin scripts. Direct callers requiring +encrypted-at-rest storage must use getFileStore.

                                                                                                        +
                                                                                                        +
                                                                                                        +

                                                                                                        Parameters

                                                                                                        +
                                                                                                          +
                                                                                                        • path: string +

                                                                                                          Virtual path relative to OPFS root (e.g. "vault/data.json")

                                                                                                          +
                                                                                                          • +
                                                                                                        • content: string | BufferSource +

                                                                                                          String, ArrayBuffer, or Uint8Array data to write

                                                                                                          +
                                                                                                        +

                                                                                                        Returns Promise<void>

                                                                                                      +
                                                                                                      +
                                                                                                      +
                                                                                                      +
                                                                                                      +

                                                                                                      Settings

                                                                                                       +
                                                                                                      +
                                                                                                      Member Visibility +
                                                                                                        +
                                                                                                        • +
                                                                                                        • +
                                                                                                      +
                                                                                                      +
                                                                                                      + +
                                                                                                      +
                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.opfsWriteJSON.html b/packages/tempo/public/v4/api/library/functions/browser.index.opfsWriteJSON.html new file mode 100644 index 00000000..73bfa57a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.opfsWriteJSON.html @@ -0,0 +1,53 @@ +opfsWriteJSON | Library API
                                                                                                      +
                                                                                                      Library API + +
                                                                                                        +
                                                                                                        +
                                                                                                        Preparing search index...
                                                                                                        +
                                                                                                        +
                                                                                                        +
                                                                                                        + +

                                                                                                        Function opfsWriteJSON

                                                                                                        +
                                                                                                        +
                                                                                                          +
                                                                                                        • + +
                                                                                                          +

                                                                                                          Serializes and writes an object or value to a JSON file in OPFS. +Note: Stored as plaintext readable by same-origin scripts. Direct callers requiring +encrypted-at-rest storage must use getFileStore.

                                                                                                          +
                                                                                                          +
                                                                                                          +

                                                                                                          Parameters

                                                                                                          +
                                                                                                            +
                                                                                                          • path: string +

                                                                                                            Virtual path relative to OPFS root

                                                                                                            +
                                                                                                            • +
                                                                                                          • data: any +

                                                                                                            Object or value to serialize

                                                                                                            +
                                                                                                          +

                                                                                                          Returns Promise<void>

                                                                                                        +
                                                                                                        +
                                                                                                        +
                                                                                                        +
                                                                                                        +

                                                                                                        Settings

                                                                                                         +
                                                                                                        +
                                                                                                        Member Visibility +
                                                                                                          +
                                                                                                          • +
                                                                                                          • +
                                                                                                        +
                                                                                                        +
                                                                                                        + +
                                                                                                        +
                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/browser.index.prompt.html b/packages/tempo/public/v4/api/library/functions/browser.index.prompt.html new file mode 100644 index 00000000..3546f0d7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/browser.index.prompt.html @@ -0,0 +1,58 @@ +prompt | Library API
                                                                                                        +
                                                                                                        Library API + +
                                                                                                          +
                                                                                                          +
                                                                                                          Preparing search index...
                                                                                                          +
                                                                                                          +
                                                                                                          +
                                                                                                          + +

                                                                                                          Function prompt

                                                                                                          +
                                                                                                          +
                                                                                                            +
                                                                                                          • + +
                                                                                                            +

                                                                                                            Displays a native browser prompt dialog, asking the user for input.

                                                                                                            +
                                                                                                            +
                                                                                                            +

                                                                                                            Parameters

                                                                                                            +
                                                                                                              +
                                                                                                            • msg: any +

                                                                                                              The message/question to display

                                                                                                              +
                                                                                                              • +
                                                                                                            • Optionaldflt: any +

                                                                                                              An optional default value for the input field

                                                                                                              +
                                                                                                            +

                                                                                                            Returns string | null

                                                                                                            The text entered by the user, or null if cancelled

                                                                                                            + +
                                                                                                            +
                                                                                                            +
                                                                                                            const name = prompt('What is your name?', 'Guest');
+
                                                                                                            + +
                                                                                                          +
                                                                                                          +
                                                                                                          +
                                                                                                          +
                                                                                                          +

                                                                                                          Settings

                                                                                                           +
                                                                                                          +
                                                                                                          Member Visibility +
                                                                                                            +
                                                                                                            • +
                                                                                                            • +
                                                                                                          +
                                                                                                          +
                                                                                                          + +
                                                                                                          +
                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Immutable.html b/packages/tempo/public/v4/api/library/functions/common.index.Immutable.html new file mode 100644 index 00000000..e58de3b9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Immutable.html @@ -0,0 +1,68 @@ +Immutable | Library API
                                                                                                          +
                                                                                                          Library API + +
                                                                                                            +
                                                                                                            +
                                                                                                            Preparing search index...
                                                                                                            +
                                                                                                            +
                                                                                                            +
                                                                                                            + +

                                                                                                            Function Immutable

                                                                                                            +
                                                                                                            +
                                                                                                              +
                                                                                                            • + +
                                                                                                              +

                                                                                                              A class decorator that freezes a class instance to prevent modification. +Provides "silent immutability" by silently ignoring modifications in non-strict mode.

                                                                                                              +
                                                                                                              +
                                                                                                              +

                                                                                                              Type Parameters

                                                                                                              +
                                                                                                              +
                                                                                                              +

                                                                                                              Parameters

                                                                                                              +
                                                                                                                +
                                                                                                              • value: T +

                                                                                                                The class constructor to freeze

                                                                                                                +
                                                                                                                • +
                                                                                                              • context: ClassDecoratorContext<T> +

                                                                                                                The decorator context

                                                                                                                +
                                                                                                              +

                                                                                                              Returns void | T

                                                                                                              The immutable class wrapper

                                                                                                              + +
                                                                                                              +
                                                                                                              +

                                                                                                              Workaround: To protect against aggressive bundlers (Rollup/Terser) mutating the TS 7.0 +ES2022 decorator IIFE structure, users must append return Object.freeze(this) as this; to their +constructors to ensure immutability survives production bundling.

                                                                                                              +
                                                                                                              +
                                                                                                              +
                                                                                                              @Immutable
                                                                                                              class Config { ... }
+
                                                                                                              + +
                                                                                                            +
                                                                                                            +
                                                                                                            +
                                                                                                            +
                                                                                                            +

                                                                                                            Settings

                                                                                                             +
                                                                                                            +
                                                                                                            Member Visibility +
                                                                                                              +
                                                                                                              • +
                                                                                                              • +
                                                                                                            +
                                                                                                            +
                                                                                                            + +
                                                                                                            +
                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Mutable.html b/packages/tempo/public/v4/api/library/functions/common.index.Mutable.html new file mode 100644 index 00000000..05d79f88 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Mutable.html @@ -0,0 +1,54 @@ +Mutable | Library API
                                                                                                            +
                                                                                                            Library API + +
                                                                                                              +
                                                                                                              +
                                                                                                              Preparing search index...
                                                                                                              +
                                                                                                              +
                                                                                                              +
                                                                                                              + +

                                                                                                              Function Mutable

                                                                                                              +
                                                                                                              +
                                                                                                                +
                                                                                                              • + +
                                                                                                                +

                                                                                                                A method, property, or getter decorator that marks a class member to remain mutable +when the class is decorated with @Immutable or @Securable.

                                                                                                                +
                                                                                                                +
                                                                                                                +

                                                                                                                Parameters

                                                                                                                +
                                                                                                                  +
                                                                                                                • OptionaltargetOrCondition: any
                                                                                                                  • +
                                                                                                                • Optionalcontext: any
                                                                                                                +

                                                                                                                Returns any

                                                                                                                +
                                                                                                                +
                                                                                                                +
                                                                                                                 @ Mutable()
                                                                                                                 static cache;

                                                                                                                 @ Mutable(() => isTestEnvironment())
                                                                                                                 static init() { ... }
+
                                                                                                                + +
                                                                                                              +
                                                                                                              +
                                                                                                              +
                                                                                                              +
                                                                                                              +

                                                                                                              Settings

                                                                                                               +
                                                                                                              +
                                                                                                              Member Visibility +
                                                                                                                +
                                                                                                                • +
                                                                                                                • +
                                                                                                              +
                                                                                                              +
                                                                                                              + +
                                                                                                              +
                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Securable.html b/packages/tempo/public/v4/api/library/functions/common.index.Securable.html new file mode 100644 index 00000000..45dd79e4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Securable.html @@ -0,0 +1,68 @@ +Securable | Library API
                                                                                                              +
                                                                                                              Library API + +
                                                                                                                +
                                                                                                                +
                                                                                                                Preparing search index...
                                                                                                                +
                                                                                                                +
                                                                                                                +
                                                                                                                + +

                                                                                                                Function Securable

                                                                                                                +
                                                                                                                +
                                                                                                                  +
                                                                                                                • + +
                                                                                                                  +

                                                                                                                  A class decorator that secures a class instance with a mutation-throwing Proxy. +Provides "noisy immutability" by throwing an error if modifications are attempted.

                                                                                                                  +
                                                                                                                  +
                                                                                                                  +

                                                                                                                  Type Parameters

                                                                                                                  +
                                                                                                                  +
                                                                                                                  +

                                                                                                                  Parameters

                                                                                                                  +
                                                                                                                    +
                                                                                                                  • value: T +

                                                                                                                    The class constructor to secure

                                                                                                                    +
                                                                                                                    • +
                                                                                                                  • context: ClassDecoratorContext<T> +

                                                                                                                    The decorator context

                                                                                                                    +
                                                                                                                  +

                                                                                                                  Returns void | T

                                                                                                                  The secured class wrapper

                                                                                                                  + +
                                                                                                                  +
                                                                                                                  +

                                                                                                                  Workaround: To protect against aggressive bundlers (Rollup/Terser) mutating the TS 7.0 +ES2022 decorator IIFE structure, users must append return Object.freeze(this) as this; +(or the secure equivalent) to their constructors to ensure immutability survives production bundling.

                                                                                                                  +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  @Securable
                                                                                                                  class Config { ... }
+
                                                                                                                  + +
                                                                                                                +
                                                                                                                +
                                                                                                                +
                                                                                                                +
                                                                                                                +

                                                                                                                Settings

                                                                                                                 +
                                                                                                                +
                                                                                                                Member Visibility +
                                                                                                                  +
                                                                                                                  • +
                                                                                                                  • +
                                                                                                                +
                                                                                                                +
                                                                                                                + +
                                                                                                                +
                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Serializable.html b/packages/tempo/public/v4/api/library/functions/common.index.Serializable.html new file mode 100644 index 00000000..2e20ca23 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Serializable.html @@ -0,0 +1,62 @@ +Serializable | Library API
                                                                                                                +
                                                                                                                Library API + +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  Preparing search index...
                                                                                                                  +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  + +

                                                                                                                  Function Serializable

                                                                                                                  +
                                                                                                                  +
                                                                                                                    +
                                                                                                                  • + +
                                                                                                                    +

                                                                                                                    A class decorator that registers a class for serialization with the runtime type system.

                                                                                                                    +
                                                                                                                    +
                                                                                                                    +

                                                                                                                    Type Parameters

                                                                                                                    +
                                                                                                                    +
                                                                                                                    +

                                                                                                                    Parameters

                                                                                                                    +
                                                                                                                      +
                                                                                                                    • value: T +

                                                                                                                      The class constructor to register

                                                                                                                      +
                                                                                                                      • +
                                                                                                                    • context: ClassDecoratorContext<T> +

                                                                                                                      The decorator context

                                                                                                                      +
                                                                                                                    +

                                                                                                                    Returns void | T

                                                                                                                    The original class constructor

                                                                                                                    + +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    @Serializable
                                                                                                                    class DataModel { ... }
+
                                                                                                                    + +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  +

                                                                                                                  Settings

                                                                                                                   +
                                                                                                                  +
                                                                                                                  Member Visibility +
                                                                                                                    +
                                                                                                                    • +
                                                                                                                    • +
                                                                                                                  +
                                                                                                                  +
                                                                                                                  + +
                                                                                                                  +
                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Singleton.html b/packages/tempo/public/v4/api/library/functions/common.index.Singleton.html new file mode 100644 index 00000000..6d00209d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Singleton.html @@ -0,0 +1,63 @@ +Singleton | Library API
                                                                                                                  +
                                                                                                                  Library API + +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    Preparing search index...
                                                                                                                    +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    + +

                                                                                                                    Function Singleton

                                                                                                                    +
                                                                                                                    +
                                                                                                                      +
                                                                                                                    • + +
                                                                                                                      +

                                                                                                                      A class decorator that transforms a class into a Singleton pattern. +Intercepts constructor calls to return a cached instance upon subsequent instantiations. +Also attaches a static .instance property to the decorated constructor.

                                                                                                                      +
                                                                                                                      +
                                                                                                                      +

                                                                                                                      Type Parameters

                                                                                                                      +
                                                                                                                      +
                                                                                                                      +

                                                                                                                      Parameters

                                                                                                                      +
                                                                                                                        +
                                                                                                                      • OptionaltargetOrOptions: SingletonOptions | T +

                                                                                                                        Class constructor or Singleton options

                                                                                                                        +
                                                                                                                        • +
                                                                                                                      • Optionalcontext: ClassDecoratorContext<T> +

                                                                                                                        Optional decorator context (when used without parentheses)

                                                                                                                        +
                                                                                                                      +

                                                                                                                      Returns any

                                                                                                                      +
                                                                                                                      +
                                                                                                                      +
                                                                                                                       @ Singleton
                                                                                                                       class ConfigStore {
                                                                                                                         public apiKey = 'secret_123';
                                                                                                                       }

                                                                                                                       const a = new ConfigStore();
                                                                                                                       const b = new ConfigStore();
                                                                                                                       console.log(a === b); // true
                                                                                                                       console.log((ConfigStore as any).instance === a); // true
+
                                                                                                                      + +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    +

                                                                                                                    Settings

                                                                                                                     +
                                                                                                                    +
                                                                                                                    Member Visibility +
                                                                                                                      +
                                                                                                                      • +
                                                                                                                      • +
                                                                                                                    +
                                                                                                                    +
                                                                                                                    + +
                                                                                                                    +
                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.Static.html b/packages/tempo/public/v4/api/library/functions/common.index.Static.html new file mode 100644 index 00000000..30940a4b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.Static.html @@ -0,0 +1,63 @@ +Static | Library API
                                                                                                                    +
                                                                                                                    Library API + +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      Preparing search index...
                                                                                                                      +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      + +

                                                                                                                      Function Static

                                                                                                                      +
                                                                                                                      +
                                                                                                                        +
                                                                                                                      • + +
                                                                                                                        +

                                                                                                                        A class decorator that prevents instantiation of the class. +Useful for grouping static methods together without allowing instances to be created.

                                                                                                                        +
                                                                                                                        +
                                                                                                                        +

                                                                                                                        Type Parameters

                                                                                                                        +
                                                                                                                        +
                                                                                                                        +

                                                                                                                        Parameters

                                                                                                                        +
                                                                                                                          +
                                                                                                                        • value: T +

                                                                                                                          The class constructor to make static

                                                                                                                          +
                                                                                                                          • +
                                                                                                                        • context: ClassDecoratorContext<T> +

                                                                                                                          The decorator context

                                                                                                                          +
                                                                                                                        +

                                                                                                                        Returns void | T

                                                                                                                        A wrapper that throws a TypeError when instantiated

                                                                                                                        + +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        @Static
                                                                                                                        class MathUtils { ... }
+
                                                                                                                        + +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      +

                                                                                                                      Settings

                                                                                                                       +
                                                                                                                      +
                                                                                                                      Member Visibility +
                                                                                                                        +
                                                                                                                        • +
                                                                                                                        • +
                                                                                                                      +
                                                                                                                      +
                                                                                                                      + +
                                                                                                                      +
                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.StringTag.html b/packages/tempo/public/v4/api/library/functions/common.index.StringTag.html new file mode 100644 index 00000000..5cf449b4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.StringTag.html @@ -0,0 +1,57 @@ +StringTag | Library API
                                                                                                                      +
                                                                                                                      Library API + +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        Preparing search index...
                                                                                                                        +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        + +

                                                                                                                        Function StringTag

                                                                                                                        +
                                                                                                                        +
                                                                                                                          +
                                                                                                                        • + +
                                                                                                                          +

                                                                                                                          Applies a string tag to a class and its prototype.

                                                                                                                          +

                                                                                                                          Supports direct use as @StringTag and configured use as @StringTag('CustomName').

                                                                                                                          +
                                                                                                                          +
                                                                                                                          +

                                                                                                                          Type Parameters

                                                                                                                          +
                                                                                                                          +
                                                                                                                          +

                                                                                                                          Parameters

                                                                                                                          +
                                                                                                                            +
                                                                                                                          • OptionaltagOrValue: string | T +

                                                                                                                            A custom tag string or the class constructor when used directly.

                                                                                                                            +
                                                                                                                            • +
                                                                                                                          • Optionalcontext: ClassDecoratorContext<T> +

                                                                                                                            The decorator context for direct decorator usage.

                                                                                                                            +
                                                                                                                          +

                                                                                                                          Returns any

                                                                                                                          The decorated class or a decorator that applies the tag.

                                                                                                                          +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        +

                                                                                                                        Settings

                                                                                                                         +
                                                                                                                        +
                                                                                                                        Member Visibility +
                                                                                                                          +
                                                                                                                          • +
                                                                                                                          • +
                                                                                                                        +
                                                                                                                        +
                                                                                                                        + +
                                                                                                                        +
                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.addUtcDays.html b/packages/tempo/public/v4/api/library/functions/common.index.addUtcDays.html new file mode 100644 index 00000000..f3e07d9f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.addUtcDays.html @@ -0,0 +1,52 @@ +addUtcDays | Library API
                                                                                                                        +
                                                                                                                        Library API + +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          Preparing search index...
                                                                                                                          +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          + +

                                                                                                                          Function addUtcDays

                                                                                                                          +
                                                                                                                          +
                                                                                                                            +
                                                                                                                          • + +
                                                                                                                            +

                                                                                                                            Adds an integer number of days to a Date in UTC, returning a new Date instance.

                                                                                                                            +
                                                                                                                            +
                                                                                                                            +

                                                                                                                            Parameters

                                                                                                                            +
                                                                                                                              +
                                                                                                                            • date: Date +

                                                                                                                              The baseline Date instance

                                                                                                                              +
                                                                                                                              • +
                                                                                                                            • days: number +

                                                                                                                              Number of days to add (can be negative)

                                                                                                                              +
                                                                                                                            +

                                                                                                                            Returns Date

                                                                                                                            A new Date instance offset by the specified number of days

                                                                                                                            +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          +

                                                                                                                          Settings

                                                                                                                           +
                                                                                                                          +
                                                                                                                          Member Visibility +
                                                                                                                            +
                                                                                                                            • +
                                                                                                                            • +
                                                                                                                          +
                                                                                                                          +
                                                                                                                          + +
                                                                                                                          +
                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.allDescriptors.html b/packages/tempo/public/v4/api/library/functions/common.index.allDescriptors.html new file mode 100644 index 00000000..dc3e2403 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.allDescriptors.html @@ -0,0 +1,60 @@ +allDescriptors | Library API
                                                                                                                          +
                                                                                                                          Library API + +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            Preparing search index...
                                                                                                                            +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            + +

                                                                                                                            Function allDescriptors

                                                                                                                            +
                                                                                                                            +
                                                                                                                              +
                                                                                                                            • + +
                                                                                                                              +

                                                                                                                              Creates a new object and shadow-copies all own-descriptors (including getters/setters) +from the source object.

                                                                                                                              +
                                                                                                                              +
                                                                                                                              +

                                                                                                                              Type Parameters

                                                                                                                              +
                                                                                                                                +
                                                                                                                              • T extends object
                                                                                                                              +
                                                                                                                              +

                                                                                                                              Parameters

                                                                                                                              +
                                                                                                                                +
                                                                                                                              • source: T +

                                                                                                                                The object to copy descriptors from

                                                                                                                                +
                                                                                                                              +

                                                                                                                              Returns T

                                                                                                                              A new object with identical descriptors

                                                                                                                              + +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              const clone = allDescriptors(source);
+
                                                                                                                              + +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            +

                                                                                                                            Settings

                                                                                                                             +
                                                                                                                            +
                                                                                                                            Member Visibility +
                                                                                                                              +
                                                                                                                              • +
                                                                                                                              • +
                                                                                                                            +
                                                                                                                            +
                                                                                                                            + +
                                                                                                                            +
                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.allObject.html b/packages/tempo/public/v4/api/library/functions/common.index.allObject.html new file mode 100644 index 00000000..70049b7d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.allObject.html @@ -0,0 +1,60 @@ +allObject | Library API
                                                                                                                            +
                                                                                                                            Library API + +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              Preparing search index...
                                                                                                                              +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              + +

                                                                                                                              Function allObject

                                                                                                                              +
                                                                                                                              +
                                                                                                                                +
                                                                                                                              • + +
                                                                                                                                +

                                                                                                                                Returns a new object containing all 'own' and 'inherited' enumerable properties +from the prototype chain of the provided object.

                                                                                                                                +
                                                                                                                                +
                                                                                                                                +

                                                                                                                                Type Parameters

                                                                                                                                +
                                                                                                                                  +
                                                                                                                                • T extends Obj
                                                                                                                                +
                                                                                                                                +

                                                                                                                                Parameters

                                                                                                                                +
                                                                                                                                  +
                                                                                                                                • json: T +

                                                                                                                                  The object to extract properties from

                                                                                                                                  +
                                                                                                                                +

                                                                                                                                Returns { [k: string]: any }

                                                                                                                                A plain object containing the flattened properties

                                                                                                                                + +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                const flat = allObject(myInstance);
+
                                                                                                                                + +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              +

                                                                                                                              Settings

                                                                                                                               +
                                                                                                                              +
                                                                                                                              Member Visibility +
                                                                                                                                +
                                                                                                                                • +
                                                                                                                                • +
                                                                                                                              +
                                                                                                                              +
                                                                                                                              + +
                                                                                                                              +
                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.anySignal.html b/packages/tempo/public/v4/api/library/functions/common.index.anySignal.html new file mode 100644 index 00000000..169b2a44 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.anySignal.html @@ -0,0 +1,51 @@ +anySignal | Library API
                                                                                                                              +
                                                                                                                              Library API + +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                Preparing search index...
                                                                                                                                +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                + +

                                                                                                                                Function anySignal

                                                                                                                                +
                                                                                                                                +
                                                                                                                                  +
                                                                                                                                • + +
                                                                                                                                  +

                                                                                                                                  Combines multiple AbortSignals into a single composite signal using a cross-realm and duck-type safe controller. +Automatically filters out undefined or non-signal values and propagates the abort reason. +The returned signal provides a cleanup() method to detach listeners from parent signals early.

                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  +

                                                                                                                                  Parameters

                                                                                                                                  +
                                                                                                                                    +
                                                                                                                                  • ...signals: (AbortSignal | undefined)[] +

                                                                                                                                    Array of AbortSignals (or undefined values)

                                                                                                                                    +
                                                                                                                                  +

                                                                                                                                  Returns AbortSignal

                                                                                                                                  A composite AbortSignal with a cleanup teardown method

                                                                                                                                  +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                +

                                                                                                                                Settings

                                                                                                                                 +
                                                                                                                                +
                                                                                                                                Member Visibility +
                                                                                                                                  +
                                                                                                                                  • +
                                                                                                                                  • +
                                                                                                                                +
                                                                                                                                +
                                                                                                                                + +
                                                                                                                                +
                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asArray.html b/packages/tempo/public/v4/api/library/functions/common.index.asArray.html new file mode 100644 index 00000000..8394325e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asArray.html @@ -0,0 +1,116 @@ +asArray | Library API
                                                                                                                                +
                                                                                                                                Library API + +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  Preparing search index...
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  + +

                                                                                                                                  Function asArray

                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                    +
                                                                                                                                  • + +
                                                                                                                                    +

                                                                                                                                    Coerces a value into an array. If the value is already an array-like or iterable, +it is converted to an array. An optional fill value can be provided to map over the elements.

                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Type Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • T
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • arr: ArrayLike<T> | undefined +

                                                                                                                                      The value to coerce into an array

                                                                                                                                      +
                                                                                                                                    +

                                                                                                                                    Returns T[]

                                                                                                                                    An array containing the coerced values

                                                                                                                                    + +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    const arr = asArray('hello'); // ['hello']
+
                                                                                                                                    + +
                                                                                                                                    • +
                                                                                                                                  • + +
                                                                                                                                    +

                                                                                                                                    Coerces a value into an array. If the value is already an array-like or iterable, +it is converted to an array. An optional fill value can be provided to map over the elements.

                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Type Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • T
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • arr: T | Iterable<T, any, any> | undefined +

                                                                                                                                      The value to coerce into an array

                                                                                                                                      +
                                                                                                                                    +

                                                                                                                                    Returns NonNullable<T>[]

                                                                                                                                    An array containing the coerced values

                                                                                                                                    + +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    const arr = asArray('hello'); // ['hello']
+
                                                                                                                                    + +
                                                                                                                                    • +
                                                                                                                                  • + +
                                                                                                                                    +

                                                                                                                                    Coerces a value into an array. If the value is already an array-like or iterable, +it is converted to an array. An optional fill value can be provided to map over the elements.

                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Type Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • T
                                                                                                                                      • +
                                                                                                                                    • K
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Parameters

                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • arr: Iterable<T, any, any> | ArrayLike<T> +

                                                                                                                                      The value to coerce into an array

                                                                                                                                      +
                                                                                                                                      • +
                                                                                                                                    • fill: K +

                                                                                                                                      Optional value to map over the elements

                                                                                                                                      +
                                                                                                                                    +

                                                                                                                                    Returns K[]

                                                                                                                                    An array containing the coerced values

                                                                                                                                    + +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    const arr = asArray('hello'); // ['hello']
+
                                                                                                                                    + +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  +

                                                                                                                                  Settings

                                                                                                                                   +
                                                                                                                                  +
                                                                                                                                  Member Visibility +
                                                                                                                                    +
                                                                                                                                    • +
                                                                                                                                    • +
                                                                                                                                  +
                                                                                                                                  +
                                                                                                                                  + +
                                                                                                                                  +
                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asError.html b/packages/tempo/public/v4/api/library/functions/common.index.asError.html new file mode 100644 index 00000000..cc3478fb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asError.html @@ -0,0 +1,56 @@ +asError | Library API
                                                                                                                                  +
                                                                                                                                  Library API + +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    Preparing search index...
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    + +

                                                                                                                                    Function asError

                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                      +
                                                                                                                                    • + +
                                                                                                                                      +

                                                                                                                                      Coerces an unknown value into a proper Error instance. +Preserves the name, message, stack, and code if available.

                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Parameters

                                                                                                                                      +
                                                                                                                                        +
                                                                                                                                      • err: unknown +

                                                                                                                                        The unknown error value

                                                                                                                                        +
                                                                                                                                      +

                                                                                                                                      Returns Error & { code?: string | number }

                                                                                                                                      An Error instance

                                                                                                                                      + +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      const err = asError('Something went wrong');
+
                                                                                                                                      + +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    +

                                                                                                                                    Settings

                                                                                                                                     +
                                                                                                                                    +
                                                                                                                                    Member Visibility +
                                                                                                                                      +
                                                                                                                                      • +
                                                                                                                                      • +
                                                                                                                                    +
                                                                                                                                    +
                                                                                                                                    + +
                                                                                                                                    +
                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asInteger.html b/packages/tempo/public/v4/api/library/functions/common.index.asInteger.html new file mode 100644 index 00000000..d339d691 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asInteger.html @@ -0,0 +1,59 @@ +asInteger | Library API
                                                                                                                                    +
                                                                                                                                    Library API + +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      Preparing search index...
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      + +

                                                                                                                                      Function asInteger

                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                        +
                                                                                                                                      • + +
                                                                                                                                        +

                                                                                                                                        Coerces a String or Number to a BigInt.

                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        +

                                                                                                                                        Type Parameters

                                                                                                                                        +
                                                                                                                                          +
                                                                                                                                        • T extends string | number | bigint
                                                                                                                                        +
                                                                                                                                        +

                                                                                                                                        Parameters

                                                                                                                                        +
                                                                                                                                          +
                                                                                                                                        • Optionalstr: T +

                                                                                                                                          The value to coerce

                                                                                                                                          +
                                                                                                                                        +

                                                                                                                                        Returns bigint

                                                                                                                                        The coerced BigInt

                                                                                                                                        + +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        const big = asInteger(123.45); // 123n
+
                                                                                                                                        + +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      +

                                                                                                                                      Settings

                                                                                                                                       +
                                                                                                                                      +
                                                                                                                                      Member Visibility +
                                                                                                                                        +
                                                                                                                                        • +
                                                                                                                                        • +
                                                                                                                                      +
                                                                                                                                      +
                                                                                                                                      + +
                                                                                                                                      +
                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asNumber.html b/packages/tempo/public/v4/api/library/functions/common.index.asNumber.html new file mode 100644 index 00000000..e2191b1f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asNumber.html @@ -0,0 +1,139 @@ +asNumber | Library API
                                                                                                                                      +
                                                                                                                                      Library API + +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        Preparing search index...
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        + +

                                                                                                                                        Function asNumber

                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                          +
                                                                                                                                        • + +
                                                                                                                                          +

                                                                                                                                          Coerces a value to a finite number. +Returns the finite number if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • val: unknown +

                                                                                                                                            The value to coerce

                                                                                                                                            +
                                                                                                                                          +

                                                                                                                                          Returns number | undefined

                                                                                                                                          The coerced finite number or fallback

                                                                                                                                          + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          asNumber(123);             // 123
                                                                                                                                          asNumber(123n);            // 123
                                                                                                                                          asNumber('123.45');        // 123.45
                                                                                                                                          asNumber('abc');           // undefined
                                                                                                                                          asNumber('abc', 0);        // 0
                                                                                                                                          asNumber(null, 1.0);       // 1.0
+
                                                                                                                                          + +
                                                                                                                                          • +
                                                                                                                                        • + +
                                                                                                                                          +

                                                                                                                                          Coerces a value to a finite number. +Returns the finite number if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • val: unknown +

                                                                                                                                            The value to coerce

                                                                                                                                            +
                                                                                                                                            • +
                                                                                                                                          • fallback: undefined +

                                                                                                                                            Optional fallback if val is not a finite number

                                                                                                                                            +
                                                                                                                                          +

                                                                                                                                          Returns number | undefined

                                                                                                                                          The coerced finite number or fallback

                                                                                                                                          + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          asNumber(123);             // 123
                                                                                                                                          asNumber(123n);            // 123
                                                                                                                                          asNumber('123.45');        // 123.45
                                                                                                                                          asNumber('abc');           // undefined
                                                                                                                                          asNumber('abc', 0);        // 0
                                                                                                                                          asNumber(null, 1.0);       // 1.0
+
                                                                                                                                          + +
                                                                                                                                          • +
                                                                                                                                        • + +
                                                                                                                                          +

                                                                                                                                          Coerces a value to a finite number. +Returns the finite number if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Type Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • T extends number
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • val: unknown +

                                                                                                                                            The value to coerce

                                                                                                                                            +
                                                                                                                                            • +
                                                                                                                                          • fallback: T +

                                                                                                                                            Optional fallback if val is not a finite number

                                                                                                                                            +
                                                                                                                                          +

                                                                                                                                          Returns number

                                                                                                                                          The coerced finite number or fallback

                                                                                                                                          + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          asNumber(123);             // 123
                                                                                                                                          asNumber(123n);            // 123
                                                                                                                                          asNumber('123.45');        // 123.45
                                                                                                                                          asNumber('abc');           // undefined
                                                                                                                                          asNumber('abc', 0);        // 0
                                                                                                                                          asNumber(null, 1.0);       // 1.0
+
                                                                                                                                          + +
                                                                                                                                          • +
                                                                                                                                        • + +
                                                                                                                                          +

                                                                                                                                          Coerces a value to a finite number. +Returns the finite number if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Type Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • T
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Parameters

                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • val: unknown +

                                                                                                                                            The value to coerce

                                                                                                                                            +
                                                                                                                                            • +
                                                                                                                                          • fallback: T +

                                                                                                                                            Optional fallback if val is not a finite number

                                                                                                                                            +
                                                                                                                                          +

                                                                                                                                          Returns number | T

                                                                                                                                          The coerced finite number or fallback

                                                                                                                                          + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          asNumber(123);             // 123
                                                                                                                                          asNumber(123n);            // 123
                                                                                                                                          asNumber('123.45');        // 123.45
                                                                                                                                          asNumber('abc');           // undefined
                                                                                                                                          asNumber('abc', 0);        // 0
                                                                                                                                          asNumber(null, 1.0);       // 1.0
+
                                                                                                                                          + +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        +

                                                                                                                                        Settings

                                                                                                                                         +
                                                                                                                                        +
                                                                                                                                        Member Visibility +
                                                                                                                                          +
                                                                                                                                          • +
                                                                                                                                          • +
                                                                                                                                        +
                                                                                                                                        +
                                                                                                                                        + +
                                                                                                                                        +
                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asObject.html b/packages/tempo/public/v4/api/library/functions/common.index.asObject.html new file mode 100644 index 00000000..606c1d5f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asObject.html @@ -0,0 +1,60 @@ +asObject | Library API
                                                                                                                                        +
                                                                                                                                        Library API + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          Preparing search index...
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          + +

                                                                                                                                          Function asObject

                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                            +
                                                                                                                                          • + +
                                                                                                                                            +

                                                                                                                                            Recursively converts an object or class/host instance with prototype getters into a plain object. +Returns the original value if it is not an object or is nullish, or specialized types (Date, RegExp, Map, Set).

                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            Type Parameters

                                                                                                                                            +
                                                                                                                                              +
                                                                                                                                            • T
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            Parameters

                                                                                                                                            +
                                                                                                                                              +
                                                                                                                                            • Optionalobj: Record<PropertyKey, any> +

                                                                                                                                              The object to convert

                                                                                                                                              +
                                                                                                                                            +

                                                                                                                                            Returns T

                                                                                                                                            A new plain object with copied/evaluated properties

                                                                                                                                            + +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            const copy = asObject({ a: 1 });
+
                                                                                                                                            + +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          +

                                                                                                                                          Settings

                                                                                                                                           +
                                                                                                                                          +
                                                                                                                                          Member Visibility +
                                                                                                                                            +
                                                                                                                                            • +
                                                                                                                                            • +
                                                                                                                                          +
                                                                                                                                          +
                                                                                                                                          + +
                                                                                                                                          +
                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asString.html b/packages/tempo/public/v4/api/library/functions/common.index.asString.html new file mode 100644 index 00000000..4e8ad48a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asString.html @@ -0,0 +1,59 @@ +asString | Library API
                                                                                                                                          +
                                                                                                                                          Library API + +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            Preparing search index...
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            + +

                                                                                                                                            Function asString

                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                              +
                                                                                                                                            • + +
                                                                                                                                              +

                                                                                                                                              Coerces a value to a string using serialization if it is not nullish.

                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              +

                                                                                                                                              Type Parameters

                                                                                                                                              +
                                                                                                                                                +
                                                                                                                                              • T
                                                                                                                                              +
                                                                                                                                              +

                                                                                                                                              Parameters

                                                                                                                                              +
                                                                                                                                                +
                                                                                                                                              • Optionalstr: T +

                                                                                                                                                The value to coerce to a string

                                                                                                                                                +
                                                                                                                                              +

                                                                                                                                              Returns string

                                                                                                                                              The stringified value, or an empty string if nullish

                                                                                                                                              + +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              const str = asString({ a: 1 }); // '{"a":1}'
+
                                                                                                                                              + +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            +

                                                                                                                                            Settings

                                                                                                                                             +
                                                                                                                                            +
                                                                                                                                            Member Visibility +
                                                                                                                                              +
                                                                                                                                              • +
                                                                                                                                              • +
                                                                                                                                            +
                                                                                                                                            +
                                                                                                                                            + +
                                                                                                                                            +
                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asText.html b/packages/tempo/public/v4/api/library/functions/common.index.asText.html new file mode 100644 index 00000000..e906f5bb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asText.html @@ -0,0 +1,148 @@ +asText | Library API
                                                                                                                                            +
                                                                                                                                            Library API + +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              Preparing search index...
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              + +

                                                                                                                                              Function asText

                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                                +
                                                                                                                                              • + +
                                                                                                                                                +

                                                                                                                                                Coerces a value to a cleaned, non-empty string. +Returns the trimmed string if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • str: unknown +

                                                                                                                                                  The value to normalize

                                                                                                                                                  +
                                                                                                                                                +

                                                                                                                                                Returns string | undefined

                                                                                                                                                The cleaned string or fallback

                                                                                                                                                + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                asText('  hello  ');              // 'hello'
                                                                                                                                                asText('   ');                    // undefined
                                                                                                                                                asText(123);                      // undefined
                                                                                                                                                asText('   ', 'en-US');           // 'en-US'
                                                                                                                                                asText(' a \t b \n', null, true); // 'a b'
+
                                                                                                                                                + +
                                                                                                                                                • +
                                                                                                                                              • + +
                                                                                                                                                +

                                                                                                                                                Coerces a value to a cleaned, non-empty string. +Returns the trimmed string if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • str: unknown +

                                                                                                                                                  The value to normalize

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • fallback: undefined +

                                                                                                                                                  Optional fallback if str is not a valid non-empty string

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • OptionaldeepClean: boolean +

                                                                                                                                                  If true, applies trimAll to normalize tabs, newlines, and collapsed spaces

                                                                                                                                                  +
                                                                                                                                                +

                                                                                                                                                Returns string | undefined

                                                                                                                                                The cleaned string or fallback

                                                                                                                                                + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                asText('  hello  ');              // 'hello'
                                                                                                                                                asText('   ');                    // undefined
                                                                                                                                                asText(123);                      // undefined
                                                                                                                                                asText('   ', 'en-US');           // 'en-US'
                                                                                                                                                asText(' a \t b \n', null, true); // 'a b'
+
                                                                                                                                                + +
                                                                                                                                                • +
                                                                                                                                              • + +
                                                                                                                                                +

                                                                                                                                                Coerces a value to a cleaned, non-empty string. +Returns the trimmed string if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • T extends string
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • str: unknown +

                                                                                                                                                  The value to normalize

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • fallback: T +

                                                                                                                                                  Optional fallback if str is not a valid non-empty string

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • OptionaldeepClean: boolean +

                                                                                                                                                  If true, applies trimAll to normalize tabs, newlines, and collapsed spaces

                                                                                                                                                  +
                                                                                                                                                +

                                                                                                                                                Returns string

                                                                                                                                                The cleaned string or fallback

                                                                                                                                                + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                asText('  hello  ');              // 'hello'
                                                                                                                                                asText('   ');                    // undefined
                                                                                                                                                asText(123);                      // undefined
                                                                                                                                                asText('   ', 'en-US');           // 'en-US'
                                                                                                                                                asText(' a \t b \n', null, true); // 'a b'
+
                                                                                                                                                + +
                                                                                                                                                • +
                                                                                                                                              • + +
                                                                                                                                                +

                                                                                                                                                Coerces a value to a cleaned, non-empty string. +Returns the trimmed string if valid, otherwise returns undefined (or an optional fallback).

                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Type Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • T
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Parameters

                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • str: unknown +

                                                                                                                                                  The value to normalize

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • fallback: T +

                                                                                                                                                  Optional fallback if str is not a valid non-empty string

                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                • OptionaldeepClean: boolean +

                                                                                                                                                  If true, applies trimAll to normalize tabs, newlines, and collapsed spaces

                                                                                                                                                  +
                                                                                                                                                +

                                                                                                                                                Returns string | T

                                                                                                                                                The cleaned string or fallback

                                                                                                                                                + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                asText('  hello  ');              // 'hello'
                                                                                                                                                asText('   ');                    // undefined
                                                                                                                                                asText(123);                      // undefined
                                                                                                                                                asText('   ', 'en-US');           // 'en-US'
                                                                                                                                                asText(' a \t b \n', null, true); // 'a b'
+
                                                                                                                                                + +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              +

                                                                                                                                              Settings

                                                                                                                                               +
                                                                                                                                              +
                                                                                                                                              Member Visibility +
                                                                                                                                                +
                                                                                                                                                • +
                                                                                                                                                • +
                                                                                                                                              +
                                                                                                                                              +
                                                                                                                                              + +
                                                                                                                                              +
                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asTime.html b/packages/tempo/public/v4/api/library/functions/common.index.asTime.html new file mode 100644 index 00000000..2806dd1d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asTime.html @@ -0,0 +1,55 @@ +asTime | Library API
                                                                                                                                              +
                                                                                                                                              Library API + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                Preparing search index...
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                + +

                                                                                                                                                Function asTime

                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                  +
                                                                                                                                                • + +
                                                                                                                                                  +

                                                                                                                                                  Removes the colon from an HH:MI time string and returns it as a number.

                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  +

                                                                                                                                                  Parameters

                                                                                                                                                  +
                                                                                                                                                    +
                                                                                                                                                  • hhmi: string | number +

                                                                                                                                                    The time string (e.g., '14:30')

                                                                                                                                                    +
                                                                                                                                                  +

                                                                                                                                                  Returns number

                                                                                                                                                  The numeric representation (e.g., 1430)

                                                                                                                                                  + +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  asTime('14:30'); // 1430
+
                                                                                                                                                  + +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                +

                                                                                                                                                Settings

                                                                                                                                                 +
                                                                                                                                                +
                                                                                                                                                Member Visibility +
                                                                                                                                                  +
                                                                                                                                                  • +
                                                                                                                                                  • +
                                                                                                                                                +
                                                                                                                                                +
                                                                                                                                                + +
                                                                                                                                                +
                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.asType.html b/packages/tempo/public/v4/api/library/functions/common.index.asType.html new file mode 100644 index 00000000..3f9b4906 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.asType.html @@ -0,0 +1,62 @@ +asType | Library API
                                                                                                                                                +
                                                                                                                                                Library API + +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  Preparing search index...
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  + +

                                                                                                                                                  Function asType

                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                    +
                                                                                                                                                  • + +
                                                                                                                                                    +

                                                                                                                                                    Wraps a value in a TypeValue object containing both its determined type and the original value.

                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    +

                                                                                                                                                    Type Parameters

                                                                                                                                                    +
                                                                                                                                                      +
                                                                                                                                                    • T
                                                                                                                                                    +
                                                                                                                                                    +

                                                                                                                                                    Parameters

                                                                                                                                                    +
                                                                                                                                                      +
                                                                                                                                                    • Optionalvalue: T +

                                                                                                                                                      The value to wrap

                                                                                                                                                      +
                                                                                                                                                      • +
                                                                                                                                                    • ...instances: Instance[] +

                                                                                                                                                      Optional list of additional custom instances to check against for typing

                                                                                                                                                      +
                                                                                                                                                    +

                                                                                                                                                    Returns TypeValue<T>

                                                                                                                                                    A TypeValue wrapper object

                                                                                                                                                    + +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    const wrapper = asType('hello'); // { type: 'String', value: 'hello' }
+
                                                                                                                                                    + +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  +

                                                                                                                                                  Settings

                                                                                                                                                   +
                                                                                                                                                  +
                                                                                                                                                  Member Visibility +
                                                                                                                                                    +
                                                                                                                                                    • +
                                                                                                                                                    • +
                                                                                                                                                  +
                                                                                                                                                  +
                                                                                                                                                  + +
                                                                                                                                                  +
                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.assertCondition.html b/packages/tempo/public/v4/api/library/functions/common.index.assertCondition.html new file mode 100644 index 00000000..60df0eed --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.assertCondition.html @@ -0,0 +1,60 @@ +assertCondition | Library API
                                                                                                                                                  +
                                                                                                                                                  Library API + +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    Preparing search index...
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    + +

                                                                                                                                                    Function assertCondition

                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                      +
                                                                                                                                                    • + +
                                                                                                                                                      +

                                                                                                                                                      Asserts a condition is true, otherwise throws an Error.

                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +

                                                                                                                                                      Parameters

                                                                                                                                                      +
                                                                                                                                                        +
                                                                                                                                                      • condition: boolean +

                                                                                                                                                        The boolean condition that must be true

                                                                                                                                                        +
                                                                                                                                                        • +
                                                                                                                                                      • Optionalmessage: string +

                                                                                                                                                        The error message to throw if the condition is false

                                                                                                                                                        +
                                                                                                                                                      +

                                                                                                                                                      Returns asserts condition

                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +

                                                                                                                                                      If the condition evaluates to false

                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      assertCondition(user.isLoggedIn, 'User must be logged in');
+
                                                                                                                                                      + +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    +

                                                                                                                                                    Settings

                                                                                                                                                     +
                                                                                                                                                    +
                                                                                                                                                    Member Visibility +
                                                                                                                                                      +
                                                                                                                                                      • +
                                                                                                                                                      • +
                                                                                                                                                    +
                                                                                                                                                    +
                                                                                                                                                    + +
                                                                                                                                                    +
                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.assertNever.html b/packages/tempo/public/v4/api/library/functions/common.index.assertNever.html new file mode 100644 index 00000000..4679d5a2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.assertNever.html @@ -0,0 +1,52 @@ +assertNever | Library API
                                                                                                                                                    +
                                                                                                                                                    Library API + +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      Preparing search index...
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      + +

                                                                                                                                                      Function assertNever

                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                        +
                                                                                                                                                      • + +
                                                                                                                                                        +

                                                                                                                                                        A TypeScript exhaustiveness check that throws an error if reached at runtime.

                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Parameters

                                                                                                                                                        +
                                                                                                                                                          +
                                                                                                                                                        • val: never +

                                                                                                                                                          The value that should never exist

                                                                                                                                                          +
                                                                                                                                                        +

                                                                                                                                                        Returns asserts val is never

                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Always throws an error

                                                                                                                                                        +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      +

                                                                                                                                                      Settings

                                                                                                                                                       +
                                                                                                                                                      +
                                                                                                                                                      Member Visibility +
                                                                                                                                                        +
                                                                                                                                                        • +
                                                                                                                                                        • +
                                                                                                                                                      +
                                                                                                                                                      +
                                                                                                                                                      + +
                                                                                                                                                      +
                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.assertString.html b/packages/tempo/public/v4/api/library/functions/common.index.assertString.html new file mode 100644 index 00000000..f8d439e6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.assertString.html @@ -0,0 +1,52 @@ +assertString | Library API
                                                                                                                                                      +
                                                                                                                                                      Library API + +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        Preparing search index...
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        + +

                                                                                                                                                        Function assertString

                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                          +
                                                                                                                                                        • + +
                                                                                                                                                          +

                                                                                                                                                          Asserts a value is a string, otherwise throws an Error.

                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +

                                                                                                                                                          Parameters

                                                                                                                                                          +
                                                                                                                                                            +
                                                                                                                                                          • str: unknown +

                                                                                                                                                            The value to assert as a string

                                                                                                                                                            +
                                                                                                                                                          +

                                                                                                                                                          Returns asserts str is string

                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +

                                                                                                                                                          If the value is not a string

                                                                                                                                                          +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        +

                                                                                                                                                        Settings

                                                                                                                                                         +
                                                                                                                                                        +
                                                                                                                                                        Member Visibility +
                                                                                                                                                          +
                                                                                                                                                          • +
                                                                                                                                                          • +
                                                                                                                                                        +
                                                                                                                                                        +
                                                                                                                                                        + +
                                                                                                                                                        +
                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.base64ToBase64Url.html b/packages/tempo/public/v4/api/library/functions/common.index.base64ToBase64Url.html new file mode 100644 index 00000000..890f30bc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.base64ToBase64Url.html @@ -0,0 +1,56 @@ +base64ToBase64Url | Library API
                                                                                                                                                        +
                                                                                                                                                        Library API + +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          Preparing search index...
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          + +

                                                                                                                                                          Function base64ToBase64Url

                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                            +
                                                                                                                                                          • + +
                                                                                                                                                            +

                                                                                                                                                            Normalizes a standard Base64 string into a URL-safe Base64URL string (RFC 4648 §5). +Replaces + with -, / with _, and strips trailing = padding.

                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            +

                                                                                                                                                            Parameters

                                                                                                                                                            +
                                                                                                                                                              +
                                                                                                                                                            • base64: string +

                                                                                                                                                              The standard Base64 string to convert

                                                                                                                                                              +
                                                                                                                                                            +

                                                                                                                                                            Returns string

                                                                                                                                                            The URL-safe Base64URL string

                                                                                                                                                            + +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            const url = base64ToBase64Url('+/8='); // '-_8'
+
                                                                                                                                                            + +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          +

                                                                                                                                                          Settings

                                                                                                                                                           +
                                                                                                                                                          +
                                                                                                                                                          Member Visibility +
                                                                                                                                                            +
                                                                                                                                                            • +
                                                                                                                                                            • +
                                                                                                                                                          +
                                                                                                                                                          +
                                                                                                                                                          + +
                                                                                                                                                          +
                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.base64ToBuffer.html b/packages/tempo/public/v4/api/library/functions/common.index.base64ToBuffer.html new file mode 100644 index 00000000..fc39fb40 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.base64ToBuffer.html @@ -0,0 +1,56 @@ +base64ToBuffer | Library API
                                                                                                                                                          +
                                                                                                                                                          Library API + +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            Preparing search index...
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            + +

                                                                                                                                                            Function base64ToBuffer

                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                              +
                                                                                                                                                            • + +
                                                                                                                                                              +

                                                                                                                                                              Decodes a Base64 string into a raw Uint8Array. +Uses native Buffer in Node.js and fallbacks to atob in browsers.

                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              +

                                                                                                                                                              Parameters

                                                                                                                                                              +
                                                                                                                                                                +
                                                                                                                                                              • base64: string +

                                                                                                                                                                The Base64 string to decode

                                                                                                                                                                +
                                                                                                                                                              +

                                                                                                                                                              Returns Uint8Array<ArrayBuffer>

                                                                                                                                                              A Uint8Array of the decoded data

                                                                                                                                                              + +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              const buf = base64ToBuffer('aGk=');
+
                                                                                                                                                              + +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            +

                                                                                                                                                            Settings

                                                                                                                                                             +
                                                                                                                                                            +
                                                                                                                                                            Member Visibility +
                                                                                                                                                              +
                                                                                                                                                              • +
                                                                                                                                                              • +
                                                                                                                                                            +
                                                                                                                                                            +
                                                                                                                                                            + +
                                                                                                                                                            +
                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBase64.html b/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBase64.html new file mode 100644 index 00000000..f7e50c85 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBase64.html @@ -0,0 +1,56 @@ +base64UrlToBase64 | Library API
                                                                                                                                                            +
                                                                                                                                                            Library API + +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              Preparing search index...
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              + +

                                                                                                                                                              Function base64UrlToBase64

                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                                +
                                                                                                                                                              • + +
                                                                                                                                                                +

                                                                                                                                                                Normalizes a URL-safe Base64URL string back into a standard Base64 string. +Replaces - with +, _ with /, and restores = padding using padTo.

                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                +

                                                                                                                                                                Parameters

                                                                                                                                                                +
                                                                                                                                                                  +
                                                                                                                                                                • base64url: string +

                                                                                                                                                                  The Base64URL string to convert

                                                                                                                                                                  +
                                                                                                                                                                +

                                                                                                                                                                Returns string

                                                                                                                                                                The standard Base64 string with padding restored

                                                                                                                                                                + +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                const b64 = base64UrlToBase64('-_8'); // '+/8='
+
                                                                                                                                                                + +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              +

                                                                                                                                                              Settings

                                                                                                                                                               +
                                                                                                                                                              +
                                                                                                                                                              Member Visibility +
                                                                                                                                                                +
                                                                                                                                                                • +
                                                                                                                                                                • +
                                                                                                                                                              +
                                                                                                                                                              +
                                                                                                                                                              + +
                                                                                                                                                              +
                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBuffer.html b/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBuffer.html new file mode 100644 index 00000000..9eafa15b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.base64UrlToBuffer.html @@ -0,0 +1,59 @@ +base64UrlToBuffer | Library API
                                                                                                                                                              +
                                                                                                                                                              Library API + +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                Preparing search index...
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                + +

                                                                                                                                                                Function base64UrlToBuffer

                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                  +
                                                                                                                                                                • + +
                                                                                                                                                                  +

                                                                                                                                                                  Decodes a URL-safe Base64URL string into a raw Uint8Array buffer. +Validates that the input contains only valid Base64URL characters and valid segment length.

                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +

                                                                                                                                                                  Parameters

                                                                                                                                                                  +
                                                                                                                                                                    +
                                                                                                                                                                  • part: string +

                                                                                                                                                                    The Base64URL string to decode

                                                                                                                                                                    +
                                                                                                                                                                  +

                                                                                                                                                                  Returns Uint8Array

                                                                                                                                                                  A Uint8Array of the decoded data

                                                                                                                                                                  + +
                                                                                                                                                                  +
                                                                                                                                                                  +

                                                                                                                                                                  If the string contains invalid characters or an impossible segment length (length % 4 === 1)

                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  const buf = base64UrlToBuffer('a-b_');
+
                                                                                                                                                                  + +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                +

                                                                                                                                                                Settings

                                                                                                                                                                 +
                                                                                                                                                                +
                                                                                                                                                                Member Visibility +
                                                                                                                                                                  +
                                                                                                                                                                  • +
                                                                                                                                                                  • +
                                                                                                                                                                +
                                                                                                                                                                +
                                                                                                                                                                + +
                                                                                                                                                                +
                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64.html b/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64.html new file mode 100644 index 00000000..fdd4b221 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64.html @@ -0,0 +1,56 @@ +bufferToBase64 | Library API
                                                                                                                                                                +
                                                                                                                                                                Library API + +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  Preparing search index...
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  + +

                                                                                                                                                                  Function bufferToBase64

                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                    +
                                                                                                                                                                  • + +
                                                                                                                                                                    +

                                                                                                                                                                    Encodes a raw Uint8Array into a Base64 string. +Uses native Buffer in Node.js and fallbacks to btoa in browsers.

                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    +

                                                                                                                                                                    Parameters

                                                                                                                                                                    +
                                                                                                                                                                      +
                                                                                                                                                                    • buffer: Uint8Array +

                                                                                                                                                                      The raw Uint8Array to encode

                                                                                                                                                                      +
                                                                                                                                                                    +

                                                                                                                                                                    Returns string

                                                                                                                                                                    The Base64 string representation

                                                                                                                                                                    + +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    const b64 = bufferToBase64(new Uint8Array([104, 105]));
+
                                                                                                                                                                    + +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  +

                                                                                                                                                                  Settings

                                                                                                                                                                   +
                                                                                                                                                                  +
                                                                                                                                                                  Member Visibility +
                                                                                                                                                                    +
                                                                                                                                                                    • +
                                                                                                                                                                    • +
                                                                                                                                                                  +
                                                                                                                                                                  +
                                                                                                                                                                  + +
                                                                                                                                                                  +
                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64Url.html b/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64Url.html new file mode 100644 index 00000000..67dbdb65 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.bufferToBase64Url.html @@ -0,0 +1,55 @@ +bufferToBase64Url | Library API
                                                                                                                                                                  +
                                                                                                                                                                  Library API + +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    Preparing search index...
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    + +

                                                                                                                                                                    Function bufferToBase64Url

                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                      +
                                                                                                                                                                    • + +
                                                                                                                                                                      +

                                                                                                                                                                      Encodes a raw Uint8Array buffer into a URL-safe Base64URL string.

                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      +

                                                                                                                                                                      Parameters

                                                                                                                                                                      +
                                                                                                                                                                        +
                                                                                                                                                                      • buffer: Uint8Array +

                                                                                                                                                                        The raw buffer to encode

                                                                                                                                                                        +
                                                                                                                                                                      +

                                                                                                                                                                      Returns string

                                                                                                                                                                      The Base64URL string representation

                                                                                                                                                                      + +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      const str = bufferToBase64Url(new Uint8Array([104, 105]));
+
                                                                                                                                                                      + +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    +

                                                                                                                                                                    Settings

                                                                                                                                                                     +
                                                                                                                                                                    +
                                                                                                                                                                    Member Visibility +
                                                                                                                                                                      +
                                                                                                                                                                      • +
                                                                                                                                                                      • +
                                                                                                                                                                    +
                                                                                                                                                                    +
                                                                                                                                                                    + +
                                                                                                                                                                    +
                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.byKey.html b/packages/tempo/public/v4/api/library/functions/common.index.byKey.html new file mode 100644 index 00000000..3ec7e5f2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.byKey.html @@ -0,0 +1,117 @@ +byKey | Library API
                                                                                                                                                                    +
                                                                                                                                                                    Library API + +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      Preparing search index...
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      + +

                                                                                                                                                                      Function byKey

                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                        +
                                                                                                                                                                      • + +
                                                                                                                                                                        +

                                                                                                                                                                        Groups an array by the return value of a callback function.

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Type Parameters

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • T
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Parameters

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • arr: T[] +

                                                                                                                                                                          The array of items to group

                                                                                                                                                                          +
                                                                                                                                                                          • +
                                                                                                                                                                        • grpFn: GroupFn<T> +

                                                                                                                                                                          The callback function returning the group key

                                                                                                                                                                          +
                                                                                                                                                                        +

                                                                                                                                                                        Returns Record<PropertyKey, T[]>

                                                                                                                                                                        A record containing arrays of grouped items

                                                                                                                                                                        + +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        const groups = byKey([{ id: 1, type: 'A' }, { id: 2, type: 'A' }], itm => itm.type);
+
                                                                                                                                                                        + +
                                                                                                                                                                        • +
                                                                                                                                                                      • + +
                                                                                                                                                                        +

                                                                                                                                                                        Groups an array of objects by a sequence of key fields.

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Type Parameters

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Parameters

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • arr: T[] +

                                                                                                                                                                          The array of objects to group

                                                                                                                                                                          +
                                                                                                                                                                          • +
                                                                                                                                                                        • key1: keyof T
                                                                                                                                                                          • +
                                                                                                                                                                        • ...keys: (keyof T)[] +

                                                                                                                                                                          The sequence of object keys to group by

                                                                                                                                                                          +
                                                                                                                                                                        +

                                                                                                                                                                        Returns Record<PropertyKey, T[]>

                                                                                                                                                                        A record containing arrays of grouped objects

                                                                                                                                                                        + +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        const groups = byKey(users, 'department', 'role');
+
                                                                                                                                                                        + +
                                                                                                                                                                        • +
                                                                                                                                                                      • + +
                                                                                                                                                                        +

                                                                                                                                                                        Groups an array by the return value of a callback function.

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Type Parameters

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Parameters

                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • arr: T[] +

                                                                                                                                                                          The array of items to group

                                                                                                                                                                          +
                                                                                                                                                                          • +
                                                                                                                                                                        • ...keys: (keyof T)[]
                                                                                                                                                                        +

                                                                                                                                                                        Returns Record<PropertyKey, T[]>

                                                                                                                                                                        A record containing arrays of grouped items

                                                                                                                                                                        + +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        const groups = byKey([{ id: 1, type: 'A' }, { id: 2, type: 'A' }], itm => itm.type);
+
                                                                                                                                                                        + +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      +

                                                                                                                                                                      Settings

                                                                                                                                                                       +
                                                                                                                                                                      +
                                                                                                                                                                      Member Visibility +
                                                                                                                                                                        +
                                                                                                                                                                        • +
                                                                                                                                                                        • +
                                                                                                                                                                      +
                                                                                                                                                                      +
                                                                                                                                                                      + +
                                                                                                                                                                      +
                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.byLkp.html b/packages/tempo/public/v4/api/library/functions/common.index.byLkp.html new file mode 100644 index 00000000..317df0a1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.byLkp.html @@ -0,0 +1,117 @@ +byLkp | Library API
                                                                                                                                                                      +
                                                                                                                                                                      Library API + +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        Preparing search index...
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        + +

                                                                                                                                                                        Function byLkp

                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                          +
                                                                                                                                                                        • + +
                                                                                                                                                                          +

                                                                                                                                                                          Groups an array of objects by a callback function, retaining only the last entry per group.

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Type Parameters

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Parameters

                                                                                                                                                                          +
                                                                                                                                                                            +
                                                                                                                                                                          • arr: T[] +

                                                                                                                                                                            The array of objects to group

                                                                                                                                                                            +
                                                                                                                                                                            • +
                                                                                                                                                                          • grpFn: GroupFn<T> +

                                                                                                                                                                            The callback function returning the group key

                                                                                                                                                                            +
                                                                                                                                                                          +

                                                                                                                                                                          Returns Record<PropertyKey, T>

                                                                                                                                                                          A record containing the last object from each group

                                                                                                                                                                          + +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          const latest = byLkp(events, ev => ev.id);
+
                                                                                                                                                                          + +
                                                                                                                                                                          • +
                                                                                                                                                                        • + +
                                                                                                                                                                          +

                                                                                                                                                                          Groups an array of objects by key fields, retaining only the last entry per group.

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Type Parameters

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Parameters

                                                                                                                                                                          +
                                                                                                                                                                            +
                                                                                                                                                                          • arr: T[] +

                                                                                                                                                                            The array of objects to group

                                                                                                                                                                            +
                                                                                                                                                                            • +
                                                                                                                                                                          • key1: keyof T
                                                                                                                                                                            • +
                                                                                                                                                                          • ...keys: (keyof T)[] +

                                                                                                                                                                            The sequence of object keys to group by

                                                                                                                                                                            +
                                                                                                                                                                          +

                                                                                                                                                                          Returns Record<PropertyKey, T>

                                                                                                                                                                          A record containing the last object from each group

                                                                                                                                                                          + +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          const latest = byLkp(events, 'type');
+
                                                                                                                                                                          + +
                                                                                                                                                                          • +
                                                                                                                                                                        • + +
                                                                                                                                                                          +

                                                                                                                                                                          Groups an array of objects by a callback function, retaining only the last entry per group.

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Type Parameters

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Parameters

                                                                                                                                                                          +
                                                                                                                                                                            +
                                                                                                                                                                          • arr: T[] +

                                                                                                                                                                            The array of objects to group

                                                                                                                                                                            +
                                                                                                                                                                            • +
                                                                                                                                                                          • ...keys: (keyof T)[]
                                                                                                                                                                          +

                                                                                                                                                                          Returns Record<keyof T, T>

                                                                                                                                                                          A record containing the last object from each group

                                                                                                                                                                          + +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          const latest = byLkp(events, ev => ev.id);
+
                                                                                                                                                                          + +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        +

                                                                                                                                                                        Settings

                                                                                                                                                                         +
                                                                                                                                                                        +
                                                                                                                                                                        Member Visibility +
                                                                                                                                                                          +
                                                                                                                                                                          • +
                                                                                                                                                                          • +
                                                                                                                                                                        +
                                                                                                                                                                        +
                                                                                                                                                                        + +
                                                                                                                                                                        +
                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.cartesian.html b/packages/tempo/public/v4/api/library/functions/common.index.cartesian.html new file mode 100644 index 00000000..26980cd7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.cartesian.html @@ -0,0 +1,59 @@ +cartesian | Library API
                                                                                                                                                                        +
                                                                                                                                                                        Library API + +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          Preparing search index...
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          + +

                                                                                                                                                                          Function cartesian

                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                            +
                                                                                                                                                                          • + +
                                                                                                                                                                            +

                                                                                                                                                                            Generates the cartesian product of multiple arrays.

                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            Type Parameters

                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • T
                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            Parameters

                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • ...args: T[][] +

                                                                                                                                                                              The arrays to combine

                                                                                                                                                                              +
                                                                                                                                                                            +

                                                                                                                                                                            Returns T[][]

                                                                                                                                                                            An array of combinations (each combination is an array)

                                                                                                                                                                            + +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            cartesian([1, 2], ['a', 'b']); // [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+
                                                                                                                                                                            + +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          +

                                                                                                                                                                          Settings

                                                                                                                                                                           +
                                                                                                                                                                          +
                                                                                                                                                                          Member Visibility +
                                                                                                                                                                            +
                                                                                                                                                                            • +
                                                                                                                                                                            • +
                                                                                                                                                                          +
                                                                                                                                                                          +
                                                                                                                                                                          + +
                                                                                                                                                                          +
                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.cast.html b/packages/tempo/public/v4/api/library/functions/common.index.cast.html new file mode 100644 index 00000000..c072701a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.cast.html @@ -0,0 +1,59 @@ +cast | Library API
                                                                                                                                                                          +
                                                                                                                                                                          Library API + +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            Preparing search index...
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            + +

                                                                                                                                                                            Function cast

                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                              +
                                                                                                                                                                            • + +
                                                                                                                                                                              +

                                                                                                                                                                              Ergonomically coerces any runtime value to type T, eliminating as unknown as T / as any as T double-assertions.

                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              +

                                                                                                                                                                              Type Parameters

                                                                                                                                                                              +
                                                                                                                                                                                +
                                                                                                                                                                              • T = any
                                                                                                                                                                              +
                                                                                                                                                                              +

                                                                                                                                                                              Parameters

                                                                                                                                                                              +
                                                                                                                                                                                +
                                                                                                                                                                              • value: any +

                                                                                                                                                                                The value to cast

                                                                                                                                                                                +
                                                                                                                                                                              +

                                                                                                                                                                              Returns T

                                                                                                                                                                              The value typed as T

                                                                                                                                                                              + +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              const instance = cast<Ticker.Instance>(proxy);
+
                                                                                                                                                                              + +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            +

                                                                                                                                                                            Settings

                                                                                                                                                                             +
                                                                                                                                                                            +
                                                                                                                                                                            Member Visibility +
                                                                                                                                                                              +
                                                                                                                                                                              • +
                                                                                                                                                                              • +
                                                                                                                                                                            +
                                                                                                                                                                            +
                                                                                                                                                                            + +
                                                                                                                                                                            +
                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.cleanify.html b/packages/tempo/public/v4/api/library/functions/common.index.cleanify.html new file mode 100644 index 00000000..73962f48 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.cleanify.html @@ -0,0 +1,60 @@ +cleanify | Library API
                                                                                                                                                                            +
                                                                                                                                                                            Library API + +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              Preparing search index...
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              + +

                                                                                                                                                                              Function cleanify

                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                                +
                                                                                                                                                                              • + +
                                                                                                                                                                                +

                                                                                                                                                                                Returns a JSON-clean copy of an object by stringifying and re-parsing. +This inherently removes unsupported values like functions and undefined.

                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                +

                                                                                                                                                                                Type Parameters

                                                                                                                                                                                +
                                                                                                                                                                                  +
                                                                                                                                                                                • T
                                                                                                                                                                                +
                                                                                                                                                                                +

                                                                                                                                                                                Parameters

                                                                                                                                                                                +
                                                                                                                                                                                  +
                                                                                                                                                                                • obj: T +

                                                                                                                                                                                  The object to clean

                                                                                                                                                                                  +
                                                                                                                                                                                +

                                                                                                                                                                                Returns T

                                                                                                                                                                                A clean, JSON-compatible object

                                                                                                                                                                                + +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                const clean = cleanify({ a: 1, b: undefined }); // { a: 1 }
+
                                                                                                                                                                                + +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              +

                                                                                                                                                                              Settings

                                                                                                                                                                               +
                                                                                                                                                                              +
                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                +
                                                                                                                                                                                • +
                                                                                                                                                                                • +
                                                                                                                                                                              +
                                                                                                                                                                              +
                                                                                                                                                                              + +
                                                                                                                                                                              +
                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.cleanupSignal.html b/packages/tempo/public/v4/api/library/functions/common.index.cleanupSignal.html new file mode 100644 index 00000000..b1338926 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.cleanupSignal.html @@ -0,0 +1,48 @@ +cleanupSignal | Library API
                                                                                                                                                                              +
                                                                                                                                                                              Library API + +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                + +

                                                                                                                                                                                Function cleanupSignal

                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                  +
                                                                                                                                                                                • + +
                                                                                                                                                                                  +

                                                                                                                                                                                  Safely releases a composed signal or timeout signal by unbinding its listeners from any parent signals.

                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  +

                                                                                                                                                                                  Parameters

                                                                                                                                                                                  +
                                                                                                                                                                                    +
                                                                                                                                                                                  • Optionalsignal: any +

                                                                                                                                                                                    The AbortSignal to clean up

                                                                                                                                                                                    +
                                                                                                                                                                                  +

                                                                                                                                                                                  Returns void

                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                +

                                                                                                                                                                                Settings

                                                                                                                                                                                 +
                                                                                                                                                                                +
                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                  +
                                                                                                                                                                                  • +
                                                                                                                                                                                  • +
                                                                                                                                                                                +
                                                                                                                                                                                +
                                                                                                                                                                                + +
                                                                                                                                                                                +
                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.clear.html b/packages/tempo/public/v4/api/library/functions/common.index.clear.html new file mode 100644 index 00000000..9de1b147 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.clear.html @@ -0,0 +1,59 @@ +clear | Library API
                                                                                                                                                                                +
                                                                                                                                                                                Library API + +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  + +

                                                                                                                                                                                  Function clear

                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                    +
                                                                                                                                                                                  • + +
                                                                                                                                                                                    +

                                                                                                                                                                                    Clears an array in-place, removing all elements and filling with null before truncation.

                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • T
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Parameters

                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • arr: T[] +

                                                                                                                                                                                      The array to clear

                                                                                                                                                                                      +
                                                                                                                                                                                    +

                                                                                                                                                                                    Returns T[]

                                                                                                                                                                                    The cleared array

                                                                                                                                                                                    + +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    const arr = [1, 2, 3];
                                                                                                                                                                                    clear(arr); // arr is now []
+
                                                                                                                                                                                    + +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  +

                                                                                                                                                                                  Settings

                                                                                                                                                                                   +
                                                                                                                                                                                  +
                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                    +
                                                                                                                                                                                    • +
                                                                                                                                                                                    • +
                                                                                                                                                                                  +
                                                                                                                                                                                  +
                                                                                                                                                                                  + +
                                                                                                                                                                                  +
                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.clearCache.html b/packages/tempo/public/v4/api/library/functions/common.index.clearCache.html new file mode 100644 index 00000000..a4c16417 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.clearCache.html @@ -0,0 +1,54 @@ +clearCache | Library API
                                                                                                                                                                                  +
                                                                                                                                                                                  Library API + +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    + +

                                                                                                                                                                                    Function clearCache

                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                      +
                                                                                                                                                                                    • + +
                                                                                                                                                                                      +

                                                                                                                                                                                      Manually clears the memoization cache for an object instance.

                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +

                                                                                                                                                                                      Parameters

                                                                                                                                                                                      +
                                                                                                                                                                                        +
                                                                                                                                                                                      • obj: object +

                                                                                                                                                                                        The object whose cache should be cleared

                                                                                                                                                                                        +
                                                                                                                                                                                      +

                                                                                                                                                                                      Returns void

                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      clearCache(myInstance);
+
                                                                                                                                                                                      + +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    +

                                                                                                                                                                                    Settings

                                                                                                                                                                                     +
                                                                                                                                                                                    +
                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                      +
                                                                                                                                                                                      • +
                                                                                                                                                                                      • +
                                                                                                                                                                                    +
                                                                                                                                                                                    +
                                                                                                                                                                                    + +
                                                                                                                                                                                    +
                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.clearStashedGeo.html b/packages/tempo/public/v4/api/library/functions/common.index.clearStashedGeo.html new file mode 100644 index 00000000..75ca8c76 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.clearStashedGeo.html @@ -0,0 +1,49 @@ +clearStashedGeo | Library API
                                                                                                                                                                                    +
                                                                                                                                                                                    Library API + +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      + +

                                                                                                                                                                                      Function clearStashedGeo

                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                        +
                                                                                                                                                                                      • + +
                                                                                                                                                                                        +

                                                                                                                                                                                        Clears stashed geolocation coordinates from storage. +Supports optional tenant key or options object for multi-tenant isolation.

                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Parameters

                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • OptionalkeyOrOpts: string | Record<string, any> +

                                                                                                                                                                                          Optional tenant key or lookup options containing key/ip

                                                                                                                                                                                          +
                                                                                                                                                                                        +

                                                                                                                                                                                        Returns void

                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      +

                                                                                                                                                                                      Settings

                                                                                                                                                                                       +
                                                                                                                                                                                      +
                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                        +
                                                                                                                                                                                        • +
                                                                                                                                                                                        • +
                                                                                                                                                                                      +
                                                                                                                                                                                      +
                                                                                                                                                                                      + +
                                                                                                                                                                                      +
                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.clearStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.clearStorage.html new file mode 100644 index 00000000..e4716987 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.clearStorage.html @@ -0,0 +1,42 @@ +clearStorage | Library API
                                                                                                                                                                                      +
                                                                                                                                                                                      Library API + +
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        + +

                                                                                                                                                                                        Function clearStorage

                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                          +
                                                                                                                                                                                        • + +
                                                                                                                                                                                          +

                                                                                                                                                                                          Clears in-memory storage entries across environments (NodeJS nodeStorage, Browser memory storage).

                                                                                                                                                                                          +
                                                                                                                                                                                          +

                                                                                                                                                                                          Returns void

                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        +

                                                                                                                                                                                        Settings

                                                                                                                                                                                         +
                                                                                                                                                                                        +
                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                          +
                                                                                                                                                                                          • +
                                                                                                                                                                                          • +
                                                                                                                                                                                        +
                                                                                                                                                                                        +
                                                                                                                                                                                        + +
                                                                                                                                                                                        +
                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.clone.html b/packages/tempo/public/v4/api/library/functions/common.index.clone.html new file mode 100644 index 00000000..12433767 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.clone.html @@ -0,0 +1,63 @@ +clone | Library API
                                                                                                                                                                                        +
                                                                                                                                                                                        Library API + +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          + +

                                                                                                                                                                                          Function clone

                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                            +
                                                                                                                                                                                          • + +
                                                                                                                                                                                            +

                                                                                                                                                                                            Performs a deep copy using the native structuredClone (if available), +falling back to a cleanify JSON strategy otherwise.

                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            +

                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                            +
                                                                                                                                                                                              +
                                                                                                                                                                                            • T
                                                                                                                                                                                            +
                                                                                                                                                                                            +

                                                                                                                                                                                            Parameters

                                                                                                                                                                                            +
                                                                                                                                                                                              +
                                                                                                                                                                                            • obj: T +

                                                                                                                                                                                              The object to clone

                                                                                                                                                                                              +
                                                                                                                                                                                              • +
                                                                                                                                                                                            • Optionalopts: { transfer: any[] } +

                                                                                                                                                                                              Optional structuredClone transfer options

                                                                                                                                                                                              +
                                                                                                                                                                                            +

                                                                                                                                                                                            Returns T

                                                                                                                                                                                            A deep copy of the object

                                                                                                                                                                                            + +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            const copy = clone(original);
+
                                                                                                                                                                                            + +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          +

                                                                                                                                                                                          Settings

                                                                                                                                                                                           +
                                                                                                                                                                                          +
                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                            +
                                                                                                                                                                                            • +
                                                                                                                                                                                            • +
                                                                                                                                                                                          +
                                                                                                                                                                                          +
                                                                                                                                                                                          + +
                                                                                                                                                                                          +
                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.cloneify.html b/packages/tempo/public/v4/api/library/functions/common.index.cloneify.html new file mode 100644 index 00000000..bd55878a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.cloneify.html @@ -0,0 +1,63 @@ +cloneify | Library API
                                                                                                                                                                                          +
                                                                                                                                                                                          Library API + +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            + +

                                                                                                                                                                                            Function cloneify

                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                              +
                                                                                                                                                                                            • + +
                                                                                                                                                                                              +

                                                                                                                                                                                              Deep-copies an Object, optionally replacing <undefined> fields +with a Sentinel function call. Leverages stringify and objectify.

                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              +

                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • T
                                                                                                                                                                                              +
                                                                                                                                                                                              +

                                                                                                                                                                                              Parameters

                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • obj: T +

                                                                                                                                                                                                The object to cloneify

                                                                                                                                                                                                +
                                                                                                                                                                                                • +
                                                                                                                                                                                              • Optionalsentinel: Function +

                                                                                                                                                                                                An optional function to handle reconstructed undefined values

                                                                                                                                                                                                +
                                                                                                                                                                                              +

                                                                                                                                                                                              Returns T

                                                                                                                                                                                              The deep-copied object

                                                                                                                                                                                              + +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              const safeCopy = cloneify(original, () => null);
+
                                                                                                                                                                                              + +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            +

                                                                                                                                                                                            Settings

                                                                                                                                                                                             +
                                                                                                                                                                                            +
                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                              +
                                                                                                                                                                                              • +
                                                                                                                                                                                              • +
                                                                                                                                                                                            +
                                                                                                                                                                                            +
                                                                                                                                                                                            + +
                                                                                                                                                                                            +
                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.coerceGeo.html b/packages/tempo/public/v4/api/library/functions/common.index.coerceGeo.html new file mode 100644 index 00000000..0fbfbbe8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.coerceGeo.html @@ -0,0 +1,51 @@ +coerceGeo | Library API
                                                                                                                                                                                            +
                                                                                                                                                                                            Library API + +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              + +

                                                                                                                                                                                              Function coerceGeo

                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                                +
                                                                                                                                                                                              • + +
                                                                                                                                                                                                +

                                                                                                                                                                                                Extracts and coerces latitude and longitude from input object (options, config, or instance) +into a canonical { latitude, longitude, ... } GeoConfig object. +Enforces coordinate boundaries (-90 to 90 for lat, -180 to 180 for lng), 3-decimal rounding, +and automatic hemisphere inference ('north' | 'south' | 'equator').

                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                +

                                                                                                                                                                                                Parameters

                                                                                                                                                                                                +
                                                                                                                                                                                                  +
                                                                                                                                                                                                • Optionalinput: any +

                                                                                                                                                                                                  Optional object containing coordinate or geo properties

                                                                                                                                                                                                  +
                                                                                                                                                                                                +

                                                                                                                                                                                                Returns GeoConfig | undefined

                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              +

                                                                                                                                                                                              Settings

                                                                                                                                                                                               +
                                                                                                                                                                                              +
                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                +
                                                                                                                                                                                                • +
                                                                                                                                                                                                • +
                                                                                                                                                                                              +
                                                                                                                                                                                              +
                                                                                                                                                                                              + +
                                                                                                                                                                                              +
                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.conceal.html b/packages/tempo/public/v4/api/library/functions/common.index.conceal.html new file mode 100644 index 00000000..e7405bb7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.conceal.html @@ -0,0 +1,56 @@ +conceal | Library API
                                                                                                                                                                                              +
                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                + +

                                                                                                                                                                                                Function conceal

                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                  +
                                                                                                                                                                                                • + +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  Converts a string into an array of char codes. +Useful as a developer utility to generate arrays to paste into reveal().

                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                  +
                                                                                                                                                                                                    +
                                                                                                                                                                                                  • str: string +

                                                                                                                                                                                                    The string to conceal

                                                                                                                                                                                                    +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  Returns number[]

                                                                                                                                                                                                  An array of character codes

                                                                                                                                                                                                  + +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  conceal('hi'); // [104, 105]
+
                                                                                                                                                                                                  + +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                +

                                                                                                                                                                                                Settings

                                                                                                                                                                                                 +
                                                                                                                                                                                                +
                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  • +
                                                                                                                                                                                                  • +
                                                                                                                                                                                                +
                                                                                                                                                                                                +
                                                                                                                                                                                                + +
                                                                                                                                                                                                +
                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.countProperties.html b/packages/tempo/public/v4/api/library/functions/common.index.countProperties.html new file mode 100644 index 00000000..09c2efa4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.countProperties.html @@ -0,0 +1,55 @@ +countProperties | Library API
                                                                                                                                                                                                +
                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  + +

                                                                                                                                                                                                  Function countProperties

                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                    +
                                                                                                                                                                                                  • + +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Returns the count of enumerable own properties on an object.

                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                    +
                                                                                                                                                                                                      +
                                                                                                                                                                                                    • obj: {} = {} +

                                                                                                                                                                                                      The object to count properties of

                                                                                                                                                                                                      +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                    The number of properties

                                                                                                                                                                                                    + +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    const count = countProperties({ a: 1, b: 2 }); // 2
+
                                                                                                                                                                                                    + +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +

                                                                                                                                                                                                  Settings

                                                                                                                                                                                                   +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    • +
                                                                                                                                                                                                    • +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  + +
                                                                                                                                                                                                  +
                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.createMemoryStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.createMemoryStorage.html new file mode 100644 index 00000000..c0b588ef --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.createMemoryStorage.html @@ -0,0 +1,47 @@ +createMemoryStorage | Library API
                                                                                                                                                                                                  +
                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    + +

                                                                                                                                                                                                    Function createMemoryStorage

                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                      +
                                                                                                                                                                                                    • + +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Creates an in-memory Storage object fallback for environments without native Storage support

                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                      +
                                                                                                                                                                                                        +
                                                                                                                                                                                                      • maxSize: number = 1000
                                                                                                                                                                                                        • +
                                                                                                                                                                                                      • ttl: number = Infinity
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Returns Storage

                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +

                                                                                                                                                                                                    Settings

                                                                                                                                                                                                     +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      • +
                                                                                                                                                                                                      • +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    + +
                                                                                                                                                                                                    +
                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.curry.html b/packages/tempo/public/v4/api/library/functions/common.index.curry.html new file mode 100644 index 00000000..8cb9d2fc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.curry.html @@ -0,0 +1,60 @@ +curry | Library API
                                                                                                                                                                                                    +
                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      + +

                                                                                                                                                                                                      Function curry

                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                        +
                                                                                                                                                                                                      • + +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Curries a function to allow partial application of its arguments.

                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • Args extends any[]
                                                                                                                                                                                                          • +
                                                                                                                                                                                                        • Res
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • fn: (...args: Args) => Res +

                                                                                                                                                                                                          The original function to curry

                                                                                                                                                                                                          +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Returns Curry<Args, Res>

                                                                                                                                                                                                        A curried version of the function

                                                                                                                                                                                                        + +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        const add = curry((a: number, b: number) => a + b);
                                                                                                                                                                                                        add(1)(2); // 3
+
                                                                                                                                                                                                        + +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +

                                                                                                                                                                                                      Settings

                                                                                                                                                                                                       +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                        • +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      + +
                                                                                                                                                                                                      +
                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.decodeBase64.html b/packages/tempo/public/v4/api/library/functions/common.index.decodeBase64.html new file mode 100644 index 00000000..90ccde93 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.decodeBase64.html @@ -0,0 +1,59 @@ +decodeBase64 | Library API
                                                                                                                                                                                                      +
                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        + +

                                                                                                                                                                                                        Function decodeBase64

                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                          +
                                                                                                                                                                                                        • + +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Decodes a Base64 string and deserializes it back into a typed object.

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • T
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • base64: string = '' +

                                                                                                                                                                                                            The Base64 string to decode

                                                                                                                                                                                                            +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Returns T

                                                                                                                                                                                                          The deserialized object

                                                                                                                                                                                                          + +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          const obj = decodeBase64`<User>`(token);
+
                                                                                                                                                                                                          + +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +

                                                                                                                                                                                                        Settings

                                                                                                                                                                                                         +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                          • +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        + +
                                                                                                                                                                                                        +
                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.decodeBuffer.html b/packages/tempo/public/v4/api/library/functions/common.index.decodeBuffer.html new file mode 100644 index 00000000..7e15579b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.decodeBuffer.html @@ -0,0 +1,59 @@ +decodeBuffer | Library API
                                                                                                                                                                                                        +
                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          + +

                                                                                                                                                                                                          Function decodeBuffer

                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                            +
                                                                                                                                                                                                          • + +
                                                                                                                                                                                                            +

                                                                                                                                                                                                            Decodes a Uint8Array or ArrayBuffer back into a string.

                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +

                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                            +
                                                                                                                                                                                                              +
                                                                                                                                                                                                            • buf: ArrayBuffer | Uint8Array<ArrayBufferLike> +

                                                                                                                                                                                                              The buffer to decode

                                                                                                                                                                                                              +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                            • encoding: string = 'utf-8' +

                                                                                                                                                                                                              The text encoding to use (default: 'utf-8')

                                                                                                                                                                                                              +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                            • Optionaloptions: TextDecoderOptions
                                                                                                                                                                                                            +

                                                                                                                                                                                                            Returns string

                                                                                                                                                                                                            The decoded string

                                                                                                                                                                                                            + +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            const str = decodeBuffer(buf);
+
                                                                                                                                                                                                            + +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +

                                                                                                                                                                                                          Settings

                                                                                                                                                                                                           +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            • +
                                                                                                                                                                                                            • +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          + +
                                                                                                                                                                                                          +
                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.decrypt.html b/packages/tempo/public/v4/api/library/functions/common.index.decrypt.html new file mode 100644 index 00000000..e89bd327 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.decrypt.html @@ -0,0 +1,49 @@ +decrypt | Library API
                                                                                                                                                                                                          +
                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            + +

                                                                                                                                                                                                            Function decrypt

                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                              +
                                                                                                                                                                                                            • + +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Decrypts a Base64-encoded encrypted string using the module-scoped ephemeral symmetric key.

                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                              +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • secret: string | Promise<string> +

                                                                                                                                                                                                                The encrypted string (or a promise resolving to one)

                                                                                                                                                                                                                +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Returns Promise<unknown>

                                                                                                                                                                                                              A promise resolving to the decrypted, deserialized data

                                                                                                                                                                                                              +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +

                                                                                                                                                                                                            Settings

                                                                                                                                                                                                             +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                              • +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            + +
                                                                                                                                                                                                            +
                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.decryptWithPassword.html b/packages/tempo/public/v4/api/library/functions/common.index.decryptWithPassword.html new file mode 100644 index 00000000..1a30fb11 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.decryptWithPassword.html @@ -0,0 +1,56 @@ +decryptWithPassword | Library API
                                                                                                                                                                                                            +
                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              + +

                                                                                                                                                                                                              Function decryptWithPassword

                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                                +
                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Decrypts data previously encrypted with encryptWithPassword using the supplied password. +Authenticates data integrity and throws an error if the password is incorrect or data was tampered with.

                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                • encrypted: BinaryData +

                                                                                                                                                                                                                  Encrypted binary data buffer

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                • password: string +

                                                                                                                                                                                                                  Decryption password / passphrase

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                • iterations: number = 100_000 +

                                                                                                                                                                                                                  PBKDF2 iteration count (default: 100,000)

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Returns Promise<Uint8Array<ArrayBufferLike>>

                                                                                                                                                                                                                Decrypted plaintext as Uint8Array

                                                                                                                                                                                                                +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +

                                                                                                                                                                                                              Settings

                                                                                                                                                                                                               +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                • +
                                                                                                                                                                                                                • +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              + +
                                                                                                                                                                                                              +
                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.deepFreeze.html b/packages/tempo/public/v4/api/library/functions/common.index.deepFreeze.html new file mode 100644 index 00000000..0452f47d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.deepFreeze.html @@ -0,0 +1,105 @@ +deepFreeze | Library API
                                                                                                                                                                                                              +
                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                + +

                                                                                                                                                                                                                Function deepFreeze

                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Deep-freeze an Array | Object to make it immutable (with recursion guard).

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • const T extends object
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • obj: T +

                                                                                                                                                                                                                    The object to freeze

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • Optionaloptions: { skip?: WeakSet<object> } +

                                                                                                                                                                                                                    Optional configuration

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                      Optionalskip?: WeakSet<object>
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Externally owned WeakSet of objects to skip during freezing; not mutated by this function (caller responsible for lifecycle)

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Returns Secure<T>

                                                                                                                                                                                                                  The frozen object with Secure<T> type

                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • Internally maintains a seen WeakSet to track visited objects and prevent infinite recursion
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • The skip parameter is an opt-out mechanism for caller-controlled exclusions
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • Symbol sym.$Extensible objects are always skipped
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Deep-freeze an Array | Object to make it immutable (with recursion guard).

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • const T extends object
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • obj: T +

                                                                                                                                                                                                                    The object to freeze

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • Optionaloptions: { skip?: WeakSet<object> } +

                                                                                                                                                                                                                    Optional configuration

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                      Optionalskip?: WeakSet<object>
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Externally owned WeakSet of objects to skip during freezing; not mutated by this function (caller responsible for lifecycle)

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • Optionalseen: WeakSet<object>
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Returns Secure<T>

                                                                                                                                                                                                                  The frozen object with Secure<T> type

                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • Internally maintains a seen WeakSet to track visited objects and prevent infinite recursion
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • The skip parameter is an opt-out mechanism for caller-controlled exclusions
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  • Symbol sym.$Extensible objects are always skipped
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +

                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                 +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                + +
                                                                                                                                                                                                                +
                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.deepMerge.html b/packages/tempo/public/v4/api/library/functions/common.index.deepMerge.html new file mode 100644 index 00000000..125d3a81 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.deepMerge.html @@ -0,0 +1,60 @@ +deepMerge | Library API
                                                                                                                                                                                                                +
                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                  Function deepMerge

                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Recursively deeply merges multiple objects into a single new object. +Does not mutate the source objects.

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • T extends Record<PropertyKey, any>
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • ...objects: Partial<T>[] +

                                                                                                                                                                                                                      The objects to merge

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Returns T

                                                                                                                                                                                                                    A new deeply merged object

                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    const merged = deepMerge({ a: { x: 1 } }, { a: { y: 2 } }); // { a: { x: 1, y: 2 } }
+
                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +

                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                   +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.delegate.html b/packages/tempo/public/v4/api/library/functions/common.index.delegate.html new file mode 100644 index 00000000..7116af42 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.delegate.html @@ -0,0 +1,130 @@ +delegate | Library API
                                                                                                                                                                                                                  +
                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                    Function delegate

                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Creates a dynamic Proxy where property access is forwarded to a discovery callback. +Useful for virtual objects and lazy-loading data.

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • T extends object
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • target: T +

                                                                                                                                                                                                                        The base object

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • onGet: (key: string | symbol, target: T) => any +

                                                                                                                                                                                                                        Callback fired when an unknown property is accessed

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • Optionalreadonly: true +

                                                                                                                                                                                                                        Whether the proxy should prevent mutations (default: true)

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Returns Readonly<T>

                                                                                                                                                                                                                      The delegated Proxy

                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      const d = delegate({}, (key) => console.log('Requested:', key));
+
                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Creates a dynamic Proxy where property access is forwarded to a discovery callback. +Useful for virtual objects and lazy-loading data.

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • T extends object
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • target: T +

                                                                                                                                                                                                                        The base object

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • onGet: (key: string | symbol, target: T) => any +

                                                                                                                                                                                                                        Callback fired when an unknown property is accessed

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • readonly: false +

                                                                                                                                                                                                                        Whether the proxy should prevent mutations (default: true)

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Returns T

                                                                                                                                                                                                                      The delegated Proxy

                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      const d = delegate({}, (key) => console.log('Requested:', key));
+
                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Creates a dynamic Proxy where property access is forwarded to a discovery callback. +Useful for virtual objects and lazy-loading data.

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • T extends object
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • target: T +

                                                                                                                                                                                                                        The base object

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • onGet: (key: string | symbol, target: T) => any +

                                                                                                                                                                                                                        Callback fired when an unknown property is accessed

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      • Optionalreadonly: boolean +

                                                                                                                                                                                                                        Whether the proxy should prevent mutations (default: true)

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Returns T | Readonly<T>

                                                                                                                                                                                                                      The delegated Proxy

                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      const d = delegate({}, (key) => console.log('Requested:', key));
+
                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +

                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                     +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.delegator.html b/packages/tempo/public/v4/api/library/functions/common.index.delegator.html new file mode 100644 index 00000000..f121e64d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.delegator.html @@ -0,0 +1,62 @@ +delegator | Library API
                                                                                                                                                                                                                    +
                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                      Function delegator

                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Creates a virtual Proxy where fixed keys are mapped to a callback function.

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        • K extends string | symbol
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        • keys: Record<K, any> | readonly K[] +

                                                                                                                                                                                                                          The array of allowed keys (or an object whose ownKeys will be used)

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        • fn: (prop: K) => any +

                                                                                                                                                                                                                          The callback fired when a key is accessed

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Returns Readonly<Record<K, any>>

                                                                                                                                                                                                                        The virtual delegator object

                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        const v = delegator(['a', 'b'], (key) => key.toUpperCase());
+
                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +

                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                       +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.distinct.html b/packages/tempo/public/v4/api/library/functions/common.index.distinct.html new file mode 100644 index 00000000..17547430 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.distinct.html @@ -0,0 +1,91 @@ +distinct | Library API
                                                                                                                                                                                                                      +
                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                        Function distinct

                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns an array with no repeated elements.

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • arr: T[] +

                                                                                                                                                                                                                            The array to extract distinct elements from

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns T[]

                                                                                                                                                                                                                          A new array containing only distinct elements

                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          const unique = distinct([1, 1, 2, 3]);
+
                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns a mapped array with no repeated elements.

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          • S
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • arr: T[] +

                                                                                                                                                                                                                            The array to extract distinct elements from

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          • mapfn: (value: T, index: number, array: T[]) => S +

                                                                                                                                                                                                                            Optional mapping function to apply before checking for distinctness

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          • OptionalthisArg: any +

                                                                                                                                                                                                                            Optional this context for the mapping function

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Returns S[]

                                                                                                                                                                                                                          A new array containing only distinct elements

                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          const uniqueIds = distinct(users, user => user.id);
+
                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +

                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                         +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.dynamicProxy.html b/packages/tempo/public/v4/api/library/functions/common.index.dynamicProxy.html new file mode 100644 index 00000000..ebbf0059 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.dynamicProxy.html @@ -0,0 +1,53 @@ +dynamicProxy | Library API
                                                                                                                                                                                                                        +
                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                          Function dynamicProxy

                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Creates a proxy that evaluates eligible function-valued properties when read.

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            • T extends object
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            • target: T +

                                                                                                                                                                                                                              The object whose properties are evaluated

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Returns Evaluated<T>

                                                                                                                                                                                                                            A proxy that invokes eligible functions with target as their receiver; symbols, constructors, and fixed function properties are returned unchanged

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +

                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                           +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.encodeBase64.html b/packages/tempo/public/v4/api/library/functions/common.index.encodeBase64.html new file mode 100644 index 00000000..bc21c396 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.encodeBase64.html @@ -0,0 +1,55 @@ +encodeBase64 | Library API
                                                                                                                                                                                                                          +
                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                            Function encodeBase64

                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              Serializes any object, encodes it to a buffer, and outputs a Base64 string.

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                              • input: unknown +

                                                                                                                                                                                                                                The object to serialize and encode

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              Returns string

                                                                                                                                                                                                                              A Base64 string representation of the serialized object

                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              const token = encodeBase64({ user: 'michael' });
+
                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +

                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                             +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.encodeBuffer.html b/packages/tempo/public/v4/api/library/functions/common.index.encodeBuffer.html new file mode 100644 index 00000000..601d3879 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.encodeBuffer.html @@ -0,0 +1,55 @@ +encodeBuffer | Library API
                                                                                                                                                                                                                            +
                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                              Function encodeBuffer

                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Serializes any object to a string and encodes it into a Uint8Array.

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                • str: any +

                                                                                                                                                                                                                                  The object or string to serialize and encode

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Returns Uint8Array<ArrayBuffer>

                                                                                                                                                                                                                                A Uint8Array containing the encoded data

                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                const buf = encodeBuffer({ a: 1 });
+
                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +

                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                               +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.encodeText.html b/packages/tempo/public/v4/api/library/functions/common.index.encodeText.html new file mode 100644 index 00000000..da20ffc6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.encodeText.html @@ -0,0 +1,55 @@ +encodeText | Library API
                                                                                                                                                                                                                              +
                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                Function encodeText

                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  Encodes a text string into a Uint8Array using UTF-8 encoding.

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                  • text: string +

                                                                                                                                                                                                                                    The string to encode

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  Returns Uint8Array<ArrayBuffer>

                                                                                                                                                                                                                                  A Uint8Array containing the encoded text

                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  const bytes = encodeText('Hello');
+
                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.encrypt.html b/packages/tempo/public/v4/api/library/functions/common.index.encrypt.html new file mode 100644 index 00000000..b6dcf1b3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.encrypt.html @@ -0,0 +1,49 @@ +encrypt | Library API
                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                  Function encrypt

                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    Encrypts arbitrary data using AES-GCM and a module-scoped ephemeral symmetric key.

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                    • data: any +

                                                                                                                                                                                                                                      The data to encrypt

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    Returns Promise<string>

                                                                                                                                                                                                                                    A promise resolving to the Base64-encoded encrypted string (including IV)

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.encryptWithPassword.html b/packages/tempo/public/v4/api/library/functions/common.index.encryptWithPassword.html new file mode 100644 index 00000000..1b2d5210 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.encryptWithPassword.html @@ -0,0 +1,56 @@ +encryptWithPassword | Library API
                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                    Function encryptWithPassword

                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Encrypts arbitrary binary or string data using a password with PBKDF2 key derivation and AES-GCM (256-bit). +Encapsulates: [ Magic 4B ("MFS1") | Salt 16B | IV 12B | Ciphertext + Tag ].

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                      • data: string | BinaryData +

                                                                                                                                                                                                                                        Raw string or binary data to encrypt

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                      • password: string +

                                                                                                                                                                                                                                        Encryption password / passphrase

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                      • iterations: number = 100_000 +

                                                                                                                                                                                                                                        PBKDF2 iteration count (default: 100,000)

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Returns Promise<Uint8Array<ArrayBufferLike>>

                                                                                                                                                                                                                                      Encrypted binary buffer as Uint8Array

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.enumify.html b/packages/tempo/public/v4/api/library/functions/common.index.enumify.html new file mode 100644 index 00000000..8ad05465 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.enumify.html @@ -0,0 +1,87 @@ +enumify | Library API
                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                      Function enumify

                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Enumify

                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        create a Proxy-based Registry (Enum) from an Object or Array.
                                                                                                                                                                                                                                        +Enums are immutable (frozen) and provide methods for iteration, search, and extension.

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • const T extends readonly any[]
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • list: T
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        • Optionalfrozen: boolean
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Returns wrap<Index<T>>

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        const Status = enumify(['Active', 'Inactive', 'Pending']);
                                                                                                                                                                                                                                        console.log(Status.Active);															// 0
                                                                                                                                                                                                                                        console.log(Enum.has(Status, 'Active'));									// true
                                                                                                                                                                                                                                        console.log(Enum.keys(Status));													// ['Active', 'Inactive', 'Pending']
+
                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Enumify

                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        create a Proxy-based Registry (Enum) from an Object or Array.
                                                                                                                                                                                                                                        +Enums are immutable (frozen) and provide methods for iteration, search, and extension.

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • list: T
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        • Optionalfrozen: boolean
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Returns wrap<T>

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        const Status = enumify(['Active', 'Inactive', 'Pending']);
                                                                                                                                                                                                                                        console.log(Status.Active);															// 0
                                                                                                                                                                                                                                        console.log(Enum.has(Status, 'Active'));									// true
                                                                                                                                                                                                                                        console.log(Enum.keys(Status));													// ['Active', 'Inactive', 'Pending']
+
                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                      EnumifyEnumify
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ephemeral.html b/packages/tempo/public/v4/api/library/functions/common.index.ephemeral.html new file mode 100644 index 00000000..3be9fa65 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ephemeral.html @@ -0,0 +1,60 @@ +ephemeral | Library API
                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                        Function ephemeral

                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Runs a callback with a temporary proxy that is revoked after execution completes.

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • T extends object
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          • R
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • target: T +

                                                                                                                                                                                                                                            The object to expose through the temporary proxy

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          • fn: (scoped: T) => R +

                                                                                                                                                                                                                                            The callback that receives the temporary proxy

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          • options: ProxyOptions = {} +

                                                                                                                                                                                                                                            Configuration options for proxy behavior

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Returns R

                                                                                                                                                                                                                                          The callback's result

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.epoch.html b/packages/tempo/public/v4/api/library/functions/common.index.epoch.html new file mode 100644 index 00000000..e6310b37 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.epoch.html @@ -0,0 +1,43 @@ +epoch | Library API
                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                          Function epoch

                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Returns the current Unix timestamp in nanoseconds.

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Returns bigint

                                                                                                                                                                                                                                            The current Unix timestamp (nanoseconds)

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluate.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluate.html new file mode 100644 index 00000000..1e84565c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluate.html @@ -0,0 +1,102 @@ +evaluate | Library API
                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                            Function evaluate

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Evaluates candidates in order and returns the first defined result.

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Values or zero-argument functions that produce candidate results

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            The first result that is not undefined, or undefined if no candidate produces one

                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Evaluates candidate synchronous scalars or supplier functions in order, returning the first defined result (lazy coalesce). +If a candidate is a function, it is invoked with zero arguments. +Candidates after the first defined value are never evaluated (short-circuiting). +If all candidates evaluate to undefined, returns undefined. +Any exception thrown by an evaluated supplier function bubbles directly to the caller.

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Returns T

                                                                                                                                                                                                                                              The first resolved defined value, or undefined if none resolved

                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              evaluate(42); // 42
                                                                                                                                                                                                                                              evaluate(() => 'UTC'); // 'UTC'
                                                                                                                                                                                                                                              evaluate(undefined, 'fallback'); // 'fallback'
                                                                                                                                                                                                                                              evaluate(undefined, () => undefined, () => 'dynamic-fallback', 'final'); // 'dynamic-fallback'
+
                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Evaluates candidate synchronous scalars or supplier functions in order, returning the first defined result (lazy coalesce). +If a candidate is a function, it is invoked with zero arguments. +Candidates after the first defined value are never evaluated (short-circuiting). +If all candidates evaluate to undefined, returns undefined. +Any exception thrown by an evaluated supplier function bubbles directly to the caller.

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • ...values: (Evaluable<T> | undefined)[] +

                                                                                                                                                                                                                                                One or more scalars or synchronous supplier functions to evaluate in sequence

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Returns T | undefined

                                                                                                                                                                                                                                              The first resolved defined value, or undefined if none resolved

                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              evaluate(42); // 42
                                                                                                                                                                                                                                              evaluate(() => 'UTC'); // 'UTC'
                                                                                                                                                                                                                                              evaluate(undefined, 'fallback'); // 'fallback'
                                                                                                                                                                                                                                              evaluate(undefined, () => undefined, () => 'dynamic-fallback', 'final'); // 'dynamic-fallback'
+
                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluateAsync.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluateAsync.html new file mode 100644 index 00000000..aea155c3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluateAsync.html @@ -0,0 +1,102 @@ +evaluateAsync | Library API
                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                              Function evaluateAsync

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Evaluates asynchronous candidates in order and stops at the first defined value.

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Values, promises, or supplier functions to evaluate.

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              The first defined result, or undefined if all candidates resolve to undefined.

                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Evaluates candidate synchronous or asynchronous scalars, Promises, or supplier functions in order, returning the first defined result (async lazy coalesce). +Supplier functions represent deferred asynchronous work and are invoked lazily only when reached during evaluation. +Rejection handlers are attached upfront to direct Promise candidates to prevent unobserved rejections if iteration short-circuits on an earlier defined candidate. +If all candidates evaluate to undefined, returns undefined. +Any exception or rejection thrown by an evaluated candidate bubbles directly to the caller.

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Returns Promise<T>

                                                                                                                                                                                                                                                A Promise resolving to the first defined value, or undefined if none resolved

                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                await evaluateAsync('apiKey123'); // 'apiKey123'
                                                                                                                                                                                                                                                await evaluateAsync(undefined, async () => fetchSecret(), 'defaultKey'); // 'secret'
+
                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Evaluates candidate synchronous or asynchronous scalars, Promises, or supplier functions in order, returning the first defined result (async lazy coalesce). +Supplier functions represent deferred asynchronous work and are invoked lazily only when reached during evaluation. +Rejection handlers are attached upfront to direct Promise candidates to prevent unobserved rejections if iteration short-circuits on an earlier defined candidate. +If all candidates evaluate to undefined, returns undefined. +Any exception or rejection thrown by an evaluated candidate bubbles directly to the caller.

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • ...values: (AsyncEvaluable<T> | undefined)[] +

                                                                                                                                                                                                                                                  One or more scalars, Promises, or async supplier functions to evaluate in sequence

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Returns Promise<T | undefined>

                                                                                                                                                                                                                                                A Promise resolving to the first defined value, or undefined if none resolved

                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                await evaluateAsync('apiKey123'); // 'apiKey123'
                                                                                                                                                                                                                                                await evaluateAsync(undefined, async () => fetchSecret(), 'defaultKey'); // 'secret'
+
                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfig.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfig.html new file mode 100644 index 00000000..a6caea3d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfig.html @@ -0,0 +1,60 @@ +evaluateConfig | Library API
                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                Function evaluateConfig

                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Resolves all top-level properties of a configuration object synchronously. +For each property whose value is a function, executes the function and sets the property to its return value.

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • T extends object
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • config: T +

                                                                                                                                                                                                                                                    The configuration object to evaluate

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Returns Evaluated<T>

                                                                                                                                                                                                                                                  A new object with all properties synchronously resolved

                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  const evaluated = evaluateConfig({
                                                                                                                                                                                                                                                    timeZone: () => 'America/New_York',
                                                                                                                                                                                                                                                    locale: 'en-US'
                                                                                                                                                                                                                                                  });
                                                                                                                                                                                                                                                  // { timeZone: 'America/New_York', locale: 'en-US' }
+
                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfigAsync.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfigAsync.html new file mode 100644 index 00000000..55dc33e0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluateConfigAsync.html @@ -0,0 +1,60 @@ +evaluateConfigAsync | Library API
                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                  Function evaluateConfigAsync

                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Resolves all top-level properties of a configuration object asynchronously. +For each property whose value is a function or Promise, executes/awaits the value and sets the property.

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • T extends object
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • config: T +

                                                                                                                                                                                                                                                      The configuration object to evaluate

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Returns Promise<AsyncEvaluated<T>>

                                                                                                                                                                                                                                                    A Promise resolving to a new object with all properties resolved

                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    const evaluated = await evaluateConfigAsync({
                                                                                                                                                                                                                                                      key: async () => fetchKey(),
                                                                                                                                                                                                                                                      url: 'https://api.openai.com/v1'
                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                    // { key: 'sk-...', url: 'https://api.openai.com/v1' }
+
                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluateString.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluateString.html new file mode 100644 index 00000000..03cec6c8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluateString.html @@ -0,0 +1,62 @@ +evaluateString | Library API
                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                    Function evaluateString

                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Evaluates a value or invokes a function with the provided arguments, stringifying the result.

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • A extends any[] = any[]
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • val: unknown +

                                                                                                                                                                                                                                                        A value or function to evaluate

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      • ...args: A +

                                                                                                                                                                                                                                                        Arguments forwarded to the function if val is callable

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                      The stringified result

                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      evaluateString('test'); // 'test'
                                                                                                                                                                                                                                                      evaluateString((locale?: string) => locale === 'fr' ? 'Sud' : 'South', 'fr'); // 'Sud'
+
                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.evaluateWith.html b/packages/tempo/public/v4/api/library/functions/common.index.evaluateWith.html new file mode 100644 index 00000000..b70d673a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.evaluateWith.html @@ -0,0 +1,64 @@ +evaluateWith | Library API
                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                      Function evaluateWith

                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Evaluates a value or invokes a function with the provided arguments. +If the value is not a function, it is returned as-is.

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • T
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • A extends any[] = any[]
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • val: T | ((...args: A) => T) +

                                                                                                                                                                                                                                                          A scalar value or function to evaluate

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        • ...args: A +

                                                                                                                                                                                                                                                          Arguments forwarded to the function if val is callable

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Returns T

                                                                                                                                                                                                                                                        The resolved value

                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        evaluateWith(42); // 42
                                                                                                                                                                                                                                                        evaluateWith((name: string) => `Hello, ${name}`, 'World'); // 'Hello, World'
+
                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.exclude.html b/packages/tempo/public/v4/api/library/functions/common.index.exclude.html new file mode 100644 index 00000000..6419e498 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.exclude.html @@ -0,0 +1,56 @@ +exclude | Library API
                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                        Function exclude

                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Recursively removes properties whose values match the specified type names.

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          • T extends Obj
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          • obj: T +

                                                                                                                                                                                                                                                            The object or array to mutate

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                          • ...types: (
                                                                                                                                                                                                                                                                | "string"
                                                                                                                                                                                                                                                                | "number"
                                                                                                                                                                                                                                                                | "bigint"
                                                                                                                                                                                                                                                                | "boolean"
                                                                                                                                                                                                                                                                | "symbol"
                                                                                                                                                                                                                                                                | Primitives
                                                                                                                                                                                                                                                                | "null"
                                                                                                                                                                                                                                                                | "void"
                                                                                                                                                                                                                                                            )[]                                                                                                                                                                                                                                                             +

                                                                                                                                                                                                                                                            The type names to exclude, such as Function or String

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Returns T

                                                                                                                                                                                                                                                          The mutated object reference

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.expandRRuleEpochs.html b/packages/tempo/public/v4/api/library/functions/common.index.expandRRuleEpochs.html new file mode 100644 index 00000000..82d4e27e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.expandRRuleEpochs.html @@ -0,0 +1,56 @@ +expandRRuleEpochs | Library API
                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                          Function expandRRuleEpochs

                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            Expands occurrences of an RFC 5545 RRULE string into epoch millisecond numbers. +Pure function operating strictly on primitive timestamps and UTC Date calculations.

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                            • rruleStr: string +

                                                                                                                                                                                                                                                              The RFC 5545 recurrence rule string to expand

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                            • anchorEpochMs: number +

                                                                                                                                                                                                                                                              Anchor timestamp in epoch milliseconds to evaluate occurrences from

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                            • Optionaloptions: { afterMs?: number; beforeMs?: number; count?: number } +

                                                                                                                                                                                                                                                              Optional bounds and count controls for the evaluation

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            Returns number[]

                                                                                                                                                                                                                                                            Array of occurrence timestamps in epoch milliseconds

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.exportJWK.html b/packages/tempo/public/v4/api/library/functions/common.index.exportJWK.html new file mode 100644 index 00000000..02585d82 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.exportJWK.html @@ -0,0 +1,49 @@ +exportJWK | Library API
                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                            Function exportJWK

                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Exports a native Web Crypto API CryptoKey object to a JSON Web Key (JWK).

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                              • key: CryptoKey +

                                                                                                                                                                                                                                                                The CryptoKey to export

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Returns Promise<JsonWebKey>

                                                                                                                                                                                                                                                              A promise resolving to the exported JsonWebKey

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.extend.html b/packages/tempo/public/v4/api/library/functions/common.index.extend.html new file mode 100644 index 00000000..2516c2de --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.extend.html @@ -0,0 +1,64 @@ +extend | Library API
                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                              Function extend

                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Extends a target object with the properties of one or more source objects. +Uses Object.assign internally.

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                • T extends {}
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                • U
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                • obj: T +

                                                                                                                                                                                                                                                                  The target object

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                • ...objs: U[] +

                                                                                                                                                                                                                                                                  The source objects

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Returns T

                                                                                                                                                                                                                                                                The extended target object

                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                const ext = extend({ a: 1 }, { b: 2 }); // { a: 1, b: 2 }
+
                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.extract.html b/packages/tempo/public/v4/api/library/functions/common.index.extract.html new file mode 100644 index 00000000..fec20b61 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.extract.html @@ -0,0 +1,65 @@ +extract | Library API
                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                Function extract

                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Gets a nested value from an object using dot or bracket notation.

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • obj: any +

                                                                                                                                                                                                                                                                    The object to extract the value from

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                  • path: string | number +

                                                                                                                                                                                                                                                                    The path to the value using dot or bracket notation

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                  • Optionaldflt: T +

                                                                                                                                                                                                                                                                    The default value to return if the path does not exist

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Returns T

                                                                                                                                                                                                                                                                  The extracted value or the default value

                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  const val = extract(user, 'profile.address.zip', '00000');
+
                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fastDigest.html b/packages/tempo/public/v4/api/library/functions/common.index.fastDigest.html new file mode 100644 index 00000000..5763094d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fastDigest.html @@ -0,0 +1,52 @@ +fastDigest | Library API
                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                  Function fastDigest

                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Computes a fast, synchronous 64-bit keyed hash of a string payload.

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • str: string +

                                                                                                                                                                                                                                                                      The string to hash

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                    • secret: string = RUNTIME_SALT +

                                                                                                                                                                                                                                                                      Optional secret key or salt (defaults to an ephemeral runtime salt, deterministic only within the current process lifetime)

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                    A 16-character hex string digest

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fetchHead.html b/packages/tempo/public/v4/api/library/functions/common.index.fetchHead.html new file mode 100644 index 00000000..ac87246f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fetchHead.html @@ -0,0 +1,56 @@ +fetchHead | Library API
                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                    Function fetchHead

                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      Performs an HTTP HEAD request to retrieve response headers without the body. +Useful for verifying URL existence or checking metadata.

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • url: string | URL +

                                                                                                                                                                                                                                                                        The resource URL to check

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      Returns Promise<{ headers: Headers; status: number }>

                                                                                                                                                                                                                                                                      A promise resolving to the response status and headers

                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      const { status } = await fetchHead('https://example.com');
+
                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fetchRequest.html b/packages/tempo/public/v4/api/library/functions/common.index.fetchRequest.html new file mode 100644 index 00000000..7cdee08b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fetchRequest.html @@ -0,0 +1,66 @@ +fetchRequest | Library API
                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                      Function fetchRequest

                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Performs an HTTP fetch request with built-in timeout, JSON parsing, prefix handling, and bounded stream reading. +Automatically throws an HttpError if the response is not ok or exceeds maxBytes.

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • T
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • url: string | URL +

                                                                                                                                                                                                                                                                          The resource URL to fetch

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • init: RequestInit = ... +

                                                                                                                                                                                                                                                                          Optional RequestInit configuration

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        • config: Config = ... +

                                                                                                                                                                                                                                                                          Optional configuration including timeout, prefix stripping, and maxBytes limit

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Returns Promise<T>

                                                                                                                                                                                                                                                                        A promise resolving to the parsed response body

                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        const data = await fetchRequest<MyData>('https://api.example.com', {}, { maxBytes: 512 * 1024 });
+
                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileDelete.html b/packages/tempo/public/v4/api/library/functions/common.index.fileDelete.html new file mode 100644 index 00000000..9599638a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileDelete.html @@ -0,0 +1,48 @@ +fileDelete | Library API
                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                        Function fileDelete

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Deletes a file from the default Virtual File Store.

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • path: string +

                                                                                                                                                                                                                                                                            Virtual relative path

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Returns Promise<boolean>

                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileExists.html b/packages/tempo/public/v4/api/library/functions/common.index.fileExists.html new file mode 100644 index 00000000..62b29f5c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileExists.html @@ -0,0 +1,48 @@ +fileExists | Library API
                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                          Function fileExists

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Checks whether a file exists in the default Virtual File Store.

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • path: string +

                                                                                                                                                                                                                                                                              Virtual relative path

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Returns Promise<boolean>

                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileList.html b/packages/tempo/public/v4/api/library/functions/common.index.fileList.html new file mode 100644 index 00000000..6e25978c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileList.html @@ -0,0 +1,48 @@ +fileList | Library API
                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                            Function fileList

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Lists entry names within a virtual directory.

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • dir: string = '' +

                                                                                                                                                                                                                                                                                Optional subdirectory

                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Returns Promise<string[]>

                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileRead.html b/packages/tempo/public/v4/api/library/functions/common.index.fileRead.html new file mode 100644 index 00000000..cb038ce8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileRead.html @@ -0,0 +1,51 @@ +fileRead | Library API
                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                              Function fileRead

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                Reads an encrypted text file from the default Virtual File Store.

                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                • path: string +

                                                                                                                                                                                                                                                                                  Virtual relative path

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                • password: string +

                                                                                                                                                                                                                                                                                  Decryption password

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                Returns Promise<string | null>

                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileReadBuffer.html b/packages/tempo/public/v4/api/library/functions/common.index.fileReadBuffer.html new file mode 100644 index 00000000..dfcbf45a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileReadBuffer.html @@ -0,0 +1,51 @@ +fileReadBuffer | Library API
                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                Function fileReadBuffer

                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Reads an encrypted binary file as a Uint8Array from the default Virtual File Store.

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                  • path: string +

                                                                                                                                                                                                                                                                                    Virtual relative path

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                  • password: string +

                                                                                                                                                                                                                                                                                    Decryption password

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Returns Promise<Uint8Array<ArrayBufferLike> | null>

                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileReadJSON.html b/packages/tempo/public/v4/api/library/functions/common.index.fileReadJSON.html new file mode 100644 index 00000000..18061cfc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileReadJSON.html @@ -0,0 +1,58 @@ +fileReadJSON | Library API
                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                  Function fileReadJSON

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                    Reads and decrypts a JSON file from the default Virtual File Store.

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                    • T = any
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                    • path: string +

                                                                                                                                                                                                                                                                                      Virtual relative path

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                    • password: string +

                                                                                                                                                                                                                                                                                      Decryption password

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                    • Optionalfallback: T +

                                                                                                                                                                                                                                                                                      Optional fallback value

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                    Returns Promise<T | null>

                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileWrite.html b/packages/tempo/public/v4/api/library/functions/common.index.fileWrite.html new file mode 100644 index 00000000..ebc21b13 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileWrite.html @@ -0,0 +1,54 @@ +fileWrite | Library API
                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                    Function fileWrite

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                      Encrypts and writes data to the default Virtual File Store.

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                      • path: string +

                                                                                                                                                                                                                                                                                        Virtual relative path

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                      • content: string | BufferSource | Uint8Array<ArrayBufferLike> +

                                                                                                                                                                                                                                                                                        String or binary payload

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                      • password: string +

                                                                                                                                                                                                                                                                                        Encryption password

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                      Returns Promise<void>

                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fileWriteJSON.html b/packages/tempo/public/v4/api/library/functions/common.index.fileWriteJSON.html new file mode 100644 index 00000000..63105031 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fileWriteJSON.html @@ -0,0 +1,54 @@ +fileWriteJSON | Library API
                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                      Function fileWriteJSON

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                        Serializes, encrypts, and writes data to a JSON file in the default Virtual File Store.

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                        • path: string +

                                                                                                                                                                                                                                                                                          Virtual relative path

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                        • data: any +

                                                                                                                                                                                                                                                                                          Object or value to store

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                        • password: string +

                                                                                                                                                                                                                                                                                          Encryption password

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                        Returns Promise<void>

                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fix.html b/packages/tempo/public/v4/api/library/functions/common.index.fix.html new file mode 100644 index 00000000..260fe309 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fix.html @@ -0,0 +1,58 @@ +fix | Library API
                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                        Function fix

                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                          Formats a number to a fixed number of decimal places.

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                          • nbr: string | number = 0 +

                                                                                                                                                                                                                                                                                            The number or string to format

                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                          • max: number = 2 +

                                                                                                                                                                                                                                                                                            The maximum number of decimal places (default: 2)

                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                          Returns string

                                                                                                                                                                                                                                                                                          The fixed-precision string representation

                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          fix(12.3456, 2); // '12.35'
+
                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatCurrency.html b/packages/tempo/public/v4/api/library/functions/common.index.formatCurrency.html new file mode 100644 index 00000000..07585f62 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatCurrency.html @@ -0,0 +1,64 @@ +formatCurrency | Library API
                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                          Function formatCurrency

                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                            Formats a numeric value as a localized currency string.

                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                            • str: string | number +

                                                                                                                                                                                                                                                                                              The numeric value or string to format

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                            • scale: number = 2 +

                                                                                                                                                                                                                                                                                              The maximum number of fractional digits (default: 2)

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                            • currency: string = 'AUD' +

                                                                                                                                                                                                                                                                                              The ISO 4217 currency code (default: 'AUD')

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                            • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                              Optional locale string (defaults to system locale)

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                            Returns string

                                                                                                                                                                                                                                                                                            The localized currency string

                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            formatCurrency(1234.5, 2, 'USD'); // '$1,234.50'
+
                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatDayPeriod.html b/packages/tempo/public/v4/api/library/functions/common.index.formatDayPeriod.html new file mode 100644 index 00000000..e716bfd9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatDayPeriod.html @@ -0,0 +1,55 @@ +formatDayPeriod | Library API
                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                            Function formatDayPeriod

                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                              Extracts the localized day-period label from a formatted date.

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                              • value: number +

                                                                                                                                                                                                                                                                                                The epoch time value to format

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                              • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                The locale used for formatting

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                              • Optionaloptions: DateTimeFormatOptions +

                                                                                                                                                                                                                                                                                                Date-time formatting options

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                              Returns string | undefined

                                                                                                                                                                                                                                                                                              The localized day-period label, or undefined if formatting fails or no day-period part exists

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatDuration.html b/packages/tempo/public/v4/api/library/functions/common.index.formatDuration.html new file mode 100644 index 00000000..dff6e165 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatDuration.html @@ -0,0 +1,56 @@ +formatDuration | Library API
                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                              Function formatDuration

                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                Returns a localized duration string using Intl.DurationFormat. +Note: Requires an environment that supports Intl.DurationFormat.

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                • duration: any +

                                                                                                                                                                                                                                                                                                  The duration object or value to format

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                  Optional locale string

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                • Optionaloptions: any +

                                                                                                                                                                                                                                                                                                  Optional format configuration

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                Returns string

                                                                                                                                                                                                                                                                                                The localized duration string

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatList.html b/packages/tempo/public/v4/api/library/functions/common.index.formatList.html new file mode 100644 index 00000000..9621a036 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatList.html @@ -0,0 +1,65 @@ +formatList | Library API
                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                Function formatList

                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                  Returns a localized list string using Intl.ListFormat. +Falls back to a simple comma-joined string if formatting fails.

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                  • list: readonly string[] +

                                                                                                                                                                                                                                                                                                    The array of strings to format

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                  • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                    Optional locale string or Intl.Locale

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                  • type: ListFormatType = 'conjunction' +

                                                                                                                                                                                                                                                                                                    The list format type (default: 'conjunction')

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                  • style: ListFormatStyle = 'long' +

                                                                                                                                                                                                                                                                                                    The list format style (default: 'long')

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                  Returns string

                                                                                                                                                                                                                                                                                                  The localized list string

                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  formatList(['A', 'B', 'C'], 'en'); // 'A, B, and C'
+
                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatNumber.html b/packages/tempo/public/v4/api/library/functions/common.index.formatNumber.html new file mode 100644 index 00000000..949006eb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatNumber.html @@ -0,0 +1,61 @@ +formatNumber | Library API
                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                  Function formatNumber

                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                    Returns a localized number string using Intl.NumberFormat.

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                    • value: number +

                                                                                                                                                                                                                                                                                                      The numeric value to format

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                    • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                      Optional locale string

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                    • Optionaloptions: NumberFormatOptions +

                                                                                                                                                                                                                                                                                                      Optional format configuration

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                    The localized number string

                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    formatNumber(1234.5, 'de-DE'); // '1.234,5'
+
                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.formatUnit.html b/packages/tempo/public/v4/api/library/functions/common.index.formatUnit.html new file mode 100644 index 00000000..401e4dd1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.formatUnit.html @@ -0,0 +1,58 @@ +formatUnit | Library API
                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                    Function formatUnit

                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                      Formats a numeric value with a localized unit.

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                      • value: number +

                                                                                                                                                                                                                                                                                                        The numeric value to format

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                      • unit: string +

                                                                                                                                                                                                                                                                                                        The unit identifier, such as day, hour, or meter

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                      • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                        The locale to use for formatting

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                      • unitDisplay: "long" | "short" | "narrow" | undefined = 'long' +

                                                                                                                                                                                                                                                                                                        The unit display style

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                                                                      The localized unit string, or the value and unit separated by a space if formatting fails

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.forwardGeocode.html b/packages/tempo/public/v4/api/library/functions/common.index.forwardGeocode.html new file mode 100644 index 00000000..ce6acae6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.forwardGeocode.html @@ -0,0 +1,51 @@ +forwardGeocode | Library API
                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                      Function forwardGeocode

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                        Forward geocodes an address or place query string into coordinates using the active or provided GeoProvider.

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                        • query: string +

                                                                                                                                                                                                                                                                                                          Address or place search query

                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                        • Optionalopts: Record<string, any> +

                                                                                                                                                                                                                                                                                                          Options including optional provider override

                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                        Returns Promise<ResolvedCoordinates | null>

                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fromIsoWeek.html b/packages/tempo/public/v4/api/library/functions/common.index.fromIsoWeek.html new file mode 100644 index 00000000..e37881fb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fromIsoWeek.html @@ -0,0 +1,50 @@ +fromIsoWeek | Library API
                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                        Function fromIsoWeek

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                          Resolves an ISO week date (isoYear, isoWeek, isoDay) into calendar year, month, and day +using lightweight UTC Date calculations. isoDay uses Monday=1 through Sunday=7 and defaults to Monday. +Out-of-range week and day values roll into adjacent dates rather than being rejected.

                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                          • isoYear: number
                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                          • isoWeek: number
                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                          • isoDay: number = 1
                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                          Returns { day: number; month: number; year: number }

                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fromRoman.html b/packages/tempo/public/v4/api/library/functions/common.index.fromRoman.html new file mode 100644 index 00000000..924a9c00 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fromRoman.html @@ -0,0 +1,55 @@ +fromRoman | Library API
                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                          Function fromRoman

                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                            Converts a Roman numeral string into its numeric integer value.

                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                            • roman: string +

                                                                                                                                                                                                                                                                                                              Standard subtractive Roman numerals; matching is case-insensitive and surrounding whitespace is ignored

                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                            The integer value (1-3999), or NaN if invalid

                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            fromRoman('MMXXVI'); // 2026
                                                                                                                                                                                                                                                                                                            fromRoman('XIV'); // 14
                                                                                                                                                                                                                                                                                                            fromRoman('IIII'); // NaN
+
                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.fromUtcParts.html b/packages/tempo/public/v4/api/library/functions/common.index.fromUtcParts.html new file mode 100644 index 00000000..591172fe --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.fromUtcParts.html @@ -0,0 +1,50 @@ +fromUtcParts | Library API
                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                            Function fromUtcParts

                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                              Creates a UTC Date instance from structured 1-indexed calendar components and optional clock values. +Inverse of getUtcParts.

                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                              • parts: UtcPartsOptions +

                                                                                                                                                                                                                                                                                                                Structured calendar components containing year, month, day, and optional clock components

                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                              Returns Date

                                                                                                                                                                                                                                                                                                              A new UTC Date instance

                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.generateKeyPair.html b/packages/tempo/public/v4/api/library/functions/common.index.generateKeyPair.html new file mode 100644 index 00000000..6dabae00 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.generateKeyPair.html @@ -0,0 +1,43 @@ +generateKeyPair | Library API
                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                              Function generateKeyPair

                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                Generates a new RSASSA-PKCS1-v1_5 asymmetric keypair using the Web Crypto API.

                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                Returns Promise<CryptoKeyPair>

                                                                                                                                                                                                                                                                                                                A promise resolving to the generated CryptoKeyPair

                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.geoLookup.html b/packages/tempo/public/v4/api/library/functions/common.index.geoLookup.html new file mode 100644 index 00000000..cbdee3ea --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.geoLookup.html @@ -0,0 +1,50 @@ +geoLookup | Library API
                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                Function geoLookup

                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                  Universal geolocation lookup dispatcher. +Automatically delegates to custom provider, browser geoLocation(), or server serverGeoLocation(). +When coordinates are resolved, stashes the result in storage with a 24-hour TTL for fast cached lookups.

                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                  • opts: Record<string, any> = {} +

                                                                                                                                                                                                                                                                                                                    Lookup options passed down to environment handler (e.g. { refresh: true, key: 'tenant-1', provider })

                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                  Returns Promise<GeoLookupResult>

                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getAccessors.html b/packages/tempo/public/v4/api/library/functions/common.index.getAccessors.html new file mode 100644 index 00000000..6f7fcddb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getAccessors.html @@ -0,0 +1,55 @@ +getAccessors | Library API
                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                  Function getAccessors

                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                    Retrieves a distinct array of 'getter' names from an object and its prototype chain.

                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                    • obj: any = {} +

                                                                                                                                                                                                                                                                                                                      The object to inspect

                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                    Returns string[]

                                                                                                                                                                                                                                                                                                                    An array of property keys that have getter functions

                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    const getters = getAccessors(myInstance);
+
                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getCaller.html b/packages/tempo/public/v4/api/library/functions/common.index.getCaller.html new file mode 100644 index 00000000..c474ec64 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getCaller.html @@ -0,0 +1,49 @@ +getCaller | Library API
                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                    Function getCaller

                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                      Analyzes the Call Stack to determine the calling function's name.

                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                      Returns string | undefined

                                                                                                                                                                                                                                                                                                                      The name of the calling function, or undefined if unresolvable

                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      function myFunc() { console.log(getCaller()); } // 'myFunc'
+
                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getContext.html b/packages/tempo/public/v4/api/library/functions/common.index.getContext.html new file mode 100644 index 00000000..a7aee469 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getContext.html @@ -0,0 +1,50 @@ +getContext | Library API
                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                      Function getContext

                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                        Determines the current JavaScript environment context. +Useful for branching logic based on the runtime environment.

                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                        Returns Context

                                                                                                                                                                                                                                                                                                                        An object containing the global scope reference and the CONTEXT type enum

                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        const { type } = getContext();
                                                                                                                                                                                                                                                                                                                        if (type === CONTEXT.Browser) { ... }
+
                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getDaysInMonth.html b/packages/tempo/public/v4/api/library/functions/common.index.getDaysInMonth.html new file mode 100644 index 00000000..b6c93be4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getDaysInMonth.html @@ -0,0 +1,52 @@ +getDaysInMonth | Library API
                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                        Function getDaysInMonth

                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                          Returns the total number of days in the specified month of a given year (1-indexed month, 1..12).

                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                          • year: number +

                                                                                                                                                                                                                                                                                                                            The full calendar year (e.g. 2026)

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                          • month: number +

                                                                                                                                                                                                                                                                                                                            The 1-indexed month number (1 for January through 12 for December)

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                          Total number of days in that month (28..31)

                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getFileStore.html b/packages/tempo/public/v4/api/library/functions/common.index.getFileStore.html new file mode 100644 index 00000000..55942969 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getFileStore.html @@ -0,0 +1,50 @@ +getFileStore | Library API
                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                          Function getFileStore

                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                            Creates or retrieves an encrypted Virtual File Store. +A non-empty password is required. All data stored is encrypted at-rest using AES-GCM (256-bit).

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                            • options: string | FileStoreOptions +

                                                                                                                                                                                                                                                                                                                              Encryption password string or FileStoreOptions object

                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                            Returns Promise<VirtualFileStore>

                                                                                                                                                                                                                                                                                                                            Encrypted VirtualFileStore instance

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getGeoProvider.html b/packages/tempo/public/v4/api/library/functions/common.index.getGeoProvider.html new file mode 100644 index 00000000..999b4215 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getGeoProvider.html @@ -0,0 +1,42 @@ +getGeoProvider | Library API
                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                            Function getGeoProvider

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                              Gets the currently registered custom geolocation provider.

                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                              Returns GeoProvider | undefined

                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getISOWeekOfYear.html b/packages/tempo/public/v4/api/library/functions/common.index.getISOWeekOfYear.html new file mode 100644 index 00000000..4a084b7d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getISOWeekOfYear.html @@ -0,0 +1,59 @@ +getISOWeekOfYear | Library API
                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                              Function getISOWeekOfYear

                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                Polyfill fallback for ISO 8601 Week of Year and Year of Week calculations.

                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                Introduced because highly experimental native browser implementations of the Temporal API +(e.g., Chrome/Firefox behind flags) currently return undefined for weekOfYear and yearOfWeek +on ZonedDateTime objects. The TC39 spec moved toward calendar-dependent definitions, +causing divergence between the @js-temporal/polyfill (which returns numbers) and native browsers (which return undefined).

                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                • zdt: input +

                                                                                                                                                                                                                                                                                                                                  The ZonedDateTime or matching input object

                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                Returns result

                                                                                                                                                                                                                                                                                                                                An object containing the weekOfYear and yearOfWeek

                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                const { weekOfYear } = getISOWeekOfYear(Temporal.Now.zonedDateTimeISO());
+
                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getIsoWeek.html b/packages/tempo/public/v4/api/library/functions/common.index.getIsoWeek.html new file mode 100644 index 00000000..55ddf66f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getIsoWeek.html @@ -0,0 +1,47 @@ +getIsoWeek | Library API
                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                Function getIsoWeek

                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                  Returns numeric week and week-year fields when both are supplied; otherwise computes them +from the Gregorian year, month, and day using standard ISO 8601 rules.

                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                  • z: {
                                                                                                                                                                                                                                                                                                                                        day: number;
                                                                                                                                                                                                                                                                                                                                        month: number;
                                                                                                                                                                                                                                                                                                                                        weekOfYear?: number;
                                                                                                                                                                                                                                                                                                                                        year: number;
                                                                                                                                                                                                                                                                                                                                        yearOfWeek?: number;
                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                  Returns { weekOfYear: number; yearOfWeek: number }

                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getLanguage.html b/packages/tempo/public/v4/api/library/functions/common.index.getLanguage.html new file mode 100644 index 00000000..2b68c635 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getLanguage.html @@ -0,0 +1,59 @@ +getLanguage | Library API
                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                  Function getLanguage

                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                    Extracts the primary language subtag (e.g., 'en', 'fr') from a locale or list of locales. +Defaults to 'en' if not determinable.

                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                    • Optionallocale: unknown +

                                                                                                                                                                                                                                                                                                                                      Locale identifier or list of locales

                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                    • fallback: string = 'en' +

                                                                                                                                                                                                                                                                                                                                      Fallback language subtag (default: 'en')

                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                    The lowercase language subtag

                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    getLanguage('en-US'); // 'en'
                                                                                                                                                                                                                                                                                                                                    getLanguage(['fr-CA', 'en-US']); // 'fr'
                                                                                                                                                                                                                                                                                                                                    getLanguage(); // 'en'
+
                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getLocaleWeekOfYear.html b/packages/tempo/public/v4/api/library/functions/common.index.getLocaleWeekOfYear.html new file mode 100644 index 00000000..36e62a33 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getLocaleWeekOfYear.html @@ -0,0 +1,58 @@ +getLocaleWeekOfYear | Library API
                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                    Function getLocaleWeekOfYear

                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                      Calculates the week-of-year and week-numbering year for a given date according to locale-specific week rules.

                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                      • zdt: input +

                                                                                                                                                                                                                                                                                                                                        The ZonedDateTime or matching input object

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                      • OptionalweekInfo: { firstDay?: number; minimalDays?: number; region?: string } +

                                                                                                                                                                                                                                                                                                                                        Optional week rules with firstDay (1=Mon..7=Sun) and minimalDays (defaults to 1 when omitted, or derived from region)

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                      Returns result

                                                                                                                                                                                                                                                                                                                                      An object containing the weekOfYear and yearOfWeek

                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      const { weekOfYear, yearOfWeek } = getLocaleWeekOfYear(Temporal.Now.zonedDateTimeISO(), { firstDay: 7, minimalDays: 1 });
+
                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getMemoryStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.getMemoryStorage.html new file mode 100644 index 00000000..e3f5f934 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getMemoryStorage.html @@ -0,0 +1,49 @@ +getMemoryStorage | Library API
                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                      Function getMemoryStorage

                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                        Retrieves or creates a named in-memory Storage instance for environments without native Storage support.

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                        • name: string +

                                                                                                                                                                                                                                                                                                                                          The identifier for the memory storage instance

                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                        Returns Storage

                                                                                                                                                                                                                                                                                                                                        A Storage-compatible object backed by in-memory Map

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getMethods.html b/packages/tempo/public/v4/api/library/functions/common.index.getMethods.html new file mode 100644 index 00000000..5aa0a010 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getMethods.html @@ -0,0 +1,58 @@ +getMethods | Library API
                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                        Function getMethods

                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                          Finds all method names on an object.

                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                          • obj: any +

                                                                                                                                                                                                                                                                                                                                            The object to inspect

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                          • all: boolean = false +

                                                                                                                                                                                                                                                                                                                                            Whether to traverse the prototype chain (default: false)

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                          Returns PropertyKey[]

                                                                                                                                                                                                                                                                                                                                          An array of property keys corresponding to functions

                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          const methods = getMethods(myClassInstance);
+
                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getNextCronEpoch.html b/packages/tempo/public/v4/api/library/functions/common.index.getNextCronEpoch.html new file mode 100644 index 00000000..e5a246cb --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getNextCronEpoch.html @@ -0,0 +1,55 @@ +getNextCronEpoch | Library API
                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                          Function getNextCronEpoch

                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                            Calculates the next occurrence of a cron schedule after the given anchor time.

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                            • pattern: string +

                                                                                                                                                                                                                                                                                                                                              The cron pattern string

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                            • anchorMs: number +

                                                                                                                                                                                                                                                                                                                                              The anchor time in milliseconds since epoch

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                            • timeZone: string = 'UTC' +

                                                                                                                                                                                                                                                                                                                                              The time zone to use for calculations (default: 'UTC')

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                            Returns number

                                                                                                                                                                                                                                                                                                                                            The next occurrence time in milliseconds since epoch

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getNextRRuleEpoch.html b/packages/tempo/public/v4/api/library/functions/common.index.getNextRRuleEpoch.html new file mode 100644 index 00000000..b133b6a9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getNextRRuleEpoch.html @@ -0,0 +1,53 @@ +getNextRRuleEpoch | Library API
                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                            Function getNextRRuleEpoch

                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                              Computes the single next RRULE occurrence epoch millisecond timestamp after fromEpochMs. +Note: RRULE evaluation is performed in UTC.

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                              • rruleStr: string +

                                                                                                                                                                                                                                                                                                                                                The RFC 5545 recurrence rule string

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                              • fromEpochMs: number +

                                                                                                                                                                                                                                                                                                                                                The baseline timestamp in epoch milliseconds

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                              Returns number | null

                                                                                                                                                                                                                                                                                                                                              Epoch millisecond timestamp of the next occurrence, or null if no further occurrences exist

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getNextScheduleEpoch.html b/packages/tempo/public/v4/api/library/functions/common.index.getNextScheduleEpoch.html new file mode 100644 index 00000000..f7ae8f82 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getNextScheduleEpoch.html @@ -0,0 +1,60 @@ +getNextScheduleEpoch | Library API
                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                              Function getNextScheduleEpoch

                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                Polymorphically computes the next occurrence epoch timestamp (in milliseconds) +for a schedule expression (Cron pattern or RRULE string).

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                • pattern: string +

                                                                                                                                                                                                                                                                                                                                                  The schedule pattern (5-field Cron or RFC 5545 RRULE)

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                • anchorMs: number +

                                                                                                                                                                                                                                                                                                                                                  The starting anchor timestamp in epoch milliseconds

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                • timeZone: string = 'UTC' +

                                                                                                                                                                                                                                                                                                                                                  The IANA time zone identifier for Cron patterns (defaults to UTC)

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                Returns number | null

                                                                                                                                                                                                                                                                                                                                                Next epoch timestamp in milliseconds, or null if no future occurrences exist

                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                RRULE strings are evaluated in UTC because getNextRRuleEpoch does not accept a timeZone, while timeZone is applied only to Cron patterns.

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getOffsets.html b/packages/tempo/public/v4/api/library/functions/common.index.getOffsets.html new file mode 100644 index 00000000..747f7c9c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getOffsets.html @@ -0,0 +1,52 @@ +getOffsets | Library API
                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                Function getOffsets

                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                  Gets the timezone offsets for January 1 and July 1 of a given year.

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                  • timeZone: string +

                                                                                                                                                                                                                                                                                                                                                    The IANA timezone identifier

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                  • year: number = 2024 +

                                                                                                                                                                                                                                                                                                                                                    The year for which to calculate the offsets; defaults to 2024

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                  Returns Readonly<{ jan: number; jul: number }>

                                                                                                                                                                                                                                                                                                                                                  An object containing January and July offsets in nanoseconds

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getPrevCronEpoch.html b/packages/tempo/public/v4/api/library/functions/common.index.getPrevCronEpoch.html new file mode 100644 index 00000000..9171f3bd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getPrevCronEpoch.html @@ -0,0 +1,55 @@ +getPrevCronEpoch | Library API
                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                  Function getPrevCronEpoch

                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                    Calculates the previous occurrence of a cron schedule before the given anchor time.

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                    • pattern: string +

                                                                                                                                                                                                                                                                                                                                                      The cron pattern string

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                    • anchorMs: number +

                                                                                                                                                                                                                                                                                                                                                      The anchor time in milliseconds since epoch

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                    • timeZone: string = 'UTC' +

                                                                                                                                                                                                                                                                                                                                                      The time zone to use for calculations (default: 'UTC')

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                    Returns number

                                                                                                                                                                                                                                                                                                                                                    The previous occurrence time in milliseconds since epoch

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getRelativeTime.html b/packages/tempo/public/v4/api/library/functions/common.index.getRelativeTime.html new file mode 100644 index 00000000..f5b79e00 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getRelativeTime.html @@ -0,0 +1,68 @@ +getRelativeTime | Library API
                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                    Function getRelativeTime

                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                      Returns a localized relative time string using Intl.RelativeTimeFormat. +Falls back to a basic string representation if formatting fails.

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                      • value: number +

                                                                                                                                                                                                                                                                                                                                                        The numeric value to format (e.g., 2)

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                      • unit: RelativeTimeFormatUnit +

                                                                                                                                                                                                                                                                                                                                                        The time unit (e.g., 'days', 'hours')

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                      • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                                                                        Optional locale string or Intl.Locale

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                      • style: RelativeTimeFormatStyle = 'narrow' +

                                                                                                                                                                                                                                                                                                                                                        The formatting style (default: 'narrow')

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                      • numeric: RelativeTimeFormatNumeric = 'always' +

                                                                                                                                                                                                                                                                                                                                                        The numeric formatting preference (default: 'always')

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                                                                                                                      The localized relative time string

                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      getRelativeTime(2, 'days', 'en'); // 'in 2 days'
+
                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getSafeStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.getSafeStorage.html new file mode 100644 index 00000000..2b951041 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getSafeStorage.html @@ -0,0 +1,46 @@ +getSafeStorage | Library API
                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                      Function getSafeStorage

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                        Safely attempt to retrieve a Storage object from globalThis or fallback to memory storage

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                        • name: "localStorage" | "sessionStorage" = 'localStorage'
                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                        Returns Storage

                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getSafeTag.html b/packages/tempo/public/v4/api/library/functions/common.index.getSafeTag.html new file mode 100644 index 00000000..0a975f75 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getSafeTag.html @@ -0,0 +1,46 @@ +getSafeTag | Library API
                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                        Function getSafeTag

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                          Safely extract Symbol.toStringTag, guarding against dynamic getters that throw

                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                          • obj: any
                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                          Returns string | undefined

                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getScript.html b/packages/tempo/public/v4/api/library/functions/common.index.getScript.html new file mode 100644 index 00000000..b1cd562e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getScript.html @@ -0,0 +1,55 @@ +getScript | Library API
                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                          Function getScript

                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                            Analyzes the Call Stack to determine the calling script's URI.

                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                            • nbr: number = 1 +

                                                                                                                                                                                                                                                                                                                                                              The stack depth to inspect (default: 1)

                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                            Returns string

                                                                                                                                                                                                                                                                                                                                                            The URI of the calling script

                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            const scriptUrl = getScript();
+
                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getSpatialCacheKey.html b/packages/tempo/public/v4/api/library/functions/common.index.getSpatialCacheKey.html new file mode 100644 index 00000000..5ddc4139 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getSpatialCacheKey.html @@ -0,0 +1,49 @@ +getSpatialCacheKey | Library API
                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                            Function getSpatialCacheKey

                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                              Computes a 2-decimal spatial bucket key (~1.1 km resolution) for coordinate caching, +partitioned by lookup source, provider identity, or custom endpoint.

                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                              • lat: number
                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                              • lng: number
                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                              • OptionalsourceOrOpts: string | Record<string, any>
                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                              Returns string

                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getSpatialReverseCache.html b/packages/tempo/public/v4/api/library/functions/common.index.getSpatialReverseCache.html new file mode 100644 index 00000000..95b37e19 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getSpatialReverseCache.html @@ -0,0 +1,42 @@ +getSpatialReverseCache | Library API
                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                              Function getSpatialReverseCache

                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                Returns the active BoundedCache instance used for spatial reverse geocoding deduplication.

                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                Returns BoundedCache<string, GeoConfig>

                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getStashedGeo.html b/packages/tempo/public/v4/api/library/functions/common.index.getStashedGeo.html new file mode 100644 index 00000000..efb9553b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getStashedGeo.html @@ -0,0 +1,50 @@ +getStashedGeo | Library API
                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                Function getStashedGeo

                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                  Synchronously retrieves stashed geolocation from storage or memory cache if present. +Supports optional tenant key or options object for multi-tenant isolation.

                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                  • OptionalkeyOrOpts: string | Record<string, any> +

                                                                                                                                                                                                                                                                                                                                                                    Optional tenant key or lookup options containing key/ip

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                  Returns GeoConfig | undefined

                                                                                                                                                                                                                                                                                                                                                                  Cached GeoConfig or undefined

                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.getStorage.html new file mode 100644 index 00000000..5cbd28ed --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getStorage.html @@ -0,0 +1,109 @@ +getStorage | Library API
                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                  Function getStorage

                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Retrieves a value from the active storage mechanism across any runtime environment +(Browser, NodeJS, Deno, GoogleAppsScript). Rebuilds serialized objects automatically.

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Returns T

                                                                                                                                                                                                                                                                                                                                                                    The deserialized value, or the default value

                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    const user = getStorage<{ name: string }>('user', { name: 'Guest' });
+
                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Retrieves a value from the active storage mechanism across any runtime environment +(Browser, NodeJS, Deno, GoogleAppsScript). Rebuilds serialized objects automatically.

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • key: string +

                                                                                                                                                                                                                                                                                                                                                                      The storage key to lookup

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                    The deserialized value, or the default value

                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    const user = getStorage<{ name: string }>('user', { name: 'Guest' });
+
                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Retrieves a value from the active storage mechanism across any runtime environment +(Browser, NodeJS, Deno, GoogleAppsScript). Rebuilds serialized objects automatically.

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • key: string | undefined +

                                                                                                                                                                                                                                                                                                                                                                      The storage key to lookup

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                    • Optionaldflt: T +

                                                                                                                                                                                                                                                                                                                                                                      The fallback value if the key does not exist

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Returns T

                                                                                                                                                                                                                                                                                                                                                                    The deserialized value, or the default value

                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    const user = getStorage<{ name: string }>('user', { name: 'Guest' });
+
                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getTemporalIds.html b/packages/tempo/public/v4/api/library/functions/common.index.getTemporalIds.html new file mode 100644 index 00000000..8d46bb8f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getTemporalIds.html @@ -0,0 +1,54 @@ +getTemporalIds | Library API
                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                    Function getTemporalIds

                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                      Normalizes TimeZone and Calendar inputs into a [timeZoneId, calendarId] tuple. +Accepts either (tz, cal) strings or a single ZonedDateTime-like object. +Supports both spec-final (flat) and V8 harmony (nested) Temporal structures.

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                      • OptionaltzOrZdt: unknown +

                                                                                                                                                                                                                                                                                                                                                                        The TimeZone string, Calendar string, or ZonedDateTime object

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                      • Optionalcal: unknown +

                                                                                                                                                                                                                                                                                                                                                                        The optional Calendar string if tzOrZdt is a timezone

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                      Returns [string, string]

                                                                                                                                                                                                                                                                                                                                                                      A tuple of [timeZoneId, calendarId]

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getType.html b/packages/tempo/public/v4/api/library/functions/common.index.getType.html new file mode 100644 index 00000000..180537dd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getType.html @@ -0,0 +1,63 @@ +getType | Library API
                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                      Function getType

                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                        Returns an object's type as a ProperCase string (e.g., 'String', 'Number', 'Array'). +If the object is a registered class instance, returns its class name.

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                        • Optionalobj: any +

                                                                                                                                                                                                                                                                                                                                                                          The value to determine the type of

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                        • ...instances: Instance[] +

                                                                                                                                                                                                                                                                                                                                                                          Optional list of additional custom instances to check against

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                        Returns Type

                                                                                                                                                                                                                                                                                                                                                                        The string representation of the object's type

                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                        Load-Order Dependency: Consumers must import modules that call registerType() +before calling getType() to ensure custom types are correctly identified.

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        getType([]); // 'Array'
+
                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.getUtcParts.html b/packages/tempo/public/v4/api/library/functions/common.index.getUtcParts.html new file mode 100644 index 00000000..bcfd60ef --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.getUtcParts.html @@ -0,0 +1,51 @@ +getUtcParts | Library API
                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                        Function getUtcParts

                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                          Extracts all UTC calendar and clock components from a Date instance as a structured object. +Month and weekday are 1-indexed (1 for January, 1 for Monday through 7 for Sunday). +Defaults to current timestamp (new Date()) if no date is provided.

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                          • date: Date = ... +

                                                                                                                                                                                                                                                                                                                                                                            Optional Date instance to inspect (defaults to new Date())

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                          Returns UtcParts

                                                                                                                                                                                                                                                                                                                                                                          An object containing { year, month, day, weekday, hours, minutes, seconds, milliseconds }

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hasAnyOf.html b/packages/tempo/public/v4/api/library/functions/common.index.hasAnyOf.html new file mode 100644 index 00000000..83249106 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hasAnyOf.html @@ -0,0 +1,66 @@ +hasAnyOf | Library API
                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                          Function hasAnyOf

                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Asserts whether an object has at least one of the specified keys (using the in operator, unwrapping Proxies if present). +Safe against null, undefined, and non-object primitives.

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                            • K extends readonly PropertyKey[]
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                              The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                            • ...keys: K +

                                                                                                                                                                                                                                                                                                                                                                              Candidate property keys to verify, including inherited properties

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Returns obj is { [P in PropertyKey]: Record<P, unknown> }[K[number]]

                                                                                                                                                                                                                                                                                                                                                                            True if the target contains at least one of the specified keys; false if no keys are provided or obj is not an object

                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Errors from proxy traps or getters used while unwrapping or checking keys propagate to the caller.

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            if (hasAnyOf(arg, 'install', 'define')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hasKey.html b/packages/tempo/public/v4/api/library/functions/common.index.hasKey.html new file mode 100644 index 00000000..fd086b8f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hasKey.html @@ -0,0 +1,96 @@ +hasKey | Library API
                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                            Function hasKey

                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Asserts that an object contains a specified key, optionally validating and narrowing its value type. +Safe against null, undefined, and non-object primitives.

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • K extends PropertyKey
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                              • key: K +

                                                                                                                                                                                                                                                                                                                                                                                The property key to verify, including inherited properties

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Returns obj is Record<K, unknown>

                                                                                                                                                                                                                                                                                                                                                                              True if the target contains the key

                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              if (hasKey(config, 'timeout')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Asserts that an object contains a specified key whose value matches at least one of the specified +type tags (case-insensitive, e.g. 'string', 'String', 'Number') or predicate functions.

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • K extends PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                              • G extends AnyGuard[]
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                              • key: K +

                                                                                                                                                                                                                                                                                                                                                                                The property key to verify

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                              • ...guards: [...G[]] +

                                                                                                                                                                                                                                                                                                                                                                                One or more type tags or predicate functions

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Returns obj is Record<K, ResolveTypeGuards<G>>

                                                                                                                                                                                                                                                                                                                                                                              True if the target contains the key and its value satisfies at least one guard

                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              if (hasKey(err, 'code', 'String', 'number')) {
                                                                                                                                                                                                                                                                                                                                                                                console.log(err.code); // string | number
                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                              if (hasKey(err, 'code', isString, isNumber)) {
                                                                                                                                                                                                                                                                                                                                                                                console.log(err.code); // string | number
                                                                                                                                                                                                                                                                                                                                                                              }
+
                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hasKeys.html b/packages/tempo/public/v4/api/library/functions/common.index.hasKeys.html new file mode 100644 index 00000000..e4138496 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hasKeys.html @@ -0,0 +1,67 @@ +hasKeys | Library API
                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                              Function hasKeys

                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Asserts whether an object has one or more keys (using the in operator, unwrapping Proxies if present). +Safe against null, undefined, and non-object primitives. +Narrows obj to a record containing the specified keys.

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • K extends PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                  The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                • ...keys: K[] +

                                                                                                                                                                                                                                                                                                                                                                                  Property keys to verify, including inherited properties

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Returns obj is Record<K, unknown>

                                                                                                                                                                                                                                                                                                                                                                                True if the target contains all specified keys; with no keys, true for objects and functions

                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Errors from proxy traps or getters used while unwrapping or checking keys propagate to the caller.

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                if (hasKeys(config, 'dialect')) { ... }
                                                                                                                                                                                                                                                                                                                                                                                if (hasKeys(options, 'from', 'to')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hasNoneOf.html b/packages/tempo/public/v4/api/library/functions/common.index.hasNoneOf.html new file mode 100644 index 00000000..16aa0bcf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hasNoneOf.html @@ -0,0 +1,62 @@ +hasNoneOf | Library API
                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                Function hasNoneOf

                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Asserts whether an object possesses NONE of the specified keys (using the in operator, unwrapping Proxies if present). +Safe against null, undefined, and non-object primitives (returns true for non-objects).

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                    The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                  • ...keys: PropertyKey[] +

                                                                                                                                                                                                                                                                                                                                                                                    Property keys that must not exist on the target

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                  True if none of the specified keys exist on the target

                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Errors from proxy traps or getters used while unwrapping or checking keys propagate to the caller.

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  if (hasNoneOf(item, 'name', 'key', 'install')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hasOwn.html b/packages/tempo/public/v4/api/library/functions/common.index.hasOwn.html new file mode 100644 index 00000000..9a186c96 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hasOwn.html @@ -0,0 +1,97 @@ +hasOwn | Library API
                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                  Function hasOwn

                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Checks whether an object possesses a specific own property, unwrapping Proxies if present. +Safe against null, undefined, and non-object primitives.

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • K extends PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                      The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    • key: K +

                                                                                                                                                                                                                                                                                                                                                                                      The property key to test

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                    True if the unwrapped target possesses key as an own property

                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    if (hasOwn(config, 'timeZone')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Asserts that an object possesses a specific own property whose value matches at least one of the +specified type tags (case-insensitive, e.g. 'string', 'String', 'Number') or predicate functions. +Safe against null, undefined, and non-object primitives.

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • K extends PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    • G extends AnyGuard[]
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                      The target object to inspect

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    • key: K +

                                                                                                                                                                                                                                                                                                                                                                                      The property key to verify

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    • ...guards: [...G[]] +

                                                                                                                                                                                                                                                                                                                                                                                      One or more type tags or predicate functions

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is Record<K, ResolveTypeGuards<G>>

                                                                                                                                                                                                                                                                                                                                                                                    True if the target possesses the own property and its value satisfies at least one guard

                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    if (hasOwn(config, 'timeout', 'number')) {
                                                                                                                                                                                                                                                                                                                                                                                      config.timeout.toFixed();
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                    if (hasOwn(err, 'code', isString, isNumber)) {
                                                                                                                                                                                                                                                                                                                                                                                      console.log(err.code);
                                                                                                                                                                                                                                                                                                                                                                                    }
+
                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hash.html b/packages/tempo/public/v4/api/library/functions/common.index.hash.html new file mode 100644 index 00000000..59fe79d6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hash.html @@ -0,0 +1,55 @@ +hash | Library API
                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                    Function hash

                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Computes a cryptographic hash digest for the provided source payload.

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      • source: string | Object +

                                                                                                                                                                                                                                                                                                                                                                                        The data to hash

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • Optionallen: number +

                                                                                                                                                                                                                                                                                                                                                                                        Optional length to truncate the resulting hex string

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      • alg: string = 'SHA-256' +

                                                                                                                                                                                                                                                                                                                                                                                        The hash algorithm to use (default: 'SHA-256')

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<string>

                                                                                                                                                                                                                                                                                                                                                                                      A promise resolving to the hash hex string

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.hmac.html b/packages/tempo/public/v4/api/library/functions/common.index.hmac.html new file mode 100644 index 00000000..81bbee3f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.hmac.html @@ -0,0 +1,58 @@ +hmac | Library API
                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                      Function hmac

                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        Generates a Hash-based Message Authentication Code (HMAC) for a given source payload.

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                        • source: string | Object +

                                                                                                                                                                                                                                                                                                                                                                                          The data to hash

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                        • secret: string +

                                                                                                                                                                                                                                                                                                                                                                                          The secret key used for hashing

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                        • alg: string = 'SHA-512' +

                                                                                                                                                                                                                                                                                                                                                                                          The hash algorithm to use (default: 'SHA-512')

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                        • Optionallen: number +

                                                                                                                                                                                                                                                                                                                                                                                          Optional length to truncate the resulting hex string

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<string>

                                                                                                                                                                                                                                                                                                                                                                                        A promise resolving to the HMAC hex string

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ifDefined.html b/packages/tempo/public/v4/api/library/functions/common.index.ifDefined.html new file mode 100644 index 00000000..94149015 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ifDefined.html @@ -0,0 +1,59 @@ +ifDefined | Library API
                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                        Function ifDefined

                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Extracts a new object containing only the properties with defined (non-undefined) values.

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                          • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                            The object to extract from

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Returns Omit<T, UnsafeKey>

                                                                                                                                                                                                                                                                                                                                                                                          A new object without undefined values

                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          const clean = ifDefined({ a: 1, b: undefined }); // { a: 1 }
+
                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ifNumeric.html b/packages/tempo/public/v4/api/library/functions/common.index.ifNumeric.html new file mode 100644 index 00000000..7df54111 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ifNumeric.html @@ -0,0 +1,58 @@ +ifNumeric | Library API
                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                          Function ifNumeric

                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            Returns the value as a Number or BigInt if possible, otherwise returns the original string.

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                            • str: string | number | bigint +

                                                                                                                                                                                                                                                                                                                                                                                              The string, number, or bigint to process

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                            • stripZero: boolean = false +

                                                                                                                                                                                                                                                                                                                                                                                              Whether to strip leading zeros when evaluating numeric strings

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            Returns string | number | bigint

                                                                                                                                                                                                                                                                                                                                                                                            The numeric coercion or the original string

                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            const num = ifNumeric('123'); // 123
+
                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.importJWK.html b/packages/tempo/public/v4/api/library/functions/common.index.importJWK.html new file mode 100644 index 00000000..d559b138 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.importJWK.html @@ -0,0 +1,56 @@ +importJWK | Library API
                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                            Function importJWK

                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              Imports a JSON Web Key (JWK) into a native Web Crypto API CryptoKey object. +Supports RSA keys (RS256, RS384, RS512) and symmetric oct keys (HS256, HS384, HS512).

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                              • jwk: JsonWebKey +

                                                                                                                                                                                                                                                                                                                                                                                                The standard JsonWebKey object

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                              • Optionalusage: KeyUsage[] +

                                                                                                                                                                                                                                                                                                                                                                                                Optional explicit key usages

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                              • extractable: boolean = false +

                                                                                                                                                                                                                                                                                                                                                                                                Optional boolean indicating whether the key is extractable (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<CryptoKey>

                                                                                                                                                                                                                                                                                                                                                                                              A promise resolving to the imported CryptoKey

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.importPrivateKey.html b/packages/tempo/public/v4/api/library/functions/common.index.importPrivateKey.html new file mode 100644 index 00000000..0785fe6d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.importPrivateKey.html @@ -0,0 +1,55 @@ +importPrivateKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                              Function importPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                Imports a PKCS#8 PEM-formatted private key string into a native Web Crypto API CryptoKey object.

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                • pem: string +

                                                                                                                                                                                                                                                                                                                                                                                                  The PEM-formatted private key string

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                • alg: string = keys.SignKey +

                                                                                                                                                                                                                                                                                                                                                                                                  The signature algorithm identifier (default: keys.SignKey)

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                • hash: string = keys.Algorithm +

                                                                                                                                                                                                                                                                                                                                                                                                  The hash algorithm identifier (default: keys.Algorithm)

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                Returns Promise<CryptoKey>

                                                                                                                                                                                                                                                                                                                                                                                                A promise resolving to the imported CryptoKey

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.importPublicKey.html b/packages/tempo/public/v4/api/library/functions/common.index.importPublicKey.html new file mode 100644 index 00000000..5c1a6c55 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.importPublicKey.html @@ -0,0 +1,55 @@ +importPublicKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                Function importPublicKey

                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  Imports a PEM-formatted public key string into a native Web Crypto API CryptoKey object.

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                  • pem: string +

                                                                                                                                                                                                                                                                                                                                                                                                    The PEM-formatted public key string

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                  • alg: string = keys.SignKey +

                                                                                                                                                                                                                                                                                                                                                                                                    The signature algorithm identifier (default: keys.SignKey)

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                  • hash: string = keys.Algorithm +

                                                                                                                                                                                                                                                                                                                                                                                                    The hash algorithm identifier (default: keys.Algorithm)

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<CryptoKey>

                                                                                                                                                                                                                                                                                                                                                                                                  A promise resolving to the imported CryptoKey

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.indexedArray.html b/packages/tempo/public/v4/api/library/functions/common.index.indexedArray.html new file mode 100644 index 00000000..4ba91d8a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.indexedArray.html @@ -0,0 +1,133 @@ +indexedArray | Library API
                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                  Function indexedArray

                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Augments a standard array with a Proxy-based lookup delegate. +Allows index/enumerable array methods to function natively (e.g., map, filter, length), +while redirecting non-numeric string keys to a custom finder function to lookup items.

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • list: readonly T[] | T[] +

                                                                                                                                                                                                                                                                                                                                                                                                      The array to augment

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • finder: (key: string) => T | undefined +

                                                                                                                                                                                                                                                                                                                                                                                                      The lookup function for non-numeric keys

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • Optionalreadonly: true +

                                                                                                                                                                                                                                                                                                                                                                                                      Whether the array should be read-only (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Returns readonly T[] & Readonly<Record<string, T>>

                                                                                                                                                                                                                                                                                                                                                                                                    The augmented array with record-like string indexing

                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    const arr = indexedArray([{ id: 'a' }], key => list.find(x => x.id === key));
                                                                                                                                                                                                                                                                                                                                                                                                    arr['a']; // { id: 'a' }
+
                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Augments a standard array with a Proxy-based lookup delegate. +Allows index/enumerable array methods to function natively (e.g., map, filter, length), +while redirecting non-numeric string keys to a custom finder function to lookup items.

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • list: T[] +

                                                                                                                                                                                                                                                                                                                                                                                                      The array to augment

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • finder: (key: string) => T | undefined +

                                                                                                                                                                                                                                                                                                                                                                                                      The lookup function for non-numeric keys

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • readonly: false +

                                                                                                                                                                                                                                                                                                                                                                                                      Whether the array should be read-only (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Returns T[] & Record<string, T>

                                                                                                                                                                                                                                                                                                                                                                                                    The augmented array with record-like string indexing

                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    const arr = indexedArray([{ id: 'a' }], key => list.find(x => x.id === key));
                                                                                                                                                                                                                                                                                                                                                                                                    arr['a']; // { id: 'a' }
+
                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Augments a standard array with a Proxy-based lookup delegate. +Allows index/enumerable array methods to function natively (e.g., map, filter, length), +while redirecting non-numeric string keys to a custom finder function to lookup items.

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • list: readonly T[] | T[] +

                                                                                                                                                                                                                                                                                                                                                                                                      The array to augment

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • finder: (key: string) => T | undefined +

                                                                                                                                                                                                                                                                                                                                                                                                      The lookup function for non-numeric keys

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    • Optionalreadonly: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                      Whether the array should be read-only (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Returns readonly T[] & Readonly<Record<string, T>> | T[] & Record<string, T>

                                                                                                                                                                                                                                                                                                                                                                                                    The augmented array with record-like string indexing

                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    const arr = indexedArray([{ id: 'a' }], key => list.find(x => x.id === key));
                                                                                                                                                                                                                                                                                                                                                                                                    arr['a']; // { id: 'a' }
+
                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.instant.html b/packages/tempo/public/v4/api/library/functions/common.index.instant.html new file mode 100644 index 00000000..289ebec9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.instant.html @@ -0,0 +1,43 @@ +instant | Library API
                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                    Function instant

                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                      Returns the current instant in time using Temporal.Now.instant().

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                      Returns Instant

                                                                                                                                                                                                                                                                                                                                                                                                      The current Temporal.Instant

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isAbortController.html b/packages/tempo/public/v4/api/library/functions/common.index.isAbortController.html new file mode 100644 index 00000000..f1a036cc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isAbortController.html @@ -0,0 +1,46 @@ +isAbortController | Library API
                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                      Function isAbortController

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Type guard to check if a value is an AbortController

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                        • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is AbortController

                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isAbortSignal.html b/packages/tempo/public/v4/api/library/functions/common.index.isAbortSignal.html new file mode 100644 index 00000000..7378e1ff --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isAbortSignal.html @@ -0,0 +1,46 @@ +isAbortSignal | Library API
                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                        Function isAbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          Type guard to check if a value is an AbortSignal (cross-realm safe)

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                          • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          Returns obj is AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isArray.html b/packages/tempo/public/v4/api/library/functions/common.index.isArray.html new file mode 100644 index 00000000..3a753b06 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isArray.html @@ -0,0 +1,48 @@ +isArray | Library API
                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                          Function isArray

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is T[]

                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isArrayLike.html b/packages/tempo/public/v4/api/library/functions/common.index.isArrayLike.html new file mode 100644 index 00000000..0d65392f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isArrayLike.html @@ -0,0 +1,48 @@ +isArrayLike | Library API
                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                            Function isArrayLike

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                              • T = any
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                              • obj: any
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is ArrayLike<T>

                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isBase64.html b/packages/tempo/public/v4/api/library/functions/common.index.isBase64.html new file mode 100644 index 00000000..bc7aa0e6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isBase64.html @@ -0,0 +1,46 @@ +isBase64 | Library API
                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                              Function isBase64

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                Type guard to check if a value is a Base64 string

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isBase64Url.html b/packages/tempo/public/v4/api/library/functions/common.index.isBase64Url.html new file mode 100644 index 00000000..2a05684a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isBase64Url.html @@ -0,0 +1,46 @@ +isBase64Url | Library API
                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                Function isBase64Url

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Type guard to check if a value is a Base64URL string

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isBoolean.html b/packages/tempo/public/v4/api/library/functions/common.index.isBoolean.html new file mode 100644 index 00000000..028f90f9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isBoolean.html @@ -0,0 +1,44 @@ +isBoolean | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                  Function isBoolean

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is boolean

                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isCallable.html b/packages/tempo/public/v4/api/library/functions/common.index.isCallable.html new file mode 100644 index 00000000..f7d1134c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isCallable.html @@ -0,0 +1,44 @@ +isCallable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                    Function isCallable

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is Function

                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isClass.html b/packages/tempo/public/v4/api/library/functions/common.index.isClass.html new file mode 100644 index 00000000..ae692484 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isClass.html @@ -0,0 +1,44 @@ +isClass | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                      Function isClass

                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is Function

                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isCronString.html b/packages/tempo/public/v4/api/library/functions/common.index.isCronString.html new file mode 100644 index 00000000..78bb8d89 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isCronString.html @@ -0,0 +1,49 @@ +isCronString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                        Function isCronString

                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          Determines whether a value is a valid five-field cron expression.

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • val: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                            The value to validate

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          Returns val is string

                                                                                                                                                                                                                                                                                                                                                                                                                          true if the value is a valid cron expression, false otherwise

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDST.html b/packages/tempo/public/v4/api/library/functions/common.index.isDST.html new file mode 100644 index 00000000..f796bdda --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDST.html @@ -0,0 +1,52 @@ +isDST | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                          Function isDST

                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            Determines whether the given (or current) date is observing Daylight Saving Time.

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionaldate: string | ZonedDateTime +

                                                                                                                                                                                                                                                                                                                                                                                                                              Optional ZonedDateTime or ISO string to check

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                            • timeZone: string = ... +

                                                                                                                                                                                                                                                                                                                                                                                                                              The timezone to use if creating a new date (default: system local)

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                            True if the date is in DST, false otherwise

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDate.html b/packages/tempo/public/v4/api/library/functions/common.index.isDate.html new file mode 100644 index 00000000..214061ca --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDate.html @@ -0,0 +1,44 @@ +isDate | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                            Function isDate

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is Date

                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDefined.html b/packages/tempo/public/v4/api/library/functions/common.index.isDefined.html new file mode 100644 index 00000000..ee1f3d66 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDefined.html @@ -0,0 +1,48 @@ +isDefined | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                              Function isDefined

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: T
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is NonNullable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDigit.html b/packages/tempo/public/v4/api/library/functions/common.index.isDigit.html new file mode 100644 index 00000000..e69bcb08 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDigit.html @@ -0,0 +1,44 @@ +isDigit | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                Function isDigit

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is number | bigint

                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDigits.html b/packages/tempo/public/v4/api/library/functions/common.index.isDigits.html new file mode 100644 index 00000000..69c25fcd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDigits.html @@ -0,0 +1,46 @@ +isDigits | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isDigits

                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Type guard to check if a value is an integer digits string (e.g. '123')

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDuration.html b/packages/tempo/public/v4/api/library/functions/common.index.isDuration.html new file mode 100644 index 00000000..a8789cee --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDuration.html @@ -0,0 +1,44 @@ +isDuration | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isDurationLike.html b/packages/tempo/public/v4/api/library/functions/common.index.isDurationLike.html new file mode 100644 index 00000000..4411a092 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isDurationLike.html @@ -0,0 +1,44 @@ +isDurationLike | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isDurationLike

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is DurationLike

                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isEmpty.html b/packages/tempo/public/v4/api/library/functions/common.index.isEmpty.html new file mode 100644 index 00000000..0c5eb445 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isEmpty.html @@ -0,0 +1,61 @@ +isEmpty | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Checks if a value is effectively empty. +Returns true for nullish values, empty objects, empty strings, NaN, empty arrays, +empty sets/maps, empty typed arrays/buffers, and invalid dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalobj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                            The value to check

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                          True if the value is empty

                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          isEmpty([]); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                          isEmpty({ a: 1 }); // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isEnglish.html b/packages/tempo/public/v4/api/library/functions/common.index.isEnglish.html new file mode 100644 index 00000000..fb89d285 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isEnglish.html @@ -0,0 +1,55 @@ +isEnglish | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isEnglish

                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Checks whether all resolved locales in the input belong to the English language family ('en-*').

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionallocales: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Single or multiple locale identifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                            True if at least one valid locale exists and all resolved locales are English

                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnglish('en-US'); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnglish(['en-US', 'en-GB']); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnglish(['en-US', 'fr-FR']); // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isEnum.html b/packages/tempo/public/v4/api/library/functions/common.index.isEnum.html new file mode 100644 index 00000000..fdc09cdf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isEnum.html @@ -0,0 +1,48 @@ +isEnum | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isEnum

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is wrap<E>

                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isEqual.html b/packages/tempo/public/v4/api/library/functions/common.index.isEqual.html new file mode 100644 index 00000000..6ce1d363 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isEqual.html @@ -0,0 +1,59 @@ +isEqual | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Performs a deep comparison between two values to determine if they are equivalent. +Supports primitives, arrays, maps, sets, and plain objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • a: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  The first value to compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • b: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  The second value to compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                True if the values are deeply equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                isEqual({ a: 1 }, { a: 1 }); // true
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isError.html b/packages/tempo/public/v4/api/library/functions/common.index.isError.html new file mode 100644 index 00000000..9ec4cbce --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isError.html @@ -0,0 +1,49 @@ +isError | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isError

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • E extends Error = Error
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • err: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalconstructor: new (...args: any[]) => E
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns err is E

                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isExtensible.html b/packages/tempo/public/v4/api/library/functions/common.index.isExtensible.html new file mode 100644 index 00000000..495472d1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isExtensible.html @@ -0,0 +1,46 @@ +isExtensible | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isExtensible

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    assert value for secure()

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is any

                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isFileUrl.html b/packages/tempo/public/v4/api/library/functions/common.index.isFileUrl.html new file mode 100644 index 00000000..853e42d1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isFileUrl.html @@ -0,0 +1,46 @@ +isFileUrl | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isFileUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type guard to check if a string is a file URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isFiniteRRule.html b/packages/tempo/public/v4/api/library/functions/common.index.isFiniteRRule.html new file mode 100644 index 00000000..496d2446 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isFiniteRRule.html @@ -0,0 +1,49 @@ +isFiniteRRule | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isFiniteRRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checks whether an RRULE string represents a finite (bounded) series.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • rrule: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          The RFC 5545 RRULE string

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                        true if the rule contains an UNTIL or COUNT boundary clause, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isFunction.html b/packages/tempo/public/v4/api/library/functions/common.index.isFunction.html new file mode 100644 index 00000000..c42c30a3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isFunction.html @@ -0,0 +1,48 @@ +isFunction | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns obj is NarrowFunction<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isHex.html b/packages/tempo/public/v4/api/library/functions/common.index.isHex.html new file mode 100644 index 00000000..d2be1d6c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isHex.html @@ -0,0 +1,46 @@ +isHex | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isHex

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type guard to check if a value is a hexadecimal string

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isHttpUrl.html b/packages/tempo/public/v4/api/library/functions/common.index.isHttpUrl.html new file mode 100644 index 00000000..3fe3cfb6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isHttpUrl.html @@ -0,0 +1,46 @@ +isHttpUrl | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isHttpUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type guard to check if a string is an HTTP or HTTPS URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isInstant.html b/packages/tempo/public/v4/api/library/functions/common.index.isInstant.html new file mode 100644 index 00000000..f1afc0c5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isInstant.html @@ -0,0 +1,44 @@ +isInstant | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isInstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is Instant

                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isInteger.html b/packages/tempo/public/v4/api/library/functions/common.index.isInteger.html new file mode 100644 index 00000000..70334623 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isInteger.html @@ -0,0 +1,46 @@ +isInteger | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isInteger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type guard to check if a value is a BigInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is bigint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isIntegerLike.html b/packages/tempo/public/v4/api/library/functions/common.index.isIntegerLike.html new file mode 100644 index 00000000..6e6ca532 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isIntegerLike.html @@ -0,0 +1,44 @@ +isIntegerLike | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isIntegerLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isIterable.html b/packages/tempo/public/v4/api/library/functions/common.index.isIterable.html new file mode 100644 index 00000000..5e5b1bf6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isIterable.html @@ -0,0 +1,50 @@ +isIterable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isIterable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type guard to check if a value is iterable (excludes strings)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is Iterable<T, any, any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isJSON.html b/packages/tempo/public/v4/api/library/functions/common.index.isJSON.html new file mode 100644 index 00000000..25f4aa92 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isJSON.html @@ -0,0 +1,55 @@ +isJSON | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tests if a given value is a valid JSON or JSONC formatted string without throwing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • text: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value to evaluate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns text is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        True if the input is a valid JSON or JSONC string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isJSON('{"valid": true}'); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isJSON('not json'); // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isLeapYear.html b/packages/tempo/public/v4/api/library/functions/common.index.isLeapYear.html new file mode 100644 index 00000000..f846ae61 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isLeapYear.html @@ -0,0 +1,49 @@ +isLeapYear | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isLeapYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines whether a given calendar year is a leap year in the Gregorian calendar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • year: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The full calendar year to test (e.g. 2024)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          true if the year is a leap year, otherwise false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isLocale.html b/packages/tempo/public/v4/api/library/functions/common.index.isLocale.html new file mode 100644 index 00000000..fd3f766d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isLocale.html @@ -0,0 +1,46 @@ +isLocale | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isLocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type guard to check if a value is an Intl.Locale instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is Locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isMap.html b/packages/tempo/public/v4/api/library/functions/common.index.isMap.html new file mode 100644 index 00000000..6107c111 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isMap.html @@ -0,0 +1,49 @@ +isMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • K = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is Map<K, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isNull.html b/packages/tempo/public/v4/api/library/functions/common.index.isNull.html new file mode 100644 index 00000000..d1ee32da --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isNull.html @@ -0,0 +1,44 @@ +isNull | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isNull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is null

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isNullish.html b/packages/tempo/public/v4/api/library/functions/common.index.isNullish.html new file mode 100644 index 00000000..1b85d611 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isNullish.html @@ -0,0 +1,44 @@ +isNullish | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isNullish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is Nullish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isNumber.html b/packages/tempo/public/v4/api/library/functions/common.index.isNumber.html new file mode 100644 index 00000000..a3d2cb81 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isNumber.html @@ -0,0 +1,46 @@ +isNumber | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type guard to check if a value is a finite number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isNumeric.html b/packages/tempo/public/v4/api/library/functions/common.index.isNumeric.html new file mode 100644 index 00000000..5d00bed7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isNumeric.html @@ -0,0 +1,56 @@ +isNumeric | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isNumeric

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tests if a value can be safely converted to a numeric value. +Handles strings, numbers, and BigInts, verifying finite properties and valid formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optionalstr: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      True if the value can be evaluated numerically

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isNumeric('123'); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isNumeric('abc'); // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isObject.html b/packages/tempo/public/v4/api/library/functions/common.index.isObject.html new file mode 100644 index 00000000..19715508 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isObject.html @@ -0,0 +1,48 @@ +isObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is Property<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainDate.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainDate.html new file mode 100644 index 00000000..de8f4f82 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainDate.html @@ -0,0 +1,44 @@ +isPlainDate | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isPlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns obj is PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainDateTime.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainDateTime.html new file mode 100644 index 00000000..3bfb862b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainDateTime.html @@ -0,0 +1,44 @@ +isPlainDateTime | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isPlainDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is PlainDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainMonthDay.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainMonthDay.html new file mode 100644 index 00000000..0ec06141 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainMonthDay.html @@ -0,0 +1,44 @@ +isPlainMonthDay | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isPlainMonthDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is PlainMonthDay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainObject.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainObject.html new file mode 100644 index 00000000..76987384 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainObject.html @@ -0,0 +1,48 @@ +isPlainObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isPlainObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainTime.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainTime.html new file mode 100644 index 00000000..3f9eea43 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainTime.html @@ -0,0 +1,44 @@ +isPlainTime | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isPlainTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is PlainTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPlainYearMonth.html b/packages/tempo/public/v4/api/library/functions/common.index.isPlainYearMonth.html new file mode 100644 index 00000000..828c71fc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPlainYearMonth.html @@ -0,0 +1,44 @@ +isPlainYearMonth | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isPlainYearMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is PlainYearMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPledge.html b/packages/tempo/public/v4/api/library/functions/common.index.isPledge.html new file mode 100644 index 00000000..2e435d33 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPledge.html @@ -0,0 +1,48 @@ +isPledge | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isPledge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • P = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is Pledge<P>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPrimitive.html b/packages/tempo/public/v4/api/library/functions/common.index.isPrimitive.html new file mode 100644 index 00000000..adead45b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPrimitive.html @@ -0,0 +1,46 @@ +isPrimitive | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isPrimitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type-Guards: assert <obj> is of <type>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalobj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is Primitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPromise.html b/packages/tempo/public/v4/api/library/functions/common.index.isPromise.html new file mode 100644 index 00000000..b83e1347 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPromise.html @@ -0,0 +1,48 @@ +isPromise | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isPromise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns obj is Promise<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isPropertyKey.html b/packages/tempo/public/v4/api/library/functions/common.index.isPropertyKey.html new file mode 100644 index 00000000..18745050 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isPropertyKey.html @@ -0,0 +1,44 @@ +isPropertyKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isPropertyKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is PropertyKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isRRuleString.html b/packages/tempo/public/v4/api/library/functions/common.index.isRRuleString.html new file mode 100644 index 00000000..073a6ba2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isRRuleString.html @@ -0,0 +1,49 @@ +isRRuleString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isRRuleString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tests whether a value is a valid RFC 5545 Recurrence Rule (RRULE) string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • input: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The candidate value to inspect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns input is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              true if the value is a string matching an RRULE pattern starting with FREQ=, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isRawJSON.html b/packages/tempo/public/v4/api/library/functions/common.index.isRawJSON.html new file mode 100644 index 00000000..3991b749 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isRawJSON.html @@ -0,0 +1,55 @@ +isRawJSON | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isRawJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Asserts whether a value is a raw JSON object produced by rawJSON or JSON.rawJSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The value to inspect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                True if the value is a raw JSON object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isRawJSON(rawJSON('123')); // true
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isReference.html b/packages/tempo/public/v4/api/library/functions/common.index.isReference.html new file mode 100644 index 00000000..7f5c825d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isReference.html @@ -0,0 +1,44 @@ +isReference | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalobj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isRegExp.html b/packages/tempo/public/v4/api/library/functions/common.index.isRegExp.html new file mode 100644 index 00000000..57cc40d9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isRegExp.html @@ -0,0 +1,44 @@ +isRegExp | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isRegExp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is RegExp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isRegExpLike.html b/packages/tempo/public/v4/api/library/functions/common.index.isRegExpLike.html new file mode 100644 index 00000000..e0fe54a9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isRegExpLike.html @@ -0,0 +1,44 @@ +isRegExpLike | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isRegExpLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isSafeKey.html b/packages/tempo/public/v4/api/library/functions/common.index.isSafeKey.html new file mode 100644 index 00000000..ed3bd440 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isSafeKey.html @@ -0,0 +1,56 @@ +isSafeKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isSafeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Asserts if a property key is safe against prototype pollution and prototype hijacking. +Returns false for 'proto', 'constructor', and 'prototype'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • key: PropertyKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The property key to check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns key is PropertyKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        True if the key is safe to assign or merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSafeKey('name'); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSafeKey('__proto__'); // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isScheduleString.html b/packages/tempo/public/v4/api/library/functions/common.index.isScheduleString.html new file mode 100644 index 00000000..01e5eb51 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isScheduleString.html @@ -0,0 +1,49 @@ +isScheduleString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isScheduleString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sniffs whether a given value is a valid schedule string (either Cron or RRULE).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • val: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to inspect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns val is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          true if the value is a valid Cron pattern or RRULE string, otherwise false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isSet.html b/packages/tempo/public/v4/api/library/functions/common.index.isSet.html new file mode 100644 index 00000000..18e36ad2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isSet.html @@ -0,0 +1,48 @@ +isSet | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is Set<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isString.html b/packages/tempo/public/v4/api/library/functions/common.index.isString.html new file mode 100644 index 00000000..54eeb7b8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isString.html @@ -0,0 +1,46 @@ +isString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type guard to check if a value is a string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isSymbol.html b/packages/tempo/public/v4/api/library/functions/common.index.isSymbol.html new file mode 100644 index 00000000..cad40625 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isSymbol.html @@ -0,0 +1,44 @@ +isSymbol | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is symbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isSymbolFor.html b/packages/tempo/public/v4/api/library/functions/common.index.isSymbolFor.html new file mode 100644 index 00000000..602b8c8e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isSymbolFor.html @@ -0,0 +1,44 @@ +isSymbolFor | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isSymbolFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns obj is symbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isTarget.html b/packages/tempo/public/v4/api/library/functions/common.index.isTarget.html new file mode 100644 index 00000000..0d5a9fe3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isTarget.html @@ -0,0 +1,44 @@ +isTarget | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isTemporal.html b/packages/tempo/public/v4/api/library/functions/common.index.isTemporal.html new file mode 100644 index 00000000..8c49ee6f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isTemporal.html @@ -0,0 +1,44 @@ +isTemporal | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isTemporal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is Temporals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isTestEnvironment.html b/packages/tempo/public/v4/api/library/functions/common.index.isTestEnvironment.html new file mode 100644 index 00000000..83333e39 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isTestEnvironment.html @@ -0,0 +1,44 @@ +isTestEnvironment | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isTestEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Safely determines if the current execution context is in a unit-testing environment (e.g. Vitest, Jest, or CI). +Uses universal getStorage API to avoid direct environment variable AST inspection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        True if running in a test suite or CI environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isText.html b/packages/tempo/public/v4/api/library/functions/common.index.isText.html new file mode 100644 index 00000000..66370813 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isText.html @@ -0,0 +1,46 @@ +isText | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type guard to check if a value is a non-empty string with meaningful content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isType.html b/packages/tempo/public/v4/api/library/functions/common.index.isType.html new file mode 100644 index 00000000..0a4c8ea3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isType.html @@ -0,0 +1,62 @@ +isType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function isType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Asserts if a value matches one of the provided types from the Type system.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The value to check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ...types: Type[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The list of valid Types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns obj is T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            True if the value matches one of the specified types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (isType<string>(value, 'String', 'Number')) { ... }
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isUndefined.html b/packages/tempo/public/v4/api/library/functions/common.index.isUndefined.html new file mode 100644 index 00000000..ccb99f92 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isUndefined.html @@ -0,0 +1,44 @@ +isUndefined | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function isUndefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns obj is undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isUuid.html b/packages/tempo/public/v4/api/library/functions/common.index.isUuid.html new file mode 100644 index 00000000..f028b88e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isUuid.html @@ -0,0 +1,46 @@ +isUuid | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function isUuid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type guard to check if a value is a valid UUID string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isValidDate.html b/packages/tempo/public/v4/api/library/functions/common.index.isValidDate.html new file mode 100644 index 00000000..d9dfa594 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isValidDate.html @@ -0,0 +1,55 @@ +isValidDate | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function isValidDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Validates whether a given year, 1-indexed month, and day constitute a valid calendar date in the Gregorian calendar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • year: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full calendar year (e.g. 2026)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • month: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The 1-indexed month number (1..12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • day: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The 1-indexed day of the month (1..31)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  true if the year, month, and day represent a valid date, otherwise false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isWhitespace.html b/packages/tempo/public/v4/api/library/functions/common.index.isWhitespace.html new file mode 100644 index 00000000..8c944634 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isWhitespace.html @@ -0,0 +1,46 @@ +isWhitespace | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function isWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type guard to check if a value consists entirely of whitespace characters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns obj is string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTime.html b/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTime.html new file mode 100644 index 00000000..8d7c3672 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTime.html @@ -0,0 +1,44 @@ +isZonedDateTime | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function isZonedDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns obj is ZonedDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTimeLike.html b/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTimeLike.html new file mode 100644 index 00000000..aa51a77e --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isZonedDateTimeLike.html @@ -0,0 +1,44 @@ +isZonedDateTimeLike | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function isZonedDateTimeLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns obj is ZonedDateTimeLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.isolateBidi.html b/packages/tempo/public/v4/api/library/functions/common.index.isolateBidi.html new file mode 100644 index 00000000..e28f0150 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.isolateBidi.html @@ -0,0 +1,47 @@ +isolateBidi | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function isolateBidi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Wraps text in Unicode Bidirectional Isolates (\u2067 RLI ... \u2069 PDI) if direction is 'rtl'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • text: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionaldirection: "ltr" | "rtl"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.lazyMethod.html b/packages/tempo/public/v4/api/library/functions/common.index.lazyMethod.html new file mode 100644 index 00000000..9bddfe34 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.lazyMethod.html @@ -0,0 +1,65 @@ +lazyMethod | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function lazyMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines a lazy method on a prototype that reifies (shadows) itself upon first access. +This allows heavy logic to be deferred while maintaining a clean, synchronous public API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The prototype or object to define the method on

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • key: PropertyKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The method name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • factory: (this: T) => Function +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A function returning the actual method implementation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lazyMethod(MyClass.prototype, 'heavy', () => function() { return 42; });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.localizeDigits.html b/packages/tempo/public/v4/api/library/functions/common.index.localizeDigits.html new file mode 100644 index 00000000..6970f386 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.localizeDigits.html @@ -0,0 +1,48 @@ +localizeDigits | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function localizeDigits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Transliterates ASCII digits (0-9) within a string or number into the target numbering system (e.g. 'arab', 'deva'). +Returns the original string if the numbering system is 'latn' or unsupported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • value: string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • numberingSystem: string = 'latn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.looseIndex.html b/packages/tempo/public/v4/api/library/functions/common.index.looseIndex.html new file mode 100644 index 00000000..cec1a7c3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.looseIndex.html @@ -0,0 +1,125 @@ +looseIndex | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function looseIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                helper to define objects with fixed literal properties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +and a loose index signature for further extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • K extends PropertyKey = string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • V = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns <const T extends object>(obj: T | (() => T)) => Extend<T, K, V>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const obj = looseIndex<string,string>()({ foo: 'bar', bar: 'foo' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type obj = typeof obj
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                helper to define objects with fixed literal properties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +and a loose index signature for further extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • const T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: T | (() => T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Extend<T, string, any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const obj = looseIndex<string,string>()({ foo: 'bar', bar: 'foo' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type obj = typeof obj
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringString +stringSymbol +symbolRegExp +symbolString +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringString: <const T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: T | (() => T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Extend<T, string, string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loose object with string keys and string values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringSymbol: <const T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: T | (() => T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Extend<T, string, symbol>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loose object with symbols values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              symbolRegExp: <const T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: T | (() => T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Extend<T, symbol, RegExp>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loose object with symbol keys and RegExp values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              symbolString: <const T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: T | (() => T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Extend<T, symbol, string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loose object with symbol keys and string values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.makeTemplate.html b/packages/tempo/public/v4/api/library/functions/common.index.makeTemplate.html new file mode 100644 index 00000000..3864c5dd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.makeTemplate.html @@ -0,0 +1,59 @@ +makeTemplate | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function makeTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interpolates an object's values into a Template Literal string containing ${key} placeholders.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • templateString: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The string containing ${key} placeholders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns (templateData: any) => string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A function that takes a data object and returns the interpolated string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WARNING: Should not be used with untrusted templateString inputs if any form of evaluation is expected. +This implementation only supports simple ${key} substitutions from templateData.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const greet = makeTemplate('Hello ${name}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  greet({ name: 'World' }); // 'Hello World'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.markConfig.html b/packages/tempo/public/v4/api/library/functions/common.index.markConfig.html new file mode 100644 index 00000000..d04cd0fa --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.markConfig.html @@ -0,0 +1,60 @@ +markConfig | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function markConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Identifies and marks an object as a logging configuration object using a global symbol. +This allows the library to securely differentiate configs from regular objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The configuration object to mark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The marked object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const cfg = markConfig({ level: 'debug' });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.markExtensible.html b/packages/tempo/public/v4/api/library/functions/common.index.markExtensible.html new file mode 100644 index 00000000..3a1b0063 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.markExtensible.html @@ -0,0 +1,59 @@ +markExtensible | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function markExtensible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Marks an object as explicitly extensible using a global symbol to exempt it from recursive deep-freezing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The object to mark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The marked object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const registry = markExtensible([]);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.memoizeFunction.html b/packages/tempo/public/v4/api/library/functions/common.index.memoizeFunction.html new file mode 100644 index 00000000..d9b4cc8c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.memoizeFunction.html @@ -0,0 +1,59 @@ +memoizeFunction | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function memoizeFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Memoizes a function, caching its return values based on serialized arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • F extends (...args: any[]) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fn: F +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The function to memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns F

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A memoized version of the function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const expensive = memoizeFunction((a, b) => a * b);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.memoizeMethod.html b/packages/tempo/public/v4/api/library/functions/common.index.memoizeMethod.html new file mode 100644 index 00000000..5e721b45 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.memoizeMethod.html @@ -0,0 +1,64 @@ +memoizeMethod | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function memoizeMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines a PropertyDescriptor for an object's memoized method. +Caches the results of method calls on a per-instance basis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • name: PropertyKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fn: (this: Context, ...args: any[]) => T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The method implementation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns PropertyDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A PropertyDescriptor containing the memoization logic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Object.defineProperty(target, 'calc', memoizeMethod('calc', () => 42));
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.normaliseFractionalDurations.html b/packages/tempo/public/v4/api/library/functions/common.index.normaliseFractionalDurations.html new file mode 100644 index 00000000..002e2ee0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.normaliseFractionalDurations.html @@ -0,0 +1,52 @@ +normaliseFractionalDurations | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function normaliseFractionalDurations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Normalizes fractional duration values downwards to smaller units. +Temporal rejects fractional Duration values (e.g., { seconds: 0.1 }), +so this function converts them (e.g., to { milliseconds: 100 }). +Mutates the provided duration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • payload: Record<string, any> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The record object containing duration properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Record<string, any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The mutated duration record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.normalizeUtcOffset.html b/packages/tempo/public/v4/api/library/functions/common.index.normalizeUtcOffset.html new file mode 100644 index 00000000..f8fbf4cd --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.normalizeUtcOffset.html @@ -0,0 +1,51 @@ +normalizeUtcOffset | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function normalizeUtcOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Converts informal UTC offset strings into the ±HH:MM format required by Temporal. +Accepts forms like 'UTC+8', 'UTC-9', 'UTC+08:00', 'UTC-05:30'. +Returns the input unchanged if it does not match the UTC± pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • zone: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The informal offset string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The normalized offset string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.nullishToEmpty.html b/packages/tempo/public/v4/api/library/functions/common.index.nullishToEmpty.html new file mode 100644 index 00000000..03d5e0b9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.nullishToEmpty.html @@ -0,0 +1,59 @@ +nullishToEmpty | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function nullishToEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns the value if defined, otherwise an empty string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The value to check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns "" | NonNullable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The value or an empty string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const val = nullishToEmpty(undefined); // ''
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.nullishToValue.html b/packages/tempo/public/v4/api/library/functions/common.index.nullishToValue.html new file mode 100644 index 00000000..3c0d2a77 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.nullishToValue.html @@ -0,0 +1,63 @@ +nullishToValue | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function nullishToValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns the value if defined, otherwise the fallback value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The value to check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • value: R +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The fallback value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns R | NonNullable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The original value or the fallback value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const val = nullishToValue(null, 'default'); // 'default'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.nullishToZero.html b/packages/tempo/public/v4/api/library/functions/common.index.nullishToZero.html new file mode 100644 index 00000000..d50c686c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.nullishToZero.html @@ -0,0 +1,59 @@ +nullishToZero | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function nullishToZero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the value if defined, otherwise 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns 0 | NonNullable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The value or 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const val = nullishToZero(null); // 0
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.objectify.html b/packages/tempo/public/v4/api/library/functions/common.index.objectify.html new file mode 100644 index 00000000..1c38f942 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.objectify.html @@ -0,0 +1,80 @@ +objectify | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function objectify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Rebuilds an Object from its stringify'd string representation. +Handles custom single key:value type definitions automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • str: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • OptionaloptionsOrSentinel: Function | ObjectifyOptions +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional configuration options or a sentinel function for undefined values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The deserialized object or original string if parsing fails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TRUST BOUNDARY WARNING +objectify() is an ACTIVE deserializer designed for internal state persistence +(e.g. WebStorage, internal caching, trusted worker IPC).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Do NOT use objectify() on untrusted or external strings (e.g. HTTP request bodies, +unverified tokens, public webhooks):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Insecure Deserialization (CWE-502): Can instantiate registered classes via Reflect.construct.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Type Confusion: May produce BigInt, Date, or Map where plain JSON values are expected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Global Symbol Pollution: Encoded symbols register into Symbol.for().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When dealing with semi-trusted strings, configure ObjectifyOptions: +set allowClasses: false (or specify an allowedClasses allowlist), maxDepth, +or enforce tamper detection with requireSigned: true. +For cryptographically authenticated payloads across untrusted network boundaries, use signJWS() / verifyJWS(). +For completely untrusted external input, use native JSON.parse() with schema validation instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const obj = objectify('{"$BigInt":"123"}'); // 123n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const safe = objectify(input, { allowClasses: false, maxDepth: 10 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const trusted = objectify(input, { requireSigned: true, secret: 'my-secret' });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.omit.html b/packages/tempo/public/v4/api/library/functions/common.index.omit.html new file mode 100644 index 00000000..730aac83 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.omit.html @@ -0,0 +1,89 @@ +omit | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Mutates an object or array by removing specified properties or indices. +If no keys are provided, it removes all properties (like a clear operation).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The object or array to mutate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The mutated object reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        omit({ a: 1, b: 2 }, 'a'); // { b: 2 }
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Mutates an object or array by removing specified properties or indices. +If no keys are provided, it removes all properties (like a clear operation).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The object or array to mutate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ...keys: PropertyKey[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The keys or indices to omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The mutated object reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        omit({ a: 1, b: 2 }, 'a'); // { b: 2 }
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.onAbort.html b/packages/tempo/public/v4/api/library/functions/common.index.onAbort.html new file mode 100644 index 00000000..ce120e7f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.onAbort.html @@ -0,0 +1,57 @@ +onAbort | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function onAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Safely binds an abort callback to an AbortSignal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • If the signal is already aborted, invokes the callback immediately.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • If a signal is provided, attaches an event listener with { once: true }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns a cleanup unbind function to safely detach the listener early (preventing memory leaks).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • signal: AbortSignal | undefined +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The AbortSignal to observe (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • callback: () => void +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The callback to execute upon abort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns () => void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A teardown function that detaches the abort listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ownEntries.html b/packages/tempo/public/v4/api/library/functions/common.index.ownEntries.html new file mode 100644 index 00000000..7d8fe33c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ownEntries.html @@ -0,0 +1,63 @@ +ownEntries | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function ownEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns an array of all enumerable [key, value] entries for an object, +including properties inherited from the prototype chain if all is true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • json: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The object to extract entries from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • all: boolean = false +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Whether to include properties from the prototype chain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns EntryOf<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            An array of [key, value] tuples

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const entries = ownEntries({ a: 1, b: 2 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ownKeys.html b/packages/tempo/public/v4/api/library/functions/common.index.ownKeys.html new file mode 100644 index 00000000..f832aed8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ownKeys.html @@ -0,0 +1,62 @@ +ownKeys | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function ownKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns an array of all enumerable property keys for an object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • json: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The object to extract keys from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • all: boolean = false +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to include keys from the prototype chain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns KeyOf<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An array of property keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const keys = ownKeys({ a: 1, b: 2 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.ownValues.html b/packages/tempo/public/v4/api/library/functions/common.index.ownValues.html new file mode 100644 index 00000000..7d8f59ea --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.ownValues.html @@ -0,0 +1,62 @@ +ownValues | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function ownValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns an array of all enumerable property values for an object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • json: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The object to extract values from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • all: boolean = false +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Whether to include values from the prototype chain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns ValueOf<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                An array of property values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const values = ownValues({ a: 1, b: 2 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.pad.html b/packages/tempo/public/v4/api/library/functions/common.index.pad.html new file mode 100644 index 00000000..a5ac4955 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.pad.html @@ -0,0 +1,61 @@ +pad | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function pad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pads a string or number with a leading fill character to reach a specified length.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • nbr: string | number | bigint = 0 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The input value to pad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • len: number = 2 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The target length (default: 2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalfill: string | number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The fill character (default: space for strings, zero for numbers)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The left-padded string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pad(5, 2); // '05'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.padString.html b/packages/tempo/public/v4/api/library/functions/common.index.padString.html new file mode 100644 index 00000000..df44e286 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.padString.html @@ -0,0 +1,53 @@ +padString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function padString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pads a numeric or string value with non-breaking spaces. +Useful for right-aligning displays in monospace environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • str: string | number | bigint +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to pad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pad: number = 6 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The target length (default: 6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The right-aligned padded string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.padTo.html b/packages/tempo/public/v4/api/library/functions/common.index.padTo.html new file mode 100644 index 00000000..b74d3049 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.padTo.html @@ -0,0 +1,61 @@ +padTo | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function padTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pads a string at the end so that its length is a multiple of the specified block size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • str: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The input string to pad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • multiple: number = 4 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The block size or multiple to align to (default: 4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fill: string | number = '=' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fill character or string to append (default: '=')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The padded string aligned to the multiple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      padTo('abc', 4, '='); // 'abc='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      padTo('abcd', 4, '='); // 'abcd'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.parseCron.html b/packages/tempo/public/v4/api/library/functions/common.index.parseCron.html new file mode 100644 index 00000000..44111c69 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.parseCron.html @@ -0,0 +1,53 @@ +parseCron | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function parseCron

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parses a standard 5-field cron pattern into a structured CronSchedule object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • pattern: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The cron pattern string (e.g., "0 12 * * 1-5")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns CronSchedule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A CronSchedule object with parsed fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error if the pattern is invalid or malformed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.parseJSONC.html b/packages/tempo/public/v4/api/library/functions/common.index.parseJSONC.html new file mode 100644 index 00000000..3b5b3bd4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.parseJSONC.html @@ -0,0 +1,117 @@ +parseJSONC | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function parseJSONC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Zero-dependency parser for JSON and JSONC (JSON with comments & trailing commas). +Supports standard reviver callbacks or options objects for safe parsing with fallbacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • text: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The JSON or JSONC string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • options: { fallback?: undefined; reviver?: JSONCReviver; safe: true }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The parsed JavaScript object or fallback value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const config = parseJSONC<{ mode: string }>('{\n  // Mode setting\n  "mode": "fallback",\n}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const safe = parseJSONC(malformedText, { fallback: { mode: 'default' } });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Zero-dependency parser for JSON and JSONC (JSON with comments & trailing commas). +Supports standard reviver callbacks or options objects for safe parsing with fallbacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • text: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The JSON or JSONC string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • options: { fallback: T; reviver?: JSONCReviver; safe?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The parsed JavaScript object or fallback value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const config = parseJSONC<{ mode: string }>('{\n  // Mode setting\n  "mode": "fallback",\n}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const safe = parseJSONC(malformedText, { fallback: { mode: 'default' } });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Zero-dependency parser for JSON and JSONC (JSON with comments & trailing commas). +Supports standard reviver callbacks or options objects for safe parsing with fallbacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • text: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The JSON or JSONC string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • OptionaloptionsOrReviver: JSONCReviver | JSONCOptions<T> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional reviver function or JSONCOptions object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The parsed JavaScript object or fallback value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const config = parseJSONC<{ mode: string }>('{\n  // Mode setting\n  "mode": "fallback",\n}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const safe = parseJSONC(malformedText, { fallback: { mode: 'default' } });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.parseJWT.html b/packages/tempo/public/v4/api/library/functions/common.index.parseJWT.html new file mode 100644 index 00000000..7faab55c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.parseJWT.html @@ -0,0 +1,63 @@ +parseJWT | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function parseJWT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parses and decodes all three segments of a JSON Web Token (Header, Payload, Signature) without signature verification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Header = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Payload = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jwt: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The JWT string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionaloptions: ParseJWTOptions +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional parsing behavior (e.g. strict: true to throw on failure)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns JWTComponents<Header, Payload> | null

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Object containing decoded header, payload, raw signature buffer, and raw segments, or null if invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const token = parseJWT`<MyHeader, MyPayload>`(jwtString);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const payload = token?.payload;
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.parseLogLevel.html b/packages/tempo/public/v4/api/library/functions/common.index.parseLogLevel.html new file mode 100644 index 00000000..df2ac3f1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.parseLogLevel.html @@ -0,0 +1,58 @@ +parseLogLevel | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function parseLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parses a debug level (numeric or string) into a strongly-typed LOG enumeration value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionallevel: DebugLevel +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The log level to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • fallback: 0 | 1 | 2 | 3 | 4 | 5 = LOG.Info +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The default log level to return if parsing fails (default: Info)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns 0 | 1 | 2 | 3 | 4 | 5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The resolved LOG enumeration value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseLogLevel('debug'); // LOG.Debug
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.parseRRule.html b/packages/tempo/public/v4/api/library/functions/common.index.parseRRule.html new file mode 100644 index 00000000..389a3340 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.parseRRule.html @@ -0,0 +1,49 @@ +parseRRule | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function parseRRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parses an RFC 5545 RRULE string into a structured ParsedRRule object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • rrule: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The raw RFC 5545 RRULE string to parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns ParsedRRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Structured representation of the recurrence parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.pick.html b/packages/tempo/public/v4/api/library/functions/common.index.pick.html new file mode 100644 index 00000000..33ca9772 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.pick.html @@ -0,0 +1,63 @@ +pick | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function pick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Creates a new object composed of the picked object properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • K extends string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The source object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ...keys: (K | K[])[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The property names to pick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Pick<T, K>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A new object containing only the picked properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const subset = pick({ a: 1, b: 2, c: 3 }, 'a', 'c'); // { a: 1, c: 3 }
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.pluck.html b/packages/tempo/public/v4/api/library/functions/common.index.pluck.html new file mode 100644 index 00000000..7df89139 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.pluck.html @@ -0,0 +1,63 @@ +pluck | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extracts a specified named key from an array of objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • K extends string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • objs: T[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The array of objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • key: K +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The property key to extract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T[K][]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An array of the extracted property values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const ids = pluck([{ id: 1 }, { id: 2 }], 'id'); // [1, 2]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.plural.html b/packages/tempo/public/v4/api/library/functions/common.index.plural.html new file mode 100644 index 00000000..d4271a3a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.plural.html @@ -0,0 +1,61 @@ +plural | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function plural

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Applies a plural suffix to a word if the quantity is not exactly 1 or -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • val: string | number | Record<string, string> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The numerical quantity or an object containing values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • word: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The singular word

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • plural: string = ... +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The explicitly provided plural form (defaults to word + 's')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string | ((num: string, word: string) => string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The appropriate singular or plural string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plural(2, 'apple'); // 'apples'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.protoType.html b/packages/tempo/public/v4/api/library/functions/common.index.protoType.html new file mode 100644 index 00000000..f0970f95 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.protoType.html @@ -0,0 +1,53 @@ +protoType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function protoType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the primitive type reported by Object.prototype.toString / Symbol.toStringTag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Performance: Short-circuits all primitives via typeof in ~0.5ns with zero allocations. +Safely wrapped in a try-catch to guard against:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. Throwing dynamic getters on Symbol.toStringTag (e.g. { get [Symbol.toStringTag]() { throw ... } })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          2. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        2. Revoked Proxies (Proxy.revocable()) which throw TypeError on property/tag access
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          3. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        3. Cross-origin / cross-realm security exceptions in browser environments (DOMException)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          4. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalobj: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.proxify.html b/packages/tempo/public/v4/api/library/functions/common.index.proxify.html new file mode 100644 index 00000000..18625bc1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.proxify.html @@ -0,0 +1,139 @@ +proxify | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function proxify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Creates a Stealth Proxy pattern to allow for on-demand lazy property discovery and registration. +Provides deep-freezing and bounding capabilities depending on options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The object to proxify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalfrozen: true +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether the proxy should throw on mutation (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionallock: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to deep-freeze the underlying target (default: frozen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalskip: WeakSet<object> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A WeakSet of objects to skip during deep-freeze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Readonly<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The proxified object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const p = proxify({ a: 1 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Creates a Stealth Proxy pattern to allow for on-demand lazy property discovery and registration. +Provides deep-freezing and bounding capabilities depending on options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The object to proxify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • frozen: false +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether the proxy should throw on mutation (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionallock: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to deep-freeze the underlying target (default: frozen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalskip: WeakSet<object> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A WeakSet of objects to skip during deep-freeze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The proxified object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const p = proxify({ a: 1 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Creates a Stealth Proxy pattern to allow for on-demand lazy property discovery and registration. +Provides deep-freezing and bounding capabilities depending on options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The object to proxify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalfrozen: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether the proxy should throw on mutation (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionallock: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to deep-freeze the underlying target (default: frozen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalskip: WeakSet<object> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A WeakSet of objects to skip during deep-freeze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | Readonly<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The proxified object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const p = proxify({ a: 1 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.purge.html b/packages/tempo/public/v4/api/library/functions/common.index.purge.html new file mode 100644 index 00000000..942b5245 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.purge.html @@ -0,0 +1,59 @@ +purge | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function purge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Removes all own properties from an object or array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The object or array to purge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The mutated object reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            purge({ a: 1 }); // {}
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.raise.html b/packages/tempo/public/v4/api/library/functions/common.index.raise.html new file mode 100644 index 00000000..30753ff5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.raise.html @@ -0,0 +1,58 @@ +raise | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function raise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Global Error Boundary Utility. +Decouples the decision to throw an error from the act of logging it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • err: string | Error +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The Error object or error string to raise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • context: BoundaryContext = {} +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional boundary context configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              raise('Invalid input', { catch: true, logger: myLogger });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.randomKey.html b/packages/tempo/public/v4/api/library/functions/common.index.randomKey.html new file mode 100644 index 00000000..ae6d0478 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.randomKey.html @@ -0,0 +1,49 @@ +randomKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function randomKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Generates a random, short UUID key based on standard Web Crypto API UUIDs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A randomly generated short string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const key = randomKey(); // 'e8b7a421'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.randomString.html b/packages/tempo/public/v4/api/library/functions/common.index.randomString.html new file mode 100644 index 00000000..1dab9a4a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.randomString.html @@ -0,0 +1,55 @@ +randomString | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function randomString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generates a random alphanumeric string of a specified length.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • len: number = 36 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The desired length of the string (default: 36)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A random string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const str = randomString(10);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.rawJSON.html b/packages/tempo/public/v4/api/library/functions/common.index.rawJSON.html new file mode 100644 index 00000000..fb912dc2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.rawJSON.html @@ -0,0 +1,56 @@ +rawJSON | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function rawJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a raw JSON representation that is embedded verbatim (unquoted) during serialization. +Leverages native JSON.rawJSON (ES2024 / Node 21+) when available, with a fallback for older environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • text: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The raw JSON string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The raw JSON object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const raw = rawJSON('12345678901234567890');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.registerSerializable.html b/packages/tempo/public/v4/api/library/functions/common.index.registerSerializable.html new file mode 100644 index 00000000..7b6d4e58 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.registerSerializable.html @@ -0,0 +1,57 @@ +registerSerializable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function registerSerializable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Registers a Class for custom serialization and deserialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The string identifier for the class (automatically prefixed with '$' if missing)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cls: Function +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The class constructor to register

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      registerSerializable('MyClass', MyClass);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.registerType.html b/packages/tempo/public/v4/api/library/functions/common.index.registerType.html new file mode 100644 index 00000000..2059548d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.registerType.html @@ -0,0 +1,60 @@ +registerType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function registerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Registers a class constructor with the runtime type system.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cls: Constructor +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The class constructor to register

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionaltype: Type +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional explicit type name to register the class under

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Custom types must augment TypeValueMap to be strictly recognized by the TypeScript compiler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerType(MyCustomClass, 'MyCustomType');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.reset.html b/packages/tempo/public/v4/api/library/functions/common.index.reset.html new file mode 100644 index 00000000..634c6180 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.reset.html @@ -0,0 +1,146 @@ +reset | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Resets an object by purging all its existing own properties and replacing them +with the properties from another object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • orig: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The original object to reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalobj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The object containing the new properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              at?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              concat?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              copyWithin?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entries?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              every?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fill?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              find?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findIndex?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findLast?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findLastIndex?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flat?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flatMap?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forEach?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includes?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              indexOf?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              join?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keys?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lastIndexOf?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              length?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              map?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pop?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              push?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reduce?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reduceRight?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverse?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              shift?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              slice?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              some?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sort?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              splice?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toLocaleString?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | (() => string)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          locales: string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: NumberFormatOptions & DateTimeFormatOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toReversed?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSorted?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSpliced?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toString?: (() => string)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | (() => string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unshift?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              values?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              with?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: number]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The mutated original object reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: number]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalat?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalconcat?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalcopyWithin?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalentries?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalevery?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalfill?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalfilter?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalfind?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalfindIndex?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalfindLast?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalfindLastIndex?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalflat?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalflatMap?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalforEach?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalincludes?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalindexOf?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionaljoin?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalkeys?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionallastIndexOf?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionallength?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Gets or sets the length of the array. This is a number one higher than the highest index in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalmap?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalpop?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalpush?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalreduce?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionalreduceRight?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalreverse?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalshift?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalslice?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalsome?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalsort?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalsplice?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionaltoLocaleString?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (() => string)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        locales: string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: NumberFormatOptions & DateTimeFormatOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionaltoReversed?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionaltoSorted?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionaltoSpliced?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptionaltoString?: (() => string) | (() => string)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalunshift?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalvalues?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optionalwith?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reset(target, { newProp: 1 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resetRegistry.html b/packages/tempo/public/v4/api/library/functions/common.index.resetRegistry.html new file mode 100644 index 00000000..c2c3becc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resetRegistry.html @@ -0,0 +1,43 @@ +resetRegistry | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function resetRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Clears the global type registry. +Primarily used for test isolation and ensuring deterministic behavior between test suites.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveDayOfYear.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveDayOfYear.html new file mode 100644 index 00000000..dbcbefb2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveDayOfYear.html @@ -0,0 +1,48 @@ +resolveDayOfYear | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function resolveDayOfYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Resolves 1-indexed day-of-year (1..366) to month (1..12) and day (1..31) using pure integer arithmetic. +Returns undefined for a day outside the given year, including day 366 in a non-leap year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • year: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • dayOfYear: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns { day: number; month: number } | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveFractionalSeconds.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveFractionalSeconds.html new file mode 100644 index 00000000..52766042 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveFractionalSeconds.html @@ -0,0 +1,49 @@ +resolveFractionalSeconds | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function resolveFractionalSeconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parses up to 9 digits of sub-second fractions into millisecond, microsecond, and nanosecond numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Optionalraw: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The raw fractional seconds string (e.g. "123", "123456789")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns SubsecondParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Object with millisecond, microsecond, and nanosecond components

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveGeoCoordinates.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveGeoCoordinates.html new file mode 100644 index 00000000..e45a48b4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveGeoCoordinates.html @@ -0,0 +1,55 @@ +resolveGeoCoordinates | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function resolveGeoCoordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Universal coordinate resolver. +Extracts latitude and longitude from input object (instance, config, options), +or triggers geoLookup() if coordinates are omitted. +Supports opt-in reverse lookup ({ reverse: true }). +Enforces 3-decimal rounding and returns rich metadata when resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalinput: CoordinateInput +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional object containing coordinate properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • opts: Record<string, any> = {} +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fallback geoLookup options if coordinates are missing from input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<ResolvedCoordinates | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveIsoCalendarYear.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveIsoCalendarYear.html new file mode 100644 index 00000000..cb4dc431 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveIsoCalendarYear.html @@ -0,0 +1,61 @@ +resolveIsoCalendarYear | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function resolveIsoCalendarYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolves the calendar year corresponding to an ISO week-numbering year +for a specified month and day, testing adjacent calendar-year candidates. +Uses expectedDayOfWeek (1=Monday..7=Sunday) to disambiguate when available, +and rejects ambiguous dates that match multiple candidate years without weekday disambiguation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • targetIsoYear: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ISO week-numbering year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • month: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The 1-indexed calendar month (1..12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • day: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The 1-indexed calendar day (1..31)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • OptionalexpectedDayOfWeek: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional 1-indexed ISO weekday (1=Monday..7=Sunday)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns number | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The resolved calendar year, or undefined if invalid or ambiguous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveLocale.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveLocale.html new file mode 100644 index 00000000..99929597 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveLocale.html @@ -0,0 +1,56 @@ +resolveLocale | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function resolveLocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Resolves a locale or list of locales into a standardized configuration format: +a single string for one valid locale, a string array for multiple, or undefined if none.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optionallocales: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Single or multiple locale identifiers or Intl.Locale instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string | readonly string[] | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A single canonical string, an array of strings, or undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolveLocale('en_US'); // 'en-US'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolveLocale(['en_US', 'fr_FR']); // ['en-US', 'fr-FR']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolveLocale(['invalid']); // undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.resolveTwoDigitYear.html b/packages/tempo/public/v4/api/library/functions/common.index.resolveTwoDigitYear.html new file mode 100644 index 00000000..32bd69c7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.resolveTwoDigitYear.html @@ -0,0 +1,55 @@ +resolveTwoDigitYear | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function resolveTwoDigitYear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Resolves a two-digit year (0–99) into a four-digit year using a 100-year sliding window (century pivot).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • yy: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The two-digit year (0–99). If >= 100, negative, or not finite, returned as-is.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • pivot: number = 75 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Cutoff offset in years relative to the reference date (default: 75, covering [reference - 75, reference + 24]).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalreference: number | PlainDate | ZonedDateTime +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Reference date, year, or ZonedDateTime to pivot against (default: current system date).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The resolved 4-digit calendar year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.reveal.html b/packages/tempo/public/v4/api/library/functions/common.index.reveal.html new file mode 100644 index 00000000..4aa5d479 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.reveal.html @@ -0,0 +1,56 @@ +reveal | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function reveal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Reconstructs a string from an array of char codes. +Useful for hiding strings from minifiers and reverse-engineers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • codes: number[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The array of character codes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The reconstructed string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reveal([104, 105]); // 'hi'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.reverseGeocode.html b/packages/tempo/public/v4/api/library/functions/common.index.reverseGeocode.html new file mode 100644 index 00000000..0693e6b3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.reverseGeocode.html @@ -0,0 +1,52 @@ +reverseGeocode | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function reverseGeocode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reverse geocodes coordinates to address or location metadata using the active or provided GeoProvider. +Employs 2-decimal spatial deduplication with BoundedCache (24h TTL).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • coords: CoordinateInput +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Coordinate input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionalopts: Record<string, any> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Options including optional provider override and { refresh: true }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<GeoConfig | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.revocable.html b/packages/tempo/public/v4/api/library/functions/common.index.revocable.html new file mode 100644 index 00000000..d6f386a0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.revocable.html @@ -0,0 +1,56 @@ +revocable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function revocable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Creates a proxy that can be permanently revoked on demand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The object to wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • options: ProxyOptions = {} +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Proxy behavior configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns { proxy: T; revoke: () => void }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An object containing the proxy and a function that revokes it

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.secure.html b/packages/tempo/public/v4/api/library/functions/common.index.secure.html new file mode 100644 index 00000000..9e2d7dd3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.secure.html @@ -0,0 +1,63 @@ +secure | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deep-freezes an object and wraps it in a loudly-throwing read-only Proxy. +Provides the highest level of noisy immutability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • const T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The object to secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skip: WeakSet<object> = ... +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A WeakSet of objects to skip during deep-freeze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Secure<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The securely frozen Proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const safe = secure({ apiKey: '123' });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.secureRef.html b/packages/tempo/public/v4/api/library/functions/common.index.secureRef.html new file mode 100644 index 00000000..66059fa1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.secureRef.html @@ -0,0 +1,60 @@ +secureRef | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function secureRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Wraps an object in a protective Proxy that allows extension (adding new keys) +but prevents modification or deletion of existing keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • target: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The object to secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The append-only secured Proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const ref = secureRef({ initial: 1 });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.selStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.selStorage.html new file mode 100644 index 00000000..ee72d2e0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.selStorage.html @@ -0,0 +1,49 @@ +selStorage | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function selStorage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Selects the active browser storage mechanism (localStorage or sessionStorage).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • store: "local" | "session" = 'local' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The storage type to use (default: 'local')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Storage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The selected Storage object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.setAccessors.html b/packages/tempo/public/v4/api/library/functions/common.index.setAccessors.html new file mode 100644 index 00000000..75ed7db3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.setAccessors.html @@ -0,0 +1,55 @@ +setAccessors | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function setAccessors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Retrieves a distinct array of 'setter' names from an object and its prototype chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • obj: any = {} +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The object to inspect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      An array of property keys that have setter functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const setters = setAccessors(myInstance);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.setGeoProvider.html b/packages/tempo/public/v4/api/library/functions/common.index.setGeoProvider.html new file mode 100644 index 00000000..49cd1a47 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.setGeoProvider.html @@ -0,0 +1,48 @@ +setGeoProvider | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function setGeoProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sets the active custom geolocation provider gateway.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalprovider: GeoProvider +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GeoProvider implementation or undefined to restore default provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.setStorage.html b/packages/tempo/public/v4/api/library/functions/common.index.setStorage.html new file mode 100644 index 00000000..0a559fd4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.setStorage.html @@ -0,0 +1,93 @@ +setStorage | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function setStorage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets or deletes a value in the active storage mechanism across any runtime environment. +Automatically serializes objects for safe storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • key: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The storage key to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalval: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The value to store (if undefined, the key is deleted)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('user', { name: 'Alice' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('user', undefined); // deletes 'user'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('coords', { lat: 10, lng: 20 }, { ttl: 86400000 }); // expires after 24h
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets or deletes a value in the active storage mechanism across any runtime environment. +Automatically serializes objects for safe storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • key: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The storage key to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • val: T | undefined +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The value to store (if undefined, the key is deleted)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • options: ServerStorageOptions +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional cache control options (server context only)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('user', { name: 'Alice' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('user', undefined); // deletes 'user'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setStorage('coords', { lat: 10, lng: 20 }, { ttl: 86400000 }); // expires after 24h
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sign.html b/packages/tempo/public/v4/api/library/functions/common.index.sign.html new file mode 100644 index 00000000..ab4ee13b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sign.html @@ -0,0 +1,49 @@ +sign | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Signs arbitrary data using RSASSA-PKCS1-v1_5 and a module-scoped ephemeral asymmetric keypair.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • doc: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The data to sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<Uint8Array<ArrayBuffer>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A promise resolving to the Uint8Array signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.signData.html b/packages/tempo/public/v4/api/library/functions/common.index.signData.html new file mode 100644 index 00000000..f60be89d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.signData.html @@ -0,0 +1,55 @@ +signData | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function signData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Cryptographically signs raw data using the provided CryptoKey.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • data: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string or binary data to sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • privateKey: CryptoKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The private CryptoKey with 'sign' usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alg: AlgorithmIdentifier = keys.SignKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The signature algorithm identifier (default: keys.SignKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<Uint8Array<ArrayBufferLike>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A promise resolving to the signature Uint8Array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.signHmac.html b/packages/tempo/public/v4/api/library/functions/common.index.signHmac.html new file mode 100644 index 00000000..064c8fa8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.signHmac.html @@ -0,0 +1,55 @@ +signHmac | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function signHmac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Computes an HMAC signature as a raw binary buffer for the provided data and secret.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • data: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The string or binary data to sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • secret: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The secret key as a string or binary buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alg: string = 'SHA-256' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The hash algorithm to use (default: 'SHA-256')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Promise<Uint8Array<ArrayBufferLike>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A promise resolving to the HMAC signature Uint8Array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.signJWS.html b/packages/tempo/public/v4/api/library/functions/common.index.signJWS.html new file mode 100644 index 00000000..a503211b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.signJWS.html @@ -0,0 +1,86 @@ +signJWS | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function signJWS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Natively signs a JSON Web Signature (JWS) payload. +Inspects headers.alg (default: { alg: 'RS256', typ: 'JWT' }) and supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Asymmetric RS256: via CryptoKey or PEM private key string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Symmetric HS256, HS384, HS512: via shared secret string or Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • payload: object +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The payload object to sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • keyOrSecret: string | CryptoKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The private CryptoKey, PEM private key string, or HMAC shared secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalheaders: JWSHeader<"RS256"> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional JWS headers (default: { alg: 'RS256', typ: 'JWT' })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A promise resolving to the signed JWS string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Natively signs a JSON Web Signature (JWS) payload. +Inspects headers.alg (default: { alg: 'RS256', typ: 'JWT' }) and supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Asymmetric RS256: via CryptoKey or PEM private key string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Symmetric HS256, HS384, HS512: via shared secret string or Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • payload: object +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The payload object to sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • keyOrSecret: string | Uint8Array<ArrayBufferLike> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The private CryptoKey, PEM private key string, or HMAC shared secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headers: JWSHMACHeader +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional JWS headers (default: { alg: 'RS256', typ: 'JWT' })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<string>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A promise resolving to the signed JWS string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.singular.html b/packages/tempo/public/v4/api/library/functions/common.index.singular.html new file mode 100644 index 00000000..6c8257a1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.singular.html @@ -0,0 +1,59 @@ +singular | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function singular

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strips a plural 's' suffix from a string if it ends with 's' and is longer than 3 characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • val: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The plural string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns SingularUnit<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The singular string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    singular('apples'); // 'apple'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sleep.html b/packages/tempo/public/v4/api/library/functions/common.index.sleep.html new file mode 100644 index 00000000..7a6bb8a3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sleep.html @@ -0,0 +1,59 @@ +sleep | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function sleep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Introduces a wait-timer that will reject with an Error on timeout. +Best used with Promise.race([myTask(), sleep()]).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • msg: string = 'sleep: timed out' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The string to display on a timeout (default: 'sleep: timed out')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • timeout: number = 2000 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number of milliseconds to sleep (default: 2000)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<Error>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Promise that rejects after the specified timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      await Promise.race([fetchData(), sleep('Fetch timeout', 5000)]);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sortBy.html b/packages/tempo/public/v4/api/library/functions/common.index.sortBy.html new file mode 100644 index 00000000..15405a5c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sortBy.html @@ -0,0 +1,59 @@ +sortBy | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function sortBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Creates a comparison function for sorting an array of objects by multiple keys.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ...keys: (PropertyKey | SortBy)[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The keys or sorting options to apply in priority order

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns (left: T, right: T) => -1 | 0 | 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A comparison function suitable for Array.prototype.sort()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const arr = [{ a: 1, b: 'z' }, { a: 1, b: 'a' }];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arr.sort(sortBy('a', { field: 'b', dir: 'desc' }));
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sortInsert.html b/packages/tempo/public/v4/api/library/functions/common.index.sortInsert.html new file mode 100644 index 00000000..2f53281a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sortInsert.html @@ -0,0 +1,67 @@ +sortInsert | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function sortInsert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Inserts a value into an array at its sorted position using binary search. +Supports both primitive values and objects (via a sorting key).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • K extends string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • arr: T[] = [] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The array to insert into (defaults to an empty array)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • val: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The value to insert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalkey: K +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The property key to sort by if inserting objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The mutated array containing the inserted value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sortInsert([1, 3], 2); // [1, 2, 3]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sortKey.html b/packages/tempo/public/v4/api/library/functions/common.index.sortKey.html new file mode 100644 index 00000000..8d96f2bf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sortKey.html @@ -0,0 +1,62 @@ +sortKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function sortKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sorts an array in place according to the specified keys or sorting options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • array: T[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The array to sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ...keys: (PropertyKey | SortBy)[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sorting criteria, applied in order of priority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns T[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The input array after sorting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const sorted = sortKey(users, 'lastName', 'firstName');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.split.html b/packages/tempo/public/v4/api/library/functions/common.index.split.html new file mode 100644 index 00000000..dce9a21b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.split.html @@ -0,0 +1,96 @@ +split | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function split

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Splits a number or string by a delimiter and parses the chunks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • nbr: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The value to split

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionalchr: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The delimiter character (default: '.')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionalzero: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to strip leading zeros during numeric conversion (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns number[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An array of parsed numeric or string chunks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              split('12.34'); // [12, 34]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Splits a number or string by a delimiter and parses the chunks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • nbr: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The value to split

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionalchr: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The delimiter character (default: '.')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionalzero: boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to strip leading zeros during numeric conversion (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns (string | number)[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An array of parsed numeric or string chunks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              split('12.34'); // [12, 34]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.sprintf.html b/packages/tempo/public/v4/api/library/functions/common.index.sprintf.html new file mode 100644 index 00000000..e4ddfbb5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.sprintf.html @@ -0,0 +1,81 @@ +sprintf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function sprintf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Formats a string using sprintf-style %s and %j parameter replacements. +Also supports positional ${digit} markers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • fmt: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The format string (or an object to stringify)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ...msg: any[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The arguments to inject into the format string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The formatted string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sprintf('Hello %s', 'World'); // 'Hello World'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Formats a string using sprintf-style %s and %j parameter replacements. +Also supports positional ${digit} markers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ...msg: any[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The arguments to inject into the format string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The formatted string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sprintf('Hello %s', 'World'); // 'Hello World'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.stashGeo.html b/packages/tempo/public/v4/api/library/functions/common.index.stashGeo.html new file mode 100644 index 00000000..eadd23fa --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.stashGeo.html @@ -0,0 +1,55 @@ +stashGeo | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function stashGeo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Explicitly stashes geolocation coordinates in storage with an optional TTL (default: 24 hours). +Supports optional tenant key or options object for multi-tenant isolation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • coords: GeoConfig +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geolocation coordinates and metadata to stash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ttl: number = DEFAULT_GEO_TTL +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time-to-live in milliseconds (default: 24 hours)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • OptionalkeyOrOpts: string | Record<string, any> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional tenant key or lookup options containing key/ip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.stringify.html b/packages/tempo/public/v4/api/library/functions/common.index.stringify.html new file mode 100644 index 00000000..e619b905 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.stringify.html @@ -0,0 +1,64 @@ +stringify | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Serializes objects for string-safe stashing in WebStorage, Cache, etc. +Uses compact tagged strings (~n, ~t, ~u, ~y) by default for primitive types, +or oneKey object envelopes when compact: false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The object to stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: StringifyOptions +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Optional serialization options (e.g. { signed: true, secret: 'key', compact: true })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The safely stringified representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(123n); // '"~n123"'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(new Date()); // '"~t1704067200000"'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(Symbol.for('app')); // '"~y@@(app)"'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(data, { signed: true, secret: 'my-secret' }); // '$sig:e8b7...:{"id":"~n123"}'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.stripJSONC.html b/packages/tempo/public/v4/api/library/functions/common.index.stripJSONC.html new file mode 100644 index 00000000..0d68e48d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.stripJSONC.html @@ -0,0 +1,56 @@ +stripJSONC | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function stripJSONC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Strips single-line (//) and multi-line (/* ... */) comments and trailing commas from a JSONC string. +Preserves URLs and slashes within quoted strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • text: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The JSONC formatted string to strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Cleaned JSON string ready for JSON.parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const cleanJson = stripJSONC('{\n  // comment\n  "key": "value",\n}');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.strlen.html b/packages/tempo/public/v4/api/library/functions/common.index.strlen.html new file mode 100644 index 00000000..98407900 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.strlen.html @@ -0,0 +1,51 @@ +strlen | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function strlen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Min extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Max extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • str: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • min: Min
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalmax: Max
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns StrLen<Min, Max>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.suffix.html b/packages/tempo/public/v4/api/library/functions/common.index.suffix.html new file mode 100644 index 00000000..ea81d933 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.suffix.html @@ -0,0 +1,55 @@ +suffix | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Appends an ordinal suffix (st, nd, rd, th) to a number.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • idx: number = 0 +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The number to format (defaults to 0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The number formatted as a string with its ordinal suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suffix(1); // '1st'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suffix(23); // '23rd'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.tap.html b/packages/tempo/public/v4/api/library/functions/common.index.tap.html new file mode 100644 index 00000000..cf5ec70a --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.tap.html @@ -0,0 +1,63 @@ +tap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function tap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Executes a callback with the provided array and returns the array. +Useful for side-effects (e.g., logging) in the middle of a function chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • arr: T[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The array to tap into

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fn: (value: T[]) => void +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The callback to execute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns T[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The original array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tap([1, 2, 3], console.log).map(x => x * 2);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.timeoutSignal.html b/packages/tempo/public/v4/api/library/functions/common.index.timeoutSignal.html new file mode 100644 index 00000000..ecc68730 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.timeoutSignal.html @@ -0,0 +1,53 @@ +timeoutSignal | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function timeoutSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Creates an AbortSignal with a timeout in milliseconds, optionally composed with an existing parent signal. +The returned signal provides a cleanup() method to detach listeners from the parent signal early.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ms: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Timeout duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • OptionalparentSignal: AbortSignal +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional parent AbortSignal to combine with the timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns AbortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An AbortSignal that aborts when either the timeout expires or the parent signal aborts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.timingSafeEqual.html b/packages/tempo/public/v4/api/library/functions/common.index.timingSafeEqual.html new file mode 100644 index 00000000..a6eb7467 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.timingSafeEqual.html @@ -0,0 +1,58 @@ +timingSafeEqual | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function timingSafeEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Compares two byte buffers in constant time to prevent timing attacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • a: Uint8Array +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  First byte buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • b: Uint8Array +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Second byte buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                True if both buffers are identical in length and content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const match = timingSafeEqual(sigA, sigB);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toBase64Url.html b/packages/tempo/public/v4/api/library/functions/common.index.toBase64Url.html new file mode 100644 index 00000000..110cbbf6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toBase64Url.html @@ -0,0 +1,55 @@ +toBase64Url | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function toBase64Url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Encodes a UTF-8 text string into a URL-safe Base64URL string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • str: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The text string to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Base64URL string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const str = toBase64Url('Hello World');
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toCamelCase.html b/packages/tempo/public/v4/api/library/functions/common.index.toCamelCase.html new file mode 100644 index 00000000..7a57a6aa --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toCamelCase.html @@ -0,0 +1,60 @@ +toCamelCase | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toCamelCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts a string to camelCase format. +Handles spaces, punctuation, and mixed casing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sentence: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The camel-cased string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toCamelCase('Hello World'); // 'helloWorld'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toHex.html b/packages/tempo/public/v4/api/library/functions/common.index.toHex.html new file mode 100644 index 00000000..1f54139c --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toHex.html @@ -0,0 +1,59 @@ +toHex | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function toHex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Converts a number or array of numbers into a contiguous hexadecimal string. +Flattens nested arrays and filters out non-integers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • num: TValues<number> = [] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The number(s) to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optionallen: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional maximum length of the resulting string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The hexadecimal string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toHex([255, 16]); // 'ff10'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toInstant.html b/packages/tempo/public/v4/api/library/functions/common.index.toInstant.html new file mode 100644 index 00000000..9b06c080 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toInstant.html @@ -0,0 +1,49 @@ +toInstant | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function toInstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Creates a Temporal.Instant from epoch nanoseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • epochNanoseconds: bigint +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The bigint representing nanoseconds since the UNIX epoch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Instant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The created Temporal.Instant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toLower.html b/packages/tempo/public/v4/api/library/functions/common.index.toLower.html new file mode 100644 index 00000000..fdbc80a7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toLower.html @@ -0,0 +1,59 @@ +toLower | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function toLower

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Coerces a value to a string, converts it to lowercase, and trims whitespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • str: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The value to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns string | T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The lowercased and trimmed string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toLower(' HELLO '); // 'hello'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toPlainDate.html b/packages/tempo/public/v4/api/library/functions/common.index.toPlainDate.html new file mode 100644 index 00000000..65f2e357 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toPlainDate.html @@ -0,0 +1,49 @@ +toPlainDate | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function toPlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Creates a Temporal.PlainDate from a property-bag or ISO string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bag: PlainDateLike +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The property bag or ISO string to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The created Temporal.PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toProperCase.html b/packages/tempo/public/v4/api/library/functions/common.index.toProperCase.html new file mode 100644 index 00000000..bbab4550 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toProperCase.html @@ -0,0 +1,59 @@ +toProperCase | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function toProperCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Converts a string to proper case, where the first letter of every word is capitalized.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ...str: T[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The strings to convert (can be multiple arguments or an array)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The proper-cased string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toProperCase('hello world'); // 'Hello World'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toRoman.html b/packages/tempo/public/v4/api/library/functions/common.index.toRoman.html new file mode 100644 index 00000000..5f019104 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toRoman.html @@ -0,0 +1,55 @@ +toRoman | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function toRoman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Converts a positive integer into its Roman numeral string representation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • num: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An integer from 1 through 3999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uppercase subtractive Roman numerals, or an empty string for non-integers or values outside that range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toRoman(2026); // 'MMXXVI'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toRoman(14); // 'XIV'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toTitleCase.html b/packages/tempo/public/v4/api/library/functions/common.index.toTitleCase.html new file mode 100644 index 00000000..fe4a3049 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toTitleCase.html @@ -0,0 +1,59 @@ +toTitleCase | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function toTitleCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Converts a string to title case, where only the first letter of the entire string is capitalized. +This is locale-aware if a locale is provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • str: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The string to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionallocale: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional locale for capitalization rules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The title-cased string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toTitleCase('HELLO WORLD'); // 'Hello world'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toUpper.html b/packages/tempo/public/v4/api/library/functions/common.index.toUpper.html new file mode 100644 index 00000000..f151d0a1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toUpper.html @@ -0,0 +1,59 @@ +toUpper | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function toUpper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Coerces a value to a string, converts it to uppercase, and trims whitespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • str: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string | T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The uppercased and trimmed string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toUpper(' hello '); // 'HELLO'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.toZonedDateTime.html b/packages/tempo/public/v4/api/library/functions/common.index.toZonedDateTime.html new file mode 100644 index 00000000..13bbd850 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.toZonedDateTime.html @@ -0,0 +1,53 @@ +toZonedDateTime | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function toZonedDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Creates a Temporal.ZonedDateTime from a property-bag or ISO string. +Automatically injects the specified timezone if missing from the string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bag: ZonedDateTimeLike +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The property bag or ISO string to convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tz: TimeZoneLike = 'UTC' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The fallback timezone (default: 'UTC')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns ZonedDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The created Temporal.ZonedDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.today.html b/packages/tempo/public/v4/api/library/functions/common.index.today.html new file mode 100644 index 00000000..ada2f2f4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.today.html @@ -0,0 +1,49 @@ +today | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function today

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the current plain date (ISO calendar) for the given timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeZone: string = ... +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The time zone to use (default: system local timezone)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current Temporal.PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.trimAll.html b/packages/tempo/public/v4/api/library/functions/common.index.trimAll.html new file mode 100644 index 00000000..a3282fdc --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.trimAll.html @@ -0,0 +1,59 @@ +trimAll | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function trimAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Cleans a string by removing standard control characters (tab, line-feed, carriage-return) +and trimming redundant spaces. Allows for an optional RegExp to specify additional matches to remove.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • str: string | number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The string to clean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalpat: RegExp +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional RegExp pattern to remove from the string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The cleaned string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          trimAll('  hello \t world \n'); // 'hello world'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.unQuoteObj.html b/packages/tempo/public/v4/api/library/functions/common.index.unQuoteObj.html new file mode 100644 index 00000000..3297d643 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.unQuoteObj.html @@ -0,0 +1,56 @@ +unQuoteObj | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function unQuoteObj

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Serializes an object to JSON and removes quotes around property names. +Useful for generating loosely formatted string representations of objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • obj: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The object to un-quote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A stringified JSON representation without quotes around keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unQuoteObj({ a: 1 }); // '{a: 1}'
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/common.index.unix.html b/packages/tempo/public/v4/api/library/functions/common.index.unix.html new file mode 100644 index 00000000..9d98af1b --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.unix.html @@ -0,0 +1,43 @@ +unix | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function unix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns the current Unix timestamp in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current Unix timestamp (seconds)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/common.index.unwrap.html b/packages/tempo/public/v4/api/library/functions/common.index.unwrap.html new file mode 100644 index 00000000..0d28e9ef --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.unwrap.html @@ -0,0 +1,60 @@ +unwrap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Traverse a Proxy chain and return the underlying raw target object. +Hardened against prototype-climbing bugs and cyclic $Target chains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • obj: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The object to unwrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns T

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The underlying raw target object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const raw = unwrap(proxyObj);
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/common.index.verify.html b/packages/tempo/public/v4/api/library/functions/common.index.verify.html new file mode 100644 index 00000000..46f7065d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.verify.html @@ -0,0 +1,52 @@ +verify | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Verifies a signature against the provided data using the module-scoped ephemeral asymmetric public key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • signature: ArrayBuffer | Promise<ArrayBuffer> | Uint8Array<ArrayBufferLike> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The signature buffer to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • doc: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The original data payload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A promise resolving to a boolean indicating verification success

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/common.index.verifyData.html b/packages/tempo/public/v4/api/library/functions/common.index.verifyData.html new file mode 100644 index 00000000..bc18ec3f --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.verifyData.html @@ -0,0 +1,58 @@ +verifyData | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function verifyData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Verifies a signature against raw data using the provided CryptoKey.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • signature: BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The signature buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • data: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The original string or binary data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • publicKey: CryptoKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The public CryptoKey with 'verify' usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alg: AlgorithmIdentifier = keys.SignKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The signature algorithm identifier (default: keys.SignKey)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A promise resolving to true if valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/common.index.verifyHmac.html b/packages/tempo/public/v4/api/library/functions/common.index.verifyHmac.html new file mode 100644 index 00000000..0c4143bf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.verifyHmac.html @@ -0,0 +1,58 @@ +verifyHmac | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function verifyHmac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Verifies an HMAC signature against the provided data and secret using constant-time comparison.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • signature: BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The signature buffer to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • data: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The original data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • secret: string | BinaryData +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The secret key as a string or binary buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • alg: string = 'SHA-256' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The hash algorithm to use (default: 'SHA-256')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A promise resolving to true if the HMAC signature matches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/common.index.verifyJWS.html b/packages/tempo/public/v4/api/library/functions/common.index.verifyJWS.html new file mode 100644 index 00000000..ae1ecbd0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.verifyJWS.html @@ -0,0 +1,115 @@ +verifyJWS | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function verifyJWS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Verifies a JSON Web Signature (JWS) against a provided key or secret. +Enforces a mandatory caller-supplied expectedAlg for algorithm dispatch to prevent algorithm confusion attacks. +Supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Asymmetric RS256: via CryptoKey or PEM public key string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Symmetric HS256, HS384, HS512: via shared secret string or Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • token: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The JWS string to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • keyOrSecret: string | CryptoKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The public CryptoKey, PEM public key string, or HMAC shared secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • expectedAlg: "RS256" +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mandatory expected algorithm to enforce (e.g. 'RS256', 'HS256', 'HS384', 'HS512')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise resolving to true if the signature is valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Verifies a JSON Web Signature (JWS) against a provided key or secret. +Enforces a mandatory caller-supplied expectedAlg for algorithm dispatch to prevent algorithm confusion attacks. +Supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Asymmetric RS256: via CryptoKey or PEM public key string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Symmetric HS256, HS384, HS512: via shared secret string or Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • token: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The JWS string to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • keyOrSecret: string | Uint8Array<ArrayBufferLike> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The public CryptoKey, PEM public key string, or HMAC shared secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • expectedAlg: HMACAlgorithm +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mandatory expected algorithm to enforce (e.g. 'RS256', 'HS256', 'HS384', 'HS512')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise resolving to true if the signature is valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Verifies a JSON Web Signature (JWS) against a provided key or secret. +Enforces a mandatory caller-supplied expectedAlg for algorithm dispatch to prevent algorithm confusion attacks. +Supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Asymmetric RS256: via CryptoKey or PEM public key string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Symmetric HS256, HS384, HS512: via shared secret string or Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • token: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The JWS string to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • keyOrSecret: string | Uint8Array<ArrayBufferLike> | CryptoKey +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The public CryptoKey, PEM public key string, or HMAC shared secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • expectedAlg: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mandatory expected algorithm to enforce (e.g. 'RS256', 'HS256', 'HS384', 'HS512')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A promise resolving to true if the signature is valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/common.index.when.html b/packages/tempo/public/v4/api/library/functions/common.index.when.html new file mode 100644 index 00000000..f49fab53 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.when.html @@ -0,0 +1,190 @@ +when | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function when

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Conditionally coalesces a value based on a predicate guard. +Returns the value (narrowed by the guard) if the guard returns true, otherwise returns the fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • guard: (v: unknown) => v is T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A predicate or type guard function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value or fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when('hello', isString);              // 'hello'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString);                  // undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString, 'default');       // 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(rawIso, v => v !== 'INVALID');   // rawIso or undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Conditionally coalesces a value based on a predicate guard. +Returns the value (narrowed by the guard) if the guard returns true, otherwise returns the fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • guard: (v: unknown) => v is T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A predicate or type guard function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fallback: undefined +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional fallback value if the guard returns false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value or fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when('hello', isString);              // 'hello'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString);                  // undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString, 'default');       // 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(rawIso, v => v !== 'INVALID');   // rawIso or undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Conditionally coalesces a value based on a predicate guard. +Returns the value (narrowed by the guard) if the guard returns true, otherwise returns the fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • guard: (v: unknown) => v is T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A predicate or type guard function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fallback: U +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional fallback value if the guard returns false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | U

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value or fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when('hello', isString);              // 'hello'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString);                  // undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString, 'default');       // 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(rawIso, v => v !== 'INVALID');   // rawIso or undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Conditionally coalesces a value based on a predicate guard. +Returns the value (narrowed by the guard) if the guard returns true, otherwise returns the fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • guard: (v: T) => boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A predicate or type guard function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value or fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when('hello', isString);              // 'hello'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString);                  // undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString, 'default');       // 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(rawIso, v => v !== 'INVALID');   // rawIso or undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Conditionally coalesces a value based on a predicate guard. +Returns the value (narrowed by the guard) if the guard returns true, otherwise returns the fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The candidate value to test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • guard: (v: T) => boolean +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A predicate or type guard function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fallback: U +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional fallback value if the guard returns false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns T | U

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value or fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when('hello', isString);              // 'hello'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString);                  // undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(123, isString, 'default');       // 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          when(rawIso, v => v !== 'INVALID');   // rawIso or undefined
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/common.index.withUtcParts.html b/packages/tempo/public/v4/api/library/functions/common.index.withUtcParts.html new file mode 100644 index 00000000..6901cb39 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/common.index.withUtcParts.html @@ -0,0 +1,53 @@ +withUtcParts | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function withUtcParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns a new Date instance with updated UTC calendar or clock fields applied to the given date. +Non-mutating (pure copy-on-write).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • date: Date +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The source Date instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parts: Partial<UtcPartsOptions> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial UTC parts to overwrite on the source date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A new UTC Date instance with the specified parts updated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverDelete.html b/packages/tempo/public/v4/api/library/functions/server.index.serverDelete.html new file mode 100644 index 00000000..a16cc965 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverDelete.html @@ -0,0 +1,52 @@ +serverDelete | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function serverDelete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deletes a file from the server sandboxed storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              True if deleted, false if file did not exist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverExists.html b/packages/tempo/public/v4/api/library/functions/server.index.serverExists.html new file mode 100644 index 00000000..3fba2351 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverExists.html @@ -0,0 +1,51 @@ +serverExists | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function serverExists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Checks whether a file exists in the server sandboxed storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverGeoCoords.html b/packages/tempo/public/v4/api/library/functions/server.index.serverGeoCoords.html new file mode 100644 index 00000000..db294ddf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverGeoCoords.html @@ -0,0 +1,51 @@ +serverGeoCoords | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function serverGeoCoords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Normalize coordinates or resolve default IP location on server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalcoords: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lat?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lng?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lon?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        long?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional coordinate input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Optionalopts: ServerMapOpts +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Server map options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<{ lat: number; lng: number } | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverGeoLocation.html b/packages/tempo/public/v4/api/library/functions/server.index.serverGeoLocation.html new file mode 100644 index 00000000..5b204097 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverGeoLocation.html @@ -0,0 +1,49 @@ +serverGeoLocation | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Function serverGeoLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perform server-side IP geolocation query via HTTP fetchRequest.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • opts: ServerMapOpts = ... +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Options including custom endpoint URL and timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns Promise<ServerGeolocationResult>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geolocation result object with coordinates and location info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverList.html b/packages/tempo/public/v4/api/library/functions/server.index.serverList.html new file mode 100644 index 00000000..9e97af23 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverList.html @@ -0,0 +1,51 @@ +serverList | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function serverList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Lists all file names in a given subdirectory of the server storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • dir: string = '' +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional subdirectory path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns Promise<string[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverMapHemisphere.html b/packages/tempo/public/v4/api/library/functions/server.index.serverMapHemisphere.html new file mode 100644 index 00000000..69829812 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverMapHemisphere.html @@ -0,0 +1,51 @@ +serverMapHemisphere | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function serverMapHemisphere

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determine Hemisphere ('north' | 'south' | null) for server coordinates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalcoords: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lat?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lng?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lon?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              long?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Optional coordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalopts: ServerMapOpts +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<"north" | "south" | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverRead.html b/packages/tempo/public/v4/api/library/functions/server.index.serverRead.html new file mode 100644 index 00000000..dd7d408d --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverRead.html @@ -0,0 +1,52 @@ +serverRead | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function serverRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Reads a text file from the server sandboxed storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Promise<string | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          File content as string, or null if file not found

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverReadBuffer.html b/packages/tempo/public/v4/api/library/functions/server.index.serverReadBuffer.html new file mode 100644 index 00000000..5d81ca59 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverReadBuffer.html @@ -0,0 +1,52 @@ +serverReadBuffer | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function serverReadBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reads a binary file as a Buffer from the server storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<Buffer<ArrayBufferLike> | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Buffer containing file bytes, or null if not found

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverReadJSON.html b/packages/tempo/public/v4/api/library/functions/server.index.serverReadJSON.html new file mode 100644 index 00000000..e98741c7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverReadJSON.html @@ -0,0 +1,58 @@ +serverReadJSON | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function serverReadJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Reads and parses a JSON file from the server storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Optionalfallback: T +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Default fallback if file does not exist or is invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Promise<T | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverWrite.html b/packages/tempo/public/v4/api/library/functions/server.index.serverWrite.html new file mode 100644 index 00000000..057f0f51 --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverWrite.html @@ -0,0 +1,55 @@ +serverWrite | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function serverWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Writes text or binary data to a file in the server sandboxed storage. +Automatically creates parent directories as needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • content: string | ArrayBufferView<ArrayBufferLike> +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Text string or Buffer/Uint8Array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/functions/server.index.serverWriteJSON.html b/packages/tempo/public/v4/api/library/functions/server.index.serverWriteJSON.html new file mode 100644 index 00000000..419fcdbf --- /dev/null +++ b/packages/tempo/public/v4/api/library/functions/server.index.serverWriteJSON.html @@ -0,0 +1,54 @@ +serverWriteJSON | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function serverWriteJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Serializes and writes data to a JSON file in the server storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • filePath: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative path inside the sandboxed root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • data: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data object or value to write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • OptionalrootDir: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional root directory override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/hierarchy.html b/packages/tempo/public/v4/api/library/hierarchy.html new file mode 100644 index 00000000..189dc862 --- /dev/null +++ b/packages/tempo/public/v4/api/library/hierarchy.html @@ -0,0 +1,38 @@ +Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hierarchy Summary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/index.html b/packages/tempo/public/v4/api/library/index.html new file mode 100644 index 00000000..89630681 --- /dev/null +++ b/packages/tempo/public/v4/api/library/index.html @@ -0,0 +1,138 @@ +Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Library Logo Magma Library (Internal Reference)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +Internal Reference Package: packages/library is an internal monorepo utility suite used across Tempo packages. It is not published as a standalone package on npm, and is provided in the documentation as a reference guide for internal architectural utilities and shared routines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Magma Library provides platform-agnostic utilities for type-safe development, data manipulation, and asynchronous operations across Browser and Node.js environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    License: MIT +TypeScript Ready +Native ESM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library is organized into specialized modules, each designed for maximum efficiency and tree-shakability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModuleDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type SystemAdvanced runtime type detection (getType), strict type-guards, and complex TS utility types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ArraySorted insertion, multi-key sorting, grouping (byKey), and cartesian products.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StringProper-casing, pluralization helpers, sprintf-style formatting, and template evaluation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SerializationJSON-compatible stabilization with deep support for Temporal, BigInt, and custom Classes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CipherSimple, secure class-based encryption and decryption wrappers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PledgeA robust wrapper for native Promises with settled-state tracking and timeout support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReflectionClean access to own-properties, values, and entries without prototype pollution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TemporalLightweight helpers and polyfill integration for the native Temporal API.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RecurrenceZero-dependency RFC 5545 recurrence rule parsing, expansion, and finiteness evaluation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The getType utility provides human-readable, proper-cased type names, even for custom classes that have been registered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { getType, isType } from '@magmacomputing/tempo/library';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getType([]);            // "Array"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getType(new Map());     // "Map"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getType(42n);           // "BigInt"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (isType(val, 'String', 'Number')) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // val is now narrowed to string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sort complex collections of objects by multiple fields with ease.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { sortKey } from '@magmacomputing/tempo/library';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const users = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { name: 'Alice', age: 30 },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { name: 'Bob', age: 25 },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { name: 'Alice', age: 22 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Sort by name (ASC) then age (DESC)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sorted = sortKey(users, 'name', { field: 'age', dir: 'desc' });
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unlike standard JSON.stringify, Magma's serialization handles complex types like Temporal and BigInt out of the box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { stringify, objectify } from '@magmacomputing/tempo/library';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const data = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      at: Temporal.Now.instant(),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: 100n,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pattern: /abc/gi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const json = stringify(data);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const restored = objectify(json); // Fully restored types!
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deep dives into specific APIs, explore the generated module reference or the user guides:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you have questions, need architectural consulting, or want to report a bug, please reach out to us:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distributed under the MIT License. See LICENSE for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    © 2026 Magma Computing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Magma Library (Internal Reference) +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.BoundaryContext.html b/packages/tempo/public/v4/api/library/interfaces/common.index.BoundaryContext.html new file mode 100644 index 00000000..35b8e83e --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.BoundaryContext.html @@ -0,0 +1,76 @@ +BoundaryContext | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interface BoundaryContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BoundaryContext {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          catch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          logger?: Logger | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          silent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      catch? +logger? +silent? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      catch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If true, errors will be caught, logged, and execution will return gracefully. +If false, errors will be immediately thrown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      logger?: Logger | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The namespaced logger to use for outputting the caught error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      silent?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If true, suppresses telemetry/logging for raise() regardless of whether the error is rethrown or swallowed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.CoordinateInput.html b/packages/tempo/public/v4/api/library/interfaces/common.index.CoordinateInput.html new file mode 100644 index 00000000..2f8b36b7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.CoordinateInput.html @@ -0,0 +1,140 @@ +CoordinateInput | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interface CoordinateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CoordinateInput {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            config?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elevation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            geo?: GeoOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lat?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lng?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lon?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            long?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sphere?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tz?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        city? +config? +country? +elevation? +geo? +lat? +latitude? +lng? +lon? +long? +longitude? +sphere? +timezone? +tz? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        config?: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        elevation?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        geo?: GeoOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lat?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lng?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lon?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        long?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sphere?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tz?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.CronField.html b/packages/tempo/public/v4/api/library/interfaces/common.index.CronField.html new file mode 100644 index 00000000..87ba7255 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.CronField.html @@ -0,0 +1,66 @@ +CronField | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interface CronField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Represents a single parsed cron field with its allowed values and restriction status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CronField {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allowed: Set<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              restricted: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowed +restricted +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowed: Set<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          restricted: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.CronSchedule.html b/packages/tempo/public/v4/api/library/interfaces/common.index.CronSchedule.html new file mode 100644 index 00000000..3b9ccc6a --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.CronSchedule.html @@ -0,0 +1,84 @@ +CronSchedule | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interface CronSchedule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Represents a fully parsed cron schedule with all five time fields.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CronSchedule {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                daysOfMonth: CronField;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                daysOfWeek: CronField;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hours: CronField;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                minutes: CronField;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                months: CronField;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            daysOfMonth +daysOfWeek +hours +minutes +months +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            daysOfMonth: CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            daysOfWeek: CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hours: CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            minutes: CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            months: CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.FileStoreOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.FileStoreOptions.html new file mode 100644 index 00000000..afcfe300 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.FileStoreOptions.html @@ -0,0 +1,78 @@ +FileStoreOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interface FileStoreOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Options required to initialize an encrypted Virtual File Store.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FileStoreOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iterations?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  password: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              iterations? +namespace? +password +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              iterations?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional PBKDF2 iteration count (default: 100,000)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional directory prefix/namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              password: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Secret password or passphrase used for PBKDF2 key derivation and AES-GCM encryption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.GeoConfig.html b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoConfig.html new file mode 100644 index 00000000..fb096064 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoConfig.html @@ -0,0 +1,124 @@ +GeoConfig | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interface GeoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GeoConfig {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elevation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sphere?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly [key: symbol]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Custom or future string/number key property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly [key: symbol]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Custom symbol key property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                city? +country? +elevation? +latitude? +longitude? +sphere? +timezone? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                City or locality name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ISO country code (e.g. 'US', 'AU')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elevation?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Altitude / Elevation in meters above sea level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Latitude coordinate in degrees (-90 to 90)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Longitude coordinate in degrees (-180 to 180)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sphere?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Inferred or explicit hemisphere ('north' | 'south' | 'equator')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IANA Time Zone ID (e.g. 'Australia/Sydney')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.GeoLookupResult.html b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoLookupResult.html new file mode 100644 index 00000000..a2b12674 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoLookupResult.html @@ -0,0 +1,122 @@ +GeoLookupResult | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interface GeoLookupResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GeoLookupResult {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      elevation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lat?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lng?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sphere?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      status?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  city? +country? +elevation? +error? +lat? +latitude? +lng? +longitude? +sphere? +status? +timezone? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elevation?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  error?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lat?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lng?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sphere?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  status?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.GeoOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoOptions.html new file mode 100644 index 00000000..d42514ad --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoOptions.html @@ -0,0 +1,118 @@ +GeoOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interface GeoOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GeoOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        elevation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sphere?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: symbol]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Custom or future string/number key property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: symbol]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Custom symbol key property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    city? +country? +elevation? +latitude? +longitude? +sphere? +timezone? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    City or locality name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO country code (e.g. 'US', 'AU')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elevation?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Altitude / Elevation in meters above sea level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Latitude coordinate in degrees

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Longitude coordinate in degrees

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sphere?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inferred or explicit hemisphere ('north' | 'south' | 'equator')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IANA Time Zone ID (e.g. 'Australia/Sydney')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.GeoProvider.html b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoProvider.html new file mode 100644 index 00000000..17292047 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.GeoProvider.html @@ -0,0 +1,120 @@ +GeoProvider | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interface GeoProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Standard interface for pluggable geocoding and geolocation providers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GeoProvider {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forwardGeocode?(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              query: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<ResolvedCoordinates | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lookup(opts?: Record<string, any>): Promise<GeoLookupResult | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reverseGeocode?(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              coords: CoordinateInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<GeoConfig | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      forwardGeocode? +lookup +reverseGeocode? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Unique identifier or provider name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional forward geocoding from place/address query to coordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • query: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalopts: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<ResolvedCoordinates | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Resolves geographic coordinates and location metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalopts: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<GeoLookupResult | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional reverse geocoding from coordinates to location details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Promise<GeoConfig | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.IgnoreOfMap.html b/packages/tempo/public/v4/api/library/interfaces/common.index.IgnoreOfMap.html new file mode 100644 index 00000000..252960b6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.IgnoreOfMap.html @@ -0,0 +1,341 @@ +IgnoreOfMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interface IgnoreOfMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Augmentable map of method/property names to exclude from KeyOf/ValueOf/OwnOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IgnoreOfMap {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "[iterator]": () => IterableIterator<readonly [PropertyKey, any]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "[toStringTag]": "Enumify";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            count(): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entries(): readonly (readonly [PropertyKey, any])[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extend<const E extends any[] | Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                list: E,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                frozen?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): EnumifyType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filter(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): EnumifyType<Partial<any>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            forEach(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            get(key: PropertyKey): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            has(key: LooseKey<PropertyKey>): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hasOwn(key: PropertyKey): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includes(search: any): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            invert(): Readonly<Invert<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyOf(search: any): PropertyKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keys(): readonly PropertyKey[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            map(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): EnumifyType<Property<any>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            values(): readonly any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [iterator] +[toStringTag] +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count +entries +extend +filter +forEach +get +has +hasOwn +includes +invert +keyOf +keys +map +values +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "[iterator]": () => IterableIterator<readonly [PropertyKey, any]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iterate through all Enum entries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "[toStringTag]": "Enumify"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        used to identify the Enumify type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.count(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns readonly (readonly [PropertyKey, any])[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • list: E
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionalfrozen: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns EnumifyType<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.extend(enumObj, list) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns EnumifyType<Partial<any>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Iterate over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • key: PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.get(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.has(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • key: PropertyKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.hasOwn(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • search: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.includes(enumObj, search) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns Readonly<Invert<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.invert(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • search: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns PropertyKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.keyOf(enumObj, search) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns readonly PropertyKey[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.keys(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                entry: readonly [PropertyKey, any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns EnumifyType<Property<any>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Map over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns readonly any[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use Enum.values(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.JSONCOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.JSONCOptions.html new file mode 100644 index 00000000..eafbb52f --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.JSONCOptions.html @@ -0,0 +1,76 @@ +JSONCOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interface JSONCOptions<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Configuration options for JSONC parsing operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JSONCOptions<T = any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fallback?: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reviver?: JSONCReviver;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              safe?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fallback? +reviver? +safe? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fallback?: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reviver?: JSONCReviver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          safe?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHMACHeader.html b/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHMACHeader.html new file mode 100644 index 00000000..91403fa8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHMACHeader.html @@ -0,0 +1,76 @@ +JWSHMACHeader | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interface JWSHMACHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JWSHMACHeader {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                alg: HMACAlgorithm;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typ?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            alg +typ? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            alg: HMACAlgorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typ?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHeader.html b/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHeader.html new file mode 100644 index 00000000..4667df9d --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.JWSHeader.html @@ -0,0 +1,78 @@ +JWSHeader | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interface JWSHeader<Alg>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JWSHeader<Alg extends string = string> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  alg?: Alg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typ?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Alg extends string = string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alg? +typ? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alg?: Alg
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typ?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.JWTComponents.html b/packages/tempo/public/v4/api/library/interfaces/common.index.JWTComponents.html new file mode 100644 index 00000000..9eec0871 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.JWTComponents.html @@ -0,0 +1,88 @@ +JWTComponents | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interface JWTComponents<Header, Payload>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JWTComponents<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Header = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Payload = Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    header: Header;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    payload: Payload;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    raw: { header: string; payload: string; signature: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    signature: Uint8Array;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Header = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Payload = Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                header +payload +raw +signature +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                header: Header
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Decoded JSON header object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: Payload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Decoded JSON payload object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                raw: { header: string; payload: string; signature: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Original encoded string segments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                signature: Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Raw binary signature buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.LocaleWeekInfo.html b/packages/tempo/public/v4/api/library/interfaces/common.index.LocaleWeekInfo.html new file mode 100644 index 00000000..9efbd259 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.LocaleWeekInfo.html @@ -0,0 +1,75 @@ +LocaleWeekInfo | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interface LocaleWeekInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LocaleWeekInfo {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      firstDay: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      minimalDays?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      weekend: readonly number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  firstDay +minimalDays? +weekend +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  firstDay: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  First day of the week: 1 (Mon) .. 7 (Sun)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minimalDays?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Minimum days required in the first week of the year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  weekend: readonly number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Regional weekend days (e.g. [6, 7] or [5, 6])

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ObjectifyOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ObjectifyOptions.html new file mode 100644 index 00000000..6bd89517 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ObjectifyOptions.html @@ -0,0 +1,118 @@ +ObjectifyOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interface ObjectifyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration options for objectify() deserialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ObjectifyOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowClasses?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowedClasses?: string[] | Set<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowRegExp?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxDepth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requireSigned?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        secret?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sentinel?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        throwOnError?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowClasses? +allowedClasses? +allowRegExp? +maxDepth? +requireSigned? +secret? +sentinel? +throwOnError? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowClasses?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether to allow instantiation of registered classes via Registry (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowedClasses?: string[] | Set<string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional allowlist of permitted registered class names (matched with or without leading '$')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowRegExp?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether to reconstruct RegExp instances (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxDepth?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Maximum object traversal nesting depth to prevent call-stack exhaustion (default: 64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requireSigned?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If true, requires that the string has a valid signature, rejecting unsigned strings (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    secret?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Secret key or salt to verify the signature against (required for signed verification)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sentinel?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional function to handle reconstructing undefined/void values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throwOnError?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If true, throws an Error when signature verification fails, secret is missing, or payload is rejected (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ParseJWTOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ParseJWTOptions.html new file mode 100644 index 00000000..cfd56da4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ParseJWTOptions.html @@ -0,0 +1,59 @@ +ParseJWTOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interface ParseJWTOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ParseJWTOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          strict?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      strict? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      strict?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If true, throws explicit Errors on length or format validation failures instead of returning null

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ParsedRRule.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ParsedRRule.html new file mode 100644 index 00000000..7a676eab --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ParsedRRule.html @@ -0,0 +1,126 @@ +ParsedRRule | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interface ParsedRRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parsed structure of an RFC 5545 Recurrence Rule string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ParsedRRule {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            byDay?: { day: string; nth?: number }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            byHour?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            byMinute?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            byMonth?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bySetPos?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            count?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            freq: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interval: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            untilMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        byDay? +byHour? +byMinute? +byMonth? +bySetPos? +count? +freq +interval +untilMs? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        byDay?: { day: string; nth?: number }[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Day-of-week specifications from BYDAY with optional nth occurrences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        byHour?: number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Hour filters (0..23) from BYHOUR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        byMinute?: number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Minute filters (0..59) from BYMINUTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        byMonth?: number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter months (1..12) from BYMONTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bySetPos?: number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Set position selectors from BYSETPOS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Maximum number of occurrences to generate, if bounded by COUNT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        freq: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Frequency unit: DAILY, WEEKLY, MONTHLY, or YEARLY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interval: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Inter-occurrence interval count (default: 1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        untilMs?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Bounded end timestamp in epoch milliseconds, if bounded by UNTIL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.Pledge.Status.html b/packages/tempo/public/v4/api/library/interfaces/common.index.Pledge.Status.html new file mode 100644 index 00000000..b0a32fd9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.Pledge.Status.html @@ -0,0 +1,98 @@ +Status | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interface Status<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Status<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              catch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              debug?: DebugLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              error?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              settled?: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              silent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              state: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          catch? +debug? +error? +settled? +silent? +state +tag? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          catch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          debug?: DebugLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          error?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          settled?: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          silent?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          state: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.Options.html b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.Options.html new file mode 100644 index 00000000..6ae9bfdc --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.Options.html @@ -0,0 +1,91 @@ +Options | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interface Options<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configuration options for Reactive instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Options<T = any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bufferSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                catch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                finalizer?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bufferSize? +catch? +finalizer? +tag? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bufferSize?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Maximum buffered items for pull-mode consumers (default: Infinity)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            catch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If true, unhandled errors are suppressed and routed to error listeners (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            finalizer?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If true, registers GC finalization safety hook (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Optional diagnostic tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.State.html b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.State.html new file mode 100644 index 00000000..8a50615c --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.State.html @@ -0,0 +1,97 @@ +State | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interface State

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Current operational state snapshot of a Reactive instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface State {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  active: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buffered: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  completed: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  emitted: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  queued: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subscribers: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              active +buffered +completed +emitted +queued +subscribers +tag? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              active: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              buffered: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              completed: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              emitted: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queued: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subscribers: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tag?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.SubscriptionOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.SubscriptionOptions.html new file mode 100644 index 00000000..f0161864 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.Reactive.SubscriptionOptions.html @@ -0,0 +1,71 @@ +SubscriptionOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interface SubscriptionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Options for event subscriptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SubscriptionOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    once?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    signal?: AbortSignal;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                once? +signal? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                once?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If true, automatically unregisters the listener after its first invocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                signal?: AbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optional AbortSignal to automatically detach the listener when aborted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedCoordinates.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedCoordinates.html new file mode 100644 index 00000000..a7c266b8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedCoordinates.html @@ -0,0 +1,141 @@ +ResolvedCoordinates | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interface ResolvedCoordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResolvedCoordinates {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      elevation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lat: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lng: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sphere?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly [key: symbol]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly [key: symbol]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom symbol key property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  city? +country? +elevation? +lat +latitude? +lng +longitude? +sphere? +timezone? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  City or locality name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ISO country code (e.g. 'US', 'AU')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elevation?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Altitude / Elevation in meters above sea level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lat: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Latitude coordinate in degrees (-90 to 90)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lng: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Longitude coordinate in degrees (-180 to 180)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sphere?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Inferred or explicit hemisphere ('north' | 'south' | 'equator')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IANA Time Zone ID (e.g. 'Australia/Sydney')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedLocaleInfo.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedLocaleInfo.html new file mode 100644 index 00000000..7f200ea3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ResolvedLocaleInfo.html @@ -0,0 +1,141 @@ +ResolvedLocaleInfo | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interface ResolvedLocaleInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResolvedLocaleInfo {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        baseName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        direction: "ltr" | "rtl";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        firstDay: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hourCycle: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hourCycles: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        language?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        locale?: Locale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minimalDays: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        numberingSystem: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        numberingSystems: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        region?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        script?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timeZones: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        weekend: readonly number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        weekInfo: LocaleWeekInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseName +direction +firstDay +hourCycle +hourCycles +language? +locale? +minimalDays +numberingSystem +numberingSystems +region? +script? +timeZones +weekend +weekInfo +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction: "ltr" | "rtl"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    firstDay: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hourCycle: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hourCycles: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    language?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    locale?: Locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minimalDays: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    numberingSystem: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    numberingSystems: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    region?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    script?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZones: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    weekend: readonly number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    weekInfo: LocaleWeekInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.SecureArray.html b/packages/tempo/public/v4/api/library/interfaces/common.index.SecureArray.html new file mode 100644 index 00000000..302d5a87 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.SecureArray.html @@ -0,0 +1,991 @@ +SecureArray | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interface SecureArray<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SecureArray<T> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[unscopables]": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "[iterator]"?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "[unscopables]"?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              at?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              concat?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entries?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              every?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              find?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findIndex?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findLast?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findLastIndex?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flat?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flatMap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forEach?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              indexOf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              join?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keys?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lastIndexOf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              length?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              map?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reduce?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reduceRight?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              slice?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              some?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toLocaleString?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toReversed?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSorted?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toSpliced?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toString?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              values?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              with?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly [key: number]: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          length: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[iterator]"(): ArrayIterator<Secure<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          at(index: number): Secure<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          concat(...items: ConcatArray<Secure<T>>[]): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          concat(...items: (Secure<T> | ConcatArray<Secure<T>>)[]): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entries(): ArrayIterator<[number, Secure<T>]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          every<S>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => value is S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): this is readonly S[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          every(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter<S>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => value is S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): S[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find<S>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => value is S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): S | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findIndex(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  obj: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLast<S>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => value is S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): S | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLast(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLastIndex(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flatMap<U, This = undefined>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  this: This,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => U | readonly U[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: This,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): U[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forEach(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes(searchElement: Secure, fromIndex?: number): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          indexOf(searchElement: Secure, fromIndex?: number): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          join(separator?: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keys(): ArrayIterator<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lastIndexOf(searchElement: Secure, fromIndex?: number): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          map<U>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): U[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduce(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduce(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduce<U>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): U;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduceRight(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduceRight(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduceRight<U>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): U;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          slice(start?: number, end?: number): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          some(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              predicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toLocaleString(): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toLocaleString(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              locales: string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NumberFormatOptions & DateTimeFormatOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toReversed(): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSorted(compareFn?: (a: Secure, b: Secure) => number): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSpliced(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deleteCount: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...items: Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSpliced(start: number, deleteCount?: number): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toString(): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          values(): ArrayIterator<Secure<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          with(index: number, value: Secure): Secure<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [n: number]: Secure<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hierarchy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ReadonlyArray<Secure<T>> +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • SecureArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Indexable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [n: number]: Secure<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [unscopables] +length +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [iterator] +at +concat +entries +every +filter +find +findIndex +findLast +findLastIndex +flat +flatMap +forEach +includes +indexOf +join +keys +lastIndexOf +map +reduce +reduceRight +slice +some +toLocaleString +toReversed +toSorted +toSpliced +toString +values +with +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "[unscopables]": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[iterator]"?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[unscopables]"?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          at?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          concat?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entries?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          every?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findIndex?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLast?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLastIndex?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flat?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flatMap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forEach?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          indexOf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          join?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keys?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lastIndexOf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          length?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          map?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduce?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reduceRight?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          slice?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          some?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toLocaleString?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toReversed?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSorted?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSpliced?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toString?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          values?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          with?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [key: number]: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Is an object whose properties have the value 'true' +when they will be absent when used in a 'with' statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [key: number]: boolean | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional[iterator]?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional Readonly[unscopables]?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Is an object whose properties have the value 'true' +when they will be absent when used in a 'with' statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalat?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalconcat?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalentries?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalevery?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalfilter?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalfind?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalfindIndex?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalfindLast?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalfindLastIndex?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalflat?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalflatMap?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalforEach?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalincludes?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalindexOf?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionaljoin?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalkeys?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionallastIndexOf?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optional Readonlylength?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Gets the length of the array. This is a number one higher than the highest element defined in an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalmap?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalreduce?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionalreduceRight?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalslice?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalsome?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionaltoLocaleString?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionaltoReversed?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionaltoSorted?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionaltoSpliced?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OptionaltoString?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalvalues?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Optionalwith?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Gets the length of the array. This is a number one higher than the highest element defined in an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Iterator of values in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns ArrayIterator<Secure<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the item located at the specified index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • index: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The zero-based index of the desired code unit. A negative index will count back from the last item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T> | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Combines two or more arrays.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ...items: ConcatArray<Secure<T>>[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Additional items to add to the end of array1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Combines two or more arrays.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ...items: (Secure<T> | ConcatArray<Secure<T>>)[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Additional items to add to the end of array1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns an iterable of key, value pairs for every entry in the array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns ArrayIterator<[number, Secure<T>]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether all the members of an array satisfy the specified test.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => value is S +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The every method calls +the predicate function for each element in the array until the predicate returns a value +which is coercible to the Boolean value false, or until the end of the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the predicate function. +If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns this is readonly S[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether all the members of an array satisfy the specified test.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The every method calls +the predicate function for each element in the array until the predicate returns a value +which is coercible to the Boolean value false, or until the end of the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the predicate function. +If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the elements of an array that meet the condition specified in a callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => value is S +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns S[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the elements of an array that meet the condition specified in a callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the value of the first element in the array where predicate is true, and undefined +otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, obj: readonly Secure<T>[]) => value is S +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find calls predicate once for each element of the array, in ascending +order, until it finds one where predicate returns true. If such an element is found, find +immediately returns that element value. Otherwise, find returns undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If provided, it will be used as the this value for each invocation of +predicate. If it is not provided, undefined is used instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns S | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, obj: readonly Secure<T>[]) => unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T> | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the index of the first element in the array where predicate is true, and -1 +otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, obj: readonly Secure<T>[]) => unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find calls predicate once for each element of the array, in ascending +order, until it finds one where predicate returns true. If such an element is found, +findIndex immediately returns that element index. Otherwise, findIndex returns -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If provided, it will be used as the this value for each invocation of +predicate. If it is not provided, undefined is used instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the value of the last element in the array where predicate is true, and undefined +otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => value is S +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLast calls predicate once for each element of the array, in descending +order, until it finds one where predicate returns true. If such an element is found, findLast +immediately returns that element value. Otherwise, findLast returns undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If provided, it will be used as the this value for each invocation of +predicate. If it is not provided, undefined is used instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns S | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T> | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the index of the last element in the array where predicate is true, and -1 +otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findLastIndex calls predicate once for each element of the array, in descending +order, until it finds one where predicate returns true. If such an element is found, +findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If provided, it will be used as the this value for each invocation of +predicate. If it is not provided, undefined is used instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns a new array with all sub-array elements concatenated into it recursively up to the +specified depth.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • D extends number = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • this: A
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionaldepth: D +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The maximum recursion depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns FlatArray<A, D>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls a defined callback function on each element of an array. Then, flattens the result into +a new array. +This is identical to a map followed by flat with depth 1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • This = undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callback: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: This,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => U | readonly U[]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The flatMap method calls the +callback function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: This +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the callback function. If +thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns U[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Performs the specified action for each element in an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (value: Secure, index: number, array: readonly Secure<T>[]) => void +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether an array includes a certain element, returning true or false as appropriate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • searchElement: Secure +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The element to search for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalfromIndex: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The position in this array at which to begin searching for searchElement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the index of the first occurrence of a value in an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • searchElement: Secure +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value to locate in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalfromIndex: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Adds all the elements of an array separated by the specified separator string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalseparator: string +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns an iterable of keys in the array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns ArrayIterator<number>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns the index of the last occurrence of a specified value in an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • searchElement: Secure +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value to locate in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalfromIndex: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls a defined callback function on each element of an array, and returns an array that contains the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (value: Secure, index: number, array: readonly Secure<T>[]) => U +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns U[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Secure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • initialValue: Secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => U                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • initialValue: U +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns U

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Secure                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • initialValue: Secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • U
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • callbackfn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previousValue: U,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentValue: Secure,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currentIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: readonly Secure<T>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => U                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • initialValue: U +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns U

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns a section of an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalstart: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The beginning of the specified portion of the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalend: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The end of the specified portion of the array. This is exclusive of the element at the index 'end'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines whether the specified callback function returns true for any element of an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • predicate: (value: Secure, index: number, array: readonly Secure<T>[]) => unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that accepts up to three arguments. The some method calls +the predicate function for each element in the array until the predicate returns a value +which is coercible to the Boolean value true, or until the end of the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An object to which the this keyword can refer in the predicate function. +If thisArg is omitted, undefined is used as the this value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • locales: string | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionaloptions: NumberFormatOptions & DateTimeFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Copies the array and returns the copied array with all of its elements reversed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Copies and sorts the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalcompareFn: (a: Secure, b: Secure) => number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Function used to determine the order of the elements. It is expected to return +a negative value if the first argument is less than the second argument, zero if they're equal, and a positive +value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Copies an array and removes elements while, if necessary, inserting new elements in their place, returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • start: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The zero-based location in the array from which to start removing elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteCount: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The number of elements to remove.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ...items: Secure<T>[] +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Elements to insert into the copied array in place of the deleted elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A copy of the original array with the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Copies an array and removes elements while returning the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • start: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The zero-based location in the array from which to start removing elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionaldeleteCount: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The number of elements to remove.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A copy of the original array with the remaining elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns a string representation of an array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns an iterable of values in the array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns ArrayIterator<Secure<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Copies an array, then overwrites the value at the provided index with the +given value. If the index is negative, then it replaces from the end +of the array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • index: number +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The index of the value to overwrite. If the index is +negative, then it replaces from the end of the array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • value: Secure +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The value to insert into the copied array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Secure<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A copy of the original array with the inserted value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.ServerStorageOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.ServerStorageOptions.html new file mode 100644 index 00000000..7e8b4be7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.ServerStorageOptions.html @@ -0,0 +1,70 @@ +ServerStorageOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interface ServerStorageOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Options for fine-grained cache control in server storage contexts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ServerStorageOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ttl?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static? +ttl? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If true, registers as an immortal static key immune to LRU capacity eviction and TTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ttl?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Custom time-to-live in milliseconds for this specific entry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.SingletonOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.SingletonOptions.html new file mode 100644 index 00000000..c4371b54 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.SingletonOptions.html @@ -0,0 +1,59 @@ +SingletonOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interface SingletonOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SingletonOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allowArgMismatch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowArgMismatch? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowArgMismatch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If true, prevents throwing when subsequent instantiations pass different arguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.SortBy.html b/packages/tempo/public/v4/api/library/interfaces/common.index.SortBy.html new file mode 100644 index 00000000..82e12a19 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.SortBy.html @@ -0,0 +1,78 @@ +SortBy | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interface SortBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sort Array-of-Objects by multiple keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SortBy {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                default?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dir?: "desc" | "asc";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                field: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index?: number | "*";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            default? +dir? +field +index? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            default?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dir?: "desc" | "asc"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            field: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index?: number | "*"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.StringifyOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.StringifyOptions.html new file mode 100644 index 00000000..196ead23 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.StringifyOptions.html @@ -0,0 +1,78 @@ +StringifyOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interface StringifyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configuration options for stringify() serialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StringifyOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  compact?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  secret?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  signed?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              compact? +secret? +signed? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              compact?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If false, uses legacy oneKey object envelopes instead of compact tagged strings (default: true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              secret?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Secret key or salt for signature calculation (required when signed is true)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signed?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If true, wraps the output with an integrity signature prefix ($sig::)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.SubsecondParts.html b/packages/tempo/public/v4/api/library/interfaces/common.index.SubsecondParts.html new file mode 100644 index 00000000..79f3dc95 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.SubsecondParts.html @@ -0,0 +1,72 @@ +SubsecondParts | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interface SubsecondParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Breakdown of subsecond fraction into millisecond, microsecond, and nanosecond integers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SubsecondParts {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    microsecond: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    millisecond: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nanosecond: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                microsecond +millisecond +nanosecond +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                microsecond: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                millisecond: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nanosecond: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.TempoIntlNamespace.html b/packages/tempo/public/v4/api/library/interfaces/common.index.TempoIntlNamespace.html new file mode 100644 index 00000000..85bc1cb0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.TempoIntlNamespace.html @@ -0,0 +1,351 @@ +TempoIntlNamespace | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interface TempoIntlNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TempoIntlNamespace {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      baseName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      direction: "ltr" | "rtl";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      firstDay: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hourCycle: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hourCycles: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      info: ResolvedLocaleInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      language?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      locale?: Locale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      minimalDays: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      numberingSystem: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      numberingSystems: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      region?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      script?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeZones: readonly string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      weekend: readonly number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      weekInfo: LocaleWeekInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dtf(options?: DateTimeFormatOptions): DateTimeFormat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lf(options?: ListFormatOptions): ListFormat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      list(items: Iterable<string>, options?: ListFormatOptions): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nf(options?: NumberFormatOptions): NumberFormat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      number(value: number | bigint, options?: NumberFormatOptions): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plural(value: number, options?: PluralRulesOptions): LDMLPluralRule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relativeTime(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unit: RelativeTimeFormatUnit,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: RelativeTimeFormatOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rtf(options?: RelativeTimeFormatOptions): RelativeTimeFormat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseName +direction +firstDay +hourCycle +hourCycles +info +language? +locale? +minimalDays +numberingSystem +numberingSystems +region? +script? +timeZones +weekend +weekInfo +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dtf +lf +list +nf +number +plural +relativeTime +rtf +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.baseName instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  direction: "ltr" | "rtl"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.direction instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  firstDay: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.firstDay instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hourCycle: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.hourCycle instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hourCycles: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.hourCycles instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  info: ResolvedLocaleInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Resolved cultural and regional calendar metadata (firstDay, weekend, direction, hourCycle, etc.) +via the host engine's CLDR / Intl.Locale Info database.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  language?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.language instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  locale?: Locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Memoized native Intl.Locale instance for the active locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minimalDays: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Minimum days required in the first week of the year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  numberingSystem: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.numberingSystem instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  numberingSystems: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.numberingSystems instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  region?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.region instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  script?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.script instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeZones: readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.timeZones instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  weekend: readonly number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.weekend instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  weekInfo: LocaleWeekInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use intl.info.weekInfo instead. To be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a globally memoized native Intl.DateTimeFormat instance pre-bound to the active locale and timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: DateTimeFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns DateTimeFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a globally memoized native Intl.ListFormat instance pre-bound to the active locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: ListFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns ListFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formats an iterable or array of strings into a localized list (e.g. ['A', 'B', 'C'] -> 'A, B, and C') +pre-bound to the active locale and backed by a globally memoized Intl.ListFormat instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • items: Iterable<string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: ListFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a globally memoized native Intl.NumberFormat instance pre-bound to the active locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: NumberFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns NumberFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formats a number according to the active locale and numbering system +backed by a globally memoized Intl.NumberFormat instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: number | bigint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: NumberFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolves the plural category rule ('zero' | 'one' | 'two' | 'few' | 'many' | 'other') +for a numeric value in the active locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: PluralRulesOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns LDMLPluralRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formats a relative time description (e.g. -1, 'day' -> 'yesterday' or 'il y a 1 jour') +pre-bound to the active locale and backed by a globally memoized Intl.RelativeTimeFormat instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • unit: RelativeTimeFormatUnit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: RelativeTimeFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a globally memoized native Intl.RelativeTimeFormat instance pre-bound to the active locale.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optionaloptions: RelativeTimeFormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns RelativeTimeFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.TypeValueMap.html b/packages/tempo/public/v4/api/library/interfaces/common.index.TypeValueMap.html new file mode 100644 index 00000000..a6c1cad3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.TypeValueMap.html @@ -0,0 +1,344 @@ +TypeValueMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interface TypeValueMap<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Augmentable interface mapping type names to their corresponding TypeValue structure. +Used by the runtime type inspection system to provide strongly-typed value extraction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TypeValueMap<T = any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array: { type: "Array"; value: T[] };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ArrayLike: { type: "ArrayLike"; value: ArrayLike<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AsyncFunction: { type: "AsyncFunction"; value: Function };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AsyncGeneratorFunction: { type: "AsyncGeneratorFunction"; value: Function };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BigInt: { type: "BigInt"; value: bigint };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Blob: { type: "Blob"; value: Blob };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Boolean: { type: "Boolean"; value: boolean };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Class: { type: "Class"; value: T };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Date: { type: "Date"; value: Date };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Empty: { type: "Empty"; value: unknown };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enumify: { type: "Enumify"; value: wrap<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error: { type: "Error"; value: Error };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function: { type: "Function"; value: Function };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GeneratorFunction: { type: "GeneratorFunction"; value: Function };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Map: { type: "Map"; value: Map<any, T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Module: { type: "Module"; value: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Null: { type: "Null"; value: null };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Number: { type: "Number"; value: number };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Object: { type: "Object"; value: Extract<T, Property<unknown>> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pledge: { type: "Pledge"; value: Pledge<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Promise: { type: "Promise"; value: Promise<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Reactive: { type: "Reactive"; value: Reactive<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Reactive.Subscription": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Reactive.Subscription";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: ReactiveSubscription;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RegExp: { type: "RegExp"; value: RegExp };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Set: { type: "Set"; value: Set<T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        String: { type: "String"; value: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Symbol: { type: "Symbol"; value: symbol };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Temporal: { type: "Temporal"; value: Temporals };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.Duration": { type: "Temporal.Duration"; value: Duration };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.DurationLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.DurationLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: DurationLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.Instant": { type: "Temporal.Instant"; value: Instant };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainDate": { type: "Temporal.PlainDate"; value: PlainDate };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainDateLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainDateLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainDateLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainDateTime": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainDateTime";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainMonthDay": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainMonthDay";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainMonthDay;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainMonthDayLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainMonthDayLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainMonthDayLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainTime": { type: "Temporal.PlainTime"; value: PlainTime };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainTimeLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainTimeLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainTimeLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainYearMonth": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainYearMonth";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainYearMonth;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.PlainYearMonthLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.PlainYearMonthLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: PlainYearMonthLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.ZonedDateTime": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.ZonedDateTime";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: ZonedDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "Temporal.ZonedDateTimeLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: "Temporal.ZonedDateTimeLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: ZonedDateTimeLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Undefined: { type: "Undefined"; value: undefined };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Void: { type: "Void"; value: void };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WeakMap: { type: "WeakMap"; value: WeakMap<Property<unknown>, T> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WeakRef: { type: "WeakRef"; value: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WeakSet: { type: "WeakSet"; value: WeakSet<Property<unknown>> };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array +ArrayLike +AsyncFunction +AsyncGeneratorFunction +BigInt +Blob +Boolean +Class +Date +Empty +Enumify +Error +Function +GeneratorFunction +Map +Module +Null +Number +Object +Pledge +Promise +Reactive +Reactive.Subscription +RegExp +Set +String +Symbol +Temporal +Temporal.Duration +Temporal.DurationLike +Temporal.Instant +Temporal.PlainDate +Temporal.PlainDateLike +Temporal.PlainDateTime +Temporal.PlainMonthDay +Temporal.PlainMonthDayLike +Temporal.PlainTime +Temporal.PlainTimeLike +Temporal.PlainYearMonth +Temporal.PlainYearMonthLike +Temporal.ZonedDateTime +Temporal.ZonedDateTimeLike +Undefined +Void +WeakMap +WeakRef +WeakSet +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array: { type: "Array"; value: T[] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ArrayLike: { type: "ArrayLike"; value: ArrayLike<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AsyncFunction: { type: "AsyncFunction"; value: Function }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AsyncGeneratorFunction: { type: "AsyncGeneratorFunction"; value: Function }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BigInt: { type: "BigInt"; value: bigint }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Blob: { type: "Blob"; value: Blob }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Boolean: { type: "Boolean"; value: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Class: { type: "Class"; value: T }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Date: { type: "Date"; value: Date }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Empty: { type: "Empty"; value: unknown }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enumify: { type: "Enumify"; value: wrap<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Error: { type: "Error"; value: Error }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function: { type: "Function"; value: Function }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GeneratorFunction: { type: "GeneratorFunction"; value: Function }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Map: { type: "Map"; value: Map<any, T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Module: { type: "Module"; value: any }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Null: { type: "Null"; value: null }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Number: { type: "Number"; value: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object: { type: "Object"; value: Extract<T, Property<unknown>> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge: { type: "Pledge"; value: Pledge<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Promise: { type: "Promise"; value: Promise<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive: { type: "Reactive"; value: Reactive<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Reactive.Subscription": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Reactive.Subscription";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: ReactiveSubscription;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RegExp: { type: "RegExp"; value: RegExp }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set: { type: "Set"; value: Set<T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String: { type: "String"; value: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbol: { type: "Symbol"; value: symbol }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal: { type: "Temporal"; value: Temporals }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.Duration": { type: "Temporal.Duration"; value: Duration }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.DurationLike": { type: "Temporal.DurationLike"; value: DurationLike }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.Instant": { type: "Temporal.Instant"; value: Instant }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainDate": { type: "Temporal.PlainDate"; value: PlainDate }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainDateLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainDateLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainDateLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainDateTime": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainDateTime";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainMonthDay": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainMonthDay";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainMonthDay;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainMonthDayLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainMonthDayLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainMonthDayLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainTime": { type: "Temporal.PlainTime"; value: PlainTime }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainTimeLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainTimeLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainTimeLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainYearMonth": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainYearMonth";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainYearMonth;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.PlainYearMonthLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.PlainYearMonthLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: PlainYearMonthLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.ZonedDateTime": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.ZonedDateTime";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: ZonedDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Temporal.ZonedDateTimeLike": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: "Temporal.ZonedDateTimeLike";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: ZonedDateTimeLike;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Undefined: { type: "Undefined"; value: undefined }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Void: { type: "Void"; value: void }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WeakMap: { type: "WeakMap"; value: WeakMap<Property<unknown>, T> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WeakRef: { type: "WeakRef"; value: any }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WeakSet: { type: "WeakSet"; value: WeakSet<Property<unknown>> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.UtcParts.html b/packages/tempo/public/v4/api/library/interfaces/common.index.UtcParts.html new file mode 100644 index 00000000..6801d15e --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.UtcParts.html @@ -0,0 +1,102 @@ +UtcParts | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interface UtcParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Structured UTC calendar and clock components.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UtcParts {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          day: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hours: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          milliseconds: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minutes: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          month: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          seconds: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          weekday: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          year: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      day +hours +milliseconds +minutes +month +seconds +weekday +year +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      day: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hours: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      milliseconds: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      minutes: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      month: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      seconds: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      weekday: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      year: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.UtcPartsOptions.html b/packages/tempo/public/v4/api/library/interfaces/common.index.UtcPartsOptions.html new file mode 100644 index 00000000..899e5648 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.UtcPartsOptions.html @@ -0,0 +1,96 @@ +UtcPartsOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interface UtcPartsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Structured calendar and clock options for creating a UTC Date instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UtcPartsOptions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            day: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hours?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            milliseconds?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            minutes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            month: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seconds?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            year: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        day +hours? +milliseconds? +minutes? +month +seconds? +year +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        day: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hours?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        milliseconds?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minutes?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        month: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        seconds?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        year: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/interfaces/common.index.VirtualFileStore.html b/packages/tempo/public/v4/api/library/interfaces/common.index.VirtualFileStore.html new file mode 100644 index 00000000..58c4b6c3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/common.index.VirtualFileStore.html @@ -0,0 +1,173 @@ +VirtualFileStore | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interface VirtualFileStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Universal interface for asynchronous encrypted virtual file operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface VirtualFileStore {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delete(path: string): Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exists(path: string): Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              list(dir?: string): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              read(path: string): Promise<string | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readBuffer(path: string): Promise<Uint8Array<ArrayBufferLike> | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readJSON<T = any>(path: string, fallback?: T): Promise<T | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              write(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content: string | BufferSource | Uint8Array<ArrayBufferLike>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writeJSON(path: string, data: any): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete +exists +list +read +readBuffer +readJSON +write +writeJSON +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<boolean>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionaldir: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<string[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<string | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<Uint8Array<ArrayBufferLike> | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionalfallback: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<T | null>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • content: string | BufferSource | Uint8Array<ArrayBufferLike>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • data: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<void>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/interfaces/server.index.ServerGeolocationResult.html b/packages/tempo/public/v4/api/library/interfaces/server.index.ServerGeolocationResult.html new file mode 100644 index 00000000..39077639 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/server.index.ServerGeolocationResult.html @@ -0,0 +1,111 @@ +ServerGeolocationResult | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interface ServerGeolocationResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServerGeolocationResult {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                city?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                country?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lat?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                latitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lng?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                longitude?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                status?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            city? +country? +error? +lat? +latitude? +lng? +longitude? +query? +status? +timezone? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            city?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            country?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            error?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lat?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            latitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lng?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            longitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            query?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            status?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timezone?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/interfaces/server.index.ServerMapOpts.html b/packages/tempo/public/v4/api/library/interfaces/server.index.ServerMapOpts.html new file mode 100644 index 00000000..3c436464 --- /dev/null +++ b/packages/tempo/public/v4/api/library/interfaces/server.index.ServerMapOpts.html @@ -0,0 +1,81 @@ +ServerMapOpts | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interface ServerMapOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ServerMapOpts {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  catch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  debug?: DebugLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ip?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              catch? +debug? +endpoint? +ip? +timeout? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              catch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              debug?: DebugLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endpoint?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ip?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeout?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/modules.html b/packages/tempo/public/v4/api/library/modules.html new file mode 100644 index 00000000..b67537ff --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules.html @@ -0,0 +1,37 @@ +Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  browser.index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  common.index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  server.index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Modules +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/modules/browser.index.Tapper.html b/packages/tempo/public/v4/api/library/modules/browser.index.Tapper.html new file mode 100644 index 00000000..3c765541 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/browser.index.Tapper.html @@ -0,0 +1,46 @@ +Tapper | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespace Tapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespace containing type definitions for the Tapper touch gesture handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Callback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EVENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EVENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variables +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/modules/browser.index.html b/packages/tempo/public/v4/api/library/modules/browser.index.html new file mode 100644 index 00000000..e9eaa141 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/browser.index.html @@ -0,0 +1,46 @@ +browser.index | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Module browser.index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tapper
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tapper
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WebStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alert
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      confirm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      geoCoords
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      geoLocation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getOPFSRoot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isOPFSSupported
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mapAddress
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mapHemisphere
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mapQuery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsDelete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsExists
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsRead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsReadBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsReadJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsWrite
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opfsWriteJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prompt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Namespaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Classes +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Functions +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/modules/common.index.Enum.html b/packages/tempo/public/v4/api/library/modules/common.index.Enum.html new file mode 100644 index 00000000..0cc70157 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/common.index.Enum.html @@ -0,0 +1,42 @@ +Enum | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespace Enum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace for Enum type-helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        methods
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        props
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/modules/common.index.Pledge.html b/packages/tempo/public/v4/api/library/modules/common.index.Pledge.html new file mode 100644 index 00000000..84e8fe6a --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/common.index.Pledge.html @@ -0,0 +1,46 @@ +Pledge | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Namespace Pledge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Namespace containing type definitions and configuration for the Pledge class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Constructor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Reject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Resolve
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/modules/common.index.Reactive.html b/packages/tempo/public/v4/api/library/modules/common.index.Reactive.html new file mode 100644 index 00000000..866feeb6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/common.index.Reactive.html @@ -0,0 +1,50 @@ +Reactive | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Namespace Reactive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unified namespace for Reactive types and options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            State
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SubscriptionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            EndListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ErrorListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            EventType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Listener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Subscription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Subscription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variables +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/modules/common.index.html b/packages/tempo/public/v4/api/library/modules/common.index.html new file mode 100644 index 00000000..fe28c409 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/common.index.html @@ -0,0 +1,58 @@ +common.index | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Module common.index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pledge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Reactive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Aborter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BoundedCache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enumify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Finalizer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HttpError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interval
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Logger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pledge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Reactive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ScopedSet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WeakCache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BoundaryContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CoordinateInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CronField
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CronSchedule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FileStoreOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GeoConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GeoLookupResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GeoOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GeoProvider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IgnoreOfMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JSONCOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JWSHeader
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JWSHMACHeader
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JWTComponents
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LocaleWeekInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ObjectifyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ParsedRRule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ParseJWTOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolvedCoordinates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolvedLocaleInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SecureArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ServerStorageOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SingletonOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SortBy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StringifyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SubsecondParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TempoIntlNamespace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TypeValueMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UtcParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UtcPartsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VirtualFileStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AssertEqual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AsyncEvaluable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AsyncEvaluableRecord
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AsyncEvaluated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BinaryData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branded
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Constructor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CONTEXT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CountOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DayKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DayMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DayValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DebugLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EmptyObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Entries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Entry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EntryOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EnumifyType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EnumMethodExclusions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EnumMethodKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EnumMethods
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Evaluable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              EvaluableRecord
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Evaluated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Extend
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GeoSphere
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GuardTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HMACAlgorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HTTP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IgnoreOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IntRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Inverse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Invert
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsoWeekdayName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsoWeekdayNames
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsoWeekdayNumber
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JSONCReviver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JWSAlgorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              KeyOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LibrarySymbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LiteralKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LocaleInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LOG
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LogLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LooseKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LooseSymbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LooseUnion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MaxLength
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MinLength
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MonthKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MonthMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MonthValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MutableCondition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MutableObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NonOptional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nullable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nullish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OneKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OwnOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ParseInt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Plural
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Primitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Primitives
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Property
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ProxyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RegistryOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Resolved
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolveTypeGuard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolveTypeGuards
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolveTypeTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Reverse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RS256Algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SecureObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Singular
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SingularUnit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Substring
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TemporalObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TemporalPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Temporals
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TimeZoneInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TValues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TypeofMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TypeofTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TypeValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnionToTuple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnsafeKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UtcDateOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ValueOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WellKnownSymbols
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Discover
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Extensible
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Inspect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $LogConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Mutable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Register
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $SerializerRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Unwrapped
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              canonicalLocales
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CONTEXT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createEncryptedFileStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DAY_MAP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DAYS_IN_WEEK
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDateTimeFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getHemisphere
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HTTP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ISO_WEEKDAY_NAMES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LOG
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              METHOD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MONTH_MAP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nodeStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOOP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              probeMDY
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_BASE64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_BASE64URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_BIGINT_LITERAL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_COMBINING_MARKS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_DIGITS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_FILE_URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_HEX
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_HEX_8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_HTTP_URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_INTEGER
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_REGEXP_LITERAL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_UUID
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_WHITESPACE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_WHITESPACES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sym
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TIMEOUT_MAX
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addUtcDays
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allDescriptors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              anySignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asInteger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asNumber
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertCondition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertNever
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asText
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              base64ToBase64Url
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              base64ToBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              base64UrlToBase64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              base64UrlToBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bufferToBase64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bufferToBase64Url
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              byKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              byLkp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cartesian
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cast
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cleanify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cleanupSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clearCache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clearStashedGeo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clearStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cloneify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              coerceGeo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              conceal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              countProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createMemoryStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              curry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decodeBase64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decodeBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decrypt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decryptWithPassword
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deepFreeze
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deepMerge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delegate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delegator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              distinct
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dynamicProxy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encodeBase64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encodeBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encodeText
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encrypt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encryptWithPassword
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ephemeral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              epoch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluateAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluateConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluateConfigAsync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluateString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              evaluateWith
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exclude
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              expandRRuleEpochs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exportJWK
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extend
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extract
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fastDigest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fetchHead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fetchRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileDelete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileExists
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileRead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileReadBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileReadJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileWrite
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fileWriteJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatCurrency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatDayPeriod
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatDuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatNumber
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              formatUnit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forwardGeocode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fromIsoWeek
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fromRoman
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fromUtcParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              generateKeyPair
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              geoLookup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getAccessors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getCaller
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDaysInMonth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getFileStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getGeoProvider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getIsoWeek
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getISOWeekOfYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getLanguage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getLocaleWeekOfYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMemoryStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMethods
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getNextCronEpoch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getNextRRuleEpoch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getNextScheduleEpoch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getOffsets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPrevCronEpoch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getRelativeTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSafeStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSafeTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getScript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSpatialCacheKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSpatialReverseCache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getStashedGeo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getTemporalIds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getUtcParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasAnyOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasNoneOf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasOwn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hmac
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ifDefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ifNumeric
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Immutable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              importJWK
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              importPrivateKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              importPublicKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              indexedArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              instant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAbortController
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAbortSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isArrayLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBase64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBase64Url
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBoolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isCallable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isClass
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isCronString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDigit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDigits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDST
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDurationLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEmpty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnglish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnum
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEqual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isExtensible
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFileUrl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFiniteRRule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isHex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isHttpUrl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isInstant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isInteger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isIntegerLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isIterable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLeapYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLocale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNull
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNullish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNumber
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNumeric
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isolateBidi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainDate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainMonthDay
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlainYearMonth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPledge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPrimitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPromise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPropertyKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRawJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReference
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRegExp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRegExpLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRRuleString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSafeKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isScheduleString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSymbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSymbolFor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTemporal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTestEnvironment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isText
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isUndefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isUuid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isValidDate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isWhitespace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isZonedDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isZonedDateTimeLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lazyMethod
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              localizeDigits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              looseIndex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              makeTemplate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              markConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              markExtensible
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              memoizeFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              memoizeMethod
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Mutable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              normaliseFractionalDurations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              normalizeUtcOffset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nullishToEmpty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nullishToValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nullishToZero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              objectify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              omit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAbort
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ownEntries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ownKeys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ownValues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pad
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              padString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              padTo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseCron
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseJSONC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseJWT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseLogLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseRRule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pluck
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              plural
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protoType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              proxify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              purge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              raise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              randomKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              randomString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rawJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              registerSerializable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              registerType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resetRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveDayOfYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveFractionalSeconds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveGeoCoordinates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveIsoCalendarYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveLocale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolveTwoDigitYear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reveal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverseGeocode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              revocable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Securable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              secure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              secureRef
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              selStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Serializable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setAccessors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setGeoProvider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setStorage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sign
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signHmac
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signJWS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Singleton
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              singular
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sleep
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sortBy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sortInsert
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sortKey
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              split
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sprintf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stashGeo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Static
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StringTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stripJSONC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              strlen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              suffix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeoutSignal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timingSafeEqual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toBase64Url
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toCamelCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toHex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toInstant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toLower
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toPlainDate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toProperCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toRoman
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toTitleCase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toUpper
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toZonedDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trimAll
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unQuoteObj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unwrap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verifyData
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verifyHmac
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verifyJWS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              withUtcParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Namespaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Classes +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AssertEqualAsyncEvaluableAsyncEvaluableRecordAsyncEvaluatedBinaryDataBrandedCastConstructorCONTEXTCountOfDayKeyDayMapDayValueDebugLevelEmptyObjectEntriesEntryEntryOfEnumifyTypeEnumMethodExclusionsEnumMethodKeysEnumMethodsEvaluableEvaluableRecordEvaluatedExtendGeoSphereGetTypeGuardTagHMACAlgorithmHTTPIgnoreOfIndexInRangeInstanceIntRangeInverseInvertIsoWeekdayNameIsoWeekdayNamesIsoWeekdayNumberJSONCReviverJWSAlgorithmKeyOfLibrarySymbolLiteralKeyLocaleInputLOGLogLevelLooseKeyLooseSymbolLooseUnionMaxLengthMinLengthMonthKeyMonthMapMonthValueMutableConditionMutableObjectNonOptionalNullableNullishObjOneKeyOptionalOwnOfParseIntPluralPrimitivePrimitivesPropertyProxyOptionsRegistryOptionResolvedResolveTypeGuardResolveTypeGuardsResolveTypeTagReverseRS256AlgorithmSecureSecureObjectSingularSingularUnitSubstringTArrayTemporalObjectTemporalPointTemporalsTimeZoneInputTValueTValuesTypeTypeofMapTypeofTagTypeValueUnionToTupleUnsafeKeyUtcDateOptionsValueOfWellKnownSymbols
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variables +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Functions +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addUtcDaysallDescriptorsallObjectanySignalasArrayasErrorasIntegerasNumberasObjectassertConditionassertNeverassertStringasStringasTextasTimeasTypebase64ToBase64Urlbase64ToBufferbase64UrlToBase64base64UrlToBufferbufferToBase64bufferToBase64UrlbyKeybyLkpcartesiancastcleanifycleanupSignalclearclearCacheclearStashedGeoclearStorageclonecloneifycoerceGeoconcealcountPropertiescreateMemoryStoragecurrydecodeBase64decodeBufferdecryptdecryptWithPassworddeepFreezedeepMergedelegatedelegatordistinctdynamicProxyencodeBase64encodeBufferencodeTextencryptencryptWithPasswordenumifyephemeralepochevaluateevaluateAsyncevaluateConfigevaluateConfigAsyncevaluateStringevaluateWithexcludeexpandRRuleEpochsexportJWKextendextractfastDigestfetchHeadfetchRequestfileDeletefileExistsfileListfileReadfileReadBufferfileReadJSONfileWritefileWriteJSONfixformatCurrencyformatDayPeriodformatDurationformatListformatNumberformatUnitforwardGeocodefromIsoWeekfromRomanfromUtcPartsgenerateKeyPairgeoLookupgetAccessorsgetCallergetContextgetDaysInMonthgetFileStoregetGeoProvidergetIsoWeekgetISOWeekOfYeargetLanguagegetLocaleWeekOfYeargetMemoryStoragegetMethodsgetNextCronEpochgetNextRRuleEpochgetNextScheduleEpochgetOffsetsgetPrevCronEpochgetRelativeTimegetSafeStoragegetSafeTaggetScriptgetSpatialCacheKeygetSpatialReverseCachegetStashedGeogetStoragegetTemporalIdsgetTypegetUtcPartshasAnyOfhashhasKeyhasKeyshasNoneOfhasOwnhmacifDefinedifNumericImmutableimportJWKimportPrivateKeyimportPublicKeyindexedArrayinstantisAbortControllerisAbortSignalisArrayisArrayLikeisBase64isBase64UrlisBooleanisCallableisClassisCronStringisDateisDefinedisDigitisDigitsisDSTisDurationisDurationLikeisEmptyisEnglishisEnumisEqualisErrorisExtensibleisFileUrlisFiniteRRuleisFunctionisHexisHttpUrlisInstantisIntegerisIntegerLikeisIterableisJSONisLeapYearisLocaleisMapisNullisNullishisNumberisNumericisObjectisolateBidiisPlainDateisPlainDateTimeisPlainMonthDayisPlainObjectisPlainTimeisPlainYearMonthisPledgeisPrimitiveisPromiseisPropertyKeyisRawJSONisReferenceisRegExpisRegExpLikeisRRuleStringisSafeKeyisScheduleStringisSetisStringisSymbolisSymbolForisTargetisTemporalisTestEnvironmentisTextisTypeisUndefinedisUuidisValidDateisWhitespaceisZonedDateTimeisZonedDateTimeLikelazyMethodlocalizeDigitslooseIndexmakeTemplatemarkConfigmarkExtensiblememoizeFunctionmemoizeMethodMutablenormaliseFractionalDurationsnormalizeUtcOffsetnullishToEmptynullishToValuenullishToZeroobjectifyomitonAbortownEntriesownKeysownValuespadpadStringpadToparseCronparseJSONCparseJWTparseLogLevelparseRRulepickpluckpluralprotoTypeproxifypurgeraiserandomKeyrandomStringrawJSONregisterSerializableregisterTyperesetresetRegistryresolveDayOfYearresolveFractionalSecondsresolveGeoCoordinatesresolveIsoCalendarYearresolveLocaleresolveTwoDigitYearrevealreverseGeocoderevocableSecurablesecuresecureRefselStorageSerializablesetAccessorssetGeoProvidersetStoragesignsignDatasignHmacsignJWSSingletonsingularsleepsortBysortInsertsortKeysplitsprintfstashGeoStaticstringifyStringTagstripJSONCstrlensuffixtaptimeoutSignaltimingSafeEqualtoBase64UrltoCamelCasetodaytoHextoInstanttoLowertoPlainDatetoProperCasetoRomantoTitleCasetoUppertoZonedDateTimetrimAllunixunQuoteObjunwrapverifyverifyDataverifyHmacverifyJWSwhenwithUtcParts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/modules/server.index.html b/packages/tempo/public/v4/api/library/modules/server.index.html new file mode 100644 index 00000000..3a0c7a82 --- /dev/null +++ b/packages/tempo/public/v4/api/library/modules/server.index.html @@ -0,0 +1,46 @@ +server.index | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Module server.index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ServerGeolocationResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ServerMapOpts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverDelete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverExists
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverGeoCoords
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverGeoLocation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverMapHemisphere
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverRead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverReadBuffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverReadJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverWrite
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serverWriteJSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Classes +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Functions +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Callback.html b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Callback.html new file mode 100644 index 00000000..951d0043 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Callback.html @@ -0,0 +1,57 @@ +Callback | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Callback: (evt: HammerInput) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Callback = (evt: HammerInput) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • (evt: HammerInput): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • evt: HammerInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/browser.index.Tapper.EVENT.html b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.EVENT.html new file mode 100644 index 00000000..1967e8c6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.EVENT.html @@ -0,0 +1,46 @@ +EVENT | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias EVENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EVENT: ValueOf<typeof Tapper.EVENT>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EVENT = "singleTap" | "doubleTap" | "tripleTap"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Tuple.html b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Tuple.html new file mode 100644 index 00000000..e81e500b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/browser.index.Tapper.Tuple.html @@ -0,0 +1,45 @@ +Tuple | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Tuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tuple: [Tapper.EVENT, Callback]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Tuple = ["singleTap" | "doubleTap" | "tripleTap", Callback]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.AssertEqual.html b/packages/tempo/public/v4/api/library/types/common.index.AssertEqual.html new file mode 100644 index 00000000..9c8fd583 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.AssertEqual.html @@ -0,0 +1,51 @@ +AssertEqual | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias AssertEqual<A, B>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AssertEqual: [A] extends [B] ? [B] extends [A] ? true : false : false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AssertEqual<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Compile-time type equality assertion utility for testing type equivalence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluable.html b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluable.html new file mode 100644 index 00000000..009e9c7f --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluable.html @@ -0,0 +1,50 @@ +AsyncEvaluable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias AsyncEvaluable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AsyncEvaluable: T | PromiseLike<T> | (() => T | PromiseLike<T>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AsyncEvaluable<T> = T | PromiseLike<T> | (() => T | PromiseLike<T>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Represents a value that can either be a direct scalar, a Promise, a thenable (such as Pledge), a synchronous supplier function, or an asynchronous supplier function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluableRecord.html b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluableRecord.html new file mode 100644 index 00000000..2258c481 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluableRecord.html @@ -0,0 +1,50 @@ +AsyncEvaluableRecord | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias AsyncEvaluableRecord<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AsyncEvaluableRecord: { [K in keyof T]: AsyncEvaluable<T[K]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AsyncEvaluableRecord<T> = { [K in keyof T]: AsyncEvaluable<T[K]>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Maps an object type so that each property value can be provided as an AsyncEvaluable<T>.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluated.html b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluated.html new file mode 100644 index 00000000..6d541b37 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.AsyncEvaluated.html @@ -0,0 +1,50 @@ +AsyncEvaluated | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias AsyncEvaluated<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AsyncEvaluated: { [K in keyof T]: Resolved<T[K]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AsyncEvaluated<T> = { [K in keyof T]: Resolved<T[K]>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Unwraps an object's asynchronous evaluable properties to their resolved values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.BinaryData.html b/packages/tempo/public/v4/api/library/types/common.index.BinaryData.html new file mode 100644 index 00000000..dd16e2cb --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.BinaryData.html @@ -0,0 +1,44 @@ +BinaryData | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias BinaryData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BinaryData: BufferSource | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BinaryData = BufferSource | Uint8Array<ArrayBufferLike>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.Branded.html b/packages/tempo/public/v4/api/library/types/common.index.Branded.html new file mode 100644 index 00000000..438cb4c4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Branded.html @@ -0,0 +1,51 @@ +Branded | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Branded<T, B>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branded: T & Brand<B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Branded<T, B> = T & Brand<B>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type utility for creating branded types that are nominally distinct from their base type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.CONTEXT.html b/packages/tempo/public/v4/api/library/types/common.index.CONTEXT.html new file mode 100644 index 00000000..bbc67f73 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.CONTEXT.html @@ -0,0 +1,47 @@ +CONTEXT | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias CONTEXT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CONTEXT: ValueOf<typeof CONTEXT>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CONTEXT = "unknown" | "browser" | "web-worker" | "nodejs" | "deno" | "google-apps-script"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type representing a JavaScript runtime context value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Cast.html b/packages/tempo/public/v4/api/library/types/common.index.Cast.html new file mode 100644 index 00000000..65e95b78 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Cast.html @@ -0,0 +1,51 @@ +Cast | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Cast<T, Target>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Cast: T extends Target ? T : Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Cast<T, Target> = T extends Target ? T : Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type-level cast: if T satisfies Target, resolves to T, otherwise forces Target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Constructor.html b/packages/tempo/public/v4/api/library/types/common.index.Constructor.html new file mode 100644 index 00000000..b7f74cf8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Constructor.html @@ -0,0 +1,50 @@ +Constructor | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Constructor<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Constructor: new (...args: any[]) => T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Constructor = { tag?: string | undefined; onResolve?: Pledge.Resolve | Pledge.Resolve[] | undefined; onReject?: Pledge.Reject | Pledge.Reject[] | undefined; onSettle?: Pledge.Settle | Pledge.Settle[] | undefined; debug?: DebugLevel; catch?: boolean; silent?: boolean; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Generic constructor type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.CountOf.html b/packages/tempo/public/v4/api/library/types/common.index.CountOf.html new file mode 100644 index 00000000..2b7e3339 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.CountOf.html @@ -0,0 +1,50 @@ +CountOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias CountOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CountOf: SafeCount<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CountOf<T> = 0 extends 1 & T ? number : [T] extends [never] ? 0 : 0 extends 1 & Exclude<T, LastInUnion<T>> ? number : [Exclude<T, LastInUnion<T>>] extends [never] ? 1 : 0 extends 1 & Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>> ? number : [Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>] extends [never] ? 2 : 0 extends 1 & Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>> ? number : [Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>] extends [never] ? 3 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>] extends [never] ? 4 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>] extends [never] ? 5 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>] extends [never] ? 6 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>] extends [never] ? 7 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>] extends [never] ? 8 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>>] extends [never] ? 9 : 0 extends 1 & Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>>>> ? number : [Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>, LastInUnion<Exclude<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>, LastInUnion<Exclude<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>, LastInUnion<Exclude<Exclude<T, LastInUnion<T>>, LastInUnion<Exclude<T, LastInUnion<T>>>>>>>>>>>>>>>>>>>>] extends [never] ? 10 : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Computes the union-member cardinality of type T, with numeric fallback for non-unions or deep recursion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.DayKey.html b/packages/tempo/public/v4/api/library/types/common.index.DayKey.html new file mode 100644 index 00000000..81cdb2fb --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.DayKey.html @@ -0,0 +1,46 @@ +DayKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias DayKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DayKey: keyof DayMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DayKey = "MO" | "TU" | "WE" | "TH" | "FR" | "SA" | "SU" | "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT" | "SUN"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Union type of all valid 2-letter and 3-letter day abbreviation keys ('MO' | 'TU' | ... | 'SUN').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.DayMap.html b/packages/tempo/public/v4/api/library/types/common.index.DayMap.html new file mode 100644 index 00000000..7dfec1ab --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.DayMap.html @@ -0,0 +1,46 @@ +DayMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias DayMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DayMap: typeof DAY_MAP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DayMap = { readonly MO: 1; readonly TU: 2; readonly WE: 3; readonly TH: 4; readonly FR: 5; readonly SA: 6; readonly SU: 7; readonly MON: 1; readonly TUE: 2; readonly WED: 3; readonly THU: 4; readonly FRI: 5; readonly SAT: 6; readonly SUN: 7; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type representing the DAY_MAP mapping structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.DayValue.html b/packages/tempo/public/v4/api/library/types/common.index.DayValue.html new file mode 100644 index 00000000..40f64cac --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.DayValue.html @@ -0,0 +1,46 @@ +DayValue | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias DayValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DayValue: DayMap[DayKey]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DayValue = 1 | 2 | 3 | 4 | 5 | 6 | 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Union type of all valid ISO weekday numeric values (1..7).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.DebugLevel.html b/packages/tempo/public/v4/api/library/types/common.index.DebugLevel.html new file mode 100644 index 00000000..891fbbdf --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.DebugLevel.html @@ -0,0 +1,46 @@ +DebugLevel | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias DebugLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DebugLevel: LOG | Method
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DebugLevel = 0 | 1 | 2 | 3 | 4 | 5 | "off" | "log" | "info" | "warn" | "debug" | "trace" | "error"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type representing any valid debug level specification (numeric or method string).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.EmptyObject.html b/packages/tempo/public/v4/api/library/types/common.index.EmptyObject.html new file mode 100644 index 00000000..c1113596 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EmptyObject.html @@ -0,0 +1,69 @@ +EmptyObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias EmptyObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type representing a JSON object with no own properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EmptyObject = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "[___brand]"?: never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EmptyObject = { [__brand]?: never; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [___brand]? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Optional[___brand]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "[___brand]"?: never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Entries.html b/packages/tempo/public/v4/api/library/types/common.index.Entries.html new file mode 100644 index 00000000..e241c279 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Entries.html @@ -0,0 +1,50 @@ +Entries | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Entries<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Entries: ReadonlyArray<Entry<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Entries<T> = readonly Entry<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Object.entries<T> as [number,T][]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Entry.html b/packages/tempo/public/v4/api/library/types/common.index.Entry.html new file mode 100644 index 00000000..a2caa933 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Entry.html @@ -0,0 +1,50 @@ +Entry | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Entry<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Entry: T extends readonly [unknown, ...unknown[]]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? TupleEntry<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : T extends ReadonlyArray<infer U> ? [`${number}`, U] : ObjectEntry<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Entry<T> = T extends readonly [unknown, ...unknown[]] ? TupleEntry<T, [], never> : T extends readonly (infer U)[] ? [`${number}`, U] : ObjectEntry<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if T extends readonly[] => [number, T], if T extends {} => [key:string, T]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.EntryOf.html b/packages/tempo/public/v4/api/library/types/common.index.EntryOf.html new file mode 100644 index 00000000..c29f8dcf --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EntryOf.html @@ -0,0 +1,50 @@ +EntryOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias EntryOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EntryOf: T extends readonly any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ? [number, T[number]]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : { [K in KeyOf<T> & PropertyKey]-?: [K, T[K & keyof T]] }[KeyOf<T> & PropertyKey]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EntryOf<T> = T extends readonly any[] ? [number, T[number]] : { [K in KeyOf<T> & PropertyKey]-?: [K, T[K & keyof T]]; }[KeyOf<T> & PropertyKey]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Constructs a correlated tuple union representing a key-value entry pair from an object, enum, or array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T extends Obj | readonly any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.Enum.methods.html b/packages/tempo/public/v4/api/library/types/common.index.Enum.methods.html new file mode 100644 index 00000000..0ab50f22 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Enum.methods.html @@ -0,0 +1,51 @@ +methods | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias methods<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            methods: keyof EnumifyType<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type methods<T> = string | number | symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum methods (filtered)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Enum.props.html b/packages/tempo/public/v4/api/library/types/common.index.Enum.props.html new file mode 100644 index 00000000..92bb35ba --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Enum.props.html @@ -0,0 +1,51 @@ +props | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias props<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              props: Readonly<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type props<T> = { readonly [P in keyof T]: T[P]; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum own properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.Enum.wrap.html b/packages/tempo/public/v4/api/library/types/common.index.Enum.wrap.html new file mode 100644 index 00000000..935deec5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Enum.wrap.html @@ -0,0 +1,51 @@ +wrap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias wrap<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wrap: T extends Property<any> ? EnumifyType<T> : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type wrap<T> = T extends Property<any> ? EnumifyType<T> : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum properties & methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.EnumMethodExclusions.html b/packages/tempo/public/v4/api/library/types/common.index.EnumMethodExclusions.html new file mode 100644 index 00000000..eac8328e --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EnumMethodExclusions.html @@ -0,0 +1,46 @@ +EnumMethodExclusions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias EnumMethodExclusions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EnumMethodExclusions: WellKnownSymbols | EnumMethodKeys | keyof IgnoreOfMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnumMethodExclusions = unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | "count" | "keys" | "values" | "entries" | "invert" | "has" | "hasOwn" | "get" | "includes" | "keyOf" | "forEach" | "filter" | "map" | "extend"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Exclusions specific to Enumify proxy objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.EnumMethodKeys.html b/packages/tempo/public/v4/api/library/types/common.index.EnumMethodKeys.html new file mode 100644 index 00000000..bbab8944 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EnumMethodKeys.html @@ -0,0 +1,46 @@ +EnumMethodKeys | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias EnumMethodKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnumMethodKeys:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "count"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "keys"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "values"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "entries"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "invert"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "has"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "hasOwn"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "get"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "includes"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "keyOf"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "forEach"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "filter"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "map"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | "extend"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EnumMethodKeys = "count" | "keys" | "values" | "entries" | "invert" | "has" | "hasOwn" | "get" | "includes" | "keyOf" | "forEach" | "filter" | "map" | "extend"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard methods attached to enumify / EnumifyType proxies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.EnumMethods.html b/packages/tempo/public/v4/api/library/types/common.index.EnumMethods.html new file mode 100644 index 00000000..0c998c7b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EnumMethods.html @@ -0,0 +1,337 @@ +EnumMethods | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias EnumMethods<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnumMethods<T extends Property<any> = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[iterator]": () => IterableIterator<readonly [KeyOf<T>, ValueOf<T>]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[toStringTag]": "Enumify";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count(): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entries(): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extend<const E extends any[] | Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              list: E,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              frozen?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): EnumifyType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): EnumifyType<Partial<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forEach(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get(key: string | number | symbol | KeyOf<T>): ValueOf<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          has(key: LooseKey<KeyOf<T>>): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasOwn(key: string | number | symbol | KeyOf<T>): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes(search: LooseKey<ValueOf<T>>): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          invert(): Readonly<Invert<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keyOf(search: LooseKey<ValueOf<T>>): KeyOf<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keys(): readonly KeyOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          map(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              thisArg?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): EnumifyType<Property<any>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          values(): readonly ValueOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnumMethods<T> = { count(): number; keys(): readonly KeyOf<T>[]; values(): readonly ValueOf<T>[]; entries(): readonly (readonly [KeyOf<T>, ValueOf<T>])[]; invert(): Readonly<Invert<T>>; has(key: LooseKey<KeyOf<T>>): boolean; hasOwn(key: LooseKey<KeyOf<T>> | PropertyKey): boolean; get(key: LooseKey<KeyOf<T>> | PropertyKey): ValueOf<T> | undefined; includes(search: LooseKey<ValueOf<T>>): boolean; keyOf(search: LooseKey<ValueOf<T>>): KeyOf<T>; forEach(fn: (entry: readonly [KeyOf<T>, ValueOf<T>], index: number, enumify: EnumifyType<any>) => void, thisArg?: any): void; filter(fn: (entry: readonly [KeyOf<T>, ValueOf<T>], index: number, enumify: EnumifyType<any>) => boolean, thisArg?: any): EnumifyType<Partial<T>>; map(fn: (entry: readonly [KeyOf<T>, ValueOf<T>], index: number, enumify: EnumifyType<any>) => any, thisArg?: any): EnumifyType<Property<any>>; extend<const E extends any[] | Property<any>>(list: E, frozen?: boolean): EnumifyType<any>; readonly [Symbol.iterator]: () => IterableIterator<readonly [KeyOf<T>, ValueOf<T>]>; readonly [Symbol.toStringTag]: "Enumify"; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hierarchy (View Summary)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [iterator] +[toStringTag] +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count +entries +extend +filter +forEach +get +has +hasOwn +includes +invert +keyOf +keys +map +values +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "[iterator]": () => IterableIterator<readonly [KeyOf<T>, ValueOf<T>]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iterate through all Enum entries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "[toStringTag]": "Enumify"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      used to identify the Enumify type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.count(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns readonly (readonly [KeyOf<T>, ValueOf<T>])[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • list: E
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Optionalfrozen: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns EnumifyType<any>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.extend(enumObj, list) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns EnumifyType<Partial<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Iterate over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • key: string | number | symbol | KeyOf<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns ValueOf<T> | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.get(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.has(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • key: string | number | symbol | KeyOf<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.hasOwn(enumObj, key) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.includes(enumObj, search) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns Readonly<Invert<T>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.invert(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns KeyOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.keyOf(enumObj, search) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns readonly KeyOf<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.keys(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entry: readonly [KeyOf<T>, ValueOf<T>],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumify: EnumifyType<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • OptionalthisArg: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns EnumifyType<Property<any>>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Map over Enum.entries(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns readonly ValueOf<T>[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use Enum.values(enumObj) instead. Prototype methods will be removed in v5.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Methods +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.EnumifyType.html b/packages/tempo/public/v4/api/library/types/common.index.EnumifyType.html new file mode 100644 index 00000000..2cc61426 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EnumifyType.html @@ -0,0 +1,50 @@ +EnumifyType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias EnumifyType<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EnumifyType: Readonly<T> & Omit<EnumMethods<T>, keyof T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnumifyType<T> = Readonly<T> & Omit<EnumMethods<T>, keyof T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum properties & methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.Evaluable.html b/packages/tempo/public/v4/api/library/types/common.index.Evaluable.html new file mode 100644 index 00000000..d1fffac9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Evaluable.html @@ -0,0 +1,50 @@ +Evaluable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Evaluable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Evaluable: T | (() => T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Evaluable<T> = T | (() => T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Represents a value that can either be a direct scalar or a synchronous supplier function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.EvaluableRecord.html b/packages/tempo/public/v4/api/library/types/common.index.EvaluableRecord.html new file mode 100644 index 00000000..45e620ec --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.EvaluableRecord.html @@ -0,0 +1,50 @@ +EvaluableRecord | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias EvaluableRecord<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            EvaluableRecord: { [K in keyof T]: Evaluable<T[K]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EvaluableRecord<T> = { [K in keyof T]: Evaluable<T[K]>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Maps an object type so that each property value can be provided as an Evaluable<T>.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Evaluated.html b/packages/tempo/public/v4/api/library/types/common.index.Evaluated.html new file mode 100644 index 00000000..1d40853d --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Evaluated.html @@ -0,0 +1,50 @@ +Evaluated | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Evaluated<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Evaluated: { [K in keyof T]: T[K] extends () => infer R ? R : T[K] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Evaluated<T> = { [K in keyof T]: T[K] extends () => infer R ? R : T[K]; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Unwraps an object's evaluable properties to their synchronously evaluated values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.Extend.html b/packages/tempo/public/v4/api/library/types/common.index.Extend.html new file mode 100644 index 00000000..5847431b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Extend.html @@ -0,0 +1,52 @@ +Extend | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Extend<T, K, V>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Extend: T & { [P in K]: V }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Extend<T, K, V> = T & { [P in K]: V; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Extend an object with a generic-signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • K extends PropertyKey = string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • V = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.GeoSphere.html b/packages/tempo/public/v4/api/library/types/common.index.GeoSphere.html new file mode 100644 index 00000000..78496ac2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.GeoSphere.html @@ -0,0 +1,46 @@ +GeoSphere | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias GeoSphere

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GeoSphere: "north" | "south" | "equator"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GeoSphere = "north" | "south" | "equator"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Supported hemisphere zones including the equatorial band.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.GetType.html b/packages/tempo/public/v4/api/library/types/common.index.GetType.html new file mode 100644 index 00000000..c752aecf --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.GetType.html @@ -0,0 +1,51 @@ +GetType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias GetType<K, T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetType: K extends keyof TypeValueMap<T> ? TypeValueMap<T>[K]["value"] : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetType<K, T> = K extends keyof TypeValueMap<T> ? TypeValueMap<T>[K]["value"] : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    late-binding Type utility for augmented modules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • K extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.GuardTag.html b/packages/tempo/public/v4/api/library/types/common.index.GuardTag.html new file mode 100644 index 00000000..58afb1c0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.GuardTag.html @@ -0,0 +1,46 @@ +GuardTag | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias GuardTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GuardTag: TypeofTag | Capitalize<TypeofTag> | Uppercase<TypeofTag> | "BigInt"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GuardTag = TypeofTag | "String" | "Number" | "Bigint" | "Boolean" | "Symbol" | "Undefined" | "Object" | "Function" | "Array" | "Null" | "Any" | "Unknown" | "STRING" | "NUMBER" | "BIGINT" | "BOOLEAN" | "SYMBOL" | "UNDEFINED" | "OBJECT" | "FUNCTION" | "ARRAY" | "NULL" | "ANY" | "UNKNOWN" | "BigInt"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Supported type guard tags including case-insensitive variants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.HMACAlgorithm.html b/packages/tempo/public/v4/api/library/types/common.index.HMACAlgorithm.html new file mode 100644 index 00000000..ff47a923 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.HMACAlgorithm.html @@ -0,0 +1,44 @@ +HMACAlgorithm | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias HMACAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HMACAlgorithm: "HS256" | "HS384" | "HS512"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HMACAlgorithm = "HS256" | "HS384" | "HS512"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.HTTP.html b/packages/tempo/public/v4/api/library/types/common.index.HTTP.html new file mode 100644 index 00000000..870f7c87 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.HTTP.html @@ -0,0 +1,47 @@ +HTTP | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias HTTP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HTTP: ValueOf<typeof HTTP>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HTTP = 200 | 301 | 302 | 400 | 401 | 403
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type representing an HTTP status code value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.IgnoreOf.html b/packages/tempo/public/v4/api/library/types/common.index.IgnoreOf.html new file mode 100644 index 00000000..b26bf2b2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.IgnoreOf.html @@ -0,0 +1,50 @@ +IgnoreOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias IgnoreOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IgnoreOf: IsEnumProxy<T> extends true ? EnumMethodExclusions : WellKnownSymbols
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IgnoreOf<T> = IsEnumProxy<T> extends true ? EnumMethodExclusions : WellKnownSymbols
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dynamic ignore type: strips Enum methods for enum proxies, but only symbols for ordinary objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.InRange.html b/packages/tempo/public/v4/api/library/types/common.index.InRange.html new file mode 100644 index 00000000..ea0646b4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.InRange.html @@ -0,0 +1,52 @@ +InRange | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias InRange<T, Min, Max>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InRange: MinLength<T, Min> & MaxLength<T, Max>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InRange<T, Min, Max> = MinLength<T, Min> & MaxLength<T, Max>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type constraint ensuring a string literal's character length falls within the specified range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Min extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Max extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.Index.html b/packages/tempo/public/v4/api/library/types/common.index.Index.html new file mode 100644 index 00000000..d682e696 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Index.html @@ -0,0 +1,50 @@ +Index | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Index<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Index: { [K in Entry<T> as `${K[1]}`]: ParseInt<K[0]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Index<T> = { [K in Entry<T> as `${K[1]}`]: ParseInt<K[0]>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assign array indexes as values in an object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T extends readonly any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.Instance.html b/packages/tempo/public/v4/api/library/types/common.index.Instance.html new file mode 100644 index 00000000..6dfdae8d --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Instance.html @@ -0,0 +1,72 @@ +Instance | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Instance = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class: Constructor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: Type;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Instance = { type: Type; class: Constructor; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class +type +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class: Constructor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: Type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.IntRange.html b/packages/tempo/public/v4/api/library/types/common.index.IntRange.html new file mode 100644 index 00000000..ea22ec50 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.IntRange.html @@ -0,0 +1,51 @@ +IntRange | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias IntRange<Lower, Upper>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IntRange: Exclude<EnumerateMax<Upper>, EnumerateMin<Lower>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IntRange<Lower, Upper> = EnumerateMax<Upper, []> extends EnumerateMin<Lower, []> ? never : EnumerateMax<Upper, []>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    declare expected range of values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lower extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Upper extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Inverse.html b/packages/tempo/public/v4/api/library/types/common.index.Inverse.html new file mode 100644 index 00000000..6b4d8eb9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Inverse.html @@ -0,0 +1,50 @@ +Inverse | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Inverse<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Inverse: { [K in keyof T as T[K] & PropertyKey]: K }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Inverse<T> = { [K in keyof T as T[K] & PropertyKey]: K; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      invert key-value object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Invert.html b/packages/tempo/public/v4/api/library/types/common.index.Invert.html new file mode 100644 index 00000000..496d870b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Invert.html @@ -0,0 +1,50 @@ +Invert | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Invert<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Invert: { [K in keyof T as T[K]]: K }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Invert<T> = { [K in keyof T as T[K]]: K; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse a Record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T extends Record<keyof T, keyof any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayName.html b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayName.html new file mode 100644 index 00000000..a316ae94 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayName.html @@ -0,0 +1,46 @@ +IsoWeekdayName | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias IsoWeekdayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IsoWeekdayName: IsoWeekdayNames[IsoWeekdayNumber]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IsoWeekdayName = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Union type of all full English weekday names ('Monday' | 'Tuesday' | ... | 'Sunday').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNames.html b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNames.html new file mode 100644 index 00000000..ef9868f7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNames.html @@ -0,0 +1,46 @@ +IsoWeekdayNames | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias IsoWeekdayNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IsoWeekdayNames: typeof ISO_WEEKDAY_NAMES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IsoWeekdayNames = { readonly 1: "Monday"; readonly 2: "Tuesday"; readonly 3: "Wednesday"; readonly 4: "Thursday"; readonly 5: "Friday"; readonly 6: "Saturday"; readonly 7: "Sunday"; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type representing the ISO_WEEKDAY_NAMES mapping structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNumber.html b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNumber.html new file mode 100644 index 00000000..30da705d --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.IsoWeekdayNumber.html @@ -0,0 +1,46 @@ +IsoWeekdayNumber | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias IsoWeekdayNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsoWeekdayNumber: keyof IsoWeekdayNames
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IsoWeekdayNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Union type of all valid ISO weekday numbers (1 | 2 | 3 | 4 | 5 | 6 | 7).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.JSONCReviver.html b/packages/tempo/public/v4/api/library/types/common.index.JSONCReviver.html new file mode 100644 index 00000000..1ff3dfb2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.JSONCReviver.html @@ -0,0 +1,60 @@ +JSONCReviver | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias JSONCReviver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                JSONCReviver: (this: any, key: string, value: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type JSONCReviver = (this: any, key: string, value: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type for a JSONC reviver function that transforms parsed values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • (this: any, key: string, value: any): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • key: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.JWSAlgorithm.html b/packages/tempo/public/v4/api/library/types/common.index.JWSAlgorithm.html new file mode 100644 index 00000000..50ccc5c1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.JWSAlgorithm.html @@ -0,0 +1,44 @@ +JWSAlgorithm | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias JWSAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  JWSAlgorithm: RS256Algorithm | HMACAlgorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type JWSAlgorithm = "RS256" | HMACAlgorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.KeyOf.html b/packages/tempo/public/v4/api/library/types/common.index.KeyOf.html new file mode 100644 index 00000000..1fcc75d9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.KeyOf.html @@ -0,0 +1,50 @@ +KeyOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias KeyOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeyOf: IsEnumProxy<T> extends true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ? T extends { "[iterator]"(): IterableIterator<readonly [K, any]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? K
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : Exclude<Extract<keyof T, string | symbol>, IgnoreOf<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        : T extends any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : Exclude<Extract<keyof T, string | symbol>, IgnoreOf<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type KeyOf<T> = IsEnumProxy<T> extends true ? T extends { [Symbol.iterator](): IterableIterator<readonly [infer K extends PropertyKey, any]>; } ? K : Exclude<Extract<keyof T, string | symbol>, IgnoreOf<T>> : T extends any[] ? number : Exclude<Extract<keyof T, string | symbol>, IgnoreOf<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extracts the keys of an object type, returning numeric indices for array types or string/symbol keys excluding ignored keys for objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.LOG.html b/packages/tempo/public/v4/api/library/types/common.index.LOG.html new file mode 100644 index 00000000..82b9fd72 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LOG.html @@ -0,0 +1,47 @@ +LOG | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias LOG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LOG: ValueOf<typeof LOG>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LOG = 0 | 1 | 2 | 3 | 4 | 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type representing a numeric log level value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.LibrarySymbol.html b/packages/tempo/public/v4/api/library/types/common.index.LibrarySymbol.html new file mode 100644 index 00000000..ce3e488b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LibrarySymbol.html @@ -0,0 +1,46 @@ +LibrarySymbol | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias LibrarySymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LibrarySymbol: ValueOf<typeof sym>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LibrarySymbol = unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Union of all global symbols managed by the library registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.LiteralKey.html b/packages/tempo/public/v4/api/library/types/common.index.LiteralKey.html new file mode 100644 index 00000000..76ec3201 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LiteralKey.html @@ -0,0 +1,50 @@ +LiteralKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias LiteralKey<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LiteralKey: { [K in keyof T]: string extends K ? never : K }[keyof T] & string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LiteralKey<T> = { [K in keyof T]: string extends K ? never : K; }[keyof T] & string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extracts only the Literal string keys (not index signatures) from an object/interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.LocaleInput.html b/packages/tempo/public/v4/api/library/types/common.index.LocaleInput.html new file mode 100644 index 00000000..d8e63afa --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LocaleInput.html @@ -0,0 +1,44 @@ +LocaleInput | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias LocaleInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LocaleInput: string | Intl.Locale | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LocaleInput = string | Intl.Locale | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.LogLevel.html b/packages/tempo/public/v4/api/library/types/common.index.LogLevel.html new file mode 100644 index 00000000..89c89a72 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LogLevel.html @@ -0,0 +1,46 @@ +LogLevel | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias LogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LogLevel: KeyOf<typeof LOG>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type LogLevel = "Error" | "Off" | "Warn" | "Info" | "Debug" | "Trace"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type representing a log level by its string key name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.LooseKey.html b/packages/tempo/public/v4/api/library/types/common.index.LooseKey.html new file mode 100644 index 00000000..854d610b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LooseKey.html @@ -0,0 +1,50 @@ +LooseKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias LooseKey<K>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LooseKey: K | LooseProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type LooseKey<K> = K | LooseProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Loose property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • K extends PropertyKey = string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.LooseSymbol.html b/packages/tempo/public/v4/api/library/types/common.index.LooseSymbol.html new file mode 100644 index 00000000..474975f7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LooseSymbol.html @@ -0,0 +1,50 @@ +LooseSymbol | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias LooseSymbol<S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LooseSymbol: S | LooseSymbolPrimitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LooseSymbol<S> = symbol | S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Loose symbol supporting union autocompletion while accepting any symbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • S extends symbol = symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.LooseUnion.html b/packages/tempo/public/v4/api/library/types/common.index.LooseUnion.html new file mode 100644 index 00000000..61dada8a --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.LooseUnion.html @@ -0,0 +1,50 @@ +LooseUnion | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias LooseUnion<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LooseUnion: T | LooseString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type LooseUnion<T> = T | LooseString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Loose union

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.MaxLength.html b/packages/tempo/public/v4/api/library/types/common.index.MaxLength.html new file mode 100644 index 00000000..531c770d --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MaxLength.html @@ -0,0 +1,51 @@ +MaxLength | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias MaxLength<T, Max>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MaxLength: Compare<Length<T>, Max> extends -1 | 0 ? T : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MaxLength<T, Max> = Compare<Length<T, []>, Max, []> extends 0 | -1 ? T : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type constraint ensuring a string literal has at most the specified character length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Max extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.MinLength.html b/packages/tempo/public/v4/api/library/types/common.index.MinLength.html new file mode 100644 index 00000000..e24fb4aa --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MinLength.html @@ -0,0 +1,51 @@ +MinLength | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias MinLength<T, Min>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinLength: Compare<Min, Length<T>> extends -1 | 0 ? T : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MinLength<T, Min> = Compare<Min, Length<T, []>, []> extends 0 | -1 ? T : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type constraint ensuring a string literal has at least the specified character length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Min extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.MonthKey.html b/packages/tempo/public/v4/api/library/types/common.index.MonthKey.html new file mode 100644 index 00000000..fd2a3040 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MonthKey.html @@ -0,0 +1,46 @@ +MonthKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias MonthKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MonthKey: keyof MonthMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MonthKey = "JAN" | "FEB" | "MAR" | "APR" | "MAY" | "JUN" | "JUL" | "AUG" | "SEP" | "OCT" | "NOV" | "DEC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Union type of all valid 3-letter month abbreviation keys ('JAN' | 'FEB' | ... | 'DEC').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.MonthMap.html b/packages/tempo/public/v4/api/library/types/common.index.MonthMap.html new file mode 100644 index 00000000..afeae8dd --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MonthMap.html @@ -0,0 +1,46 @@ +MonthMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias MonthMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MonthMap: typeof MONTH_MAP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MonthMap = { readonly JAN: 1; readonly FEB: 2; readonly MAR: 3; readonly APR: 4; readonly MAY: 5; readonly JUN: 6; readonly JUL: 7; readonly AUG: 8; readonly SEP: 9; readonly OCT: 10; readonly NOV: 11; readonly DEC: 12; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type representing the MONTH_MAP mapping structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.MonthValue.html b/packages/tempo/public/v4/api/library/types/common.index.MonthValue.html new file mode 100644 index 00000000..c06af7dc --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MonthValue.html @@ -0,0 +1,46 @@ +MonthValue | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias MonthValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MonthValue: MonthMap[MonthKey]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MonthValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Union type of all valid 1-indexed month numeric values (1..12).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.MutableCondition.html b/packages/tempo/public/v4/api/library/types/common.index.MutableCondition.html new file mode 100644 index 00000000..b0fb72c5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MutableCondition.html @@ -0,0 +1,44 @@ +MutableCondition | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias MutableCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MutableCondition: boolean | (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MutableCondition = boolean | (() => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.MutableObject.html b/packages/tempo/public/v4/api/library/types/common.index.MutableObject.html new file mode 100644 index 00000000..0b399b68 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.MutableObject.html @@ -0,0 +1,50 @@ +MutableObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias MutableObject<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MutableObject: { -readonly [K in keyof T]: T[K] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MutableObject<T> = { -readonly [K in keyof T]: T[K]; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remove readonly from all keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.NonOptional.html b/packages/tempo/public/v4/api/library/types/common.index.NonOptional.html new file mode 100644 index 00000000..e51cf32b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.NonOptional.html @@ -0,0 +1,50 @@ +NonOptional | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias NonOptional<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NonOptional: { [K in keyof T]-?: Exclude<T[K], undefined> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NonOptional<T> = { [K in keyof T]-?: Exclude<T[K], undefined>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Remove 'optional' on keys as well as 'undefined' on values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Nullable.html b/packages/tempo/public/v4/api/library/types/common.index.Nullable.html new file mode 100644 index 00000000..10f0f00b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Nullable.html @@ -0,0 +1,50 @@ +Nullable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Nullable<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nullable: T | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Nullable<T> = T | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generic value which may be NULL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Nullish.html b/packages/tempo/public/v4/api/library/types/common.index.Nullish.html new file mode 100644 index 00000000..b46459a5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Nullish.html @@ -0,0 +1,46 @@ +Nullish | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Nullish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nullish: null | undefined | void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Nullish = void | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bottom value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.Obj.html b/packages/tempo/public/v4/api/library/types/common.index.Obj.html new file mode 100644 index 00000000..b46ae5e9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Obj.html @@ -0,0 +1,46 @@ +Obj | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Obj

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Obj: Property<any> | any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Obj = any[] | Property<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Generic Record or Array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.OneKey.html b/packages/tempo/public/v4/api/library/types/common.index.OneKey.html new file mode 100644 index 00000000..911f8afc --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.OneKey.html @@ -0,0 +1,52 @@ +OneKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias OneKey<K, V, KK>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OneKey: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [P in K]: ({ [Q in P]: V } & { [Q in Exclude<KK, P>]?: undefined }) extends infer O
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ? { [Q in keyof O]: O[Q] }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type OneKey<K, V, KK> = { [P in K]: { [Q in P]: V; } & { [Q in Exclude<KK, P>]?: undefined; } extends infer O ? { [Q in keyof O]: O[Q]; } : never; }[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record with only one-key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • K extends keyof any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • KK extends keyof any = K
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Optional.html b/packages/tempo/public/v4/api/library/types/common.index.Optional.html new file mode 100644 index 00000000..03300bb3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Optional.html @@ -0,0 +1,51 @@ +Optional | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Optional<T, K>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional: Omit<T, K> & Partial<Pick<T, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Optional<T, K> = Omit<T, K> & Partial<Pick<T, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mark some fields as Optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • K extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.OwnOf.html b/packages/tempo/public/v4/api/library/types/common.index.OwnOf.html new file mode 100644 index 00000000..d7f5e789 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.OwnOf.html @@ -0,0 +1,50 @@ +OwnOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias OwnOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                OwnOf: T extends any[] ? { [K in number]: T[number] } : Omit<T, IgnoreOf<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OwnOf<T> = T extends any[] ? { [x: number]: T[number]; } : Omit<T, IgnoreOf<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Extracts own properties of an object, excluding well-known symbols and ignored keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T extends Obj
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.ParseInt.html b/packages/tempo/public/v4/api/library/types/common.index.ParseInt.html new file mode 100644 index 00000000..9e13176a --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ParseInt.html @@ -0,0 +1,50 @@ +ParseInt | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias ParseInt<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ParseInt: T extends `${infer N extends number}` ? N : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ParseInt<T> = T extends `${infer N extends number}` ? N : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parses a string literal type into a numeric literal type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.Pledge.Constructor.html b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Constructor.html new file mode 100644 index 00000000..8b54e5c8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Constructor.html @@ -0,0 +1,103 @@ +Constructor | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias Constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Constructor = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        catch?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        debug?: DebugLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onReject?: Reject | Reject[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onResolve?: Resolve | Resolve[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onSettle?: Settle | Settle[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        silent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Constructor = { tag?: string | undefined; onResolve?: Pledge.Resolve | Pledge.Resolve[] | undefined; onReject?: Pledge.Reject | Pledge.Reject[] | undefined; onSettle?: Pledge.Settle | Pledge.Settle[] | undefined; debug?: DebugLevel; catch?: boolean; silent?: boolean; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catch? +debug? +onReject? +onResolve? +onSettle? +silent? +tag? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catch?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debug?: DebugLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onReject?: Reject | Reject[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onResolve?: Resolve | Resolve[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onSettle?: Settle | Settle[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    silent?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Pledge.Reject.html b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Reject.html new file mode 100644 index 00000000..2b45a5d5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Reject.html @@ -0,0 +1,57 @@ +Reject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Reject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reject: (err: Error) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Reject = (err: Error) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (err: Error): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • err: Error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Pledge.Resolve.html b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Resolve.html new file mode 100644 index 00000000..096d60c5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Resolve.html @@ -0,0 +1,57 @@ +Resolve | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Resolve: (val?: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Resolve = (val?: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (val?: any): any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionalval: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.Pledge.Settle.html b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Settle.html new file mode 100644 index 00000000..51453497 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Pledge.Settle.html @@ -0,0 +1,53 @@ +Settle | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Settle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settle: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Settle = () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.Plural.html b/packages/tempo/public/v4/api/library/types/common.index.Plural.html new file mode 100644 index 00000000..a72e1376 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Plural.html @@ -0,0 +1,50 @@ +Plural | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias Plural<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Plural: `${T}s`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Plural<T> = `${T}s`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Converts a string literal type to its plural form by appending 's'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Primitive.html b/packages/tempo/public/v4/api/library/types/common.index.Primitive.html new file mode 100644 index 00000000..39105154 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Primitive.html @@ -0,0 +1,46 @@ +Primitive | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Primitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Primitive: string | number | bigint | boolean | symbol | void | undefined | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Primitive = string | number | bigint | boolean | symbol | void | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Union type of all JavaScript primitive value types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.Primitives.html b/packages/tempo/public/v4/api/library/types/common.index.Primitives.html new file mode 100644 index 00000000..b371d29e --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Primitives.html @@ -0,0 +1,46 @@ +Primitives | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Primitives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Primitives: toName<Primitive>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Primitives = "String" | "Number" | "Boolean" | "Symbol" | "Null" | "BigInt" | "Void"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Union type of all JavaScript primitive type name strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.Property.html b/packages/tempo/public/v4/api/library/types/common.index.Property.html new file mode 100644 index 00000000..edffef6b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Property.html @@ -0,0 +1,50 @@ +Property | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Property<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Property: Record<PropertyKey, T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Property<T> = { [x: string]: T; [x: number]: T; [x: symbol]: T; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Generic Record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.ProxyOptions.html b/packages/tempo/public/v4/api/library/types/common.index.ProxyOptions.html new file mode 100644 index 00000000..7dcc77f0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ProxyOptions.html @@ -0,0 +1,105 @@ +ProxyOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias ProxyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    internal options for the unified proxy engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ProxyOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        appendOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bind?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        frozen?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keys?: (string | symbol)[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lock?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onGet?: (key: string | symbol, target: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: WeakSet<object>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ProxyOptions = { frozen?: boolean; lock?: boolean; appendOnly?: boolean; onGet?: (key: string | symbol, target: any) => any; keys?: (string | symbol)[]; bind?: boolean; skip?: WeakSet<object>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appendOnly? +bind? +frozen? +keys? +lock? +onGet? +skip? +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appendOnly?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bind?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    frozen?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keys?: (string | symbol)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lock?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onGet?: (key: string | symbol, target: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skip?: WeakSet<object>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.RS256Algorithm.html b/packages/tempo/public/v4/api/library/types/common.index.RS256Algorithm.html new file mode 100644 index 00000000..22886350 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.RS256Algorithm.html @@ -0,0 +1,44 @@ +RS256Algorithm | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias RS256Algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RS256Algorithm: "RS256"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RS256Algorithm = "RS256"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reactive.EndListener.html b/packages/tempo/public/v4/api/library/types/common.index.Reactive.EndListener.html new file mode 100644 index 00000000..852be214 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reactive.EndListener.html @@ -0,0 +1,55 @@ +EndListener | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias EndListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EndListener: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EndListener = () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Listener callback for end/stop events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reactive.ErrorListener.html b/packages/tempo/public/v4/api/library/types/common.index.Reactive.ErrorListener.html new file mode 100644 index 00000000..b50c2585 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reactive.ErrorListener.html @@ -0,0 +1,60 @@ +ErrorListener | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias ErrorListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ErrorListener: (error: Error, stop: () => void) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ErrorListener = (error: Error, stop: () => void) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Listener callback for error events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (error: Error, stop: () => void): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • error: Error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • stop: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reactive.EventType.html b/packages/tempo/public/v4/api/library/types/common.index.Reactive.EventType.html new file mode 100644 index 00000000..8da41c58 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reactive.EventType.html @@ -0,0 +1,47 @@ +EventType | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            EventType: "data" | "error" | "end" | "stop"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EventType = "error" | "data" | "end" | "stop"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Event types supported by Reactive instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reactive.Listener.html b/packages/tempo/public/v4/api/library/types/common.index.Reactive.Listener.html new file mode 100644 index 00000000..54cbe7a3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reactive.Listener.html @@ -0,0 +1,64 @@ +Listener | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Listener<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Listener: (value: T, stop: () => void) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Listener<T> = (value: T, stop: () => void) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Listener callback for data events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • (value: T, stop: () => void): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • value: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • stop: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reactive.Subscription.html b/packages/tempo/public/v4/api/library/types/common.index.Reactive.Subscription.html new file mode 100644 index 00000000..44d39df3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reactive.Subscription.html @@ -0,0 +1,48 @@ +Subscription | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Subscription: ReactiveSubscription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Subscription = ReactiveSubscription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disposable subscription handle type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.RegistryOption.html b/packages/tempo/public/v4/api/library/types/common.index.RegistryOption.html new file mode 100644 index 00000000..3a204791 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.RegistryOption.html @@ -0,0 +1,51 @@ +RegistryOption | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias RegistryOption<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RegistryOption: T | Record<string | symbol, T> | RegistryOption<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RegistryOption<T> = T | Record<string | symbol, T> | RegistryOption<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value which may be a single T, a Record of T, or a recursive Array of either. +Used for flexible configuration registries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuard.html b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuard.html new file mode 100644 index 00000000..3189ecf1 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuard.html @@ -0,0 +1,51 @@ +ResolveTypeGuard | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias ResolveTypeGuard<G>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ResolveTypeGuard: G extends (val: any) => val is infer V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ? V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        : G extends (val: any) => boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : G extends string ? ResolveTypeTag<G> : unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ResolveTypeGuard<G> = G extends (val: any) => val is infer V ? V : G extends (val: any) => boolean ? unknown : G extends string ? ResolveTypeTag<G> : unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolves an individual type guard (either a case-insensitive type tag string or an assertion/predicate function) +to its narrowed TypeScript type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • G
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuards.html b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuards.html new file mode 100644 index 00000000..9fcc4d88 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeGuards.html @@ -0,0 +1,50 @@ +ResolveTypeGuards | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias ResolveTypeGuards<G>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResolveTypeGuards: G extends readonly [infer Head, ...(infer Tail)]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ? ResolveTypeGuard<Head> | ResolveTypeGuards<Tail>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          : G extends readonly (infer Item)[] ? ResolveTypeGuard<Item> : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ResolveTypeGuards<G> = G extends readonly [infer Head, ...infer Tail] ? ResolveTypeGuard<Head> | ResolveTypeGuards<Tail> : G extends readonly (infer Item)[] ? ResolveTypeGuard<Item> : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Resolves a tuple/array of type guards into a TypeScript union type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • G extends readonly unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeTag.html b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeTag.html new file mode 100644 index 00000000..c73ff388 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ResolveTypeTag.html @@ -0,0 +1,51 @@ +ResolveTypeTag | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias ResolveTypeTag<S>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ResolveTypeTag: string extends S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : S extends any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? Lowercase<Trim<S>> extends keyof TypeofMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ? TypeofMap[Lowercase<Trim<S>>]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ResolveTypeTag<S> = string extends S ? unknown : S extends any ? Lowercase<Trim<S>> extends keyof TypeofMap ? TypeofMap[Lowercase<Trim<S>>] : never : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Resolves a type tag string (case-insensitive, e.g. 'string', 'String', 'Number') +to its corresponding TypeScript type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • S extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.Resolved.html b/packages/tempo/public/v4/api/library/types/common.index.Resolved.html new file mode 100644 index 00000000..a0177cd4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Resolved.html @@ -0,0 +1,50 @@ +Resolved | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Resolved<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Resolved: T extends (...args: any[]) => infer R ? Awaited<R> : Awaited<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Resolved<T> = T extends (...args: any[]) => infer R ? Awaited<R> : Awaited<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Unwraps an Evaluable<T> or AsyncEvaluable<T> to its resolved value type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.Reverse.html b/packages/tempo/public/v4/api/library/types/common.index.Reverse.html new file mode 100644 index 00000000..d7180b08 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Reverse.html @@ -0,0 +1,51 @@ +Reverse | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias Reverse<T, R>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reverse: ReturnType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                T extends [infer F, ...(infer L)]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ? () => Reverse<L, [F, ...R]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    : () => R,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Reverse<T, R> = (T extends [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R) extends (...args: any) => infer R ? R : any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reverse a Tuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T extends any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • R extends any[] = []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.Secure.html b/packages/tempo/public/v4/api/library/types/common.index.Secure.html new file mode 100644 index 00000000..e77469d8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Secure.html @@ -0,0 +1,50 @@ +Secure | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Secure<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Secure: T extends | Primitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | RegExp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Map<any, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Set<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Promise<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ? T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  : T extends readonly any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? number extends T["length"]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ? SecureArray<T[number]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          : { readonly [K in keyof T]: Secure<T[K]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T extends object ? SecureObject<T> : T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Secure<T> = T extends Function | RegExp | Primitive | Date | Error | Map<any, any> | Set<any> | Promise<any> ? T : T extends readonly any[] ? number extends T["length"] ? SecureArray<T[number]> : { readonly [K in keyof T]: Secure<T[K]>; } : T extends object ? SecureObject<T> : T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deep Readonly object for type safety

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.SecureObject.html b/packages/tempo/public/v4/api/library/types/common.index.SecureObject.html new file mode 100644 index 00000000..51575cdb --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.SecureObject.html @@ -0,0 +1,48 @@ +SecureObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias SecureObject<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SecureObject: { readonly [K in keyof T]: Secure<T[K]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SecureObject<T> = { readonly [K in keyof T]: Secure<T[K]>; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.Singular.html b/packages/tempo/public/v4/api/library/types/common.index.Singular.html new file mode 100644 index 00000000..952210f2 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Singular.html @@ -0,0 +1,50 @@ +Singular | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Singular<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Singular: T extends `${infer S}s` ? T extends MinLength<T, 4> ? S : T : T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Singular<T> = T extends `${infer S}s` ? T extends MinLength<T, 4> ? S : T : T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Converts a string literal type from plural to singular by removing trailing 's' (if length permits)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.SingularUnit.html b/packages/tempo/public/v4/api/library/types/common.index.SingularUnit.html new file mode 100644 index 00000000..40681197 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.SingularUnit.html @@ -0,0 +1,50 @@ +SingularUnit | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias SingularUnit<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SingularUnit: Singular<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SingularUnit<T> = T extends `${infer S}s` ? T extends MinLength<T, 4> ? S : T : T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alias for Singular type utility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Substring.html b/packages/tempo/public/v4/api/library/types/common.index.Substring.html new file mode 100644 index 00000000..052b4c58 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Substring.html @@ -0,0 +1,56 @@ +Substring | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Substring<U, Max, Start>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Substring: Substr<U, Max, Start>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Substring<U, Max, Start> = U extends `${infer NextChar}${infer Rest}` ? 1 extends Start ? 0 extends Max ? "" : Substr<Rest, Max, Start, `${NextChar}`, [0]> : Substr<Rest, Max, Start, "", [0, 0]> : ""
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      return a substring of a string-type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +eg: Substr<Monday|Tuesday|Wednesday, 3> returns Mon|Tue|Wed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +U is the original string union
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +Max is the number of chars to return
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +Start is the offset (starting from '1')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • U extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Max extends number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Start extends number = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.TArray.html b/packages/tempo/public/v4/api/library/types/common.index.TArray.html new file mode 100644 index 00000000..0ca043d4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TArray.html @@ -0,0 +1,50 @@ +TArray | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias TArray<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TArray: TValue<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TArray<T> = TValue<T>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cast <T | T[]> as T[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.TValue.html b/packages/tempo/public/v4/api/library/types/common.index.TValue.html new file mode 100644 index 00000000..baaf6a84 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TValue.html @@ -0,0 +1,50 @@ +TValue | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias TValue<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TValue: T extends (infer A)[] ? A : NonNullable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TValue<T> = T extends (infer A)[] ? A : NonNullable<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          infer T of a <T | T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.TValues.html b/packages/tempo/public/v4/api/library/types/common.index.TValues.html new file mode 100644 index 00000000..ae105743 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TValues.html @@ -0,0 +1,50 @@ +TValues | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias TValues<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TValues: TValue<T> | TValue<T>[] | Extract<T, undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TValues<T> = TValue<T> | TValue<T>[] | Extract<T, undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cast <T | undefined> as <T | T[]>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.TemporalObject.html b/packages/tempo/public/v4/api/library/types/common.index.TemporalObject.html new file mode 100644 index 00000000..1b9549c7 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TemporalObject.html @@ -0,0 +1,46 @@ +TemporalObject | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias TemporalObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TemporalObject:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.PlainDate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.PlainTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.PlainDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.ZonedDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.Instant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.PlainYearMonth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.PlainMonthDay
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Temporal.Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TemporalObject = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime | Temporal.Instant | Temporal.PlainYearMonth | Temporal.PlainMonthDay | Temporal.Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Union type of all ECMAScript Temporal API object instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.TemporalPoint.html b/packages/tempo/public/v4/api/library/types/common.index.TemporalPoint.html new file mode 100644 index 00000000..5fb0c6a6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TemporalPoint.html @@ -0,0 +1,44 @@ +TemporalPoint | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias TemporalPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TemporalPoint: { epoch?: { ns: bigint } } | { epochNanoseconds: bigint } | any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TemporalPoint = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.Temporals.html b/packages/tempo/public/v4/api/library/types/common.index.Temporals.html new file mode 100644 index 00000000..7f73d5e4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Temporals.html @@ -0,0 +1,46 @@ +Temporals | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Temporals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Temporals:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "Instant"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "ZonedDateTime"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "PlainDateTime"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "PlainDate"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "PlainTime"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "PlainYearMonth"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "PlainMonthDay"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | "Duration"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Temporals = "Instant" | "ZonedDateTime" | "PlainDateTime" | "PlainDate" | "PlainTime" | "PlainYearMonth" | "PlainMonthDay" | "Duration"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Union type of all ECMAScript Temporal API type name strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.TimeZoneInput.html b/packages/tempo/public/v4/api/library/types/common.index.TimeZoneInput.html new file mode 100644 index 00000000..637b47e0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TimeZoneInput.html @@ -0,0 +1,44 @@ +TimeZoneInput | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias TimeZoneInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TimeZoneInput: Temporal.TimeZoneLike | string | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TimeZoneInput = Temporal.TimeZoneLike | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.Type.html b/packages/tempo/public/v4/api/library/types/common.index.Type.html new file mode 100644 index 00000000..a51c1e96 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.Type.html @@ -0,0 +1,46 @@ +Type | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type: keyof TypeValueMap<any> | "Enumify" | "Pledge" | "Tempo"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Type = keyof TypeValueMap<any> | "Tempo"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      add Special Type placeholders to the keyof TypeValueMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/types/common.index.TypeValue.html b/packages/tempo/public/v4/api/library/types/common.index.TypeValue.html new file mode 100644 index 00000000..f08e4a6b --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TypeValue.html @@ -0,0 +1,48 @@ +TypeValue | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias TypeValue<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TypeValue: { [K in Type]: { type: K; value: GetType<K, T> } }[Type]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TypeValue<T> = { type: "String"; value: string; } | { type: "Number"; value: number; } | { type: "Boolean"; value: boolean; } | { type: "Symbol"; value: symbol; } | { type: "Undefined"; value: undefined; } | { type: "Object"; value: Extract<T, Property<unknown>>; } | { type: "Function"; value: Function; } | { type: "Array"; value: T[]; } | { type: "Null"; value: null; } | { type: "BigInt"; value: bigint; } | { type: "ArrayLike"; value: ArrayLike<T>; } | { type: "Void"; value: void; } | { type: "Empty"; value: unknown; } | { type: "Date"; value: Date; } | { type: "AsyncFunction"; value: Function; } | { type: "GeneratorFunction"; value: Function; } | { type: "AsyncGeneratorFunction"; value: Function; } | { type: "Class"; value: T; } | { type: "Promise"; value: Promise<T>; } | { type: "RegExp"; value: RegExp; } | { type: "Blob"; value: Blob; } | { type: "Map"; value: Map<any, T>; } | { type: "Set"; value: Set<T>; } | { type: "WeakSet"; value: WeakSet<Property<unknown>>; } | { type: "WeakMap"; value: WeakMap<Property<unknown>, T>; } | { type: "WeakRef"; value: any; } | { type: "Error"; value: Error; } | { type: "Module"; value: any; } | { type: "Temporal"; value: Temporals; } | { type: "Temporal.Instant"; value: Temporal.Instant; } | { type: "Temporal.ZonedDateTime"; value: Temporal.ZonedDateTime; } | { type: "Temporal.PlainDateTime"; value: Temporal.PlainDateTime; } | { type: "Temporal.PlainDate"; value: Temporal.PlainDate; } | { type: "Temporal.PlainTime"; value: Temporal.PlainTime; } | { type: "Temporal.PlainYearMonth"; value: Temporal.PlainYearMonth; } | { type: "Temporal.PlainMonthDay"; value: Temporal.PlainMonthDay; } | { type: "Temporal.ZonedDateTimeLike"; value: Temporal.ZonedDateTimeLike; } | { type: "Temporal.Duration"; value: Temporal.Duration; } | { type: "Temporal.DurationLike"; value: Temporal.DurationLike; } | { type: "Temporal.PlainDateLike"; value: Temporal.PlainDateLike; } | { type: "Temporal.PlainTimeLike"; value: Temporal.PlainTimeLike; } | { type: "Temporal.PlainYearMonthLike"; value: Temporal.PlainYearMonthLike; } | { type: "Temporal.PlainMonthDayLike"; value: Temporal.PlainMonthDayLike; } | { type: "Enumify"; value: import("../runtime/enumerate.library.js").Enum.wrap<T>; } | { type: "Pledge"; value: import("../runtime/pledge.class.js").Pledge<T>; } | { type: "Reactive"; value: import("../runtime/reactive.class.js").Reactive<T>; } | { type: "Reactive.Subscription"; value: ReactiveSubscription; } | { type: "Tempo"; value: any; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/types/common.index.TypeofMap.html b/packages/tempo/public/v4/api/library/types/common.index.TypeofMap.html new file mode 100644 index 00000000..7cce0fb0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TypeofMap.html @@ -0,0 +1,132 @@ +TypeofMap | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias TypeofMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TypeofMap = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              any: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array: unknown[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bigint: bigint;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              boolean: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function: (...args: any[]) => unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              null: null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              number: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              object: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              string: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              symbol: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              undefined: undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unknown: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TypeofMap = { string: string; number: number; boolean: boolean; function: (...args: any[]) => unknown; object: object; bigint: bigint; symbol: symbol; undefined: undefined; array: unknown[]; null: null; any: any; unknown: unknown; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          any +array +bigint +boolean +function +null +number +object +string +symbol +undefined +unknown +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          any: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          array: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bigint: bigint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function: (...args: any[]) => unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          null: null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          object: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          string: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          symbol: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          undefined: undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unknown: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Properties +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/types/common.index.TypeofTag.html b/packages/tempo/public/v4/api/library/types/common.index.TypeofTag.html new file mode 100644 index 00000000..d00f251d --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.TypeofTag.html @@ -0,0 +1,46 @@ +TypeofTag | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias TypeofTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TypeofTag:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "string"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "number"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "boolean"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "function"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "object"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "bigint"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "symbol"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "undefined"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "array"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "null"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "any"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | "unknown"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TypeofTag = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null" | "any" | "unknown"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Standard typeof primitive type names plus common structural types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/types/common.index.UnionToTuple.html b/packages/tempo/public/v4/api/library/types/common.index.UnionToTuple.html new file mode 100644 index 00000000..fbde2281 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.UnionToTuple.html @@ -0,0 +1,53 @@ +UnionToTuple | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias UnionToTuple<T, Acc, Last>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnionToTuple: Acc["length"] extends SafeRecursion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ? T[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  : [T] extends [never]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? Acc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : UnionToTuple<Exclude<T, Last>, [Last, ...Acc]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UnionToTuple<T, Acc, Last> = Acc["length"] extends 50 ? T[] : [T] extends [never] ? Acc : UnionToTuple<Exclude<T, Last>, [Last, ...Acc], LastInUnion<Exclude<T, Last>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              convert a Union to a Tuple.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +usage: UnionToTuple<A | B> = [A, B]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Acc extends any[] = []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Last = LastInUnion<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/types/common.index.UnsafeKey.html b/packages/tempo/public/v4/api/library/types/common.index.UnsafeKey.html new file mode 100644 index 00000000..8be67723 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.UnsafeKey.html @@ -0,0 +1,46 @@ +UnsafeKey | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias UnsafeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnsafeKey: ValueOf<typeof UNSAFE_KEYS>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UnsafeKey = "prototype" | "__proto__" | "constructor"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Property keys rejected to guard against prototype pollution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/types/common.index.UtcDateOptions.html b/packages/tempo/public/v4/api/library/types/common.index.UtcDateOptions.html new file mode 100644 index 00000000..59380897 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.UtcDateOptions.html @@ -0,0 +1,46 @@ +UtcDateOptions | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias UtcDateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UtcDateOptions: UtcPartsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type UtcDateOptions = UtcPartsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type alias for UtcPartsOptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/types/common.index.ValueOf.html b/packages/tempo/public/v4/api/library/types/common.index.ValueOf.html new file mode 100644 index 00000000..07eecfb6 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.ValueOf.html @@ -0,0 +1,50 @@ +ValueOf | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias ValueOf<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ValueOf: IsEnumProxy<T> extends true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ? T extends { "[iterator]"(): IterableIterator<readonly [any, V]> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : T[KeyOf<T> & keyof T]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        : T extends readonly any[] ? T[number] : T[KeyOf<T> & keyof T]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ValueOf<T> = IsEnumProxy<T> extends true ? T extends { [Symbol.iterator](): IterableIterator<readonly [any, infer V]>; } ? V : T[KeyOf<T> & keyof T] : T extends readonly any[] ? T[number] : T[KeyOf<T> & keyof T]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extracts the value types from an object or array (including readonly arrays)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • T extends Obj | readonly any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/types/common.index.WellKnownSymbols.html b/packages/tempo/public/v4/api/library/types/common.index.WellKnownSymbols.html new file mode 100644 index 00000000..349f6bd5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/types/common.index.WellKnownSymbols.html @@ -0,0 +1,46 @@ +WellKnownSymbols | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias WellKnownSymbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WellKnownSymbols: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [K in keyof SymbolConstructor]: SymbolConstructor[K] extends symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ? SymbolConstructor[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }[keyof SymbolConstructor]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WellKnownSymbols = unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol | unique symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Own properties of an Array, Object, Map or Enum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/browser.index.Tapper.EVENT.html b/packages/tempo/public/v4/api/library/variables/browser.index.Tapper.EVENT.html new file mode 100644 index 00000000..6c56d5b5 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/browser.index.Tapper.EVENT.html @@ -0,0 +1,37 @@ +EVENT | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable EVENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EVENT: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DoubleTap: "doubleTap";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SingleTap: "singleTap";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TripleTap: "tripleTap";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index.CONTEXT.html b/packages/tempo/public/v4/api/library/variables/common.index.CONTEXT.html new file mode 100644 index 00000000..8d4a6079 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.CONTEXT.html @@ -0,0 +1,53 @@ +CONTEXT | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable CONTEXTConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CONTEXT: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Browser: "browser";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deno: "deno";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GoogleAppsScript: "google-apps-script";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NodeJS: "nodejs";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Unknown: "unknown";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WebWorker: "web-worker";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enumeration of supported JavaScript runtime environment identifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyBrowser: "browser"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyDeno: "deno"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyGoogleAppsScript: "google-apps-script"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyNodeJS: "nodejs"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyUnknown: "unknown"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadonlyWebWorker: "web-worker"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index.DAYS_IN_WEEK.html b/packages/tempo/public/v4/api/library/variables/common.index.DAYS_IN_WEEK.html new file mode 100644 index 00000000..f6c1c46a --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.DAYS_IN_WEEK.html @@ -0,0 +1,37 @@ +DAYS_IN_WEEK | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable DAYS_IN_WEEKConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DAYS_IN_WEEK: 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Number of days in a standard week.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index.DAY_MAP.html b/packages/tempo/public/v4/api/library/variables/common.index.DAY_MAP.html new file mode 100644 index 00000000..3be7f272 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.DAY_MAP.html @@ -0,0 +1,37 @@ +DAY_MAP | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable DAY_MAPConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DAY_MAP: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FR: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FRI: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MO: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MON: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SA: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SAT: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SU: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SUN: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TH: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      THU: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TU: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TUE: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WE: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WED: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Mapping of 2-letter and 3-letter ISO day abbreviations to 1-indexed weekday numbers (1..7, Monday=1, Sunday=7).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index.Enum.html b/packages/tempo/public/v4/api/library/variables/common.index.Enum.html new file mode 100644 index 00000000..fae5560e --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.Enum.html @@ -0,0 +1,36 @@ +Enum | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable EnumConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum: Readonly<typeof enumMethods> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index.HTTP.html b/packages/tempo/public/v4/api/library/variables/common.index.HTTP.html new file mode 100644 index 00000000..455696c3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.HTTP.html @@ -0,0 +1,53 @@ +HTTP | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable HTTPConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  HTTP: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BadRequest: 400;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Forbidden: 403;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ok: 200;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PermRedirect: 301;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TempRedirect: 302;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Unauthorised: 401;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Common HTTP status code constants.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyBadRequest: 400
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyForbidden: 403
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyOk: 200
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyPermRedirect: 301
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyTempRedirect: 302
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadonlyUnauthorised: 401
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index.ISO_WEEKDAY_NAMES.html b/packages/tempo/public/v4/api/library/variables/common.index.ISO_WEEKDAY_NAMES.html new file mode 100644 index 00000000..271f21ad --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.ISO_WEEKDAY_NAMES.html @@ -0,0 +1,37 @@ +ISO_WEEKDAY_NAMES | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable ISO_WEEKDAY_NAMESConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO_WEEKDAY_NAMES: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "1": "Monday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "2": "Tuesday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "3": "Wednesday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "4": "Thursday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "5": "Friday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "6": "Saturday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "7": "Sunday";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mapping of 1-indexed ISO weekday numbers (1..7, Monday=1, Sunday=7) to full English weekday names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/variables/common.index.LOG.html b/packages/tempo/public/v4/api/library/variables/common.index.LOG.html new file mode 100644 index 00000000..7f39e3d4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.LOG.html @@ -0,0 +1,38 @@ +LOG | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable LOGConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LOG: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index<readonly ["Off", "Error", "Warn", "Info", "Debug", "Trace"]>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enumeration of available log levels from lowest to highest verbosity.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/common.index.METHOD.html b/packages/tempo/public/v4/api/library/variables/common.index.METHOD.html new file mode 100644 index 00000000..9bf01832 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.METHOD.html @@ -0,0 +1,48 @@ +METHOD | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable METHODConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        METHOD: { Delete: "DELETE"; Get: "GET"; Head: "HEAD"; Post: "POST"; Put: "PUT" } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadonlyDelete: "DELETE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadonlyGet: "GET"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadonlyPost: "POST"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadonlyPut: "PUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index.MONTH_MAP.html b/packages/tempo/public/v4/api/library/variables/common.index.MONTH_MAP.html new file mode 100644 index 00000000..ee49ff65 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.MONTH_MAP.html @@ -0,0 +1,37 @@ +MONTH_MAP | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable MONTH_MAPConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTH_MAP: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  APR: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AUG: 8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DEC: 12;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FEB: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  JAN: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  JUL: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  JUN: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MAR: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MAY: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NOV: 11;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OCT: 10;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SEP: 9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mapping of 3-letter month abbreviations (JAN..DEC) to 1-indexed month numbers (1..12).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index.NOOP.html b/packages/tempo/public/v4/api/library/variables/common.index.NOOP.html new file mode 100644 index 00000000..3a5bf13a --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.NOOP.html @@ -0,0 +1,45 @@ +NOOP | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable NOOPConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOOP: () => void = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Immutable shared noop function for null-object teardown patterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (): void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64.html new file mode 100644 index 00000000..42e11776 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64.html @@ -0,0 +1,37 @@ +RE_BASE64 | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable RE_BASE64Const

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_BASE64: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Regular expression matching Base64 string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64URL.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64URL.html new file mode 100644 index 00000000..9f7ade33 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_BASE64URL.html @@ -0,0 +1,37 @@ +RE_BASE64URL | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable RE_BASE64URLConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RE_BASE64URL: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Regular expression matching Base64URL string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_BIGINT_LITERAL.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_BIGINT_LITERAL.html new file mode 100644 index 00000000..d1591714 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_BIGINT_LITERAL.html @@ -0,0 +1,37 @@ +RE_BIGINT_LITERAL | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable RE_BIGINT_LITERALConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RE_BIGINT_LITERAL: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Regular expression matching BigInt literal notation (123n or -123n)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_COMBINING_MARKS.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_COMBINING_MARKS.html new file mode 100644 index 00000000..afafc8e0 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_COMBINING_MARKS.html @@ -0,0 +1,37 @@ +RE_COMBINING_MARKS | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable RE_COMBINING_MARKSConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RE_COMBINING_MARKS: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global regular expression matching Unicode combining diacritical marks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_DIGITS.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_DIGITS.html new file mode 100644 index 00000000..0df98f6c --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_DIGITS.html @@ -0,0 +1,37 @@ +RE_DIGITS | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable RE_DIGITSConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RE_DIGITS: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Regular expression matching integer digits string (^\d+$)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_FILE_URL.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_FILE_URL.html new file mode 100644 index 00000000..efbcc45c --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_FILE_URL.html @@ -0,0 +1,37 @@ +RE_FILE_URL | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable RE_FILE_URLConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RE_FILE_URL: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Regular expression matching file protocol prefix (file://)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX.html new file mode 100644 index 00000000..58a04254 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX.html @@ -0,0 +1,37 @@ +RE_HEX | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable RE_HEXConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RE_HEX: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Regular expression matching hexadecimal string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX_8.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX_8.html new file mode 100644 index 00000000..a8707944 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_HEX_8.html @@ -0,0 +1,37 @@ +RE_HEX_8 | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable RE_HEX_8Const

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RE_HEX_8: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Regular expression matching 8-character hexadecimal string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_HTTP_URL.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_HTTP_URL.html new file mode 100644 index 00000000..cbd4f0a4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_HTTP_URL.html @@ -0,0 +1,37 @@ +RE_HTTP_URL | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable RE_HTTP_URLConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RE_HTTP_URL: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Regular expression matching HTTP or HTTPS protocol prefixes (http:// or https://)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_INTEGER.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_INTEGER.html new file mode 100644 index 00000000..5e4f67d9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_INTEGER.html @@ -0,0 +1,37 @@ +RE_INTEGER | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable RE_INTEGERConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RE_INTEGER: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Regular expression matching signed integer string (^[+-]?[0-9]+$)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_REGEXP_LITERAL.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_REGEXP_LITERAL.html new file mode 100644 index 00000000..64c0b621 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_REGEXP_LITERAL.html @@ -0,0 +1,37 @@ +RE_REGEXP_LITERAL | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable RE_REGEXP_LITERALConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RE_REGEXP_LITERAL: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Regular expression matching regular expression string literal (/.../)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_UUID.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_UUID.html new file mode 100644 index 00000000..ae6a3da9 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_UUID.html @@ -0,0 +1,37 @@ +RE_UUID | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable RE_UUIDConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RE_UUID: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regular expression matching standard UUID format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACE.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACE.html new file mode 100644 index 00000000..b6930348 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACE.html @@ -0,0 +1,37 @@ +RE_WHITESPACE | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable RE_WHITESPACEConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RE_WHITESPACE: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Regular expression matching one or more whitespace characters (\s+)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACES.html b/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACES.html new file mode 100644 index 00000000..31ce4793 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.RE_WHITESPACES.html @@ -0,0 +1,37 @@ +RE_WHITESPACES | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable RE_WHITESPACESConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RE_WHITESPACES: RegExp = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Global regular expression matching one or more whitespace characters (\s+/g)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index.Reactive.Subscription.html b/packages/tempo/public/v4/api/library/variables/common.index.Reactive.Subscription.html new file mode 100644 index 00000000..7dfa4d35 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.Reactive.Subscription.html @@ -0,0 +1,37 @@ +Subscription | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable Subscription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Subscription: typeof ReactiveSubscription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index.Registry.html b/packages/tempo/public/v4/api/library/variables/common.index.Registry.html new file mode 100644 index 00000000..e3bae491 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.Registry.html @@ -0,0 +1,42 @@ +Registry | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable RegistryConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Registry: any = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Global registry mapping class names to their constructors for serialization/deserialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only register trusted classes whose constructors are free of harmful side effects. +Deserializing via objectify will invoke constructors via Reflect.construct with deserialized arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index.TIMEOUT_MAX.html b/packages/tempo/public/v4/api/library/variables/common.index.TIMEOUT_MAX.html new file mode 100644 index 00000000..50de2975 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.TIMEOUT_MAX.html @@ -0,0 +1,37 @@ +TIMEOUT_MAX | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable TIMEOUT_MAXConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TIMEOUT_MAX: number = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Maximum 32-bit signed integer timer delay supported by Node.js and the HTML timer specification (2^31 - 1).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Discover.html b/packages/tempo/public/v4/api/library/variables/common.index._Discover.html new file mode 100644 index 00000000..386a2c33 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Discover.html @@ -0,0 +1,37 @@ +$Discover | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable $DiscoverConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $Discover: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Global symbol for marking discoverable entities in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Extensible.html b/packages/tempo/public/v4/api/library/variables/common.index._Extensible.html new file mode 100644 index 00000000..8741cf62 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Extensible.html @@ -0,0 +1,37 @@ +$Extensible | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable $ExtensibleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $Extensible: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Global symbol for tracking extensible objects in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Identity.html b/packages/tempo/public/v4/api/library/variables/common.index._Identity.html new file mode 100644 index 00000000..62fbbccc --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Identity.html @@ -0,0 +1,37 @@ +$Identity | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable $IdentityConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $Identity: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global symbol for brand-checking class instances across module boundaries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Inspect.html b/packages/tempo/public/v4/api/library/variables/common.index._Inspect.html new file mode 100644 index 00000000..bdd33761 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Inspect.html @@ -0,0 +1,37 @@ +$Inspect | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable $InspectConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Inspect: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for Node.js custom inspection (used by util.inspect)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/common.index._LogConfig.html b/packages/tempo/public/v4/api/library/variables/common.index._LogConfig.html new file mode 100644 index 00000000..032d306a --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._LogConfig.html @@ -0,0 +1,37 @@ +$LogConfig | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable $LogConfigConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $LogConfig: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Global symbol for identifying logging configuration objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Mutable.html b/packages/tempo/public/v4/api/library/variables/common.index._Mutable.html new file mode 100644 index 00000000..8f8849fd --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Mutable.html @@ -0,0 +1,37 @@ +$Mutable | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable $MutableConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $Mutable: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Global symbol for marking class members exempt from immutability enforcement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Register.html b/packages/tempo/public/v4/api/library/variables/common.index._Register.html new file mode 100644 index 00000000..d4105874 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Register.html @@ -0,0 +1,37 @@ +$Register | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable $RegisterConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $Register: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Global symbol for marking registered types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Registry.html b/packages/tempo/public/v4/api/library/variables/common.index._Registry.html new file mode 100644 index 00000000..72186607 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Registry.html @@ -0,0 +1,37 @@ +$Registry | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable $RegistryConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $Registry: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Global symbol for accessing the type registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index._SerializerRegistry.html b/packages/tempo/public/v4/api/library/variables/common.index._SerializerRegistry.html new file mode 100644 index 00000000..f6e80423 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._SerializerRegistry.html @@ -0,0 +1,37 @@ +$SerializerRegistry | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable $SerializerRegistryConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $SerializerRegistry: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Global symbol for accessing the serializer registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Target.html b/packages/tempo/public/v4/api/library/variables/common.index._Target.html new file mode 100644 index 00000000..1aef750b --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Target.html @@ -0,0 +1,37 @@ +$Target | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable $TargetConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $Target: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Global symbol for identifying target objects in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index._Unwrapped.html b/packages/tempo/public/v4/api/library/variables/common.index._Unwrapped.html new file mode 100644 index 00000000..92fbd9d3 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index._Unwrapped.html @@ -0,0 +1,37 @@ +$Unwrapped | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable $UnwrappedConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $Unwrapped: unique symbol = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global symbol for opting out of class decorator subclass wrapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/library/variables/common.index.canonicalLocales.html b/packages/tempo/public/v4/api/library/variables/common.index.canonicalLocales.html new file mode 100644 index 00000000..3271547c --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.canonicalLocales.html @@ -0,0 +1,59 @@ +canonicalLocales | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable canonicalLocalesConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      canonicalLocales: (locales?: unknown) => readonly string[] = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Canonicalizes an array or single locale input into a list of valid BCP 47 locale strings. +Gracefully ignores malformed locales and strips invalid/falsy values without throwing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • (locales?: unknown): readonly string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Optionallocales: unknown +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Single or multiple locale identifiers or Intl.Locale instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns readonly string[]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An array of canonical BCP 47 locale strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      canonicalLocales(['en_US.UTF-8', 'fr-FR', 'invalid!tag']); // ['en-US', 'fr-FR']
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/library/variables/common.index.createEncryptedFileStore.html b/packages/tempo/public/v4/api/library/variables/common.index.createEncryptedFileStore.html new file mode 100644 index 00000000..740eeba8 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.createEncryptedFileStore.html @@ -0,0 +1,55 @@ +createEncryptedFileStore | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable createEncryptedFileStoreConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createEncryptedFileStore: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: string | FileStoreOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<VirtualFileStore> = getFileStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Convenience alias for getFileStore.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • (options: string | FileStoreOptions): Promise<VirtualFileStore>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Creates or retrieves an encrypted Virtual File Store. +A non-empty password is required. All data stored is encrypted at-rest using AES-GCM (256-bit).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • options: string | FileStoreOptions +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Encryption password string or FileStoreOptions object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns Promise<VirtualFileStore>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Encrypted VirtualFileStore instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/library/variables/common.index.getDateTimeFormat.html b/packages/tempo/public/v4/api/library/variables/common.index.getDateTimeFormat.html new file mode 100644 index 00000000..501d45fd --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.getDateTimeFormat.html @@ -0,0 +1,53 @@ +getDateTimeFormat | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable getDateTimeFormatConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDateTimeFormat: () => Readonly<Intl.ResolvedDateTimeFormatOptions> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Retrieves the system's current TimeZone, Calendar, and Locale information +by resolving the default Intl.DateTimeFormat options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • (): Readonly<Intl.ResolvedDateTimeFormatOptions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns Readonly<Intl.ResolvedDateTimeFormatOptions>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The resolved DateTimeFormat options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const { timeZone, locale } = getDateTimeFormat();
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/library/variables/common.index.getHemisphere.html b/packages/tempo/public/v4/api/library/variables/common.index.getHemisphere.html new file mode 100644 index 00000000..3a673471 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.getHemisphere.html @@ -0,0 +1,54 @@ +getHemisphere | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable getHemisphereConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getHemisphere: (timeZone?: string) => "north" | "south" | undefined = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Try to infer hemisphere using the timezone's daylight-savings setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • (timeZone?: string): "north" | "south" | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeZone: string = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns "north" | "south" | undefined

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This implementation intentionally differs from the version in tempo-fns +(including specific fallback and return behaviors). Do not directly synchronize them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/library/variables/common.index.keys.html b/packages/tempo/public/v4/api/library/variables/common.index.keys.html new file mode 100644 index 00000000..d19c34ed --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.keys.html @@ -0,0 +1,48 @@ +keys | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable keysConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Algorithm: "SHA-256";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Encoding: "utf-8";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SignKey: "RSASSA-PKCS1-v1_5";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TypeKey: "AES-GCM";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Cryptographic algorithm and encoding constants used throughout the cipher library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadonlyAlgorithm: "SHA-256"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadonlyEncoding: "utf-8"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadonlySignKey: "RSASSA-PKCS1-v1_5"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadonlyTypeKey: "AES-GCM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/library/variables/common.index.nodeStorage.html b/packages/tempo/public/v4/api/library/variables/common.index.nodeStorage.html new file mode 100644 index 00000000..44cfa902 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.nodeStorage.html @@ -0,0 +1,35 @@ +nodeStorage | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable nodeStorageConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nodeStorage: BoundedCache<string, string | undefined> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/library/variables/common.index.probeMDY.html b/packages/tempo/public/v4/api/library/variables/common.index.probeMDY.html new file mode 100644 index 00000000..41d798e4 --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.probeMDY.html @@ -0,0 +1,59 @@ +probeMDY | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable probeMDYConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  probeMDY: (locale?: LocaleInput) => boolean = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Probes the runtime to see if the locale defaults to Month-Day-Year (MDY) order. +Useful for resolving ambiguous dates like '12/11/2024'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • (locale?: LocaleInput): boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Optionallocale: LocaleInput +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The locale string to probe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      True if the locale uses MDY format, false otherwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  probeMDY('en-US') // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  probeMDY('en-GB') // false
+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/library/variables/common.index.sym.html b/packages/tempo/public/v4/api/library/variables/common.index.sym.html new file mode 100644 index 00000000..47adadac --- /dev/null +++ b/packages/tempo/public/v4/api/library/variables/common.index.sym.html @@ -0,0 +1,82 @@ +sym | Library API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Library API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable symConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sym: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Discover: typeof $Discover;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Extensible: typeof $Extensible;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Identity: typeof $Identity;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Inspect: typeof $Inspect;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $LogConfig: typeof $LogConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Mutable: typeof $Mutable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Register: typeof $Register;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Registry: typeof $Registry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $SerializerRegistry: typeof $SerializerRegistry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Target: typeof $Target;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $Unwrapped: typeof $Unwrapped;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Discover: typeof $Discover
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for marking discoverable entities in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Extensible: typeof $Extensible
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for tracking extensible objects in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Identity: typeof $Identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for brand-checking class instances across module boundaries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Inspect: typeof $Inspect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for Node.js custom inspection (used by util.inspect)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $LogConfig: typeof $LogConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for identifying logging configuration objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Mutable: typeof $Mutable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for marking class members exempt from immutability enforcement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Register: typeof $Register
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for marking registered types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Registry: typeof $Registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for accessing the type registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $SerializerRegistry: typeof $SerializerRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for accessing the serializer registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Target: typeof $Target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for identifying target objects in the library system

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $Unwrapped: typeof $Unwrapped
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Global symbol for opting out of class decorator subclass wrapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/modules.html b/packages/tempo/public/v4/api/modules.html new file mode 100644 index 00000000..9626521b --- /dev/null +++ b/packages/tempo/public/v4/api/modules.html @@ -0,0 +1,61 @@ +Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interval
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TempoTermRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermLifecycleHooks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermParseContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermPlugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ResolvedRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermHook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermHookSymbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DurationModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enums
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fmtTempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FormatModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getStamp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getTempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MutateModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ParseEngine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ParseModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermHook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TermsModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defineConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defineRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defineTerm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resolveRangeDiff
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resolveRangeFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resolveRangeOrdinal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        default → Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Classes +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variables +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Functions +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        References +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/modules/Tempo.html b/packages/tempo/public/v4/api/modules/Tempo.html new file mode 100644 index 00000000..8ba971ec --- /dev/null +++ b/packages/tempo/public/v4/api/modules/Tempo.html @@ -0,0 +1,50 @@ +Tempo | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Namespace Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BaseOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FormatOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Params
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Add
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          COMPASS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DURATION
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DURATIONS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Element
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ELEMENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FormatRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Formats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Groups
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hh
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Logic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Modifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Month
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTHS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mutate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pair
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Relative
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SEASON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Set
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ss
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TimeStamp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Unit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Until
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          us
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Weekday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WEEKDAY
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WEEKDAYS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          COMPASS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DURATION
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DURATIONS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ELEMENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTHS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SEASON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WEEKDAY
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WEEKDAYS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Interfaces +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Functions +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Accessors +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/Range.html b/packages/tempo/public/v4/api/types/Range.html new file mode 100644 index 00000000..ef77f8c6 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Range.html @@ -0,0 +1,116 @@ +Range | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias Range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Range: { group?: string; key: string | null; [meta: string]: any } & (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { year: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { month: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { week: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { day: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { hour: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { minute: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { second: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { millisecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { microsecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | { nanosecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                day?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hour?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                microsecond?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                millisecond?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                minute?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                month?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nanosecond?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                second?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                week?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                year?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Range = { [meta: string]: any; key: string | null; group?: string; } & (({ year: number; } | { month: number; } | { week: number; } | { day: number; } | { hour: number; } | { minute: number; } | { second: number; } | { millisecond: number; } | { microsecond: number; } | { nanosecond: number; }) & { year?: number; month?: number; week?: number; day?: number; hour?: number; minute?: number; second?: number; millisecond?: number; microsecond?: number; nanosecond?: number; })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discrete time interval within a specific term.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When Range.year is a number it is interpreted as a relative offset if |year| ≤ 10 +and as an absolute year otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [meta: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalgroup?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Categorization marker (e.g. 'western', 'chinese', 'fiscal')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Unique identifier for the range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { year: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { month: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { week: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { day: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { hour: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { minute: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { second: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { millisecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { microsecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • { nanosecond: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalday?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional day override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalhour?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional hour override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalmicrosecond?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional microsecond override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalmillisecond?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional millisecond override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalminute?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional minute override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalmonth?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional month override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalnanosecond?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional nanosecond override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalsecond?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional second override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalweek?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional week override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optionalyear?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Optional year override

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/ResolvedRange.html b/packages/tempo/public/v4/api/types/ResolvedRange.html new file mode 100644 index 00000000..ad8eee92 --- /dev/null +++ b/packages/tempo/public/v4/api/types/ResolvedRange.html @@ -0,0 +1,82 @@ +ResolvedRange | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias ResolvedRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolvedRange: Range & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: Tempo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  locale?: Record<string, string | Function>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rollover?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scope?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: Tempo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unit?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [str: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ResolvedRange = Range & { [str: string]: any; start: Tempo; end: Tempo; scope?: string; label?: string; locale?: Record<string, string | Function>; unit?: string; rollover?: string; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Range with additional metadata.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [str: string]: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end: Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                End boundary of the resolved range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optionallabel?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Human-readable label for the range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optionallocale?: Record<string, string | Function>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Locale-specific translations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optionalrollover?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Rollover behavior for the range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optionalscope?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Scope or category of the term

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                start: Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Start boundary of the resolved range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Optionalunit?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Primary unit for this range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ResolvedRange
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/types/Tempo.Add.html b/packages/tempo/public/v4/api/types/Tempo.Add.html new file mode 100644 index 00000000..1653d41a --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Add.html @@ -0,0 +1,46 @@ +Add | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Add: t.MutateAdd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Add = t.DateTime | (t.AddUnits & { yy?: number; yw?: number; mm?: number; ww?: number; dd?: number; hh?: number; mi?: number; ss?: number; wy?: number; woy?: number; ms?: number; us?: number; ns?: number; yow?: number; isoYear?: number; isoyear?: number; isoWeek?: number; isoweek?: number; } & t.TermOffset)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Add operations for adding durations to date/time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/types/Tempo.COMPASS.html b/packages/tempo/public/v4/api/types/Tempo.COMPASS.html new file mode 100644 index 00000000..f97b0659 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.COMPASS.html @@ -0,0 +1,47 @@ +COMPASS | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias COMPASS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  COMPASS: t.COMPASS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type COMPASS = "north" | "south" | "equator" | "east" | "west"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Cardinal directions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/types/Tempo.DURATION-1.html b/packages/tempo/public/v4/api/types/Tempo.DURATION-1.html new file mode 100644 index 00000000..c89addd8 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.DURATION-1.html @@ -0,0 +1,47 @@ +DURATION | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias DURATION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DURATION: t.DURATION
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DURATION = "second" | "year" | "month" | "week" | "day" | "hour" | "minute" | "millisecond" | "microsecond" | "nanosecond"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Duration in seconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/types/Tempo.DURATIONS.html b/packages/tempo/public/v4/api/types/Tempo.DURATIONS.html new file mode 100644 index 00000000..83b88c8a --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.DURATIONS.html @@ -0,0 +1,47 @@ +DURATIONS | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias DURATIONS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DURATIONS: t.DURATIONS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DURATIONS = "years" | "months" | "weeks" | "days" | "hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Duration in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/types/Tempo.DateTime.html b/packages/tempo/public/v4/api/types/Tempo.DateTime.html new file mode 100644 index 00000000..490d642f --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.DateTime.html @@ -0,0 +1,46 @@ +DateTime | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias DateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DateTime: t.DateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DateTime = string | number | bigint | Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime | Temporal.Instant | Temporal.PlainYearMonth | Temporal.PlainMonthDay | Temporal.Duration | Date | Temporal.ZonedDateTimeLikeObject | Temporal.DurationLikeObject | Tempo | import("#tempo/support").TempoBrand | t.ISOString | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Represents any value that can be parsed as a date/time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/types/Tempo.Duration.html b/packages/tempo/public/v4/api/types/Tempo.Duration.html new file mode 100644 index 00000000..7e7394f3 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Duration.html @@ -0,0 +1,46 @@ +Duration | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Duration: t.Duration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Duration = import("#library/type.library.js").NonOptional<Temporal.DurationLikeObject> & Record<"iso", string> & Record<"sign", number> & Record<"blank", boolean> & Record<"unit", string | undefined> & { balance(opts?: { nominal?: boolean; relativeTo?: any; largestUnit?: t.Unit | string; }): t.Duration; format(opts?: Intl.NumberFormatOptions & { locales?: string | string[]; }): string; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Temporal duration object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/Tempo.ELEMENT-1.html b/packages/tempo/public/v4/api/types/Tempo.ELEMENT-1.html new file mode 100644 index 00000000..7dc21de2 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.ELEMENT-1.html @@ -0,0 +1,47 @@ +ELEMENT | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias ELEMENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ELEMENT: t.ELEMENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ELEMENT = "second" | "year" | "month" | "week" | "day" | "hour" | "minute" | "millisecond" | "microsecond" | "nanosecond"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Date-time element tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/Tempo.Element.html b/packages/tempo/public/v4/api/types/Tempo.Element.html new file mode 100644 index 00000000..34ff44cd --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Element.html @@ -0,0 +1,46 @@ +Element | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Element: t.Element
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Element = "yy" | "mm" | "ww" | "dd" | "hh" | "mi" | "ss" | "wy" | "woy" | "ms" | "us" | "ns"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Date-time element name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/types/Tempo.Format.html b/packages/tempo/public/v4/api/types/Tempo.Format.html new file mode 100644 index 00000000..058e4940 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Format.html @@ -0,0 +1,46 @@ +Format | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Format: t.Format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Format = (string & {}) | "date" | "time" | "yearMonthDay" | "display" | "weekDate" | "weekTime" | "weekStamp" | "dayMonth" | "dayDate" | "dayTime" | "logStamp" | "sortTime" | "yearWeek" | "yearMonth"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A single format string template name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/types/Tempo.FormatRegistry.html b/packages/tempo/public/v4/api/types/Tempo.FormatRegistry.html new file mode 100644 index 00000000..3748ac75 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.FormatRegistry.html @@ -0,0 +1,46 @@ +FormatRegistry | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias FormatRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FormatRegistry: t.FormatRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FormatRegistry = Readonly<import("./support/support.enum.js").Formats> & Omit<import("#library/enumerate.library.js").EnumMethods<import("./support/support.enum.js").Formats>, string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Registry of format strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/types/Tempo.Formats.html b/packages/tempo/public/v4/api/types/Tempo.Formats.html new file mode 100644 index 00000000..697b00ad --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Formats.html @@ -0,0 +1,46 @@ +Formats | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias Formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formats: t.Formats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Formats = { [x: string]: string; } & Record<string, string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Collection of format string templates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/types/Tempo.Groups.html b/packages/tempo/public/v4/api/types/Tempo.Groups.html new file mode 100644 index 00000000..fe0b2605 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Groups.html @@ -0,0 +1,46 @@ +Groups | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Groups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups: t.Groups
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Groups = { [x: string]: string; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Regex capture groups from pattern matching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/types/Tempo.Logic.html b/packages/tempo/public/v4/api/types/Tempo.Logic.html new file mode 100644 index 00000000..492b47c0 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Logic.html @@ -0,0 +1,46 @@ +Logic | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Logic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Logic: t.Logic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Logic = string | number | t.AliasFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function or string logic for event/period evaluation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/types/Tempo.MONTH-1.html b/packages/tempo/public/v4/api/types/Tempo.MONTH-1.html new file mode 100644 index 00000000..7fa70641 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.MONTH-1.html @@ -0,0 +1,47 @@ +MONTH | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias MONTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MONTH: t.MONTH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MONTH = "All" | "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" | "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Month enumeration (short form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/Tempo.MONTHS.html b/packages/tempo/public/v4/api/types/Tempo.MONTHS.html new file mode 100644 index 00000000..17ddabd7 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.MONTHS.html @@ -0,0 +1,47 @@ +MONTHS | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias MONTHS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MONTHS: t.MONTHS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MONTHS = "May" | "Every" | "January" | "February" | "March" | "April" | "June" | "July" | "August" | "September" | "October" | "November" | "December"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Month enumeration (long form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/Tempo.Modifier.html b/packages/tempo/public/v4/api/types/Tempo.Modifier.html new file mode 100644 index 00000000..217d84e7 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Modifier.html @@ -0,0 +1,46 @@ +Modifier | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Modifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Modifier: t.Modifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Modifier = "first" | "last" | "=" | "-" | "+" | "<" | "<=" | "-=" | ">" | ">=" | "+=" | "this" | "next" | "prev" | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Temporal direction modifier (next, last, this, etc.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/types/Tempo.Month.html b/packages/tempo/public/v4/api/types/Tempo.Month.html new file mode 100644 index 00000000..225cd3e9 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Month.html @@ -0,0 +1,46 @@ +Month | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias Month

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Month: t.Month
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Month = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Month numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/types/Tempo.Mutate.html b/packages/tempo/public/v4/api/types/Tempo.Mutate.html new file mode 100644 index 00000000..45003150 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Mutate.html @@ -0,0 +1,46 @@ +Mutate | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Mutate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Mutate: t.Mutate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Mutate = "start" | "mid" | "end"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Mutation operations for date/time modification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/types/Tempo.Options.html b/packages/tempo/public/v4/api/types/Tempo.Options.html new file mode 100644 index 00000000..19f5ac16 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Options.html @@ -0,0 +1,46 @@ +Options | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options: t.Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Options = t.Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Full configuration options for Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/types/Tempo.Pair.html b/packages/tempo/public/v4/api/types/Tempo.Pair.html new file mode 100644 index 00000000..5642425f --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Pair.html @@ -0,0 +1,46 @@ +Pair | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias Pair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pair: t.Pair
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Pair = [string, string] | readonly [string, string]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pair of values for date ranges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/types/Tempo.Pattern.html b/packages/tempo/public/v4/api/types/Tempo.Pattern.html new file mode 100644 index 00000000..4722a586 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Pattern.html @@ -0,0 +1,46 @@ +Pattern | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias Pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pattern: t.Pattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Pattern = string | RegExp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        String or RegExp pattern for matching dates/times

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/types/Tempo.Relative.html b/packages/tempo/public/v4/api/types/Tempo.Relative.html new file mode 100644 index 00000000..92f7b233 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Relative.html @@ -0,0 +1,46 @@ +Relative | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Relative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Relative: t.Relative
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Relative = "ago" | "hence" | "prior" | "from now"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Relative temporal expression (e.g., 'next week', '2 days ago')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/Tempo.SEASON.html b/packages/tempo/public/v4/api/types/Tempo.SEASON.html new file mode 100644 index 00000000..4bd1c1d4 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.SEASON.html @@ -0,0 +1,47 @@ +SEASON | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias SEASON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SEASON: t.SEASON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SEASON = "spring" | "summer" | "autumn" | "winter"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Calendar seasons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/Tempo.Set.html b/packages/tempo/public/v4/api/types/Tempo.Set.html new file mode 100644 index 00000000..ecd03704 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Set.html @@ -0,0 +1,46 @@ +Set | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias Set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Set: t.MutateSet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Set = t.DateTime | ({ start?: "yw" | "yow" | "isoYear" | "isoyear" | "isoWeek" | "isoweek" | t.Unit; mid?: "yw" | "yow" | "isoYear" | "isoyear" | "isoWeek" | "isoweek" | t.Unit; end?: "yw" | "yow" | "isoYear" | "isoyear" | "isoWeek" | "isoweek" | t.Unit; } & { date?: string; time?: string; event?: string; period?: string; } & { yw?: number | t.Mutate | (string & {}); second?: number | t.Mutate | (string & {}); year?: number | t.Mutate | (string & {}); month?: number | t.Mutate | (string & {}); week?: number | t.Mutate | (string & {}); day?: number | t.Mutate | (string & {}); hour?: number | t.Mutate | (string & {}); minute?: number | t.Mutate | (string & {}); millisecond?: number | t.Mutate | (string & {}); microsecond?: number | t.Mutate | (string & {}); nanosecond?: number | t.Mutate | (string & {}); yow?: number | t.Mutate | (string & {}); isoYear?: number | t.Mutate | (string & {}); isoyear?: number | t.Mutate | (string & {}); isoWeek?: number | t.Mutate | (string & {}); isoweek?: number | t.Mutate | (string & {}); } & t.MutateShorthand & { timeZone?: Temporal.TimeZoneLike; calendar?: Temporal.CalendarLike; } & t.TermOffset)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Set operations for setting specific date/time values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/types/Tempo.TimeStamp.html b/packages/tempo/public/v4/api/types/Tempo.TimeStamp.html new file mode 100644 index 00000000..f5a40342 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.TimeStamp.html @@ -0,0 +1,46 @@ +TimeStamp | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias TimeStamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TimeStamp: t.Internal.TimeStamp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TimeStamp = "ss" | "ms" | "us" | "ns"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Timestamp precision unit (ss, ms, us, ns)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/types/Tempo.Unit.html b/packages/tempo/public/v4/api/types/Tempo.Unit.html new file mode 100644 index 00000000..3090f37e --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Unit.html @@ -0,0 +1,46 @@ +Unit | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias Unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Unit: t.Unit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Unit = "years" | "months" | "weeks" | "days" | "hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds" | "yy" | "mm" | "ww" | "dd" | "hh" | "mi" | "ss" | "wy" | "woy" | "ms" | "us" | "ns" | t.DateTimeUnit | `#${string}`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configuration to use for #until() and #since() argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/types/Tempo.Until.html b/packages/tempo/public/v4/api/types/Tempo.Until.html new file mode 100644 index 00000000..1e9ea739 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Until.html @@ -0,0 +1,46 @@ +Until | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias Until

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Until: t.Until
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Until = t.Unit | (t.Options & { unit?: t.Unit; })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options for calculating duration until/since another date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/types/Tempo.WEEKDAY-1.html b/packages/tempo/public/v4/api/types/Tempo.WEEKDAY-1.html new file mode 100644 index 00000000..5da701ed --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.WEEKDAY-1.html @@ -0,0 +1,47 @@ +WEEKDAY | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias WEEKDAY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WEEKDAY: t.WEEKDAY
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WEEKDAY = "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Weekday enumeration (short form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/types/Tempo.WEEKDAYS.html b/packages/tempo/public/v4/api/types/Tempo.WEEKDAYS.html new file mode 100644 index 00000000..e3d31fc6 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.WEEKDAYS.html @@ -0,0 +1,47 @@ +WEEKDAYS | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias WEEKDAYS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WEEKDAYS: t.WEEKDAYS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WEEKDAYS = "Everyday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Weekday enumeration (long form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/types/Tempo.Weekday.html b/packages/tempo/public/v4/api/types/Tempo.Weekday.html new file mode 100644 index 00000000..83f3dab0 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.Weekday.html @@ -0,0 +1,46 @@ +Weekday | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias Weekday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Weekday: t.Weekday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Weekday numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/Tempo.hh.html b/packages/tempo/public/v4/api/types/Tempo.hh.html new file mode 100644 index 00000000..19908e8b --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.hh.html @@ -0,0 +1,46 @@ +hh | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias hh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hh: t.hh
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type hh = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 23 | 21
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hour numeric value (0-23)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/Tempo.mi.html b/packages/tempo/public/v4/api/types/Tempo.mi.html new file mode 100644 index 00000000..fd30d40e --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.mi.html @@ -0,0 +1,46 @@ +mi | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias mi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mi: t.mi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type mi = 0 | 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52 | 54 | 59 | 55 | 56 | 57 | 58
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Minute numeric value (0-59)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/types/Tempo.mm.html b/packages/tempo/public/v4/api/types/Tempo.mm.html new file mode 100644 index 00000000..c93476ea --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.mm.html @@ -0,0 +1,46 @@ +mm | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Alias mm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mm: t.mm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type mm = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Month numeric value (1-12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/types/Tempo.ms.html b/packages/tempo/public/v4/api/types/Tempo.ms.html new file mode 100644 index 00000000..746c99b7 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.ms.html @@ -0,0 +1,46 @@ +ms | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Alias ms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ms: t.ms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ms = 0 | 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 200 | 301 | 302 | 400 | 401 | 403 | 60 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52 | 54 | 59 | 55 | 56 | 57 | 58 | 999 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 402 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 | 451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 | 551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 | 576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 | 651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | 659 | 660 | 661 | 662 | 663 | 664 | 665 | 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 | 688 | 689 | 690 | 691 | 692 | 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 | 701 | 702 | 703 | 704 | 705 | 706 | 707 | 708 | 709 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | 722 | 723 | 724 | 725 | 726 | 727 | 728 | 729 | 730 | 731 | 732 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 | 751 | 752 | 753 | 754 | 755 | 756 | 757 | 758 | 759 | 760 | 761 | 762 | 763 | 764 | 765 | 766 | 767 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 | 776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 | 798 | 799 | 800 | 801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 809 | 810 | 811 | 812 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 | 824 | 825 | 826 | 827 | 828 | 829 | 830 | 831 | 832 | 833 | 834 | 835 | 836 | 837 | 838 | 839 | 840 | 841 | 842 | 843 | 844 | 845 | 846 | 847 | 848 | 849 | 850 | 851 | 852 | 853 | 854 | 855 | 856 | 857 | 858 | 859 | 860 | 861 | 862 | 863 | 864 | 865 | 866 | 867 | 868 | 869 | 870 | 871 | 872 | 873 | 874 | 875 | 876 | 877 | 878 | 879 | 880 | 881 | 882 | 883 | 884 | 885 | 886 | 887 | 888 | 889 | 890 | 891 | 892 | 893 | 894 | 895 | 896 | 897 | 898 | 899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 | 910 | 911 | 912 | 913 | 914 | 915 | 916 | 917 | 918 | 919 | 920 | 921 | 922 | 923 | 924 | 925 | 926 | 927 | 928 | 929 | 930 | 931 | 932 | 933 | 934 | 935 | 936 | 937 | 938 | 939 | 940 | 941 | 942 | 943 | 944 | 945 | 946 | 947 | 948 | 949 | 950 | 951 | 952 | 953 | 954 | 955 | 956 | 957 | 958 | 959 | 960 | 961 | 962 | 963 | 964 | 965 | 966 | 967 | 968 | 969 | 970 | 971 | 972 | 973 | 974 | 975 | 976 | 977 | 978 | 979 | 980 | 981 | 982 | 983 | 984 | 985 | 986 | 987 | 988 | 989 | 990 | 991 | 992 | 993 | 994 | 995 | 996 | 997 | 998
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Millisecond numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/types/Tempo.ns.html b/packages/tempo/public/v4/api/types/Tempo.ns.html new file mode 100644 index 00000000..b430f944 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.ns.html @@ -0,0 +1,46 @@ +ns | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Alias ns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ns: t.ns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ns = 0 | 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 200 | 301 | 302 | 400 | 401 | 403 | 60 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52 | 54 | 59 | 55 | 56 | 57 | 58 | 999 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 402 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 | 451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 | 551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 | 576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 | 651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | 659 | 660 | 661 | 662 | 663 | 664 | 665 | 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 | 688 | 689 | 690 | 691 | 692 | 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 | 701 | 702 | 703 | 704 | 705 | 706 | 707 | 708 | 709 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | 722 | 723 | 724 | 725 | 726 | 727 | 728 | 729 | 730 | 731 | 732 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 | 751 | 752 | 753 | 754 | 755 | 756 | 757 | 758 | 759 | 760 | 761 | 762 | 763 | 764 | 765 | 766 | 767 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 | 776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 | 798 | 799 | 800 | 801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 809 | 810 | 811 | 812 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 | 824 | 825 | 826 | 827 | 828 | 829 | 830 | 831 | 832 | 833 | 834 | 835 | 836 | 837 | 838 | 839 | 840 | 841 | 842 | 843 | 844 | 845 | 846 | 847 | 848 | 849 | 850 | 851 | 852 | 853 | 854 | 855 | 856 | 857 | 858 | 859 | 860 | 861 | 862 | 863 | 864 | 865 | 866 | 867 | 868 | 869 | 870 | 871 | 872 | 873 | 874 | 875 | 876 | 877 | 878 | 879 | 880 | 881 | 882 | 883 | 884 | 885 | 886 | 887 | 888 | 889 | 890 | 891 | 892 | 893 | 894 | 895 | 896 | 897 | 898 | 899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 | 910 | 911 | 912 | 913 | 914 | 915 | 916 | 917 | 918 | 919 | 920 | 921 | 922 | 923 | 924 | 925 | 926 | 927 | 928 | 929 | 930 | 931 | 932 | 933 | 934 | 935 | 936 | 937 | 938 | 939 | 940 | 941 | 942 | 943 | 944 | 945 | 946 | 947 | 948 | 949 | 950 | 951 | 952 | 953 | 954 | 955 | 956 | 957 | 958 | 959 | 960 | 961 | 962 | 963 | 964 | 965 | 966 | 967 | 968 | 969 | 970 | 971 | 972 | 973 | 974 | 975 | 976 | 977 | 978 | 979 | 980 | 981 | 982 | 983 | 984 | 985 | 986 | 987 | 988 | 989 | 990 | 991 | 992 | 993 | 994 | 995 | 996 | 997 | 998
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nanosecond numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/types/Tempo.ss.html b/packages/tempo/public/v4/api/types/Tempo.ss.html new file mode 100644 index 00000000..ccaef441 --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.ss.html @@ -0,0 +1,46 @@ +ss | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Alias ss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ss: t.ss
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ss = 0 | 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52 | 54 | 59 | 55 | 56 | 57 | 58
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Second numeric value (0-59)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/types/Tempo.us.html b/packages/tempo/public/v4/api/types/Tempo.us.html new file mode 100644 index 00000000..298e07fd --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.us.html @@ -0,0 +1,46 @@ +us | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Alias us

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        us: t.us
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type us = 0 | 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 200 | 301 | 302 | 400 | 401 | 403 | 60 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52 | 54 | 59 | 55 | 56 | 57 | 58 | 999 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 402 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 | 451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 | 551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 | 576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 | 651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | 659 | 660 | 661 | 662 | 663 | 664 | 665 | 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 | 688 | 689 | 690 | 691 | 692 | 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 | 701 | 702 | 703 | 704 | 705 | 706 | 707 | 708 | 709 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | 722 | 723 | 724 | 725 | 726 | 727 | 728 | 729 | 730 | 731 | 732 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 | 751 | 752 | 753 | 754 | 755 | 756 | 757 | 758 | 759 | 760 | 761 | 762 | 763 | 764 | 765 | 766 | 767 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 | 776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 | 798 | 799 | 800 | 801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 809 | 810 | 811 | 812 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 | 824 | 825 | 826 | 827 | 828 | 829 | 830 | 831 | 832 | 833 | 834 | 835 | 836 | 837 | 838 | 839 | 840 | 841 | 842 | 843 | 844 | 845 | 846 | 847 | 848 | 849 | 850 | 851 | 852 | 853 | 854 | 855 | 856 | 857 | 858 | 859 | 860 | 861 | 862 | 863 | 864 | 865 | 866 | 867 | 868 | 869 | 870 | 871 | 872 | 873 | 874 | 875 | 876 | 877 | 878 | 879 | 880 | 881 | 882 | 883 | 884 | 885 | 886 | 887 | 888 | 889 | 890 | 891 | 892 | 893 | 894 | 895 | 896 | 897 | 898 | 899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 | 910 | 911 | 912 | 913 | 914 | 915 | 916 | 917 | 918 | 919 | 920 | 921 | 922 | 923 | 924 | 925 | 926 | 927 | 928 | 929 | 930 | 931 | 932 | 933 | 934 | 935 | 936 | 937 | 938 | 939 | 940 | 941 | 942 | 943 | 944 | 945 | 946 | 947 | 948 | 949 | 950 | 951 | 952 | 953 | 954 | 955 | 956 | 957 | 958 | 959 | 960 | 961 | 962 | 963 | 964 | 965 | 966 | 967 | 968 | 969 | 970 | 971 | 972 | 973 | 974 | 975 | 976 | 977 | 978 | 979 | 980 | 981 | 982 | 983 | 984 | 985 | 986 | 987 | 988 | 989 | 990 | 991 | 992 | 993 | 994 | 995 | 996 | 997 | 998
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Microsecond numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/types/Tempo.wy.html b/packages/tempo/public/v4/api/types/Tempo.wy.html new file mode 100644 index 00000000..9919d88d --- /dev/null +++ b/packages/tempo/public/v4/api/types/Tempo.wy.html @@ -0,0 +1,46 @@ +wy | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Alias wy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wy: t.wy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type wy = 1 | 50 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 38 | 26 | 25 | 24 | 23 | 21 | 31 | 27 | 28 | 29 | 30 | 32 | 53 | 33 | 34 | 35 | 36 | 37 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 51 | 52
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ISO week-year numeric value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/types/TermHook.html b/packages/tempo/public/v4/api/types/TermHook.html new file mode 100644 index 00000000..a302b0c5 --- /dev/null +++ b/packages/tempo/public/v4/api/types/TermHook.html @@ -0,0 +1,47 @@ +TermHook | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Alias TermHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TermHook: typeof TermHook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TermHook = { readonly parse: symbol; readonly ordinal: symbol; readonly step: symbol; readonly diff: symbol; readonly bound: symbol; readonly format: symbol; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Well-Known Symbols for Term Lifecycle Protocol. +Utilizing Symbol.for() to guarantee consistency across module boundaries and dual package instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/types/TermHookSymbol.html b/packages/tempo/public/v4/api/types/TermHookSymbol.html new file mode 100644 index 00000000..1fa5291a --- /dev/null +++ b/packages/tempo/public/v4/api/types/TermHookSymbol.html @@ -0,0 +1,43 @@ +TermHookSymbol | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Alias TermHookSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TermHookSymbol: ValueOf<typeof TermHook>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + + 🔍 Expanded Type Evaluation (Compiler API) + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TermHookSymbol = symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/variables/DurationModule.html b/packages/tempo/public/v4/api/variables/DurationModule.html new file mode 100644 index 00000000..0c1fab7b --- /dev/null +++ b/packages/tempo/public/v4/api/variables/DurationModule.html @@ -0,0 +1,36 @@ +DurationModule | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable DurationModuleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DurationModule: TempoModule = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Functional Module to attach duration methods to Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/variables/FormatModule.html b/packages/tempo/public/v4/api/variables/FormatModule.html new file mode 100644 index 00000000..c31d7d50 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/FormatModule.html @@ -0,0 +1,36 @@ +FormatModule | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable FormatModuleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FormatModule: Tempo.Module = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Format Module Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/variables/MutateModule.html b/packages/tempo/public/v4/api/variables/MutateModule.html new file mode 100644 index 00000000..00839787 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/MutateModule.html @@ -0,0 +1,36 @@ +MutateModule | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable MutateModuleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MutateModule: TempoModule = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MutateModule registration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/api/variables/ParseEngine.html b/packages/tempo/public/v4/api/variables/ParseEngine.html new file mode 100644 index 00000000..22a2073f --- /dev/null +++ b/packages/tempo/public/v4/api/variables/ParseEngine.html @@ -0,0 +1,63 @@ +ParseEngine | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Variable ParseEngineConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ParseEngine: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          conform: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tempo: DateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      State,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tempo: DateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | { calendar?: undefined; type: string; value: any; zone?: undefined }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | { calendar: string; type: string; value: ZonedDateTime; zone: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  calendar?: undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: ZonedDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zone: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isZonedDateTimeLike: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: [tempo: Options | DateTime] | [State, tempo: Options | DateTime],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [tempo: DateTime, dateTime?: ZonedDateTime, term?: string]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [State, tempo: DateTime, dateTime?: ZonedDateTime, term?: string],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parseLayout: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      State,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => TypeValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parseMatch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [pat: RegExp, value: string | number]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [State, pat: RegExp, value: string | number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => R;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          result: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: Partial<Match>[] | [State, ...Partial<Match>[]],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Public Parse Engine (wrapped for dual-mode support)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        conform: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo: DateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    State,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo: DateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | { calendar?: undefined; type: string; value: any; zone?: undefined }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | { calendar: string; type: string; value: ZonedDateTime; zone: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                calendar?: undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: ZonedDateTime;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                zone: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Conforms a parse result to a specific temporal type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isZonedDateTimeLike: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: [tempo: Options | DateTime] | [State, tempo: Options | DateTime],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checks if input is a ZonedDateTime-like object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [tempo: DateTime, dateTime?: ZonedDateTime, term?: string]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [State, tempo: DateTime, dateTime?: ZonedDateTime, term?: string],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parses a DateTime input into a normalized temporal object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parseLayout: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    State,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dateTime: ZonedDateTime,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAnchored: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolvingKeys: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => TypeValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parses input using a specific layout pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parseMatch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [pat: RegExp, value: string | number]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [State, pat: RegExp, value: string | number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Matches input against the supplied regular expression pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        result: (this: any, ...args: Partial<Match>[] | [State, ...Partial<Match>[]]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulates and returns parse results

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diff --git a/packages/tempo/public/v4/api/variables/ParseModule.html b/packages/tempo/public/v4/api/variables/ParseModule.html new file mode 100644 index 00000000..a86d140f --- /dev/null +++ b/packages/tempo/public/v4/api/variables/ParseModule.html @@ -0,0 +1,62 @@ +ParseModule | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Variable ParseModuleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ParseModule: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            install(this: typeof Tempo, TempoClass: typeof Tempo): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ParseModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The internal parsing engine for Tempo. +Decouples date-string interpretation from the core class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          install: function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        On This Page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ParseModule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        diff --git a/packages/tempo/public/v4/api/variables/TermHook.html b/packages/tempo/public/v4/api/variables/TermHook.html new file mode 100644 index 00000000..5bed96d6 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/TermHook.html @@ -0,0 +1,53 @@ +TermHook | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Variable TermHookConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TermHook: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bound: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              format: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ordinal: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parse: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              step: symbol;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Well-Known Symbols for Term Lifecycle Protocol. +Utilizing Symbol.for() to guarantee consistency across module boundaries and dual package instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlybound: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlydiff: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlyformat: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlyordinal: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlyparse: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Readonlystep: symbol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          diff --git a/packages/tempo/public/v4/api/variables/TermsModule.html b/packages/tempo/public/v4/api/variables/TermsModule.html new file mode 100644 index 00000000..17972f67 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/TermsModule.html @@ -0,0 +1,61 @@ +TermsModule | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variable TermsModuleConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TermsModule: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                install(this: typeof Tempo, TempoClass: typeof Tempo): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TermsModule provides the standard term definitions for Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This module automatically registers standard temporal terms like "today", "tomorrow", +"next week", etc., and ensures they are re-registered on registry resets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Module name identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              install: function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Installs standard terms into the Tempo class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff --git a/packages/tempo/public/v4/api/variables/enums.html b/packages/tempo/public/v4/api/variables/enums.html new file mode 100644 index 00000000..0d9bc2e2 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/enums.html @@ -0,0 +1,119 @@ +enums | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Variable enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enums: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CACHE: EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  COMPASS: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              East: "east";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Equator: "equator";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              North: "north";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              South: "south";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              West: "west";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CONFIG: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "config",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "parse",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "value",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "intl",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "localeInfo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "store",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "discovery",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "debug",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "catch",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "silent",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "timeZone",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "calendar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "locale",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "sphere",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "geo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "latitude",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "lat",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "longitude",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "lng",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "timeStamp",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "registry",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "plugins",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "extends",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "cache",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DURATION: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          day: 86400;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hour: 3600;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          microsecond: 0.000001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          millisecond: 0.001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minute: 60;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          month: 2628000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nanosecond: 1e-9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          second: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          week: 604800;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          year: 31536000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DURATIONS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          days: 86400000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hours: 3600000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          microseconds: 0.001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          milliseconds: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minutes: 60000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          months: 2628000000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nanoseconds: 0.000001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          seconds: 1000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          weeks: 604800000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          years: 31536000000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ELEMENT: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dd: "day";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hh: "hour";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mi: "minute";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mm: "month";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ms: "millisecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ns: "nanosecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ss: "second";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          us: "microsecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          woy: "week";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ww: "week";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          yy: "year";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "[hasInstance]"(instance: any): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count<T extends Property<any>>(enumObj: T): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entries<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extend<const E extends any[] | Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              list: E,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              frozen?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): EnumifyType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): ValueOf<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          has<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): key is KeyOf<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasOwn<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): key is KeyOf<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes<T extends Property<any>>(enumObj: T, search: any): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          invert<T extends Property<any>>(enumObj: T): Readonly<Invert<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keyOf<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              search: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): KeyOf<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keys<T extends Property<any>>(enumObj: T): readonly KeyOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          values<T extends Property<any>>(enumObj: T): readonly ValueOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FORMAT: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              date: "{yyyy}-{mm}-{dd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dayDate: "{dd}-{mmm}-{yyyy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dayMonth: "{dd}-{mmm}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              display: "{www}, {dd} {mmm} {yyyy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              logStamp: "{ymd}T{hms}.{ff}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              time: "{hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yearMonth: "{yyyy}{mm}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yearMonthDay: "{ymd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yearWeek: "{yw}{wy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LIMIT: Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LOCALE: Readonly<Record<string, Record<string, any>>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MODE: EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MONTH: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "All",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Jan",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Feb",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Mar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Apr",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "May",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Jun",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Jul",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Aug",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Sep",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Oct",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Nov",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Dec",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MONTH_DAY: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          layouts: readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly ["dayMonthYearShort", "monthDayYearShort"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly ["dayMonthYear", "monthDayYear"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          locales: readonly ["en-US", "en-AS"];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timezones: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "en-AS": readonly ["Pacific/Pago_Pago"];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "en-US": readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Adak",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Anchorage",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Boise",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Chicago",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Denver",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Detroit",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Indianapolis",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Knox",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Marengo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Petersburg",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Tell_City",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Vevay",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Vincennes",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indiana/Winamac",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Indianapolis",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Juneau",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Kentucky/Louisville",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Kentucky/Monticello",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Los_Angeles",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Louisville",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Menominee",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Metlakatla",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/New_York",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Nome",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/North_Dakota/Beulah",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/North_Dakota/Center",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/North_Dakota/New_Salem",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Phoenix",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Sitka",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "America/Yakutat",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "Pacific/Honolulu",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Aleutian",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Alaska",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Arizona",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Central",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Eastern",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Mountain",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "US/Pacific",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MONTHS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Every",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "January",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "February",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "March",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "April",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "May",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "June",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "July",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "August",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "September",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "October",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "November",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "December",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MUTATION: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "yy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mm",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "wy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ww",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "woy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "dd",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "hh",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mi",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ss",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ms",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "us",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ns",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "yw",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "yow",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "isoYear",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "isoyear",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "isoWeek",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "isoweek",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "event",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "period",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "clock",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "time",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "date",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "start",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mid",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "end",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NUMBER: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eight: 8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              five: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              four: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nine: 9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              one: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              seven: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              six: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ten: 10;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              three: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              two: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              zero: 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ORDINAL: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              current: 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eighth: 8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fifth: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              first: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fourth: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              last: -1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ninth: 9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              second: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              seventh: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sixth: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tenth: 10;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              third: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PARSE: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "monthDay",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "planner",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "layoutOrder",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "preFilter",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mode",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "pivot",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "snippet",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "layout",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "event",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "period",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "anchor",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SEASON: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Autumn: "autumn";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Spring: "spring";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Summer: "summer";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Winter: "winter";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TIMEZONE: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              acdt: "Australia/Adelaide";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              acst: "Australia/Adelaide";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              aedt: "Australia/Sydney";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              aest: "Australia/Sydney";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              awst: "Australia/Perth";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cdt: "America/Chicago";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cest: "Europe/Paris";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cet: "Europe/Paris";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cst: "America/Chicago";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              edt: "America/New_York";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eest: "Europe/Helsinki";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eet: "Europe/Helsinki";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              est: "America/New_York";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              gmt: "UTC";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ist: "Asia/Kolkata";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jst: "Asia/Tokyo";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mdt: "America/Denver";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mst: "America/Denver";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              npt: "Asia/Kathmandu";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nzdt: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nzst: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nzt: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pdt: "America/Los_Angeles";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pst: "America/Los_Angeles";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              utc: "UTC";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WEEKDAY: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WEEKDAYS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Everyday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Monday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Tuesday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Wednesday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Thursday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Friday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Saturday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "Sunday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ZONED_DATE_TIME: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "value",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "timeZoneId",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "calendarId",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "monthCode",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "offset",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "timeZone",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "calendar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "year",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "month",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "day",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "hour",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "minute",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "second",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "yy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mm",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "wy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ww",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "woy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "dd",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "hh",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "mi",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ss",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ms",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "us",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "ns",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              public-reachable enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CACHE: EnumifyType<{ Off: false; On: true; Refresh: "refresh" }>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cache operation modes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                COMPASS: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            East: "east";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Equator: "equator";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            North: "north";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            South: "south";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            West: "west";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cardinal directions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CONFIG: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "config",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "parse",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "value",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "intl",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "localeInfo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "store",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "discovery",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "debug",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "catch",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "silent",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "timeZone",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "calendar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "locale",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "sphere",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "geo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "latitude",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "lat",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "longitude",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "lng",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "timeStamp",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "registry",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "plugins",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "extends",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "cache",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DURATION: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        day: 86400;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hour: 3600;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        microsecond: 0.000001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        millisecond: 0.001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minute: 60;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        month: 2628000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nanosecond: 1e-9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        second: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        week: 604800;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        year: 31536000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                number of seconds in a time unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DURATIONS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        days: 86400000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hours: 3600000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        microseconds: 0.001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        milliseconds: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minutes: 60000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        months: 2628000000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nanoseconds: 0.000001;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        seconds: 1000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        weeks: 604800000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        years: 31536000000;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                number of milliseconds in a time unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ELEMENT: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dd: "day";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hh: "hour";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mi: "minute";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mm: "month";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ms: "millisecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ns: "nanosecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ss: "second";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        us: "microsecond";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        woy: "week";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ww: "week";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        yy: "year";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "[hasInstance]"(instance: any): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count<T extends Property<any>>(enumObj: T): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        entries<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): readonly (readonly [KeyOf<T>, ValueOf<T>])[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extend<const E extends any[] | Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            list: E,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            frozen?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): EnumifyType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): ValueOf<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        has<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): key is KeyOf<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasOwn<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: string | number | symbol | KeyOf<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): key is KeyOf<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includes<T extends Property<any>>(enumObj: T, search: any): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        invert<T extends Property<any>>(enumObj: T): Readonly<Invert<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyOf<T extends Property<any>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enumObj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): KeyOf<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keys<T extends Property<any>>(enumObj: T): readonly KeyOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        values<T extends Property<any>>(enumObj: T): readonly ValueOf<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FORMAT: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            date: "{yyyy}-{mm}-{dd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dayDate: "{dd}-{mmm}-{yyyy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dayMonth: "{dd}-{mmm}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            display: "{www}, {dd} {mmm} {yyyy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            logStamp: "{ymd}T{hms}.{ff}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            time: "{hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            weekDate: "{www}, {yyyy}-{mmm}-{dd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            yearMonth: "{yyyy}{mm}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            yearMonthDay: "{ymd}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            yearWeek: "{yw}{wy}";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                common format aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LIMIT: Readonly<{ get maxTempo(): bigint; get minTempo(): bigint }>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Temporal limits (min/max date bounds)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LOCALE: Readonly<Record<string, Record<string, any>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                localized dictionary translations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MODE: EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict" }>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                initialization strategies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MONTH: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "All",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Jan",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Feb",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Mar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Apr",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "May",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Jun",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Jul",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Aug",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Sep",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Oct",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Nov",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Dec",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Gregorian calendar months (short-form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MONTH_DAY: Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        layouts: readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly ["dayMonthYearShort", "monthDayYearShort"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly ["dayMonthYear", "monthDayYear"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        locales: readonly ["en-US", "en-AS"];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timezones: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "en-AS": readonly ["Pacific/Pago_Pago"];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "en-US": readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Adak",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Anchorage",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Boise",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Chicago",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Denver",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Detroit",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Indianapolis",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Knox",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Marengo",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Petersburg",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Tell_City",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Vevay",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Vincennes",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indiana/Winamac",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Indianapolis",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Juneau",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Kentucky/Louisville",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Kentucky/Monticello",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Los_Angeles",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Louisville",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Menominee",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Metlakatla",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/New_York",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Nome",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/North_Dakota/Beulah",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/North_Dakota/Center",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/North_Dakota/New_Salem",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Phoenix",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Sitka",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "America/Yakutat",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "Pacific/Honolulu",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Aleutian",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Alaska",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Arizona",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Central",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Eastern",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Mountain",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "US/Pacific",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                regional month-day-year parsing settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MONTHS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Every",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "January",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "February",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "March",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "April",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "May",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "June",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "July",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "August",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "September",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "October",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "November",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "December",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Gregorian calendar months (long-form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MUTATION: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "yy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mm",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "wy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ww",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "woy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "dd",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "hh",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mi",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ss",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ms",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "us",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ns",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "yw",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "yow",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "isoYear",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "isoyear",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "isoWeek",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "isoweek",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "event",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "period",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "clock",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "time",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "date",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "start",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mid",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "end",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NUMBER: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eight: 8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            five: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            four: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nine: 9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            one: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seven: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            six: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ten: 10;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            three: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            two: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zero: 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                number names (0-10)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ORDINAL: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current: 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eighth: 8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fifth: 5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            first: 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fourth: 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            last: -1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ninth: 9;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            second: 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seventh: 7;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sixth: 6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tenth: 10;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            third: 3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ordinal names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                PARSE: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "monthDay",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "planner",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "layoutOrder",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "preFilter",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mode",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "pivot",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "snippet",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "layout",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "event",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "period",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "anchor",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SEASON: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Autumn: "autumn";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Spring: "spring";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Summer: "summer";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Winter: "winter";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                calendar seasons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TIMEZONE: Extend<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acdt: "Australia/Adelaide";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acst: "Australia/Adelaide";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aedt: "Australia/Sydney";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aest: "Australia/Sydney";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            awst: "Australia/Perth";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cdt: "America/Chicago";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cest: "Europe/Paris";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cet: "Europe/Paris";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cst: "America/Chicago";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            edt: "America/New_York";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eest: "Europe/Helsinki";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eet: "Europe/Helsinki";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            est: "America/New_York";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gmt: "UTC";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ist: "Asia/Kolkata";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            jst: "Asia/Tokyo";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mdt: "America/Denver";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mst: "America/Denver";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            npt: "Asia/Kathmandu";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nzdt: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nzst: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nzt: "Pacific/Auckland";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pdt: "America/Los_Angeles";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pst: "America/Los_Angeles";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            utc: "UTC";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                common time-zone aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WEEKDAY: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Gregorian calendar week-days (short-form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WEEKDAYS: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Everyday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Monday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Tuesday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Wednesday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Thursday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Friday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Saturday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "Sunday",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Gregorian calendar week-days (long-form)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ZONED_DATE_TIME: EnumifyType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "value",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "timeZoneId",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "calendarId",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "monthCode",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "offset",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "timeZone",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "calendar",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "year",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "month",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "day",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "hour",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "minute",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "second",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "yy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mm",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "wy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ww",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "woy",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "dd",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "hh",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "mi",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ss",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ms",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "us",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "ns",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              diff --git a/packages/tempo/public/v4/api/variables/fmtTempo.html b/packages/tempo/public/v4/api/variables/fmtTempo.html new file mode 100644 index 00000000..5ad9c1d5 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/fmtTempo.html @@ -0,0 +1,36 @@ +fmtTempo | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Variable fmtTempoConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fmtTempo: Fmt = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                format a Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                diff --git a/packages/tempo/public/v4/api/variables/getStamp.html b/packages/tempo/public/v4/api/variables/getStamp.html new file mode 100644 index 00000000..88ce0925 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/getStamp.html @@ -0,0 +1,36 @@ +getStamp | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Variable getStampConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getStamp: Params<number | bigint> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  current timestamp (ts)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  diff --git a/packages/tempo/public/v4/api/variables/getTempo.html b/packages/tempo/public/v4/api/variables/getTempo.html new file mode 100644 index 00000000..689ce999 --- /dev/null +++ b/packages/tempo/public/v4/api/variables/getTempo.html @@ -0,0 +1,36 @@ +getTempo | Tempo API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tempo API + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Preparing search index...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Variable getTempoConst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getTempo: Params<Tempo> = ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    create new Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Member Visibility +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diff --git a/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.js b/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.js new file mode 100644 index 00000000..4a27d9d2 --- /dev/null +++ b/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.js @@ -0,0 +1,3 @@ +import{_ as n,o as s,c as i,j as t,a,a2 as o}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Contributing to Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"CONTRIBUTING.md","filePath":"CONTRIBUTING.md"}'),r={name:"CONTRIBUTING.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function p(h,e,c,u,m,g){return s(),i("div",null,[e[7]||(e[7]=t("h1",{id:"contributing-to-tempo",tabindex:"-1"},[a("Contributing to Tempo "),t("a",{class:"header-anchor",href:"#contributing-to-tempo","aria-label":'Permalink to "Contributing to Tempo"'},"​")],-1)),e[8]||(e[8]=t("p",null,[a("Thank you for your interest in contributing to Tempo! This project is a professional-grade date-time utility built on top of the native "),t("code",null,"Temporal"),a(" API. To maintain the high performance and architectural integrity of the library, please follow these guidelines.")],-1)),e[9]||(e[9]=t("h2",{id:"🏗️-project-architecture",tabindex:"-1"},[a("🏗️ Project Architecture "),t("a",{class:"header-anchor",href:"#🏗️-project-architecture","aria-label":'Permalink to "🏗️ Project Architecture"'},"​")],-1)),e[10]||(e[10]=t("p",null,"Tempo uses several advanced JavaScript patterns that contributors should be familiar with:",-1)),t("ul",null,[t("li",null,[e[2]||(e[2]=t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/lazy-evaluation-pattern.html"},"Proxy-Delegators")],-1)),e[3]||(e[3]=a(": For ",-1)),t("mjx-container",l,[(s(),i("svg",d,[...e[0]||(e[0]=[o('',1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=a(" lazy evaluation of instance properties.",-1))]),e[5]||(e[5]=t("li",null,[t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/soft_freeze_strategy.html"},"Soft Freeze")]),a(": For secure but extensible global registries.")],-1)),e[6]||(e[6]=t("li",null,[t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/architecture.html"},"Diagnostic Engine")]),a(": For decoupled, symbol-based diagnostic logging.")],-1))]),e[11]||(e[11]=o(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Local Development ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prerequisites ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Node.js 20+ (Tempo requires native Temporal support or a robust environment; Node 22.0.x native Temporal has known instabilities, so a polyfill like @js-temporal/polyfill is highly recommended).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • npm v9+ (For monorepo workspace support).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Setup ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git clone https://github.com/magmacomputing/magma.git
+cd magma
+npm install

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Building ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a TypeScript project that compiles to ES2022.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm run build -w @magmacomputing/tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Testing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We use Vitest for our test suite. All new features or bug fixes must include corresponding tests.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Run all tests: npm run test
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Run distribution tests: npm run test:dist (Tests the compiled dist/ bundles)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Run CI environment tests: npm run test:ci (Runs with fixed timezone America/New_York)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Interactive Watch mode: npx vitest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORTANT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero State Contamination: Tests must be idempotent. If your test modifies a global registry (e.g., Tempo.use), ensure you use the using keyword or manually call Tempo[Symbol.dispose]() to reset the engine for the next test.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Coding Standards ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Private Fields: Use native #private fields for internal state that should not be accessible via Proxies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Internal Symbols: Use the symbols exported from tempo.symbol.ts for cross-module internal communication.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Immutability: Tempo instances are strictly immutable. Any method that changes state must return a new instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Documentation: If you change a public API, please update the corresponding .md file in the doc/ directory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Pull Request Process ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Create a new branch for your feature or fix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Ensure the test suite passes at 100%.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Update the CHANGELOG.md with a brief description of your changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Open a Pull Request and describe the problem you are solving and your technical approach.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is maintained by Magma Computing. For commercial support or architectural consulting, please reach out via the Contact Page.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18))])}const k=n(r,[["render",p]]);export{b as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.lean.js b/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.lean.js new file mode 100644 index 00000000..3157ab43 --- /dev/null +++ b/packages/tempo/public/v4/assets/CONTRIBUTING.md.CcocJclI.lean.js @@ -0,0 +1 @@ +import{_ as n,o as s,c as i,j as t,a,a2 as o}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Contributing to Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"CONTRIBUTING.md","filePath":"CONTRIBUTING.md"}'),r={name:"CONTRIBUTING.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function p(h,e,c,u,m,g){return s(),i("div",null,[e[7]||(e[7]=t("h1",{id:"contributing-to-tempo",tabindex:"-1"},[a("Contributing to Tempo "),t("a",{class:"header-anchor",href:"#contributing-to-tempo","aria-label":'Permalink to "Contributing to Tempo"'},"​")],-1)),e[8]||(e[8]=t("p",null,[a("Thank you for your interest in contributing to Tempo! This project is a professional-grade date-time utility built on top of the native "),t("code",null,"Temporal"),a(" API. To maintain the high performance and architectural integrity of the library, please follow these guidelines.")],-1)),e[9]||(e[9]=t("h2",{id:"🏗️-project-architecture",tabindex:"-1"},[a("🏗️ Project Architecture "),t("a",{class:"header-anchor",href:"#🏗️-project-architecture","aria-label":'Permalink to "🏗️ Project Architecture"'},"​")],-1)),e[10]||(e[10]=t("p",null,"Tempo uses several advanced JavaScript patterns that contributors should be familiar with:",-1)),t("ul",null,[t("li",null,[e[2]||(e[2]=t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/lazy-evaluation-pattern.html"},"Proxy-Delegators")],-1)),e[3]||(e[3]=a(": For ",-1)),t("mjx-container",l,[(s(),i("svg",d,[...e[0]||(e[0]=[o("",1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=a(" lazy evaluation of instance properties.",-1))]),e[5]||(e[5]=t("li",null,[t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/soft_freeze_strategy.html"},"Soft Freeze")]),a(": For secure but extensible global registries.")],-1)),e[6]||(e[6]=t("li",null,[t("strong",null,[t("a",{href:"./doc/5-architecture-and-internals/architecture.html"},"Diagnostic Engine")]),a(": For decoupled, symbol-based diagnostic logging.")],-1))]),e[11]||(e[11]=o("",18))])}const k=n(r,[["render",p]]);export{b as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/README.md.BEdbpgCY.js b/packages/tempo/public/v4/assets/README.md.BEdbpgCY.js new file mode 100644 index 00000000..40c866d5 --- /dev/null +++ b/packages/tempo/public/v4/assets/README.md.BEdbpgCY.js @@ -0,0 +1,42 @@ +import{_ as a,o as t,c as e,j as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"","description":"","frontmatter":{},"headers":[],"relativePath":"README.md","filePath":"README.md"}'),l={name:"README.md"};function p(o,i,r,h,g,k){return t(),e("div",null,[...i[0]||(i[0]=[s("table",null,[s("tbody",null,[s("tr",null,[s("td",{width:"100",valign:"top"},[s("img",{src:"https://raw.githubusercontent.com/magmacomputing/magma/main/packages/tempo/img/tempo-logo.svg",width:"90",height:"90",alt:"Tempo Logo"})]),s("td",{valign:"middle"},[s("h1",{style:{"border-bottom":"none","margin-bottom":"0"}},"Tempo"),s("p",{style:{"font-weight":"600","font-size":"1.1rem",color:"#2c3e50","margin-top":"0"}},"The Professional Date-Time Library for the Temporal API")])])])],-1),n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a premium, high-performance wrapper for the ECMAScript Temporal API. Designed for professionals, it combines immutable state-management with a fluent, natural-language engine. It is the modern, type-safe successor to legacy libraries like Moment.js and Luxon.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Our Mission: Humanizing Temporal. Bringing developer intuition, cultural awareness, and expressive natural-language ergonomics to JavaScript dates—anchored in a rock-solid ISO 8601 baseline. Read our vision & architecture →

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version Socket Security Temporal Documentation Live Interactive REPL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Quick Start ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+// 🔌 Instantly Extensible (with deterministic defaults)
+Tempo.init({ 
+  plugins: [CelestialPlugin],
+  timeZone: 'America/New_York'
+});
+
+// 🎯 Natural Language Parsing (Deterministic anchor)
+const event = new Tempo('next Friday 3pm', { anchor: '2026-10-15' });
+
+// 🔄 Fluent Mutations (Immutable)
+const reminder = event.add({ hours: 2 }).set({ minute: 0 });
+
+// ⏳ Comparative Durations
+const diff = event.until('2026-12-25');
+console.log(diff.iso); // P2M2D
+
+// 📝 Beautiful Formatting
+console.log(event.format('{mon} {dd:ord}, {yyyy}')); // October 23rd, 2026
+
+// 🌌 Domain Logic (via Plugin)
+console.log(event.term.astronomy.season); // 'Autumn'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo       # npm
+yarn add @magmacomputing/tempo          # yarn
+pnpm add @magmacomputing/tempo          # pnpm
+bun add @magmacomputing/tempo           # bun
+deno add npm:@magmacomputing/tempo      # deno

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runtime Support: Requires Node.js >= 20.0.0 (Recommended: Node 24 LTS or Node >= 26.10.0 with full native Temporal support).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Browser & Native Environments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For standard usage natively in the browser, use the pre-optimized Global ESM Bundle. It includes the entire core engine in a single file:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.esm.js"
+  }
+}
+</script>
+
+<script type="module">
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  
+  const t = new Tempo('next Friday');
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced Usage (Tempo Plugins & CDNs) If you need to use Tempo Plugins natively in the browser, require granular module resolution, or want to use on-the-fly bundling CDNs (like esm.sh), please see our comprehensive Installation Guide for detailed import map configurations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏳ Why Tempo? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While the native Temporal API gives you perfect primitives (ZonedDateTime, PlainDate), it doesn't give you business logic. Tempo bridges that gap.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureNative Temporal APIThe Tempo Ecosystem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PrimitivesPerfect (Instant, ZonedDateTime)Powered by Native Primitives ✨
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TimezonesIANA String SupportAdvanced fallback & auto-syncing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Domain Logic❌ Build it yourself✅ Plugins (astro, sync)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural Language❌ Manual parsing✅ "next Friday 3pm"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Missing Domain Layer ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 🗣️ Natural Language & Smart Parsing: Parse natural language phrases (e.g. "next Friday 3pm", "two days ago") with zero-cost lazy evaluation and functional aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 🌍 Zero-Bundle Localization: Multi-language date parsing and formatting powered natively by ECMAScript Intl—no heavy static locale dictionaries required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 🧩 Extensible & AI-Ready: Modular plugin ecosystem for astronomical cycles (astro), financial quarters (finance), schedulers (ticker), and LLM-powered parsing (ai).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 🏗️ Future-Proof & Ultra-Lightweight: Built natively on the TC39 Stage 4 Temporal foundation with zero legacy runtime baggage and full tree-shaking support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For a deeper dive into the API, architecture, and advanced features:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧰 The Tempo Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is the core library, but the ecosystem extends further:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PackageDescriptionDocs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempoCore library — parsing, formatting, natural-language engineDocumentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-fnsPure functional utilities built on native Temporal & Tempo — tree-shakeable helpersDocumentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-*Official & community plugins — AI, Ticker, Astro, Finance, Sync, Snap, and morePlugin Ecosystem Catalog

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💬 Contact & Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Bug Reports & Features: Please open an Issue.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Questions & Ideas: Start a thread in Discussions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Direct Contact: You can reach us at hello@magmacomputing.com.au.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗳️ Feedback & Reactions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Premium!   |   ⭐ Loving it!   |   💡 Needs work   |   🐞 Found a bug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚖️ License ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distributed under the MIT License. See LICENSE for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,34)])])}const c=a(l,[["render",p]]);export{m as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/README.md.BEdbpgCY.lean.js b/packages/tempo/public/v4/assets/README.md.BEdbpgCY.lean.js new file mode 100644 index 00000000..d54ca613 --- /dev/null +++ b/packages/tempo/public/v4/assets/README.md.BEdbpgCY.lean.js @@ -0,0 +1 @@ +import{_ as a,o as t,c as e,j as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"","description":"","frontmatter":{},"headers":[],"relativePath":"README.md","filePath":"README.md"}'),l={name:"README.md"};function p(o,i,r,h,g,k){return t(),e("div",null,[...i[0]||(i[0]=[s("table",null,[s("tbody",null,[s("tr",null,[s("td",{width:"100",valign:"top"},[s("img",{src:"https://raw.githubusercontent.com/magmacomputing/magma/main/packages/tempo/img/tempo-logo.svg",width:"90",height:"90",alt:"Tempo Logo"})]),s("td",{valign:"middle"},[s("h1",{style:{"border-bottom":"none","margin-bottom":"0"}},"Tempo"),s("p",{style:{"font-weight":"600","font-size":"1.1rem",color:"#2c3e50","margin-top":"0"}},"The Professional Date-Time Library for the Temporal API")])])])],-1),n("",34)])])}const c=a(l,[["render",p]]);export{m as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.js b/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.js new file mode 100644 index 00000000..09a08cac --- /dev/null +++ b/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.js @@ -0,0 +1 @@ +import{_ as t,o as i,c as o,a2 as r}from"./chunks/framework.DNL3hc5c.js";const h=JSON.parse('{"title":"Security Policy","description":"","frontmatter":{},"headers":[],"relativePath":"SECURITY.md","filePath":"SECURITY.md"}'),a={name:"SECURITY.md"};function s(l,e,n,u,c,d){return i(),o("div",null,[...e[0]||(e[0]=[r('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Security Policy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Versions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The following table lists the versions of Magma projects that currently receive security updates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VersionSupported
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4.x✅
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    < 4.0❌

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reporting a Vulnerability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We take the security of Magma Computing projects and @magmacomputing/tempo seriously. If you believe you have discovered a security vulnerability, please follow responsible disclosure guidelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How to Report ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Do NOT report security vulnerabilities through public GitHub issues.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead, please report security issues by emailing our security team at: security@magmacomputing.com.au

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alternatively, you may submit a private security advisory through the Security tab of our GitHub repository: Submit Security Advisory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What to Include ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To help us investigate and resolve the issue quickly, please include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A detailed description of the vulnerability and potential impact.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Step-by-step instructions or proof-of-concept (PoC) code to reproduce the issue.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The package name and version affected (e.g. @magmacomputing/tempo@4.0.1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Any potential mitigations or suggested fixes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Response Timeline ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Acknowledgement: We will acknowledge receipt of your vulnerability report within 48 hours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Assessment & Fix: We aim to assess and patch verified vulnerabilities within 7 business days.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Public Disclosure: Public advisories and patched releases will be coordinated with the reporter after a fix is verified and deployed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Thank you for helping keep the open-source ecosystem secure!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',16)])])}const m=t(a,[["render",s]]);export{h as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.lean.js b/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.lean.js new file mode 100644 index 00000000..c271faaf --- /dev/null +++ b/packages/tempo/public/v4/assets/SECURITY.md.CSgJK_tg.lean.js @@ -0,0 +1 @@ +import{_ as t,o as i,c as o,a2 as r}from"./chunks/framework.DNL3hc5c.js";const h=JSON.parse('{"title":"Security Policy","description":"","frontmatter":{},"headers":[],"relativePath":"SECURITY.md","filePath":"SECURITY.md"}'),a={name:"SECURITY.md"};function s(l,e,n,u,c,d){return i(),o("div",null,[...e[0]||(e[0]=[r("",16)])])}const m=t(a,[["render",s]]);export{h as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/app.CbekdYod.js b/packages/tempo/public/v4/assets/app.CbekdYod.js new file mode 100644 index 00000000..5a1dcbe0 --- /dev/null +++ b/packages/tempo/public/v4/assets/app.CbekdYod.js @@ -0,0 +1,312 @@ +const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/chunks/sizeCapture-INFHLROL.Dsb_Hwxo.js","assets/chunks/framework.DNL3hc5c.js","assets/chunks/theme.BHijFyhG.js","assets/chunks/dagre-GXQ25YYZ.Bfcz7YMP.js","assets/chunks/layout.Bj1YlMtA.js","assets/chunks/swimlanes-42K2YHIH.DzZBAVKe.js","assets/chunks/cose-bilkent-JH36ORCC.DH3k0r7k.js","assets/chunks/cytoscape.esm.DdbNXSXN.js","assets/chunks/c4Diagram-7LVT6UL2.C1MP3r9C.js","assets/chunks/chunk-F27PBJKO.CcniKEe6.js","assets/chunks/flowDiagram-HODETNUW.ClPsWLK6.js","assets/chunks/chunk-5VM5RSS4.-zPOtr2J.js","assets/chunks/chunk-XXDRQBXY.C52oJrTB.js","assets/chunks/chunk-POPQ4Y6H.DEs7vhGS.js","assets/chunks/channel.DScgq80D.js","assets/chunks/swimlanesDiagram-VR7AAH4N.DfLXry6V.js","assets/chunks/erDiagram-RLTQ6QDP.BA9x2mfr.js","assets/chunks/gitGraphDiagram-WWUBYQGX.Cf6cAMBl.js","assets/chunks/chunk-2Q5K7J3B.3yPGAHkH.js","assets/chunks/chunk-JWPE2WC7.5yopTNlD.js","assets/chunks/cynefin-OW5HDTMX.C9PKCYHo.js","assets/chunks/ganttDiagram-EL5Y4UJY.xjuXBlhL.js","assets/chunks/linear.D7HjFZ5V.js","assets/chunks/init.Gi6I4Gst.js","assets/chunks/defaultLocale.DX6XiGOO.js","assets/chunks/infoDiagram-27XIBGKW.C3BlkN34.js","assets/chunks/pieDiagram-E7YTZNPT.C7NYDYqu.js","assets/chunks/arc.BFiNID6s.js","assets/chunks/ordinal.BYWQX77i.js","assets/chunks/quadrantDiagram-AXDQQJYC.Cm2_JhFa.js","assets/chunks/xychartDiagram-S5SC5T6Z.By1ew1_3.js","assets/chunks/requirementDiagram-BXWQKSXE.BhCYrhyS.js","assets/chunks/sequenceDiagram-WJ2MYXX4.9pY_tZ7u.js","assets/chunks/classDiagram-ZZMXUADV.BCySuZ6w.js","assets/chunks/chunk-TICWLB2K.E0Eenl49.js","assets/chunks/classDiagram-v2-VYDZK3BY.BCySuZ6w.js","assets/chunks/stateDiagram-D77RDMKH.teR48ecX.js","assets/chunks/chunk-IMKFNOWR.GyfNfwKa.js","assets/chunks/stateDiagram-v2-MP3YSRHH.ij9DA5rL.js","assets/chunks/journeyDiagram-3NMN7TZE.NTDjZdp_.js","assets/chunks/timeline-definition-24CTP7MA.XH_18yc2.js","assets/chunks/mindmap-definition-YA3MSWOX.Cc4iPRg4.js","assets/chunks/kanban-definition-UXKFOSKX.BU_et4EL.js","assets/chunks/sankeyDiagram-P5KCCOFB.Dat3kWim.js","assets/chunks/diagram-Z3DM3KII.CIAlmXh0.js","assets/chunks/diagram-UQ7AKVKN.gzh-btDB.js","assets/chunks/blockDiagram-I7D4REHJ.BO9kROxn.js","assets/chunks/diagram-S7CK7UJ4.BFoB1FMC.js","assets/chunks/architectureDiagram-5GKGNRK7.BaOScXd6.js","assets/chunks/diagram-VSXAHHWV.BOdI9TU8.js","assets/chunks/ishikawaDiagram-5VMMS53U.dqUjFnmd.js","assets/chunks/vennDiagram-4TSXK5OY.REB-xxGl.js","assets/chunks/diagram-VX7I27RA.CLNxhO1L.js","assets/chunks/wardleyDiagram-VM6X3IG4.DCCyph2y.js","assets/chunks/cynefinDiagram-5FMLGOSQ.Ebp3fBAZ.js","assets/chunks/railroadDiagram-O6MQD6OU.CLUHLRPG.js","assets/chunks/chunk-SVP7TREG.tNKCi1Yy.js","assets/chunks/ebnfDiagram-PWID7BFC.Dni2gpVx.js","assets/chunks/abnfDiagram-VCTEODGH.C-XKIPnK.js","assets/chunks/pegDiagram-XKGWAZYB.kTxCBLbr.js"])))=>i.map(i=>d[i]); +import{V as Et,u as Id,ap as Q0,v as Pd,x as J0,c as tx,n as ex,p as Zh,o as rx,R as kn,aq as ix,ar as sx,as as ox,am as ax,at as nx,au as lx,av as hx,aw as cx,an as ux,ax as dx,d as fx,s as px,ay as gx,az as mx,aA as yx,aB as xx}from"./chunks/framework.DNL3hc5c.js";import{R as Cx}from"./chunks/theme.BHijFyhG.js";var Rd=Object.defineProperty,p=(e,t)=>Rd(e,"name",{value:t,configurable:!0}),bx=(e,t)=>{for(var r in t)Rd(e,r,{get:t[r],enumerable:!0})},wn=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function fl(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var Nd={exports:{}};(function(e,t){(function(r,i){e.exports=i()})(wn,(function(){var r=1e3,i=6e4,s=36e5,o="millisecond",a="second",n="minute",l="hour",c="day",h="week",u="month",d="quarter",f="year",m="date",y="Invalid Date",x=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,C=/\[([^\]]+)]|YYYY|YY|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,k={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function($){var I=["th","st","nd","rd"],B=$%100;return"["+$+(I[(B-20)%10]||I[B]||I[0])+"]"}},T=function($,I,B){var q=String($);return!q||q.length>=I?$:""+Array(I+1-q.length).join(B)+$},S={s:T,z:function($){var I=-$.utcOffset(),B=Math.abs(I),q=Math.floor(B/60),O=B%60;return(I<=0?"+":"-")+T(q,2,"0")+":"+T(O,2,"0")},m:function $(I,B){if(I.date()1)return $(tt[0])}else{var gt=I.name;A[gt]=I,O=gt}return!q&&O&&(v=O),O||!q&&v},U=function($,I){if(F($))return $.clone();var B=typeof I=="object"?I:{};return B.date=$,B.args=arguments,new st(B)},N=S;N.l=Z,N.i=F,N.w=function($,I){return U($,{locale:I.$L,utc:I.$u,x:I.$x,$offset:I.$offset})};var st=(function(){function $(B){this.$L=Z(B.locale,null,!0),this.parse(B),this.$x=this.$x||B.x||{},this[L]=!0}var I=$.prototype;return I.parse=function(B){this.$d=(function(q){var O=q.date,it=q.utc;if(O===null)return new Date(NaN);if(N.u(O))return new Date;if(O instanceof Date)return new Date(O);if(typeof O=="string"&&!/Z$/i.test(O)){var tt=O.match(x);if(tt){var gt=tt[2]-1||0,ht=(tt[7]||"0").substring(0,3);return it?new Date(Date.UTC(tt[1],gt,tt[3]||1,tt[4]||0,tt[5]||0,tt[6]||0,ht)):new Date(tt[1],gt,tt[3]||1,tt[4]||0,tt[5]||0,tt[6]||0,ht)}}return new Date(O)})(B),this.init()},I.init=function(){var B=this.$d;this.$y=B.getFullYear(),this.$M=B.getMonth(),this.$D=B.getDate(),this.$W=B.getDay(),this.$H=B.getHours(),this.$m=B.getMinutes(),this.$s=B.getSeconds(),this.$ms=B.getMilliseconds()},I.$utils=function(){return N},I.isValid=function(){return this.$d.toString()!==y},I.isSame=function(B,q){var O=U(B);return this.startOf(q)<=O&&O<=this.endOf(q)},I.isAfter=function(B,q){return U(B){},"trace"),debug:p((...e)=>{},"debug"),info:p((...e)=>{},"info"),warn:p((...e)=>{},"warn"),error:p((...e)=>{},"error"),fatal:p((...e)=>{},"fatal")},pl=p(function(e="fatal"){let t=xr.fatal;typeof e=="string"?e.toLowerCase()in xr&&(t=xr[e]):typeof e=="number"&&(t=e),R.trace=()=>{},R.debug=()=>{},R.info=()=>{},R.warn=()=>{},R.error=()=>{},R.fatal=()=>{},t<=xr.fatal&&(R.fatal=console.error?console.error.bind(console,qe("FATAL"),"color: orange"):console.log.bind(console,"\x1B[35m",qe("FATAL"))),t<=xr.error&&(R.error=console.error?console.error.bind(console,qe("ERROR"),"color: orange"):console.log.bind(console,"\x1B[31m",qe("ERROR"))),t<=xr.warn&&(R.warn=console.warn?console.warn.bind(console,qe("WARN"),"color: orange"):console.log.bind(console,"\x1B[33m",qe("WARN"))),t<=xr.info&&(R.info=console.info?console.info.bind(console,qe("INFO"),"color: lightblue"):console.log.bind(console,"\x1B[34m",qe("INFO"))),t<=xr.debug&&(R.debug=console.debug?console.debug.bind(console,qe("DEBUG"),"color: lightgreen"):console.log.bind(console,"\x1B[32m",qe("DEBUG"))),t<=xr.trace&&(R.trace=console.debug?console.debug.bind(console,qe("TRACE"),"color: lightgreen"):console.log.bind(console,"\x1B[32m",qe("TRACE")))},"setLogLevel"),qe=p(e=>`%c${wx().format("ss.SSS")} : ${e} : `,"format");const no={min:{r:0,g:0,b:0,s:0,l:0,a:0},max:{r:255,g:255,b:255,h:360,s:100,l:100,a:1},clamp:{r:e=>e>=255?255:e<0?0:e,g:e=>e>=255?255:e<0?0:e,b:e=>e>=255?255:e<0?0:e,h:e=>e%360,s:e=>e>=100?100:e<0?0:e,l:e=>e>=100?100:e<0?0:e,a:e=>e>=1?1:e<0?0:e},toLinear:e=>{const t=e/255;return e>.03928?Math.pow((t+.055)/1.055,2.4):t/12.92},hue2rgb:(e,t,r)=>(r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*(2/3-r)*6:e),hsl2rgb:({h:e,s:t,l:r},i)=>{if(!t)return r*2.55;e/=360,t/=100,r/=100;const s=r<.5?r*(1+t):r+t-r*t,o=2*r-s;switch(i){case"r":return no.hue2rgb(o,s,e+1/3)*255;case"g":return no.hue2rgb(o,s,e)*255;case"b":return no.hue2rgb(o,s,e-1/3)*255}},rgb2hsl:({r:e,g:t,b:r},i)=>{e/=255,t/=255,r/=255;const s=Math.max(e,t,r),o=Math.min(e,t,r),a=(s+o)/2;if(i==="l")return a*100;if(s===o)return 0;const n=s-o,l=a>.5?n/(2-s-o):n/(s+o);if(i==="s")return l*100;switch(s){case e:return((t-r)/n+(tt>r?Math.min(t,Math.max(r,e)):Math.min(r,Math.max(t,e)),round:e=>Math.round(e*1e10)/1e10},_x={dec2hex:e=>{const t=Math.round(e).toString(16);return t.length>1?t:`0${t}`}},Lt={channel:no,lang:Tx,unit:_x},Dr={};for(let e=0;e<=255;e++)Dr[e]=Lt.unit.dec2hex(e);const me={ALL:0,RGB:1,HSL:2};let Sx=class{constructor(){this.type=me.ALL}get(){return this.type}set(t){if(this.type&&this.type!==t)throw new Error("Cannot change both RGB and HSL channels at the same time");this.type=t}reset(){this.type=me.ALL}is(t){return this.type===t}};class vx{constructor(t,r){this.color=r,this.changed=!1,this.data=t,this.type=new Sx}set(t,r){return this.color=r,this.changed=!1,this.data=t,this.type.type=me.ALL,this}_ensureHSL(){const t=this.data,{h:r,s:i,l:s}=t;r===void 0&&(t.h=Lt.channel.rgb2hsl(t,"h")),i===void 0&&(t.s=Lt.channel.rgb2hsl(t,"s")),s===void 0&&(t.l=Lt.channel.rgb2hsl(t,"l"))}_ensureRGB(){const t=this.data,{r,g:i,b:s}=t;r===void 0&&(t.r=Lt.channel.hsl2rgb(t,"r")),i===void 0&&(t.g=Lt.channel.hsl2rgb(t,"g")),s===void 0&&(t.b=Lt.channel.hsl2rgb(t,"b"))}get r(){const t=this.data,r=t.r;return!this.type.is(me.HSL)&&r!==void 0?r:(this._ensureHSL(),Lt.channel.hsl2rgb(t,"r"))}get g(){const t=this.data,r=t.g;return!this.type.is(me.HSL)&&r!==void 0?r:(this._ensureHSL(),Lt.channel.hsl2rgb(t,"g"))}get b(){const t=this.data,r=t.b;return!this.type.is(me.HSL)&&r!==void 0?r:(this._ensureHSL(),Lt.channel.hsl2rgb(t,"b"))}get h(){const t=this.data,r=t.h;return!this.type.is(me.RGB)&&r!==void 0?r:(this._ensureRGB(),Lt.channel.rgb2hsl(t,"h"))}get s(){const t=this.data,r=t.s;return!this.type.is(me.RGB)&&r!==void 0?r:(this._ensureRGB(),Lt.channel.rgb2hsl(t,"s"))}get l(){const t=this.data,r=t.l;return!this.type.is(me.RGB)&&r!==void 0?r:(this._ensureRGB(),Lt.channel.rgb2hsl(t,"l"))}get a(){return this.data.a}set r(t){this.type.set(me.RGB),this.changed=!0,this.data.r=t}set g(t){this.type.set(me.RGB),this.changed=!0,this.data.g=t}set b(t){this.type.set(me.RGB),this.changed=!0,this.data.b=t}set h(t){this.type.set(me.HSL),this.changed=!0,this.data.h=t}set s(t){this.type.set(me.HSL),this.changed=!0,this.data.s=t}set l(t){this.type.set(me.HSL),this.changed=!0,this.data.l=t}set a(t){this.changed=!0,this.data.a=t}}const Go=new vx({r:0,g:0,b:0,a:0},"transparent"),Li={re:/^#((?:[a-f0-9]{2}){2,4}|[a-f0-9]{3})$/i,parse:e=>{if(e.charCodeAt(0)!==35)return;const t=e.match(Li.re);if(!t)return;const r=t[1],i=parseInt(r,16),s=r.length,o=s%4===0,a=s>4,n=a?1:17,l=a?8:4,c=o?0:-1,h=a?255:15;return Go.set({r:(i>>l*(c+3)&h)*n,g:(i>>l*(c+2)&h)*n,b:(i>>l*(c+1)&h)*n,a:o?(i&h)*n/255:1},e)},stringify:e=>{const{r:t,g:r,b:i,a:s}=e;return s<1?`#${Dr[Math.round(t)]}${Dr[Math.round(r)]}${Dr[Math.round(i)]}${Dr[Math.round(s*255)]}`:`#${Dr[Math.round(t)]}${Dr[Math.round(r)]}${Dr[Math.round(i)]}`}},Jr={re:/^hsla?\(\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?(?:deg|grad|rad|turn)?)\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?%)\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?%)(?:\s*?(?:,|\/)\s*?\+?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?(%)?))?\s*?\)$/i,hueRe:/^(.+?)(deg|grad|rad|turn)$/i,_hue2deg:e=>{const t=e.match(Jr.hueRe);if(t){const[,r,i]=t;switch(i){case"grad":return Lt.channel.clamp.h(parseFloat(r)*.9);case"rad":return Lt.channel.clamp.h(parseFloat(r)*180/Math.PI);case"turn":return Lt.channel.clamp.h(parseFloat(r)*360)}}return Lt.channel.clamp.h(parseFloat(e))},parse:e=>{const t=e.charCodeAt(0);if(t!==104&&t!==72)return;const r=e.match(Jr.re);if(!r)return;const[,i,s,o,a,n]=r;return Go.set({h:Jr._hue2deg(i),s:Lt.channel.clamp.s(parseFloat(s)),l:Lt.channel.clamp.l(parseFloat(o)),a:a?Lt.channel.clamp.a(n?parseFloat(a)/100:parseFloat(a)):1},e)},stringify:e=>{const{h:t,s:r,l:i,a:s}=e;return s<1?`hsla(${Lt.lang.round(t)}, ${Lt.lang.round(r)}%, ${Lt.lang.round(i)}%, ${s})`:`hsl(${Lt.lang.round(t)}, ${Lt.lang.round(r)}%, ${Lt.lang.round(i)}%)`}},ms={colors:{aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyanaqua:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",rebeccapurple:"#663399",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",transparent:"#00000000",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"},parse:e=>{e=e.toLowerCase();const t=ms.colors[e];if(t)return Li.parse(t)},stringify:e=>{const t=Li.stringify(e);for(const r in ms.colors)if(ms.colors[r]===t)return r}},os={re:/^rgba?\(\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))(?:\s*?(?:,|\/)\s*?\+?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?)))?\s*?\)$/i,parse:e=>{const t=e.charCodeAt(0);if(t!==114&&t!==82)return;const r=e.match(os.re);if(!r)return;const[,i,s,o,a,n,l,c,h]=r;return Go.set({r:Lt.channel.clamp.r(s?parseFloat(i)*2.55:parseFloat(i)),g:Lt.channel.clamp.g(a?parseFloat(o)*2.55:parseFloat(o)),b:Lt.channel.clamp.b(l?parseFloat(n)*2.55:parseFloat(n)),a:c?Lt.channel.clamp.a(h?parseFloat(c)/100:parseFloat(c)):1},e)},stringify:e=>{const{r:t,g:r,b:i,a:s}=e;return s<1?`rgba(${Lt.lang.round(t)}, ${Lt.lang.round(r)}, ${Lt.lang.round(i)}, ${Lt.lang.round(s)})`:`rgb(${Lt.lang.round(t)}, ${Lt.lang.round(r)}, ${Lt.lang.round(i)})`}},nr={format:{keyword:ms,hex:Li,rgb:os,rgba:os,hsl:Jr,hsla:Jr},parse:e=>{if(typeof e!="string")return e;const t=Li.parse(e)||os.parse(e)||Jr.parse(e)||ms.parse(e);if(t)return t;throw new Error(`Unsupported color format: "${e}"`)},stringify:e=>!e.changed&&e.color?e.color:e.type.is(me.HSL)||e.data.r===void 0?Jr.stringify(e):e.a<1||!Number.isInteger(e.r)||!Number.isInteger(e.g)||!Number.isInteger(e.b)?os.stringify(e):Li.stringify(e)},qd=(e,t)=>{const r=nr.parse(e);for(const i in t)r[i]=Lt.channel.clamp[i](t[i]);return nr.stringify(r)},qr=(e,t,r=0,i=1)=>{if(typeof e!="number")return qd(e,{a:t});const s=Go.set({r:Lt.channel.clamp.r(e),g:Lt.channel.clamp.g(t),b:Lt.channel.clamp.b(r),a:Lt.channel.clamp.a(i)});return nr.stringify(s)},Bx=e=>{const{r:t,g:r,b:i}=nr.parse(e),s=.2126*Lt.channel.toLinear(t)+.7152*Lt.channel.toLinear(r)+.0722*Lt.channel.toLinear(i);return Lt.lang.round(s)},Lx=e=>Bx(e)>=.5,Ze=e=>!Lx(e),zd=(e,t,r)=>{const i=nr.parse(e),s=i[t],o=Lt.channel.clamp[t](s+r);return s!==o&&(i[t]=o),nr.stringify(i)},z=(e,t)=>zd(e,"l",t),W=(e,t)=>zd(e,"l",-t),b=(e,t)=>{const r=nr.parse(e),i={};for(const s in t)t[s]&&(i[s]=r[s]+t[s]);return qd(e,i)},Fx=(e,t,r=50)=>{const{r:i,g:s,b:o,a}=nr.parse(e),{r:n,g:l,b:c,a:h}=nr.parse(t),u=r/100,d=u*2-1,f=a-h,y=((d*f===-1?d:(d+f)/(1+d*f))+1)/2,x=1-y,C=i*y+n*x,k=s*y+l*x,T=o*y+c*x,S=a*u+h*(1-u);return qr(C,k,T,S)},E=(e,t=100)=>{const r=nr.parse(e);return r.r=255-r.r,r.g=255-r.g,r.b=255-r.b,Fx(r,e,t)};/*! @license DOMPurify 3.4.13 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.13/LICENSE */function Kh(e,t){(t==null||t>e.length)&&(t=e.length);for(var r=0,i=Array(t);r2?i-2:0),o=2;o1?r-1:0),s=1;s"u"?null:ie(BigInt.prototype.toString),ic=typeof Symbol>"u"?null:ie(Symbol.prototype.toString),oe=ie(Object.prototype.hasOwnProperty),Zi=ie(Object.prototype.toString),se=ie(RegExp.prototype.test),Gr=Hx(TypeError);function ie(e){return function(t){t instanceof RegExp&&(t.lastIndex=0);for(var r=arguments.length,i=new Array(r>1?r-1:0),s=1;s2&&arguments[2]!==void 0?arguments[2]:as;if(Qh&&Qh(e,null),!Pr(t))return e;let i=t.length;for(;i--;){let s=t[i];if(typeof s=="string"){const o=r(s);o!==s&&(Dx(t)||(t[i]=o),s=o)}e[s]=!0}return e}function Yx(e){for(let t=0;t/g),Kx=ue(/\${[\w\W]*/g),Qx=ue(/^data-[\-\w.\u00B7-\uFFFF]+$/),Jx=ue(/^aria-[\-\w]+$/),lc=ue(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),tC=ue(/^(?:\w+script|data):/i),eC=ue(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),rC=ue(/^html$/i),iC=ue(/^[a-z][.\w]*(-[.\w]+)+$/i),hc=ue(/<[/\w!]/g),cc=ue(/<[/\w]/g),sC=ue(/<\/no(script|embed|frames)/i),oC=ue(/\/>/i),Ie={element:1,attribute:2,text:3,cdataSection:4,entityReference:5,entityNode:6,processingInstruction:7,comment:8,document:9,documentType:10,documentFragment:11,notation:12},aC=function(){return typeof window>"u"?null:window},nC=function(t,r){if(typeof t!="object"||typeof t.createPolicy!="function")return null;let i=null;const s="data-tt-policy-suffix";r&&r.hasAttribute(s)&&(i=r.getAttribute(s));const o="dompurify"+(i?"#"+i:"");try{return t.createPolicy(o,{createHTML(a){return a},createScriptURL(a){return a}})}catch{return console.warn("TrustedTypes policy "+o+" could not be created."),null}},uc=function(){return{afterSanitizeAttributes:[],afterSanitizeElements:[],afterSanitizeShadowDOM:[],beforeSanitizeAttributes:[],beforeSanitizeElements:[],beforeSanitizeShadowDOM:[],uponSanitizeAttribute:[],uponSanitizeElement:[],uponSanitizeShadowNode:[]}},$r=function(t,r,i,s){return oe(t,r)&&Pr(t[r])?qt(s.base?ge(s.base):{},t[r],s.transform):i};function Yd(){let e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:aC();const t=ot=>Yd(ot);if(t.version="3.4.13",t.removed=[],!e||!e.document||e.document.nodeType!==Ie.document||!e.Element)return t.isSupported=!1,t;let r=e.document;const i=r,s=i.currentScript;e.DocumentFragment;const o=e.HTMLTemplateElement,a=e.Node,n=e.Element,l=e.NodeFilter,c=e.NamedNodeMap;c===void 0&&(e.NamedNodeMap||e.MozNamedAttrMap),e.HTMLFormElement;const h=e.DOMParser,u=e.trustedTypes,d=n.prototype,f=Ye(d,"cloneNode"),m=Ye(d,"remove"),y=Ye(d,"nextSibling"),x=Ye(d,"childNodes"),C=Ye(d,"parentNode"),k=Ye(d,"shadowRoot"),T=Ye(d,"attributes"),S=a&&a.prototype?Ye(a.prototype,"nodeType"):null,v=a&&a.prototype?Ye(a.prototype,"nodeName"):null,A=a&&a.prototype?Ye(a.prototype,"ownerDocument"):null;if(typeof o=="function"){const ot=r.createElement("template");ot.content&&ot.content.ownerDocument&&(r=ot.content.ownerDocument)}let L,F="",Z,U=!1,N=0;const st=function(){if(N>0)throw Gr('A configured TRUSTED_TYPES_POLICY callback (createHTML or createScriptURL) must not call DOMPurify.sanitize, as that causes infinite recursion. Do not pass a policy whose callbacks wrap DOMPurify as TRUSTED_TYPES_POLICY; see the "DOMPurify and Trusted Types" section of the README.')},Y=function(_){st(),N++;try{return L.createHTML(_)}finally{N--}},$=function(_){st(),N++;try{return L.createScriptURL(_)}finally{N--}},I=function(){return U||(Z=nC(u,s),U=!0),Z},B=r,q=B.implementation,O=B.createNodeIterator,it=B.createDocumentFragment,tt=B.getElementsByTagName,gt=i.importNode;let ht=uc();t.isSupported=typeof Wd=="function"&&typeof C=="function"&&q&&q.createHTMLDocument!==void 0;const Tt=Vx,Ft=Zx,Bt=Kx,pt=Qx,wt=Jx,Ot=tC,_t=eC,zt=iC;let Wt=lc,$t=null;const we=qt({},[...sc,...Ba,...La,...Fa,...oc]);let Pt=null;const pr=qt({},[...ac,...Aa,...nc,...Gs]);let jt=Object.seal(Ti(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),de=null,gr=null;const ve=Object.seal(Ti(null,{tagCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeCheck:{writable:!0,configurable:!1,enumerable:!0,value:null}}));let mr=!0,Je=!0,Er=!1,Be=!0,Le=!1,Te=!0,Fe=!1,yr=!1,g=null,M=null,j=!1,X=!1,H=!1,rt=!1,w=!0,P=!1;const J="user-content-";let G=!0,V=!1,Q={},K=null;const ut=qt({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","selectedcontent","style","svg","template","thead","title","video","xmp"]);let nt=null;const mt=qt({},["audio","video","img","source","image","track"]);let bt=null;const Dt=qt({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),Yt="http://www.w3.org/1998/Math/MathML",Ur="http://www.w3.org/2000/svg",fe="http://www.w3.org/1999/xhtml";let Ne=fe,xa=!1,Ca=null;const I0=qt({},[Yt,Ur,fe],va),Rh=ce(["mi","mo","mn","ms","mtext"]);let ba=qt({},Rh);const Nh=ce(["annotation-xml"]);let ka=qt({},Nh);const P0=qt({},["title","style","font","a","script"]);let ji=null;const R0=["application/xhtml+xml","text/html"],N0="text/html";let Kt=null,gi=null;const q0=r.createElement("form"),qh=function(_){return _ instanceof RegExp||_ instanceof Function},wa=function(){let _=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};if(gi&&gi===_)return;(!_||typeof _!="object")&&(_={}),_=ge(_),ji=R0.indexOf(_.PARSER_MEDIA_TYPE)===-1?N0:_.PARSER_MEDIA_TYPE,Kt=ji==="application/xhtml+xml"?va:as,$t=$r(_,"ALLOWED_TAGS",we,{transform:Kt}),Pt=$r(_,"ALLOWED_ATTR",pr,{transform:Kt}),Ca=$r(_,"ALLOWED_NAMESPACES",I0,{transform:va}),bt=$r(_,"ADD_URI_SAFE_ATTR",Dt,{transform:Kt,base:Dt}),nt=$r(_,"ADD_DATA_URI_TAGS",mt,{transform:Kt,base:mt}),K=$r(_,"FORBID_CONTENTS",ut,{transform:Kt}),de=$r(_,"FORBID_TAGS",ge({}),{transform:Kt}),gr=$r(_,"FORBID_ATTR",ge({}),{transform:Kt}),Q=oe(_,"USE_PROFILES")?_.USE_PROFILES&&typeof _.USE_PROFILES=="object"?ge(_.USE_PROFILES):_.USE_PROFILES:!1,mr=_.ALLOW_ARIA_ATTR!==!1,Je=_.ALLOW_DATA_ATTR!==!1,Er=_.ALLOW_UNKNOWN_PROTOCOLS||!1,Be=_.ALLOW_SELF_CLOSE_IN_ATTR!==!1,Le=_.SAFE_FOR_TEMPLATES||!1,Te=_.SAFE_FOR_XML!==!1,Fe=_.WHOLE_DOCUMENT||!1,X=_.RETURN_DOM||!1,H=_.RETURN_DOM_FRAGMENT||!1,rt=_.RETURN_TRUSTED_TYPE||!1,j=_.FORCE_BODY||!1,w=_.SANITIZE_DOM!==!1,P=_.SANITIZE_NAMED_PROPS||!1,G=_.KEEP_CONTENT!==!1,V=_.IN_PLACE||!1,Wt=jx(_.ALLOWED_URI_REGEXP)?_.ALLOWED_URI_REGEXP:lc,Ne=typeof _.NAMESPACE=="string"?_.NAMESPACE:fe,ba=oe(_,"MATHML_TEXT_INTEGRATION_POINTS")&&_.MATHML_TEXT_INTEGRATION_POINTS&&typeof _.MATHML_TEXT_INTEGRATION_POINTS=="object"?ge(_.MATHML_TEXT_INTEGRATION_POINTS):qt({},Rh),ka=oe(_,"HTML_INTEGRATION_POINTS")&&_.HTML_INTEGRATION_POINTS&&typeof _.HTML_INTEGRATION_POINTS=="object"?ge(_.HTML_INTEGRATION_POINTS):qt({},Nh);const D=oe(_,"CUSTOM_ELEMENT_HANDLING")&&_.CUSTOM_ELEMENT_HANDLING&&typeof _.CUSTOM_ELEMENT_HANDLING=="object"?ge(_.CUSTOM_ELEMENT_HANDLING):Ti(null);if(jt=Ti(null),oe(D,"tagNameCheck")&&qh(D.tagNameCheck)&&(jt.tagNameCheck=D.tagNameCheck),oe(D,"attributeNameCheck")&&qh(D.attributeNameCheck)&&(jt.attributeNameCheck=D.attributeNameCheck),oe(D,"allowCustomizedBuiltInElements")&&typeof D.allowCustomizedBuiltInElements=="boolean"&&(jt.allowCustomizedBuiltInElements=D.allowCustomizedBuiltInElements),ue(jt),Le&&(Je=!1),H&&(X=!0),Q&&($t=qt({},oc),Pt=Ti(null),Q.html===!0&&(qt($t,sc),qt(Pt,ac)),Q.svg===!0&&(qt($t,Ba),qt(Pt,Aa),qt(Pt,Gs)),Q.svgFilters===!0&&(qt($t,La),qt(Pt,Aa),qt(Pt,Gs)),Q.mathMl===!0&&(qt($t,Fa),qt(Pt,nc),qt(Pt,Gs))),ve.tagCheck=null,ve.attributeCheck=null,oe(_,"ADD_TAGS")&&(typeof _.ADD_TAGS=="function"?ve.tagCheck=_.ADD_TAGS:Pr(_.ADD_TAGS)&&($t===we&&($t=ge($t)),qt($t,_.ADD_TAGS,Kt))),oe(_,"ADD_ATTR")&&(typeof _.ADD_ATTR=="function"?ve.attributeCheck=_.ADD_ATTR:Pr(_.ADD_ATTR)&&(Pt===pr&&(Pt=ge(Pt)),qt(Pt,_.ADD_ATTR,Kt))),oe(_,"ADD_URI_SAFE_ATTR")&&Pr(_.ADD_URI_SAFE_ATTR)&&qt(bt,_.ADD_URI_SAFE_ATTR,Kt),oe(_,"FORBID_CONTENTS")&&Pr(_.FORBID_CONTENTS)&&(K===ut&&(K=ge(K)),qt(K,_.FORBID_CONTENTS,Kt)),oe(_,"ADD_FORBID_CONTENTS")&&Pr(_.ADD_FORBID_CONTENTS)&&(K===ut&&(K=ge(K)),qt(K,_.ADD_FORBID_CONTENTS,Kt)),G&&($t["#text"]=!0),Fe&&qt($t,["html","head","body"]),$t.table&&(qt($t,["tbody"]),delete de.tbody),_.TRUSTED_TYPES_POLICY){if(typeof _.TRUSTED_TYPES_POLICY.createHTML!="function")throw Gr('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if(typeof _.TRUSTED_TYPES_POLICY.createScriptURL!="function")throw Gr('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');const et=L;L=_.TRUSTED_TYPES_POLICY;try{F=Y("")}catch(yt){throw L=et,yt}}else _.TRUSTED_TYPES_POLICY===null?(L=void 0,F=""):(L===void 0&&(L=I()),L&&typeof F=="string"&&(F=Y("")));ce&&ce(_),gi=_},zh=qt({},[...Ba,...La,...Gx]),Wh=qt({},[...Fa,...Xx]),z0=function(_,D,et){return D.namespaceURI===fe?_==="svg":D.namespaceURI===Yt?_==="svg"&&(et==="annotation-xml"||ba[et]):!!zh[_]},W0=function(_,D,et){return D.namespaceURI===fe?_==="math":D.namespaceURI===Ur?_==="math"&&ka[et]:!!Wh[_]},H0=function(_,D,et){return D.namespaceURI===Ur&&!ka[et]||D.namespaceURI===Yt&&!ba[et]?!1:!Wh[_]&&(P0[_]||!zh[_])},Y0=function(_){let D=C(_);(!D||!D.tagName)&&(D={namespaceURI:Ne,tagName:"template"});const et=as(_.tagName),yt=as(D.tagName);return Ca[_.namespaceURI]?_.namespaceURI===Ur?z0(et,D,yt):_.namespaceURI===Yt?W0(et,D,yt):_.namespaceURI===fe?H0(et,D,yt):!!(ji==="application/xhtml+xml"&&Ca[_.namespaceURI]):!1},Mr=function(_){xi(t.removed,{element:_});try{C(_).removeChild(_)}catch{if(m(_),!C(_))throw Gr("a node selected for removal could not be detached from its tree and cannot be safely returned; refusing to sanitize in place")}},Hs=function(_){Gi(_);const D=x(_);if(D){const yt=[];yi(D,kt=>{xi(yt,kt)}),yi(yt,kt=>{try{m(kt)}catch{}})}const et=T(_);if(et)for(let yt=et.length-1;yt>=0;--yt){const kt=et[yt],Mt=kt&&kt.name;if(typeof Mt=="string")try{_.removeAttribute(Mt)}catch{}}},jr=function(_,D){try{xi(t.removed,{attribute:D.getAttributeNode(_),from:D})}catch{xi(t.removed,{attribute:null,from:D})}if(D.removeAttribute(_),_==="is")if(X||H)try{Mr(D)}catch{}else try{D.setAttribute(_,"")}catch{}},U0=function(_){const D=T(_);if(D)for(let et=D.length-1;et>=0;--et){const yt=D[et],kt=yt&&yt.name;if(!(typeof kt!="string"||Pt[Kt(kt)]))try{_.removeAttribute(kt)}catch{}}},Gi=function(_){const D=[_];for(;D.length>0;){const et=D.pop();(S?S(et):et.nodeType)===Ie.element&&U0(et);const kt=x(et);if(kt)for(let Mt=kt.length-1;Mt>=0;--Mt)D.push(kt[Mt])}},j0=function(_){if(!Te)return;const D=[_];for(;D.length>0;){const et=D.pop(),yt=S?S(et):et.nodeType;if(yt===Ie.processingInstruction||yt===Ie.comment&&se(cc,et.data)){try{m(et)}catch{}continue}if(yt===Ie.element){const Mt=et,Gt=Kt(v?v(et):et.nodeName);try{Mt.hasAttribute&&Mt.hasAttribute("patchsrc")&&Mt.removeAttribute("patchsrc"),Mt.hasAttribute&&Mt.hasAttribute("for")&&Gt!=="label"&&Gt!=="output"&&Mt.removeAttribute("for")}catch{}}const kt=x(et);if(kt)for(let Mt=kt.length-1;Mt>=0;--Mt)D.push(kt[Mt])}},Hh=function(_){let D=null,et=null;if(j)_=""+_;else{const Mt=tc(_,/^[\r\n\t ]+/);et=Mt&&Mt[0]}ji==="application/xhtml+xml"&&Ne===fe&&(_=''+_+"");const yt=L?Y(_):_;if(Ne===fe)try{D=new h().parseFromString(yt,ji)}catch{}if(!D||!D.documentElement){D=q.createDocument(Ne,"template",null);try{D.documentElement.innerHTML=xa?F:yt}catch{}}const kt=D.body||D.documentElement;return _&&et&&kt.insertBefore(r.createTextNode(et),kt.childNodes[0]||null),Ne===fe?tt.call(D,Fe?"html":"body")[0]:Fe?D.documentElement:kt},Yh=function(_){const D=A?A(_):_.ownerDocument;return O.call(D||_,_,l.SHOW_ELEMENT|l.SHOW_COMMENT|l.SHOW_TEXT|l.SHOW_PROCESSING_INSTRUCTION|l.SHOW_CDATA_SECTION,null)},Ys=function(_){return _=Vi(_,Tt," "),_=Vi(_,Ft," "),_=Vi(_,Bt," "),_},Ta=function(_){var D;_.normalize();const et=A?A(_):_.ownerDocument,yt=O.call(et||_,_,l.SHOW_TEXT|l.SHOW_COMMENT|l.SHOW_CDATA_SECTION|l.SHOW_PROCESSING_INSTRUCTION,null);let kt=yt.nextNode();for(;kt;)kt.data=Ys(kt.data),kt=yt.nextNode();const Mt=(D=_.querySelectorAll)===null||D===void 0?void 0:D.call(_,"template");Mt&&yi(Mt,Gt=>{mi(Gt.content)&&Ta(Gt.content)})},Us=function(_){const D=v?v(_):null;return typeof D!="string"||Kt(D)!=="form"?!1:typeof _.nodeName!="string"||typeof _.textContent!="string"||typeof _.removeChild!="function"||_.attributes!==T(_)||typeof _.removeAttribute!="function"||typeof _.setAttribute!="function"||typeof _.namespaceURI!="string"||typeof _.insertBefore!="function"||typeof _.hasChildNodes!="function"||_.nodeType!==S(_)||_.childNodes!==x(_)},mi=function(_){if(!S||typeof _!="object"||_===null)return!1;try{return S(_)===Ie.documentFragment}catch{return!1}},Xi=function(_){if(!S||typeof _!="object"||_===null)return!1;try{return typeof S(_)=="number"}catch{return!1}};function tr(ot,_,D){ot.length!==0&&yi(ot,et=>{et.call(t,_,D,gi)})}const G0=function(_,D){return!!(Te&&_.hasChildNodes()&&!Xi(_.firstElementChild)&&se(hc,_.textContent)&&se(hc,_.innerHTML)||Te&&_.namespaceURI===fe&&D==="style"&&Xi(_.firstElementChild)||_.nodeType===Ie.processingInstruction||Te&&_.nodeType===Ie.comment&&se(cc,_.data))},X0=function(_,D,et){if(!de[D]&&Xh(D)&&(jt.tagNameCheck instanceof RegExp&&se(jt.tagNameCheck,D)||jt.tagNameCheck instanceof Function&&jt.tagNameCheck(D)))return!1;if(G&&!K[D]){const yt=C(_),kt=x(_);if(kt&&yt){const Mt=kt.length;for(let Gt=Mt-1;Gt>=0;--Gt){const Qt=_===et?f(kt[Gt],!0):kt[Gt];yt.insertBefore(Qt,y(_))}}}return Mr(_),!0},Uh=function(_,D,et,yt){return _.length===0?D:D===et||D===yt?ge(D):D},jh=function(_,D){if(tr(ht.beforeSanitizeElements,_,null),_!==D&&C(_)===null)return V&&Gi(_),!0;if(Us(_))return Mr(_),!0;const et=Kt(v?v(_):_.nodeName);if($t=Uh(ht.uponSanitizeElement,$t,we,g),tr(ht.uponSanitizeElement,_,{tagName:et,allowedTags:$t}),_!==D&&C(_)===null)return V&&Gi(_),!0;if(G0(_,et))return Mr(_),!0;if(de[et]||!(ve.tagCheck instanceof Function&&ve.tagCheck(et))&&!$t[et]){const kt=X0(_,et,D);return kt===!1&&tr(ht.afterSanitizeElements,_,null),kt}if((S?S(_):_.nodeType)===Ie.element&&!Y0(_)||(et==="noscript"||et==="noembed"||et==="noframes")&&se(sC,_.innerHTML))return Mr(_),!0;if(Le&&_.nodeType===Ie.text){const kt=Ys(_.textContent);_.textContent!==kt&&(xi(t.removed,{element:_.cloneNode()}),_.textContent=kt)}return tr(ht.afterSanitizeElements,_,null),!1},Gh=function(_,D,et){if(gr[D]||Te&&D==="patchsrc"||Te&&D==="for"&&_!=="label"&&_!=="output"||w&&(D==="id"||D==="name")&&(et in r||et in q0))return!1;const yt=Pt[D]||ve.attributeCheck instanceof Function&&ve.attributeCheck(D,_);if(!(Je&&se(pt,D))){if(!(mr&&se(wt,D))){if(yt){if(!bt[D]){if(!se(Wt,Vi(et,_t,""))){if(!((D==="src"||D==="xlink:href"||D==="href")&&_!=="script"&&ec(et,"data:")===0&&nt[_])){if(!(Er&&!se(Ot,Vi(et,_t,"")))){if(et)return!1}}}}}else if(!(Xh(_)&&(jt.tagNameCheck instanceof RegExp&&se(jt.tagNameCheck,_)||jt.tagNameCheck instanceof Function&&jt.tagNameCheck(_))&&(jt.attributeNameCheck instanceof RegExp&&se(jt.attributeNameCheck,D)||jt.attributeNameCheck instanceof Function&&jt.attributeNameCheck(D,_))||D==="is"&&jt.allowCustomizedBuiltInElements&&(jt.tagNameCheck instanceof RegExp&&se(jt.tagNameCheck,et)||jt.tagNameCheck instanceof Function&&jt.tagNameCheck(et))))return!1}}return!0},V0=qt({},["annotation-xml","color-profile","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","missing-glyph"]),Xh=function(_){return!V0[as(_)]&&se(zt,_)},Z0=function(_,D,et,yt){if(L&&typeof u=="object"&&typeof u.getAttributeType=="function"&&!et)switch(u.getAttributeType(_,D)){case"TrustedHTML":return Y(yt);case"TrustedScriptURL":return $(yt)}return yt},K0=function(_,D,et,yt){try{et?_.setAttributeNS(et,D,yt):_.setAttribute(D,yt),Us(_)?Mr(_):Jh(t.removed)}catch{jr(D,_)}},Vh=function(_){tr(ht.beforeSanitizeAttributes,_,null);const D=_.attributes;if(!D||Us(_))return;Pt=Uh(ht.uponSanitizeAttribute,Pt,pr,M);const et={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:Pt,forceKeepAttr:void 0};let yt=D.length;const kt=Kt(_.nodeName);for(;yt--;){const Mt=D[yt],Gt=Mt.name,Qt=Mt.namespaceURI,Ae=Mt.value,Ee=Kt(Gt),Sa=Ae;let _e=Gt==="value"?Sa:qx(Sa);if(et.attrName=Ee,et.attrValue=_e,et.keepAttr=!0,et.forceKeepAttr=void 0,tr(ht.uponSanitizeAttribute,_,et),_e=et.attrValue,P&&(Ee==="id"||Ee==="name")&&ec(_e,J)!==0&&(jr(Gt,_),_e=J+_e),Te&&se(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i,_e)){jr(Gt,_);continue}if(Ee==="attributename"&&tc(_e,"href")){jr(Gt,_);continue}if(!et.forceKeepAttr){if(!et.keepAttr){jr(Gt,_);continue}if(!Be&&se(oC,_e)){jr(Gt,_);continue}if(Le&&(_e=Ys(_e)),!Gh(kt,Ee,_e)){jr(Gt,_);continue}_e=Z0(kt,Ee,Qt,_e),_e!==Sa&&K0(_,Gt,Qt,_e)}}tr(ht.afterSanitizeAttributes,_,null)},js=function(_){let D=null;const et=Yh(_);for(tr(ht.beforeSanitizeShadowDOM,_,null);D=et.nextNode();)if(tr(ht.uponSanitizeShadowNode,D,null),jh(D,_),Vh(D),mi(D.content)&&js(D.content),(S?S(D):D.nodeType)===Ie.element){const kt=k(D);mi(kt)&&(_a(kt),js(kt))}tr(ht.afterSanitizeShadowDOM,_,null)},_a=function(_){const D=[{node:_,shadow:null}];for(;D.length>0;){const et=D.pop();if(et.shadow){js(et.shadow);continue}const yt=et.node,Mt=(S?S(yt):yt.nodeType)===Ie.element,Gt=x(yt);if(Gt)for(let Qt=Gt.length-1;Qt>=0;--Qt)D.push({node:Gt[Qt],shadow:null});if(Mt){const Qt=v?v(yt):null;if(typeof Qt=="string"&&Kt(Qt)==="template"){const Ae=yt.content;mi(Ae)&&D.push({node:Ae,shadow:null})}}if(Mt){const Qt=k(yt);mi(Qt)&&D.push({node:null,shadow:Qt},{node:Qt,shadow:null})}}};return t.sanitize=function(ot){let _=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},D=null,et=null,yt=null,kt=null;if(xa=!ot,xa&&(ot=""),typeof ot!="string"&&!Xi(ot)&&(ot=Ux(ot),typeof ot!="string"))throw Gr("dirty is not a string, aborting");if(!t.isSupported)return ot;yr?($t=g,Pt=M):wa(_),(ht.uponSanitizeElement.length>0||ht.uponSanitizeAttribute.length>0)&&($t=ge($t)),ht.uponSanitizeAttribute.length>0&&(Pt=ge(Pt)),t.removed=[];const Mt=V&&typeof ot!="string"&&Xi(ot);if(Mt){j0(ot);const Ae=v?v(ot):ot.nodeName;if(typeof Ae=="string"){const Ee=Kt(Ae);if(!$t[Ee]||de[Ee])throw Hs(ot),Gr("root node is forbidden and cannot be sanitized in-place")}if(Us(ot))throw Hs(ot),Gr("root node is clobbered and cannot be sanitized in-place");try{_a(ot)}catch(Ee){throw Hs(ot),Ee}}else if(Xi(ot))D=Hh(""),et=D.ownerDocument.importNode(ot,!0),et.nodeType===Ie.element&&et.nodeName==="BODY"||et.nodeName==="HTML"?D=et:D.appendChild(et),_a(et);else{if(!X&&!Le&&!Fe&&ot.indexOf("<")===-1)return L&&rt?Y(ot):ot;if(D=Hh(ot),!D)return X?null:rt?F:""}D&&j&&Mr(D.firstChild);const Gt=Mt?ot:D;try{const Ae=Yh(Gt);for(;yt=Ae.nextNode();)jh(yt,Gt),Vh(yt),mi(yt.content)&&js(yt.content)}catch(Ae){throw Mt&&(Hs(ot),yi(t.removed,Ee=>{Ee.element&&Gi(Ee.element)})),Ae}if(Mt)return yi(t.removed,Ae=>{Ae.element&&Gi(Ae.element)}),Le&&Ta(ot),ot;if(X){if(Le&&Ta(D),H)for(kt=it.call(D.ownerDocument);D.firstChild;)kt.appendChild(D.firstChild);else kt=D;return(Pt.shadowroot||Pt.shadowrootmode)&&(kt=gt.call(i,kt,!0)),kt}let Qt=Fe?D.outerHTML:D.innerHTML;return Fe&&$t["!doctype"]&&D.ownerDocument&&D.ownerDocument.doctype&&D.ownerDocument.doctype.name&&se(rC,D.ownerDocument.doctype.name)&&(Qt=" +`+Qt),Le&&(Qt=Ys(Qt)),L&&rt?Y(Qt):Qt},t.setConfig=function(){let ot=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};wa(ot),yr=!0,g=$t,M=Pt},t.clearConfig=function(){gi=null,yr=!1,g=null,M=null,L=Z,F=""},t.isValidAttribute=function(ot,_,D){gi||wa({});const et=Kt(ot),yt=Kt(_);return Gh(et,yt,D)},t.addHook=function(ot,_){typeof _=="function"&&oe(ht,ot)&&xi(ht[ot],_)},t.removeHook=function(ot,_){if(oe(ht,ot)){if(_!==void 0){const D=Rx(ht[ot],_);return D===-1?void 0:Nx(ht[ot],D,1)[0]}return Jh(ht[ot])}},t.removeHooks=function(ot){oe(ht,ot)&&(ht[ot]=[])},t.removeAllHooks=function(){ht=uc()},t}var $i=Yd(),Sn=p((e,t,{depth:r=2}={})=>{const i={depth:r};if(Array.isArray(t)&&!Array.isArray(e))return t.forEach(s=>Sn(e,s,i)),e;if(Array.isArray(t)&&Array.isArray(e))return t.forEach(s=>{e.includes(s)||e.push(s)}),e;if(e==null||r<=0)return e!=null&&typeof e=="object"&&typeof t=="object"?Object.assign(e,t):t;if(t!=null&&typeof e=="object"&&typeof t=="object"){const s=e;Object.entries(t).forEach(([o,a])=>{if(typeof a=="object"){if(a===null)return;Object.hasOwn(e,o)||Object.defineProperty(e,o,{value:void 0,writable:!0,enumerable:!0,configurable:!0}),s[o]===void 0&&(s[o]=Array.isArray(a)?[]:{}),typeof s[o]=="object"&&(s[o]=Sn(s[o],a,{depth:r-1}))}else typeof s[o]!="object"&&(Object.hasOwn(e,o)?s[o]=a:Object.defineProperty(e,o,{value:a,writable:!0,enumerable:!0,configurable:!0}))})}return e},"assignWithDepth"),ne=Sn,hr="#ffffff",cr="#f2f2f2",vt=p((e,t)=>t?b(e,{s:-40,l:10}):b(e,{s:-40,l:-10}),"mkBorder"),lC=class{static{p(this,"Theme")}constructor(){this.background="#f4f4f4",this.primaryColor="#fff4dd",this.noteBkgColor="#fff5ad",this.noteTextColor="#333",this.THEME_COLOR_LIMIT=12,this.radius=5,this.strokeWidth=1,this.fontFamily='"trebuchet ms", verdana, arial, sans-serif',this.fontSize="16px",this.useGradient=!0,this.dropShadow="drop-shadow( 1px 2px 2px rgba(185,185,185,1))"}updateColors(){if(this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#333"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#333",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.primaryBorderColor,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.sectionBkgColor=this.sectionBkgColor||this.tertiaryColor,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||this.secondaryColor,this.sectionBkgColor2=this.sectionBkgColor2||this.primaryColor,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||this.primaryColor,this.activeTaskBorderColor=this.activeTaskBorderColor||this.primaryColor,this.activeTaskBkgColor=this.activeTaskBkgColor||z(this.primaryColor,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.vertLineColor=this.vertLineColor||"navy",this.taskTextColor=this.taskTextColor||this.textColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.noteFontWeight=this.noteFontWeight||"normal",this.fontWeight=this.fontWeight||"normal",this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.darkMode?(this.rowOdd=this.rowOdd||W(this.mainBkg,5)||"#ffffff",this.rowEven=this.rowEven||W(this.mainBkg,10)):(this.rowOdd=this.rowOdd||z(this.mainBkg,75)||"#ffffff",this.rowEven=this.rowEven||z(this.mainBkg,5)),this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||this.tertiaryColor,this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210,l:150}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330}),this.darkMode)for(let r=0;r{this[i]=t[i]}),this.updateColors(),r.forEach(i=>{this[i]=t[i]})}},hC=p(e=>{const t=new lC;return t.calculate(e),t},"getThemeVariables"),cC=class{static{p(this,"Theme")}constructor(){this.background="#333",this.primaryColor="#1f2020",this.secondaryColor=z(this.primaryColor,16),this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=E(this.background),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.lineColor=E(this.background),this.textColor=E(this.background),this.mainBkg="#1f2020",this.secondBkg="calculated",this.mainContrastColor="lightgrey",this.darkTextColor=z(E("#323D47"),10),this.lineColor="calculated",this.border1="#ccc",this.border2=qr(255,255,255,.25),this.arrowheadColor="calculated",this.fontFamily='"trebuchet ms", verdana, arial, sans-serif',this.fontSize="16px",this.labelBackground="#181818",this.textColor="#ccc",this.THEME_COLOR_LIMIT=12,this.radius=5,this.strokeWidth=1,this.nodeBkg="calculated",this.nodeBorder="calculated",this.clusterBkg="calculated",this.clusterBorder="calculated",this.defaultLinkColor="calculated",this.titleColor="#F9FFFE",this.edgeLabelBackground="calculated",this.actorBorder="calculated",this.actorBkg="calculated",this.actorTextColor="calculated",this.actorLineColor="calculated",this.signalColor="calculated",this.signalTextColor="calculated",this.labelBoxBkgColor="calculated",this.labelBoxBorderColor="calculated",this.labelTextColor="calculated",this.loopTextColor="calculated",this.noteBorderColor="calculated",this.noteBkgColor="#fff5ad",this.noteTextColor="calculated",this.activationBorderColor="calculated",this.activationBkgColor="calculated",this.sequenceNumberColor="black",this.clusterBkg="#302F3D",this.sectionBkgColor=W("#EAE8D9",30),this.altSectionBkgColor="calculated",this.sectionBkgColor2="#EAE8D9",this.excludeBkgColor=W(this.sectionBkgColor,10),this.taskBorderColor=qr(255,255,255,70),this.taskBkgColor="calculated",this.taskTextColor="calculated",this.taskTextLightColor="calculated",this.taskTextOutsideColor="calculated",this.taskTextClickableColor="#003163",this.activeTaskBorderColor=qr(255,255,255,50),this.activeTaskBkgColor="#81B1DB",this.gridColor="calculated",this.doneTaskBkgColor="calculated",this.doneTaskBorderColor="grey",this.critBorderColor="#E83737",this.critBkgColor="#E83737",this.taskTextDarkColor="calculated",this.todayLineColor="#DB5757",this.vertLineColor="#00BFFF",this.personBorder=this.primaryBorderColor,this.personBkg=this.mainBkg,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.rowOdd=this.rowOdd||z(this.mainBkg,5)||"#ffffff",this.rowEven=this.rowEven||W(this.mainBkg,10),this.labelColor="calculated",this.errorBkgColor="#a44141",this.errorTextColor="#ddd",this.useGradient=!0,this.gradientStart=this.primaryBorderColor,this.gradientStop=this.secondaryBorderColor,this.dropShadow="drop-shadow( 1px 2px 2px rgba(185,185,185,1))",this.noteFontWeight=this.noteFontWeight||"normal",this.fontWeight=this.fontWeight||"normal"}updateColors(){this.secondBkg=z(this.mainBkg,16),this.lineColor=this.mainContrastColor,this.arrowheadColor=this.mainContrastColor,this.nodeBkg=this.mainBkg,this.nodeBorder=this.border1,this.clusterBkg=this.secondBkg,this.clusterBorder=this.border2,this.defaultLinkColor=this.lineColor,this.edgeLabelBackground=z(this.labelBackground,25),this.actorBorder=this.border1,this.actorBkg=this.mainBkg,this.actorTextColor=this.mainContrastColor,this.actorLineColor=this.actorBorder,this.signalColor=this.mainContrastColor,this.signalTextColor=this.mainContrastColor,this.labelBoxBkgColor=this.actorBkg,this.labelBoxBorderColor=this.actorBorder,this.labelTextColor=this.mainContrastColor,this.loopTextColor=this.mainContrastColor,this.noteBorderColor=this.secondaryBorderColor,this.noteBkgColor=this.secondBkg,this.noteTextColor=this.secondaryTextColor,this.activationBorderColor=this.border1,this.activationBkgColor=this.secondBkg,this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.altSectionBkgColor=this.background,this.taskBkgColor=z(this.mainBkg,23),this.taskTextColor=this.darkTextColor,this.taskTextLightColor=this.mainContrastColor,this.taskTextOutsideColor=this.taskTextLightColor,this.gridColor=this.mainContrastColor,this.doneTaskBkgColor=this.mainContrastColor,this.taskTextDarkColor=E(this.doneTaskBkgColor),this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#555",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.primaryBorderColor,this.specialStateColor="#f4f4f4",this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.fillType0=this.primaryColor,this.fillType1=this.secondaryColor,this.fillType2=b(this.primaryColor,{h:64}),this.fillType3=b(this.secondaryColor,{h:64}),this.fillType4=b(this.primaryColor,{h:-64}),this.fillType5=b(this.secondaryColor,{h:-64}),this.fillType6=b(this.primaryColor,{h:128}),this.fillType7=b(this.secondaryColor,{h:128}),this.cScale1=this.cScale1||"#0b0000",this.cScale2=this.cScale2||"#4d1037",this.cScale3=this.cScale3||"#3f5258",this.cScale4=this.cScale4||"#4f2f1b",this.cScale5=this.cScale5||"#6e0a0a",this.cScale6=this.cScale6||"#3b0048",this.cScale7=this.cScale7||"#995a01",this.cScale8=this.cScale8||"#154706",this.cScale9=this.cScale9||"#161722",this.cScale10=this.cScale10||"#00296f",this.cScale11=this.cScale11||"#01629c",this.cScale12=this.cScale12||"#010029",this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330});for(let e=0;e{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},uC=p(e=>{const t=new cC;return t.calculate(e),t},"getThemeVariables"),dC=class{static{p(this,"Theme")}constructor(){this.background="#f4f4f4",this.primaryColor="#ECECFF",this.secondaryColor=b(this.primaryColor,{h:120}),this.secondaryColor="#ffffde",this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.lineColor=E(this.background),this.textColor=E(this.background),this.background="white",this.mainBkg="#ECECFF",this.secondBkg="#ffffde",this.lineColor="#333333",this.border1="#9370DB",this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.border2="#aaaa33",this.arrowheadColor="#333333",this.fontFamily='"trebuchet ms", verdana, arial, sans-serif',this.fontSize="16px",this.labelBackground="rgba(232,232,232, 0.8)",this.textColor="#333",this.THEME_COLOR_LIMIT=12,this.radius=5,this.strokeWidth=1,this.nodeBkg="calculated",this.nodeBorder="calculated",this.clusterBkg="calculated",this.clusterBorder="calculated",this.defaultLinkColor="calculated",this.titleColor="calculated",this.edgeLabelBackground="calculated",this.actorBorder="calculated",this.actorBkg="calculated",this.actorTextColor="black",this.actorLineColor="calculated",this.signalColor="calculated",this.signalTextColor="calculated",this.labelBoxBkgColor="calculated",this.labelBoxBorderColor="calculated",this.labelTextColor="calculated",this.loopTextColor="calculated",this.noteBorderColor="calculated",this.noteBkgColor="#fff5ad",this.noteTextColor="calculated",this.activationBorderColor="#666",this.activationBkgColor="#f4f4f4",this.sequenceNumberColor="white",this.clusterBkg="#FBFBFF",this.sectionBkgColor="calculated",this.altSectionBkgColor="calculated",this.sectionBkgColor2="calculated",this.excludeBkgColor="#eeeeee",this.taskBorderColor="calculated",this.taskBkgColor="calculated",this.taskTextLightColor="calculated",this.taskTextColor=this.taskTextLightColor,this.taskTextDarkColor="calculated",this.taskTextOutsideColor=this.taskTextDarkColor,this.taskTextClickableColor="calculated",this.activeTaskBorderColor="calculated",this.activeTaskBkgColor="calculated",this.gridColor="calculated",this.doneTaskBkgColor="calculated",this.doneTaskBorderColor="calculated",this.critBorderColor="calculated",this.critBkgColor="calculated",this.todayLineColor="calculated",this.vertLineColor="calculated",this.sectionBkgColor=qr(102,102,255,.49),this.altSectionBkgColor="white",this.sectionBkgColor2="#fff400",this.taskBorderColor="#534fbc",this.taskBkgColor="#8a90dd",this.taskTextLightColor="white",this.taskTextColor="calculated",this.taskTextDarkColor="black",this.taskTextOutsideColor="calculated",this.taskTextClickableColor="#003163",this.activeTaskBorderColor="#534fbc",this.activeTaskBkgColor="#bfc7ff",this.gridColor="lightgrey",this.doneTaskBkgColor="lightgrey",this.doneTaskBorderColor="grey",this.critBorderColor="#ff8888",this.critBkgColor="red",this.todayLineColor="red",this.vertLineColor="navy",this.noteFontWeight=this.noteFontWeight||"normal",this.fontWeight=this.fontWeight||"normal",this.personBorder=this.primaryBorderColor,this.personBkg=this.mainBkg,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.rowOdd="calculated",this.rowEven="calculated",this.labelColor="black",this.errorBkgColor="#552222",this.errorTextColor="#552222",this.useGradient=!1,this.gradientStart=this.primaryBorderColor,this.gradientStop=this.secondaryBorderColor,this.dropShadow="drop-shadow(1px 2px 2px rgba(185, 185, 185, 1))",this.updateColors()}updateColors(){this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330}),this.cScalePeer1=this.cScalePeer1||W(this.secondaryColor,45),this.cScalePeer2=this.cScalePeer2||W(this.tertiaryColor,40);for(let e=0;e{this[r]==="calculated"&&(this[r]=void 0)}),typeof e!="object"){this.updateColors();return}const t=Object.keys(e);t.forEach(r=>{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},fC=p(e=>{const t=new dC;return t.calculate(e),t},"getThemeVariables"),pC=class{static{p(this,"Theme")}constructor(){this.background="#f4f4f4",this.primaryColor="#cde498",this.secondaryColor="#cdffb2",this.background="white",this.mainBkg="#cde498",this.secondBkg="#cdffb2",this.lineColor="green",this.border1="#13540c",this.border2="#6eaa49",this.arrowheadColor="green",this.fontFamily='"trebuchet ms", verdana, arial, sans-serif',this.fontSize="16px",this.tertiaryColor=z("#cde498",10),this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.primaryColor),this.lineColor=E(this.background),this.textColor=E(this.background),this.THEME_COLOR_LIMIT=12,this.radius=5,this.strokeWidth=1,this.nodeBkg="calculated",this.nodeBorder="calculated",this.clusterBkg="calculated",this.clusterBorder="calculated",this.defaultLinkColor="calculated",this.titleColor="#333",this.edgeLabelBackground="#e8e8e8",this.actorBorder="calculated",this.actorBkg="calculated",this.actorTextColor="black",this.actorLineColor="calculated",this.signalColor="#333",this.signalTextColor="#333",this.labelBoxBkgColor="calculated",this.labelBoxBorderColor="#326932",this.labelTextColor="calculated",this.loopTextColor="calculated",this.noteBorderColor="calculated",this.noteBkgColor="#fff5ad",this.noteTextColor="calculated",this.activationBorderColor="#666",this.activationBkgColor="#f4f4f4",this.sequenceNumberColor="white",this.sectionBkgColor="#6eaa49",this.altSectionBkgColor="white",this.sectionBkgColor2="#6eaa49",this.excludeBkgColor="#eeeeee",this.taskBorderColor="calculated",this.taskBkgColor="#487e3a",this.taskTextLightColor="white",this.taskTextColor="calculated",this.taskTextDarkColor="black",this.taskTextOutsideColor="calculated",this.taskTextClickableColor="#003163",this.activeTaskBorderColor="calculated",this.activeTaskBkgColor="calculated",this.gridColor="lightgrey",this.doneTaskBkgColor="lightgrey",this.doneTaskBorderColor="grey",this.critBorderColor="#ff8888",this.critBkgColor="red",this.todayLineColor="red",this.vertLineColor="#00BFFF",this.personBorder=this.primaryBorderColor,this.personBkg=this.mainBkg,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.noteFontWeight="normal",this.fontWeight="normal",this.labelColor="black",this.errorBkgColor="#552222",this.errorTextColor="#552222",this.useGradient=!0,this.gradientStart=this.primaryBorderColor,this.gradientStop=this.secondaryBorderColor,this.dropShadow="drop-shadow( 1px 2px 2px rgba(185,185,185,0.5))"}updateColors(){this.actorBorder=W(this.mainBkg,20),this.actorBkg=this.mainBkg,this.labelBoxBkgColor=this.actorBkg,this.labelTextColor=this.actorTextColor,this.loopTextColor=this.actorTextColor,this.noteBorderColor=this.border2,this.noteTextColor=this.actorTextColor,this.actorLineColor=this.actorBorder,this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330}),this.cScalePeer1=this.cScalePeer1||W(this.secondaryColor,45),this.cScalePeer2=this.cScalePeer2||W(this.tertiaryColor,40);for(let e=0;e{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},gC=p(e=>{const t=new pC;return t.calculate(e),t},"getThemeVariables"),mC=class{static{p(this,"Theme")}constructor(){this.primaryColor="#eee",this.contrast="#707070",this.secondaryColor=z(this.contrast,55),this.background="#ffffff",this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.lineColor=E(this.background),this.textColor=E(this.background),this.mainBkg="#eee",this.secondBkg="calculated",this.lineColor="#666",this.border1="#999",this.border2="calculated",this.note="#ffa",this.text="#333",this.critical="#d42",this.done="#bbb",this.arrowheadColor="#333333",this.fontFamily='"trebuchet ms", verdana, arial, sans-serif',this.fontSize="16px",this.THEME_COLOR_LIMIT=12,this.radius=5,this.strokeWidth=1,this.nodeBkg="calculated",this.nodeBorder="calculated",this.clusterBkg="calculated",this.clusterBorder="calculated",this.defaultLinkColor="calculated",this.titleColor="calculated",this.edgeLabelBackground="white",this.actorBorder="calculated",this.actorBkg="calculated",this.actorTextColor="calculated",this.actorLineColor=this.actorBorder,this.signalColor="calculated",this.signalTextColor="calculated",this.labelBoxBkgColor="calculated",this.labelBoxBorderColor="calculated",this.labelTextColor="calculated",this.loopTextColor="calculated",this.noteBorderColor="calculated",this.noteBkgColor="calculated",this.noteTextColor="calculated",this.activationBorderColor="#666",this.activationBkgColor="#f4f4f4",this.sequenceNumberColor="white",this.sectionBkgColor="calculated",this.altSectionBkgColor="white",this.sectionBkgColor2="calculated",this.excludeBkgColor="#eeeeee",this.taskBorderColor="calculated",this.taskBkgColor="calculated",this.taskTextLightColor="white",this.taskTextColor="calculated",this.taskTextDarkColor="calculated",this.taskTextOutsideColor="calculated",this.taskTextClickableColor="#003163",this.activeTaskBorderColor="calculated",this.activeTaskBkgColor="calculated",this.gridColor="calculated",this.doneTaskBkgColor="calculated",this.doneTaskBorderColor="calculated",this.critBkgColor="calculated",this.critBorderColor="calculated",this.todayLineColor="calculated",this.vertLineColor="calculated",this.personBorder=this.primaryBorderColor,this.personBkg=this.mainBkg,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.noteFontWeight="normal",this.fontWeight="normal",this.rowOdd=this.rowOdd||z(this.mainBkg,75)||"#ffffff",this.rowEven=this.rowEven||"#f4f4f4",this.labelColor="black",this.errorBkgColor="#552222",this.errorTextColor="#552222",this.useGradient=!0,this.gradientStart=this.primaryBorderColor,this.gradientStop=this.secondaryBorderColor,this.dropShadow="drop-shadow( 1px 2px 2px rgba(185,185,185,1))"}updateColors(){this.secondBkg=z(this.contrast,55),this.border2=this.contrast,this.actorBorder=z(this.border1,23),this.actorBkg=this.mainBkg,this.actorTextColor=this.text,this.actorLineColor=this.actorBorder,this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.signalColor=this.text,this.signalTextColor=this.text,this.labelBoxBkgColor=this.actorBkg,this.labelBoxBorderColor=this.actorBorder,this.labelTextColor=this.text,this.loopTextColor=this.text,this.noteBorderColor="#999",this.noteBkgColor="#666",this.noteTextColor="#fff",this.cScale0=this.cScale0||"#555",this.cScale1=this.cScale1||"#F4F4F4",this.cScale2=this.cScale2||"#555",this.cScale3=this.cScale3||"#BBB",this.cScale4=this.cScale4||"#777",this.cScale5=this.cScale5||"#999",this.cScale6=this.cScale6||"#DDD",this.cScale7=this.cScale7||"#FFF",this.cScale8=this.cScale8||"#DDD",this.cScale9=this.cScale9||"#BBB",this.cScale10=this.cScale10||"#999",this.cScale11=this.cScale11||"#777";for(let e=0;e{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},yC=p(e=>{const t=new mC;return t.calculate(e),t},"getThemeVariables"),xC=class{static{p(this,"Theme")}constructor(){this.background="#ffffff",this.primaryColor="#cccccc",this.mainBkg="#ffffff",this.noteBkgColor="#fff5ad",this.noteTextColor="#333",this.THEME_COLOR_LIMIT=12,this.radius=3,this.strokeWidth=2,this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.fontFamily="arial, sans-serif",this.fontSize="14px",this.nodeBorder="#000000",this.stateBorder="#000000",this.useGradient=!0,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="drop-shadow( 0px 1px 2px rgba(0, 0, 0, 0.25));",this.tertiaryColor="#ffffff",this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.noteFontWeight="normal",this.fontWeight="normal"}updateColors(){this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#333"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#333",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.primaryBorderColor,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor;const e="#ECECFE",t="#E9E9F1",r=b(e,{h:180,l:5});if(this.sectionBkgColor=this.sectionBkgColor||r,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||t,this.sectionBkgColor2=this.sectionBkgColor2||e,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||e,this.activeTaskBorderColor=this.activeTaskBorderColor||e,this.activeTaskBkgColor=this.activeTaskBkgColor||z(e,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.taskTextColor=this.taskTextColor||this.textColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||e,this.cScale1=this.cScale1||t,this.cScale2=this.cScale2||r,this.cScale3=this.cScale3||b(e,{h:30}),this.cScale4=this.cScale4||b(e,{h:60}),this.cScale5=this.cScale5||b(e,{h:90}),this.cScale6=this.cScale6||b(e,{h:120}),this.cScale7=this.cScale7||b(e,{h:150}),this.cScale8=this.cScale8||b(e,{h:210,l:150}),this.cScale9=this.cScale9||b(e,{h:270}),this.cScale10=this.cScale10||b(e,{h:300}),this.cScale11=this.cScale11||b(e,{h:330}),this.darkMode)for(let s=0;s{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},CC=p(e=>{const t=new xC;return t.calculate(e),t},"getThemeVariables"),bC=class{static{p(this,"Theme")}constructor(){this.background="#333",this.primaryColor="#1f2020",this.secondaryColor=z(this.primaryColor,16),this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=E(this.background),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.mainBkg="#2a2020",this.secondBkg="calculated",this.mainContrastColor="lightgrey",this.darkTextColor=z(E("#323D47"),10),this.border1="#ccc",this.border2=qr(255,255,255,.25),this.arrowheadColor=E(this.background),this.fontFamily="arial, sans-serif",this.fontSize="14px",this.labelBackground="#181818",this.textColor="#ccc",this.THEME_COLOR_LIMIT=12,this.radius=3,this.strokeWidth=1,this.noteBkgColor="#fff5ad",this.noteTextColor="#333",this.THEME_COLOR_LIMIT=12,this.fontFamily="arial, sans-serif",this.fontSize="14px",this.useGradient=!0,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="drop-shadow( 1px 2px 2px rgba(185,185,185,0.2))",this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.noteFontWeight="normal",this.fontWeight="normal"}updateColors(){if(this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#333"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#333",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.border1,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.sectionBkgColor=this.sectionBkgColor||this.tertiaryColor,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||this.secondaryColor,this.sectionBkgColor2=this.sectionBkgColor2||this.primaryColor,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||this.primaryColor,this.activeTaskBorderColor=this.activeTaskBorderColor||this.primaryColor,this.activeTaskBkgColor=this.activeTaskBkgColor||z(this.primaryColor,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.taskTextColor=this.taskTextColor||this.textColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210,l:150}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330}),this.darkMode)for(let t=0;t{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},kC=p(e=>{const t=new bC;return t.calculate(e),t},"getThemeVariables"),wC=class{static{p(this,"Theme")}constructor(){this.background="#ffffff",this.primaryColor="#cccccc",this.mainBkg="#ffffff",this.noteBkgColor="#fff5ad",this.noteTextColor="#28253D",this.THEME_COLOR_LIMIT=12,this.radius=12,this.strokeWidth=2,this.primaryBorderColor=vt("#28253D",this.darkMode),this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.nodeBorder="#28253D",this.stateBorder="#28253D",this.useGradient=!1,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="url(#drop-shadow)",this.nodeShadow=!0,this.tertiaryColor="#ffffff",this.clusterBkg="#F9F9FB",this.clusterBorder="#BDBCCC",this.noteBorderColor="#FACC15",this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.actorBorder="#28253D",this.filterColor="#000000"}updateColors(){this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#28253D"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#FEF9C3",this.noteTextColor=this.noteTextColor||"#28253D",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.primaryBorderColor,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.noteFontWeight=600,this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor;const e="#ECECFE",t="#E9E9F1",r=b(e,{h:180,l:5});this.sectionBkgColor=this.sectionBkgColor||r,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||t,this.sectionBkgColor2=this.sectionBkgColor2||e,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||e,this.activeTaskBorderColor=this.activeTaskBorderColor||e,this.activeTaskBkgColor=this.activeTaskBkgColor||z(e,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.taskTextColor=this.taskTextColor||this.textColor,this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.compositeTitleBackground="#F9F9FB",this.altBackground="#F9F9FB",this.stateEdgeLabelBackground="#FFFFFF",this.fontWeight=600,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor;for(let s=0;s{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},TC=p(e=>{const t=new wC;return t.calculate(e),t},"getThemeVariables"),_C=class{static{p(this,"Theme")}constructor(){this.background="#333",this.primaryColor="#1f2020",this.secondaryColor=z(this.primaryColor,16),this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=E(this.background),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.mainBkg="#111113",this.secondBkg="calculated",this.mainContrastColor="lightgrey",this.darkTextColor=z(E("#323D47"),10),this.border1="#ccc",this.border2=qr(255,255,255,.25),this.arrowheadColor=E(this.background),this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.labelBackground="#111113",this.textColor="#ccc",this.THEME_COLOR_LIMIT=12,this.radius=12,this.strokeWidth=2,this.noteBkgColor=this.noteBkgColor??"#FEF9C3",this.noteTextColor=this.noteTextColor??"#28253D",this.THEME_COLOR_LIMIT=12,this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.nodeBorder="#FFFFFF",this.stateBorder="#FFFFFF",this.useGradient=!1,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="url(#drop-shadow)",this.nodeShadow=!0,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.clusterBkg="#1E1A2E",this.clusterBorder="#BDBCCC",this.noteBorderColor="#FACC15",this.noteFontWeight=600,this.filterColor="#FFFFFF"}updateColors(){if(this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#FFFFFF"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#FFFFFF",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.border1,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder="#FFFFFF",this.signalColor="#FFFFFF",this.labelBoxBorderColor="#BDBCCC",this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.sectionBkgColor=this.sectionBkgColor||this.tertiaryColor,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||this.secondaryColor,this.sectionBkgColor2=this.sectionBkgColor2||this.primaryColor,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||this.primaryColor,this.activeTaskBorderColor=this.activeTaskBorderColor||this.primaryColor,this.activeTaskBkgColor=this.activeTaskBkgColor||z(this.primaryColor,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.taskTextColor=this.taskTextColor||this.textColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.compositeBackground="#16141F",this.altBackground="#16141F",this.compositeTitleBackground="#16141F",this.stateEdgeLabelBackground="#16141F",this.fontWeight=600,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||this.primaryColor,this.cScale1=this.cScale1||this.secondaryColor,this.cScale2=this.cScale2||this.tertiaryColor,this.cScale3=this.cScale3||b(this.primaryColor,{h:30}),this.cScale4=this.cScale4||b(this.primaryColor,{h:60}),this.cScale5=this.cScale5||b(this.primaryColor,{h:90}),this.cScale6=this.cScale6||b(this.primaryColor,{h:120}),this.cScale7=this.cScale7||b(this.primaryColor,{h:150}),this.cScale8=this.cScale8||b(this.primaryColor,{h:210,l:150}),this.cScale9=this.cScale9||b(this.primaryColor,{h:270}),this.cScale10=this.cScale10||b(this.primaryColor,{h:300}),this.cScale11=this.cScale11||b(this.primaryColor,{h:330}),this.darkMode)for(let t=0;t{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},SC=p(e=>{const t=new _C;return t.calculate(e),t},"getThemeVariables"),vC=class{static{p(this,"Theme")}constructor(){this.background="#ffffff",this.primaryColor="#cccccc",this.mainBkg="#ffffff",this.noteBkgColor="#fff5ad",this.noteTextColor="#28253D",this.THEME_COLOR_LIMIT=12,this.radius=12,this.strokeWidth=2,this.primaryBorderColor=vt(this.primaryColor,this.darkMode),this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.nodeBorder="#28253D",this.stateBorder="#28253D",this.useGradient=!1,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="url(#drop-shadow)",this.nodeShadow=!0,this.tertiaryColor="#ffffff",this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.actorBorder="#28253D",this.noteBorderColor="#FACC15",this.noteFontWeight=600,this.borderColorArray=["#E879F9","#2DD4BF","#FB923C","#22D3EE","#4ADE80","#A78BFA","#F87171","#FACC15","#818CF8","#A3E635 ","#38BDF8","#FB7185"],this.bkgColorArray=["#FDF4FF","#F0FDFA","#FFF7ED","#ECFEFF","#F0FDF4","#F5F3FF","#FEF2F2","#FEFCE8","#EEF2FF","#F7FEE7","#F0F9FF","#FFF1F2"],this.filterColor="#000000"}updateColors(){this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#28253D"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#28253D",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.primaryBorderColor,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor;const e="#ECECFE",t="#E9E9F1",r=b(e,{h:180,l:5});this.sectionBkgColor=this.sectionBkgColor||r,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||t,this.sectionBkgColor2=this.sectionBkgColor2||e,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||e,this.activeTaskBorderColor=this.activeTaskBorderColor||e,this.activeTaskBkgColor=this.activeTaskBkgColor||z(e,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.taskTextColor=this.taskTextColor||this.textColor,this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||"#f4a8ff",this.cScale1=this.cScale1||"#46ecd5",this.cScale2=this.cScale2||"#ffb86a",this.cScale3=this.cScale3||"#dab2ff",this.cScale4=this.cScale4||"#7bf1a8",this.cScale5=this.cScale5||"#c4b4ff",this.cScale6=this.cScale6||"#ffa2a2",this.cScale7=this.cScale7||"#ffdf20",this.cScale8=this.cScale8||"#a3b3ff",this.cScale9=this.cScale9||"#bbf451",this.cScale10=this.cScale10||"#74d4ff",this.cScale11=this.cScale11||"#ffa1ad";for(let s=0;s{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},BC=p(e=>{const t=new vC;return t.calculate(e),t},"getThemeVariables"),LC=class{static{p(this,"Theme")}constructor(){this.background="#333",this.primaryColor="#1f2020",this.secondaryColor=z(this.primaryColor,16),this.tertiaryColor=b(this.primaryColor,{h:-160}),this.primaryBorderColor=E(this.background),this.secondaryBorderColor=vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=vt(this.tertiaryColor,this.darkMode),this.primaryTextColor=E(this.primaryColor),this.secondaryTextColor=E(this.secondaryColor),this.tertiaryTextColor=E(this.tertiaryColor),this.mainBkg="#111113",this.secondBkg="calculated",this.mainContrastColor="lightgrey",this.darkTextColor=z(E("#323D47"),10),this.border1="#ccc",this.border2=qr(255,255,255,.25),this.arrowheadColor=E(this.background),this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.labelBackground="#111113",this.textColor="#ccc",this.THEME_COLOR_LIMIT=12,this.radius=12,this.strokeWidth=2,this.noteBkgColor=this.noteBkgColor??"#FEF9C3",this.noteTextColor=this.noteTextColor??"#28253D",this.THEME_COLOR_LIMIT=12,this.fontFamily='"Recursive Variable", arial, sans-serif',this.fontSize="14px",this.nodeBorder="#FFFFFF",this.stateBorder="#FFFFFF",this.useGradient=!1,this.gradientStart="#0042eb",this.gradientStop="#eb0042",this.dropShadow="url(#drop-shadow)",this.nodeShadow=!0,this.archEdgeColor="calculated",this.archEdgeArrowColor="calculated",this.archEdgeWidth="3",this.archGroupBorderColor=this.primaryBorderColor,this.archGroupBorderWidth="2px",this.clusterBkg="#1E1A2E",this.clusterBorder="#BDBCCC",this.noteBorderColor="#FACC15",this.noteFontWeight=600,this.borderColorArray=["#E879F9","#2DD4BF","#FB923C","#22D3EE","#4ADE80","#A78BFA","#F87171","#FACC15","#818CF8","#A3E635 ","#38BDF8","#FB7185"],this.bkgColorArray=[],this.filterColor="#FFFFFF"}updateColors(){this.primaryTextColor=this.primaryTextColor||(this.darkMode?"#eee":"#FFFFFF"),this.secondaryColor=this.secondaryColor||b(this.primaryColor,{h:-120}),this.tertiaryColor=this.tertiaryColor||b(this.primaryColor,{h:180,l:5}),this.primaryBorderColor=this.primaryBorderColor||vt(this.primaryColor,this.darkMode),this.secondaryBorderColor=this.secondaryBorderColor||vt(this.secondaryColor,this.darkMode),this.tertiaryBorderColor=this.tertiaryBorderColor||vt(this.tertiaryColor,this.darkMode),this.noteBorderColor=this.noteBorderColor||vt(this.noteBkgColor,this.darkMode),this.noteBkgColor=this.noteBkgColor||"#fff5ad",this.noteTextColor=this.noteTextColor||"#FFFFFF",this.secondaryTextColor=this.secondaryTextColor||E(this.secondaryColor),this.tertiaryTextColor=this.tertiaryTextColor||E(this.tertiaryColor),this.lineColor=this.lineColor||E(this.background),this.arrowheadColor=this.arrowheadColor||E(this.background),this.textColor=this.textColor||this.primaryTextColor,this.border2=this.border2||this.tertiaryBorderColor,this.nodeBkg=this.nodeBkg||this.primaryColor,this.mainBkg=this.mainBkg||this.primaryColor,this.nodeBorder=this.nodeBorder||this.border1,this.clusterBkg=this.clusterBkg||this.tertiaryColor,this.clusterBorder=this.clusterBorder||this.tertiaryBorderColor,this.defaultLinkColor=this.defaultLinkColor||this.lineColor,this.titleColor=this.titleColor||this.tertiaryTextColor,this.edgeLabelBackground=this.edgeLabelBackground||(this.darkMode?W(this.secondaryColor,30):this.secondaryColor),this.nodeTextColor=this.nodeTextColor||this.primaryTextColor,this.actorBorder="#FFFFFF",this.signalColor="#FFFFFF",this.labelBoxBorderColor="#BDBCCC",this.actorBorder=this.actorBorder||this.primaryBorderColor,this.actorBkg=this.actorBkg||this.mainBkg,this.actorTextColor=this.actorTextColor||this.primaryTextColor,this.actorLineColor=this.actorLineColor||this.actorBorder,this.labelBoxBkgColor=this.labelBoxBkgColor||this.actorBkg,this.signalColor=this.signalColor||this.textColor,this.signalTextColor=this.signalTextColor||this.textColor,this.labelBoxBorderColor=this.labelBoxBorderColor||this.actorBorder,this.labelTextColor=this.labelTextColor||this.actorTextColor,this.loopTextColor=this.loopTextColor||this.actorTextColor,this.activationBorderColor=this.activationBorderColor||W(this.secondaryColor,10),this.activationBkgColor=this.activationBkgColor||this.secondaryColor,this.sequenceNumberColor=this.sequenceNumberColor||E(this.lineColor),this.rectBkgColor=this.rectBkgColor||this.tertiaryColor,this.rootLabelColor="#FFFFFF",this.sectionBkgColor=this.sectionBkgColor||this.tertiaryColor,this.altSectionBkgColor=this.altSectionBkgColor||"white",this.sectionBkgColor=this.sectionBkgColor||this.secondaryColor,this.sectionBkgColor2=this.sectionBkgColor2||this.primaryColor,this.excludeBkgColor=this.excludeBkgColor||"#eeeeee",this.taskBorderColor=this.taskBorderColor||this.primaryBorderColor,this.taskBkgColor=this.taskBkgColor||this.primaryColor,this.activeTaskBorderColor=this.activeTaskBorderColor||this.primaryColor,this.activeTaskBkgColor=this.activeTaskBkgColor||z(this.primaryColor,23),this.gridColor=this.gridColor||"lightgrey",this.doneTaskBkgColor=this.doneTaskBkgColor||"lightgrey",this.doneTaskBorderColor=this.doneTaskBorderColor||"grey",this.critBorderColor=this.critBorderColor||"#ff8888",this.critBkgColor=this.critBkgColor||"red",this.todayLineColor=this.todayLineColor||"red",this.taskTextColor=this.taskTextColor||this.textColor,this.vertLineColor=this.vertLineColor||this.primaryBorderColor,this.taskTextOutsideColor=this.taskTextOutsideColor||this.textColor,this.taskTextLightColor=this.taskTextLightColor||this.textColor,this.taskTextColor=this.taskTextColor||this.primaryTextColor,this.taskTextDarkColor=this.taskTextDarkColor||this.textColor,this.taskTextClickableColor=this.taskTextClickableColor||"#003163",this.archEdgeColor=this.lineColor,this.archEdgeArrowColor=this.lineColor,this.personBorder=this.personBorder||this.primaryBorderColor,this.personBkg=this.personBkg||this.mainBkg,this.transitionColor=this.transitionColor||this.lineColor,this.transitionLabelColor=this.transitionLabelColor||this.textColor,this.stateLabelColor=this.stateLabelColor||this.stateBkg||this.primaryTextColor,this.stateBkg=this.stateBkg||this.mainBkg,this.labelBackgroundColor=this.labelBackgroundColor||this.stateBkg,this.compositeBackground=this.compositeBackground||this.background||this.tertiaryColor,this.altBackground=this.altBackground||"#f0f0f0",this.compositeTitleBackground=this.compositeTitleBackground||this.mainBkg,this.compositeBorder=this.compositeBorder||this.nodeBorder,this.innerEndBackground=this.nodeBorder,this.errorBkgColor=this.errorBkgColor||this.tertiaryColor,this.errorTextColor=this.errorTextColor||this.tertiaryTextColor,this.transitionColor=this.transitionColor||this.lineColor,this.specialStateColor=this.lineColor,this.cScale0=this.cScale0||"#f4a8ff",this.cScale1=this.cScale1||"#46ecd5",this.cScale2=this.cScale2||"#ffb86a",this.cScale3=this.cScale3||"#dab2ff",this.cScale4=this.cScale4||"#7bf1a8",this.cScale5=this.cScale5||"#c4b4ff",this.cScale6=this.cScale6||"#ffa2a2",this.cScale7=this.cScale7||"#ffdf20",this.cScale8=this.cScale8||"#a3b3ff",this.cScale9=this.cScale9||"#bbf451",this.cScale10=this.cScale10||"#74d4ff",this.cScale11=this.cScale11||"#ffa1ad";for(let t=0;t{this[r]=e[r]}),this.updateColors(),t.forEach(r=>{this[r]=e[r]})}},FC=p(e=>{const t=new LC;return t.calculate(e),t},"getThemeVariables"),Tr={base:{getThemeVariables:hC},dark:{getThemeVariables:uC},default:{getThemeVariables:fC},forest:{getThemeVariables:gC},neutral:{getThemeVariables:yC},neo:{getThemeVariables:CC},"neo-dark":{getThemeVariables:kC},redux:{getThemeVariables:TC},"redux-dark":{getThemeVariables:SC},"redux-color":{getThemeVariables:BC},"redux-dark-color":{getThemeVariables:FC}},le={flowchart:{useMaxWidth:!0,titleTopMargin:25,subGraphTitleMargin:{top:0,bottom:0},diagramPadding:8,htmlLabels:null,nodeSpacing:50,rankSpacing:50,curve:"basis",padding:15,defaultRenderer:"dagre-wrapper",wrappingWidth:200,inheritDir:!1},swimlane:{useMaxWidth:!0,lineHops:"arc",ignoreCrossLaneEdges:!0,optimizeRanksByCrossings:!0,automaticLaneOrdering:!1},sequence:{useMaxWidth:!0,hideUnusedParticipants:!1,activationWidth:10,diagramMarginX:50,diagramMarginY:10,actorMargin:50,width:150,height:65,boxMargin:10,boxTextMargin:5,noteMargin:10,messageMargin:35,messageAlign:"center",mirrorActors:!0,forceMenus:!1,bottomMarginAdj:1,rightAngles:!1,showSequenceNumbers:!1,actorFontSize:14,actorFontFamily:'"Open Sans", sans-serif',actorFontWeight:400,noteFontSize:14,noteFontFamily:'"trebuchet ms", verdana, arial, sans-serif',noteFontWeight:400,noteAlign:"center",messageFontSize:16,messageFontFamily:'"trebuchet ms", verdana, arial, sans-serif',messageFontWeight:400,wrap:!1,wrapPadding:10,labelBoxWidth:50,labelBoxHeight:20},gantt:{useMaxWidth:!0,titleTopMargin:25,barHeight:20,barGap:4,topPadding:50,rightPadding:75,leftPadding:75,gridLineStartPadding:35,fontSize:11,sectionFontSize:11,numberSectionStyles:4,axisFormat:"%Y-%m-%d",topAxis:!1,displayMode:"",weekday:"sunday"},journey:{useMaxWidth:!0,diagramMarginX:50,diagramMarginY:10,leftMargin:150,maxLabelWidth:360,width:150,height:50,boxMargin:10,boxTextMargin:5,noteMargin:10,messageMargin:35,messageAlign:"center",bottomMarginAdj:1,rightAngles:!1,taskFontSize:14,taskFontFamily:'"Open Sans", sans-serif',taskMargin:50,activationWidth:10,textPlacement:"fo",actorColours:["#8FBC8F","#7CFC00","#00FFFF","#20B2AA","#B0E0E6","#FFFFE0"],sectionFills:["#191970","#8B008B","#4B0082","#2F4F4F","#800000","#8B4513","#00008B"],sectionColours:["#fff"],titleColor:"",titleFontFamily:'"trebuchet ms", verdana, arial, sans-serif',titleFontSize:"4ex"},class:{useMaxWidth:!0,titleTopMargin:25,arrowMarkerAbsolute:!1,dividerMargin:10,padding:5,textHeight:10,defaultRenderer:"dagre-wrapper",htmlLabels:!1,hideEmptyMembersBox:!1,hierarchicalNamespaces:!0},state:{useMaxWidth:!0,titleTopMargin:25,dividerMargin:10,sizeUnit:5,padding:8,textHeight:10,titleShift:-15,noteMargin:10,forkWidth:70,forkHeight:7,miniPadding:2,fontSizeFactor:5.02,fontSize:24,labelHeight:16,edgeLengthFactor:"20",compositTitleSize:35,radius:5,defaultRenderer:"dagre-wrapper"},er:{useMaxWidth:!0,titleTopMargin:25,diagramPadding:20,layoutDirection:"TB",minEntityWidth:100,minEntityHeight:75,entityPadding:15,nodeSpacing:140,rankSpacing:80,stroke:"gray",fill:"honeydew",fontSize:12},pie:{useMaxWidth:!0,textPosition:.75,donutHole:0,legendPosition:"right",highlightSlice:""},quadrantChart:{useMaxWidth:!0,chartWidth:500,chartHeight:500,titleFontSize:20,titlePadding:10,quadrantPadding:5,xAxisLabelPadding:5,yAxisLabelPadding:5,xAxisLabelFontSize:16,yAxisLabelFontSize:16,quadrantLabelFontSize:16,quadrantTextTopPadding:5,pointTextPadding:5,pointLabelFontSize:12,pointRadius:5,xAxisPosition:"top",yAxisPosition:"left",quadrantInternalBorderStrokeWidth:1,quadrantExternalBorderStrokeWidth:2},xyChart:{useMaxWidth:!0,width:700,height:500,titleFontSize:20,titlePadding:10,showDataLabel:!1,showDataLabelOutsideBar:!1,showTitle:!0,showLegend:!0,legendFontSize:14,legendPadding:10,xAxis:{$ref:"#/$defs/XYChartAxisConfig",showLabel:!0,labelFontSize:14,labelPadding:5,showTitle:!0,titleFontSize:16,titlePadding:5,showTick:!0,tickLength:5,tickWidth:2,showAxisLine:!0,axisLineWidth:2,labelRotation:0},yAxis:{$ref:"#/$defs/XYChartAxisConfig",showLabel:!0,labelFontSize:14,labelPadding:5,showTitle:!0,titleFontSize:16,titlePadding:5,showTick:!0,tickLength:5,tickWidth:2,showAxisLine:!0,axisLineWidth:2,labelRotation:0},chartOrientation:"vertical",plotReservedSpacePercent:50},requirement:{useMaxWidth:!0,rect_fill:"#f9f9f9",text_color:"#333",rect_border_size:"0.5px",rect_border_color:"#bbb",rect_min_width:200,rect_min_height:200,fontSize:14,rect_padding:10,line_height:20},mindmap:{useMaxWidth:!0,padding:10,maxNodeWidth:200,layoutAlgorithm:"cose-bilkent"},ishikawa:{useMaxWidth:!0,diagramPadding:20},kanban:{useMaxWidth:!0,padding:8,sectionWidth:200,ticketBaseUrl:""},timeline:{useMaxWidth:!0,diagramMarginX:50,diagramMarginY:10,leftMargin:150,width:150,height:50,boxMargin:10,boxTextMargin:5,noteMargin:10,messageMargin:35,messageAlign:"center",bottomMarginAdj:1,rightAngles:!1,taskFontSize:14,taskFontFamily:'"Open Sans", sans-serif',taskMargin:50,activationWidth:10,textPlacement:"fo",actorColours:["#8FBC8F","#7CFC00","#00FFFF","#20B2AA","#B0E0E6","#FFFFE0"],sectionFills:["#191970","#8B008B","#4B0082","#2F4F4F","#800000","#8B4513","#00008B"],sectionColours:["#fff"],disableMulticolor:!1},gitGraph:{useMaxWidth:!0,titleTopMargin:25,diagramPadding:8,nodeLabel:{width:75,height:100,x:-25,y:0},mainBranchName:"main",mainBranchOrder:0,showCommitLabel:!0,showBranches:!0,rotateCommitLabel:!0,parallelCommits:!1,arrowMarkerAbsolute:!1},c4:{useMaxWidth:!0,diagramMarginX:50,diagramMarginY:10,c4ShapeMargin:50,c4ShapePadding:20,width:216,height:60,boxMargin:10,c4ShapeInRow:4,nextLinePaddingX:0,c4BoundaryInRow:2,personFontSize:14,personFontFamily:'"Open Sans", sans-serif',personFontWeight:"normal",external_personFontSize:14,external_personFontFamily:'"Open Sans", sans-serif',external_personFontWeight:"normal",systemFontSize:14,systemFontFamily:'"Open Sans", sans-serif',systemFontWeight:"normal",external_systemFontSize:14,external_systemFontFamily:'"Open Sans", sans-serif',external_systemFontWeight:"normal",system_dbFontSize:14,system_dbFontFamily:'"Open Sans", sans-serif',system_dbFontWeight:"normal",external_system_dbFontSize:14,external_system_dbFontFamily:'"Open Sans", sans-serif',external_system_dbFontWeight:"normal",system_queueFontSize:14,system_queueFontFamily:'"Open Sans", sans-serif',system_queueFontWeight:"normal",external_system_queueFontSize:14,external_system_queueFontFamily:'"Open Sans", sans-serif',external_system_queueFontWeight:"normal",boundaryFontSize:14,boundaryFontFamily:'"Open Sans", sans-serif',boundaryFontWeight:"normal",messageFontSize:12,messageFontFamily:'"Open Sans", sans-serif',messageFontWeight:"normal",containerFontSize:14,containerFontFamily:'"Open Sans", sans-serif',containerFontWeight:"normal",external_containerFontSize:14,external_containerFontFamily:'"Open Sans", sans-serif',external_containerFontWeight:"normal",container_dbFontSize:14,container_dbFontFamily:'"Open Sans", sans-serif',container_dbFontWeight:"normal",external_container_dbFontSize:14,external_container_dbFontFamily:'"Open Sans", sans-serif',external_container_dbFontWeight:"normal",container_queueFontSize:14,container_queueFontFamily:'"Open Sans", sans-serif',container_queueFontWeight:"normal",external_container_queueFontSize:14,external_container_queueFontFamily:'"Open Sans", sans-serif',external_container_queueFontWeight:"normal",componentFontSize:14,componentFontFamily:'"Open Sans", sans-serif',componentFontWeight:"normal",external_componentFontSize:14,external_componentFontFamily:'"Open Sans", sans-serif',external_componentFontWeight:"normal",component_dbFontSize:14,component_dbFontFamily:'"Open Sans", sans-serif',component_dbFontWeight:"normal",external_component_dbFontSize:14,external_component_dbFontFamily:'"Open Sans", sans-serif',external_component_dbFontWeight:"normal",component_queueFontSize:14,component_queueFontFamily:'"Open Sans", sans-serif',component_queueFontWeight:"normal",external_component_queueFontSize:14,external_component_queueFontFamily:'"Open Sans", sans-serif',external_component_queueFontWeight:"normal",wrap:!0,wrapPadding:10,person_bg_color:"#08427B",person_border_color:"#073B6F",external_person_bg_color:"#686868",external_person_border_color:"#8A8A8A",system_bg_color:"#1168BD",system_border_color:"#3C7FC0",system_db_bg_color:"#1168BD",system_db_border_color:"#3C7FC0",system_queue_bg_color:"#1168BD",system_queue_border_color:"#3C7FC0",external_system_bg_color:"#999999",external_system_border_color:"#8A8A8A",external_system_db_bg_color:"#999999",external_system_db_border_color:"#8A8A8A",external_system_queue_bg_color:"#999999",external_system_queue_border_color:"#8A8A8A",container_bg_color:"#438DD5",container_border_color:"#3C7FC0",container_db_bg_color:"#438DD5",container_db_border_color:"#3C7FC0",container_queue_bg_color:"#438DD5",container_queue_border_color:"#3C7FC0",external_container_bg_color:"#B3B3B3",external_container_border_color:"#A6A6A6",external_container_db_bg_color:"#B3B3B3",external_container_db_border_color:"#A6A6A6",external_container_queue_bg_color:"#B3B3B3",external_container_queue_border_color:"#A6A6A6",component_bg_color:"#85BBF0",component_border_color:"#78A8D8",component_db_bg_color:"#85BBF0",component_db_border_color:"#78A8D8",component_queue_bg_color:"#85BBF0",component_queue_border_color:"#78A8D8",external_component_bg_color:"#CCCCCC",external_component_border_color:"#BFBFBF",external_component_db_bg_color:"#CCCCCC",external_component_db_border_color:"#BFBFBF",external_component_queue_bg_color:"#CCCCCC",external_component_queue_border_color:"#BFBFBF"},sankey:{useMaxWidth:!0,width:600,height:400,linkColor:"gradient",nodeAlignment:"justify",showValues:!0,prefix:"",suffix:"",nodeWidth:10,nodePadding:12,labelStyle:"legacy"},block:{useMaxWidth:!0,padding:8},packet:{useMaxWidth:!0,rowHeight:32,bitWidth:32,bitsPerRow:32,showBits:!0,paddingX:5,paddingY:5},treeView:{useMaxWidth:!0,rowIndent:10,paddingX:5,paddingY:5,lineThickness:1,showIcons:!1,defaultIconPack:"",filenameIcons:{},extensionIcons:{}},architecture:{useMaxWidth:!0,padding:40,iconSize:80,fontSize:16,randomize:!1,nodeSeparation:75,idealEdgeLengthMultiplier:1.5,edgeElasticity:.45,numIter:2500,seed:1},eventmodeling:{useMaxWidth:!0,padding:30,rowHeight:32},radar:{useMaxWidth:!0,width:600,height:600,marginTop:50,marginRight:50,marginBottom:50,marginLeft:50,axisScaleFactor:1,axisLabelFactor:1.05,curveTension:.17},venn:{useMaxWidth:!0,width:800,height:450,padding:8,useDebugLayout:!1},cynefin:{useMaxWidth:!0,width:800,height:600,padding:40,showDomainDescriptions:!0,boundaryAmplitude:8,seed:0},theme:"default",look:"classic",handDrawnSeed:0,layout:"dagre",maxTextSize:5e4,maxEdges:500,darkMode:!1,fontFamily:'"trebuchet ms", verdana, arial, sans-serif;',logLevel:5,securityLevel:"strict",startOnLoad:!0,arrowMarkerAbsolute:!1,secure:["secure","securityLevel","startOnLoad","maxTextSize","suppressErrorRendering","maxEdges"],legacyMathML:!1,forceLegacyMathML:!1,deterministicIds:!1,fontSize:16,markdownAutoWrap:!0,suppressErrorRendering:!1},Ud={...le,deterministicIDSeed:void 0,elk:{mergeEdges:!1,nodePlacementStrategy:"BRANDES_KOEPF",nodePlacementAlignment:"NONE",forceNodeModelOrder:!1,considerModelOrder:"NODES_AND_EDGES",keepEntryNodeOnTop:!1},themeCSS:void 0,themeVariables:Tr.default.getThemeVariables(),sequence:{...le.sequence,messageFont:p(function(){return{fontFamily:this.messageFontFamily,fontSize:this.messageFontSize,fontWeight:this.messageFontWeight}},"messageFont"),noteFont:p(function(){return{fontFamily:this.noteFontFamily,fontSize:this.noteFontSize,fontWeight:this.noteFontWeight}},"noteFont"),actorFont:p(function(){return{fontFamily:this.actorFontFamily,fontSize:this.actorFontSize,fontWeight:this.actorFontWeight}},"actorFont")},class:{defaultRenderer:"dagre-wrapper",hideEmptyMembersBox:!1,hierarchicalNamespaces:!0},gantt:{...le.gantt,tickInterval:void 0,useWidth:void 0},c4:{...le.c4,useWidth:void 0,personFont:p(function(){return{fontFamily:this.personFontFamily,fontSize:this.personFontSize,fontWeight:this.personFontWeight}},"personFont"),flowchart:{...le.flowchart,inheritDir:!1},external_personFont:p(function(){return{fontFamily:this.external_personFontFamily,fontSize:this.external_personFontSize,fontWeight:this.external_personFontWeight}},"external_personFont"),systemFont:p(function(){return{fontFamily:this.systemFontFamily,fontSize:this.systemFontSize,fontWeight:this.systemFontWeight}},"systemFont"),external_systemFont:p(function(){return{fontFamily:this.external_systemFontFamily,fontSize:this.external_systemFontSize,fontWeight:this.external_systemFontWeight}},"external_systemFont"),system_dbFont:p(function(){return{fontFamily:this.system_dbFontFamily,fontSize:this.system_dbFontSize,fontWeight:this.system_dbFontWeight}},"system_dbFont"),external_system_dbFont:p(function(){return{fontFamily:this.external_system_dbFontFamily,fontSize:this.external_system_dbFontSize,fontWeight:this.external_system_dbFontWeight}},"external_system_dbFont"),system_queueFont:p(function(){return{fontFamily:this.system_queueFontFamily,fontSize:this.system_queueFontSize,fontWeight:this.system_queueFontWeight}},"system_queueFont"),external_system_queueFont:p(function(){return{fontFamily:this.external_system_queueFontFamily,fontSize:this.external_system_queueFontSize,fontWeight:this.external_system_queueFontWeight}},"external_system_queueFont"),containerFont:p(function(){return{fontFamily:this.containerFontFamily,fontSize:this.containerFontSize,fontWeight:this.containerFontWeight}},"containerFont"),external_containerFont:p(function(){return{fontFamily:this.external_containerFontFamily,fontSize:this.external_containerFontSize,fontWeight:this.external_containerFontWeight}},"external_containerFont"),container_dbFont:p(function(){return{fontFamily:this.container_dbFontFamily,fontSize:this.container_dbFontSize,fontWeight:this.container_dbFontWeight}},"container_dbFont"),external_container_dbFont:p(function(){return{fontFamily:this.external_container_dbFontFamily,fontSize:this.external_container_dbFontSize,fontWeight:this.external_container_dbFontWeight}},"external_container_dbFont"),container_queueFont:p(function(){return{fontFamily:this.container_queueFontFamily,fontSize:this.container_queueFontSize,fontWeight:this.container_queueFontWeight}},"container_queueFont"),external_container_queueFont:p(function(){return{fontFamily:this.external_container_queueFontFamily,fontSize:this.external_container_queueFontSize,fontWeight:this.external_container_queueFontWeight}},"external_container_queueFont"),componentFont:p(function(){return{fontFamily:this.componentFontFamily,fontSize:this.componentFontSize,fontWeight:this.componentFontWeight}},"componentFont"),external_componentFont:p(function(){return{fontFamily:this.external_componentFontFamily,fontSize:this.external_componentFontSize,fontWeight:this.external_componentFontWeight}},"external_componentFont"),component_dbFont:p(function(){return{fontFamily:this.component_dbFontFamily,fontSize:this.component_dbFontSize,fontWeight:this.component_dbFontWeight}},"component_dbFont"),external_component_dbFont:p(function(){return{fontFamily:this.external_component_dbFontFamily,fontSize:this.external_component_dbFontSize,fontWeight:this.external_component_dbFontWeight}},"external_component_dbFont"),component_queueFont:p(function(){return{fontFamily:this.component_queueFontFamily,fontSize:this.component_queueFontSize,fontWeight:this.component_queueFontWeight}},"component_queueFont"),external_component_queueFont:p(function(){return{fontFamily:this.external_component_queueFontFamily,fontSize:this.external_component_queueFontSize,fontWeight:this.external_component_queueFontWeight}},"external_component_queueFont"),boundaryFont:p(function(){return{fontFamily:this.boundaryFontFamily,fontSize:this.boundaryFontSize,fontWeight:this.boundaryFontWeight}},"boundaryFont"),messageFont:p(function(){return{fontFamily:this.messageFontFamily,fontSize:this.messageFontSize,fontWeight:this.messageFontWeight}},"messageFont")},pie:{...le.pie,useWidth:984},xyChart:{...le.xyChart,useWidth:void 0},requirement:{...le.requirement,useWidth:void 0},packet:{...le.packet},eventmodeling:{...le.eventmodeling},treeView:{...le.treeView,useWidth:void 0},radar:{...le.radar},railroad:{...le.railroad,fontSize:void 0,fontFamily:void 0,terminalFill:void 0,terminalStroke:void 0,terminalTextColor:void 0,nonTerminalFill:void 0,nonTerminalStroke:void 0,nonTerminalTextColor:void 0,lineColor:void 0,markerFill:void 0,commentFill:void 0,commentStroke:void 0,commentTextColor:void 0,specialFill:void 0,specialStroke:void 0,ruleNameColor:void 0},ishikawa:{...le.ishikawa},sankey:{...le.sankey,nodeColors:void 0},treemap:{useMaxWidth:!0,padding:10,diagramPadding:8,showValues:!0,nodeWidth:100,nodeHeight:40,borderWidth:1,valueFontSize:12,labelFontSize:14,valueFormat:","},venn:{...le.venn},cynefin:{...le.cynefin}},jd=p((e,t="")=>Object.keys(e).reduce((r,i)=>Array.isArray(e[i])?r:typeof e[i]=="object"&&e[i]!==null?[...r,t+i,...jd(e[i],"")]:[...r,t+i],[]),"keyify"),AC=new Set(jd(Ud,"")),Gd=Ud,EC={nodeColors:/^#[\da-f]{3,8}$|^rgb\([\d\s%,.]+\)$|^hsl\([\d\s%,.]+\)$|^[a-z]+$/i,filenameIcons:/^[\w-]+(?::[\w-]+)?$/,extensionIcons:/^[\w-]+(?::[\w-]+)?$/},MC=p((e,t)=>{for(const r of Object.keys(e)){const i=e[r];(r.startsWith("__")||r.includes("proto")||r.includes("constr")||typeof i!="string"||!t.test(i))&&(R.debug("sanitize deleting dictionary entry:",r,i),delete e[r])}},"sanitizeDictionaryConfig"),Co=p(e=>{if(R.debug("sanitizeDirective called with",e),!(typeof e!="object"||e==null)){if(Array.isArray(e)){e.forEach(t=>Co(t));return}for(const t of Object.keys(e)){if(R.debug("Checking key",t),t.startsWith("__")||t.includes("proto")||t.includes("constr")||!AC.has(t)||e[t]==null){R.debug("sanitize deleting key: ",t),delete e[t];continue}if(typeof e[t]=="object"){const i=EC[t];i?MC(e[t],i):(R.debug("sanitizing object",t),Co(e[t]));continue}const r=["themeCSS","fontFamily","altFontFamily"];for(const i of r)t.includes(i)&&(R.debug("sanitizing css option",t),e[t]=Xd(e[t]))}if(e.themeVariables)for(const t of Object.keys(e.themeVariables)){const r=e.themeVariables[t];r?.match&&!r.match(/^[\d "#%(),.;A-Za-z]+$/)&&(e.themeVariables[t]="")}R.debug("After sanitization",e)}},"sanitizeDirective"),Xd=p(e=>{let t=0,r=0;for(const i of e){if(t!(e===!1||["false","null","0"].includes(String(e).trim().toLowerCase())),"evaluate"),$e=ne({},Oi),bo,ii=[],ys=ne({},Oi),Os=p((e,t)=>{let r=ne({},e),i={};for(const s of t)Kd(s),i=ne(i,s);if(r=ne(r,i),i.theme&&i.theme in Tr){const s=ne({},bo),o=ne(s.themeVariables||{},i.themeVariables);r.theme&&r.theme in Tr&&(r.themeVariables=Tr[r.theme].getThemeVariables(o))}return ys=r,RC(ys),ys},"updateCurrentConfig"),$C=p(e=>($e=ne({},Oi),$e=ne($e,e),e.theme&&Tr[e.theme]&&($e.themeVariables=Tr[e.theme].getThemeVariables(e.themeVariables)),Os($e,ii),$e),"setSiteConfig"),OC=p(e=>{bo=ne({},e)},"saveConfigFromInitialize"),DC=p(e=>($e=ne($e,e),Os($e,ii),$e),"updateSiteConfig"),Vd=p(()=>ne({},$e),"getSiteConfig"),Zd=p(e=>(Os(ys,[e]),Zt()),"setConfig"),Zt=p(()=>ne({},ys),"getConfig"),Kd=p(e=>{e&&(["secure",...$e.secure??[]].forEach(t=>{Object.hasOwn(e,t)&&(R.debug(`Denied attempt to modify a secure key ${t}`,e[t]),delete e[t])}),Object.keys(e).forEach(t=>{t.startsWith("__")&&delete e[t]}),Object.keys(e).forEach(t=>{typeof e[t]=="string"&&(e[t].includes("<")||e[t].includes(">")||e[t].includes("url(data:"))&&delete e[t],typeof e[t]=="object"&&Kd(e[t])}))},"sanitize"),IC=p(e=>{Co(e),e.fontFamily&&!e.themeVariables?.fontFamily&&(e.themeVariables={...e.themeVariables,fontFamily:e.fontFamily}),ii.push(e),Os($e,ii)},"addDirective"),ko=p((e=$e)=>{ii=[],Os(e,ii)},"reset"),PC={LAZY_LOAD_DEPRECATED:"The configuration options lazyLoadedDiagrams and loadExternalDiagramsAtStartup are deprecated. Please use registerExternalDiagrams instead.",FLOWCHART_HTML_LABELS_DEPRECATED:"flowchart.htmlLabels is deprecated. Please use global htmlLabels instead."},dc={},Qd=p(e=>{dc[e]||(R.warn(PC[e]),dc[e]=!0)},"issueWarning"),RC=p(e=>{e&&(e.lazyLoadedDiagrams||e.loadExternalDiagramsAtStartup)&&Qd("LAZY_LOAD_DEPRECATED")},"checkConfig"),z5=p(()=>{let e={};bo&&(e=ne(e,bo));for(const t of ii)e=ne(e,t);return e},"getUserDefinedConfig"),be=p(e=>(e.flowchart?.htmlLabels!=null&&Qd("FLOWCHART_HTML_LABELS_DEPRECATED"),ur(e.htmlLabels??e.flowchart?.htmlLabels??!0)),"getEffectiveHtmlLabels"),Jd=/^([^\S\n\r]*)-{3}\s*[\n\r](.*?)[\n\r]\1-{3}\s*[\n\r]+/s,xs=/%{2}{\s*(?:(\w+)\s*:|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi,NC=/\s*%%.*\n/gm,tf=class extends Error{static{p(this,"UnknownDiagramError")}constructor(e){super(e),this.name="UnknownDiagramError"}},si={},gl=p(function(e,t){e=e.replace(Jd,"").replace(xs,"").replace(NC,` +`);for(const[r,{detector:i}]of Object.entries(si))if(i(e,t))return r;throw new tf(`No diagram type detected matching given configuration for text: ${e}`)},"detectType"),vn=p((...e)=>{for(const{id:t,detector:r,loader:i}of e)ef(t,r,i)},"registerLazyLoadedDiagrams"),ef=p((e,t,r)=>{si[e]&&R.warn(`Detector with key ${e} already exists. Overwriting.`),si[e]={detector:t,loader:r},R.debug(`Detector with key ${e} added${r?" with loader":""}`)},"addDetector"),qC=p(e=>si[e].loader,"getDiagramLoader"),Ds=//gi,zC=p(e=>e?of(e).replace(/\\n/g,"#br#").split("#br#"):[""],"getRows"),WC=(()=>{let e=!1;return()=>{e||(rf(),e=!0)}})();function rf(){const e="data-temp-href-target";$i.addHook("beforeSanitizeAttributes",t=>{t.tagName==="A"&&t.hasAttribute("target")&&t.setAttribute(e,t.getAttribute("target")??"")}),$i.addHook("afterSanitizeAttributes",t=>{t.tagName==="A"&&t.hasAttribute(e)&&(t.setAttribute("target",t.getAttribute(e)??""),t.removeAttribute(e),t.getAttribute("target")==="_blank"&&t.setAttribute("rel","noopener"))})}p(rf,"setupDompurifyHooks");var sf=p(e=>(WC(),$i.sanitize(e)),"removeScript"),fc=p((e,t)=>{if(be(t)){const r=t.securityLevel;r==="antiscript"||r==="strict"||r==="sandbox"?e=sf(e):r!=="loose"&&(e=of(e),e=e.replace(//g,">"),e=e.replace(/=/g,"="),e=jC(e))}return e},"sanitizeMore"),ze=p((e,t)=>e&&(t.dompurifyConfig?e=$i.sanitize(fc(e,t),t.dompurifyConfig).toString():e=$i.sanitize(fc(e,t),{FORBID_TAGS:["style"]}).toString(),e),"sanitizeText"),HC=p((e,t)=>typeof e=="string"?ze(e,t):e.flat().map(r=>ze(r,t)),"sanitizeTextOrArray"),YC=p(e=>Ds.test(e),"hasBreaks"),UC=p(e=>e.split(Ds),"splitBreaks"),jC=p(e=>e.replace(/#br#/g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "),"placeholderToBreak"),of=p(e=>e.replace(Ds,"#br#"),"breakToPlaceholder"),GC=p(e=>{let t="";return e&&(t=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,t=CSS.escape(t)),t},"getUrl"),XC=p(function(...e){const t=e.filter(r=>!isNaN(r));return Math.max(...t)},"getMax"),VC=p(function(...e){const t=e.filter(r=>!isNaN(r));return Math.min(...t)},"getMin"),pc=p(function(e){const t=e.split(/(,)/),r=[];for(let i=0;i0&&i+1Math.max(0,e.split(t).length-1),"countOccurrence"),ZC=p((e,t)=>{const r=Bn(e,"~"),i=Bn(t,"~");return r===1&&i===1},"shouldCombineSets"),KC=p(e=>{const t=Bn(e,"~");let r=!1;if(t<=1)return e;t%2!==0&&e.startsWith("~")&&(e=e.substring(1),r=!0);const i=[...e];let s=i.indexOf("~"),o=i.lastIndexOf("~");for(;s!==-1&&o!==-1&&s!==o;)i[s]="<",i[o]=">",s=i.indexOf("~"),o=i.lastIndexOf("~");return r&&i.unshift("~"),i.join("")},"processSet"),gc=p(()=>window.MathMLElement!==void 0,"isMathMLSupported"),Ln=/\$\$(.*?)\$\$/g,Ts=p(e=>(e.match(Ln)?.length??0)>0,"hasKatex"),W5=p(async(e,t)=>{const r=document.createElement("div");r.innerHTML=await af(e,t),r.id="katex-temp",r.style.visibility="hidden",r.style.position="absolute",r.style.top="0",document.querySelector("body")?.insertAdjacentElement("beforeend",r);const s={width:r.clientWidth,height:r.clientHeight};return r.remove(),s},"calculateMathMLDimensions"),QC=p(async(e,t)=>{if(!Ts(e))return e;if(!(gc()||t.legacyMathML||t.forceLegacyMathML))return e.replace(Ln,"MathML is unsupported in this environment.");{const{default:r}=await Et(async()=>{const{default:s}=await import("./chunks/katex.HP8lGamR.js");return{default:s}},[]),i=t.forceLegacyMathML||!gc()&&t.legacyMathML?"htmlAndMathml":"mathml";return e.split(Ds).map(s=>Ts(s)?`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${s}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `:`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${s}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `).join("").replace(Ln,(s,o)=>r.renderToString(o,{throwOnError:!0,displayMode:!0,output:i}).replace(/\n/g," ").replace(//g,""))}},"renderKatexUnsanitized"),af=p(async(e,t)=>ze(await QC(e,t),t),"renderKatexSanitized"),Is={getRows:zC,sanitizeText:ze,sanitizeTextOrArray:HC,hasBreaks:YC,splitBreaks:UC,lineBreakRegex:Ds,removeScript:sf,getUrl:GC,evaluate:ur,getMax:XC,getMin:VC},JC=p(function(e,t){for(let r of t)e.attr(r[0],r[1])},"d3Attrs"),tb=p(function(e,t,r){let i=new Map;return r?(i.set("width","100%"),i.set("style",`max-width: ${t}px;`)):(i.set("height",e),i.set("width",t)),i},"calculateSvgSizeAttrs"),nf=p(function(e,t,r,i){const s=tb(t,r,i);JC(e,s)},"configureSvgSize"),eb=p(function(e,t,r,i){const s=t.node().getBBox(),o=s.width,a=s.height;R.info(`SVG bounds: ${o}x${a}`,s);let n=0,l=0;R.info(`Graph bounds: ${n}x${l}`,e),n=o+r*2,l=a+r*2,R.info(`Calculated bounds: ${n}x${l}`),nf(t,l,n,i);const c=`${s.x-r} ${s.y-r} ${s.width+2*r} ${s.height+2*r}`;t.attr("viewBox",c)},"setupGraphViewbox"),lo={};function Fn(e){return[...e.cssRules].map(t=>t.cssText).join(` +`)}p(Fn,"cssStyleSheetToString");var rb=p((e,t,r,i)=>{let s="";return e in lo&&lo[e]?s=lo[e]({...r,svgId:i}):R.warn(`No theme found for ${e}`),`& { + font-family: ${r.fontFamily}; + font-size: ${r.fontSize}; + fill: ${r.textColor} + } + @keyframes edge-animation-frame { + from { + stroke-dashoffset: 0; + } + } + @keyframes dash { + to { + stroke-dashoffset: 0; + } + } + & .edge-animation-slow { + stroke-dasharray: 9,5 !important; + stroke-dashoffset: 900; + animation: dash 50s linear infinite; + stroke-linecap: round; + } + & .edge-animation-fast { + stroke-dasharray: 9,5 !important; + stroke-dashoffset: 900; + animation: dash 20s linear infinite; + stroke-linecap: round; + } + /* Classes common for multiple diagrams */ + + & .error-icon { + fill: ${r.errorBkgColor}; + } + & .error-text { + fill: ${r.errorTextColor}; + stroke: ${r.errorTextColor}; + } + + & .edge-thickness-normal { + stroke-width: ${r.strokeWidth??1}px; + } + & .edge-thickness-thick { + stroke-width: 3.5px + } + & .edge-pattern-solid { + stroke-dasharray: 0; + } + & .edge-thickness-invisible { + stroke-width: 0; + fill: none; + } + & .edge-pattern-dashed{ + stroke-dasharray: 3; + } + .edge-pattern-dotted { + stroke-dasharray: 2; + } + + & .marker { + fill: ${r.lineColor}; + stroke: ${r.lineColor}; + } + & .marker.cross { + stroke: ${r.lineColor}; + } + + & svg { + font-family: ${r.fontFamily}; + font-size: ${r.fontSize}; + } + & p { + margin: 0 + } + + ${s} + .node .neo-node { + stroke: ${r.nodeBorder}; + } + + [data-look="neo"].node rect, [data-look="neo"].cluster rect, [data-look="neo"].node polygon { + stroke: ${r.useGradient?"url("+i+"-gradient)":r.nodeBorder}; + filter: ${r.dropShadow?r.dropShadow.replace("url(#drop-shadow)",`url(${i}-drop-shadow)`):"none"}; + } + [data-look="neo"].swimlane.cluster rect { + filter: none; + } + + + [data-look="neo"].node path { + stroke: ${r.useGradient?"url("+i+"-gradient)":r.nodeBorder}; + stroke-width: ${r.strokeWidth??1}px; + } + + [data-look="neo"].node .outer-path { + filter: ${r.dropShadow?r.dropShadow.replace("url(#drop-shadow)",`url(${i}-drop-shadow)`):"none"}; + } + + [data-look="neo"].node .neo-line path { + stroke: ${r.nodeBorder}; + filter: none; + } + + [data-look="neo"].node circle{ + stroke: ${r.useGradient?"url("+i+"-gradient)":r.nodeBorder}; + filter: ${r.dropShadow?r.dropShadow.replace("url(#drop-shadow)",`url(${i}-drop-shadow)`):"none"}; + } + + [data-look="neo"].node circle .state-start{ + fill: #000000; + } + + [data-look="neo"].icon-shape .icon { + fill: ${r.useGradient?"url("+i+"-gradient)":r.nodeBorder}; + filter: ${r.dropShadow?r.dropShadow.replace("url(#drop-shadow)",`url(${i}-drop-shadow)`):"none"}; + } + + [data-look="neo"].icon-shape .icon-neo path { + stroke: ${r.useGradient?"url("+i+"-gradient)":r.nodeBorder}; + filter: ${r.dropShadow?r.dropShadow.replace("url(#drop-shadow)",`url(${i}-drop-shadow)`):"none"}; + } + + ${t} +`},"getStyles"),ib=p((e,t)=>{t!==void 0&&(lo[e]=t)},"addStylesForDiagram"),sb=rb,lf={};bx(lf,{clear:()=>ob,getAccDescription:()=>hb,getAccTitle:()=>nb,getDiagramTitle:()=>ub,setAccDescription:()=>lb,setAccTitle:()=>ab,setDiagramTitle:()=>cb});var ml="",yl="",xl="",Cl=p(e=>ze(e,Zt()),"sanitizeText"),ob=p(()=>{ml="",xl="",yl=""},"clear"),ab=p(e=>{ml=Cl(e).replace(/^\s+/g,"")},"setAccTitle"),nb=p(()=>ml,"getAccTitle"),lb=p(e=>{xl=Cl(e).replace(/\n\s+/g,` +`)},"setAccDescription"),hb=p(()=>xl,"getAccDescription"),cb=p(e=>{yl=Cl(e)},"setDiagramTitle"),ub=p(()=>yl,"getDiagramTitle"),mc=R,db=pl,It=Zt,H5=Zd,Y5=Oi,bl=p(e=>ze(e,It()),"sanitizeText"),fb=eb,pb=p(()=>lf,"getCommonDb"),wo={},To=p((e,t,r)=>{wo[e]&&mc.warn(`Diagram with id ${e} already registered. Overwriting.`),wo[e]=t,r&&ef(e,r),ib(e,t.styles),t.injectUtils?.(mc,db,It,bl,fb,pb(),()=>{})},"registerDiagram"),An=p(e=>{if(e in wo)return wo[e];throw new gb(e)},"getDiagram"),gb=class extends Error{static{p(this,"DiagramNotFoundError")}constructor(e){super(`Diagram ${e} not found.`)}},mb={value:()=>{}};function hf(){for(var e=0,t=arguments.length,r={},i;e=0&&(i=r.slice(s+1),r=r.slice(0,s)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:i}})}ho.prototype=hf.prototype={constructor:ho,on:function(e,t){var r=this._,i=yb(e+"",r),s,o=-1,a=i.length;if(arguments.length<2){for(;++o0)for(var r=new Array(s),i=0,s,o;i=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),xc.hasOwnProperty(t)?{space:xc[t],local:e}:e}function Cb(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===En&&t.documentElement.namespaceURI===En?t.createElement(e):t.createElementNS(r,e)}}function bb(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function cf(e){var t=Xo(e);return(t.local?bb:Cb)(t)}function kb(){}function kl(e){return e==null?kb:function(){return this.querySelector(e)}}function wb(e){typeof e!="function"&&(e=kl(e));for(var t=this._groups,r=t.length,i=new Array(r),s=0;s=T&&(T=k+1);!(v=x[T])&&++T=0;)(a=i[s])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}function Gb(e){e||(e=Xb);function t(u,d){return u&&d?e(u.__data__,d.__data__):!u-!d}for(var r=this._groups,i=r.length,s=new Array(i),o=0;ot?1:e>=t?0:NaN}function Vb(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function Zb(){return Array.from(this)}function Kb(){for(var e=this._groups,t=0,r=e.length;t1?this.each((t==null?l1:typeof t=="function"?c1:h1)(e,t,r??"")):Di(this.node(),e)}function Di(e,t){return e.style.getPropertyValue(t)||gf(e).getComputedStyle(e,null).getPropertyValue(t)}function d1(e){return function(){delete this[e]}}function f1(e,t){return function(){this[e]=t}}function p1(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function g1(e,t){return arguments.length>1?this.each((t==null?d1:typeof t=="function"?p1:f1)(e,t)):this.node()[e]}function mf(e){return e.trim().split(/^|\s+/)}function wl(e){return e.classList||new yf(e)}function yf(e){this._node=e,this._names=mf(e.getAttribute("class")||"")}yf.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}};function xf(e,t){for(var r=wl(e),i=-1,s=t.length;++i=0&&(r=t.slice(i+1),t=t.slice(0,i)),{type:t,name:r}})}function H1(e){return function(){var t=this.__on;if(t){for(var r=0,i=-1,s=t.length,o;r>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?Xs(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?Xs(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=Q1.exec(e))?new Oe(t[1],t[2],t[3],1):(t=J1.exec(e))?new Oe(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=tk.exec(e))?Xs(t[1],t[2],t[3],t[4]):(t=ek.exec(e))?Xs(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=rk.exec(e))?Sc(t[1],t[2]/100,t[3]/100,1):(t=ik.exec(e))?Sc(t[1],t[2]/100,t[3]/100,t[4]):Cc.hasOwnProperty(e)?wc(Cc[e]):e==="transparent"?new Oe(NaN,NaN,NaN,0):null}function wc(e){return new Oe(e>>16&255,e>>8&255,e&255,1)}function Xs(e,t,r,i){return i<=0&&(e=t=r=NaN),new Oe(e,t,r,i)}function ak(e){return e instanceof Rs||(e=vs(e)),e?(e=e.rgb(),new Oe(e.r,e.g,e.b,e.opacity)):new Oe}function Mn(e,t,r,i){return arguments.length===1?ak(e):new Oe(e,t,r,i??1)}function Oe(e,t,r,i){this.r=+e,this.g=+t,this.b=+r,this.opacity=+i}Tl(Oe,Mn,wf(Rs,{brighter(e){return e=e==null?So:Math.pow(So,e),new Oe(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=e==null?_s:Math.pow(_s,e),new Oe(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new Oe(ri(this.r),ri(this.g),ri(this.b),vo(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Tc,formatHex:Tc,formatHex8:nk,formatRgb:_c,toString:_c}));function Tc(){return`#${ti(this.r)}${ti(this.g)}${ti(this.b)}`}function nk(){return`#${ti(this.r)}${ti(this.g)}${ti(this.b)}${ti((isNaN(this.opacity)?1:this.opacity)*255)}`}function _c(){const e=vo(this.opacity);return`${e===1?"rgb(":"rgba("}${ri(this.r)}, ${ri(this.g)}, ${ri(this.b)}${e===1?")":`, ${e})`}`}function vo(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function ri(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function ti(e){return e=ri(e),(e<16?"0":"")+e.toString(16)}function Sc(e,t,r,i){return i<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Xe(e,t,r,i)}function Tf(e){if(e instanceof Xe)return new Xe(e.h,e.s,e.l,e.opacity);if(e instanceof Rs||(e=vs(e)),!e)return new Xe;if(e instanceof Xe)return e;e=e.rgb();var t=e.r/255,r=e.g/255,i=e.b/255,s=Math.min(t,r,i),o=Math.max(t,r,i),a=NaN,n=o-s,l=(o+s)/2;return n?(t===o?a=(r-i)/n+(r0&&l<1?0:a,new Xe(a,n,l,e.opacity)}function lk(e,t,r,i){return arguments.length===1?Tf(e):new Xe(e,t,r,i??1)}function Xe(e,t,r,i){this.h=+e,this.s=+t,this.l=+r,this.opacity=+i}Tl(Xe,lk,wf(Rs,{brighter(e){return e=e==null?So:Math.pow(So,e),new Xe(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=e==null?_s:Math.pow(_s,e),new Xe(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,i=r+(r<.5?r:1-r)*t,s=2*r-i;return new Oe(Ea(e>=240?e-240:e+120,s,i),Ea(e,s,i),Ea(e<120?e+240:e-120,s,i),this.opacity)},clamp(){return new Xe(vc(this.h),Vs(this.s),Vs(this.l),vo(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const e=vo(this.opacity);return`${e===1?"hsl(":"hsla("}${vc(this.h)}, ${Vs(this.s)*100}%, ${Vs(this.l)*100}%${e===1?")":`, ${e})`}`}}));function vc(e){return e=(e||0)%360,e<0?e+360:e}function Vs(e){return Math.max(0,Math.min(1,e||0))}function Ea(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}const _l=e=>()=>e;function _f(e,t){return function(r){return e+r*t}}function hk(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(i){return Math.pow(e+i*t,r)}}function U5(e,t){var r=t-e;return r?_f(e,r>180||r<-180?r-360*Math.round(r/360):r):_l(isNaN(e)?t:e)}function ck(e){return(e=+e)==1?Sf:function(t,r){return r-t?hk(t,r,e):_l(isNaN(t)?r:t)}}function Sf(e,t){var r=t-e;return r?_f(e,r):_l(isNaN(e)?t:e)}const Bc=(function e(t){var r=ck(t);function i(s,o){var a=r((s=Mn(s)).r,(o=Mn(o)).r),n=r(s.g,o.g),l=r(s.b,o.b),c=Sf(s.opacity,o.opacity);return function(h){return s.r=a(h),s.g=n(h),s.b=l(h),s.opacity=c(h),s+""}}return i.gamma=e,i})(1);function Ir(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var $n=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ma=new RegExp($n.source,"g");function uk(e){return function(){return e}}function dk(e){return function(t){return e(t)+""}}function fk(e,t){var r=$n.lastIndex=Ma.lastIndex=0,i,s,o,a=-1,n=[],l=[];for(e=e+"",t=t+"";(i=$n.exec(e))&&(s=Ma.exec(t));)(o=s.index)>r&&(o=t.slice(r,o),n[a]?n[a]+=o:n[++a]=o),(i=i[0])===(s=s[0])?n[a]?n[a]+=s:n[++a]=s:(n[++a]=null,l.push({i:a,x:Ir(i,s)})),r=Ma.lastIndex;return r180?h+=360:h-c>180&&(c+=360),d.push({i:u.push(s(u)+"rotate(",null,i)-2,x:Ir(c,h)})):h&&u.push(s(u)+"rotate("+h+i)}function n(c,h,u,d){c!==h?d.push({i:u.push(s(u)+"skewX(",null,i)-2,x:Ir(c,h)}):h&&u.push(s(u)+"skewX("+h+i)}function l(c,h,u,d,f,m){if(c!==u||h!==d){var y=f.push(s(f)+"scale(",null,",",null,")");m.push({i:y-4,x:Ir(c,u)},{i:y-2,x:Ir(h,d)})}else(u!==1||d!==1)&&f.push(s(f)+"scale("+u+","+d+")")}return function(c,h){var u=[],d=[];return c=e(c),h=e(h),o(c.translateX,c.translateY,h.translateX,h.translateY,u,d),a(c.rotate,h.rotate,u,d),n(c.skewX,h.skewX,u,d),l(c.scaleX,c.scaleY,h.scaleX,h.scaleY,u,d),c=h=null,function(f){for(var m=-1,y=d.length,x;++m=0&&e._call.call(void 0,t),e=e._next;--Ii}function Fc(){oi=(Lo=Bs.now())+Vo,Ii=ns=0;try{Ck()}finally{Ii=0,kk(),oi=0}}function bk(){var e=Bs.now(),t=e-Lo;t>Lf&&(Vo-=t,Lo=e)}function kk(){for(var e,t=Bo,r,i=1/0;t;)t._call?(i>t._time&&(i=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:Bo=r);ls=e,Dn(i)}function Dn(e){if(!Ii){ns&&(ns=clearTimeout(ns));var t=e-oi;t>24?(e<1/0&&(ns=setTimeout(Fc,e-Bs.now()-Vo)),Ki&&(Ki=clearInterval(Ki))):(Ki||(Lo=Bs.now(),Ki=setInterval(bk,Lf)),Ii=1,Ff(Fc))}}function Ac(e,t,r){var i=new Fo;return t=t==null?0:+t,i.restart(s=>{i.stop(),e(s+t)},t,r),i}var wk=hf("start","end","cancel","interrupt"),Tk=[],Ef=0,Ec=1,In=2,co=3,Mc=4,Pn=5,uo=6;function Zo(e,t,r,i,s,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;_k(e,r,{name:t,index:i,group:s,on:wk,tween:Tk,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:Ef})}function vl(e,t){var r=Ke(e,t);if(r.state>Ef)throw new Error("too late; already scheduled");return r}function dr(e,t){var r=Ke(e,t);if(r.state>co)throw new Error("too late; already running");return r}function Ke(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function _k(e,t,r){var i=e.__transition,s;i[t]=r,r.timer=Af(o,0,r.time);function o(c){r.state=Ec,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var h,u,d,f;if(r.state!==Ec)return l();for(h in i)if(f=i[h],f.name===r.name){if(f.state===co)return Ac(a);f.state===Mc?(f.state=uo,f.timer.stop(),f.on.call("interrupt",e,e.__data__,f.index,f.group),delete i[h]):+hIn&&i.state=0&&(t=t.slice(0,r)),!t||t==="start"})}function e2(e,t,r){var i,s,o=t2(t)?vl:dr;return function(){var a=o(this,e),n=a.on;n!==i&&(s=(i=n).copy()).on(t,r),a.on=s}}function r2(e,t){var r=this._id;return arguments.length<2?Ke(this.node(),r).on.on(e):this.each(e2(r,e,t))}function i2(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function s2(){return this.on("end.remove",i2(this._id))}function o2(e){var t=this._name,r=this._id;typeof e!="function"&&(e=kl(e));for(var i=this._groups,s=i.length,o=new Array(s),a=0;a=0))throw new Error(`invalid digits: ${e}`);if(t>15)return Df;const r=10**t;return function(i){this._+=i[0];for(let s=1,o=i.length;sKr)if(!(Math.abs(u*l-c*h)>Kr)||!o)this._append`L${this._x1=t},${this._y1=r}`;else{let f=i-a,m=s-n,y=l*l+c*c,x=f*f+m*m,C=Math.sqrt(y),k=Math.sqrt(d),T=o*Math.tan((Rn-Math.acos((y+d-x)/(2*C*k)))/2),S=T/k,v=T/C;Math.abs(S-1)>Kr&&this._append`L${t+S*h},${r+S*u}`,this._append`A${o},${o},0,0,${+(u*f>h*m)},${this._x1=t+v*l},${this._y1=r+v*c}`}}arc(t,r,i,s,o,a){if(t=+t,r=+r,i=+i,a=!!a,i<0)throw new Error(`negative radius: ${i}`);let n=i*Math.cos(s),l=i*Math.sin(s),c=t+n,h=r+l,u=1^a,d=a?s-o:o-s;this._x1===null?this._append`M${c},${h}`:(Math.abs(this._x1-c)>Kr||Math.abs(this._y1-h)>Kr)&&this._append`L${c},${h}`,i&&(d<0&&(d=d%Nn+Nn),d>A2?this._append`A${i},${i},0,1,${u},${t-n},${r-l}A${i},${i},0,1,${u},${this._x1=c},${this._y1=h}`:d>Kr&&this._append`A${i},${i},0,${+(d>=Rn)},${u},${this._x1=t+i*Math.cos(o)},${this._y1=r+i*Math.sin(o)}`)}rect(t,r,i,s){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+r}h${i=+i}v${+s}h${-i}Z`}toString(){return this._}}function Ci(e){return function(){return e}}const j5=Math.abs,G5=Math.atan2,X5=Math.cos,V5=Math.max,Z5=Math.min,K5=Math.sin,Q5=Math.sqrt,$c=1e-12,Ll=Math.PI,Oc=Ll/2,J5=2*Ll;function t3(e){return e>1?0:e<-1?Ll:Math.acos(e)}function e3(e){return e>=1?Oc:e<=-1?-Oc:Math.asin(e)}function $2(e){let t=3;return e.digits=function(r){if(!arguments.length)return t;if(r==null)t=null;else{const i=Math.floor(r);if(!(i>=0))throw new RangeError(`invalid digits: ${r}`);t=i}return e},()=>new M2(t)}function O2(e){return typeof e=="object"&&"length"in e?e:Array.from(e)}function If(e){this._context=e}If.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Cs(e){return new If(e)}function D2(e){return e[0]}function I2(e){return e[1]}function P2(e,t){var r=Ci(!0),i=null,s=Cs,o=null,a=$2(n);e=typeof e=="function"?e:e===void 0?D2:Ci(e),t=typeof t=="function"?t:t===void 0?I2:Ci(t);function n(l){var c,h=(l=O2(l)).length,u,d=!1,f;for(i==null&&(o=s(f=a())),c=0;c<=h;++c)!(c0)for(var i=e[0],s=t[0],o=e[r]-i,a=t[r]-s,n=-1,l;++n<=r;)l=n/r,this._basis.point(this._beta*e[n]+(1-this._beta)*(i+l*o),this._beta*t[n]+(1-this._beta)*(s+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};const q2=(function e(t){function r(i){return t===1?new Ko(i):new Wf(i,t)}return r.beta=function(i){return e(+i)},r})(.85);function Eo(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function Fl(e,t){this._context=e,this._k=(1-t)/6}Fl.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Eo(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:Eo(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const Hf=(function e(t){function r(i){return new Fl(i,t)}return r.tension=function(i){return e(+i)},r})(0);function Al(e,t){this._context=e,this._k=(1-t)/6}Al.prototype={areaStart:zr,areaEnd:zr,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Eo(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const z2=(function e(t){function r(i){return new Al(i,t)}return r.tension=function(i){return e(+i)},r})(0);function El(e,t){this._context=e,this._k=(1-t)/6}El.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Eo(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const W2=(function e(t){function r(i){return new El(i,t)}return r.tension=function(i){return e(+i)},r})(0);function Ml(e,t,r){var i=e._x1,s=e._y1,o=e._x2,a=e._y2;if(e._l01_a>$c){var n=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);i=(i*n-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,s=(s*n-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>$c){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,h=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/h,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/h}e._context.bezierCurveTo(i,s,o,a,e._x2,e._y2)}function Yf(e,t){this._context=e,this._alpha=t}Yf.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,i=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:Ml(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const Uf=(function e(t){function r(i){return t?new Yf(i,t):new Fl(i,0)}return r.alpha=function(i){return e(+i)},r})(.5);function jf(e,t){this._context=e,this._alpha=t}jf.prototype={areaStart:zr,areaEnd:zr,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,i=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Ml(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const H2=(function e(t){function r(i){return t?new jf(i,t):new Al(i,0)}return r.alpha=function(i){return e(+i)},r})(.5);function Gf(e,t){this._context=e,this._alpha=t}Gf.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,i=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+i*i,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Ml(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};const Y2=(function e(t){function r(i){return t?new Gf(i,t):new El(i,0)}return r.alpha=function(i){return e(+i)},r})(.5);function Xf(e){this._context=e}Xf.prototype={areaStart:zr,areaEnd:zr,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function U2(e){return new Xf(e)}function Dc(e){return e<0?-1:1}function Ic(e,t,r){var i=e._x1-e._x0,s=t-e._x1,o=(e._y1-e._y0)/(i||s<0&&-0),a=(r-e._y1)/(s||i<0&&-0),n=(o*s+a*i)/(i+s);return(Dc(o)+Dc(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(n))||0}function Pc(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function $a(e,t,r){var i=e._x0,s=e._y0,o=e._x1,a=e._y1,n=(o-i)/3;e._context.bezierCurveTo(i+n,s+n*t,o-n,a-n*r,o,a)}function Mo(e){this._context=e}Mo.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:$a(this,this._t0,Pc(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,$a(this,Pc(this,r=Ic(this,e,t)),r);break;default:$a(this,this._t0,r=Ic(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function Vf(e){this._context=new Zf(e)}(Vf.prototype=Object.create(Mo.prototype)).point=function(e,t){Mo.prototype.point.call(this,t,e)};function Zf(e){this._context=e}Zf.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,i,s,o){this._context.bezierCurveTo(t,e,i,r,o,s)}};function Kf(e){return new Mo(e)}function Qf(e){return new Vf(e)}function Jf(e){this._context=e}Jf.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var i=Rc(e),s=Rc(t),o=0,a=1;a=0;--t)s[t]=(a[t]-s[t+1])/o[t];for(o[r-1]=(e[r]+s[r-1])/2,t=0;t=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function ep(e){return new Qo(e,.5)}function rp(e){return new Qo(e,0)}function ip(e){return new Qo(e,1)}function hs(e,t,r){this.k=e,this.x=t,this.y=r}hs.prototype={constructor:hs,scale:function(e){return e===1?this:new hs(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new hs(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};hs.prototype;var j2=p(e=>{const{securityLevel:t}=It();let r=At("body");if(t==="sandbox"){const o=At(`#i${e}`).node()?.contentDocument??document;r=At(o.body)}return r.select(`#${e}`)},"selectSvgElement"),G2=p(e=>{const{handDrawnSeed:t}=It();return{fill:e,hachureAngle:120,hachureGap:4,fillWeight:2,roughness:.7,stroke:e,seed:t}},"solidStateFill"),X2=p(e=>Array.isArray(e)?e:e?e.split(";").map(t=>t.trim()).filter(Boolean):[],"normalizeStyleList"),qi=p(e=>{const t=V2([...e.cssCompiledStyles||[],...e.cssStyles||[],...X2(e.labelStyle)]);return{stylesMap:t,stylesArray:[...t]}},"compileStyles"),V2=p(e=>{const t=new Map;return e.forEach(r=>{const[i,s]=r.split(":");t.set(i.trim(),s?.trim())}),t},"styles2Map"),sp=p(e=>e==="color"||e==="font-size"||e==="font-family"||e==="font-weight"||e==="font-style"||e==="text-decoration"||e==="text-align"||e==="text-transform"||e==="line-height"||e==="letter-spacing"||e==="word-spacing"||e==="text-shadow"||e==="text-overflow"||e==="white-space"||e==="word-wrap"||e==="word-break"||e==="overflow-wrap"||e==="hyphens","isLabelStyle"),ft=p(e=>{const{stylesArray:t}=qi(e),r=[],i=[],s=[],o=[];return t.forEach(a=>{const n=a[0];sp(n)?r.push(a.join(":")+" !important"):(i.push(a.join(":")+" !important"),n.includes("stroke")&&s.push(a.join(":")+" !important"),n==="fill"&&o.push(a.join(":")+" !important"))}),{labelStyles:r.join(";"),nodeStyles:i.join(";"),stylesArray:t,borderStyles:s,backgroundStyles:o}},"styles2String"),lt=p((e,t)=>{const{themeVariables:r,handDrawnSeed:i}=It(),{nodeBorder:s,mainBkg:o}=r,{stylesMap:a}=qi(e);return Object.assign({roughness:.7,fill:a.get("fill")||o,fillStyle:"hachure",fillWeight:4,hachureGap:5.2,stroke:a.get("stroke")||s,seed:i,strokeWidth:a.get("stroke-width")?.replace("px","")||1.3,fillLineDash:[0,0],strokeLineDash:Z2(a.get("stroke-dasharray"))},t)},"userNodeOverrides"),Z2=p(e=>{if(!e)return[0,0];const t=e.trim().split(/\s+/).map(Number);if(t.length===1){const s=isNaN(t[0])?0:t[0];return[s,s]}const r=isNaN(t[0])?0:t[0],i=isNaN(t[1])?0:t[1];return[r,i]},"getStrokeDashArray");const K2=Object.freeze({left:0,top:0,width:16,height:16}),$o=Object.freeze({rotate:0,vFlip:!1,hFlip:!1}),op=Object.freeze({...K2,...$o}),Q2=Object.freeze({...op,body:"",hidden:!1}),J2=Object.freeze({width:null,height:null}),tw=Object.freeze({...J2,...$o}),ew=(e,t,r,i="")=>{const s=e.split(":");if(e.slice(0,1)==="@"){if(s.length<2||s.length>3)return null;i=s.shift().slice(1)}if(s.length>3||!s.length)return null;if(s.length>1){const n=s.pop(),l=s.pop(),c={provider:s.length>0?s[0]:i,prefix:l,name:n};return Oa(c)?c:null}const o=s[0],a=o.split("-");if(a.length>1){const n={provider:i,prefix:a.shift(),name:a.join("-")};return Oa(n)?n:null}if(r&&i===""){const n={provider:i,prefix:"",name:o};return Oa(n,r)?n:null}return null},Oa=(e,t)=>e?!!((t&&e.prefix===""||e.prefix)&&e.name):!1;function rw(e,t){const r={};!e.hFlip!=!t.hFlip&&(r.hFlip=!0),!e.vFlip!=!t.vFlip&&(r.vFlip=!0);const i=((e.rotate||0)+(t.rotate||0))%4;return i&&(r.rotate=i),r}function Nc(e,t){const r=rw(e,t);for(const i in Q2)i in $o?i in e&&!(i in r)&&(r[i]=$o[i]):i in t?r[i]=t[i]:i in e&&(r[i]=e[i]);return r}function iw(e,t){const r=e.icons,i=e.aliases||Object.create(null),s=Object.create(null);function o(a){if(r[a])return s[a]=[];if(!(a in s)){s[a]=null;const n=i[a]&&i[a].parent,l=n&&o(n);l&&(s[a]=[n].concat(l))}return s[a]}return(t||Object.keys(r).concat(Object.keys(i))).forEach(o),s}function qc(e,t,r){const i=e.icons,s=e.aliases||Object.create(null);let o={};function a(n){o=Nc(i[n]||s[n],o)}return a(t),r.forEach(a),Nc(e,o)}function sw(e,t){if(e.icons[t])return qc(e,t,[]);const r=iw(e,[t])[t];return r?qc(e,t,r):null}const ow=/(-?[0-9.]*[0-9]+[0-9.]*)/g,aw=/^-?[0-9.]*[0-9]+[0-9.]*$/g;function zc(e,t,r){if(t===1)return e;if(r=r||100,typeof e=="number")return Math.ceil(e*t*r)/r;if(typeof e!="string")return e;const i=e.split(ow);if(i===null||!i.length)return e;const s=[];let o=i.shift(),a=aw.test(o);for(;;){if(a){const n=parseFloat(o);isNaN(n)?s.push(o):s.push(Math.ceil(n*t*r)/r)}else s.push(o);if(o=i.shift(),o===void 0)return s.join("");a=!a}}function nw(e,t="defs"){let r="";const i=e.indexOf("<"+t);for(;i>=0;){const s=e.indexOf(">",i),o=e.indexOf("",o);if(a===-1)break;r+=e.slice(s+1,o).trim(),e=e.slice(0,i).trim()+e.slice(a+1)}return{defs:r,content:e}}function lw(e,t){return e?""+e+""+t:t}function hw(e,t,r){const i=nw(e);return lw(i.defs,t+i.content+r)}const cw=e=>e==="unset"||e==="undefined"||e==="none";function uw(e,t){const r={...op,...e},i={...tw,...t},s={left:r.left,top:r.top,width:r.width,height:r.height};let o=r.body;[r,i].forEach(y=>{const x=[],C=y.hFlip,k=y.vFlip;let T=y.rotate;C?k?T+=2:(x.push("translate("+(s.width+s.left).toString()+" "+(0-s.top).toString()+")"),x.push("scale(-1 1)"),s.top=s.left=0):k&&(x.push("translate("+(0-s.left).toString()+" "+(s.height+s.top).toString()+")"),x.push("scale(1 -1)"),s.top=s.left=0);let S;switch(T<0&&(T-=Math.floor(T/4)*4),T=T%4,T){case 1:S=s.height/2+s.top,x.unshift("rotate(90 "+S.toString()+" "+S.toString()+")");break;case 2:x.unshift("rotate(180 "+(s.width/2+s.left).toString()+" "+(s.height/2+s.top).toString()+")");break;case 3:S=s.width/2+s.left,x.unshift("rotate(-90 "+S.toString()+" "+S.toString()+")");break}T%2===1&&(s.left!==s.top&&(S=s.left,s.left=s.top,s.top=S),s.width!==s.height&&(S=s.width,s.width=s.height,s.height=S)),x.length&&(o=hw(o,'',""))});const a=i.width,n=i.height,l=s.width,c=s.height;let h,u;a===null?(u=n===null?"1em":n==="auto"?c:n,h=zc(u,l/c)):(h=a==="auto"?l:a,u=n===null?zc(h,c/l):n==="auto"?c:n);const d={},f=(y,x)=>{cw(x)||(d[y]=x.toString())};f("width",h),f("height",u);const m=[s.left,s.top,l,c];return d.viewBox=m.join(" "),{attributes:d,viewBox:m,body:o}}const dw=/\sid="(\S+)"/g,Wc=new Map;function fw(e){e=e.replace(/[0-9]+$/,"")||"a";const t=Wc.get(e)||0;return Wc.set(e,t+1),t?`${e}${t}`:e}function pw(e){const t=[];let r;for(;r=dw.exec(e);)t.push(r[1]);if(!t.length)return e;const i="suffix"+(Math.random()*16777216|Date.now()).toString(16);return t.forEach(s=>{const o=fw(s),a=s.replace(/[.*+?^${}()|[\]\\]/g,"\\$&");e=e.replace(new RegExp('([#;"])('+a+')([")]|\\.[a-z])',"g"),"$1"+o+i+"$3")}),e=e.replace(new RegExp(i,"g"),""),e}function gw(e,t){let r=e.indexOf("xlink:")===-1?"":' xmlns:xlink="http://www.w3.org/1999/xlink"';for(const i in t)r+=" "+i+'="'+t[i]+'"';return'"+e+""}var mw={body:'?',height:80,width:80},zn=new Map,ap=new Map,yw=p(e=>{for(const t of e){if(!t.name)throw new Error('Invalid icon loader. Must have a "name" property with non-empty string value.');if(R.debug("Registering icon pack:",t.name),"loader"in t)ap.set(t.name,t.loader);else if("icons"in t)zn.set(t.name,t.icons);else throw R.error("Invalid icon loader:",t),new Error('Invalid icon loader. Must have either "icons" or "loader" property.')}},"registerIconPacks"),np=p(async(e,t)=>{const r=ew(e,!0,t!==void 0);if(!r)throw new Error(`Invalid icon name: ${e}`);const i=r.prefix||t;if(!i)throw new Error(`Icon name must contain a prefix: ${e}`);let s=zn.get(i);if(!s){const a=ap.get(i);if(!a)throw new Error(`Icon set not found: ${r.prefix}`);try{s={...await a(),prefix:i},zn.set(i,s)}catch(n){throw R.error(n),new Error(`Failed to load icon set: ${r.prefix}`)}}const o=sw(s,r.name);if(!o)throw new Error(`Icon not found: ${e}`);return o},"getRegisteredIconData"),xw=p(async e=>{try{return await np(e),!0}catch{return!1}},"isIconAvailable"),Ns=p(async(e,t,r)=>{let i;try{i=await np(e,t?.fallbackPrefix)}catch(a){R.error(a),i=mw}const s=uw(i,t),o=gw(pw(s.body),{...s.attributes,...r});return ze(o,Zt())},"getIconSVG"),lp={},ae={};Object.defineProperty(ae,"__esModule",{value:!0});ae.BLANK_URL=ae.relativeFirstCharacters=ae.whitespaceEscapeCharsRegex=ae.urlSchemeRegex=ae.ctrlCharactersRegex=ae.htmlCtrlEntityRegex=ae.htmlEntitiesRegex=ae.invalidProtocolRegex=void 0;ae.invalidProtocolRegex=/^([^\w]*)(javascript|data|vbscript)/im;ae.htmlEntitiesRegex=/&#(\w+)(^\w|;)?/g;ae.htmlCtrlEntityRegex=/&(newline|tab);/gi;ae.ctrlCharactersRegex=/[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;ae.urlSchemeRegex=/^.+(:|:)/gim;ae.whitespaceEscapeCharsRegex=/(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;ae.relativeFirstCharacters=[".","/"];ae.BLANK_URL="about:blank";Object.defineProperty(lp,"__esModule",{value:!0});var Cw=lp.sanitizeUrl=Tw,ye=ae;function bw(e){return ye.relativeFirstCharacters.indexOf(e[0])>-1}function kw(e){var t=e.replace(ye.ctrlCharactersRegex,"");return t.replace(ye.htmlEntitiesRegex,function(r,i){return String.fromCharCode(i)})}function ww(e){return URL.canParse(e)}function Hc(e){try{return decodeURIComponent(e)}catch{return e}}function Tw(e){if(!e)return ye.BLANK_URL;var t,r=Hc(e.trim());do r=kw(r).replace(ye.htmlCtrlEntityRegex,"").replace(ye.ctrlCharactersRegex,"").replace(ye.whitespaceEscapeCharsRegex,"").trim(),r=Hc(r),t=r.match(ye.ctrlCharactersRegex)||r.match(ye.htmlEntitiesRegex)||r.match(ye.htmlCtrlEntityRegex)||r.match(ye.whitespaceEscapeCharsRegex);while(t&&t.length>0);var i=r;if(!i)return ye.BLANK_URL;if(bw(i))return i;var s=i.trimStart(),o=s.match(ye.urlSchemeRegex);if(!o)return i;var a=o[0].toLowerCase().trim();if(ye.invalidProtocolRegex.test(a))return ye.BLANK_URL;var n=s.replace(/\\/g,"/");if(a==="mailto:"||a.includes("://"))return n;if(a==="http:"||a==="https:"){if(!ww(n))return ye.BLANK_URL;var l=new URL(n);return l.protocol=l.protocol.toLowerCase(),l.hostname=l.hostname.toLowerCase(),l.toString()}return n}function Da(e){if(typeof e!="object"||e==null)return!1;if(Object.getPrototypeOf(e)===null)return!0;if(Object.prototype.toString.call(e)!=="[object Object]"){const r=e[Symbol.toStringTag];return r==null||!Object.getOwnPropertyDescriptor(e,Symbol.toStringTag)?.writable?!1:e.toString()===`[object ${r}]`}let t=e;for(;Object.getPrototypeOf(t)!==null;)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t}function _w(){}function hp(e){return Object.getOwnPropertySymbols(e).filter(t=>Object.prototype.propertyIsEnumerable.call(e,t))}function $l(e){return e==null?e===void 0?"[object Undefined]":"[object Null]":Object.prototype.toString.call(e)}const Sw="[object RegExp]",cp="[object String]",up="[object Number]",dp="[object Boolean]",fp="[object Arguments]",vw="[object Symbol]",Bw="[object Date]",Lw="[object Map]",Fw="[object Set]",Aw="[object Array]",Ew="[object ArrayBuffer]",Mw="[object Object]",$w="[object DataView]",Ow="[object Uint8Array]",Dw="[object Uint8ClampedArray]",Iw="[object Uint16Array]",Pw="[object Uint32Array]",Rw="[object Int8Array]",Nw="[object Int16Array]",qw="[object Int32Array]",zw="[object Float32Array]",Ww="[object Float64Array]",Yc=typeof globalThis=="object"&&globalThis||typeof window=="object"&&window||typeof self=="object"&&self||typeof global=="object"&&global||(function(){return this})();function Ol(e){return typeof Yc.Buffer<"u"&&Yc.Buffer.isBuffer(e)}function Hw(e){return Number.isSafeInteger(e)&&e>=0}function pp(e){return e!=null&&typeof e!="function"&&Hw(e.length)}function Yw(e){return e==="__proto__"}function Dl(e){return e==null||typeof e!="object"&&typeof e!="function"}function Il(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Uw(e,t){return Bi(e,void 0,e,new Map,t)}function Bi(e,t,r,i=new Map,s=void 0){const o=s?.(e,t,r,i);if(o!==void 0)return o;if(Dl(e))return e;if(i.has(e))return i.get(e);if(Array.isArray(e)){const a=new Array(e.length);i.set(e,a);for(let n=0;n{if(typeof e=="object"){if($l(e)==="[object Object]"&&typeof e.constructor!="function"){const a={};return o.set(e,a),Ue(a,e,s,o),a}switch(Object.prototype.toString.call(e)){case up:case cp:case dp:{const a=new e.constructor(e?.valueOf());return Ue(a,e),a}case fp:{const a={};return Ue(a,e),a.length=e.length,a[Symbol.iterator]=e[Symbol.iterator],a}default:return}}})}function Uc(e){return Gw(e)}function Wn(e){return e!==null&&typeof e=="object"&&$l(e)==="[object Arguments]"}function Hn(e){return typeof e=="object"&&e!==null}function Xw(e){return Hn(e)&&pp(e)}function fo(e){return Il(e)}function Vw(e){const t=e?.constructor;return e===(typeof t=="function"?t.prototype:Object.prototype)}function qs(e,t){if(typeof e!="function"||t!=null&&typeof t!="function")throw new TypeError("Expected a function");const r=function(...i){const s=t?t.apply(this,i):i[0],o=r.cache;if(o.has(s))return o.get(s);const a=e.apply(this,i);return r.cache=o.set(s,a)||o,a};return r.cache=new(qs.Cache||Map),r}qs.Cache=Map;function Zw(e){if(Dl(e))return e;if(Array.isArray(e)||Il(e)||e instanceof ArrayBuffer||typeof SharedArrayBuffer<"u"&&e instanceof SharedArrayBuffer)return e.slice(0);const t=Object.getPrototypeOf(e);if(t==null)return Object.assign(Object.create(t),e);const r=t.constructor;if(e instanceof Date||e instanceof Map||e instanceof Set)return new r(e);if(e instanceof RegExp){const i=new r(e);return i.lastIndex=e.lastIndex,i}if(e instanceof DataView)return new r(e.buffer.slice(0));if(e instanceof Error){let i;return e instanceof AggregateError?i=new r(e.errors,e.message,{cause:e.cause}):i=new r(e.message,{cause:e.cause}),i.stack=e.stack,Object.assign(i,e),i}return typeof File<"u"&&e instanceof File?new r([e],e.name,{type:e.type,lastModified:e.lastModified}):typeof e=="object"?Object.assign(Object.create(t),e):e}function Kw(e,...t){const r=t.slice(0,-1),i=t[t.length-1];let s=e;for(let o=0;or!=="constructor").length===0:t.length===0}return!0}var Jw="​",tT={curveBasis:qn,curveBasisClosed:R2,curveBasisOpen:N2,curveBumpX:Rf,curveBumpY:Nf,curveBundle:q2,curveCardinalClosed:z2,curveCardinalOpen:W2,curveCardinal:Hf,curveCatmullRomClosed:H2,curveCatmullRomOpen:Y2,curveCatmullRom:Uf,curveLinear:Cs,curveLinearClosed:U2,curveMonotoneX:Kf,curveMonotoneY:Qf,curveNatural:tp,curveStep:ep,curveStepAfter:ip,curveStepBefore:rp},eT=/\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi,rT=p(function(e,t){const r=gp(e,/(?:init\b)|(?:initialize\b)/);let i={};if(Array.isArray(r)){const a=r.map(n=>n.args);Co(a),i=ne(i,[...a])}else i=r.args;if(!i)return;let s=gl(e,t);const o="config";return i[o]!==void 0&&(s==="flowchart-v2"&&(s="flowchart"),i[s]=i[o],delete i[o]),i},"detectInit"),gp=p(function(e,t=null){try{const r=new RegExp(`[%]{2}(?![{]${eT.source})(?=[}][%]{2}).* +`,"ig");e=e.trim().replace(r,"").replace(/'/gm,'"'),R.debug(`Detecting diagram directive${t!==null?" type:"+t:""} based on the text:${e}`);let i;const s=[];for(;(i=xs.exec(e))!==null;)if(i.index===xs.lastIndex&&xs.lastIndex++,i&&!t||t&&i[1]?.match(t)||t&&i[2]?.match(t)){const o=i[1]?i[1]:i[2],a=i[3]?i[3].trim():i[4]?JSON.parse(i[4].trim()):null;s.push({type:o,args:a})}return s.length===0?{type:e,args:null}:s.length===1?s[0]:s}catch(r){return R.error(`ERROR: ${r.message} - Unable to parse directive type: '${t}' based on the text: '${e}'`),{type:void 0,args:null}}},"detectDirective"),iT=p(function(e){return e.replace(xs,"")},"removeDirectives"),sT=p(function(e,t){for(const[r,i]of t.entries())if(i.match(e))return r;return-1},"isSubstringInArray");function Pl(e,t){if(!e)return t;const r=`curve${e.charAt(0).toUpperCase()+e.slice(1)}`;return tT[r]??t}p(Pl,"interpolateToCurve");function mp(e,t){const r=e.trim();if(r)return t.securityLevel!=="loose"?Cw(r):r}p(mp,"formatUrl");var oT=p((e,...t)=>{const r=e.split("."),i=r.length-1,s=r[i];let o=window;for(let a=0;a{r+=Rl(s,t),t=s});const i=r/2;return Nl(e,i)}p(yp,"traverseEdge");function xp(e){return e.length===1?e[0]:yp(e)}p(xp,"calcLabelPosition");var Gc=p((e,t=2)=>{const r=Math.pow(10,t);return Math.round(e*r)/r},"roundNumber"),Nl=p((e,t)=>{let r,i=t;for(const s of e){if(r){const o=Rl(s,r);if(o===0)return r;if(o=1)return{x:s.x,y:s.y};if(a>0&&a<1)return{x:Gc((1-a)*r.x+a*s.x,5),y:Gc((1-a)*r.y+a*s.y,5)}}}r=s}throw new Error("Could not find a suitable point for the given distance")},"calculatePoint"),aT=p((e,t,r)=>{R.info(`our points ${JSON.stringify(t)}`),t[0]!==r&&(t=t.reverse());const s=Nl(t,25),o=e?10:5,a=Math.atan2(t[0].y-s.y,t[0].x-s.x),n={x:0,y:0};return n.x=Math.sin(a)*o+(t[0].x+s.x)/2,n.y=-Math.cos(a)*o+(t[0].y+s.y)/2,n},"calcCardinalityPosition");function Cp(e,t,r){const i=structuredClone(r);R.info("our points",i),t!=="start_left"&&t!=="start_right"&&i.reverse();const s=25+e,o=Nl(i,s),a=10+e*.5,n=Math.atan2(i[0].y-o.y,i[0].x-o.x),l={x:0,y:0};return t==="start_left"?(l.x=Math.sin(n+Math.PI)*a+(i[0].x+o.x)/2,l.y=-Math.cos(n+Math.PI)*a+(i[0].y+o.y)/2):t==="end_right"?(l.x=Math.sin(n-Math.PI)*a+(i[0].x+o.x)/2-5,l.y=-Math.cos(n-Math.PI)*a+(i[0].y+o.y)/2-5):t==="end_left"?(l.x=Math.sin(n)*a+(i[0].x+o.x)/2-5,l.y=-Math.cos(n)*a+(i[0].y+o.y)/2-5):(l.x=Math.sin(n)*a+(i[0].x+o.x)/2,l.y=-Math.cos(n)*a+(i[0].y+o.y)/2),l}p(Cp,"calcTerminalLabelPosition");function bp(e){let t="",r="";for(const i of e)i!==void 0&&(i.startsWith("color:")||i.startsWith("text-align:")?r=r+i+";":t=t+i+";");return{style:t,labelStyle:r}}p(bp,"getStylesFromArray");var Xc=0,nT=p(()=>(Xc++,"id-"+Math.random().toString(36).substr(2,12)+"-"+Xc),"generateId");function kp(e){let t="";const r="0123456789abcdef",i=r.length;for(let s=0;skp(e.length),"random"),hT=p(function(){return{x:0,y:0,fill:void 0,anchor:"start",style:"#666",width:100,height:100,textMargin:0,rx:0,ry:0,valign:void 0,text:""}},"getTextObj"),cT=p(function(e,t){const r=t.text.replace(Is.lineBreakRegex," "),[,i]=Jo(t.fontSize),s=e.append("text");s.attr("x",t.x),s.attr("y",t.y),s.style("text-anchor",t.anchor),s.style("font-family",t.fontFamily),s.style("font-size",i),s.style("font-weight",t.fontWeight),s.attr("fill",t.fill),t.class!==void 0&&s.attr("class",t.class);const o=s.append("tspan");return o.attr("x",t.x+t.textMargin*2),o.attr("fill",t.fill),o.text(r),s},"drawSimpleText"),uT=qs((e,t,r)=>{if(!e||(r=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",joinWith:"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "},r),Is.lineBreakRegex.test(e)))return e;const i=e.split(" ").filter(Boolean),s=[];let o="";return i.forEach((a,n)=>{const l=vr(`${a} `,r),c=vr(o,r);if(l>t){const{hyphenatedStrings:d,remainingWord:f}=dT(a,t,"-",r);s.push(o,...d),o=f}else c+l>=t?(s.push(o),o=a):o=[o,a].filter(Boolean).join(" ");n+1===i.length&&s.push(o)}),s.filter(a=>a!=="").join(r.joinWith)},(e,t,r)=>`${e}${t}${r.fontSize}${r.fontWeight}${r.fontFamily}${r.joinWith}`),dT=qs((e,t,r="-",i)=>{i=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",margin:0},i);const s=[...e],o=[];let a="";return s.forEach((n,l)=>{const c=`${a}${n}`;if(vr(c,i)>=t){const u=l+1,d=s.length===u,f=`${c}${r}`;o.push(d?c:f),a=""}else a=c}),{hyphenatedStrings:o,remainingWord:a}},(e,t,r="-",i)=>`${e}${t}${r}${i.fontSize}${i.fontWeight}${i.fontFamily}`);function wp(e,t){return ql(e,t).height}p(wp,"calculateTextHeight");function vr(e,t){return ql(e,t).width}p(vr,"calculateTextWidth");var ql=qs((e,t)=>{const{fontSize:r=12,fontFamily:i="Arial",fontWeight:s=400}=t;if(!e)return{width:0,height:0};const[,o]=Jo(r),a=["sans-serif",i],n=e.split(Is.lineBreakRegex),l=[],c=At("body");if(!c.remove)return{width:0,height:0,lineHeight:0};const h=c.append("svg");for(const d of a){let f=0;const m={width:0,height:0,lineHeight:0};for(const y of n){const x=hT();x.text=y||Jw;const C=cT(h,x).style("font-size",o).style("font-weight",s).style("font-family",d),k=(C._groups||C)[0][0].getBBox();if(k.width===0&&k.height===0)throw new Error("svg element not in render tree");m.width=Math.round(Math.max(m.width,k.width)),f=Math.round(k.height),m.height+=f,m.lineHeight=Math.round(Math.max(m.lineHeight,f))}l.push(m)}h.remove();const u=isNaN(l[1].height)||isNaN(l[1].width)||isNaN(l[1].lineHeight)||l[0].height>l[1].height&&l[0].width>l[1].width&&l[0].lineHeight>l[1].lineHeight?0:1;return l[u]},(e,t)=>`${e}${t.fontSize}${t.fontWeight}${t.fontFamily}`),fT=class{constructor(e=!1,t){this.count=0,this.count=t?t.length:0,this.next=e?()=>this.count++:()=>Date.now()}static{p(this,"InitIDGenerator")}},Ks,pT=p(function(e){return Ks=Ks||document.createElement("div"),e=escape(e).replace(/%26/g,"&").replace(/%23/g,"#").replace(/%3B/g,";"),Ks.innerHTML=e,unescape(Ks.textContent)},"entityDecode");function zl(e){return"str"in e}p(zl,"isDetailedError");var gT=p((e,t,r,i)=>{if(!i)return;const s=e.node()?.getBBox();s&&e.append("text").text(i).attr("text-anchor","middle").attr("x",s.x+s.width/2).attr("y",-r).attr("class",t)},"insertTitle"),Jo=p(e=>{if(typeof e=="number")return[e,e+"px"];const t=parseInt(e??"",10);return Number.isNaN(t)?[void 0,void 0]:e===String(t)?[t,e+"px"]:[t,e]},"parseFontSize");function Wl(e,t){return Qw({},e,t)}p(Wl,"cleanAndMerge");var Ce={assignWithDepth:ne,wrapLabel:uT,calculateTextHeight:wp,calculateTextWidth:vr,calculateTextDimensions:ql,cleanAndMerge:Wl,detectInit:rT,detectDirective:gp,isSubstringInArray:sT,interpolateToCurve:Pl,calcLabelPosition:xp,calcCardinalityPosition:aT,calcTerminalLabelPosition:Cp,formatUrl:mp,getStylesFromArray:bp,generateId:nT,random:lT,runFunc:oT,entityDecode:pT,insertTitle:gT,isLabelCoordinateInPath:Tp,parseFontSize:Jo,InitIDGenerator:fT},mT=p(function(e){let t=e;return t=t.replace(/style.*:\S*#.*;/g,function(r){return r.substring(0,r.length-1)}),t=t.replace(/classDef.*:\S*#.*;/g,function(r){return r.substring(0,r.length-1)}),t=t.replace(/#\w+;/g,function(r){const i=r.substring(1,r.length-1);return/^\+?\d+$/.test(i)?"fl°°"+i+"¶ß":"fl°"+i+"¶ß"}),t},"encodeEntities"),Wr=p(function(e){return e.replace(/fl°°/g,"&#").replace(/fl°/g,"&").replace(/¶ß/g,";")},"decodeEntities"),r3=p((e,t,{counter:r=0,prefix:i,suffix:s},o)=>o||`${i?`${i}_`:""}${e}_${t}_${r}${s?`_${s}`:""}`,"getEdgeId");function re(e){return e??null}p(re,"handleUndefinedAttr");function Tp(e,t){const r=Math.round(e.x),i=Math.round(e.y),s=t.replace(/(\d+\.\d+)/g,o=>Math.round(parseFloat(o)).toString());return s.includes(r.toString())||s.includes(i.toString())}p(Tp,"isLabelCoordinateInPath");var _p={exports:{}};(function(e){(function(t){var r=function(){},i=t.requestAnimationFrame||t.webkitRequestAnimationFrame||t.mozRequestAnimationFrame||t.msRequestAnimationFrame||function(h){return setTimeout(h,16)};function s(){var h=this;h.reads=[],h.writes=[],h.raf=i.bind(t)}s.prototype={constructor:s,runTasks:function(h){for(var u;u=h.shift();)u()},measure:function(h,u){var d=u?h.bind(u):h;return this.reads.push(d),o(this),d},mutate:function(h,u){var d=u?h.bind(u):h;return this.writes.push(d),o(this),d},clear:function(h){return n(this.reads,h)||n(this.writes,h)},extend:function(h){if(typeof h!="object")throw new Error("expected object");var u=Object.create(this);return l(u,h),u.fastdom=this,u.initialize&&u.initialize(),u},catch:null};function o(h){h.scheduled||(h.scheduled=!0,h.raf(a.bind(null,h)))}function a(h){var u=h.writes,d=h.reads,f;try{r("flushing reads",d.length),h.runTasks(d),r("flushing writes",u.length),h.runTasks(u)}catch(m){f=m}if(h.scheduled=!1,(d.length||u.length)&&o(h),f)if(r("task errored",f.message),h.catch)h.catch(f);else throw f}function n(h,u){var d=h.indexOf(u);return!!~d&&!!h.splice(d,1)}function l(h,u){for(var d in u)u.hasOwnProperty(d)&&(h[d]=u[d])}var c=t.fastdom=t.fastdom||new s;e.exports=c})(typeof window<"u"?window:typeof wn<"u"?wn:globalThis)})(_p);var yT=_p.exports;const xT=fl(yT);var Sp={exports:{}};(function(e){(function(){var t={initialize:function(){this._tasks=new Map},mutate:function(i,s){return r(this,"mutate",i,s)},measure:function(i,s){return r(this,"measure",i,s)},clear:function(i){var s=this._tasks,o=s.get(i);this.fastdom.clear(o),s.delete(i)}};function r(i,s,o,a){var n=i._tasks,l=i.fastdom,c,h=new Promise(function(u,d){c=l[s](function(){n.delete(h);try{u(a?o.call(a):o())}catch(f){d(f)}},a)});return n.set(h,c),h}e.exports=t})()})(Sp);var CT=Sp.exports;const bT=fl(CT);function Hl(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var ui=Hl();function vp(e){ui=e}var bs={exec:()=>null};function Ht(e,t=""){let r=typeof e=="string"?e:e.source,i={replace:(s,o)=>{let a=typeof o=="string"?o:o.source;return a=a.replace(Se.caret,"$1"),r=r.replace(s,a),i},getRegex:()=>new RegExp(r,t)};return i}var kT=(()=>{try{return!!new RegExp("(?<=1)(?/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceTabs:/^\t+/,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] /,listReplaceTask:/^\[[ xX]\] +/,anyLine:/\n.*\n/,hrefBrackets:/^<(.*)>$/,tableDelimiter:/[:|]/,tableAlignChars:/^\||\| *$/g,tableRowBlankLine:/\n[ \t]*$/,tableAlignRight:/^ *-+: *$/,tableAlignCenter:/^ *:-+: *$/,tableAlignLeft:/^ *:-+ *$/,startATag:/^/i,startPreScriptTag:/^<(pre|code|kbd|script)(\s|>)/i,endPreScriptTag:/^<\/(pre|code|kbd|script)(\s|>)/i,startAngleBracket:/^$/,pedanticHrefTitle:/^([^'"]*[^\s])\s+(['"])(.*)\2/,unicodeAlphaNumeric:/[\p{L}\p{N}]/u,escapeTest:/[&<>"']/,escapeReplace:/[&<>"']/g,escapeTestNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,escapeReplaceNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,unescapeTest:/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:e=>new RegExp(`^( {0,3}${e})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`),hrRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),fencesBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:\`\`\`|~~~)`),headingBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}#`),htmlBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}<(?:[a-z].*>|!--)`,"i")},wT=/^(?:[ \t]*(?:\n|$))+/,TT=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,_T=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,zs=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,ST=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,Yl=/(?:[*+-]|\d{1,9}[.)])/,Bp=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,Lp=Ht(Bp).replace(/bull/g,Yl).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/\|table/g,"").getRegex(),vT=Ht(Bp).replace(/bull/g,Yl).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/table/g,/ {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(),Ul=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,BT=/^[^\n]+/,jl=/(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/,LT=Ht(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",jl).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),FT=Ht(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g,Yl).getRegex(),ta="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",Gl=/|$))/,AT=Ht("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$))","i").replace("comment",Gl).replace("tag",ta).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),Fp=Ht(Ul).replace("hr",zs).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("|table","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",ta).getRegex(),ET=Ht(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",Fp).getRegex(),Xl={blockquote:ET,code:TT,def:LT,fences:_T,heading:ST,hr:zs,html:AT,lheading:Lp,list:FT,newline:wT,paragraph:Fp,table:bs,text:BT},Vc=Ht("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",zs).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("blockquote"," {0,3}>").replace("code","(?: {4}| {0,3} )[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",ta).getRegex(),MT={...Xl,lheading:vT,table:Vc,paragraph:Ht(Ul).replace("hr",zs).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",Vc).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",ta).getRegex()},$T={...Xl,html:Ht(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment",Gl).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:bs,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:Ht(Ul).replace("hr",zs).replace("heading",` *#{1,6} *[^ +]`).replace("lheading",Lp).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},OT=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,DT=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,Ap=/^( {2,}|\\)\n(?!\s*$)/,IT=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-",kT?"(?`+)[^`]+\k(?!`)/).replace("html",/<(?! )[^<>]*?>/).getRegex(),$p=/^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/,zT=Ht($p,"u").replace(/punct/g,ea).getRegex(),WT=Ht($p,"u").replace(/punct/g,Mp).getRegex(),Op="^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)",HT=Ht(Op,"gu").replace(/notPunctSpace/g,Ep).replace(/punctSpace/g,Vl).replace(/punct/g,ea).getRegex(),YT=Ht(Op,"gu").replace(/notPunctSpace/g,NT).replace(/punctSpace/g,RT).replace(/punct/g,Mp).getRegex(),UT=Ht("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,Ep).replace(/punctSpace/g,Vl).replace(/punct/g,ea).getRegex(),jT=Ht(/\\(punct)/,"gu").replace(/punct/g,ea).getRegex(),GT=Ht(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme",/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email",/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(),XT=Ht(Gl).replace("(?:-->|$)","-->").getRegex(),VT=Ht("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment",XT).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),Oo=/(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+[^`]*?`+(?!`)|[^\[\]\\`])*?/,ZT=Ht(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label",Oo).replace("href",/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),Dp=Ht(/^!?\[(label)\]\[(ref)\]/).replace("label",Oo).replace("ref",jl).getRegex(),Ip=Ht(/^!?\[(ref)\](?:\[\])?/).replace("ref",jl).getRegex(),KT=Ht("reflink|nolink(?!\\()","g").replace("reflink",Dp).replace("nolink",Ip).getRegex(),Zc=/[hH][tT][tT][pP][sS]?|[fF][tT][pP]/,Zl={_backpedal:bs,anyPunctuation:jT,autolink:GT,blockSkip:qT,br:Ap,code:DT,del:bs,emStrongLDelim:zT,emStrongRDelimAst:HT,emStrongRDelimUnd:UT,escape:OT,link:ZT,nolink:Ip,punctuation:PT,reflink:Dp,reflinkSearch:KT,tag:VT,text:IT,url:bs},QT={...Zl,link:Ht(/^!?\[(label)\]\((.*?)\)/).replace("label",Oo).getRegex(),reflink:Ht(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",Oo).getRegex()},Yn={...Zl,emStrongRDelimAst:YT,emStrongLDelim:WT,url:Ht(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol",Zc).replace("email",/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),_backpedal:/(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/,text:Ht(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":">",'"':""","'":"'"},Kc=e=>t_[e];function er(e,t){if(t){if(Se.escapeTest.test(e))return e.replace(Se.escapeReplace,Kc)}else if(Se.escapeTestNoEncode.test(e))return e.replace(Se.escapeReplaceNoEncode,Kc);return e}function Qc(e){try{e=encodeURI(e).replace(Se.percentDecode,"%")}catch{return null}return e}function Jc(e,t){let r=e.replace(Se.findPipe,(o,a,n)=>{let l=!1,c=a;for(;--c>=0&&n[c]==="\\";)l=!l;return l?"|":" |"}),i=r.split(Se.splitPipe),s=0;if(i[0].trim()||i.shift(),i.length>0&&!i.at(-1)?.trim()&&i.pop(),t)if(i.length>t)i.splice(t);else for(;i.length0?-2:-1}function tu(e,t,r,i,s){let o=t.href,a=t.title||null,n=e[1].replace(s.other.outputLinkReplace,"$1");i.state.inLink=!0;let l={type:e[0].charAt(0)==="!"?"image":"link",raw:r,href:o,title:a,text:n,tokens:i.inlineTokens(n)};return i.state.inLink=!1,l}function r_(e,t,r){let i=e.match(r.other.indentCodeCompensation);if(i===null)return t;let s=i[1];return t.split(` +`).map(o=>{let a=o.match(r.other.beginningSpace);if(a===null)return o;let[n]=a;return n.length>=s.length?o.slice(s.length):o}).join(` +`)}var Do=class{options;rules;lexer;constructor(t){this.options=t||ui}space(t){let r=this.rules.block.newline.exec(t);if(r&&r[0].length>0)return{type:"space",raw:r[0]}}code(t){let r=this.rules.block.code.exec(t);if(r){let i=r[0].replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:r[0],codeBlockStyle:"indented",text:this.options.pedantic?i:Ji(i,` +`)}}}fences(t){let r=this.rules.block.fences.exec(t);if(r){let i=r[0],s=r_(i,r[3]||"",this.rules);return{type:"code",raw:i,lang:r[2]?r[2].trim().replace(this.rules.inline.anyPunctuation,"$1"):r[2],text:s}}}heading(t){let r=this.rules.block.heading.exec(t);if(r){let i=r[2].trim();if(this.rules.other.endingHash.test(i)){let s=Ji(i,"#");(this.options.pedantic||!s||this.rules.other.endingSpaceChar.test(s))&&(i=s.trim())}return{type:"heading",raw:r[0],depth:r[1].length,text:i,tokens:this.lexer.inline(i)}}}hr(t){let r=this.rules.block.hr.exec(t);if(r)return{type:"hr",raw:Ji(r[0],` +`)}}blockquote(t){let r=this.rules.block.blockquote.exec(t);if(r){let i=Ji(r[0],` +`).split(` +`),s="",o="",a=[];for(;i.length>0;){let n=!1,l=[],c;for(c=0;c1,o={type:"list",raw:"",ordered:s,start:s?+i.slice(0,-1):"",loose:!1,items:[]};i=s?`\\d{1,9}\\${i.slice(-1)}`:`\\${i}`,this.options.pedantic&&(i=s?i:"[*+-]");let a=this.rules.other.listItemRegex(i),n=!1;for(;t;){let c=!1,h="",u="";if(!(r=a.exec(t))||this.rules.block.hr.test(t))break;h=r[0],t=t.substring(h.length);let d=r[2].split(` +`,1)[0].replace(this.rules.other.listReplaceTabs,k=>" ".repeat(3*k.length)),f=t.split(` +`,1)[0],m=!d.trim(),y=0;if(this.options.pedantic?(y=2,u=d.trimStart()):m?y=r[1].length+1:(y=r[2].search(this.rules.other.nonSpaceChar),y=y>4?1:y,u=d.slice(y),y+=r[1].length),m&&this.rules.other.blankLine.test(f)&&(h+=f+` +`,t=t.substring(f.length+1),c=!0),!c){let k=this.rules.other.nextBulletRegex(y),T=this.rules.other.hrRegex(y),S=this.rules.other.fencesBeginRegex(y),v=this.rules.other.headingBeginRegex(y),A=this.rules.other.htmlBeginRegex(y);for(;t;){let L=t.split(` +`,1)[0],F;if(f=L,this.options.pedantic?(f=f.replace(this.rules.other.listReplaceNesting," "),F=f):F=f.replace(this.rules.other.tabCharGlobal," "),S.test(f)||v.test(f)||A.test(f)||k.test(f)||T.test(f))break;if(F.search(this.rules.other.nonSpaceChar)>=y||!f.trim())u+=` +`+F.slice(y);else{if(m||d.replace(this.rules.other.tabCharGlobal," ").search(this.rules.other.nonSpaceChar)>=4||S.test(d)||v.test(d)||T.test(d))break;u+=` +`+f}!m&&!f.trim()&&(m=!0),h+=L+` +`,t=t.substring(L.length+1),d=F.slice(y)}}o.loose||(n?o.loose=!0:this.rules.other.doubleBlankLine.test(h)&&(n=!0));let x=null,C;this.options.gfm&&(x=this.rules.other.listIsTask.exec(u),x&&(C=x[0]!=="[ ] ",u=u.replace(this.rules.other.listReplaceTask,""))),o.items.push({type:"list_item",raw:h,task:!!x,checked:C,loose:!1,text:u,tokens:[]}),o.raw+=h}let l=o.items.at(-1);if(l)l.raw=l.raw.trimEnd(),l.text=l.text.trimEnd();else return;o.raw=o.raw.trimEnd();for(let c=0;cd.type==="space"),u=h.length>0&&h.some(d=>this.rules.other.anyLine.test(d.raw));o.loose=u}if(o.loose)for(let c=0;c({text:l,tokens:this.lexer.inline(l),header:!1,align:a.align[c]})));return a}}lheading(t){let r=this.rules.block.lheading.exec(t);if(r)return{type:"heading",raw:r[0],depth:r[2].charAt(0)==="="?1:2,text:r[1],tokens:this.lexer.inline(r[1])}}paragraph(t){let r=this.rules.block.paragraph.exec(t);if(r){let i=r[1].charAt(r[1].length-1)===` +`?r[1].slice(0,-1):r[1];return{type:"paragraph",raw:r[0],text:i,tokens:this.lexer.inline(i)}}}text(t){let r=this.rules.block.text.exec(t);if(r)return{type:"text",raw:r[0],text:r[0],tokens:this.lexer.inline(r[0])}}escape(t){let r=this.rules.inline.escape.exec(t);if(r)return{type:"escape",raw:r[0],text:r[1]}}tag(t){let r=this.rules.inline.tag.exec(t);if(r)return!this.lexer.state.inLink&&this.rules.other.startATag.test(r[0])?this.lexer.state.inLink=!0:this.lexer.state.inLink&&this.rules.other.endATag.test(r[0])&&(this.lexer.state.inLink=!1),!this.lexer.state.inRawBlock&&this.rules.other.startPreScriptTag.test(r[0])?this.lexer.state.inRawBlock=!0:this.lexer.state.inRawBlock&&this.rules.other.endPreScriptTag.test(r[0])&&(this.lexer.state.inRawBlock=!1),{type:"html",raw:r[0],inLink:this.lexer.state.inLink,inRawBlock:this.lexer.state.inRawBlock,block:!1,text:r[0]}}link(t){let r=this.rules.inline.link.exec(t);if(r){let i=r[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(i)){if(!this.rules.other.endAngleBracket.test(i))return;let a=Ji(i.slice(0,-1),"\\");if((i.length-a.length)%2===0)return}else{let a=e_(r[2],"()");if(a===-2)return;if(a>-1){let n=(r[0].indexOf("!")===0?5:4)+r[1].length+a;r[2]=r[2].substring(0,a),r[0]=r[0].substring(0,n).trim(),r[3]=""}}let s=r[2],o="";if(this.options.pedantic){let a=this.rules.other.pedanticHrefTitle.exec(s);a&&(s=a[1],o=a[3])}else o=r[3]?r[3].slice(1,-1):"";return s=s.trim(),this.rules.other.startAngleBracket.test(s)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(i)?s=s.slice(1):s=s.slice(1,-1)),tu(r,{href:s&&s.replace(this.rules.inline.anyPunctuation,"$1"),title:o&&o.replace(this.rules.inline.anyPunctuation,"$1")},r[0],this.lexer,this.rules)}}reflink(t,r){let i;if((i=this.rules.inline.reflink.exec(t))||(i=this.rules.inline.nolink.exec(t))){let s=(i[2]||i[1]).replace(this.rules.other.multipleSpaceGlobal," "),o=r[s.toLowerCase()];if(!o){let a=i[0].charAt(0);return{type:"text",raw:a,text:a}}return tu(i,o,i[0],this.lexer,this.rules)}}emStrong(t,r,i=""){let s=this.rules.inline.emStrongLDelim.exec(t);if(!(!s||s[3]&&i.match(this.rules.other.unicodeAlphaNumeric))&&(!(s[1]||s[2])||!i||this.rules.inline.punctuation.exec(i))){let o=[...s[0]].length-1,a,n,l=o,c=0,h=s[0][0]==="*"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(h.lastIndex=0,r=r.slice(-1*t.length+o);(s=h.exec(r))!=null;){if(a=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!a)continue;if(n=[...a].length,s[3]||s[4]){l+=n;continue}else if((s[5]||s[6])&&o%3&&!((o+n)%3)){c+=n;continue}if(l-=n,l>0)continue;n=Math.min(n,n+l+c);let u=[...s[0]][0].length,d=t.slice(0,o+s.index+u+n);if(Math.min(o,n)%2){let m=d.slice(1,-1);return{type:"em",raw:d,text:m,tokens:this.lexer.inlineTokens(m)}}let f=d.slice(2,-2);return{type:"strong",raw:d,text:f,tokens:this.lexer.inlineTokens(f)}}}}codespan(t){let r=this.rules.inline.code.exec(t);if(r){let i=r[2].replace(this.rules.other.newLineCharGlobal," "),s=this.rules.other.nonSpaceChar.test(i),o=this.rules.other.startingSpaceChar.test(i)&&this.rules.other.endingSpaceChar.test(i);return s&&o&&(i=i.substring(1,i.length-1)),{type:"codespan",raw:r[0],text:i}}}br(t){let r=this.rules.inline.br.exec(t);if(r)return{type:"br",raw:r[0]}}del(t){let r=this.rules.inline.del.exec(t);if(r)return{type:"del",raw:r[0],text:r[2],tokens:this.lexer.inlineTokens(r[2])}}autolink(t){let r=this.rules.inline.autolink.exec(t);if(r){let i,s;return r[2]==="@"?(i=r[1],s="mailto:"+i):(i=r[1],s=i),{type:"link",raw:r[0],text:i,href:s,tokens:[{type:"text",raw:i,text:i}]}}}url(t){let r;if(r=this.rules.inline.url.exec(t)){let i,s;if(r[2]==="@")i=r[0],s="mailto:"+i;else{let o;do o=r[0],r[0]=this.rules.inline._backpedal.exec(r[0])?.[0]??"";while(o!==r[0]);i=r[0],r[1]==="www."?s="http://"+r[0]:s=r[0]}return{type:"link",raw:r[0],text:i,href:s,tokens:[{type:"text",raw:i,text:i}]}}}inlineText(t){let r=this.rules.inline.text.exec(t);if(r){let i=this.lexer.state.inRawBlock;return{type:"text",raw:r[0],text:r[0],escaped:i}}}},je=class Un{tokens;options;state;tokenizer;inlineQueue;constructor(t){this.tokens=[],this.tokens.links=Object.create(null),this.options=t||ui,this.options.tokenizer=this.options.tokenizer||new Do,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};let r={other:Se,block:Qs.normal,inline:Qi.normal};this.options.pedantic?(r.block=Qs.pedantic,r.inline=Qi.pedantic):this.options.gfm&&(r.block=Qs.gfm,this.options.breaks?r.inline=Qi.breaks:r.inline=Qi.gfm),this.tokenizer.rules=r}static get rules(){return{block:Qs,inline:Qi}}static lex(t,r){return new Un(r).lex(t)}static lexInline(t,r){return new Un(r).inlineTokens(t)}lex(t){t=t.replace(Se.carriageReturn,` +`),this.blockTokens(t,this.tokens);for(let r=0;r(s=a.call({lexer:this},t,r))?(t=t.substring(s.raw.length),r.push(s),!0):!1))continue;if(s=this.tokenizer.space(t)){t=t.substring(s.raw.length);let a=r.at(-1);s.raw.length===1&&a!==void 0?a.raw+=` +`:r.push(s);continue}if(s=this.tokenizer.code(t)){t=t.substring(s.raw.length);let a=r.at(-1);a?.type==="paragraph"||a?.type==="text"?(a.raw+=(a.raw.endsWith(` +`)?"":` +`)+s.raw,a.text+=` +`+s.text,this.inlineQueue.at(-1).src=a.text):r.push(s);continue}if(s=this.tokenizer.fences(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.heading(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.hr(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.blockquote(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.list(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.html(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.def(t)){t=t.substring(s.raw.length);let a=r.at(-1);a?.type==="paragraph"||a?.type==="text"?(a.raw+=(a.raw.endsWith(` +`)?"":` +`)+s.raw,a.text+=` +`+s.raw,this.inlineQueue.at(-1).src=a.text):this.tokens.links[s.tag]||(this.tokens.links[s.tag]={href:s.href,title:s.title},r.push(s));continue}if(s=this.tokenizer.table(t)){t=t.substring(s.raw.length),r.push(s);continue}if(s=this.tokenizer.lheading(t)){t=t.substring(s.raw.length),r.push(s);continue}let o=t;if(this.options.extensions?.startBlock){let a=1/0,n=t.slice(1),l;this.options.extensions.startBlock.forEach(c=>{l=c.call({lexer:this},n),typeof l=="number"&&l>=0&&(a=Math.min(a,l))}),a<1/0&&a>=0&&(o=t.substring(0,a+1))}if(this.state.top&&(s=this.tokenizer.paragraph(o))){let a=r.at(-1);i&&a?.type==="paragraph"?(a.raw+=(a.raw.endsWith(` +`)?"":` +`)+s.raw,a.text+=` +`+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=a.text):r.push(s),i=o.length!==t.length,t=t.substring(s.raw.length);continue}if(s=this.tokenizer.text(t)){t=t.substring(s.raw.length);let a=r.at(-1);a?.type==="text"?(a.raw+=(a.raw.endsWith(` +`)?"":` +`)+s.raw,a.text+=` +`+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=a.text):r.push(s);continue}if(t){let a="Infinite loop on byte: "+t.charCodeAt(0);if(this.options.silent){console.error(a);break}else throw new Error(a)}}return this.state.top=!0,r}inline(t,r=[]){return this.inlineQueue.push({src:t,tokens:r}),r}inlineTokens(t,r=[]){let i=t,s=null;if(this.tokens.links){let l=Object.keys(this.tokens.links);if(l.length>0)for(;(s=this.tokenizer.rules.inline.reflinkSearch.exec(i))!=null;)l.includes(s[0].slice(s[0].lastIndexOf("[")+1,-1))&&(i=i.slice(0,s.index)+"["+"a".repeat(s[0].length-2)+"]"+i.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(s=this.tokenizer.rules.inline.anyPunctuation.exec(i))!=null;)i=i.slice(0,s.index)+"++"+i.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let o;for(;(s=this.tokenizer.rules.inline.blockSkip.exec(i))!=null;)o=s[2]?s[2].length:0,i=i.slice(0,s.index+o)+"["+"a".repeat(s[0].length-o-2)+"]"+i.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);i=this.options.hooks?.emStrongMask?.call({lexer:this},i)??i;let a=!1,n="";for(;t;){a||(n=""),a=!1;let l;if(this.options.extensions?.inline?.some(h=>(l=h.call({lexer:this},t,r))?(t=t.substring(l.raw.length),r.push(l),!0):!1))continue;if(l=this.tokenizer.escape(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.tag(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.link(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.reflink(t,this.tokens.links)){t=t.substring(l.raw.length);let h=r.at(-1);l.type==="text"&&h?.type==="text"?(h.raw+=l.raw,h.text+=l.text):r.push(l);continue}if(l=this.tokenizer.emStrong(t,i,n)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.codespan(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.br(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.del(t)){t=t.substring(l.raw.length),r.push(l);continue}if(l=this.tokenizer.autolink(t)){t=t.substring(l.raw.length),r.push(l);continue}if(!this.state.inLink&&(l=this.tokenizer.url(t))){t=t.substring(l.raw.length),r.push(l);continue}let c=t;if(this.options.extensions?.startInline){let h=1/0,u=t.slice(1),d;this.options.extensions.startInline.forEach(f=>{d=f.call({lexer:this},u),typeof d=="number"&&d>=0&&(h=Math.min(h,d))}),h<1/0&&h>=0&&(c=t.substring(0,h+1))}if(l=this.tokenizer.inlineText(c)){t=t.substring(l.raw.length),l.raw.slice(-1)!=="_"&&(n=l.raw.slice(-1)),a=!0;let h=r.at(-1);h?.type==="text"?(h.raw+=l.raw,h.text+=l.text):r.push(l);continue}if(t){let h="Infinite loop on byte: "+t.charCodeAt(0);if(this.options.silent){console.error(h);break}else throw new Error(h)}}return r}},Io=class{options;parser;constructor(t){this.options=t||ui}space(t){return""}code({text:t,lang:r,escaped:i}){let s=(r||"").match(Se.notSpaceStart)?.[0],o=t.replace(Se.endingNewline,"")+` +`;return s?'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    '+(i?o:er(o,!0))+`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`:"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "+(i?o:er(o,!0))+`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`}blockquote({tokens:t}){return`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +${this.parser.parse(t)}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`}html({text:t}){return t}def(t){return""}heading({tokens:t,depth:r}){return`${this.parser.parseInline(t)} +`}hr(t){return`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`}list(t){let r=t.ordered,i=t.start,s="";for(let n=0;n +`+s+" +`}listitem(t){let r="";if(t.task){let i=this.checkbox({checked:!!t.checked});t.loose?t.tokens[0]?.type==="paragraph"?(t.tokens[0].text=i+" "+t.tokens[0].text,t.tokens[0].tokens&&t.tokens[0].tokens.length>0&&t.tokens[0].tokens[0].type==="text"&&(t.tokens[0].tokens[0].text=i+" "+er(t.tokens[0].tokens[0].text),t.tokens[0].tokens[0].escaped=!0)):t.tokens.unshift({type:"text",raw:i+" ",text:i+" ",escaped:!0}):r+=i+" "}return r+=this.parser.parse(t.tokens,!!t.loose),`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ${r}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +`}checkbox({checked:t}){return"'}paragraph({tokens:t}){return`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${this.parser.parseInline(t)}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`}table(t){let r="",i="";for(let o=0;o${s}`),` + +`+r+` +`+s+`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +`}tablerow({text:t}){return` +${t} +`}tablecell(t){let r=this.parser.parseInline(t.tokens),i=t.header?"th":"td";return(t.align?`<${i} align="${t.align}">`:`<${i}>`)+r+` +`}strong({tokens:t}){return`${this.parser.parseInline(t)}`}em({tokens:t}){return`${this.parser.parseInline(t)}`}codespan({text:t}){return`${er(t,!0)}`}br(t){return"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "}del({tokens:t}){return`${this.parser.parseInline(t)}`}link({href:t,title:r,tokens:i}){let s=this.parser.parseInline(i),o=Qc(t);if(o===null)return s;t=o;let a='                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ",a}image({href:t,title:r,text:i,tokens:s}){s&&(i=this.parser.parseInline(s,this.parser.textRenderer));let o=Qc(t);if(o===null)return er(i);t=o;let a=`${i}{let n=o[a].flat(1/0);i=i.concat(this.walkTokens(n,r))}):o.tokens&&(i=i.concat(this.walkTokens(o.tokens,r)))}}return i}use(...t){let r=this.defaults.extensions||{renderers:{},childTokens:{}};return t.forEach(i=>{let s={...i};if(s.async=this.defaults.async||s.async||!1,i.extensions&&(i.extensions.forEach(o=>{if(!o.name)throw new Error("extension name required");if("renderer"in o){let a=r.renderers[o.name];a?r.renderers[o.name]=function(...n){let l=o.renderer.apply(this,n);return l===!1&&(l=a.apply(this,n)),l}:r.renderers[o.name]=o.renderer}if("tokenizer"in o){if(!o.level||o.level!=="block"&&o.level!=="inline")throw new Error("extension level must be 'block' or 'inline'");let a=r[o.level];a?a.unshift(o.tokenizer):r[o.level]=[o.tokenizer],o.start&&(o.level==="block"?r.startBlock?r.startBlock.push(o.start):r.startBlock=[o.start]:o.level==="inline"&&(r.startInline?r.startInline.push(o.start):r.startInline=[o.start]))}"childTokens"in o&&o.childTokens&&(r.childTokens[o.name]=o.childTokens)}),s.extensions=r),i.renderer){let o=this.defaults.renderer||new Io(this.defaults);for(let a in i.renderer){if(!(a in o))throw new Error(`renderer '${a}' does not exist`);if(["options","parser"].includes(a))continue;let n=a,l=i.renderer[n],c=o[n];o[n]=(...h)=>{let u=l.apply(o,h);return u===!1&&(u=c.apply(o,h)),u||""}}s.renderer=o}if(i.tokenizer){let o=this.defaults.tokenizer||new Do(this.defaults);for(let a in i.tokenizer){if(!(a in o))throw new Error(`tokenizer '${a}' does not exist`);if(["options","rules","lexer"].includes(a))continue;let n=a,l=i.tokenizer[n],c=o[n];o[n]=(...h)=>{let u=l.apply(o,h);return u===!1&&(u=c.apply(o,h)),u}}s.tokenizer=o}if(i.hooks){let o=this.defaults.hooks||new cs;for(let a in i.hooks){if(!(a in o))throw new Error(`hook '${a}' does not exist`);if(["options","block"].includes(a))continue;let n=a,l=i.hooks[n],c=o[n];cs.passThroughHooks.has(a)?o[n]=h=>{if(this.defaults.async&&cs.passThroughHooksRespectAsync.has(a))return(async()=>{let d=await l.call(o,h);return c.call(o,d)})();let u=l.call(o,h);return c.call(o,u)}:o[n]=(...h)=>{if(this.defaults.async)return(async()=>{let d=await l.apply(o,h);return d===!1&&(d=await c.apply(o,h)),d})();let u=l.apply(o,h);return u===!1&&(u=c.apply(o,h)),u}}s.hooks=o}if(i.walkTokens){let o=this.defaults.walkTokens,a=i.walkTokens;s.walkTokens=function(n){let l=[];return l.push(a.call(this,n)),o&&(l=l.concat(o.call(this,n))),l}}this.defaults={...this.defaults,...s}}),this}setOptions(t){return this.defaults={...this.defaults,...t},this}lexer(t,r){return je.lex(t,r??this.defaults)}parser(t,r){return Ge.parse(t,r??this.defaults)}parseMarkdown(t){return(r,i)=>{let s={...i},o={...this.defaults,...s},a=this.onError(!!o.silent,!!o.async);if(this.defaults.async===!0&&s.async===!1)return a(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));if(typeof r>"u"||r===null)return a(new Error("marked(): input parameter is undefined or null"));if(typeof r!="string")return a(new Error("marked(): input parameter is of type "+Object.prototype.toString.call(r)+", string expected"));if(o.hooks&&(o.hooks.options=o,o.hooks.block=t),o.async)return(async()=>{let n=o.hooks?await o.hooks.preprocess(r):r,l=await(o.hooks?await o.hooks.provideLexer():t?je.lex:je.lexInline)(n,o),c=o.hooks?await o.hooks.processAllTokens(l):l;o.walkTokens&&await Promise.all(this.walkTokens(c,o.walkTokens));let h=await(o.hooks?await o.hooks.provideParser():t?Ge.parse:Ge.parseInline)(c,o);return o.hooks?await o.hooks.postprocess(h):h})().catch(a);try{o.hooks&&(r=o.hooks.preprocess(r));let n=(o.hooks?o.hooks.provideLexer():t?je.lex:je.lexInline)(r,o);o.hooks&&(n=o.hooks.processAllTokens(n)),o.walkTokens&&this.walkTokens(n,o.walkTokens);let l=(o.hooks?o.hooks.provideParser():t?Ge.parse:Ge.parseInline)(n,o);return o.hooks&&(l=o.hooks.postprocess(l)),l}catch(n){return a(n)}}}onError(t,r){return i=>{if(i.message+=` +Please report this to https://github.com/markedjs/marked.`,t){let s="

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An error occurred:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "+er(i.message+"",!0)+"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ";return r?Promise.resolve(s):s}if(r)return Promise.reject(i);throw i}}},ai=new i_;function Ut(e,t){return ai.parse(e,t)}Ut.options=Ut.setOptions=function(e){return ai.setOptions(e),Ut.defaults=ai.defaults,vp(Ut.defaults),Ut};Ut.getDefaults=Hl;Ut.defaults=ui;Ut.use=function(...e){return ai.use(...e),Ut.defaults=ai.defaults,vp(Ut.defaults),Ut};Ut.walkTokens=function(e,t){return ai.walkTokens(e,t)};Ut.parseInline=ai.parseInline;Ut.Parser=Ge;Ut.parser=Ge.parse;Ut.Renderer=Io;Ut.TextRenderer=Kl;Ut.Lexer=je;Ut.lexer=je.lex;Ut.Tokenizer=Do;Ut.Hooks=cs;Ut.parse=Ut;Ut.options;Ut.setOptions;Ut.use;Ut.walkTokens;Ut.parseInline;Ge.parse;je.lex;function Pp(e){for(var t=[],r=1;rGn?performance.now():0,"now"),Ia="🧜 ",s_="Mermaid render",o_="Mermaid",a_={parse:"tertiary",prepare:"secondary",measure:"primary",layout:"primary-dark",layoutCore:"error",draw:"primary-light",paint:"secondary-dark",serialize:"tertiary-dark",render:"primary-light"};(class{constructor(){this.enabled=!1,this.autoPrint=!0,this.records=[],this.maxRecords=200,this.roots=[],this.stack=[],this.buckets={}}static{p(this,"Profiler")}enable(){return this.enabled=!0,this}disable(){return this.enabled=!1,this}start(e){this.enabled&&(this.roots=[],this.stack=[],this.buckets={},this.begin(e))}tickSync(e,t){if(!this.enabled)return t();const r=bi();try{return t()}finally{this.buckets[e]=(this.buckets[e]??0)+(bi()-r)}}async tick(e,t){if(!this.enabled)return t();const r=bi();try{return await t()}finally{this.buckets[e]=(this.buckets[e]??0)+(bi()-r)}}stop(){if(!this.enabled)return;for(;this.stack.length>0;)this.end();const e=this.roots.at(-1),t=this.runLabel??e?.name;return e&&(this.records.push({label:t??e.name,tree:e,buckets:{...this.buckets}}),this.records.length>this.maxRecords&&this.records.splice(0,this.records.length-this.maxRecords),this.autoPrint&&this.printSummary(e,t)),this.runLabel=void 0,e}begin(e){if(!this.enabled)return;const t={name:e,start:bi(),duration:-1,children:[]},r=this.stack.at(-1);if(r?r.children.push(t):this.roots.push(t),this.stack.push(t),Gn&&typeof performance.mark=="function")try{performance.mark(`${Ia}${e} ▶`)}catch{}}end(){if(!this.enabled)return;const e=this.stack.pop();if(!e)return;const t=bi();if(e.duration=t-e.start,Gn&&typeof performance.measure=="function")try{performance.measure(`${Ia}${e.name}`,{start:e.start,end:t,detail:{devtools:{dataType:"track-entry",track:s_,trackGroup:o_,color:a_[e.name]??"primary",tooltipText:`${e.name} — ${e.duration.toFixed(1)} ms`}}})}catch{}}async span(e,t){if(!this.enabled)return t();this.begin(e);try{return await t()}finally{this.end()}}report(){return this.records.at(-1)?.tree??this.roots.at(-1)}clear(){this.records.length=0,this.roots=[],this.stack=[],this.runLabel=void 0}reset(){this.roots=[],this.stack=[]}printSummary(e=this.report(),t){if(!e)return;const r=e.duration,i=t&&t!==e.name?`${e.name} [${t}]`:e.name,s=["ms % phase"],o=p((n,l)=>{const c=" ".repeat(l),h=n.duration.toFixed(1).padStart(8),u=r>0?`${(n.duration/r*100).toFixed(0).padStart(3)}%`:" -";s.push(`${h} ${u} ${c}${n.name}`);for(const d of n.children)o(d,l+1);if(n.children.length>0){const d=n.children.reduce((m,y)=>m+y.duration,0),f=n.duration-d;if(f>.5){const m=f.toFixed(1).padStart(8);s.push(`${m} ${c} (self)`)}}},"walk");o(e,0);const a=Object.keys(this.buckets);if(a.length>0){s.push("—— buckets (summed) ——");for(const n of a)s.push(`${this.buckets[n].toFixed(1).padStart(8)} ${n}`)}console.log(`${Ia}mermaid render profile · ${i} +${s.join(` +`)}`)}});globalThis.injected??={includeLargeFeatures:!0,profiling:!1,version:"0.0.0"};var n_=xT.extend({raf(e){typeof queueMicrotask=="function"?queueMicrotask(e):setTimeout(e,0)}}).extend(bT),ni=n_;function Rp(e,{markdownAutoWrap:t}){const i=e.replace(//g,` +`).replace(/\n{2,}/g,` +`);return Pp(i)}p(Rp,"preprocessMarkdown");function Np(e){return e.split(/\\n|\n|/gi).map(t=>t.trim().match(/<[^>]+>|[^\s<>]+/g)?.map(r=>({content:r,type:"normal"}))??[])}p(Np,"nonMarkdownToLines");function qp(e,t={}){const r=Rp(e,t),i=Ut.lexer(r),s=[[]];let o=0;function a(n,l="normal"){n.type==="text"?n.text.split(` +`).forEach((h,u)=>{u!==0&&(o++,s.push([])),h.split(" ").forEach(d=>{d=d.replace(/'/g,"'"),d&&s[o].push({content:d,type:l})})}):n.type==="strong"||n.type==="em"?n.tokens.forEach(c=>{a(c,n.type)}):n.type==="html"&&s[o].push({content:n.text,type:"normal"})}return p(a,"processNode"),i.forEach(n=>{n.type==="paragraph"?n.tokens?.forEach(l=>{a(l)}):n.type==="html"?s[o].push({content:n.text,type:"normal"}):s[o].push({content:n.raw,type:"normal"})}),s}p(qp,"markdownToLines");function zp(e){return e?`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${e.replace(/\\n|\n/g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ")}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `:""}p(zp,"nonMarkdownToHTML");function Wp(e,{markdownAutoWrap:t}={}){const r=Ut.lexer(e);function i(s){return s.type==="text"?t===!1?s.text.replace(/\n */g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ").replace(/ /g," "):s.text.replace(/\n */g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "):s.type==="strong"?`${s.tokens?.map(i).join("")}`:s.type==="em"?`${s.tokens?.map(i).join("")}`:s.type==="paragraph"?`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${s.tokens?.map(i).join("")}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `:s.type==="space"?"":s.type==="html"?`${s.text}`:s.type==="escape"?s.text:(R.warn(`Unsupported markdown: ${s.type}`),s.raw)}return p(i,"output"),r.map(i).join("")}p(Wp,"markdownToHTML");function Hp(e){return Intl.Segmenter?[...new Intl.Segmenter().segment(e)].map(t=>t.segment):[...e]}p(Hp,"splitTextToChars");function Yp(e,t){const r=Hp(t.content);return Ql(e,[],r,t.type)}p(Yp,"splitWordToFitWidth");function Ql(e,t,r,i){if(r.length===0)return[{content:t.join(""),type:i},{content:"",type:i}];const[s,...o]=r,a=[...t,s];return e([{content:a.join(""),type:i}])?Ql(e,a,o,i):(t.length===0&&s&&(t.push(s),r.shift()),[{content:t.join(""),type:i},{content:r.join(""),type:i}])}p(Ql,"splitWordToFitWidthRecursion");function Up(e,t){if(e.some(({content:r})=>r.includes(` +`)))throw new Error("splitLineToFitWidth does not support newlines in the line");return Po(e,t)}p(Up,"splitLineToFitWidth");function Po(e,t,r=[],i=[]){if(e.length===0)return i.length>0&&r.push(i),r.length>0?r:[];let s="";e[0].content===" "&&(s=" ",e.shift());const o=e.shift()??{content:" ",type:"normal"},a=[...i];if(s!==""&&a.push({content:s,type:"normal"}),a.push(o),t(a))return Po(e,t,r,a);if(i.length>0)r.push(i),e.unshift(o);else if(o.content){const[n,l]=Yp(t,o);r.push([n]),l.content&&e.unshift(l)}return Po(e,t,r)}p(Po,"splitLineToFitWidthRecursion");function Xn(e,t){t&&e.attr("style",t)}p(Xn,"applyStyle");var eu=16384;async function jp(e,t,r,i,s=!1,o=Zt()){const a=e.append("foreignObject");a.attr("width",`${Math.min(10*r,eu)}px`),a.attr("height",`${Math.min(10*r,eu)}px`);const n=a.append("xhtml:div"),l=Ts(t.label)?await af(t.label.replace(Is.lineBreakRegex,` +`),o):ze(t.label,o),c=t.isNode?"nodeLabel":"edgeLabel",h=n.append("span");return h.html(l),Xn(h,t.labelStyle),h.attr("class",`${c} ${i}`),Xn(n,t.labelStyle),n.style("display","table-cell"),n.style("white-space","nowrap"),n.style("line-height","1.5"),r!==Number.POSITIVE_INFINITY&&(n.style("max-width",r+"px"),n.style("text-align","center")),n.attr("xmlns","http://www.w3.org/1999/xhtml"),s&&n.attr("class","labelBkg"),(await ni.measure(()=>n.node().getBoundingClientRect())).width===r&&(n.style("display","table"),n.style("white-space","break-spaces"),n.style("width",r+"px")),a.node()}p(jp,"addHtmlSpan");function ra(e,t,r,i=!1){const s=e.append("tspan").attr("class","text-outer-tspan").attr("x",0).attr("y",t*r-.1+"em").attr("dy",r+"em");return i&&s.attr("text-anchor","middle"),s}p(ra,"createTspan");function Gp(e,t,r){const i=e.append("text"),s=ra(i,1,t);ia(s,r);const o=s.node().getComputedTextLength();return i.remove(),o}p(Gp,"computeWidthOfText");function l_(e,t,r){const i=e.append("text"),s=ra(i,1,t);ia(s,[{content:r,type:"normal"}]);const o=s.node()?.getBoundingClientRect();return o&&i.remove(),o}p(l_,"computeDimensionOfText");function Xp(e,t,r,i=!1,s=!1){const a=t.append("g"),n=a.insert("rect").attr("class","background").attr("style","stroke: none"),l=a.append("text").attr("y","-10.1");s&&l.attr("text-anchor","middle");let c=0;for(const h of r){const u=p(f=>Gp(a,1.1,f)<=e,"checkWidth"),d=u(h)?[h]:Up(h,u);for(const f of d){const m=ra(l,c,1.1,s);ia(m,f),c++}}if(i){const h=l.node().getBBox(),u=2;return n.attr("x",h.x-u).attr("y",h.y-u).attr("width",h.width+2*u).attr("height",h.height+2*u),a.node()}else return l.node()}p(Xp,"createFormattedText");function Vn(e){const t=/&(amp|lt|gt);/g;return e.replace(t,(r,i)=>{switch(i){case"amp":return"&";case"lt":return"<";case"gt":return">";default:return r}})}p(Vn,"decodeHTMLEntities");function ia(e,t){e.text(""),t.forEach((r,i)=>{const s=e.append("tspan").attr("font-style",r.type==="em"?"italic":"normal").attr("class","text-inner-tspan").attr("font-weight",r.type==="strong"?"bold":"normal");i===0?s.text(Vn(r.content)):s.text(" "+Vn(r.content))})}p(ia,"updateTextContentAndStyles");async function Vp(e,t={}){const r=[];e.replace(/(fa[bklrs]?):fa-([\w-]+)/g,(s,o,a)=>(r.push((async()=>{const n=`${o}:${a}`;return await xw(n)?await Ns(n,void 0,{class:"label-icon"}):``})()),s));const i=await Promise.all(r);return e.replace(/(fa[bklrs]?):fa-([\w-]+)/g,()=>i.shift()??"")}p(Vp,"replaceIconSubstring");var Qe=p(async(e,t="",{style:r="",isTitle:i=!1,classes:s="",useHtmlLabels:o=!0,markdown:a=!0,isNode:n=!0,width:l=200,addSvgBackground:c=!1}={},h)=>{if(R.debug("XYZ createText",t,r,i,s,o,n,"addSvgBackground: ",c),o){const u=a?Wp(t,h):zp(t),d=await Vp(Wr(u),h),f=t.replace(/\\\\/g,"\\"),m={isNode:n,label:Ts(t)?f:d,labelStyle:r.replace("fill:","color:")};return await jp(e,m,l,s,c,h)}else{const u=Wr(t.replace(//g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ")),d=a?qp(u.replace("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ","
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "),h):Np(u),f=Xp(l,e,d,t?c:!1,!n);if(n){/stroke:/.exec(r)&&(r=r.replace("stroke:","lineColor:"));const m=r.replace(/stroke:[^;]+;?/g,"").replace(/stroke-width:[^;]+;?/g,"").replace(/fill:[^;]+;?/g,"").replace(/color:/g,"fill:");At(f).attr("style",m)}else{const m=r.replace(/stroke:[^;]+;?/g,"").replace(/stroke-width:[^;]+;?/g,"").replace(/fill:[^;]+;?/g,"").replace(/background:/g,"fill:");At(f).select("rect").attr("style",m.replace(/background:/g,"fill:"));const y=r.replace(/stroke:[^;]+;?/g,"").replace(/stroke-width:[^;]+;?/g,"").replace(/fill:[^;]+;?/g,"").replace(/color:/g,"fill:");At(f).select("text").attr("style",y)}return i?At(f).selectAll("tspan.text-outer-tspan").classed("title-row",!0):At(f).selectAll("tspan.text-outer-tspan").classed("row",!0),f}},"createText");function Pa(e,t,r){if(e&&e.length){const[i,s]=t,o=Math.PI/180*r,a=Math.cos(o),n=Math.sin(o);for(const l of e){const[c,h]=l;l[0]=(c-i)*a-(h-s)*n+i,l[1]=(c-i)*n+(h-s)*a+s}}}function h_(e,t){return e[0]===t[0]&&e[1]===t[1]}function c_(e,t,r,i=1){const s=r,o=Math.max(t,.1),a=e[0]&&e[0][0]&&typeof e[0][0]=="number"?[e]:e,n=[0,0];if(s)for(const c of a)Pa(c,n,s);const l=(function(c,h,u){const d=[];for(const k of c){const T=[...k];h_(T[0],T[T.length-1])||T.push([T[0][0],T[0][1]]),T.length>2&&d.push(T)}const f=[];h=Math.max(h,.1);const m=[];for(const k of d)for(let T=0;Tk.yminT.ymin?1:k.xT.x?1:k.ymax===T.ymax?0:(k.ymax-T.ymax)/Math.abs(k.ymax-T.ymax))),!m.length)return f;let y=[],x=m[0].ymin,C=0;for(;y.length||m.length;){if(m.length){let k=-1;for(let T=0;Tx);T++)k=T;m.splice(0,k+1).forEach((T=>{y.push({s:x,edge:T})}))}if(y=y.filter((k=>!(k.edge.ymax<=x))),y.sort(((k,T)=>k.edge.x===T.edge.x?0:(k.edge.x-T.edge.x)/Math.abs(k.edge.x-T.edge.x))),(u!==1||C%h==0)&&y.length>1)for(let k=0;k=y.length)break;const S=y[k].edge,v=y[T].edge;f.push([[Math.round(S.x),x],[Math.round(v.x),x]])}x+=u,y.forEach((k=>{k.edge.x=k.edge.x+u*k.edge.islope})),C++}return f})(a,o,i);if(s){for(const c of a)Pa(c,n,-s);(function(c,h,u){const d=[];c.forEach((f=>d.push(...f))),Pa(d,h,u)})(l,n,-s)}return l}function Ws(e,t){var r;const i=t.hachureAngle+90;let s=t.hachureGap;s<0&&(s=4*t.strokeWidth),s=Math.round(Math.max(s,.1));let o=1;return t.roughness>=1&&(((r=t.randomizer)===null||r===void 0?void 0:r.next())||Math.random())>.7&&(o=s),c_(e,s,i,o||1)}class Jl{constructor(t){this.helper=t}fillPolygons(t,r){return this._fillPolygons(t,r)}_fillPolygons(t,r){const i=Ws(t,r);return{type:"fillSketch",ops:this.renderLines(i,r)}}renderLines(t,r){const i=[];for(const s of t)i.push(...this.helper.doubleLineOps(s[0][0],s[0][1],s[1][0],s[1][1],r));return i}}function sa(e){const t=e[0],r=e[1];return Math.sqrt(Math.pow(t[0]-r[0],2)+Math.pow(t[1]-r[1],2))}class u_ extends Jl{fillPolygons(t,r){let i=r.hachureGap;i<0&&(i=4*r.strokeWidth),i=Math.max(i,.1);const s=Ws(t,Object.assign({},r,{hachureGap:i})),o=Math.PI/180*r.hachureAngle,a=[],n=.5*i*Math.cos(o),l=.5*i*Math.sin(o);for(const[c,h]of s)sa([c,h])&&a.push([[c[0]-n,c[1]+l],[...h]],[[c[0]+n,c[1]-l],[...h]]);return{type:"fillSketch",ops:this.renderLines(a,r)}}}class d_ extends Jl{fillPolygons(t,r){const i=this._fillPolygons(t,r),s=Object.assign({},r,{hachureAngle:r.hachureAngle+90}),o=this._fillPolygons(t,s);return i.ops=i.ops.concat(o.ops),i}}class f_{constructor(t){this.helper=t}fillPolygons(t,r){const i=Ws(t,r=Object.assign({},r,{hachureAngle:0}));return this.dotsOnLines(i,r)}dotsOnLines(t,r){const i=[];let s=r.hachureGap;s<0&&(s=4*r.strokeWidth),s=Math.max(s,.1);let o=r.fillWeight;o<0&&(o=r.strokeWidth/2);const a=s/4;for(const n of t){const l=sa(n),c=l/s,h=Math.ceil(c)-1,u=l-h*s,d=(n[0][0]+n[1][0])/2-s/4,f=Math.min(n[0][1],n[1][1]);for(let m=0;m{const n=sa(a),l=Math.floor(n/(i+s)),c=(n+s-l*(i+s))/2;let h=a[0],u=a[1];h[0]>u[0]&&(h=a[1],u=a[0]);const d=Math.atan((u[1]-h[1])/(u[0]-h[0]));for(let f=0;f{const a=sa(o),n=Math.round(a/(2*r));let l=o[0],c=o[1];l[0]>c[0]&&(l=o[1],c=o[0]);const h=Math.atan((c[1]-l[1])/(c[0]-l[0]));for(let u=0;uh%2?c+r:c+t));o.push({key:"C",data:l}),t=l[4],r=l[5];break}case"Q":o.push({key:"Q",data:[...n]}),t=n[2],r=n[3];break;case"q":{const l=n.map(((c,h)=>h%2?c+r:c+t));o.push({key:"Q",data:l}),t=l[2],r=l[3];break}case"A":o.push({key:"A",data:[...n]}),t=n[5],r=n[6];break;case"a":t+=n[5],r+=n[6],o.push({key:"A",data:[n[0],n[1],n[2],n[3],n[4],t,r]});break;case"H":o.push({key:"H",data:[...n]}),t=n[0];break;case"h":t+=n[0],o.push({key:"H",data:[t]});break;case"V":o.push({key:"V",data:[...n]}),r=n[0];break;case"v":r+=n[0],o.push({key:"V",data:[r]});break;case"S":o.push({key:"S",data:[...n]}),t=n[2],r=n[3];break;case"s":{const l=n.map(((c,h)=>h%2?c+r:c+t));o.push({key:"S",data:l}),t=l[2],r=l[3];break}case"T":o.push({key:"T",data:[...n]}),t=n[0],r=n[1];break;case"t":t+=n[0],r+=n[1],o.push({key:"T",data:[t,r]});break;case"Z":case"z":o.push({key:"Z",data:[]}),t=i,r=s}return o}function Kp(e){const t=[];let r="",i=0,s=0,o=0,a=0,n=0,l=0;for(const{key:c,data:h}of e){switch(c){case"M":t.push({key:"M",data:[...h]}),[i,s]=h,[o,a]=h;break;case"C":t.push({key:"C",data:[...h]}),i=h[4],s=h[5],n=h[2],l=h[3];break;case"L":t.push({key:"L",data:[...h]}),[i,s]=h;break;case"H":i=h[0],t.push({key:"L",data:[i,s]});break;case"V":s=h[0],t.push({key:"L",data:[i,s]});break;case"S":{let u=0,d=0;r==="C"||r==="S"?(u=i+(i-n),d=s+(s-l)):(u=i,d=s),t.push({key:"C",data:[u,d,...h]}),n=h[0],l=h[1],i=h[2],s=h[3];break}case"T":{const[u,d]=h;let f=0,m=0;r==="Q"||r==="T"?(f=i+(i-n),m=s+(s-l)):(f=i,m=s);const y=i+2*(f-i)/3,x=s+2*(m-s)/3,C=u+2*(f-u)/3,k=d+2*(m-d)/3;t.push({key:"C",data:[y,x,C,k,u,d]}),n=f,l=m,i=u,s=d;break}case"Q":{const[u,d,f,m]=h,y=i+2*(u-i)/3,x=s+2*(d-s)/3,C=f+2*(u-f)/3,k=m+2*(d-m)/3;t.push({key:"C",data:[y,x,C,k,f,m]}),n=u,l=d,i=f,s=m;break}case"A":{const u=Math.abs(h[0]),d=Math.abs(h[1]),f=h[2],m=h[3],y=h[4],x=h[5],C=h[6];u===0||d===0?(t.push({key:"C",data:[i,s,x,C,x,C]}),i=x,s=C):(i!==x||s!==C)&&(Qp(i,s,x,C,u,d,f,m,y).forEach((function(k){t.push({key:"C",data:k})})),i=x,s=C);break}case"Z":t.push({key:"Z",data:[]}),i=o,s=a}r=c}return t}function ts(e,t,r){return[e*Math.cos(r)-t*Math.sin(r),e*Math.sin(r)+t*Math.cos(r)]}function Qp(e,t,r,i,s,o,a,n,l,c){const h=(u=a,Math.PI*u/180);var u;let d=[],f=0,m=0,y=0,x=0;if(c)[f,m,y,x]=c;else{[e,t]=ts(e,t,-h),[r,i]=ts(r,i,-h);const Y=(e-r)/2,$=(t-i)/2;let I=Y*Y/(s*s)+$*$/(o*o);I>1&&(I=Math.sqrt(I),s*=I,o*=I);const B=s*s,q=o*o,O=B*q-B*$*$-q*Y*Y,it=B*$*$+q*Y*Y,tt=(n===l?-1:1)*Math.sqrt(Math.abs(O/it));y=tt*s*$/o+(e+r)/2,x=tt*-o*Y/s+(t+i)/2,f=Math.asin(parseFloat(((t-x)/o).toFixed(9))),m=Math.asin(parseFloat(((i-x)/o).toFixed(9))),em&&(f-=2*Math.PI),!l&&m>f&&(m-=2*Math.PI)}let C=m-f;if(Math.abs(C)>120*Math.PI/180){const Y=m,$=r,I=i;m=l&&m>f?f+120*Math.PI/180*1:f+120*Math.PI/180*-1,d=Qp(r=y+s*Math.cos(m),i=x+o*Math.sin(m),$,I,s,o,a,0,l,[m,Y,y,x])}C=m-f;const k=Math.cos(f),T=Math.sin(f),S=Math.cos(m),v=Math.sin(m),A=Math.tan(C/4),L=4/3*s*A,F=4/3*o*A,Z=[e,t],U=[e+L*T,t-F*k],N=[r+L*v,i-F*S],st=[r,i];if(U[0]=2*Z[0]-U[0],U[1]=2*Z[1]-U[1],c)return[U,N,st].concat(d);{d=[U,N,st].concat(d);const Y=[];for(let $=0;$2){const s=[];for(let o=0;o2*Math.PI&&(f=0,m=2*Math.PI);const y=2*Math.PI/l.curveStepCount,x=Math.min(y/2,(m-f)/2),C=lu(x,c,h,u,d,f,m,1,l);if(!l.disableMultiStroke){const k=lu(x,c,h,u,d,f,m,1.5,l);C.push(...k)}return a&&(n?C.push(...Hr(c,h,c+u*Math.cos(f),h+d*Math.sin(f),l),...Hr(c,h,c+u*Math.cos(m),h+d*Math.sin(m),l)):C.push({op:"lineTo",data:[c,h]},{op:"lineTo",data:[c+u*Math.cos(f),h+d*Math.sin(f)]})),{type:"path",ops:C}}function ou(e,t){const r=Kp(Zp(th(e))),i=[];let s=[0,0],o=[0,0];for(const{key:a,data:n}of r)switch(a){case"M":o=[n[0],n[1]],s=[n[0],n[1]];break;case"L":i.push(...Hr(o[0],o[1],n[0],n[1],t)),o=[n[0],n[1]];break;case"C":{const[l,c,h,u,d,f]=n;i.push(...b_(l,c,h,u,d,f,o,t)),o=[d,f];break}case"Z":i.push(...Hr(o[0],o[1],s[0],s[1],t)),o=[s[0],s[1]]}return{type:"path",ops:i}}function qa(e,t){const r=[];for(const i of e)if(i.length){const s=t.maxRandomnessOffset||0,o=i.length;if(o>2){r.push({op:"move",data:[i[0][0]+St(s,t),i[0][1]+St(s,t)]});for(let a=1;a500?.4:-.0016668*l+1.233334;let h=s.maxRandomnessOffset||0;h*h*100>n&&(h=l/10);const u=h/2,d=.2+.2*eg(s);let f=s.bowing*s.maxRandomnessOffset*(i-t)/200,m=s.bowing*s.maxRandomnessOffset*(e-r)/200;f=St(f,s,c),m=St(m,s,c);const y=[],x=()=>St(u,s,c),C=()=>St(h,s,c),k=s.preserveVertices;return a?y.push({op:"move",data:[e+(k?0:x()),t+(k?0:x())]}):y.push({op:"move",data:[e+(k?0:St(h,s,c)),t+(k?0:St(h,s,c))]}),a?y.push({op:"bcurveTo",data:[f+e+(r-e)*d+x(),m+t+(i-t)*d+x(),f+e+2*(r-e)*d+x(),m+t+2*(i-t)*d+x(),r+(k?0:x()),i+(k?0:x())]}):y.push({op:"bcurveTo",data:[f+e+(r-e)*d+C(),m+t+(i-t)*d+C(),f+e+2*(r-e)*d+C(),m+t+2*(i-t)*d+C(),r+(k?0:C()),i+(k?0:C())]}),y}function to(e,t,r){if(!e.length)return[];const i=[];i.push([e[0][0]+St(t,r),e[0][1]+St(t,r)]),i.push([e[0][0]+St(t,r),e[0][1]+St(t,r)]);for(let s=1;s3){const o=[],a=1-r.curveTightness;s.push({op:"move",data:[e[1][0],e[1][1]]});for(let n=1;n+21&&s.push(n)):s.push(n),s.push(e[t+3])}else{const l=e[t+0],c=e[t+1],h=e[t+2],u=e[t+3],d=Qr(l,c,.5),f=Qr(c,h,.5),m=Qr(h,u,.5),y=Qr(d,f,.5),x=Qr(f,m,.5),C=Qr(y,x,.5);Qn([l,d,y,C],0,r,s),Qn([C,x,m,u],0,r,s)}var o,a;return s}function w_(e,t){return qo(e,0,e.length,t)}function qo(e,t,r,i,s){const o=s||[],a=e[t],n=e[r-1];let l=0,c=1;for(let h=t+1;hl&&(l=u,c=h)}return Math.sqrt(l)>i?(qo(e,t,c+1,i,o),qo(e,c,r,i,o)):(o.length||o.push(a),o.push(n)),o}function za(e,t=.15,r){const i=[],s=(e.length-1)/3;for(let o=0;o0?qo(i,0,i.length,r):i}const Pe="none";class zo{constructor(t){this.defaultOptions={maxRandomnessOffset:2,roughness:1,bowing:1,stroke:"#000",strokeWidth:1,curveTightness:0,curveFitting:.95,curveStepCount:9,fillStyle:"hachure",fillWeight:-1,hachureAngle:-41,hachureGap:-1,dashOffset:-1,dashGap:-1,zigzagOffset:-1,seed:0,disableMultiStroke:!1,disableMultiStrokeFill:!1,preserveVertices:!1,fillShapeRoughnessGain:.8},this.config=t||{},this.config.options&&(this.defaultOptions=this._o(this.config.options))}static newSeed(){return Math.floor(Math.random()*2**31)}_o(t){return t?Object.assign({},this.defaultOptions,t):this.defaultOptions}_d(t,r,i){return{shape:t,sets:r||[],options:i||this.defaultOptions}}line(t,r,i,s,o){const a=this._o(o);return this._d("line",[Jp(t,r,i,s,a)],a)}rectangle(t,r,i,s,o){const a=this._o(o),n=[],l=C_(t,r,i,s,a);if(a.fill){const c=[[t,r],[t+i,r],[t+i,r+s],[t,r+s]];a.fillStyle==="solid"?n.push(qa([c],a)):n.push(ki([c],a))}return a.stroke!==Pe&&n.push(l),this._d("rectangle",n,a)}ellipse(t,r,i,s,o){const a=this._o(o),n=[],l=tg(i,s,a),c=Zn(t,r,a,l);if(a.fill)if(a.fillStyle==="solid"){const h=Zn(t,r,a,l).opset;h.type="fillPath",n.push(h)}else n.push(ki([c.estimatedPoints],a));return a.stroke!==Pe&&n.push(c.opset),this._d("ellipse",n,a)}circle(t,r,i,s){const o=this.ellipse(t,r,i,i,s);return o.shape="circle",o}linearPath(t,r){const i=this._o(r);return this._d("linearPath",[go(t,!1,i)],i)}arc(t,r,i,s,o,a,n=!1,l){const c=this._o(l),h=[],u=su(t,r,i,s,o,a,n,!0,c);if(n&&c.fill)if(c.fillStyle==="solid"){const d=Object.assign({},c);d.disableMultiStroke=!0;const f=su(t,r,i,s,o,a,!0,!1,d);f.type="fillPath",h.push(f)}else h.push((function(d,f,m,y,x,C,k){const T=d,S=f;let v=Math.abs(m/2),A=Math.abs(y/2);v+=St(.01*v,k),A+=St(.01*A,k);let L=x,F=C;for(;L<0;)L+=2*Math.PI,F+=2*Math.PI;F-L>2*Math.PI&&(L=0,F=2*Math.PI);const Z=(F-L)/k.curveStepCount,U=[];for(let N=L;N<=F;N+=Z)U.push([T+v*Math.cos(N),S+A*Math.sin(N)]);return U.push([T+v*Math.cos(F),S+A*Math.sin(F)]),U.push([T,S]),ki([U],k)})(t,r,i,s,o,a,c));return c.stroke!==Pe&&h.push(u),this._d("arc",h,c)}curve(t,r){const i=this._o(r),s=[],o=iu(t,i);if(i.fill&&i.fill!==Pe)if(i.fillStyle==="solid"){const a=iu(t,Object.assign(Object.assign({},i),{disableMultiStroke:!0,roughness:i.roughness?i.roughness+i.fillShapeRoughnessGain:0}));s.push({type:"fillPath",ops:this._mergedShape(a.ops)})}else{const a=[],n=t;if(n.length){const l=typeof n[0][0]=="number"?[n]:n;for(const c of l)c.length<3?a.push(...c):c.length===3?a.push(...za(hu([c[0],c[0],c[1],c[2]]),10,(1+i.roughness)/2)):a.push(...za(hu(c),10,(1+i.roughness)/2))}a.length&&s.push(ki([a],i))}return i.stroke!==Pe&&s.push(o),this._d("curve",s,i)}polygon(t,r){const i=this._o(r),s=[],o=go(t,!0,i);return i.fill&&(i.fillStyle==="solid"?s.push(qa([t],i)):s.push(ki([t],i))),i.stroke!==Pe&&s.push(o),this._d("polygon",s,i)}path(t,r){const i=this._o(r),s=[];if(!t)return this._d("path",s,i);t=(t||"").replace(/\n/g," ").replace(/(-\s)/g,"-").replace("/(ss)/g"," ");const o=i.fill&&i.fill!=="transparent"&&i.fill!==Pe,a=i.stroke!==Pe,n=!!(i.simplification&&i.simplification<1),l=(function(h,u,d){const f=Kp(Zp(th(h))),m=[];let y=[],x=[0,0],C=[];const k=()=>{C.length>=4&&y.push(...za(C,u)),C=[]},T=()=>{k(),y.length&&(m.push(y),y=[])};for(const{key:v,data:A}of f)switch(v){case"M":T(),x=[A[0],A[1]],y.push(x);break;case"L":k(),y.push([A[0],A[1]]);break;case"C":if(!C.length){const L=y.length?y[y.length-1]:x;C.push([L[0],L[1]])}C.push([A[0],A[1]]),C.push([A[2],A[3]]),C.push([A[4],A[5]]);break;case"Z":k(),y.push([x[0],x[1]])}if(T(),!d)return m;const S=[];for(const v of m){const A=w_(v,d);A.length&&S.push(A)}return S})(t,1,n?4-4*(i.simplification||1):(1+i.roughness)/2),c=ou(t,i);if(o)if(i.fillStyle==="solid")if(l.length===1){const h=ou(t,Object.assign(Object.assign({},i),{disableMultiStroke:!0,roughness:i.roughness?i.roughness+i.fillShapeRoughnessGain:0}));s.push({type:"fillPath",ops:this._mergedShape(h.ops)})}else s.push(qa(l,i));else s.push(ki(l,i));return a&&(n?l.forEach((h=>{s.push(go(h,!1,i))})):s.push(c)),this._d("path",s,i)}opsToPath(t,r){let i="";for(const s of t.ops){const o=typeof r=="number"&&r>=0?s.data.map((a=>+a.toFixed(r))):s.data;switch(s.op){case"move":i+=`M${o[0]} ${o[1]} `;break;case"bcurveTo":i+=`C${o[0]} ${o[1]}, ${o[2]} ${o[3]}, ${o[4]} ${o[5]} `;break;case"lineTo":i+=`L${o[0]} ${o[1]} `}}return i.trim()}toPaths(t){const r=t.sets||[],i=t.options||this.defaultOptions,s=[];for(const o of r){let a=null;switch(o.type){case"path":a={d:this.opsToPath(o),stroke:i.stroke,strokeWidth:i.strokeWidth,fill:Pe};break;case"fillPath":a={d:this.opsToPath(o),stroke:Pe,strokeWidth:0,fill:i.fill||Pe};break;case"fillSketch":a=this.fillSketch(o,i)}a&&s.push(a)}return s}fillSketch(t,r){let i=r.fillWeight;return i<0&&(i=r.strokeWidth/2),{d:this.opsToPath(t),stroke:r.fill||Pe,strokeWidth:i,fill:Pe}}_mergedShape(t){return t.filter(((r,i)=>i===0||r.op!=="move"))}}class T_{constructor(t,r){this.canvas=t,this.ctx=this.canvas.getContext("2d"),this.gen=new zo(r)}draw(t){const r=t.sets||[],i=t.options||this.getDefaultOptions(),s=this.ctx,o=t.options.fixedDecimalPlaceDigits;for(const a of r)switch(a.type){case"path":s.save(),s.strokeStyle=i.stroke==="none"?"transparent":i.stroke,s.lineWidth=i.strokeWidth,i.strokeLineDash&&s.setLineDash(i.strokeLineDash),i.strokeLineDashOffset&&(s.lineDashOffset=i.strokeLineDashOffset),this._drawToContext(s,a,o),s.restore();break;case"fillPath":{s.save(),s.fillStyle=i.fill||"";const n=t.shape==="curve"||t.shape==="polygon"||t.shape==="path"?"evenodd":"nonzero";this._drawToContext(s,a,o,n),s.restore();break}case"fillSketch":this.fillSketch(s,a,i)}}fillSketch(t,r,i){let s=i.fillWeight;s<0&&(s=i.strokeWidth/2),t.save(),i.fillLineDash&&t.setLineDash(i.fillLineDash),i.fillLineDashOffset&&(t.lineDashOffset=i.fillLineDashOffset),t.strokeStyle=i.fill||"",t.lineWidth=s,this._drawToContext(t,r,i.fixedDecimalPlaceDigits),t.restore()}_drawToContext(t,r,i,s="nonzero"){t.beginPath();for(const o of r.ops){const a=typeof i=="number"&&i>=0?o.data.map((n=>+n.toFixed(i))):o.data;switch(o.op){case"move":t.moveTo(a[0],a[1]);break;case"bcurveTo":t.bezierCurveTo(a[0],a[1],a[2],a[3],a[4],a[5]);break;case"lineTo":t.lineTo(a[0],a[1])}}r.type==="fillPath"?t.fill(s):t.stroke()}get generator(){return this.gen}getDefaultOptions(){return this.gen.defaultOptions}line(t,r,i,s,o){const a=this.gen.line(t,r,i,s,o);return this.draw(a),a}rectangle(t,r,i,s,o){const a=this.gen.rectangle(t,r,i,s,o);return this.draw(a),a}ellipse(t,r,i,s,o){const a=this.gen.ellipse(t,r,i,s,o);return this.draw(a),a}circle(t,r,i,s){const o=this.gen.circle(t,r,i,s);return this.draw(o),o}linearPath(t,r){const i=this.gen.linearPath(t,r);return this.draw(i),i}polygon(t,r){const i=this.gen.polygon(t,r);return this.draw(i),i}arc(t,r,i,s,o,a,n=!1,l){const c=this.gen.arc(t,r,i,s,o,a,n,l);return this.draw(c),c}curve(t,r){const i=this.gen.curve(t,r);return this.draw(i),i}path(t,r){const i=this.gen.path(t,r);return this.draw(i),i}}const eo="http://www.w3.org/2000/svg";class __{constructor(t,r){this.svg=t,this.gen=new zo(r)}draw(t){const r=t.sets||[],i=t.options||this.getDefaultOptions(),s=this.svg.ownerDocument||window.document,o=s.createElementNS(eo,"g"),a=t.options.fixedDecimalPlaceDigits;for(const n of r){let l=null;switch(n.type){case"path":l=s.createElementNS(eo,"path"),l.setAttribute("d",this.opsToPath(n,a)),l.setAttribute("stroke",i.stroke),l.setAttribute("stroke-width",i.strokeWidth+""),l.setAttribute("fill","none"),i.strokeLineDash&&l.setAttribute("stroke-dasharray",i.strokeLineDash.join(" ").trim()),i.strokeLineDashOffset&&l.setAttribute("stroke-dashoffset",`${i.strokeLineDashOffset}`);break;case"fillPath":l=s.createElementNS(eo,"path"),l.setAttribute("d",this.opsToPath(n,a)),l.setAttribute("stroke","none"),l.setAttribute("stroke-width","0"),l.setAttribute("fill",i.fill||""),t.shape!=="curve"&&t.shape!=="polygon"||l.setAttribute("fill-rule","evenodd");break;case"fillSketch":l=this.fillSketch(s,n,i)}l&&o.appendChild(l)}return o}fillSketch(t,r,i){let s=i.fillWeight;s<0&&(s=i.strokeWidth/2);const o=t.createElementNS(eo,"path");return o.setAttribute("d",this.opsToPath(r,i.fixedDecimalPlaceDigits)),o.setAttribute("stroke",i.fill||""),o.setAttribute("stroke-width",s+""),o.setAttribute("fill","none"),i.fillLineDash&&o.setAttribute("stroke-dasharray",i.fillLineDash.join(" ").trim()),i.fillLineDashOffset&&o.setAttribute("stroke-dashoffset",`${i.fillLineDashOffset}`),o}get generator(){return this.gen}getDefaultOptions(){return this.gen.defaultOptions}opsToPath(t,r){return this.gen.opsToPath(t,r)}line(t,r,i,s,o){const a=this.gen.line(t,r,i,s,o);return this.draw(a)}rectangle(t,r,i,s,o){const a=this.gen.rectangle(t,r,i,s,o);return this.draw(a)}ellipse(t,r,i,s,o){const a=this.gen.ellipse(t,r,i,s,o);return this.draw(a)}circle(t,r,i,s){const o=this.gen.circle(t,r,i,s);return this.draw(o)}linearPath(t,r){const i=this.gen.linearPath(t,r);return this.draw(i)}polygon(t,r){const i=this.gen.polygon(t,r);return this.draw(i)}arc(t,r,i,s,o,a,n=!1,l){const c=this.gen.arc(t,r,i,s,o,a,n,l);return this.draw(c)}curve(t,r){const i=this.gen.curve(t,r);return this.draw(i)}path(t,r){const i=this.gen.path(t,r);return this.draw(i)}}var ct={canvas:(e,t)=>new T_(e,t),svg:(e,t)=>new __(e,t),generator:e=>new zo(e),newSeed:()=>zo.newSeed()},S_=1,v_=3;async function eh(e){const t=e.getElementsByTagName("img");if(!t||t.length===0)return;const r=!rh(e);await Promise.all([...t].map(i=>new Promise(s=>{function o(){if(i.style.display="flex",i.style.flexDirection="column",r){const a=It().fontSize?It().fontSize:window.getComputedStyle(document.body).fontSize,n=5,[l=Gd.fontSize]=Jo(a),c=l*n+"px";i.style.minWidth=c,i.style.maxWidth=c}else i.style.width="100%";s(i)}p(o,"setupImage"),setTimeout(()=>{i.complete&&o()}),i.addEventListener("error",o),i.addEventListener("load",o)})))}p(eh,"configureLabelImages");function rh(e){return e.nodeType===v_?e.textContent?.trim()!=="":e.nodeType!==S_||e.tagName.toLowerCase()==="img"?!1:[...e.childNodes].some(rh)}p(rh,"hasTextBesidesImages");var cu=3,B_=32,L_=p(async(e,t,r)=>{const i=It(),s=e.insert("g").attr("class",r??"node default").attr("id",t.domId||t.id),o=s.insert("g").attr("class","label").attr("style",re(t.labelStyle)),n=[{text:typeof t.label=="string"?t.label:t.label?.[0]??"",cssClass:"c4-name"},{text:t.stereotype,cssClass:"c4-type"},...(t.description??[]).map(C=>({text:C,cssClass:"c4-descr"}))].filter(C=>C.text),l=t.width?Math.max(t.width-2*(t.padding??0),B_):It().flowchart?.wrappingWidth??200,h=i.c4?.wrap??!0?l:Number.POSITIVE_INFINITY,u=await Promise.all(n.map(async C=>{const k=o.append("g").attr("class",C.cssClass),T=await Qe(k,ze(Wr(C.text??""),i),{useHtmlLabels:!1,markdown:!1,isNode:!0,width:h,style:t.labelStyle},i);return At(T).selectAll("tspan.text-outer-tspan").attr("text-anchor","middle"),At(T).selectAll("tspan.text-inner-tspan").attr("font-weight",null).attr("font-style",null),{el:k,box:k.node().getBBox()}})),d=Math.max(...u.map(({box:C})=>C.width),0);let f=0;for(const{el:C,box:k}of u)C.attr("transform",`translate(${d/2-k.x-k.width/2}, ${f-k.y})`),f+=k.height+cu;const m=u.length>0?f-cu:0;o.insert("rect",":first-child"),o.attr("transform",`translate(${-d/2}, ${-m/2})`);const y=o.node().getBBox(),x=(t.padding??0)/2;return{shapeSvg:s,bbox:y,halfPadding:x,label:o}},"c4LabelHelper"),xt=p(async(e,t,r)=>{if(t.stereotype!==void 0)return L_(e,t,r);let i;const s=t.useHtmlLabels||ur(It()?.htmlLabels);r?i=r:i="node default";const o=e.insert("g").attr("class",i).attr("id",t.domId||t.id),a=o.insert("g").attr("class","label").attr("style",re(t.labelStyle));let n;t.label===void 0?n="":n=typeof t.label=="string"?t.label:t.label[0];const l=!!t.icon||!!t.img,c=t.labelType==="markdown",h=await Qe(a,ze(Wr(n),It()),{useHtmlLabels:s,width:t.width||t.wrappingWidth||It().flowchart?.wrappingWidth,classes:c?"markdown-node-label":"",style:t.labelStyle,addSvgBackground:l,markdown:c},It()),u=(t?.padding??0)/2;let d;if(s){const f=h.children[0],m=At(h);await eh(f),d=await ni.measure(()=>f.getBoundingClientRect()),m.attr("width",d.width),m.attr("height",d.height)}else d=await ni.measure(()=>h.getBBox());return s?a.attr("transform","translate("+-d.width/2+", "+-d.height/2+")"):a.attr("transform","translate(0, "+-d.height/2+")"),t.centerLabel&&a.attr("transform","translate("+-d.width/2+", "+-d.height/2+")"),a.insert("rect",":first-child"),{shapeSvg:o,bbox:d,halfPadding:u,label:a}},"labelHelper"),Wa=p(async(e,t,r)=>{const i=r.useHtmlLabels??be(It()),s=e.insert("g").attr("class","label").attr("style",r.labelStyle||""),o=await Qe(s,ze(Wr(t),It()),{useHtmlLabels:i,width:r.width||It()?.flowchart?.wrappingWidth,style:r.labelStyle,addSvgBackground:!!r.icon||!!r.img}),a=r.padding/2;let n;if(be(It())){const l=o.children[0],c=At(o);n=await ni.measure(()=>l.getBoundingClientRect()),c.attr("width",n.width),c.attr("height",n.height)}else n=await ni.measure(()=>o.getBBox());return i?s.attr("transform","translate("+-n.width/2+", "+-n.height/2+")"):s.attr("transform","translate(0, "+-n.height/2+")"),r.centerLabel&&s.attr("transform","translate("+-n.width/2+", "+-n.height/2+")"),s.insert("rect",":first-child"),{shapeSvg:e,bbox:n,halfPadding:a,label:s}},"insertLabel"),dt=p((e,t,r)=>{if(r){e.width=r.width,e.height=r.height;return}const i=t.node().getBBox();e.width=i.width,e.height=i.height},"updateNodeBounds"),Ct=p((e,t)=>(e.look==="handDrawn"?"rough-node":"node")+" "+e.cssClasses+" "+(t||""),"getNodeClasses");function Nt(e){const t=e.map((r,i)=>`${i===0?"M":"L"}${r.x},${r.y}`);return t.push("Z"),t.join(" ")}p(Nt,"createPathFromPoints");function Yr(e,t,r,i,s,o){const a=[],l=r-e,c=i-t,h=l/o,u=2*Math.PI/h,d=t+c/2;for(let f=0;f<=50;f++){const m=f/50,y=e+m*l,x=d+s*Math.sin(u*(y-e));a.push({x:y,y:x})}return a}p(Yr,"generateFullSineWavePoints");function or(e,t,r,i,s,o){const a=[],n=s*Math.PI/180,h=(o*Math.PI/180-n)/(i-1);for(let u=0;ul.tagName==="path"),r=document.createElementNS("http://www.w3.org/2000/svg","path"),i=t.map(l=>l.getAttribute("d")).filter(l=>l!==null).join(" ");r.setAttribute("d",i);const s=t.find(l=>l.getAttribute("fill")!=="none"),o=t.find(l=>l.getAttribute("stroke")!=="none"),a=p((l,c)=>l?.getAttribute(c)??void 0,"getAttr");if(s){const l={fill:a(s,"fill"),"fill-opacity":a(s,"fill-opacity")??"1"};Object.entries(l).forEach(([c,h])=>{h&&r.setAttribute(c,h)})}if(o){const l={stroke:a(o,"stroke"),"stroke-width":a(o,"stroke-width")??"1","stroke-opacity":a(o,"stroke-opacity")??"1"};Object.entries(l).forEach(([c,h])=>{h&&r.setAttribute(c,h)})}const n=document.createElementNS("http://www.w3.org/2000/svg","g");return n.appendChild(r),n}p(Jn,"mergePaths");var F_=p((e,t)=>{var r=e.x,i=e.y,s=t.x-r,o=t.y-i,a=e.width/2,n=e.height/2,l,c;return Math.abs(o)*a>Math.abs(s)*n?(o<0&&(n=-n),l=o===0?0:n*s/o,c=n):(s<0&&(a=-a),l=a,c=s===0?0:a*o/s),{x:r+l,y:i+c}},"intersectRect"),di=F_,He=p((e,t,r,i,s)=>["M",e+s,t,"H",e+r-s,"A",s,s,0,0,1,e+r,t+s,"V",t+i-s,"A",s,s,0,0,1,e+r-s,t+i,"H",e+s,"A",s,s,0,0,1,e,t+i-s,"V",t+s,"A",s,s,0,0,1,e+s,t,"Z"].join(" "),"createRoundedRectPathD"),A_=p(async(e,t,r,i=!1,s=!1)=>{let o=t||"";typeof o=="object"&&(o=o[0]);const a=It(),n=be(a);return await Qe(e,o,{style:r,isTitle:i,useHtmlLabels:n,markdown:!1,isNode:s,width:Number.POSITIVE_INFINITY},a)},"createLabel"),Rr=A_;function rg(e,t){return e.intersect(t)}p(rg,"intersectNode");var E_=rg;function ig(e,t,r,i){var s=e.x,o=e.y,a=s-i.x,n=o-i.y,l=Math.sqrt(t*t*n*n+r*r*a*a),c=Math.abs(t*r*a/l);i.x0}p(tl,"sameSign");var $_=ag;function ng(e,t,r){let i=e.x,s=e.y,o=[],a=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY;typeof t.forEach=="function"?t.forEach(function(h){a=Math.min(a,h.x),n=Math.min(n,h.y)}):(a=Math.min(a,t.x),n=Math.min(n,t.y));let l=i-e.width/2-a,c=s-e.height/2-n;for(let h=0;h1&&o.sort(function(h,u){let d=h.x-r.x,f=h.y-r.y,m=Math.sqrt(d*d+f*f),y=u.x-r.x,x=u.y-r.y,C=Math.sqrt(y*y+x*x);return mh,":first-child");return u.attr("class","anchor").attr("style",re(n)),dt(t,u),t.intersect=function(d){return R.info("Circle intersect",t,a,d),at.circle(t,a,d)},o}p(lg,"anchor");function el(e,t,r,i,s,o,a){const l=(e+r)/2,c=(t+i)/2,h=Math.atan2(i-t,r-e),u=(r-e)/2,d=(i-t)/2,f=u/s,m=d/o,y=Math.sqrt(f**2+m**2);if(y>1)throw new Error("The given radii are too small to create an arc between the points.");const x=Math.sqrt(1-y**2),C=l+x*o*Math.sin(h)*(a?-1:1),k=c-x*s*Math.cos(h)*(a?-1:1),T=Math.atan2((t-k)/o,(e-C)/s);let v=Math.atan2((i-k)/o,(r-C)/s)-T;a&&v<0&&(v+=2*Math.PI),!a&&v>0&&(v-=2*Math.PI);const A=[];for(let L=0;L<20;L++){const F=L/19,Z=T+F*v,U=C+s*Math.cos(Z),N=k+o*Math.sin(Z);A.push({x:U,y:N})}return A}p(el,"generateArcPoints");function hg(e,t,r){const[i,s]=[t,r].sort((o,a)=>a-o);return s*(1-Math.sqrt(1-(e/i/2)**2))}p(hg,"calculateArcSagitta");async function cg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s,n=p(Z=>Z+a,"calcTotalHeight"),l=p(Z=>{const U=Z/2;return[U/(2.5+Z/50),U]},"calcEllipseRadius"),{shapeSvg:c,bbox:h}=await xt(e,t,Ct(t)),u=n(t?.height?t?.height:h.height),[d,f]=l(u),m=hg(u,d,f),x=(t?.width?t?.width:h.width)+o*2+m-m,C=u,{cssStyles:k}=t,T=[{x:x/2,y:-C/2},{x:-x/2,y:-C/2},...el(-x/2,-C/2,-x/2,C/2,d,f,!1),{x:x/2,y:C/2},...el(x/2,C/2,x/2,-C/2,d,f,!0)],S=ct.svg(c),v=lt(t,{});t.look!=="handDrawn"&&(v.roughness=0,v.fillStyle="solid");const A=Nt(T),L=S.path(A,v),F=c.insert(()=>L,":first-child");return F.attr("class","basic label-container outer-path"),k&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",k),i&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",i),F.attr("transform",`translate(${d/2}, 0)`),dt(t,F),t.intersect=function(Z){return at.polygon(t,T,Z)},c}p(cg,"bowTieRect");async function ug(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{shapeSvg:o,bbox:a,label:n}=await xt(e,t,Ct(t)),l=r?.nodeBorder??r?.lineColor??"currentColor",c=t.padding??12,h=Math.max(a.width+c*2,t.width??0,80),u=Math.max(Math.min(h*.08,12),5),d=Math.max(a.height+c*2+u,t.height??0),f=-d/2+u,m=d/2,y=h*.72,x=[`M${-h/2},${f}`,`L${-y/2},${m}`,`A${y/2},${u} 0 0 0 ${y/2},${m}`,`L${h/2},${f}`,`A${h/2},${u} 0 0 0 ${-h/2},${f}`,"Z"].join(" "),{cssStyles:C}=t,k=o.insert("g",":first-child").attr("class","basic label-container");if(t.look==="handDrawn"){const F=ct.svg(o).path(x,lt(t,{}));k.node()?.appendChild(F),C&&k.attr("style",C)}else k.append("path").attr("d",x).attr("style",s);k.append("ellipse").attr("cx",0).attr("cy",f).attr("rx",h/2).attr("ry",u).attr("style",`fill:none;stroke:${l};stroke-width:1px`),dt(t,k);const T=f+(m-f)/2;n.attr("transform",`translate(${-(a.width/2)-(a.x-(a.left??0))}, ${T-a.height/2-(a.y-(a.top??0))})`);const S=12,v=p((L,F,Z)=>Array.from({length:S+1},(U,N)=>{const st=Math.PI-N*Math.PI/S;return{x:L*Math.cos(st),y:F+Z*u*Math.sin(st)}}),"arc"),A=[...v(h/2,f,-1),...v(y/2,m,1).reverse()];return t.intersect=function(L){return at.polygon(t,A,L)},o}p(ug,"bucket");var uu=20,du=8,D_=80,Ha=8;async function dg(e,t){const{themeVariables:r}=It(),i=r.clusterBkg,s=r.clusterBorder,{nodeStyles:o}=ft(t),{shapeSvg:a,bbox:n}=await xt(e,t,Ct(t)),l=t.padding??8,c=n.height,h=Math.max(n.width+l*2,D_,t?.width??0),u=Math.max(c+du+uu+l*2,t?.height??0),d=-h/2,f=-u/2,m=-28/2,y=a.select(".label");y&&(t.useHtmlLabels??be(It())?y.attr("transform",`translate(${-n.width/2}, ${-n.height/2+m})`):y.attr("transform",`translate(0, ${-n.height/2+m})`));let x;if(t.look==="handDrawn"){const v=ct.svg(a),A=lt(t,{fill:i,stroke:s,fillStyle:"solid"}),L=v.path(He(d,f,h,u,Ha),A);x=a.insert(()=>L,":first-child"),x.attr("class","basic label-container collapsed-group").attr("style",re(t.cssStyles))}else x=a.insert("rect",":first-child"),x.attr("class","basic label-container collapsed-group").attr("style",o).attr("rx",Ha).attr("ry",Ha).attr("x",d).attr("y",f).attr("width",h).attr("height",u).attr("fill",i).attr("stroke",s);const C=f+l+c+du;a.append("line").attr("class","collapsed-separator").attr("x1",d+8).attr("y1",C).attr("x2",d+h-8).attr("y2",C).attr("stroke",s).attr("stroke-dasharray","3, 3");const k=C+uu/2,T=2.5,S=10;for(let v=-1;v<=1;v++)a.append("circle").attr("class","collapsed-indicator").attr("cx",v*S).attr("cy",k).attr("r",T).attr("fill",s);return dt(t,x),t.calcIntersect=function(v,A){return at.rect(v,A)},t.intersect=function(v){return at.rect(t,v)},a}p(dg,"collapsedGroup");function fr(e,t,r,i){return e.insert("polygon",":first-child").attr("points",i.map(function(s){return s.x+","+s.y}).join(" ")).attr("class","label-container").attr("transform","translate("+-t/2+","+r/2+")")}p(fr,"insertPolygonShape");var I_=["right","left","up","down"],ih="point",P_=p(e=>{const t=new Set;for(const r of e)switch(r){case"x":t.add("right"),t.add("left");break;case"y":t.add("up"),t.add("down");break;default:t.add(r);break}return t},"expandAndDeduplicateDirections"),R_=p(e=>I_.filter(t=>e.has(t)).join("|")||ih,"getDirectionKey"),fu={"right|left|up|down":p(({height:e,midpoint:t,padding:r,width:i})=>[{x:0,y:0},{x:t,y:0},{x:i/2,y:2*r},{x:i-t,y:0},{x:i,y:0},{x:i,y:-e/3},{x:i+2*r,y:-e/2},{x:i,y:-2*e/3},{x:i,y:-e},{x:i-t,y:-e},{x:i/2,y:-e-2*r},{x:t,y:-e},{x:0,y:-e},{x:0,y:-2*e/3},{x:-2*r,y:-e/2},{x:0,y:-e/3}],"right|left|up|down"),"right|left|up":p(({height:e,midpoint:t,width:r})=>[{x:t,y:0},{x:r-t,y:0},{x:r,y:-e/2},{x:r-t,y:-e},{x:t,y:-e},{x:0,y:-e/2}],"right|left|up"),"right|left|down":p(({height:e,midpoint:t,width:r})=>[{x:0,y:0},{x:t,y:-e},{x:r-t,y:-e},{x:r,y:0}],"right|left|down"),"right|up|down":p(({height:e,midpoint:t,width:r})=>[{x:0,y:0},{x:r,y:-t},{x:r,y:-e+t},{x:0,y:-e}],"right|up|down"),"left|up|down":p(({height:e,midpoint:t,width:r})=>[{x:r,y:0},{x:0,y:-t},{x:0,y:-e+t},{x:r,y:-e}],"left|up|down"),"right|left":p(({height:e,midpoint:t,padding:r,width:i})=>[{x:t,y:0},{x:t,y:-r},{x:i-t,y:-r},{x:i-t,y:0},{x:i,y:-e/2},{x:i-t,y:-e},{x:i-t,y:-e+r},{x:t,y:-e+r},{x:t,y:-e},{x:0,y:-e/2}],"right|left"),"up|down":p(({height:e,midpoint:t,padding:r,width:i})=>[{x:i/2,y:0},{x:0,y:-r},{x:t,y:-r},{x:t,y:-e+r},{x:0,y:-e+r},{x:i/2,y:-e},{x:i,y:-e+r},{x:i-t,y:-e+r},{x:i-t,y:-r},{x:i,y:-r}],"up|down"),"right|up":p(({height:e,midpoint:t,width:r})=>[{x:0,y:0},{x:r,y:-t},{x:0,y:-e}],"right|up"),"right|down":p(({height:e,width:t})=>[{x:0,y:0},{x:t,y:0},{x:0,y:-e}],"right|down"),"left|up":p(({height:e,midpoint:t,width:r})=>[{x:r,y:0},{x:0,y:-t},{x:r,y:-e}],"left|up"),"left|down":p(({height:e,width:t})=>[{x:t,y:0},{x:0,y:0},{x:t,y:-e}],"left|down"),right:p(({height:e,midpoint:t,padding:r,width:i})=>[{x:t,y:-r},{x:t,y:-r},{x:i-t,y:-r},{x:i-t,y:0},{x:i,y:-e/2},{x:i-t,y:-e},{x:i-t,y:-e+r},{x:t,y:-e+r},{x:t,y:-e+r}],"right"),left:p(({height:e,midpoint:t,padding:r,width:i})=>[{x:t,y:0},{x:t,y:-r},{x:i-t,y:-r},{x:i-t,y:-e+r},{x:t,y:-e+r},{x:t,y:-e},{x:0,y:-e/2}],"left"),up:p(({height:e,midpoint:t,padding:r,width:i})=>[{x:t,y:-r},{x:t,y:-e+r},{x:0,y:-e+r},{x:i/2,y:-e},{x:i,y:-e+r},{x:i-t,y:-e+r},{x:i-t,y:-r}],"up"),down:p(({height:e,midpoint:t,padding:r,width:i})=>[{x:i/2,y:0},{x:0,y:-r},{x:t,y:-r},{x:t,y:-e+r},{x:i-t,y:-e+r},{x:i-t,y:-r},{x:i,y:-r}],"down"),[ih]:()=>[{x:0,y:0}]},N_=p((e,t,r,i)=>{const s=P_(e),o=(r.padding??0)/2,a=t.height+4*o,n=a/2,l=i??t.width+2*n+2*o,c=R_(s);return(fu[c]??fu[ih])({height:a,midpoint:n,padding:o,width:l})},"getArrowPoints");async function fg(e,t){const r=t,{shapeSvg:i,bbox:s}=await xt(e,r,Ct(r)),o=r.padding??0,a=s.height+2*o,n=a/2,l=s.width+2*n+o,c=r.width??0,u=r.positioned&&(r.widthInColumns??1)>1&&c>l?c:l,d=N_(r.directions??[],s,r,u),f=fr(i,u,a,d);return f.attr("style",r.style??null),dt(r,f),r.intersect=function(m){return at.polygon(r,d,m)},i}p(fg,"block_arrow");async function pg(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{shapeSvg:o,bbox:a,label:n}=await xt(e,t,Ct(t)),l=r?.nodeBorder??r?.lineColor??"currentColor",c=t.padding??12,h=18,u=12,d=Math.max(a.width+c*2,t.width??0,90),f=Math.max(a.height+c*2+h,t.height??0),m=-f/2,{cssStyles:y}=t,x=o.insert("g",":first-child").attr("class","basic label-container");if(t.look==="handDrawn"){const T=ct.svg(o).path(He(-d/2,m,d,f,u),lt(t,{}));x.node()?.appendChild(T),y&&x.attr("style",y)}else x.append("rect").attr("x",-d/2).attr("y",m).attr("width",d).attr("height",f).attr("rx",u).attr("ry",u).attr("style",s);x.append("line").attr("x1",-d/2).attr("y1",m+h).attr("x2",d/2).attr("y2",m+h).attr("style",`stroke:${l};stroke-width:1px`);for(let k=0;k<3;k++)x.append("circle").attr("cx",-d/2+12+k*9).attr("cy",m+h/2).attr("r",2.5).attr("style",`fill:${l};stroke:none`);x.append("rect").attr("class","browser-address-bar").attr("x",-d/2+44).attr("y",m+4).attr("width",Math.max(d-56,10)).attr("height",h-8).attr("rx",3).attr("ry",3).attr("style",`fill:none;stroke:${l};stroke-width:1px;opacity:0.6`),dt(t,x);const C=m+h+(f-h)/2;return n.attr("transform",`translate(${-(a.width/2)-(a.x-(a.left??0))}, ${C-a.height/2-(a.y-(a.top??0))})`),t.intersect=function(k){return at.rect(t,k)},o}p(pg,"browser");var ro=12;async function gg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?28:s,a=t.look==="neo"?24:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=(t?.width??l.width)+(t.look==="neo"?o*2:o+ro),h=(t?.height??l.height)+(t.look==="neo"?a*2:a),u=0,d=c,f=-h,m=0,y=[{x:u+ro,y:f},{x:d,y:f},{x:d,y:m},{x:u,y:m},{x:u,y:f+ro},{x:u+ro,y:f}];let x;const{cssStyles:C}=t;if(t.look==="handDrawn"){const k=ct.svg(n),T=lt(t,{}),S=Nt(y),v=k.path(S,T);x=n.insert(()=>v,":first-child").attr("transform",`translate(${-c/2}, ${h/2})`),C&&x.attr("style",C)}else x=fr(n,c,h,y);return i&&x.attr("style",i),dt(t,x),t.intersect=function(k){return at.polygon(t,y,k)},n}p(gg,"card");function mg(e,t){const{nodeStyles:r}=ft(t);t.label="";const i=e.insert("g").attr("class",Ct(t)).attr("id",t.domId??t.id),{cssStyles:s}=t,o=Math.max(28,t.width??0),a=[{x:0,y:o/2},{x:o/2,y:0},{x:0,y:-o/2},{x:-o/2,y:0}],n=ct.svg(i),l=lt(t,{});t.look!=="handDrawn"&&(l.roughness=0,l.fillStyle="solid");const c=Nt(a),h=n.path(c,l),u=i.insert(()=>h,":first-child");return s&&t.look!=="handDrawn"&&u.selectAll("path").attr("style",s),r&&t.look!=="handDrawn"&&u.selectAll("path").attr("style",r),t.width=28,t.height=28,t.intersect=function(d){return at.polygon(t,a,d)},i}p(mg,"choice");async function sh(e,t,r){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{shapeSvg:o,bbox:a,halfPadding:n}=await xt(e,t,Ct(t)),l=16,c=r?.padding??n,h=t.look==="neo"?a.width/2+l*2:a.width/2+c;let u;const{cssStyles:d}=t;if(t.look==="handDrawn"){const f=ct.svg(o),m=lt(t,{}),y=f.circle(0,0,h*2,m);u=o.insert(()=>y,":first-child"),u.attr("class","basic label-container").attr("style",re(d))}else u=o.insert("circle",":first-child").attr("class","basic label-container").attr("style",s).attr("r",h).attr("cx",0).attr("cy",0);return dt(t,u),t.calcIntersect=function(f,m){const y=f.width/2;return at.circle(f,y,m)},t.intersect=function(f){return R.info("Circle intersect",t,h,f),at.circle(t,h,f)},o}p(sh,"circle");async function yg(e,t){const r=t,i=["node",r.cssClasses,r.class].filter(Boolean).join(" "),{shapeSvg:s,bbox:o,halfPadding:a}=await xt(e,r,i),n=s.insert("rect",":first-child"),l=r.padding??0,c=r.positioned?r.width??0:o.width+l,h=r.positioned?r.height??0:o.height+l,u=r.positioned?-c/2:-o.width/2-a,d=r.positioned?-h/2:-o.height/2-a;return n.attr("class","basic cluster composite label-container").attr("style",r.style??null).attr("rx",r.rx??null).attr("ry",r.ry??null).attr("x",u).attr("y",d).attr("width",c).attr("height",h),dt(r,n),r.intersect=function(f){return at.rect(r,f)},s}p(yg,"composite");async function xg(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{shapeSvg:o,bbox:a,label:n}=await xt(e,t,Ct(t)),l=r?.nodeBorder??r?.lineColor??"currentColor",c=t.padding??12,h=20,u=12,d=Math.max(a.width+c*2,t.width??0,90),f=Math.max(a.height+c*2+h,t.height??0),m=-f/2,{cssStyles:y}=t,x=o.insert("g",":first-child").attr("class","basic label-container");if(t.look==="handDrawn"){const T=ct.svg(o).path(He(-d/2,m,d,f,u),lt(t,{}));x.node()?.appendChild(T),y&&x.attr("style",y)}else x.append("rect").attr("x",-d/2).attr("y",m).attr("width",d).attr("height",f).attr("rx",u).attr("ry",u).attr("style",s);x.append("text").attr("x",-d/2+12).attr("y",m+16).attr("class","console-glyph").attr("style",`font-family:monospace;font-weight:bold;font-size:14px;fill:${l}`).text(">_"),dt(t,x);const C=m+h+(f-h)/2;return n.attr("transform",`translate(${-(a.width/2)-(a.x-(a.left??0))}, ${C-a.height/2-(a.y-(a.top??0))})`),t.intersect=function(k){return at.rect(t,k)},o}p(xg,"consoleWindow");function Cg(e){const t=Math.cos(Math.PI/4),r=Math.sin(Math.PI/4),i=e*2,s={x:i/2*t,y:i/2*r},o={x:-(i/2)*t,y:i/2*r},a={x:-(i/2)*t,y:-(i/2)*r},n={x:i/2*t,y:-(i/2)*r};return`M ${o.x},${o.y} L ${n.x},${n.y} + M ${s.x},${s.y} L ${a.x},${a.y}`}p(Cg,"createLine");function bg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r,t.label="";const s=e.insert("g").attr("class",Ct(t)).attr("id",t.domId??t.id),o=Math.max(30,t?.width??0),{cssStyles:a}=t,n=ct.svg(s),l=lt(t,{});t.look!=="handDrawn"&&(l.roughness=0,l.fillStyle="solid");const c=n.circle(0,0,o*2,l),h=Cg(o),u=n.path(h,l),d=s.insert(()=>c,":first-child");return d.insert(()=>u),d.attr("class","outer-path"),a&&t.look!=="handDrawn"&&d.selectAll("path").attr("style",a),i&&t.look!=="handDrawn"&&d.selectAll("path").attr("style",i),dt(t,d),t.intersect=function(f){return R.info("crossedCircle intersect",t,{radius:o,point:f}),at.circle(t,o,f)},s}p(bg,"crossedCircle");function br(e,t,r,i=100,s=0,o=180){const a=[],n=s*Math.PI/180,h=(o*Math.PI/180-n)/(i-1);for(let u=0;uv,":first-child").attr("stroke-opacity",0),A.insert(()=>T,":first-child"),A.attr("class","text"),d&&t.look!=="handDrawn"&&A.selectAll("path").attr("style",d),i&&t.look!=="handDrawn"&&A.selectAll("path").attr("style",i),A.attr("transform",`translate(${u}, 0)`),a.attr("transform",`translate(${-c/2+u-(o.x-(o.left??0))},${-h/2+(t.padding??0)/2-(o.y-(o.top??0))})`),dt(t,A),t.intersect=function(L){return at.polygon(t,m,L)},s}p(kg,"curlyBraceLeft");function kr(e,t,r,i=100,s=0,o=180){const a=[],n=s*Math.PI/180,h=(o*Math.PI/180-n)/(i-1);for(let u=0;uv,":first-child").attr("stroke-opacity",0),A.insert(()=>T,":first-child"),A.attr("class","text"),d&&t.look!=="handDrawn"&&A.selectAll("path").attr("style",d),i&&t.look!=="handDrawn"&&A.selectAll("path").attr("style",i),A.attr("transform",`translate(${-u}, 0)`),a.attr("transform",`translate(${-c/2+(t.padding??0)/2-(o.x-(o.left??0))},${-h/2+(t.padding??0)/2-(o.y-(o.top??0))})`),dt(t,A),t.intersect=function(L){return at.polygon(t,m,L)},s}p(wg,"curlyBraceRight");function he(e,t,r,i=100,s=0,o=180){const a=[],n=s*Math.PI/180,h=(o*Math.PI/180-n)/(i-1);for(let u=0;uZ,":first-child").attr("stroke-opacity",0),U.insert(()=>S,":first-child"),U.insert(()=>L,":first-child"),U.attr("class","text"),d&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",d),i&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",i),U.attr("transform",`translate(${u-u/4}, 0)`),a.attr("transform",`translate(${-c/2+(t.padding??0)/2-(o.x-(o.left??0))},${-h/2+(t.padding??0)/2-(o.y-(o.top??0))})`),dt(t,U),t.intersect=function(N){return at.polygon(t,y,N)},s}p(Tg,"curlyBraces");async function _g(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s,n=20,l=5,{shapeSvg:c,bbox:h}=await xt(e,t,Ct(t)),u=Math.max(n,(h.width+o*2)*1.25,t?.width??0),d=Math.max(l,h.height+a*2,t?.height??0),f=d/2,{cssStyles:m}=t,y=ct.svg(c),x=lt(t,{});t.look!=="handDrawn"&&(x.roughness=0,x.fillStyle="solid");const C=u,k=d,T=C-f,S=k/4,v=[{x:T,y:0},{x:S,y:0},{x:0,y:k/2},{x:S,y:k},{x:T,y:k},...or(-T,-k/2,f,50,270,90)],A=Nt(v),L=y.path(A,x),F=c.insert(()=>L,":first-child");return F.attr("class","basic label-container outer-path"),m&&t.look!=="handDrawn"&&F.selectChildren("path").attr("style",m),i&&t.look!=="handDrawn"&&F.selectChildren("path").attr("style",i),F.attr("transform",`translate(${-u/2}, ${-d/2})`),dt(t,F),t.intersect=function(Z){return at.polygon(t,v,Z)},c}p(_g,"curvedTrapezoid");async function Sg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,label:a}=await xt(e,t,Ct(t)),n=t.padding??20,l=Math.max(o.width+n*2,t.width??0,100),c=Math.min(Math.max(l*.23,16),56),h=c*.27,u=Math.max(o.height+n*2,t.height?t.height-(2*c-h):0),d=Math.min(l*.177,u*.45),f=u+2*c-h,m=-f/2,y=m+2*c-h,x=s.insert("g",":first-child").attr("class","basic label-container"),{cssStyles:C}=t;if(t.look==="handDrawn"){const F=ct.svg(s),Z=lt(t,{}),U=F.path(He(-l/2,y,l,u,d),Z),N=F.circle(0,m+c,c*2,Z);x.insert(()=>N,":first-child"),x.insert(()=>U,":first-child"),C&&x.attr("style",C)}else x.append("rect").attr("x",-l/2).attr("y",y).attr("width",l).attr("height",u).attr("rx",d).attr("ry",d).attr("style",i),x.append("circle").attr("cx",0).attr("cy",m+c).attr("r",c).attr("style",i);dt(t,x);const k=y+u/2;a.attr("transform",`translate(${-(o.width/2)-(o.x-(o.left??0))}, ${k-o.height/2-(o.y-(o.top??0))})`);const T=m+c,S=Math.asin(Math.min(1,(y-T)/c))*180/Math.PI,L=[...or(0,-T,c,24,180+S,-S),...or(-(-l/2+d),-(y+d),d,12,90,0),...or(-(-l/2+d),-(f/2-d),d,12,360,270),...or(-(l/2-d),-(f/2-d),d,12,270,180),...or(-(l/2-d),-(y+d),d,12,180,90)];return t.intersect=function(F){return at.polygon(t,L,F)},s}p(Sg,"person");var q_=p((e,t,r,i,s,o)=>[`M${e},${t+o}`,`a${s},${o} 0,0,0 ${r},0`,`a${s},${o} 0,0,0 ${-r},0`,`l0,${i}`,`a${s},${o} 0,0,0 ${r},0`,`l0,${-i}`].join(" "),"createCylinderPathD"),z_=p((e,t,r,i,s,o)=>[`M${e},${t+o}`,`M${e+r},${t+o}`,`a${s},${o} 0,0,0 ${-r},0`,`l0,${i}`,`a${s},${o} 0,0,0 ${r},0`,`l0,${-i}`].join(" "),"createOuterCylinderPathD"),W_=p((e,t,r,i,s,o)=>[`M${e-r/2},${-i/2}`,`a${s},${o} 0,0,0 ${r},0`].join(" "),"createInnerCylinderPathD"),pu=8,gu=8;async function vg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?24:s,a=t.look==="neo"?24:s,n=t.width??0;if(t.width&&(t.width=t.width-a,t.widthA,":first-child"),y=l.insert(()=>v,":first-child"),y.attr("class","basic label-container"),x&&y.attr("style",x)}else{const C=q_(0,0,u,m,d,f);y=l.insert("path",":first-child").attr("d",C).attr("class","basic label-container outer-path").attr("style",re(x)).attr("style",i)}return y.attr("label-offset-y",f),y.attr("transform",`translate(${-u/2}, ${-(m/2+f)})`),dt(t,y),h.attr("transform",`translate(${-(c.width/2)-(c.x-(c.left??0))}, ${-(c.height/2)+(t.padding??0)/1.5-(c.y-(c.top??0))})`),t.intersect=function(C){const k=at.rect(t,C),T=k.x-(t.x??0);if(d!=0&&(Math.abs(T)<(t.width??0)/2||Math.abs(T)==(t.width??0)/2&&Math.abs(k.y-(t.y??0))>(t.height??0)/2-f)){let S=f*f*(1-T*T/(d*d));S>0&&(S=Math.sqrt(S)),S=f-S,C.y-(t.y??0)>0&&(S=-S),k.y+=S}return k},l}p(vg,"cylinder");async function zi(e,t,r){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{shapeSvg:o,bbox:a}=await xt(e,t,Ct(t)),n=Math.max(a.width+r.labelPaddingX*2,t?.width||0),l=Math.max(a.height+r.labelPaddingY*2,t?.height||0),c=-n/2,h=-l/2;let u,{rx:d,ry:f}=t;const{cssStyles:m}=t;if(r?.rx&&r.ry&&(d=r.rx,f=r.ry),t.look==="handDrawn"){const y=ct.svg(o),x=lt(t,{}),C=d||f?y.path(He(c,h,n,l,d||0),x):y.rectangle(c,h,n,l,x);u=o.insert(()=>C,":first-child"),u.attr("class","basic label-container").attr("style",re(m))}else u=o.insert("rect",":first-child"),u.attr("class","basic label-container").attr("style",s).attr("rx",re(d)).attr("ry",re(f)).attr("x",c).attr("y",h).attr("width",n).attr("height",l);return dt(t,u,t.look==="handDrawn"?void 0:{width:n,height:l}),t.calcIntersect=function(y,x){return at.rect(y,x)},t.intersect=function(y){return at.rect(t,y)},o}p(zi,"drawRect");async function Bg(e,t){const{cssClasses:r,labelPaddingX:i,labelPaddingY:s,padding:o,width:a,height:n}=t,l={rx:0,ry:0,labelPaddingX:i??(o??0)*2,labelPaddingY:s??o??0},c=await zi(e,t,l);if(t.look==="handDrawn"){const f=ct.svg(c),m=lt(t,{}),y=c.select(".basic.label-container > path:nth-child(2)"),x=y.node();if(!x)return c;let C=null;if(x instanceof SVGGraphicsElement)C=x.getBBox();else return c;return c.insert(()=>f.line(C.x,C.y,C.x+C.width,C.y,m),".basic.label-container g.label"),c.insert(()=>f.line(C.x,C.y+C.height,C.x+C.width,C.y+C.height,m),".basic.label-container g.label"),y.remove(),c}const h=c.select(".basic.label-container"),u=(Number(h.attr("width"))||a)??0,d=(Number(h.attr("height"))||n)??0;return u>0&&d>0&&h.attr("stroke-dasharray",`${u} ${d}`),c}p(Bg,"datastore");async function Lg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.look==="neo"?16:t.padding??0,o=t.look==="neo"?16:t.padding??0,{shapeSvg:a,bbox:n,label:l}=await xt(e,t,Ct(t)),c=n.width+s,h=n.height+o,u=h*.2,d=-c/2,f=-h/2-u/2,{cssStyles:m}=t,y=ct.svg(a),x=lt(t,{});t.look!=="handDrawn"&&(x.roughness=0,x.fillStyle="solid");const C=[{x:d,y:f+u},{x:-d,y:f+u},{x:-d,y:-f},{x:d,y:-f},{x:d,y:f},{x:-d,y:f},{x:-d,y:f+u}],k=y.polygon(C.map(S=>[S.x,S.y]),x),T=a.insert(()=>k,":first-child");return T.attr("class","basic label-container outer-path"),m&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",m),i&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",i),l.attr("transform",`translate(${d+(t.padding??0)/2-(n.x-(n.left??0))}, ${f+u+(t.padding??0)/2-(n.y-(n.top??0))})`),dt(t,T),t.intersect=function(S){return at.rect(t,S)},a}p(Lg,"dividedRectangle");async function Fg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t),s=t.look==="neo"?12:5;t.labelStyle=r;const o=t.padding??0,a=t.look==="neo"?16:o,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=(t?.width?t?.width/2:l.width/2)+(a??0),h=c-s;let u;const{cssStyles:d}=t;if(t.look==="handDrawn"){const f=ct.svg(n),m=lt(t,{roughness:.2,strokeWidth:2.5}),y=lt(t,{roughness:.2,strokeWidth:1.5}),x=f.circle(0,0,c*2,m),C=f.circle(0,0,h*2,y);u=n.insert("g",":first-child"),u.attr("class",re(t.cssClasses)).attr("style",re(d)),u.node()?.appendChild(x),u.node()?.appendChild(C)}else{u=n.insert("g",":first-child");const f=u.insert("circle",":first-child"),m=u.insert("circle");u.attr("class","basic label-container").attr("style",i),f.attr("class","outer-circle").attr("style",i).attr("r",c).attr("cx",0).attr("cy",0),m.attr("class","inner-circle").attr("style",i).attr("r",h).attr("cx",0).attr("cy",0)}return dt(t,u),t.intersect=function(f){return R.info("DoubleCircle intersect",t,c,f),at.circle(t,c,f)},n}p(Fg,"doublecircle");function Ag(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.label="",t.labelStyle=i;const o=e.insert("g").attr("class",Ct(t)).attr("id",t.domId??t.id),a=7,{cssStyles:n}=t,l=ct.svg(o),{nodeBorder:c}=r,h=lt(t,{fillStyle:"solid"});t.look!=="handDrawn"&&(h.roughness=0);const u=l.circle(0,0,a*2,h),d=o.insert(()=>u,":first-child");return d.selectAll("path").attr("style",`fill: ${c} !important;`),n&&n.length>0&&t.look!=="handDrawn"&&d.selectAll("path").attr("style",n),s&&t.look!=="handDrawn"&&d.selectAll("path").attr("style",s),dt(t,d),t.intersect=function(f){return R.info("filledCircle intersect",t,{radius:a,point:f}),at.circle(t,a,f)},o}p(Ag,"filledCircle");var mu=10,yu=10;async function Eg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?s*2:s;(t.width||t.height)&&(t.height=t?.height??0,t.heightC,":first-child").attr("transform",`translate(${-h/2}, ${h/2})`).attr("class","outer-path");return f&&t.look!=="handDrawn"&&k.selectChildren("path").attr("style",f),i&&t.look!=="handDrawn"&&k.selectChildren("path").attr("style",i),t.width=c,t.height=h,dt(t,k),l.attr("transform",`translate(${-n.width/2-(n.x-(n.left??0))}, ${-h/2+(t.padding??0)/2+(n.y-(n.top??0))})`),t.intersect=function(T){return R.info("Triangle intersect",t,d,T),at.polygon(t,d,T)},a}p(Eg,"flippedTriangle");async function Mg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,label:a}=await xt(e,t,Ct(t)),n=t.padding??12,l=Math.max(o.width+n*2,t.width??0,90),c=o.height+n*2,h=Math.max(Math.min(c*.16,14),8),u=Math.max(c+h,t.height??0),d=u-h,f=Math.max(l*.38,28),m=-u/2,y=[{x:-l/2,y:m},{x:-l/2+f,y:m},{x:-l/2+f,y:m+h},{x:l/2,y:m+h},{x:l/2,y:u/2},{x:-l/2,y:u/2}],x=[`M${y[0].x},${y[0].y}`,...y.slice(1).map(S=>`L${S.x},${S.y}`),"Z"].join(" "),{cssStyles:C}=t;let k;if(t.look==="handDrawn"){const v=ct.svg(s).path(x,lt(t,{}));k=s.insert(()=>v,":first-child").attr("class","basic label-container"),C&&k.attr("style",C)}else k=s.insert("path",":first-child").attr("d",x).attr("class","basic label-container").attr("style",i);t.look==="handDrawn"?dt(t,k):dt(t,k,{width:l,height:u});const T=m+h+d/2;return a.attr("transform",`translate(${-(o.width/2)-(o.x-(o.left??0))}, ${T-o.height/2-(o.y-(o.top??0))})`),t.intersect=function(S){return at.polygon(t,y,S)},s}p(Mg,"folder");function $g(e,t,{dir:r,config:{state:i,themeVariables:s}}){const{nodeStyles:o}=ft(t);t.label="";const a=e.insert("g").attr("class",Ct(t)).attr("id",t.domId??t.id),{cssStyles:n}=t;let l=Math.max(70,t?.width??0),c=Math.max(10,t?.height??0);r==="LR"&&(l=Math.max(10,t?.width??0),c=Math.max(70,t?.height??0));const h=-1*l/2,u=-1*c/2,d=ct.svg(a),f=lt(t,{stroke:s.lineColor,fill:s.lineColor});t.look!=="handDrawn"&&(f.roughness=0,f.fillStyle="solid");const m=d.rectangle(h,u,l,c,f),y=a.insert(()=>m,":first-child");n&&t.look!=="handDrawn"&&y.selectAll("path").attr("style",n),o&&t.look!=="handDrawn"&&y.selectAll("path").attr("style",o),dt(t,y);const x=i?.padding??0;return t.width&&t.height&&(t.width+=x/2||0,t.height+=x/2||0),t.intersect=function(C){return at.rect(t,C)},a}p($g,"forkJoin");async function Og(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=15,o=10,a=t.look==="neo"?16:t.padding??0,n=t.look==="neo"?12:t.padding??0;(t.width||t.height)&&(t.height=(t?.height??0)-n*2,t.heightk,":first-child");return T.attr("class","basic label-container outer-path"),f&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",f),i&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",i),dt(t,T),t.intersect=function(S){return R.info("Pill intersect",t,{radius:d,point:S}),at.polygon(t,x,S)},l}p(Og,"halfRoundedRectangle");var H_=p((e,t,r,i,s)=>[`M${e+s},${t}`,`L${e+r-s},${t}`,`L${e+r},${t-i/2}`,`L${e+r-s},${t-i}`,`L${e+s},${t-i}`,`L${e},${t-i/2}`,"Z"].join(" "),"createHexagonPathD");async function Dg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t),s=t.look==="neo"?3.5:4;t.labelStyle=r;const o=t.padding??0,a=70,n=32,l=t.look==="neo"?a:o,c=t.look==="neo"?n:o;if(t.width||t.height){const T=(t.height??0)/s;t.width=(t?.width??0)-2*T-c,t.height=(t.height??0)-l}const{shapeSvg:h,bbox:u}=await xt(e,t,Ct(t)),d=(t?.height?t?.height:u.height)+l,f=d/s,m=(t?.width?t?.width:u.width)+2*f+c,y=[{x:f,y:0},{x:m-f,y:0},{x:m,y:-d/2},{x:m-f,y:-d},{x:f,y:-d},{x:0,y:-d/2}];let x;const{cssStyles:C}=t;if(t.look==="handDrawn"){const k=ct.svg(h),T=lt(t,{}),S=H_(0,0,m,d,f),v=k.path(S,T);x=h.insert(()=>v,":first-child").attr("transform",`translate(${-m/2}, ${d/2})`),C&&x.attr("style",C)}else x=fr(h,m,d,y);return i&&x.attr("style",i),t.width=m,t.height=d,dt(t,x),t.intersect=function(k){return at.polygon(t,y,k)},h}p(Dg,"hexagon");async function Ig(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.label="",t.labelStyle=r;const{shapeSvg:s}=await xt(e,t,Ct(t)),o=Math.max(30,t?.width??0),a=Math.max(30,t?.height??0),{cssStyles:n}=t,l=ct.svg(s),c=lt(t,{});t.look!=="handDrawn"&&(c.roughness=0,c.fillStyle="solid");const h=[{x:0,y:0},{x:o,y:0},{x:0,y:a},{x:o,y:a}],u=Nt(h),d=l.path(u,c),f=s.insert(()=>d,":first-child");return f.attr("class","basic label-container outer-path"),n&&t.look!=="handDrawn"&&f.selectChildren("path").attr("style",n),i&&t.look!=="handDrawn"&&f.selectChildren("path").attr("style",i),f.attr("transform",`translate(${-o/2}, ${-a/2})`),dt(t,f),t.intersect=function(m){return R.info("Pill intersect",t,{points:h}),at.polygon(t,h,m)},s}p(Ig,"hourglass");async function Pg(e,t,{config:{themeVariables:r,flowchart:i}}){const{labelStyles:s}=ft(t);t.labelStyle=s;const o=t.assetHeight??48,a=t.assetWidth??48,n=Math.max(o,a),l=i?.wrappingWidth;t.width=Math.max(n,l??0);const{shapeSvg:c,bbox:h,label:u}=await xt(e,t,"icon-shape default"),d=t.pos==="t",f=n,m=n,{nodeBorder:y}=r,{stylesMap:x}=qi(t),C=-m/2,k=-f/2,T=t.label?8:0,S=ct.svg(c),v=lt(t,{stroke:"none",fill:"none"});t.look!=="handDrawn"&&(v.roughness=0,v.fillStyle="solid");const A=S.rectangle(C,k,m,f,v),L=Math.max(m,h.width),F=f+h.height+T,Z=S.rectangle(-L/2,-F/2,L,F,{...v,fill:"transparent",stroke:"none"}),U=c.insert(()=>A,":first-child"),N=c.insert(()=>Z);if(t.icon){const st=c.append("g");st.html(`${await Ns(t.icon,{height:n,width:n,fallbackPrefix:""})}`);const Y=st.node().getBBox(),$=Y.width,I=Y.height,B=Y.x,q=Y.y;st.attr("transform",`translate(${-$/2-B},${d?h.height/2+T/2-I/2-q:-h.height/2-T/2-I/2-q})`),st.attr("style",`color: ${x.get("stroke")??y};`)}return u.attr("transform",`translate(${-h.width/2-(h.x-(h.left??0))},${d?-F/2:F/2-h.height})`),U.attr("transform",`translate(0,${d?h.height/2+T/2:-h.height/2-T/2})`),dt(t,N),t.intersect=function(st){if(R.info("iconSquare intersect",t,st),!t.label)return at.rect(t,st);const Y=t.x??0,$=t.y??0,I=t.height??0;let B=[];return d?B=[{x:Y-h.width/2,y:$-I/2},{x:Y+h.width/2,y:$-I/2},{x:Y+h.width/2,y:$-I/2+h.height+T},{x:Y+m/2,y:$-I/2+h.height+T},{x:Y+m/2,y:$+I/2},{x:Y-m/2,y:$+I/2},{x:Y-m/2,y:$-I/2+h.height+T},{x:Y-h.width/2,y:$-I/2+h.height+T}]:B=[{x:Y-m/2,y:$-I/2},{x:Y+m/2,y:$-I/2},{x:Y+m/2,y:$-I/2+f},{x:Y+h.width/2,y:$-I/2+f},{x:Y+h.width/2/2,y:$+I/2},{x:Y-h.width/2,y:$+I/2},{x:Y-h.width/2,y:$-I/2+f},{x:Y-m/2,y:$-I/2+f}],at.polygon(t,B,st)},c}p(Pg,"icon");async function Rg(e,t,{config:{themeVariables:r,flowchart:i}}){const{labelStyles:s}=ft(t);t.labelStyle=s;const o=t.assetHeight??48,a=t.assetWidth??48,n=Math.max(o,a),l=i?.wrappingWidth;t.width=Math.max(n,l??0);const{shapeSvg:c,bbox:h,label:u}=await xt(e,t,"icon-shape default"),d=20,f=t.label?8:0,m=t.pos==="t",{nodeBorder:y,mainBkg:x}=r,{stylesMap:C}=qi(t),k=ct.svg(c),T=lt(t,{});t.look!=="handDrawn"&&(T.roughness=0,T.fillStyle="solid");const S=C.get("fill");T.stroke=S??x;const v=c.append("g");t.icon&&v.html(`${await Ns(t.icon,{height:n,width:n,fallbackPrefix:""})}`);const A=v.node().getBBox(),L=A.width,F=A.height,Z=A.x,U=A.y,N=Math.max(L,F)*Math.SQRT2+d*2,st=k.circle(0,0,N,T),Y=Math.max(N,h.width),$=N+h.height+f,I=k.rectangle(-Y/2,-$/2,Y,$,{...T,fill:"transparent",stroke:"none"}),B=c.insert(()=>st,":first-child"),q=c.insert(()=>I);return v.attr("transform",`translate(${-L/2-Z},${m?h.height/2+f/2-F/2-U:-h.height/2-f/2-F/2-U})`),v.attr("style",`color: ${C.get("stroke")??y};`),u.attr("transform",`translate(${-h.width/2-(h.x-(h.left??0))},${m?-$/2:$/2-h.height})`),B.attr("transform",`translate(0,${m?h.height/2+f/2:-h.height/2-f/2})`),dt(t,q),t.intersect=function(O){return R.info("iconSquare intersect",t,O),at.rect(t,O)},c}p(Rg,"iconCircle");async function Ng(e,t,{config:{themeVariables:r,flowchart:i}}){const{labelStyles:s}=ft(t);t.labelStyle=s;const o=t.assetHeight??48,a=t.assetWidth??48,n=Math.max(o,a),l=i?.wrappingWidth;t.width=Math.max(n,l??0);const{shapeSvg:c,bbox:h,halfPadding:u,label:d}=await xt(e,t,"icon-shape default"),f=t.pos==="t",m=n+u*2,y=n+u*2,{nodeBorder:x,mainBkg:C}=r,{stylesMap:k}=qi(t),T=-y/2,S=-m/2,v=t.label?8:0,A=ct.svg(c),L=lt(t,{});t.look!=="handDrawn"&&(L.roughness=0,L.fillStyle="solid");const F=k.get("fill");L.stroke=F??C;const Z=A.path(He(T,S,y,m,5),L),U=Math.max(y,h.width),N=m+h.height+v,st=A.rectangle(-U/2,-N/2,U,N,{...L,fill:"transparent",stroke:"none"}),Y=c.insert(()=>Z,":first-child").attr("class","icon-shape2"),$=c.insert(()=>st);if(t.icon){const I=c.append("g");I.html(`${await Ns(t.icon,{height:n,width:n,fallbackPrefix:""})}`);const B=I.node().getBBox(),q=B.width,O=B.height,it=B.x,tt=B.y;I.attr("transform",`translate(${-q/2-it},${f?h.height/2+v/2-O/2-tt:-h.height/2-v/2-O/2-tt})`),I.attr("style",`color: ${k.get("stroke")??x};`)}return d.attr("transform",`translate(${-h.width/2-(h.x-(h.left??0))},${f?-N/2:N/2-h.height})`),Y.attr("transform",`translate(0,${f?h.height/2+v/2:-h.height/2-v/2})`),dt(t,$),t.intersect=function(I){if(R.info("iconSquare intersect",t,I),!t.label)return at.rect(t,I);const B=t.x??0,q=t.y??0,O=t.height??0;let it=[];return f?it=[{x:B-h.width/2,y:q-O/2},{x:B+h.width/2,y:q-O/2},{x:B+h.width/2,y:q-O/2+h.height+v},{x:B+y/2,y:q-O/2+h.height+v},{x:B+y/2,y:q+O/2},{x:B-y/2,y:q+O/2},{x:B-y/2,y:q-O/2+h.height+v},{x:B-h.width/2,y:q-O/2+h.height+v}]:it=[{x:B-y/2,y:q-O/2},{x:B+y/2,y:q-O/2},{x:B+y/2,y:q-O/2+m},{x:B+h.width/2,y:q-O/2+m},{x:B+h.width/2/2,y:q+O/2},{x:B-h.width/2,y:q+O/2},{x:B-h.width/2,y:q-O/2+m},{x:B-y/2,y:q-O/2+m}],at.polygon(t,it,I)},c}p(Ng,"iconRounded");async function qg(e,t,{config:{themeVariables:r,flowchart:i}}){const{labelStyles:s}=ft(t);t.labelStyle=s;const o=t.assetHeight??48,a=t.assetWidth??48,n=Math.max(o,a),l=i?.wrappingWidth;t.width=Math.max(n,l??0);const{shapeSvg:c,bbox:h,halfPadding:u,label:d}=await xt(e,t,"icon-shape default"),f=t.pos==="t",m=n+u*2,y=n+u*2,{nodeBorder:x,mainBkg:C}=r,{stylesMap:k}=qi(t),T=-y/2,S=-m/2,v=t.label?8:0,A=ct.svg(c),L=lt(t,{});t.look!=="handDrawn"&&(L.roughness=0,L.fillStyle="solid");const F=k.get("fill");L.stroke=F??C;const Z=A.path(He(T,S,y,m,.1),L),U=Math.max(y,h.width),N=m+h.height+v,st=A.rectangle(-U/2,-N/2,U,N,{...L,fill:"transparent",stroke:"none"}),Y=c.insert(()=>Z,":first-child"),$=c.insert(()=>st);if(t.icon){const I=c.append("g");I.html(`${await Ns(t.icon,{height:n,width:n,fallbackPrefix:""})}`);const B=I.node().getBBox(),q=B.width,O=B.height,it=B.x,tt=B.y;I.attr("transform",`translate(${-q/2-it},${f?h.height/2+v/2-O/2-tt:-h.height/2-v/2-O/2-tt})`),I.attr("style",`color: ${k.get("stroke")??x};`)}return d.attr("transform",`translate(${-h.width/2-(h.x-(h.left??0))},${f?-N/2:N/2-h.height})`),Y.attr("transform",`translate(0,${f?h.height/2+v/2:-h.height/2-v/2})`),dt(t,$),t.intersect=function(I){if(R.info("iconSquare intersect",t,I),!t.label)return at.rect(t,I);const B=t.x??0,q=t.y??0,O=t.height??0;let it=[];return f?it=[{x:B-h.width/2,y:q-O/2},{x:B+h.width/2,y:q-O/2},{x:B+h.width/2,y:q-O/2+h.height+v},{x:B+y/2,y:q-O/2+h.height+v},{x:B+y/2,y:q+O/2},{x:B-y/2,y:q+O/2},{x:B-y/2,y:q-O/2+h.height+v},{x:B-h.width/2,y:q-O/2+h.height+v}]:it=[{x:B-y/2,y:q-O/2},{x:B+y/2,y:q-O/2},{x:B+y/2,y:q-O/2+m},{x:B+h.width/2,y:q-O/2+m},{x:B+h.width/2/2,y:q+O/2},{x:B-h.width/2,y:q+O/2},{x:B-h.width/2,y:q-O/2+m},{x:B-y/2,y:q-O/2+m}],at.polygon(t,it,I)},c}p(qg,"iconSquare");async function zg(e,t,{config:{flowchart:r}}){const i=new Image;i.src=t?.img??"",await i.decode();const s=Number(i.naturalWidth.toString().replace("px","")),o=Number(i.naturalHeight.toString().replace("px",""));t.imageAspectRatio=s/o;const{labelStyles:a}=ft(t);t.labelStyle=a;const n=r?.wrappingWidth;t.defaultWidth=r?.wrappingWidth;const l=Math.max(t.label?n??0:0,t?.assetWidth??s),c=t.constraint==="on"&&t?.assetHeight?t.assetHeight*t.imageAspectRatio:l,h=t.constraint==="on"?c/t.imageAspectRatio:t?.assetHeight??o;t.width=Math.max(c,n??0);const{shapeSvg:u,bbox:d,label:f}=await xt(e,t,"image-shape default"),m=t.pos==="t",y=-c/2,x=-h/2,C=t.label?8:0,k=ct.svg(u),T=lt(t,{});t.look!=="handDrawn"&&(T.roughness=0,T.fillStyle="solid");const S=k.rectangle(y,x,c,h,T),v=Math.max(c,d.width),A=h+d.height+C,L=k.rectangle(-v/2,-A/2,v,A,{...T,fill:"none",stroke:"none"}),F=u.insert(()=>S,":first-child"),Z=u.insert(()=>L);if(t.img){const U=u.append("image");U.attr("href",t.img),U.attr("width",c),U.attr("height",h),U.attr("preserveAspectRatio","none"),U.attr("transform",`translate(${-c/2},${m?A/2-h:-A/2})`)}return f.attr("transform",`translate(${-d.width/2-(d.x-(d.left??0))},${m?-h/2-d.height/2-C/2:h/2-d.height/2+C/2})`),F.attr("transform",`translate(0,${m?d.height/2+C/2:-d.height/2-C/2})`),dt(t,Z),t.intersect=function(U){if(R.info("iconSquare intersect",t,U),!t.label)return at.rect(t,U);const N=t.x??0,st=t.y??0,Y=t.height??0;let $=[];return m?$=[{x:N-d.width/2,y:st-Y/2},{x:N+d.width/2,y:st-Y/2},{x:N+d.width/2,y:st-Y/2+d.height+C},{x:N+c/2,y:st-Y/2+d.height+C},{x:N+c/2,y:st+Y/2},{x:N-c/2,y:st+Y/2},{x:N-c/2,y:st-Y/2+d.height+C},{x:N-d.width/2,y:st-Y/2+d.height+C}]:$=[{x:N-c/2,y:st-Y/2},{x:N+c/2,y:st-Y/2},{x:N+c/2,y:st-Y/2+h},{x:N+d.width/2,y:st-Y/2+h},{x:N+d.width/2/2,y:st+Y/2},{x:N-d.width/2,y:st+Y/2},{x:N-d.width/2,y:st-Y/2+h},{x:N-c/2,y:st-Y/2+h}],at.polygon(t,$,U)},u}p(zg,"imageSquare");async function Wg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=s,a=t.look==="neo"?s*2:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=Math.max(l.height+o*2,t.height??0),h=Math.max(l.width+a*2,(t.width??0)-c),u=[{x:0,y:0},{x:h,y:0},{x:h+3*c/6,y:-c},{x:-3*c/6,y:-c}];let d;const{cssStyles:f}=t;if(t.look==="handDrawn"){const m=ct.svg(n),y=lt(t,{}),x=Nt(u),C=m.path(x,y);d=n.insert(()=>C,":first-child").attr("transform",`translate(${-h/2}, ${c/2})`),f&&d.attr("style",f)}else d=fr(n,h,c,u);return i&&d.attr("style",i),t.width=h,t.height=c,dt(t,d),t.intersect=function(m){return at.polygon(t,u,m)},n}p(Wg,"inv_trapezoid");async function Hg(e,t){const{shapeSvg:r,bbox:i,label:s}=await xt(e,t,"label"),o=r.insert("rect",":first-child");return o.attr("width",.1).attr("height",.1),r.attr("class","label edgeLabel"),s.attr("transform",`translate(${-(i.width/2)-(i.x-(i.left??0))}, ${-(i.height/2)-(i.y-(i.top??0))})`),dt(t,o),t.intersect=function(l){return at.rect(t,l)},r}p(Hg,"labelRect");async function Yg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=s,a=t.look==="neo"?s*2:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=Math.max(l.height+o,t.height??0),h=Math.max(l.width+a,(t.width??0)-c),u=[{x:0,y:0},{x:h+3*c/6,y:0},{x:h,y:-c},{x:-(3*c)/6,y:-c}];let d;const{cssStyles:f}=t;if(t.look==="handDrawn"){const m=ct.svg(n),y=lt(t,{}),x=Nt(u),C=m.path(x,y);d=n.insert(()=>C,":first-child").attr("transform",`translate(${-h/2}, ${c/2})`),f&&d.attr("style",f)}else d=fr(n,h,c,u);return i&&d.attr("style",i),t.width=h,t.height=c,dt(t,d),t.intersect=function(m){return at.polygon(t,u,m)},n}p(Yg,"lean_left");async function Ug(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=s,a=t.look==="neo"?s*2:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=Math.max(l.height+o,t.height??0),h=Math.max(l.width+a,(t.width??0)-c),u=[{x:-3*c/6,y:0},{x:h,y:0},{x:h+3*c/6,y:-c},{x:0,y:-c}];let d;const{cssStyles:f}=t;if(t.look==="handDrawn"){const m=ct.svg(n),y=lt(t,{}),x=Nt(u),C=m.path(x,y);d=n.insert(()=>C,":first-child").attr("transform",`translate(${-h/2}, ${c/2})`),f&&d.attr("style",f)}else d=fr(n,h,c,u);return i&&d.attr("style",i),t.width=h,t.height=c,dt(t,d),t.intersect=function(m){return at.polygon(t,u,m)},n}p(Ug,"lean_right");function jg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.label="",t.labelStyle=r;const s=e.insert("g").attr("class",Ct(t)).attr("id",t.domId??t.id),{cssStyles:o}=t,a=Math.max(35,t?.width??0),n=Math.max(35,t?.height??0),l=7,c=[{x:a,y:0},{x:0,y:n+l/2},{x:a-2*l,y:n+l/2},{x:0,y:2*n},{x:a,y:n-l/2},{x:2*l,y:n-l/2}],h=ct.svg(s),u=lt(t,{});t.look!=="handDrawn"&&(u.roughness=0,u.fillStyle="solid");const d=Nt(c),f=h.path(d,u),m=s.insert(()=>f,":first-child");return m.attr("class","outer-path"),o&&t.look!=="handDrawn"&&m.selectAll("path").attr("style",o),i&&t.look!=="handDrawn"&&m.selectAll("path").attr("style",i),m.attr("transform",`translate(-${a/2},${-n})`),dt(t,m),t.intersect=function(y){return R.info("lightningBolt intersect",t,y),at.polygon(t,c,y)},s}p(jg,"lightningBolt");var Y_=p((e,t,r,i,s,o,a)=>[`M${e},${t+o}`,`a${s},${o} 0,0,0 ${r},0`,`a${s},${o} 0,0,0 ${-r},0`,`l0,${i}`,`a${s},${o} 0,0,0 ${r},0`,`l0,${-i}`,`M${e},${t+o+a}`,`a${s},${o} 0,0,0 ${r},0`].join(" "),"createCylinderPathD"),U_=p((e,t,r,i,s,o,a)=>[`M${e},${t+o}`,`M${e+r},${t+o}`,`a${s},${o} 0,0,0 ${-r},0`,`l0,${i}`,`a${s},${o} 0,0,0 ${r},0`,`l0,${-i}`,`M${e},${t+o+a}`,`a${s},${o} 0,0,0 ${r},0`].join(" "),"createOuterCylinderPathD"),j_=p((e,t,r,i,s,o)=>[`M${e-r/2},${-i/2}`,`a${s},${o} 0,0,0 ${r},0`].join(" "),"createInnerCylinderPathD"),xu=10,Cu=10;async function Gg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?24:s;if(t.width||t.height){const C=t.width??0;t.width=(t.width??0)-o,t.widthA,":first-child").attr("class","line"),y=n.insert(()=>v,":first-child"),y.attr("class","basic label-container"),x&&y.attr("style",x)}else{const C=Y_(0,0,h,f,u,d,m);y=n.insert("path",":first-child").attr("d",C).attr("class","basic label-container outer-path").attr("style",re(x)).attr("style",i)}return y.attr("label-offset-y",d),y.attr("transform",`translate(${-h/2}, ${-(f/2+d)})`),dt(t,y),c.attr("transform",`translate(${-(l.width/2)-(l.x-(l.left??0))}, ${-(l.height/2)+d-(l.y-(l.top??0))})`),t.intersect=function(C){const k=at.rect(t,C),T=k.x-(t.x??0);if(u!=0&&(Math.abs(T)<(t.width??0)/2||Math.abs(T)==(t.width??0)/2&&Math.abs(k.y-(t.y??0))>(t.height??0)/2-d)){let S=d*d*(1-T*T/(u*u));S>0&&(S=Math.sqrt(S)),S=d-S,C.y-(t.y??0)>0&&(S=-S),k.y+=S}return k},n}p(Gg,"linedCylinder");async function Xg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s;if(t.width||t.height){const S=t.width;t.width=(S??0)*10/11-o*2,t.width<10&&(t.width=10),t.height=(t?.height??0)-a*2,t.height<10&&(t.height=10)}const{shapeSvg:n,bbox:l,label:c}=await xt(e,t,Ct(t)),h=(t?.width?t?.width:l.width)+(o??0)*2,u=(t?.height?t?.height:l.height)+(a??0)*2,d=t.look==="neo"?u/4:u/8,f=u+d,{cssStyles:m}=t,y=ct.svg(n),x=lt(t,{});t.look!=="handDrawn"&&(x.roughness=0,x.fillStyle="solid");const C=[{x:-h/2-h/2*.1,y:-f/2},{x:-h/2-h/2*.1,y:f/2},...Yr(-h/2-h/2*.1,f/2,h/2+h/2*.1,f/2,d,.8),{x:h/2+h/2*.1,y:-f/2},{x:-h/2-h/2*.1,y:-f/2},{x:-h/2,y:-f/2},{x:-h/2,y:f/2*1.1},{x:-h/2,y:-f/2}],k=y.polygon(C.map(S=>[S.x,S.y]),x),T=n.insert(()=>k,":first-child");return T.attr("class","basic label-container outer-path"),m&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",m),i&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",i),T.attr("transform",`translate(0,${-d/2})`),c.attr("transform",`translate(${-h/2+(t.padding??0)+h/2*.1/2-(l.x-(l.left??0))},${-u/2+(t.padding??0)-d/2-(l.y-(l.top??0))})`),dt(t,T),t.intersect=function(S){return at.polygon(t,C,S)},n}p(Xg,"linedWaveEdgedRect");async function Vg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s,n=t.look==="neo"?10:5;(t.width||t.height)&&(t.width=Math.max((t?.width??0)-o*2-2*n,10),t.height=Math.max((t?.height??0)-a*2-2*n,10));const{shapeSvg:l,bbox:c,label:h}=await xt(e,t,Ct(t)),u=(t?.width?t?.width:c.width)+o*2+2*n,d=(t?.height?t?.height:c.height)+a*2+2*n,f=u-2*n,m=d-2*n,y=-f/2,x=-m/2,{cssStyles:C}=t,k=ct.svg(l),T=lt(t,{}),S=[{x:y-n,y:x+n},{x:y-n,y:x+m+n},{x:y+f-n,y:x+m+n},{x:y+f-n,y:x+m},{x:y+f,y:x+m},{x:y+f,y:x+m-n},{x:y+f+n,y:x+m-n},{x:y+f+n,y:x-n},{x:y+n,y:x-n},{x:y+n,y:x},{x:y,y:x},{x:y,y:x+n}],v=[{x:y,y:x+n},{x:y+f-n,y:x+n},{x:y+f-n,y:x+m},{x:y+f,y:x+m},{x:y+f,y:x},{x:y,y:x}];t.look!=="handDrawn"&&(T.roughness=0,T.fillStyle="solid");const A=Nt(S);let L=k.path(A,T);const F=Nt(v);let Z=k.path(F,T);t.look!=="handDrawn"&&(L=Jn(L),Z=Jn(Z));const U=l.insert("g",":first-child");return U.insert(()=>L),U.insert(()=>Z),U.attr("class","basic label-container outer-path"),C&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",C),i&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",i),h.attr("transform",`translate(${-(c.width/2)-n-(c.x-(c.left??0))}, ${-(c.height/2)+n-(c.y-(c.top??0))})`),dt(t,U),t.intersect=function(N){return at.polygon(t,S,N)},l}p(Vg,"multiRect");async function Zg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,label:a}=await xt(e,t,Ct(t)),n=t.padding??0,l=t.look==="neo"?16:n,c=t.look==="neo"?12:n;let h=!0;(t.width||t.height)&&(h=!1,t.width=(t?.width??0)-l*2,t.height=(t?.height??0)-c*3);const u=Math.max(o.width,t?.width??0)+l*2,d=Math.max(o.height,t?.height??0)+c*3,f=t.look==="neo"?d/4:d/8,m=d+(h?f/2:-f/2),y=-u/2,x=-m/2,C=10,{cssStyles:k}=t,T=Yr(y-C,x+m+C,y+u-C,x+m+C,f,.8),S=T?.[T.length-1],v=[{x:y-C,y:x+C},{x:y-C,y:x+m+C},...T,{x:y+u-C,y:S.y-C},{x:y+u,y:S.y-C},{x:y+u,y:S.y-2*C},{x:y+u+C,y:S.y-2*C},{x:y+u+C,y:x-C},{x:y+C,y:x-C},{x:y+C,y:x},{x:y,y:x},{x:y,y:x+C}],A=[{x:y,y:x+C},{x:y+u-C,y:x+C},{x:y+u-C,y:S.y-C},{x:y+u,y:S.y-C},{x:y+u,y:x},{x:y,y:x}],L=ct.svg(s),F=lt(t,{});t.look!=="handDrawn"&&(F.roughness=0,F.fillStyle="solid");const Z=Nt(v),U=L.path(Z,F),N=Nt(A),st=L.path(N,F),Y=s.insert(()=>U,":first-child");return Y.insert(()=>st),Y.attr("class","basic label-container outer-path"),k&&t.look!=="handDrawn"&&Y.selectAll("path").attr("style",k),i&&t.look!=="handDrawn"&&Y.selectAll("path").attr("style",i),Y.attr("transform",`translate(0,${-f/2})`),a.attr("transform",`translate(${-(o.width/2)-C-(o.x-(o.left??0))}, ${-(o.height/2)+C-f/2-(o.y-(o.top??0))})`),dt(t,Y),t.intersect=function($){return at.polygon(t,v,$)},s}p(Zg,"multiWaveEdgedRectangle");async function Kg(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i,t.useHtmlLabels||be(Zt())||(t.centerLabel=!0);const{shapeSvg:a,bbox:n,label:l}=await xt(e,t,Ct(t)),c=Math.max(n.width+(t.padding??0)*2,t?.width??0),h=Math.max(n.height+(t.padding??0)*2,t?.height??0),u=-c/2,d=-h/2,{cssStyles:f}=t,m=ct.svg(a),y=lt(t,{fill:r.noteBkgColor,stroke:r.noteBorderColor});t.look!=="handDrawn"&&(y.roughness=0,y.fillStyle="solid");const x=m.rectangle(u,d,c,h,y),C=a.insert(()=>x,":first-child");return C.attr("class","basic label-container outer-path"),l.attr("class","label noteLabel"),f&&t.look!=="handDrawn"&&C.selectAll("path").attr("style",f),s&&t.look!=="handDrawn"&&C.selectAll("path").attr("style",s),l.attr("transform",`translate(${-n.width/2-(n.x-(n.left??0))}, ${-(n.height/2)-(n.y-(n.top??0))})`),dt(t,C),t.intersect=function(k){return at.rect(t,k)},a}p(Kg,"note");var G_=p((e,t,r)=>[`M${e+r/2},${t}`,`L${e+r},${t-r/2}`,`L${e+r/2},${t-r}`,`L${e},${t-r/2}`,"Z"].join(" "),"createDecisionBoxPathD");async function Qg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o}=await xt(e,t,Ct(t)),a=o.width+(t.padding??0),n=o.height+(t.padding??0),l=a+n,c=.5,h=[{x:l/2,y:0},{x:l,y:-l/2},{x:l/2,y:-l},{x:0,y:-l/2}];let u;const{cssStyles:d}=t;if(t.look==="handDrawn"){const f=ct.svg(s),m=lt(t,{}),y=G_(0,0,l),x=f.path(y,m);u=s.insert(()=>x,":first-child").attr("transform",`translate(${-l/2+c}, ${l/2})`),d&&u.attr("style",d)}else u=fr(s,l,l,h),u.attr("transform",`translate(${-l/2+c}, ${l/2})`);return i&&u.attr("style",i),dt(t,u),t.calcIntersect=function(f,m){const y=f.width,x=[{x:y/2,y:0},{x:y,y:-y/2},{x:y/2,y:-y},{x:0,y:-y/2}],C=at.polygon(f,x,m);return{x:C.x-.5,y:C.y-.5}},t.intersect=function(f){return this.calcIntersect(t,f)},s}p(Qg,"question");async function Jg(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?21:s??0,a=t.look==="neo"?12:s??0,{shapeSvg:n,bbox:l,label:c}=await xt(e,t,Ct(t)),h=l.width+(t.look==="neo"?o*2:o),u=Math.max(l.height+(t.look==="neo"?a*2:a),t.height??0),d=u/4,m=-Math.max(h,(t.width??0)-d)/2,y=-u/2,x=y/2,C=[{x:m+x,y},{x:m,y:0},{x:m+x,y:-y},{x:-m,y:-y},{x:-m,y}],{cssStyles:k}=t,T=ct.svg(n),S=lt(t,{});t.look!=="handDrawn"&&(S.roughness=0,S.fillStyle="solid");const v=Nt(C),A=T.path(v,S),L=n.insert(()=>A,":first-child");return L.attr("class","basic label-container outer-path"),k&&t.look!=="handDrawn"&&L.selectAll("path").attr("style",k),i&&t.look!=="handDrawn"&&L.selectAll("path").attr("style",i),L.attr("transform",`translate(${-x/2},0)`),c.attr("transform",`translate(${-x/2-l.width/2-(l.x-(l.left??0))}, ${-(l.height/2)-(l.y-(l.top??0))})`),dt(t,L),t.intersect=function(F){return at.polygon(t,C,F)},n}p(Jg,"rect_left_inv_arrow");async function tm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;let s;t.cssClasses?s="node "+t.cssClasses:s="node default";const o=e.insert("g").attr("class",s).attr("id",t.domId||t.id),a=o.insert("g"),n=o.insert("g").attr("class","label").attr("style",i),l=t.description,c=t.label,h=await Rr(n,c,t.labelStyle,!0,!0);let u={width:0,height:0};if(be(It())){const F=h.children[0],Z=At(h);u=F.getBoundingClientRect(),Z.attr("width",u.width),Z.attr("height",u.height)}R.info("Text 2",l);const d=l||[],f=h.getBBox(),m=await Rr(n,Array.isArray(d)?d.join("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "):d,t.labelStyle,!0,!0),y=m.children[0],x=At(m);u=y.getBoundingClientRect(),x.attr("width",u.width),x.attr("height",u.height);const C=(t.padding||0)/2;At(m).attr("transform","translate( "+(u.width>f.width?0:(f.width-u.width)/2)+", "+(f.height+C+5)+")"),At(h).attr("transform","translate( "+(u.width(R.debug("Rough node insert CXC",U),N),":first-child"),A=o.insert(()=>(R.debug("Rough node insert CXC",U),U),":first-child")}else A=a.insert("rect",":first-child"),L=a.insert("line"),A.attr("class","outer title-state").attr("style",i).attr("x",-u.width/2-C).attr("y",-u.height/2-C).attr("width",u.width+(t.padding||0)).attr("height",u.height+(t.padding||0)),L.attr("class","divider").attr("x1",-u.width/2-C).attr("x2",u.width/2+C).attr("y1",-u.height/2-C+f.height+C).attr("y2",-u.height/2-C+f.height+C);return dt(t,A),t.intersect=function(F){return at.rect(t,F)},o}p(tm,"rectWithTitle");async function em(e,t,{config:{themeVariables:r}}){const i=r?.radius??5,s={rx:i,ry:i,labelPaddingX:(t?.padding??0)*1,labelPaddingY:(t?.padding??0)*1};return zi(e,t,s)}p(em,"roundedRect");var Xr=8;async function rm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.look==="neo"?16:t.padding??0,o=t.look==="neo"?12:t.padding??0,{shapeSvg:a,bbox:n,label:l}=await xt(e,t,Ct(t)),c=(t?.width??n.width)+s*2+(t.look==="neo"?Xr:Xr*2),h=(t?.height??n.height)+o*2,u=c-Xr,d=h,f=Xr-c/2,m=-h/2,{cssStyles:y}=t,x=ct.svg(a),C=lt(t,{});t.look!=="handDrawn"&&(C.roughness=0,C.fillStyle="solid");const k=[{x:f,y:m},{x:f+u,y:m},{x:f+u,y:m+d},{x:f-Xr,y:m+d},{x:f-Xr,y:m},{x:f,y:m},{x:f,y:m+d}],T=x.polygon(k.map(v=>[v.x,v.y]),C),S=a.insert(()=>T,":first-child");return S.attr("class","basic label-container outer-path").attr("style",re(y)),i&&t.look!=="handDrawn"&&S.selectAll("path").attr("style",i),y&&t.look!=="handDrawn"&&S.selectAll("path").attr("style",i),l.attr("transform",`translate(${Xr/2-n.width/2-(n.x-(n.left??0))}, ${-(n.height/2)-(n.y-(n.top??0))})`),dt(t,S),t.intersect=function(v){return at.rect(t,v)},a}p(rm,"shadedProcess");async function im(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s;(t.width||t.height)&&(t.width=Math.max((t?.width??0)-o*2,10),t.height=Math.max((t?.height??0)/1.5-a*2,10));const{shapeSvg:n,bbox:l,label:c}=await xt(e,t,Ct(t)),h=(t?.width?t?.width:l.width)+o*2,u=((t?.height?t?.height:l.height)+a*2)*1.5,d=h,f=u/1.5,m=-d/2,y=-f/2,{cssStyles:x}=t,C=ct.svg(n),k=lt(t,{});t.look!=="handDrawn"&&(k.roughness=0,k.fillStyle="solid");const T=[{x:m,y},{x:m,y:y+f},{x:m+d,y:y+f},{x:m+d,y:y-f/2}],S=Nt(T),v=C.path(S,k),A=n.insert(()=>v,":first-child");return A.attr("class","basic label-container outer-path"),x&&t.look!=="handDrawn"&&A.selectChildren("path").attr("style",x),i&&t.look!=="handDrawn"&&A.selectChildren("path").attr("style",i),A.attr("transform",`translate(0, ${f/4})`),c.attr("transform",`translate(${-d/2+(t.padding??0)-(l.x-(l.left??0))}, ${-f/4+(t.padding??0)-(l.y-(l.top??0))})`),dt(t,A),t.intersect=function(L){return at.polygon(t,T,L)},n}p(im,"slopedRect");async function sm(e,t){const r=t.padding??0,i=t.look==="neo"?16:r*2,s=t.look==="neo"?12:r,o={rx:0,ry:0,labelPaddingX:t.labelPaddingX??i,labelPaddingY:s};return zi(e,t,o)}p(sm,"squareRect");async function om(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?20:s,a=t.look==="neo"?12:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=l.height+(t.look==="neo"?a*2:a),h=l.width+c/4+(t.look==="neo"?o*2:o),u=c/2,{cssStyles:d}=t,f=ct.svg(n),m=lt(t,{});t.look!=="handDrawn"&&(m.roughness=0,m.fillStyle="solid");const y=[{x:-h/2+u,y:-c/2},{x:h/2-u,y:-c/2},...or(-h/2+u,0,u,50,90,270),{x:h/2-u,y:c/2},...or(h/2-u,0,u,50,270,450)],x=Nt(y),C=f.path(x,m),k=n.insert(()=>C,":first-child");return k.attr("class","basic label-container outer-path"),d&&t.look!=="handDrawn"&&k.selectChildren("path").attr("style",d),i&&t.look!=="handDrawn"&&k.selectChildren("path").attr("style",i),dt(t,k),t.intersect=function(T){return at.polygon(t,y,T)},n}p(om,"stadium");async function am(e,t){const r={rx:t.look==="neo"?3:5,ry:t.look==="neo"?3:5};return zi(e,t,r)}p(am,"state");function nm(e,t,{config:{themeVariables:r}}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i;const{cssStyles:o}=t,{lineColor:a,stateBorder:n,nodeBorder:l,nodeShadow:c}=r;(t.width||t.height)&&((t.width??0)<14&&(t.width=14),(t.height??0)<14&&(t.height=14)),t.width||(t.width=14),t.height||(t.height=14);const h=e.insert("g").attr("class","node default").attr("id",t.domId??t.id),u=ct.svg(h),d=lt(t,{});t.look!=="handDrawn"&&(d.roughness=0,d.fillStyle="solid");const f=u.circle(0,0,t.width,{...d,stroke:a,strokeWidth:2}),m=n??l,y=(t.width??0)*5/14,x=u.circle(0,0,y,{...d,fill:m,stroke:m,strokeWidth:2,fillStyle:"solid"}),C=h.insert(()=>f,":first-child");if(C.insert(()=>x),t.look!=="handDrawn"&&C.attr("class","outer-path"),o&&C.selectAll("path").attr("style",o),s&&C.selectAll("path").attr("style",s),t.width<25&&c&&t.look!=="handDrawn"){const k=e.node()?.ownerSVGElement?.id??"",T=k?`${k}-drop-shadow-small`:"drop-shadow-small";C.attr("style",`filter:url(#${T})`)}return dt(t,C),t.intersect=function(k){return at.circle(t,(t.width??0)/2,k)},h}p(nm,"stateEnd");function lm(e,t,{config:{themeVariables:r}}){const{lineColor:i,nodeShadow:s}=r;(t.width||t.height)&&((t.width??0)<14&&(t.width=14),(t.height??0)<14&&(t.height=14)),t.width||(t.width=14),t.height||(t.height=14);const o=e.insert("g").attr("class","node default").attr("id",t.domId||t.id);let a;if(t.look==="handDrawn"){const l=ct.svg(o).circle(0,0,t.width,G2(i));a=o.insert(()=>l),a.attr("class","state-start").attr("r",(t.width??7)/2).attr("width",t.width??14).attr("height",t.height??14)}else a=o.insert("circle",":first-child"),a.attr("class","state-start").attr("r",(t.width??7)/2).attr("width",t.width??14).attr("height",t.height??14);if(t.width<25&&s&&t.look!=="handDrawn"){const n=e.node()?.ownerSVGElement?.id??"",l=n?`${n}-drop-shadow-small`:"drop-shadow-small";a.attr("style",`filter:url(#${l})`)}return dt(t,a),t.intersect=function(n){return at.circle(t,(t.width??7)/2,n)},o}p(lm,"stateStart");var wi=8;async function hm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t?.padding??8,o=t.look==="neo"?28:s,a=t.look==="neo"?12:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=Math.max(l.width+2*wi+o,t.width??0),h=Math.max(l.height+a,t.height??0),u=c-2*wi,d=h,f=-c/2,m=-h/2,y=[{x:0,y:0},{x:u,y:0},{x:u,y:-d},{x:0,y:-d},{x:0,y:0},{x:-8,y:0},{x:u+8,y:0},{x:u+8,y:-d},{x:-8,y:-d},{x:-8,y:0}];if(t.look==="handDrawn"){const x=ct.svg(n),C=lt(t,{}),k=x.rectangle(f,m,u+16,d,C),T=x.line(f+wi,m,f+wi,m+d,C),S=x.line(f+wi+u,m,f+wi+u,m+d,C);n.insert(()=>T,":first-child"),n.insert(()=>S,":first-child");const v=n.insert(()=>k,":first-child"),{cssStyles:A}=t;v.attr("class","basic label-container").attr("style",re(A)),dt(t,v)}else{const x=fr(n,u,d,y);i&&x.attr("style",i),dt(t,x)}return t.intersect=function(x){return at.polygon(t,y,x)},n}p(hm,"subroutine");var Ya=.2;async function cm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s;(t.width||t.height)&&(t.height=Math.max((t?.height??0)-a*2,10),t.width=Math.max((t?.width??0)-o*2-Ya*(t.height+a*2),10));const{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=(t?.height?t?.height:l.height)+a*2,h=Ya*c,u=Ya*c,f=(t?.width?t?.width:l.width)+o*2+h-h,m=c,y=-f/2,x=-m/2,{cssStyles:C}=t,k=ct.svg(n),T=lt(t,{}),S=[{x:y-h/2,y:x},{x:y+f+h/2,y:x},{x:y+f+h/2,y:x+m},{x:y-h/2,y:x+m}],v=[{x:y+f-h/2,y:x+m},{x:y+f+h/2,y:x+m},{x:y+f+h/2,y:x+m-u}];t.look!=="handDrawn"&&(T.roughness=0,T.fillStyle="solid");const A=Nt(S),L=k.path(A,T),F=Nt(v),Z=k.path(F,{...T,fillStyle:"solid"}),U=n.insert(()=>Z,":first-child");return U.insert(()=>L,":first-child"),U.attr("class","basic label-container outer-path"),C&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",C),i&&t.look!=="handDrawn"&&U.selectAll("path").attr("style",i),dt(t,U),t.intersect=function(N){return at.polygon(t,S,N)},n}p(cm,"taggedRect");async function um(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,label:a}=await xt(e,t,Ct(t)),n=Math.max(o.width+(t.padding??0)*2,t?.width??0),l=Math.max(o.height+(t.padding??0)*2,t?.height??0),c=l/8,h=.2*n,u=.2*l,d=l+c,{cssStyles:f}=t,m=ct.svg(s),y=lt(t,{});t.look!=="handDrawn"&&(y.roughness=0,y.fillStyle="solid");const x=[{x:-n/2-n/2*.1,y:d/2},...Yr(-n/2-n/2*.1,d/2,n/2+n/2*.1,d/2,c,.8),{x:n/2+n/2*.1,y:-d/2},{x:-n/2-n/2*.1,y:-d/2}],C=-n/2+n/2*.1,k=-d/2-u*.4,T=[{x:C+n-h,y:(k+l)*1.3},{x:C+n,y:k+l-u},{x:C+n,y:(k+l)*.9},...Yr(C+n,(k+l)*1.25,C+n-h,(k+l)*1.3,-l*.02,.5)],S=Nt(x),v=m.path(S,y),A=Nt(T),L=m.path(A,{...y,fillStyle:"solid"}),F=s.insert(()=>L,":first-child");return F.insert(()=>v,":first-child"),F.attr("class","basic label-container outer-path"),f&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",f),i&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",i),F.attr("transform",`translate(0,${-c/2})`),a.attr("transform",`translate(${-n/2+(t.padding??0)-(o.x-(o.left??0))},${-l/2+(t.padding??0)-c/2-(o.y-(o.top??0))})`),dt(t,F),t.intersect=function(Z){return at.polygon(t,x,Z)},s}p(um,"taggedWaveEdgedRectangle");async function dm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o}=await xt(e,t,Ct(t)),a=Math.max(o.width+(t.padding??0),t?.width||0),n=Math.max(o.height+(t.padding??0),t?.height||0),l=-a/2,c=-n/2,h=s.insert("rect",":first-child");return h.attr("class","text").attr("style",i).attr("rx",0).attr("ry",0).attr("x",l).attr("y",c).attr("width",a).attr("height",n),dt(t,h),t.intersect=function(u){return at.rect(t,u)},s}p(dm,"text");var X_=p((e,t,r,i,s,o)=>`M${e},${t} + a${s},${o} 0,0,1 0,${-i} + l${r},0 + a${s},${o} 0,0,1 0,${i} + M${r},${-i} + a${s},${o} 0,0,0 0,${i} + l${-r},0`,"createCylinderPathD"),V_=p((e,t,r,i,s,o)=>[`M${e},${t}`,`M${e+r},${t}`,`a${s},${o} 0,0,0 0,${-i}`,`l${-r},0`,`a${s},${o} 0,0,0 0,${i}`,`l${r},0`].join(" "),"createOuterCylinderPathD"),Z_=p((e,t,r,i,s,o)=>[`M${e+r/2},${-i/2}`,`a${s},${o} 0,0,0 0,${i}`].join(" "),"createInnerCylinderPathD"),bu=5,ku=10;async function fm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?12:s/2,a=t.height??0;if(t.height&&(t.height=t.height-o,t.heightS,":first-child"),y=n.insert(()=>T,":first-child"),y.attr("class","basic label-container"),m&&y.attr("style",m)}else{const x=X_(0,0,f,h,d,u);y=n.insert("path",":first-child").attr("d",x).attr("class","basic label-container").attr("style",re(m)).attr("style",i),y.attr("class","basic label-container outer-path"),m&&y.selectAll("path").attr("style",m),i&&y.selectAll("path").attr("style",i)}return y.attr("label-offset-x",d),y.attr("transform",`translate(${-f/2}, ${h/2} )`),c.attr("transform",`translate(${-(l.width/2)-d-(l.x-(l.left??0))}, ${-(l.height/2)-(l.y-(l.top??0))})`),dt(t,y),t.intersect=function(x){const C=at.rect(t,x),k=C.y-(t.y??0);if(u!=0&&(Math.abs(k)<(t.height??0)/2||Math.abs(k)==(t.height??0)/2&&Math.abs(C.x-(t.x??0))>(t.width??0)/2-d)){let T=d*d*(1-k*k/(u*u));T!=0&&(T=Math.sqrt(Math.abs(T))),T=d-T,x.x-(t.x??0)>0&&(T=-T),C.x+=T}return C},n}p(fm,"tiltedCylinder");async function pm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=(t.look==="neo",s),a=t.look==="neo"?s*2:s,{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=Math.max(l.height+o,t.height??0),h=Math.max(l.width+a,(t.width??0)-c),u=[{x:-3*c/6,y:0},{x:h+3*c/6,y:0},{x:h,y:-c},{x:0,y:-c}];let d;const{cssStyles:f}=t;if(t.look==="handDrawn"){const m=ct.svg(n),y=lt(t,{}),x=Nt(u),C=m.path(x,y);d=n.insert(()=>C,":first-child").attr("transform",`translate(${-h/2}, ${c/2})`),f&&d.attr("style",f)}else d=fr(n,h,c,u);return i&&d.attr("style",i),t.width=h,t.height=c,dt(t,d),t.intersect=function(m){return at.polygon(t,u,m)},n}p(pm,"trapezoid");async function gm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s,n=15,l=5;(t.width||t.height)&&(t.height=(t.height??0)-a*2,t.heightk,":first-child");return T.attr("class","basic label-container outer-path"),f&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",f),i&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",i),dt(t,T),t.intersect=function(S){return at.polygon(t,x,S)},c}p(gm,"trapezoidalPentagon");var wu=10,Tu=10;async function mm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?s*2:s;(t.width||t.height)&&(t.width=((t?.width??0)-o)/2,t.widthk,":first-child").attr("transform",`translate(${-u/2}, ${u/2})`).attr("class","outer-path");return m&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",m),i&&t.look!=="handDrawn"&&T.selectChildren("path").attr("style",i),t.width=h,t.height=u,dt(t,T),l.attr("transform",`translate(${-n.width/2-(n.x-(n.left??0))}, ${u/2-(n.height+(t.padding??0)/(c?2:1)-(n.y-(n.top??0)))})`),t.intersect=function(S){return R.info("Triangle intersect",t,f,S),at.polygon(t,f,S)},a}p(mm,"triangle");async function ym(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?12:s;let n=!0;(t.width||t.height)&&(n=!1,t.width=(t?.width??0)-o*2,t.width<10&&(t.width=10),t.height=(t?.height??0)-a*2,t.height<10&&(t.height=10));const{shapeSvg:l,bbox:c,label:h}=await xt(e,t,Ct(t)),u=(t?.width?t?.width:c.width)+(o??0)*2,d=(t?.height?t?.height:c.height)+(a??0)*2,f=t.look==="neo"?d/4:d/8,m=d+(n?f:-f),{cssStyles:y}=t,C=14-u,k=C>0?C/2:0,T=ct.svg(l),S=lt(t,{});t.look!=="handDrawn"&&(S.roughness=0,S.fillStyle="solid");const v=[{x:-u/2-k,y:m/2},...Yr(-u/2-k,m/2,u/2+k,m/2,f,.8),{x:u/2+k,y:-m/2},{x:-u/2-k,y:-m/2}],A=Nt(v),L=T.path(A,S),F=l.insert(()=>L,":first-child");return F.attr("class","basic label-container outer-path"),y&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",y),i&&t.look!=="handDrawn"&&F.selectAll("path").attr("style",i),F.attr("transform",`translate(0,${-f/2})`),h.attr("transform",`translate(${-u/2+(t.padding??0)-(c.x-(c.left??0))},${-d/2+(t.padding??0)-f-(c.y-(c.top??0))})`),dt(t,F),t.intersect=function(Z){return at.polygon(t,v,Z)},l}p(ym,"waveEdgedRectangle");async function xm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.padding??0,o=t.look==="neo"?16:s,a=t.look==="neo"?20:s;if(t.width||t.height){t.width=t?.width??0,t.width<20&&(t.width=20),t.height=t?.height??0,t.height<10&&(t.height=10);const S=Math.min(t.height*.2,t.height/4);t.height=Math.ceil(t.height-a-S*(20/9)),t.width=t.width-o*2}const{shapeSvg:n,bbox:l}=await xt(e,t,Ct(t)),c=(t?.width?t?.width:l.width)+o*2,h=(t?.height?t?.height:l.height)+a,u=h/8,d=h+u*2,{cssStyles:f}=t,m=ct.svg(n),y=lt(t,{});t.look!=="handDrawn"&&(y.roughness=0,y.fillStyle="solid");const x=[{x:-c/2,y:d/2},...Yr(-c/2,d/2,c/2,d/2,u,1),{x:c/2,y:-d/2},...Yr(c/2,-d/2,-c/2,-d/2,u,-1)],C=Nt(x),k=m.path(C,y),T=n.insert(()=>k,":first-child");return T.attr("class","basic label-container"),f&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",f),i&&t.look!=="handDrawn"&&T.selectAll("path").attr("style",i),dt(t,T),t.intersect=function(S){return at.polygon(t,x,S)},n}p(xm,"waveRectangle");var Jt=10;async function Cm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t.look==="neo"?16:t.padding??0,o=t.look==="neo"?12:t.padding??0;(t.width||t.height)&&(t.width=Math.max((t?.width??0)-s*2-Jt,10),t.height=Math.max((t?.height??0)-o*2-Jt,10));const{shapeSvg:a,bbox:n,label:l}=await xt(e,t,Ct(t)),c=(t?.width?t?.width:n.width)+s*2+Jt,h=(t?.height?t?.height:n.height)+o*2+Jt,u=c-Jt,d=h-Jt,f=-u/2,m=-d/2,{cssStyles:y}=t,x=ct.svg(a),C=lt(t,{}),k=[{x:f-Jt,y:m-Jt},{x:f-Jt,y:m+d},{x:f+u,y:m+d},{x:f+u,y:m-Jt}],T=`M${f-Jt},${m-Jt} L${f+u},${m-Jt} L${f+u},${m+d} L${f-Jt},${m+d} L${f-Jt},${m-Jt} + M${f-Jt},${m} L${f+u},${m} + M${f},${m-Jt} L${f},${m+d}`;t.look!=="handDrawn"&&(C.roughness=0,C.fillStyle="solid");const S=x.path(T,C),v=a.insert(()=>S,":first-child");return v.attr("transform",`translate(${Jt/2}, ${Jt/2})`),v.attr("class","basic label-container outer-path"),y&&t.look!=="handDrawn"&&v.selectAll("path").attr("style",y),i&&t.look!=="handDrawn"&&v.selectAll("path").attr("style",i),l.attr("transform",`translate(${-(n.width/2)+Jt/2-(n.x-(n.left??0))}, ${-(n.height/2)+Jt/2-(n.y-(n.top??0))})`),dt(t,v),t.intersect=function(A){return at.polygon(t,k,A)},a}p(Cm,"windowPane");var _u=new Set(["redux-color","redux-dark-color"]),K_=new Set(["redux","redux-dark","redux-color","redux-dark-color"]);async function oh(e,t){const r=t;r.alias&&(t.label=r.alias);const{theme:i,themeVariables:s}=Zt(),{rowEven:o,rowOdd:a,nodeBorder:n,borderColorArray:l}=s;if(t.look==="handDrawn"){const{themeVariables:pt}=Zt(),{background:wt}=pt,Ot={...t,id:t.id+"-background",domId:(t.domId||t.id)+"-background",look:"default",cssStyles:["stroke: none",`fill: ${wt}`]};await oh(e,Ot)}const c=Zt();t.useHtmlLabels=c.htmlLabels;let h=c.er?.diagramPadding??10,u=c.er?.entityPadding??6;const{cssStyles:d}=t,{labelStyles:f,nodeStyles:m}=ft(t);if(r.attributes.length===0&&t.label){const pt={rx:0,ry:0,labelPaddingX:h,labelPaddingY:h*1.5};vr(t.label,c)+pt.labelPaddingX*20){const pt=C.width+h*2-(v+A+L+F);v+=pt/N,A+=pt/N,L>0&&(L+=pt/N),F>0&&(F+=pt/N)}const Y=v+A+L+F,$=ct.svg(x),I=lt(t,{});t.look!=="handDrawn"&&(I.roughness=0,I.fillStyle="solid");let B=0;S.length>0&&(B=S.reduce((pt,wt)=>pt+(wt?.rowHeight??0),0));const q=Math.max(st.width+h*2,t?.width||0,Y),O=Math.max((B??0)+C.height,t?.height||0),it=-q/2,tt=-O/2;if(x.selectAll("g:not(:first-child)").each((pt,wt,Ot)=>{const _t=At(Ot[wt]),zt=_t.attr("transform");let Wt=0,$t=0;if(zt){const Pt=RegExp(/translate\(([^,]+),([^)]+)\)/).exec(zt);Pt&&(Wt=parseFloat(Pt[1]),$t=parseFloat(Pt[2]),_t.attr("class").includes("attribute-name")?Wt+=v:_t.attr("class").includes("attribute-keys")?Wt+=v+A:_t.attr("class").includes("attribute-comment")&&(Wt+=v+A+L))}_t.attr("transform",`translate(${it+h/2+Wt}, ${$t+tt+C.height+u/2})`)}),x.select(".name").attr("transform","translate("+-C.width/2+", "+(tt+u/2)+")"),i!=null&&_u.has(i)){const pt=r.colorIndex??0;x.attr("data-color-id",`color-${pt%l.length}`)}const gt=$.rectangle(it,tt,q,O,I),ht=x.insert(()=>gt,":first-child").attr("class","outer-path").attr("style",d.join(""));T.push(0);for(const[pt,wt]of S.entries()){const _t=(pt+1)%2===0&&wt.yOffset!==0,zt=$.rectangle(it,C.height+tt+wt?.yOffset,q,wt?.rowHeight,{...I,fill:_t?o:a,stroke:n});x.insert(()=>zt,"g.label").attr("style",d.join("")).attr("class",`row-rect-${_t?"even":"odd"}`)}const Tt=1e-4;let Ft=Si(it,C.height+tt,q+it,C.height+tt,Tt),Bt=$.polygon(Ft.map(pt=>[pt.x,pt.y]),I);if(x.insert(()=>Bt).attr("class","divider"),Ft=Si(v+it,C.height+tt,v+it,O+tt,Tt),Bt=$.polygon(Ft.map(pt=>[pt.x,pt.y]),I),x.insert(()=>Bt).attr("class","divider"),Z){const pt=v+A+it;Ft=Si(pt,C.height+tt,pt,O+tt,Tt),Bt=$.polygon(Ft.map(wt=>[wt.x,wt.y]),I),x.insert(()=>Bt).attr("class","divider")}if(U){const pt=v+A+L+it;Ft=Si(pt,C.height+tt,pt,O+tt,Tt),Bt=$.polygon(Ft.map(wt=>[wt.x,wt.y]),I),x.insert(()=>Bt).attr("class","divider")}for(const pt of T){const wt=C.height+tt+pt;Ft=Si(it,wt,q+it,wt,Tt),Bt=$.polygon(Ft.map(Ot=>[Ot.x,Ot.y]),I),x.insert(()=>Bt).attr("class","divider")}if(dt(t,ht),m&&t.look!=="handDrawn")if(i!=null&&K_.has(i))x.selectAll("path").attr("style",m);else{const wt=m.split(";")?.filter(Ot=>Ot.includes("stroke"))?.map(Ot=>`${Ot}`).join("; ");x.selectAll("path").attr("style",wt??""),x.selectAll(".row-rect-even path").attr("style",m)}return t.intersect=function(pt){return at.rect(t,pt)},x}p(oh,"erBox");async function _i(e,t,r,i=0,s=0,o=[],a=""){const n=e.insert("g").attr("class",`label ${o.join(" ")}`).attr("transform",`translate(${i}, ${s})`).attr("style",a);t!==pc(t)&&(t=pc(t),t=t.replaceAll("<","<").replaceAll(">",">"));const l=n.node().appendChild(await Qe(n,t,{width:vr(t,r)+100,style:a,useHtmlLabels:r.htmlLabels},r));if(t.includes("<")||t.includes(">")){let h=l.children[0];for(h.textContent=h.textContent.replaceAll("<","<").replaceAll(">",">");h.childNodes[0];)h=h.childNodes[0],h.textContent=h.textContent.replaceAll("<","<").replaceAll(">",">")}let c=l.getBBox();if(ur(r.htmlLabels)){const h=l.children[0];h.style.textAlign="start";const u=At(l);c=h.getBoundingClientRect(),u.attr("width",c.width),u.attr("height",c.height)}return c}p(_i,"addText");function Si(e,t,r,i,s){return e===r?[{x:e-s/2,y:t},{x:e+s/2,y:t},{x:r+s/2,y:i},{x:r-s/2,y:i}]:[{x:e,y:t-s/2},{x:e,y:t+s/2},{x:r,y:i+s/2},{x:r,y:i-s/2}]}p(Si,"lineToPolygon");async function bm(e,t,r,i,s=r.class.padding??12){const o=i?0:3,a=e.insert("g").attr("class",Ct(t)).attr("id",t.domId||t.id);let n=null,l=null,c=null,h=null,u=0,d=0,f=0;if(n=a.insert("g").attr("class","annotation-group text"),t.annotations.length>0){const k=t.annotations[0];await us(n,{text:`«${k}»`},0),u=n.node().getBBox().height}l=a.insert("g").attr("class","label-group text"),await us(l,t,0,["font-weight: bolder"]);const m=l.node().getBBox();d=m.height,c=a.insert("g").attr("class","members-group text");let y=0;for(const k of t.members){const T=await us(c,k,y,[k.parseClassifier()]);y+=T+o}f=c.node().getBBox().height,f<=0&&(f=s/2),h=a.insert("g").attr("class","methods-group text");let x=0;for(const k of t.methods){const T=await us(h,k,x,[k.parseClassifier()]);x+=T+o}let C=a.node().getBBox();if(n!==null){const k=n.node().getBBox();n.attr("transform",`translate(${-k.width/2})`)}return l.attr("transform",`translate(${-m.width/2}, ${u})`),C=a.node().getBBox(),c.attr("transform",`translate(0, ${u+d+s*2})`),C=a.node().getBBox(),h.attr("transform",`translate(0, ${u+d+(f?f+s*4:s*2)})`),C=a.node().getBBox(),{shapeSvg:a,bbox:C}}p(bm,"textHelper");async function us(e,t,r,i=[]){const s=e.insert("g").attr("class","label").attr("style",i.join("; ")),o=Zt();let a="useHtmlLabels"in t?t.useHtmlLabels:ur(o.htmlLabels)??!0,n="";"text"in t?n=t.text:n=t.label,!a&&n.startsWith("\\")&&(n=n.substring(1)),Ts(n)&&(a=!0);const l=await Qe(s,bl(Wr(n)),{width:vr(n,o)+50,classes:"markdown-node-label",useHtmlLabels:a},o);let c,h=1;if(a){const u=l.children[0],d=At(l);h=u.innerHTML.split("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ").length,u.innerHTML.includes("")&&(h+=u.innerHTML.split("").length-1),await eh(u),c=u.getBoundingClientRect(),d.attr("width",c.width),d.attr("height",c.height)}else{i.includes("font-weight: bolder")&&At(l).selectAll("tspan").attr("font-weight",""),h=l.children.length;const u=l.children[0];(l.textContent===""||l.textContent.includes(">"))&&(u.textContent=n[0]+n.substring(1).replaceAll(">",">").replaceAll("<","<").trim(),n[1]===" "&&(u.textContent=u.textContent[0]+" "+u.textContent.substring(1))),u.textContent==="undefined"&&(u.textContent=""),c=l.getBBox()}return s.attr("transform","translate(0,"+(-c.height/(2*h)+r)+")"),c.height}p(us,"addText");async function km(e,t){const r=It(),{themeVariables:i}=r,{useGradient:s}=i,o=r.class.padding??12,a=o,n=t.useHtmlLabels??ur(r.htmlLabels)??!0,l=t;l.annotations=l.annotations??[],l.members=l.members??[],l.methods=l.methods??[];const{shapeSvg:c,bbox:h}=await bm(e,t,r,n,a),{labelStyles:u,nodeStyles:d}=ft(t);t.labelStyle=u,t.cssStyles=l.styles||"";const f=l.styles?.join(";")||d||"";t.cssStyles||(t.cssStyles=f.replaceAll("!important","").split(";"));const m=l.members.length===0&&l.methods.length===0&&!r.class?.hideEmptyMembersBox,y=ct.svg(c),x=lt(t,{});t.look!=="handDrawn"&&(x.roughness=0,x.fillStyle="solid");const C=Math.max(t.width??0,h.width);let k=Math.max(t.height??0,h.height);const T=(t.height??0)>h.height;l.members.length===0&&l.methods.length===0?k+=a:l.members.length>0&&l.methods.length===0&&(k+=a*2);const S=-C/2,v=-k/2;let A=m?o*2:l.members.length===0&&l.methods.length===0?-o:0;T&&(A=o*2);const L=y.rectangle(S-o,v-o-(m?o:l.members.length===0&&l.methods.length===0?-o/2:0),C+2*o,k+2*o+A,x),F=c.insert(()=>L,":first-child");F.attr("class","basic label-container outer-path");const Z=F.node().getBBox(),U=c.select(".annotation-group").node().getBBox().height-(m?o/2:0)||0,N=c.select(".label-group").node().getBBox().height-(m?o/2:0)||0,st=c.select(".members-group").node().getBBox().height-(m?o/2:0)||0,Y=(U+N+v+o-(v-o-(m?o:l.members.length===0&&l.methods.length===0?-o/2:0)))/2;if(c.selectAll(".text").each(($,I,B)=>{const q=At(B[I]),O=q.attr("transform");let it=0;if(O){const Tt=RegExp(/translate\(([^,]+),([^)]+)\)/).exec(O);Tt&&(it=parseFloat(Tt[2]))}let tt=it+v+o-(m?o:l.members.length===0&&l.methods.length===0?-o/2:0);if(q.attr("class").includes("methods-group")){const ht=Math.max(st,a/2);T?tt=Math.max(Y,U+N+ht+v+a*2+o)+a*2:tt=U+N+ht+v+a*4+o}l.members.length===0&&l.methods.length===0&&r.class?.hideEmptyMembersBox&&(l.annotations.length>0?tt=it-a:tt=it),n||(tt-=4);let gt=S;(q.attr("class").includes("label-group")||q.attr("class").includes("annotation-group"))&&(gt=-q.node()?.getBBox().width/2||0,c.selectAll("text").each(function(ht,Tt,Ft){window.getComputedStyle(Ft[Tt]).textAnchor==="middle"&&(gt=0)})),q.attr("transform",`translate(${gt}, ${tt})`)}),l.members.length>0||l.methods.length>0||m){const $=U+N+v+o,I=y.line(Z.x,$,Z.x+Z.width,$+.001,x);c.insert(()=>I).attr("class",`divider${t.look==="neo"&&!s?" neo-line":""}`).attr("style",f)}if(m||l.members.length>0||l.methods.length>0){const $=U+N+st+v+a*2+o,I=y.line(Z.x,T?Math.max(Y,$):$,Z.x+Z.width,(T?Math.max(Y,$):$)+.001,x);c.insert(()=>I).attr("class",`divider${t.look==="neo"&&!s?" neo-line":""}`).attr("style",f)}if(l.look!=="handDrawn"&&c.selectAll("path").attr("style",f),F.select(":nth-child(2)").attr("style",f),c.selectAll(".divider").select("path").attr("style",f),t.labelStyle?c.selectAll("span").attr("style",t.labelStyle):c.selectAll("span").attr("style",f),!n){const $=RegExp(/color\s*:\s*([^;]*)/),I=$.exec(f);if(I){const B=I[0].replace("color","fill");c.selectAll("tspan").attr("style",B)}else if(u){const B=$.exec(u);if(B){const q=B[0].replace("color","fill");c.selectAll("tspan").attr("style",q)}}}return dt(t,F),t.intersect=function($){return at.rect(t,$)},c}p(km,"classBox");async function wm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const s=t,o=t,a=20,n=20,l="verifyMethod"in t,c=Ct(t),h=It(),{themeVariables:u}=h,{borderColorArray:d,requirementEdgeLabelBackground:f}=u,m=h.layout==="elk"?"start":"center",y=e.insert("g").attr("class",c).attr("id",t.domId??t.id);let x;l?x=await rr(y,`<<${s.type}>>`,0,t.labelStyle):x=await rr(y,"<<Element>>",0,t.labelStyle);let C=x;const k=await rr(y,s.name,C,t.labelStyle+"; font-weight: bold;");if(C+=k+n,l){const N=await rr(y,`${s.requirementId?`ID: ${s.requirementId}`:""}`,C,t.labelStyle,m);C+=N;const st=await rr(y,`${s.text?`Text: ${s.text}`:""}`,C,t.labelStyle,m);C+=st;const Y=await rr(y,`${s.risk?`Risk: ${s.risk}`:""}`,C,t.labelStyle,m);C+=Y,await rr(y,`${s.verifyMethod?`Verification: ${s.verifyMethod}`:""}`,C,t.labelStyle,m)}else{const N=await rr(y,`${o.type?`Type: ${o.type}`:""}`,C,t.labelStyle,m);C+=N,await rr(y,`${o.docRef?`Doc Ref: ${o.docRef}`:""}`,C,t.labelStyle,m)}const T=(y.node()?.getBBox().width??200)+a,S=(y.node()?.getBBox().height??200)+a,v=-T/2,A=-S/2,L=ct.svg(y),F=lt(t,{});t.look!=="handDrawn"&&(F.roughness=0,F.fillStyle="solid");const Z=L.rectangle(v,A,T,S,F),U=y.insert(()=>Z,":first-child");if(U.attr("class","basic label-container outer-path").attr("style",i),d?.length){const N=t.colorIndex??0;y.attr("data-color-id",`color-${N%d.length}`)}if(y.selectAll(".label").each((N,st,Y)=>{const $=At(Y[st]),I=$.attr("transform");let B=0,q=0;if(I){const gt=RegExp(/translate\(([^,]+),([^)]+)\)/).exec(I);gt&&(B=parseFloat(gt[1]),q=parseFloat(gt[2]))}const O=q-S/2;let it=v+a/2;(st===0||st===1)&&(it=B),$.attr("transform",`translate(${it}, ${O+a})`)}),C>x+k+n){const N=A+x+k+n;let st;if(t.look==="neo"){const I=[[v,N],[v+T,N],[v+T,N+.001],[v,N+.001]];st=L.polygon(I,F)}else st=L.line(v,N,v+T,N,F);y.insert(()=>st).attr("class","divider")}return dt(t,U),t.intersect=function(N){return at.rect(t,N)},i&&t.look!=="handDrawn"&&(f||d?.length)&&y.selectAll("path").attr("style",i),y}p(wm,"requirementBox");async function rr(e,t,r,i="",s="center"){if(t==="")return 0;const o=e.insert("g").attr("class","label").attr("style",i),a=It(),n=a.htmlLabels??!0,l=await Qe(o,bl(Wr(t)),{width:vr(t,a)+50,classes:"markdown-node-label",useHtmlLabels:n,style:i},a);let c;if(n){const h=l.children[0],u=At(l);s==="start"&&At(h).style("text-align","left"),c=h.getBoundingClientRect(),u.attr("width",c.width),u.attr("height",c.height)}else{const h=l.children[0];for(const u of h.children)i&&u.setAttribute("style",i);if(s==="start"){h.setAttribute("text-anchor","start");for(const u of h.children)u.setAttribute("text-anchor","start")}c=l.getBBox(),c.height+=6}return o.attr("transform",`translate(${-c.width/2},${-c.height/2+r})`),c.height}p(rr,"addText");var Q_=p(e=>{switch(e){case"Very High":return"red";case"High":return"orange";case"Medium":return null;case"Low":return"blue";case"Very Low":return"lightblue"}},"colorFromPriority");async function Tm(e,t,{config:r}){const{labelStyles:i,nodeStyles:s}=ft(t);t.labelStyle=i||"";const o=10,a=t.width;t.width=(t.width??200)-10;const{shapeSvg:n,bbox:l,label:c}=await xt(e,t,Ct(t)),h=t.padding||10;let u="",d;"ticket"in t&&t.ticket&&r?.kanban?.ticketBaseUrl&&(u=r?.kanban?.ticketBaseUrl.replace("#TICKET#",t.ticket),d=n.insert("svg:a",":first-child").attr("class","kanban-ticket-link").attr("xlink:href",u).attr("target","_blank"));const f={useHtmlLabels:t.useHtmlLabels,labelStyle:t.labelStyle||"",width:t.width,img:t.img,padding:t.padding||8,centerLabel:!1};let m,y;d?{label:m,bbox:y}=await Wa(d,"ticket"in t&&t.ticket||"",f):{label:m,bbox:y}=await Wa(n,"ticket"in t&&t.ticket||"",f);const{label:x,bbox:C}=await Wa(n,"assigned"in t&&t.assigned||"",f);t.width=a;const k=10,T=t?.width||0,S=Math.max(y.height,C.height)/2,v=Math.max(l.height+k*2,t?.height||0)+S,A=-T/2,L=-v/2;c.attr("transform","translate("+(h-T/2)+", "+(-S-l.height/2)+")"),m.attr("transform","translate("+(h-T/2)+", "+(-S+l.height/2)+")"),x.attr("transform","translate("+(h+T/2-C.width-2*o)+", "+(-S+l.height/2)+")");let F;const{rx:Z,ry:U}=t,{cssStyles:N}=t;if(t.look==="handDrawn"){const st=ct.svg(n),Y=lt(t,{}),$=Z||U?st.path(He(A,L,T,v,Z||0),Y):st.rectangle(A,L,T,v,Y);F=n.insert(()=>$,":first-child"),F.attr("class","basic label-container").attr("style",N||null)}else{F=n.insert("rect",":first-child"),F.attr("class","basic label-container __APA__").attr("style",s).attr("rx",Z??5).attr("ry",U??5).attr("x",A).attr("y",L).attr("width",T).attr("height",v);const st="priority"in t&&t.priority;if(st){const Y=n.append("line"),$=A+2,I=L+Math.floor((Z??0)/2),B=L+v-Math.floor((Z??0)/2);Y.attr("x1",$).attr("y1",I).attr("x2",$).attr("y2",B).attr("stroke-width","4").attr("stroke",Q_(st))}}return dt(t,F),t.height=v,t.intersect=function(st){return at.rect(t,st)},n}p(Tm,"kanbanItem");async function _m(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,halfPadding:a,label:n}=await xt(e,t,Ct(t)),l=o.width+10*a,c=o.height+8*a,h=.15*l,{cssStyles:u}=t,d=o.width+20,f=o.height+20,m=Math.max(l,d),y=Math.max(c,f);n.attr("transform",`translate(${-o.width/2}, ${-o.height/2})`);let x;const C=`M0 0 + a${h},${h} 1 0,0 ${m*.25},${-1*y*.1} + a${h},${h} 1 0,0 ${m*.25},0 + a${h},${h} 1 0,0 ${m*.25},0 + a${h},${h} 1 0,0 ${m*.25},${y*.1} + + a${h},${h} 1 0,0 ${m*.15},${y*.33} + a${h*.8},${h*.8} 1 0,0 0,${y*.34} + a${h},${h} 1 0,0 ${-1*m*.15},${y*.33} + + a${h},${h} 1 0,0 ${-1*m*.25},${y*.15} + a${h},${h} 1 0,0 ${-1*m*.25},0 + a${h},${h} 1 0,0 ${-1*m*.25},0 + a${h},${h} 1 0,0 ${-1*m*.25},${-1*y*.15} + + a${h},${h} 1 0,0 ${-1*m*.1},${-1*y*.33} + a${h*.8},${h*.8} 1 0,0 0,${-1*y*.34} + a${h},${h} 1 0,0 ${m*.1},${-1*y*.33} + H0 V0 Z`;if(t.look==="handDrawn"){const k=ct.svg(s),T=lt(t,{}),S=k.path(C,T);x=s.insert(()=>S,":first-child"),x.attr("class","basic label-container").attr("style",re(u))}else x=s.insert("path",":first-child").attr("class","basic label-container").attr("style",i).attr("d",C);return x.attr("transform",`translate(${-m/2}, ${-y/2})`),dt(t,x),t.calcIntersect=function(k,T){return at.rect(k,T)},t.intersect=function(k){return R.info("Bang intersect",t,k),at.rect(t,k)},s}p(_m,"bang");async function Sm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,halfPadding:a,label:n}=await xt(e,t,Ct(t)),l=o.width+2*a,c=o.height+2*a,h=.15*l,u=.25*l,d=.35*l,f=.2*l,{cssStyles:m}=t;let y;const x=`M0 0 + a${h},${h} 0 0,1 ${l*.25},${-1*l*.1} + a${d},${d} 1 0,1 ${l*.4},${-1*l*.1} + a${u},${u} 1 0,1 ${l*.35},${l*.2} + + a${h},${h} 1 0,1 ${l*.15},${c*.35} + a${f},${f} 1 0,1 ${-1*l*.15},${c*.65} + + a${u},${h} 1 0,1 ${-1*l*.25},${l*.15} + a${d},${d} 1 0,1 ${-1*l*.5},0 + a${h},${h} 1 0,1 ${-1*l*.25},${-1*l*.15} + + a${h},${h} 1 0,1 ${-1*l*.1},${-1*c*.35} + a${f},${f} 1 0,1 ${l*.1},${-1*c*.65} + H0 V0 Z`;if(t.look==="handDrawn"){const C=ct.svg(s),k=lt(t,{}),T=C.path(x,k);y=s.insert(()=>T,":first-child"),y.attr("class","basic label-container").attr("style",re(m))}else y=s.insert("path",":first-child").attr("class","basic label-container").attr("style",i).attr("d",x);return n.attr("transform",`translate(${-o.width/2}, ${-o.height/2})`),y.attr("transform",`translate(${-l/2}, ${-c/2})`),dt(t,y),t.calcIntersect=function(C,k){return at.rect(C,k)},t.intersect=function(C){return R.info("Cloud intersect",t,C),at.rect(t,C)},s}p(Sm,"cloud");async function vm(e,t){const{labelStyles:r,nodeStyles:i}=ft(t);t.labelStyle=r;const{shapeSvg:s,bbox:o,halfPadding:a,label:n}=await xt(e,t,Ct(t)),l=o.width+8*a,c=o.height+2*a,h=5,u=t.look==="neo"?` + M${-l/2} ${c/2-h} + v${-c+2*h} + q0,-${h} ${h},-${h} + h${l-2*h} + q${h},0 ${h},${h} + v${c-h} + H${-l/2} + Z + `:` + M${-l/2} ${c/2-h} + v${-c+2*h} + q0,-${h} ${h},-${h} + h${l-2*h} + q${h},0 ${h},${h} + v${c-2*h} + q0,${h} ${-h},${h} + h${-(l-2*h)} + q${-h},0 ${-h},${-h} + Z + `;if(!t.domId)throw new Error(`defaultMindmapNode: node "${t.id}" is missing a domId — was render.ts domId prefixing skipped?`);const d=s.append("path").attr("id",t.domId).attr("class","node-bkg node-"+t.type).attr("style",i).attr("d",u);return s.append("line").attr("class","node-line-").attr("x1",-l/2).attr("y1",c/2).attr("x2",l/2).attr("y2",c/2),n.attr("transform",`translate(${-o.width/2}, ${-o.height/2})`),s.append(()=>n.node()),dt(t,d),t.calcIntersect=function(f,m){return at.rect(f,m)},t.intersect=function(f){return at.rect(t,f)},s}p(vm,"defaultMindmapNode");async function Bm(e,t){const r={padding:t.padding??0};return sh(e,t,r)}p(Bm,"mindmapCircle");var J_=[{semanticName:"Process",name:"Rectangle",shortName:"rect",description:"Standard process shape",aliases:["proc","process","rectangle"],internalAliases:["squareRect"],handler:sm},{semanticName:"Event",name:"Rounded Rectangle",shortName:"rounded",description:"Represents an event",aliases:["event"],internalAliases:["roundedRect"],handler:em},{semanticName:"Terminal Point",name:"Stadium",shortName:"stadium",description:"Terminal point",aliases:["terminal","pill"],handler:om},{semanticName:"Subprocess",name:"Framed Rectangle",shortName:"fr-rect",description:"Subprocess",aliases:["subprocess","subproc","framed-rectangle","subroutine"],handler:hm},{semanticName:"Database",name:"Cylinder",shortName:"cyl",description:"Database storage",aliases:["db","database","cylinder"],handler:vg},{semanticName:"Data Store",name:"Data Store",shortName:"datastore",description:"Data flow diagram data store",aliases:["data-store"],handler:Bg},{semanticName:"Folder",name:"Folder",shortName:"folder",description:"Folder or directory",aliases:["directory"],handler:Mg},{semanticName:"Bucket",name:"Bucket",shortName:"bucket",description:"Object storage bucket",handler:ug},{semanticName:"Console",name:"Console (terminal window)",shortName:"console",description:"Terminal or console window",handler:xg},{semanticName:"Browser",name:"Browser",shortName:"browser",description:"Browser window",handler:pg},{semanticName:"Person",name:"Person",shortName:"person",description:"Person (circular head above a rounded body)",handler:Sg},{semanticName:"Start",name:"Circle",shortName:"circle",description:"Starting point",aliases:["circ"],handler:sh},{semanticName:"Bang",name:"Bang",shortName:"bang",description:"Bang",aliases:["bang"],handler:_m},{semanticName:"Cloud",name:"Cloud",shortName:"cloud",description:"cloud",aliases:["cloud"],handler:Sm},{semanticName:"Decision",name:"Diamond",shortName:"diam",description:"Decision-making step",aliases:["decision","diamond","question"],handler:Qg},{semanticName:"Prepare Conditional",name:"Hexagon",shortName:"hex",description:"Preparation or condition step",aliases:["hexagon","prepare"],handler:Dg},{semanticName:"Data Input/Output",name:"Lean Right",shortName:"lean-r",description:"Represents input or output",aliases:["lean-right","in-out"],internalAliases:["lean_right"],handler:Ug},{semanticName:"Data Input/Output",name:"Lean Left",shortName:"lean-l",description:"Represents output or input",aliases:["lean-left","out-in"],internalAliases:["lean_left"],handler:Yg},{semanticName:"Priority Action",name:"Trapezoid Base Bottom",shortName:"trap-b",description:"Priority action",aliases:["priority","trapezoid-bottom","trapezoid"],handler:pm},{semanticName:"Manual Operation",name:"Trapezoid Base Top",shortName:"trap-t",description:"Represents a manual task",aliases:["manual","trapezoid-top","inv-trapezoid"],internalAliases:["inv_trapezoid"],handler:Wg},{semanticName:"Stop",name:"Double Circle",shortName:"dbl-circ",description:"Represents a stop point",aliases:["double-circle"],internalAliases:["doublecircle"],handler:Fg},{semanticName:"Text Block",name:"Text Block",shortName:"text",description:"Text block",handler:dm},{semanticName:"Card",name:"Notched Rectangle",shortName:"notch-rect",description:"Represents a card",aliases:["card","notched-rectangle"],handler:gg},{semanticName:"Lined/Shaded Process",name:"Lined Rectangle",shortName:"lin-rect",description:"Lined process shape",aliases:["lined-rectangle","lined-process","lin-proc","shaded-process"],handler:rm},{semanticName:"Start",name:"Small Circle",shortName:"sm-circ",description:"Small starting point",aliases:["start","small-circle"],internalAliases:["stateStart"],handler:lm},{semanticName:"Stop",name:"Framed Circle",shortName:"fr-circ",description:"Stop point",aliases:["stop","framed-circle"],internalAliases:["stateEnd"],handler:nm},{semanticName:"Fork/Join",name:"Filled Rectangle",shortName:"fork",description:"Fork or join in process flow",aliases:["join"],internalAliases:["forkJoin"],handler:$g},{semanticName:"Collate",name:"Hourglass",shortName:"hourglass",description:"Represents a collate operation",aliases:["hourglass","collate"],handler:Ig},{semanticName:"Comment",name:"Curly Brace",shortName:"brace",description:"Adds a comment",aliases:["comment","brace-l"],handler:kg},{semanticName:"Comment Right",name:"Curly Brace",shortName:"brace-r",description:"Adds a comment",handler:wg},{semanticName:"Comment with braces on both sides",name:"Curly Braces",shortName:"braces",description:"Adds a comment",handler:Tg},{semanticName:"Com Link",name:"Lightning Bolt",shortName:"bolt",description:"Communication link",aliases:["com-link","lightning-bolt"],handler:jg},{semanticName:"Document",name:"Document",shortName:"doc",description:"Represents a document",aliases:["doc","document"],handler:ym},{semanticName:"Delay",name:"Half-Rounded Rectangle",shortName:"delay",description:"Represents a delay",aliases:["half-rounded-rectangle"],handler:Og},{semanticName:"Direct Access Storage",name:"Horizontal Cylinder",shortName:"h-cyl",description:"Direct access storage",aliases:["das","horizontal-cylinder"],handler:fm},{semanticName:"Disk Storage",name:"Lined Cylinder",shortName:"lin-cyl",description:"Disk storage",aliases:["disk","lined-cylinder"],handler:Gg},{semanticName:"Display",name:"Curved Trapezoid",shortName:"curv-trap",description:"Represents a display",aliases:["curved-trapezoid","display"],handler:_g},{semanticName:"Divided Process",name:"Divided Rectangle",shortName:"div-rect",description:"Divided process shape",aliases:["div-proc","divided-rectangle","divided-process"],handler:Lg},{semanticName:"Extract",name:"Triangle",shortName:"tri",description:"Extraction process",aliases:["extract","triangle"],handler:mm},{semanticName:"Internal Storage",name:"Window Pane",shortName:"win-pane",description:"Internal storage",aliases:["internal-storage","window-pane"],handler:Cm},{semanticName:"Junction",name:"Filled Circle",shortName:"f-circ",description:"Junction point",aliases:["junction","filled-circle"],handler:Ag},{semanticName:"Loop Limit",name:"Trapezoidal Pentagon",shortName:"notch-pent",description:"Loop limit step",aliases:["loop-limit","notched-pentagon"],handler:gm},{semanticName:"Manual File",name:"Flipped Triangle",shortName:"flip-tri",description:"Manual file operation",aliases:["manual-file","flipped-triangle"],handler:Eg},{semanticName:"Manual Input",name:"Sloped Rectangle",shortName:"sl-rect",description:"Manual input step",aliases:["manual-input","sloped-rectangle"],handler:im},{semanticName:"Multi-Document",name:"Stacked Document",shortName:"docs",description:"Multiple documents",aliases:["documents","st-doc","stacked-document"],handler:Zg},{semanticName:"Multi-Process",name:"Stacked Rectangle",shortName:"st-rect",description:"Multiple processes",aliases:["procs","processes","stacked-rectangle"],handler:Vg},{semanticName:"Stored Data",name:"Bow Tie Rectangle",shortName:"bow-rect",description:"Stored data",aliases:["stored-data","bow-tie-rectangle"],handler:cg},{semanticName:"Summary",name:"Crossed Circle",shortName:"cross-circ",description:"Summary",aliases:["summary","crossed-circle"],handler:bg},{semanticName:"Tagged Document",name:"Tagged Document",shortName:"tag-doc",description:"Tagged document",aliases:["tag-doc","tagged-document"],handler:um},{semanticName:"Tagged Process",name:"Tagged Rectangle",shortName:"tag-rect",description:"Tagged process",aliases:["tagged-rectangle","tag-proc","tagged-process"],handler:cm},{semanticName:"Paper Tape",name:"Flag",shortName:"flag",description:"Paper tape",aliases:["paper-tape"],handler:xm},{semanticName:"Odd",name:"Odd",shortName:"odd",description:"Odd shape",internalAliases:["rect_left_inv_arrow"],handler:Jg},{semanticName:"Lined Document",name:"Lined Document",shortName:"lin-doc",description:"Lined document",aliases:["lined-document"],handler:Xg}],tS=p(()=>{const t=[...Object.entries({state:am,choice:mg,note:Kg,composite:yg,rectWithTitle:tm,labelRect:Hg,block_arrow:fg,collapsedGroup:dg,iconSquare:qg,iconCircle:Rg,icon:Pg,iconRounded:Ng,imageSquare:zg,anchor:lg,kanbanItem:Tm,mindmapCircle:Bm,defaultMindmapNode:vm,classBox:km,erBox:oh,requirementBox:wm}),...J_.flatMap(r=>[r.shortName,..."aliases"in r?r.aliases:[],..."internalAliases"in r?r.internalAliases:[]].map(s=>[s,r.handler]))];return Object.fromEntries(t)},"generateShapeMap"),Lm=tS();function eS(e){return e in Lm}p(eS,"isValidShape");var oa=p(({flowchart:e})=>{const t=e?.subGraphTitleMargin?.top??0,r=e?.subGraphTitleMargin?.bottom??0,i=t+r;return{subGraphTitleTopMargin:t,subGraphTitleBottomMargin:r,subGraphTitleTotalMargin:i}},"getSubGraphTitleMargins"),aa=new Map;async function ah(e,t,r){let i,s;t.shape==="rect"&&(t.rx&&t.ry?t.shape="roundedRect":t.shape="squareRect");const o=t.shape?Lm[t.shape]:void 0;if(!o)throw new Error(`No such shape: ${t.shape}. Please check your syntax.`);if(t.link){let a;r.config.securityLevel==="sandbox"?a="_top":t.linkTarget&&(a=t.linkTarget||"_blank"),i=e.insert("svg:a").attr("xlink:href",t.link).attr("target",a??null),s=await o(i,t,r)}else s=await o(e,t,r),i=s;return i.attr("data-look",re(t.look)),t.tooltip&&s.attr("title",t.tooltip),aa.set(t.id,i),t.haveCallback&&i.attr("class",i.attr("class")+" clickable"),i}p(ah,"insertNode");var l3=p((e,t)=>{aa.set(t.id,e)},"setNodeElem"),rS=p(()=>{aa.clear()},"clear"),Su=p(e=>{const t=aa.get(e.id);R.trace("Transforming node",e.diff,e,"translate("+(e.x-e.width/2-5)+", "+e.width/2+")");const r=8,i=e.diff||0;return e.clusterNode?t.attr("transform","translate("+(e.x+i-e.width/2)+", "+(e.y-e.height/2-r)+")"):t.attr("transform","translate("+e.x+", "+e.y+")"),i},"positionNode"),iS=p(async(e,t)=>{const r=It(),{themeVariables:i,handDrawnSeed:s}=r,{clusterBkg:o,clusterBorder:a}=i,n=a,{labelStyles:l,nodeStyles:c,borderStyles:h,backgroundStyles:u}=ft(t),d=e.insert("g").attr("class","cluster swimlane "+(t.cssClasses||"")).attr("id",t.id).attr("data-id",t.id).attr("data-et","cluster").attr("data-look",t.look),f=ur(r.flowchart.htmlLabels),m=t.direction==="LR",y=d.insert("g").attr("class","cluster-label swimlane-label"),x=await Qe(y,t.label,{style:t.labelStyle,useHtmlLabels:f,isNode:!0,width:t.width});let C=x.getBBox();if(f){const Y=x.children[0],$=At(x);C=Y.getBoundingClientRect(),$.attr("width",C.width),$.attr("height",C.height)}const k=t.padding??0,T=t.width<=C.width+k?C.width+k:t.width;t.width<=C.width+k?t.diff=(T-t.width)/2-k:t.diff=-k;const S=t.height,v=t.y-S/2,A=t.y+S/2,L=t.x-T/2,F=t.swimlaneContentTop!==void 0?t.swimlaneContentTop:v+S/3,Z=m?4:0,U=C.height+2*Z;let N,st;if(m){const Y=Math.max(U,C.height+2*Z),$=L+Y,I=Math.max(0,T-Y);if(t.look==="handDrawn"){const O=ct.svg(d),it=lt(t,{roughness:.7,fill:o,stroke:n,fillWeight:3,seed:s}),tt=lt(t,{roughness:.7,fill:"none",stroke:n,seed:s}),gt=O.rectangle(L,v,Y,S,it);N=d.insert(()=>gt,":first-child");const ht=O.rectangle($,v,I,S,tt);st=d.insert(()=>ht,":first-child"),N.select("path:nth-child(2)").attr("style",h.join(";")),N.select("path").attr("style",u.join(";").replace("fill","stroke"))}else N=d.insert("rect",":first-child"),st=d.insert("rect",":first-child"),N.attr("class","swimlane-title").attr("style",c).attr("x",L).attr("y",v).attr("width",Y).attr("height",S).attr("fill",o).attr("stroke",n),st.attr("class","swimlane-body").attr("style",c).attr("x",$).attr("y",v).attr("width",I).attr("height",S).attr("fill","none").attr("stroke",n);const B=L+Y/2,q=t.y;y.attr("transform",`translate(${B}, ${q}) rotate(-90) translate(${-C.width/2}, ${-C.height/2})`)}else{const Y=Math.max(0,F-v),$=Math.min(U,Y),I=v+$,B=Math.max(0,A-I),q=t.x-T/2;if(t.look==="handDrawn"){const tt=ct.svg(d),gt=lt(t,{roughness:.7,fill:o,stroke:n,fillWeight:3,seed:s}),ht=lt(t,{roughness:.7,fill:"none",stroke:n,seed:s}),Tt=tt.rectangle(q,v,T,$,gt);N=d.insert(()=>Tt,":first-child");const Ft=tt.rectangle(q,I,T,B,ht);st=d.insert(()=>Ft,":first-child"),N.select("path:nth-child(2)").attr("style",h.join(";")),N.select("path").attr("style",u.join(";").replace("fill","stroke"))}else N=d.insert("rect",":first-child"),st=d.insert("rect",":first-child"),N.attr("class","swimlane-title").attr("style",c).attr("x",q).attr("y",v).attr("width",T).attr("height",$).attr("fill",o).attr("stroke",n),st.attr("class","swimlane-body").attr("style",c).attr("x",q).attr("y",I).attr("width",T).attr("height",B).attr("fill","none").attr("stroke",n);const O=t.x-C.width/2,it=v+($-C.height)/2;y.attr("transform",`translate(${O}, ${it})`)}if(R.trace("Swimlane data ",t,JSON.stringify(t)),l){const Y=y.select("span");Y&&Y.attr("style",l)}return t.offsetX=0,t.width=T,t.height=S,t.offsetY=C.height-k/2,t.intersect=function(Y){return di(t,Y)},{cluster:d,labelBBox:C}},"swimlane"),Fm=p(async(e,t)=>{R.info("Creating subgraph rect for ",t.id,t);const r=It(),{themeVariables:i,handDrawnSeed:s}=r,{clusterBkg:o,clusterBorder:a}=i,{labelStyles:n,nodeStyles:l,borderStyles:c,backgroundStyles:h}=ft(t),u=e.insert("g").attr("class","cluster "+t.cssClasses).attr("id",t.domId).attr("data-look",t.look),d=be(r),f=u.insert("g").attr("class","cluster-label ");let m;t.labelType==="markdown"?m=await Qe(f,t.label,{style:t.labelStyle,useHtmlLabels:d,isNode:!0,width:t.width}):m=await Rr(f,t.label,t.labelStyle||"",!1,!0);let y=m.getBBox();if(be(r)){const L=m.children[0],F=At(m);y=L.getBoundingClientRect(),F.attr("width",y.width),F.attr("height",y.height)}const x=t.width<=y.width+t.padding?y.width+t.padding:t.width;t.width<=y.width+t.padding?t.diff=(x-t.width)/2-t.padding:t.diff=-t.padding;const C=t.height,k=t.x-x/2,T=t.y-C/2;R.trace("Data ",t,JSON.stringify(t));let S;if(t.look==="handDrawn"){const L=ct.svg(u),F=lt(t,{roughness:.7,fill:o,stroke:a,fillWeight:3,seed:s}),Z=L.path(He(k,T,x,C,0),F);S=u.insert(()=>(R.debug("Rough node insert CXC",Z),Z),":first-child"),S.select("path:nth-child(2)").attr("style",c.join(";")),S.select("path").attr("style",h.join(";").replace("fill","stroke"))}else S=u.insert("rect",":first-child"),S.attr("style",l).attr("rx",t.rx).attr("ry",t.ry).attr("x",k).attr("y",T).attr("width",x).attr("height",C);const{subGraphTitleTopMargin:v}=oa(r);if(f.attr("transform",`translate(${t.x-y.width/2}, ${t.y-t.height/2+v})`),n){const L=f.select("span");L&&L.attr("style",n)}const A=S.node().getBBox();return t.offsetX=0,t.width=A.width,t.height=A.height,t.offsetY=y.height-t.padding/2,t.intersect=function(L){return di(t,L)},{cluster:u,labelBBox:y}},"rect"),sS=p((e,t)=>{const r=e.insert("g").attr("class","note-cluster").attr("id",t.domId),i=r.insert("rect",":first-child"),s=0*t.padding,o=s/2;i.attr("rx",t.rx).attr("ry",t.ry).attr("x",t.x-t.width/2-o).attr("y",t.y-t.height/2-o).attr("width",t.width+s).attr("height",t.height+s).attr("fill","none");const a=i.node().getBBox();return t.width=a.width,t.height=a.height,t.intersect=function(n){return di(t,n)},{cluster:r,labelBBox:{width:0,height:0}}},"noteGroup"),oS=p(async(e,t)=>{const r=It(),{themeVariables:i,handDrawnSeed:s}=r,{altBackground:o,compositeBackground:a,compositeTitleBackground:n,nodeBorder:l}=i,c=e.insert("g").attr("class",t.cssClasses).attr("id",t.domId).attr("data-id",t.id).attr("data-look",t.look),h=c.insert("g",":first-child"),u=c.insert("g").attr("class","cluster-label");let d=c.append("rect");const f=await Rr(u,t.label,t.labelStyle,void 0,!0);let m=f.getBBox();if(be(r)){const Z=f.children[0],U=At(f);m=Z.getBoundingClientRect(),U.attr("width",m.width),U.attr("height",m.height)}const y=0*t.padding,x=y/2,C=(t.width<=m.width+t.padding?m.width+t.padding:t.width)+y;t.width<=m.width+t.padding?t.diff=(C-t.width)/2-t.padding:t.diff=-t.padding;const k=t.height+y,T=t.height+y-m.height-6,S=t.x-C/2,v=t.y-k/2;t.width=C;const A=t.y-t.height/2-x+m.height+2;let L;if(t.look==="handDrawn"){const Z=t.cssClasses.includes("statediagram-cluster-alt"),U=ct.svg(c),N=t.rx||t.ry?U.path(He(S,v,C,k,10),{roughness:.7,fill:n,fillStyle:"solid",stroke:l,seed:s}):U.rectangle(S,v,C,k,{seed:s});L=c.insert(()=>N,":first-child");const st=U.rectangle(S,A,C,T,{fill:Z?o:a,fillStyle:Z?"hachure":"solid",stroke:l,seed:s});L=c.insert(()=>N,":first-child"),d=c.insert(()=>st)}else L=h.insert("rect",":first-child"),L.attr("class","outer").attr("x",S).attr("y",v).attr("width",C).attr("height",k).attr("data-look",t.look),d.attr("class","inner").attr("x",S).attr("y",A).attr("width",C).attr("height",T);u.attr("transform",`translate(${t.x-m.width/2}, ${v+1-(be(r)?0:3)})`);const F=L.node().getBBox();return t.height=F.height,t.offsetX=0,t.offsetY=m.height-t.padding/2,t.labelBBox=m,t.intersect=function(Z){return di(t,Z)},{cluster:c,labelBBox:m}},"roundedWithTitle"),aS=p(async(e,t)=>{R.info("Creating subgraph rect for ",t.id,t);const r=It(),{themeVariables:i,handDrawnSeed:s}=r,{clusterBkg:o,clusterBorder:a}=i,{labelStyles:n,nodeStyles:l,borderStyles:c,backgroundStyles:h}=ft(t),u=e.insert("g").attr("class","cluster "+t.cssClasses).attr("id",t.domId).attr("data-look",t.look),d=be(r),f=u.insert("g").attr("class","cluster-label "),m=await Qe(f,t.label,{style:t.labelStyle,useHtmlLabels:d,isNode:!0,width:t.width});let y=m.getBBox();if(be(r)){const L=m.children[0],F=At(m);y=L.getBoundingClientRect(),F.attr("width",y.width),F.attr("height",y.height)}const x=t.width<=y.width+t.padding?y.width+t.padding:t.width;t.width<=y.width+t.padding?t.diff=(x-t.width)/2-t.padding:t.diff=-t.padding;const C=t.height,k=t.x-x/2,T=t.y-C/2;R.trace("Data ",t,JSON.stringify(t));let S;if(t.look==="handDrawn"){const L=ct.svg(u),F=lt(t,{roughness:.7,fill:o,stroke:a,fillWeight:4,seed:s}),Z=L.path(He(k,T,x,C,t.rx),F);S=u.insert(()=>(R.debug("Rough node insert CXC",Z),Z),":first-child"),S.select("path:nth-child(2)").attr("style",c.join(";")),S.select("path").attr("style",h.join(";").replace("fill","stroke"))}else S=u.insert("rect",":first-child"),S.attr("style",l).attr("rx",t.rx).attr("ry",t.ry).attr("x",k).attr("y",T).attr("width",x).attr("height",C);const{subGraphTitleTopMargin:v}=oa(r);if(f.attr("transform",`translate(${t.x-y.width/2}, ${t.y-t.height/2+v})`),n){const L=f.select("span");L&&L.attr("style",n)}const A=S.node().getBBox();return t.offsetX=0,t.width=A.width,t.height=A.height,t.offsetY=y.height-t.padding/2,t.intersect=function(L){return di(t,L)},{cluster:u,labelBBox:y}},"kanbanSection"),nS=p((e,t)=>{const r=It(),{themeVariables:i,handDrawnSeed:s}=r,{nodeBorder:o}=i,a=e.insert("g").attr("class",t.cssClasses).attr("id",t.domId).attr("data-look",t.look),n=a.insert("g",":first-child"),l=0*t.padding,c=t.width+l;t.diff=-t.padding;const h=t.height+l,u=t.x-c/2,d=t.y-h/2;t.width=c;let f;if(t.look==="handDrawn"){const x=ct.svg(a).rectangle(u,d,c,h,{fill:"lightgrey",roughness:.5,strokeLineDash:[5],stroke:o,seed:s});f=a.insert(()=>x,":first-child")}else{f=n.insert("rect",":first-child");let y="outer";t.look,y="divider",f.attr("class",y).attr("x",u).attr("y",d).attr("width",c).attr("height",h).attr("data-look",t.look)}const m=f.node().getBBox();return t.height=m.height,t.offsetX=0,t.offsetY=0,t.intersect=function(y){return di(t,y)},{cluster:a,labelBBox:{}}},"divider"),lS=Fm,hS={rect:Fm,squareRect:lS,roundedWithTitle:oS,noteGroup:sS,divider:nS,kanbanSection:aS,swimlane:iS},Am=new Map,Em=p(async(e,t)=>{const r=t.shape||"rect",i=await hS[r](e,t);return Am.set(t.id,i),i},"insertCluster"),cS=p(()=>{Am=new Map},"clear"),rs=p((e,t)=>{if(t)return"translate("+-e.width/2+", "+-e.height/2+")";const r=e.x??0,i=e.y??0;return"translate("+-(r+e.width/2)+", "+-(i+e.height/2)+")"},"computeLabelTransform"),xe={aggregation:17.25,extension:17.25,composition:17.25,dependency:6,lollipop:13.5,arrow_point:4,arrow_barb:0,arrow_barb_neo:5.5},vu={arrow_point:4,arrow_cross:12.5,arrow_circle:12.5};function ds(e,t){if(e===void 0||t===void 0)return{angle:0,deltaX:0,deltaY:0};e=Vt(e),t=Vt(t);const[r,i]=[e.x,e.y],[s,o]=[t.x,t.y],a=s-r,n=o-i;return{angle:Math.atan(n/a),deltaX:a,deltaY:n}}p(ds,"calculateDeltaAndAngle");var Vt=p(e=>Array.isArray(e)?{x:e[0],y:e[1]}:e,"pointTransformer"),uS=p(e=>({x:p(function(t,r,i){let s=0;const o=Vt(i[0]).x=0?1:-1)}else if(r===i.length-1&&Object.hasOwn(xe,e.arrowTypeEnd)){const{angle:f,deltaX:m}=ds(i[i.length-1],i[i.length-2]);s=xe[e.arrowTypeEnd]*Math.cos(f)*(m>=0?1:-1)}const a=Math.abs(Vt(t).x-Vt(i[i.length-1]).x),n=Math.abs(Vt(t).y-Vt(i[i.length-1]).y),l=Math.abs(Vt(t).x-Vt(i[0]).x),c=Math.abs(Vt(t).y-Vt(i[0]).y),h=xe[e.arrowTypeStart],u=xe[e.arrowTypeEnd],d=1;if(a0&&n0&&c=0?1:-1)}else if(r===i.length-1&&Object.hasOwn(xe,e.arrowTypeEnd)){const{angle:f,deltaY:m}=ds(i[i.length-1],i[i.length-2]);s=xe[e.arrowTypeEnd]*Math.abs(Math.sin(f))*(m>=0?1:-1)}const a=Math.abs(Vt(t).y-Vt(i[i.length-1]).y),n=Math.abs(Vt(t).x-Vt(i[i.length-1]).x),l=Math.abs(Vt(t).y-Vt(i[0]).y),c=Math.abs(Vt(t).x-Vt(i[0]).x),h=xe[e.arrowTypeStart],u=xe[e.arrowTypeEnd],d=1;if(a0&&n0&&c{t.arrowTypeStart&&Bu(e,"start",t.arrowTypeStart,r,i,s,o,a),t.arrowTypeEnd&&Bu(e,"end",t.arrowTypeEnd,r,i,s,o,a)},"addEdgeMarkers"),fS={arrow_cross:{type:"cross",fill:!1},arrow_point:{type:"point",fill:!0},arrow_barb:{type:"barb",fill:!0},arrow_barb_neo:{type:"barb",fill:!0},arrow_circle:{type:"circle",fill:!1},aggregation:{type:"aggregation",fill:!1},extension:{type:"extension",fill:!1},composition:{type:"composition",fill:!0},dependency:{type:"dependency",fill:!0},lollipop:{type:"lollipop",fill:!1},only_one:{type:"onlyOne",fill:!1},zero_or_one:{type:"zeroOrOne",fill:!1},one_or_more:{type:"oneOrMore",fill:!1},zero_or_more:{type:"zeroOrMore",fill:!1},requirement_arrow:{type:"requirement_arrow",fill:!1},requirement_contains:{type:"requirement_contains",fill:!1}},pS=["cross","point","circle","lollipop","aggregation","extension","composition","dependency","barb"],Bu=p((e,t,r,i,s,o,a=!1,n)=>{if(!r||r==="none")return;const l=fS[r],c=l&&pS.includes(l.type);if(!l){R.warn(`Unknown arrow type: ${r}`);return}const h=l.type,f=`${s}_${o}-${h}${t==="start"?"Start":"End"}${a&&c?"-margin":""}`;if(n&&n.trim()!==""){const m=n.replace(/[^\dA-Za-z]/g,"_"),y=`${f}_${m}`;if(!document.getElementById(y)){const x=document.getElementById(f);if(x){const C=x.cloneNode(!0);C.id=y,C.querySelectorAll("path, circle, line").forEach(T=>{T.setAttribute("stroke",n),l.fill&&T.setAttribute("fill",n)}),x.parentNode?.appendChild(C)}}e.attr(`marker-${t}`,`url(${i}#${y})`)}else e.attr(`marker-${t}`,`url(${i}#${f})`)},"addEdgeMarker"),gS=p(e=>typeof e=="string"?e:It()?.flowchart?.curve,"resolveEdgeCurveType"),Pi=new Map,te=new Map,mS=p(()=>{Pi.clear(),te.clear()},"clear"),Mm=p(e=>!!(e.label||e.startLabelLeft||e.startLabelRight||e.endLabelLeft||e.endLabelRight),"hasEdgeLabel"),is=p(e=>e?typeof e=="string"?e:e.reduce((t,r)=>t+";"+r,""):"","getLabelStyles"),nh=p(async(e,t)=>{const r=It();let i=be(r);const{labelStyles:s}=ft(t);t.labelStyle=s;const o=e.insert("g").attr("class","edgeLabel"),a=o.insert("g").attr("class","label").attr("data-id",t.id),n=t.labelType==="markdown",c=await Qe(e,t.label,{style:is(t.labelStyle),useHtmlLabels:i,addSvgBackground:!0,isNode:!1,markdown:n,width:n?void 0:void 0},r);a.node().appendChild(c),R.info("abc82",t,t.labelType);let h,u;if(i){const f=c.children[0],m=At(c);h=await ni.measure(()=>f.getBoundingClientRect()),u=h,m.attr("width",h.width),m.attr("height",h.height)}else{const f=At(c).select("text").node();await ni.measure(()=>{h=c.getBBox(),f&&typeof f.getBBox=="function"?u=f.getBBox():u=h})}a.attr("transform",rs(u,i)),Pi.set(t.id,o),t.width=h.width,t.height=h.height;let d;if(t.startLabelLeft){const f=e.insert("g").attr("class","edgeTerminals"),m=f.insert("g").attr("class","inner"),y=await Rr(m,t.startLabelLeft,is(t.labelStyle)||"",!1,!1);d=y;let x=y.getBBox();if(i){const C=y.children[0],k=At(y);x=C.getBoundingClientRect(),k.attr("width",x.width),k.attr("height",x.height)}m.attr("transform",rs(x,i)),te.get(t.id)||te.set(t.id,{}),te.get(t.id).startLeft=f,fs(d,t.startLabelLeft)}if(t.startLabelRight){const f=e.insert("g").attr("class","edgeTerminals"),m=f.insert("g").attr("class","inner"),y=await Rr(m,t.startLabelRight,is(t.labelStyle)||"",!1,!1);d=y;let x=y.getBBox();if(i){const C=y.children[0],k=At(y);x=C.getBoundingClientRect(),k.attr("width",x.width),k.attr("height",x.height)}m.attr("transform",rs(x,i)),te.get(t.id)||te.set(t.id,{}),te.get(t.id).startRight=f,fs(d,t.startLabelRight)}if(t.endLabelLeft){const f=e.insert("g").attr("class","edgeTerminals"),m=f.insert("g").attr("class","inner"),y=await Rr(f,t.endLabelLeft,is(t.labelStyle)||"",!1,!1);d=y;let x=y.getBBox();if(i){const C=y.children[0],k=At(y);x=C.getBoundingClientRect(),k.attr("width",x.width),k.attr("height",x.height)}m.attr("transform",rs(x,i)),te.get(t.id)||te.set(t.id,{}),te.get(t.id).endLeft=f,fs(d,t.endLabelLeft)}if(t.endLabelRight){const f=e.insert("g").attr("class","edgeTerminals"),m=f.insert("g").attr("class","inner"),y=await Rr(f,t.endLabelRight,is(t.labelStyle)||"",!1,!1);d=y;let x=y.getBBox();if(i){const C=y.children[0],k=At(y);x=C.getBoundingClientRect(),k.attr("width",x.width),k.attr("height",x.height)}m.attr("transform",rs(x,i)),te.get(t.id)||te.set(t.id,{}),te.get(t.id).endRight=f,fs(d,t.endLabelRight)}return c},"insertEdgeLabel");function fs(e,t){be(It())&&e&&(e.style.width=t.length*9+"px",e.style.height="12px")}p(fs,"setTerminalWidth");var yS=p((e,t)=>{R.debug("Moving label abc88 ",e.id,e.label,Pi.get(e.id),t);let r=t.updatedPath?t.updatedPath:t.originalPath;const i=It(),{subGraphTitleTotalMargin:s}=oa(i);if(e.label){const o=Pi.get(e.id);let a=e.x,n=e.y;if(r){const l=Ce.calcLabelPosition(r);R.debug("Moving label "+e.label+" from (",a,",",n,") to (",l.x,",",l.y,") abc88"),t.updatedPath&&(a=l.x,n=l.y)}o.attr("transform",`translate(${a}, ${n+s/2})`)}if(e.startLabelLeft){const o=te.get(e.id).startLeft;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeStart?10:0,"start_left",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.startLabelRight){const o=te.get(e.id).startRight;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeStart?10:0,"start_right",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.endLabelLeft){const o=te.get(e.id).endLeft;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeEnd?10:0,"end_left",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.endLabelRight){const o=te.get(e.id).endRight;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeEnd?10:0,"end_right",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}},"positionEdgeLabel"),xS=p((e,t)=>{if(!e?.isLabelEdge||!e?.id?.endsWith("-to-label")||!Array.isArray(t)||t.length!==2)return t;const[r,i]=t,s=Math.abs(i.x-r.x),o=Math.abs(i.y-r.y);return s<.001||o<.001?t:o>=s?[r,{x:r.x,y:i.y},i]:[r,{x:i.x,y:r.y},i]},"orthogonalizeToLabelClippedPoints"),CS=p((e,t)=>{const r=e.x,i=e.y,s=Math.abs(t.x-r),o=Math.abs(t.y-i),a=e.width/2,n=e.height/2;return s>=a||o>=n},"outsideNode"),bS=p((e,t,r)=>{R.debug(`intersection calc abc89: + outsidePoint: ${JSON.stringify(t)} + insidePoint : ${JSON.stringify(r)} + node : x:${e.x} y:${e.y} w:${e.width} h:${e.height}`);const i=e.x,s=e.y,o=Math.abs(i-r.x),a=e.width/2;let n=r.xMath.abs(i-t.x)*l){let u=r.y{R.warn("abc88 cutPathAtIntersect",e,t);let r=[],i=e[0],s=!1;return e.forEach(o=>{if(R.info("abc88 checking point",o,t),!CS(t,o)&&!s){const a=bS(t,i,o);R.debug("abc88 inside",o,i,a),R.debug("abc88 intersection",a,t);let n=!1;r.forEach(l=>{n=n||l.x===a.x&&l.y===a.y}),r.some(l=>l.x===a.x&&l.y===a.y)?R.warn("abc88 no intersect",a,r):r.push(a),s=!0}else R.warn("abc88 outside",o,i),i=o,s||r.push(o)}),R.debug("returning points",r),r},"cutPathAtIntersect");function $m(e){const t=[],r=[];for(let i=1;i5&&Math.abs(o.y-s.y)>5||s.y===o.y&&o.x===a.x&&Math.abs(o.x-s.x)>5&&Math.abs(o.y-a.y)>5)&&(t.push(o),r.push(i))}return{cornerPoints:t,cornerPointPositions:r}}p($m,"extractCornerPoints");var Fu=p(function(e,t,r){const i=t.x-e.x,s=t.y-e.y,o=Math.sqrt(i*i+s*s),a=r/o;return{x:t.x-a*i,y:t.y-a*s}},"findAdjacentPoint"),kS=p(function(e){const{cornerPointPositions:t}=$m(e),r=[];for(let i=0;i10&&Math.abs(o.y-s.y)>=10){R.debug("Corner point fixing",Math.abs(o.x-s.x),Math.abs(o.y-s.y));const f=5;a.x===n.x?d={x:c<0?n.x-f+u:n.x+f-u,y:h<0?n.y-u:n.y+u}:d={x:c<0?n.x-u:n.x+u,y:h<0?n.y-f+u:n.y+f-u}}else R.debug("Corner point skipping fixing",Math.abs(o.x-s.x),Math.abs(o.y-s.y));r.push(d,l)}else r.push(e[i]);return r},"fixCorners"),wS=p((e,t,r)=>{const i=e-t-r,s=2,o=2,a=s+o,n=Math.floor(i/a),l=Number.isFinite(n)?Math.max(0,n):0,c=Array(l).fill(`${s} ${o}`).join(" ");return`0 ${t} ${c} ${r}`},"generateDashArray"),Om=p(function(e,t,r,i,s,o,a,n=!1){if(!a)throw new Error(`insertEdge: missing diagramId for edge "${t.id}" — edge IDs require a diagram prefix for uniqueness`);const{handDrawnSeed:l,layout:c}=It();let h=t.points,u=!1;const d=s;var f=o;const m=[];for(const O in t.cssCompiledStyles)sp(O)||m.push(t.cssCompiledStyles[O]);if(c==="swimlane"){if(f.intersect&&d.intersect&&Array.isArray(h)&&h.length>=2)if(h.length===2)h=[d.intersect(h[0]),f.intersect(h[1])];else{const O=h.slice(1,-1),it=O[0],tt=O[O.length-1],gt=.5,ht=Math.abs(h[h.length-1].x-tt.x)!Number.isNaN(O.y));const C=gS(t.curve);C!=="rounded"&&(x=kS(x));let k=Cs;switch(C){case"linear":k=Cs;break;case"basis":k=qn;break;case"cardinal":k=Hf;break;case"bumpX":k=Rf;break;case"bumpY":k=Nf;break;case"catmullRom":k=Uf;break;case"monotoneX":k=Kf;break;case"monotoneY":k=Qf;break;case"natural":k=tp;break;case"step":k=ep;break;case"stepAfter":k=ip;break;case"stepBefore":k=rp;break;case"rounded":k=Cs;break;default:k=qn}const{x:T,y:S}=uS(t),v=P2().x(T).y(S).curve(k);let A;switch(t.thickness){case"normal":A="edge-thickness-normal";break;case"thick":A="edge-thickness-thick";break;case"invisible":A="edge-thickness-invisible";break;default:A="edge-thickness-normal"}switch(t.pattern){case"solid":A+=" edge-pattern-solid";break;case"dotted":A+=" edge-pattern-dotted";break;case"dashed":A+=" edge-pattern-dashed";break;default:A+=" edge-pattern-solid"}let L,F=C==="rounded"?Dm(Im(x,t),5):v(x);const Z=Array.isArray(t.style)?t.style:[t.style];let U=Z.find(O=>O?.startsWith("stroke:")),N="";t.animate&&(N="edge-animation-fast"),t.animation&&(N="edge-animation-"+t.animation);let st=!1;if(t.look==="handDrawn"){const O=ct.svg(e);Object.assign([],x);const it=O.path(F,{roughness:.3,seed:l});A+=" transition",L=At(it).select("path").attr("id",`${a}-${t.id}`).attr("class"," "+A+(t.classes?" "+t.classes:"")+(N?" "+N:"")).attr("style",Z?Z.reduce((gt,ht)=>gt+";"+ht,""):"");let tt=L.attr("d");L.attr("d",tt),e.node().appendChild(L.node())}else{const O=m.join(";"),it=Z?Z.reduce((Bt,pt)=>Bt+pt+";",""):"",tt=(O?O+";"+it+";":it)+";"+(Z?Z.reduce((Bt,pt)=>Bt+";"+pt,""):"");L=e.append("path").attr("d",F).attr("id",`${a}-${t.id}`).attr("class"," "+A+(t.classes?" "+t.classes:"")+(N?" "+N:"")).attr("style",tt),U=tt.match(/stroke:([^;]+)/)?.[1],st=t.animate===!0||!!t.animation||O.includes("animation");const gt=L.node(),ht=typeof gt.getTotalLength=="function"?gt.getTotalLength():0,Tt=vu[t.arrowTypeStart]||0,Ft=vu[t.arrowTypeEnd]||0;if(t.look==="neo"&&!st){const pt=`stroke-dasharray: ${t.pattern==="dotted"||t.pattern==="dashed"?wS(ht,Tt,Ft):`0 ${Tt} ${ht-Tt-Ft} ${Ft}`}; stroke-dashoffset: 0;`;L.attr("style",pt+L.attr("style"))}}L.attr("data-edge",!0),L.attr("data-et","edge"),L.attr("data-id",t.id),L.attr("data-points",y),L.attr("data-look",re(t.look)),t.showPoints&&x.forEach(O=>{e.append("circle").style("stroke","red").style("fill","red").attr("r",1).attr("cx",O.x).attr("cy",O.y)});let Y="";(It().flowchart.arrowMarkerAbsolute||It().state.arrowMarkerAbsolute)&&(Y=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,Y=Y.replace(/\(/g,"\\(").replace(/\)/g,"\\)")),R.info("arrowTypeStart",t.arrowTypeStart),R.info("arrowTypeEnd",t.arrowTypeEnd);const $=!st&&t?.look==="neo";dS(L,t,Y,a,i,$,U);const I=Math.floor(h.length/2),B=h[I];Ce.isLabelCoordinateInPath(B,L.attr("d"))||(u=!0);let q={};return u&&(q.updatedPath=h),q.originalPath=t.points,q},"insertEdge");function Dm(e,t){if(e.length<2)return"";let r="";const i=e.length,s=1e-5;for(let o=0;o({...s}));if(e.length>=2&&xe[t.arrowTypeStart]){const s=xe[t.arrowTypeStart],o=e[0],a=e[1],{angle:n}=rl(o,a),l=s*Math.cos(n),c=s*Math.sin(n);r[0].x=o.x+l,r[0].y=o.y+c}const i=e.length;if(i>=2&&xe[t.arrowTypeEnd]){const s=xe[t.arrowTypeEnd],o=e[i-1],a=e[i-2],{angle:n}=rl(a,o),l=s*Math.cos(n),c=s*Math.sin(n);r[i-1].x=o.x-l,r[i-1].y=o.y-c}return r}p(Im,"applyMarkerOffsetsToPoints");var TS=p((e,t,r,i)=>{t.forEach(s=>{jS[s](e,r,i)})},"insertMarkers"),_S=p((e,t,r)=>{R.trace("Making markers for ",r),e.append("defs").append("marker").attr("id",r+"_"+t+"-extensionStart").attr("class","marker extension "+t).attr("refX",18).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 1,7 L18,13 V 1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-extensionEnd").attr("class","marker extension "+t).attr("refX",1).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 1,1 V 13 L18,7 Z"),e.append("marker").attr("id",r+"_"+t+"-extensionStart-margin").attr("class","marker extension "+t).attr("refX",18).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").attr("viewBox","0 0 20 14").append("polygon").attr("points","10,7 18,13 18,1").style("stroke-width",2).style("stroke-dasharray","0"),e.append("defs").append("marker").attr("id",r+"_"+t+"-extensionEnd-margin").attr("class","marker extension "+t).attr("refX",9).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").attr("viewBox","0 0 20 14").append("polygon").attr("points","10,1 10,13 18,7").style("stroke-width",2).style("stroke-dasharray","0")},"extension"),SS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-compositionStart").attr("class","marker composition "+t).attr("refX",18).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-compositionEnd").attr("class","marker composition "+t).attr("refX",1).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-compositionStart-margin").attr("class","marker composition "+t).attr("refX",15).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",0).attr("viewBox","0 0 15 15").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-compositionEnd-margin").attr("class","marker composition "+t).attr("refX",3.5).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",0).attr("d","M 18,7 L9,13 L1,7 L9,1 Z")},"composition"),vS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-aggregationStart").attr("class","marker aggregation "+t).attr("refX",18).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-aggregationEnd").attr("class","marker aggregation "+t).attr("refX",1).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-aggregationStart-margin").attr("class","marker aggregation "+t).attr("refX",15).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",2).attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-aggregationEnd-margin").attr("class","marker aggregation "+t).attr("refX",1).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",2).attr("d","M 18,7 L9,13 L1,7 L9,1 Z")},"aggregation"),BS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-dependencyStart").attr("class","marker dependency "+t).attr("refX",6).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 5,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-dependencyEnd").attr("class","marker dependency "+t).attr("refX",13).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-dependencyStart-margin").attr("class","marker dependency "+t).attr("refX",4).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",0).attr("d","M 5,7 L9,13 L1,7 L9,1 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-dependencyEnd-margin").attr("class","marker dependency "+t).attr("refX",16).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").style("stroke-width",0).attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},"dependency"),LS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-lollipopStart").attr("class","marker lollipop "+t).attr("refX",13).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("circle").attr("fill","transparent").attr("cx",7).attr("cy",7).attr("r",6),e.append("defs").append("marker").attr("id",r+"_"+t+"-lollipopEnd").attr("class","marker lollipop "+t).attr("refX",1).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("circle").attr("fill","transparent").attr("cx",7).attr("cy",7).attr("r",6),e.append("defs").append("marker").attr("id",r+"_"+t+"-lollipopStart-margin").attr("class","marker lollipop "+t).attr("refX",13).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("circle").attr("fill","transparent").attr("cx",7).attr("cy",7).attr("r",6).attr("stroke-width",2),e.append("defs").append("marker").attr("id",r+"_"+t+"-lollipopEnd-margin").attr("class","marker lollipop "+t).attr("refX",1).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("circle").attr("fill","transparent").attr("cx",7).attr("cy",7).attr("r",6).attr("stroke-width",2)},"lollipop"),FS=p((e,t,r)=>{e.append("marker").attr("id",r+"_"+t+"-pointEnd").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refX",5).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",8).attr("markerHeight",8).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z").attr("class","arrowMarkerPath").style("stroke-width",1).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-pointStart").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refX",4.5).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",8).attr("markerHeight",8).attr("orient","auto").append("path").attr("d","M 0 5 L 10 10 L 10 0 z").attr("class","arrowMarkerPath").style("stroke-width",1).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-pointEnd-margin").attr("class","marker "+t).attr("viewBox","0 0 11.5 14").attr("refX",11.5).attr("refY",7).attr("markerUnits","userSpaceOnUse").attr("markerWidth",10.5).attr("markerHeight",14).attr("orient","auto").append("path").attr("d","M 0 0 L 11.5 7 L 0 14 z").attr("class","arrowMarkerPath").style("stroke-width",0).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-pointStart-margin").attr("class","marker "+t).attr("viewBox","0 0 11.5 14").attr("refX",1).attr("refY",7).attr("markerUnits","userSpaceOnUse").attr("markerWidth",11.5).attr("markerHeight",14).attr("orient","auto").append("polygon").attr("points","0,7 11.5,14 11.5,0").attr("class","arrowMarkerPath").style("stroke-width",0).style("stroke-dasharray","1,0")},"point"),AS=p((e,t,r)=>{e.append("marker").attr("id",r+"_"+t+"-circleEnd").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refX",11).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",11).attr("markerHeight",11).attr("orient","auto").append("circle").attr("cx","5").attr("cy","5").attr("r","5").attr("class","arrowMarkerPath").style("stroke-width",1).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-circleStart").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refX",-1).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",11).attr("markerHeight",11).attr("orient","auto").append("circle").attr("cx","5").attr("cy","5").attr("r","5").attr("class","arrowMarkerPath").style("stroke-width",1).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-circleEnd-margin").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refY",5).attr("refX",12.25).attr("markerUnits","userSpaceOnUse").attr("markerWidth",14).attr("markerHeight",14).attr("orient","auto").append("circle").attr("cx","5").attr("cy","5").attr("r","5").attr("class","arrowMarkerPath").style("stroke-width",0).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-circleStart-margin").attr("class","marker "+t).attr("viewBox","0 0 10 10").attr("refX",-2).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",14).attr("markerHeight",14).attr("orient","auto").append("circle").attr("cx","5").attr("cy","5").attr("r","5").attr("class","arrowMarkerPath").style("stroke-width",0).style("stroke-dasharray","1,0")},"circle"),ES=p((e,t,r)=>{e.append("marker").attr("id",r+"_"+t+"-crossEnd").attr("class","marker cross "+t).attr("viewBox","0 0 11 11").attr("refX",12).attr("refY",5.2).attr("markerUnits","userSpaceOnUse").attr("markerWidth",11).attr("markerHeight",11).attr("orient","auto").append("path").attr("d","M 1,1 l 9,9 M 10,1 l -9,9").attr("class","arrowMarkerPath").style("stroke-width",2).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-crossStart").attr("class","marker cross "+t).attr("viewBox","0 0 11 11").attr("refX",-1).attr("refY",5.2).attr("markerUnits","userSpaceOnUse").attr("markerWidth",11).attr("markerHeight",11).attr("orient","auto").append("path").attr("d","M 1,1 l 9,9 M 10,1 l -9,9").attr("class","arrowMarkerPath").style("stroke-width",2).style("stroke-dasharray","1,0"),e.append("marker").attr("id",r+"_"+t+"-crossEnd-margin").attr("class","marker cross "+t).attr("viewBox","0 0 15 15").attr("refX",17.7).attr("refY",7.5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 1,1 L 14,14 M 1,14 L 14,1").attr("class","arrowMarkerPath").style("stroke-width",2.5),e.append("marker").attr("id",r+"_"+t+"-crossStart-margin").attr("class","marker cross "+t).attr("viewBox","0 0 15 15").attr("refX",-3.5).attr("refY",7.5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 1,1 L 14,14 M 1,14 L 14,1").attr("class","arrowMarkerPath").style("stroke-width",2.5).style("stroke-dasharray","1,0")},"cross"),MS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-barbEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",14).attr("markerUnits","userSpaceOnUse").attr("orient","auto").append("path").attr("d","M 19,7 L9,13 L14,7 L9,1 Z")},"barb"),$S=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{transitionColor:o}=s;e.append("defs").append("marker").attr("id",r+"_"+t+"-barbEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",14).attr("markerUnits","strokeWidth").attr("orient","auto").append("path").attr("d","M 19,7 L11,14 L13,7 L11,0 Z"),e.append("defs").append("marker").attr("id",r+"_"+t+"-barbEnd-margin").attr("refX",17).attr("refY",7).attr("markerWidth",20).attr("markerHeight",14).attr("markerUnits","userSpaceOnUse").attr("orient","auto").append("path").attr("d","M 19,7 L11,14 L13,7 L11,0 Z").attr("fill",`${o}`)},"barbNeo"),OS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-onlyOneStart").attr("class","marker onlyOne "+t).attr("refX",0).attr("refY",9).attr("markerWidth",18).attr("markerHeight",18).attr("orient","auto").append("path").attr("d","M9,0 L9,18 M15,0 L15,18"),e.append("defs").append("marker").attr("id",r+"_"+t+"-onlyOneEnd").attr("class","marker onlyOne "+t).attr("refX",18).attr("refY",9).attr("markerWidth",18).attr("markerHeight",18).attr("orient","auto").append("path").attr("d","M3,0 L3,18 M9,0 L9,18")},"only_one"),DS=p((e,t,r)=>{const i=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrOneStart").attr("class","marker zeroOrOne "+t).attr("refX",0).attr("refY",9).attr("markerWidth",30).attr("markerHeight",18).attr("orient","auto");i.append("circle").attr("fill","white").attr("cx",21).attr("cy",9).attr("r",6),i.append("path").attr("d","M9,0 L9,18");const s=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrOneEnd").attr("class","marker zeroOrOne "+t).attr("refX",30).attr("refY",9).attr("markerWidth",30).attr("markerHeight",18).attr("orient","auto");s.append("circle").attr("fill","white").attr("cx",9).attr("cy",9).attr("r",6),s.append("path").attr("d","M21,0 L21,18")},"zero_or_one"),IS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-oneOrMoreStart").attr("class","marker oneOrMore "+t).attr("refX",18).attr("refY",18).attr("markerWidth",45).attr("markerHeight",36).attr("orient","auto").append("path").attr("d","M0,18 Q 18,0 36,18 Q 18,36 0,18 M42,9 L42,27"),e.append("defs").append("marker").attr("id",r+"_"+t+"-oneOrMoreEnd").attr("class","marker oneOrMore "+t).attr("refX",27).attr("refY",18).attr("markerWidth",45).attr("markerHeight",36).attr("orient","auto").append("path").attr("d","M3,9 L3,27 M9,18 Q27,0 45,18 Q27,36 9,18")},"one_or_more"),PS=p((e,t,r)=>{const i=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrMoreStart").attr("class","marker zeroOrMore "+t).attr("refX",18).attr("refY",18).attr("markerWidth",57).attr("markerHeight",36).attr("orient","auto");i.append("circle").attr("fill","white").attr("cx",48).attr("cy",18).attr("r",6),i.append("path").attr("d","M0,18 Q18,0 36,18 Q18,36 0,18");const s=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrMoreEnd").attr("class","marker zeroOrMore "+t).attr("refX",39).attr("refY",18).attr("markerWidth",57).attr("markerHeight",36).attr("orient","auto");s.append("circle").attr("fill","white").attr("cx",9).attr("cy",18).attr("r",6),s.append("path").attr("d","M21,18 Q39,0 57,18 Q39,36 21,18")},"zero_or_more"),RS=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o}=s;e.append("defs").append("marker").attr("id",r+"_"+t+"-onlyOneStart").attr("class","marker onlyOne "+t).attr("refX",0).attr("refY",9).attr("markerWidth",18).attr("markerHeight",18).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M9,0 L9,18 M15,0 L15,18").attr("stroke-width",`${o}`),e.append("defs").append("marker").attr("id",r+"_"+t+"-onlyOneEnd").attr("class","marker onlyOne "+t).attr("refX",18).attr("refY",9).attr("markerWidth",18).attr("markerHeight",18).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M3,0 L3,18 M9,0 L9,18").attr("stroke-width",`${o}`)},"only_one_neo"),NS=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o,mainBkg:a}=s,n=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrOneStart").attr("class","marker zeroOrOne "+t).attr("refX",0).attr("refY",9).attr("markerWidth",30).attr("markerHeight",18).attr("orient","auto").attr("markerUnits","userSpaceOnUse");n.append("circle").attr("fill",a??"white").attr("cx",21).attr("cy",9).attr("stroke-width",`${o}`).attr("r",6),n.append("path").attr("d","M9,0 L9,18").attr("stroke-width",`${o}`);const l=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrOneEnd").attr("class","marker zeroOrOne "+t).attr("refX",30).attr("refY",9).attr("markerWidth",30).attr("markerHeight",18).attr("markerUnits","userSpaceOnUse").attr("orient","auto");l.append("circle").attr("fill",a??"white").attr("cx",9).attr("cy",9).attr("stroke-width",`${o}`).attr("r",6),l.append("path").attr("d","M21,0 L21,18").attr("stroke-width",`${o}`)},"zero_or_one_neo"),qS=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o}=s;e.append("defs").append("marker").attr("id",r+"_"+t+"-oneOrMoreStart").attr("class","marker oneOrMore "+t).attr("refX",18).attr("refY",18).attr("markerWidth",45).attr("markerHeight",36).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("path").attr("d","M0,18 Q 18,0 36,18 Q 18,36 0,18 M42,9 L42,27").attr("stroke-width",`${o}`),e.append("defs").append("marker").attr("id",r+"_"+t+"-oneOrMoreEnd").attr("class","marker oneOrMore "+t).attr("refX",27).attr("refY",18).attr("markerWidth",45).attr("markerHeight",36).attr("markerUnits","userSpaceOnUse").attr("orient","auto").append("path").attr("d","M3,9 L3,27 M9,18 Q27,0 45,18 Q27,36 9,18").attr("stroke-width",`${o}`)},"one_or_more_neo"),zS=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o,mainBkg:a}=s,n=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrMoreStart").attr("class","marker zeroOrMore "+t).attr("refX",18).attr("refY",18).attr("markerWidth",57).attr("markerHeight",36).attr("markerUnits","userSpaceOnUse").attr("orient","auto");n.append("circle").attr("fill",a??"white").attr("cx",45.5).attr("cy",18).attr("r",6).attr("stroke-width",`${o}`),n.append("path").attr("d","M0,18 Q18,0 36,18 Q18,36 0,18").attr("stroke-width",`${o}`);const l=e.append("defs").append("marker").attr("id",r+"_"+t+"-zeroOrMoreEnd").attr("class","marker zeroOrMore "+t).attr("refX",39).attr("refY",18).attr("markerWidth",57).attr("markerHeight",36).attr("orient","auto").attr("markerUnits","userSpaceOnUse");l.append("circle").attr("fill",a??"white").attr("cx",11).attr("cy",18).attr("r",6).attr("stroke-width",`${o}`),l.append("path").attr("d","M21,18 Q39,0 57,18 Q39,36 21,18").attr("stroke-width",`${o}`)},"zero_or_more_neo"),WS=p((e,t,r)=>{e.append("defs").append("marker").attr("id",r+"_"+t+"-requirement_arrowEnd").attr("refX",20).attr("refY",10).attr("markerWidth",20).attr("markerHeight",20).attr("orient","auto").append("path").attr("d",`M0,0 + L20,10 + M20,10 + L0,20`)},"requirement_arrow"),HS=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o}=s;e.append("defs").append("marker").attr("id",r+"_"+t+"-requirement_arrowEnd").attr("refX",20).attr("refY",10).attr("markerWidth",20).attr("markerHeight",20).attr("orient","auto").attr("markerUnits","userSpaceOnUse").attr("stroke-width",`${o}`).attr("viewBox","0 0 25 20").append("path").attr("d",`M0,0 + L20,10 + M20,10 + L0,20`).attr("stroke-linejoin","miter")},"requirement_arrow_neo"),YS=p((e,t,r)=>{const i=e.append("defs").append("marker").attr("id",r+"_"+t+"-requirement_containsStart").attr("refX",0).attr("refY",10).attr("markerWidth",20).attr("markerHeight",20).attr("orient","auto").append("g");i.append("circle").attr("cx",10).attr("cy",10).attr("r",9).attr("fill","none"),i.append("line").attr("x1",1).attr("x2",19).attr("y1",10).attr("y2",10),i.append("line").attr("y1",1).attr("y2",19).attr("x1",10).attr("x2",10)},"requirement_contains"),US=p((e,t,r)=>{const i=Zt(),{themeVariables:s}=i,{strokeWidth:o}=s,a=e.append("defs").append("marker").attr("id",r+"_"+t+"-requirement_containsStart").attr("refX",0).attr("refY",10).attr("markerWidth",20).attr("markerHeight",20).attr("orient","auto").attr("markerUnits","userSpaceOnUse").append("g");a.append("circle").attr("cx",10).attr("cy",10).attr("r",9).attr("fill","none"),a.append("line").attr("x1",1).attr("x2",19).attr("y1",10).attr("y2",10),a.append("line").attr("y1",1).attr("y2",19).attr("x1",10).attr("x2",10),a.selectAll("*").attr("stroke-width",`${o}`)},"requirement_contains_neo"),jS={extension:_S,composition:SS,aggregation:vS,dependency:BS,lollipop:LS,point:FS,circle:AS,cross:ES,barb:MS,barbNeo:$S,only_one:OS,zero_or_one:DS,one_or_more:IS,zero_or_more:PS,only_one_neo:RS,zero_or_one_neo:NS,one_or_more_neo:qS,zero_or_more_neo:zS,requirement_arrow:WS,requirement_contains:YS,requirement_arrow_neo:HS,requirement_contains_neo:US},Pm=TS,Rm=typeof global=="object"&&global&&global.Object===Object&&global,GS=typeof self=="object"&&self&&self.Object===Object&&self,Lr=Rm||GS||Function("return this")(),lr=Lr.Symbol,Nm=Object.prototype,XS=Nm.hasOwnProperty,VS=Nm.toString,ss=lr?lr.toStringTag:void 0;function ZS(e){var t=XS.call(e,ss),r=e[ss];try{e[ss]=void 0;var i=!0}catch{}var s=VS.call(e);return i&&(t?e[ss]=r:delete e[ss]),s}var KS=Object.prototype,QS=KS.toString;function JS(e){return QS.call(e)}var tv="[object Null]",ev="[object Undefined]",Au=lr?lr.toStringTag:void 0;function Wi(e){return e==null?e===void 0?ev:tv:Au&&Au in Object(e)?ZS(e):JS(e)}function li(e){return e!=null&&typeof e=="object"}var rv="[object Symbol]";function lh(e){return typeof e=="symbol"||li(e)&&Wi(e)==rv}function qm(e,t){for(var r=-1,i=e==null?0:e.length,s=Array(i);++r0){if(++t>=kv)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}function ps(e){return function(){return e}}var Ou=(function(){try{var e=pi(Object,"defineProperty");return e({},"",{}),e}catch{}})(),Sv=Ou?function(e,t){return Ou(e,"toString",{configurable:!0,enumerable:!1,value:ps(t),writable:!0})}:na,vv=_v(Sv);function Bv(e,t){for(var r=-1,i=e==null?0:e.length;++r-1}var $v=9007199254740991,Ov=/^(?:0|[1-9]\d*)$/;function Wm(e,t){var r=typeof e;return t=t??$v,!!t&&(r=="number"||r!="symbol"&&Ov.test(e))&&e>-1&&e%1==0&&e-1&&e%1==0&&e<=Pv}function la(e){return e!=null&&ch(e.length)&&!Wo(e)}var Rv=Object.prototype;function Ym(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||Rv;return e===r}function Nv(e,t){for(var r=-1,i=Array(e);++r-1}function UB(e,t){var r=this.__data__,i=ca(r,e);return i<0?(++this.size,r.push([e,t])):r[i][1]=t,this}function Fr(e){var t=-1,r=e==null?0:e.length;for(this.clear();++tn))return!1;var c=o.get(e),h=o.get(t);if(c&&h)return c==t&&h==e;var u=-1,d=!0,f=r&EL?new As:void 0;for(o.set(e,t),o.set(t,e);++u=AF){var c=FF(e);if(c)return ph(c);a=!1,s=Jm,l=new As}else l=n;t:for(;++i1?s.setNode(o,r):s.setNode(o)}),this}setNode(t,r){return Object.prototype.hasOwnProperty.call(this._nodes,t)?(arguments.length>1&&(this._nodes[t]=r),this):(this._nodes[t]=arguments.length>1?r:this._defaultNodeLabelFn(t),this._isCompound&&(this._parent[t]=Zr,this._children[t]={},this._children[Zr][t]=!0),this._in[t]={},this._preds[t]={},this._out[t]={},this._sucs[t]={},++this._nodeCount,this)}node(t){return this._nodes[t]}hasNode(t){return Object.prototype.hasOwnProperty.call(this._nodes,t)}removeNode(t){if(Object.prototype.hasOwnProperty.call(this._nodes,t)){var r=i=>this.removeEdge(this._edgeObjs[i]);delete this._nodes[t],this._isCompound&&(this._removeFromParentsChildList(t),delete this._parent[t],Vr(this.children(t),i=>{this.setParent(i)}),delete this._children[t]),Vr(sr(this._in[t]),r),delete this._in[t],delete this._preds[t],Vr(sr(this._out[t]),r),delete this._out[t],delete this._sucs[t],--this._nodeCount}return this}setParent(t,r){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(vi(r))r=Zr;else{r+="";for(var i=r;!vi(i);i=this.parent(i))if(i===t)throw new Error("Setting "+r+" as parent of "+t+" would create a cycle");this.setNode(r)}return this.setNode(t),this._removeFromParentsChildList(t),this._parent[t]=r,this._children[r][t]=!0,this}_removeFromParentsChildList(t){delete this._children[this._parent[t]][t]}parent(t){if(this._isCompound){var r=this._parent[t];if(r!==Zr)return r}}children(t){if(vi(t)&&(t=Zr),this._isCompound){var r=this._children[t];if(r)return sr(r)}else{if(t===Zr)return this.nodes();if(this.hasNode(t))return[]}}predecessors(t){var r=this._preds[t];if(r)return sr(r)}successors(t){var r=this._sucs[t];if(r)return sr(r)}neighbors(t){var r=this.predecessors(t);if(r)return MF(r,this.successors(t))}isLeaf(t){var r;return this.isDirected()?r=this.successors(t):r=this.neighbors(t),r.length===0}filterNodes(t){var r=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});r.setGraph(this.graph());var i=this;Vr(this._nodes,function(a,n){t(n)&&r.setNode(n,a)}),Vr(this._edgeObjs,function(a){r.hasNode(a.v)&&r.hasNode(a.w)&&r.setEdge(a,i.edge(a))});var s={};function o(a){var n=i.parent(a);return n===void 0||r.hasNode(n)?(s[a]=n,n):n in s?s[n]:o(n)}return this._isCompound&&Vr(r.nodes(),function(a){r.setParent(a,o(a))}),r}setDefaultEdgeLabel(t){return Wo(t)||(t=ps(t)),this._defaultEdgeLabelFn=t,this}edgeCount(){return this._edgeCount}edges(){return Xa(this._edgeObjs)}setPath(t,r){var i=this,s=arguments;return BF(t,function(o,a){return s.length>1?i.setEdge(o,a,r):i.setEdge(o,a),a}),this}setEdge(){var t,r,i,s,o=!1,a=arguments[0];typeof a=="object"&&a!==null&&"v"in a?(t=a.v,r=a.w,i=a.name,arguments.length===2&&(s=arguments[1],o=!0)):(t=a,r=arguments[1],i=arguments[3],arguments.length>2&&(s=arguments[2],o=!0)),t=""+t,r=""+r,vi(i)||(i=""+i);var n=gs(this._isDirected,t,r,i);if(Object.prototype.hasOwnProperty.call(this._edgeLabels,n))return o&&(this._edgeLabels[n]=s),this;if(!vi(i)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(t),this.setNode(r),this._edgeLabels[n]=o?s:this._defaultEdgeLabelFn(t,r,i);var l=OF(this._isDirected,t,r,i);return t=l.v,r=l.w,Object.freeze(l),this._edgeObjs[n]=l,rd(this._preds[r],t),rd(this._sucs[t],r),this._in[r][n]=l,this._out[t][n]=l,this._edgeCount++,this}edge(t,r,i){var s=arguments.length===1?Va(this._isDirected,arguments[0]):gs(this._isDirected,t,r,i);return this._edgeLabels[s]}hasEdge(t,r,i){var s=arguments.length===1?Va(this._isDirected,arguments[0]):gs(this._isDirected,t,r,i);return Object.prototype.hasOwnProperty.call(this._edgeLabels,s)}removeEdge(t,r,i){var s=arguments.length===1?Va(this._isDirected,arguments[0]):gs(this._isDirected,t,r,i),o=this._edgeObjs[s];return o&&(t=o.v,r=o.w,delete this._edgeLabels[s],delete this._edgeObjs[s],id(this._preds[r],t),id(this._sucs[t],r),delete this._in[r][s],delete this._out[t][s],this._edgeCount--),this}inEdges(t,r){var i=this._in[t];if(i){var s=Xa(i);return r?so(s,function(o){return o.v===r}):s}}outEdges(t,r){var i=this._out[t];if(i){var s=Xa(i);return r?so(s,function(o){return o.w===r}):s}}nodeEdges(t,r){var i=this.inEdges(t,r);if(i)return i.concat(this.outEdges(t,r))}}fa.prototype._nodeCount=0;fa.prototype._edgeCount=0;function rd(e,t){e[t]?e[t]++:e[t]=1}function id(e,t){--e[t]||delete e[t]}function gs(e,t,r,i){var s=""+t,o=""+r;if(!e&&s>o){var a=s;s=o,o=a}return s+ed+o+ed+(vi(i)?$F:i)}function OF(e,t,r,i){var s=""+t,o=""+r;if(!e&&s>o){var a=s;s=o,o=a}var n={v:s,w:o};return i&&(n.name=i),n}function Va(e,t){return gs(e,t.v,t.w,t.name)}function sy(e,{edgePathsClass:t="edges edgePaths"}={}){const r=e.insert("g").attr("class","root"),i=r.insert("g").attr("class","clusters"),s=r.insert("g").attr("class",t),o=r.insert("g").attr("class","edgeLabels"),a=r.insert("g").attr("class","nodes");return{clusters:i,edgePaths:s,edgeLabels:o,nodes:a,rootGroups:r}}p(sy,"createLayoutElementGroups");async function oy(e,t){if(t.label){const{shapeSvg:r,bbox:i}=await xt(e,t);t.labelBBox={width:i.width,height:i.height},r.remove()}else t.labelBBox={width:0,height:0}}p(oy,"measureGroupLabel");async function ay(e,t,r){const i=await ah(e,t,r),s=i.node()?.getBBox()??{width:0,height:0};return t.width=s.width,t.height=s.height,i}p(ay,"insertMeasuredNode");async function ny(e,t){const r=new fa({multigraph:!0,compound:!0}),i=[...t.edges],s=It(),o=sy(e),{edgeLabels:a,nodes:n}=o,l=new Map,c=e.node()!=null;await Promise.all(t.nodes.map(async h=>{if(h.isGroup)c&&await oy(n,h),r.setNode(h.id,{...h});else{if(c){const u=await ay(n,h,{config:s,dir:h.dir});l.set(h.id,u)}r.setNode(h.id,{...h})}}));for(const h of i)c&&Mm(h)&&await nh(a,h),r.setEdge(h.start,h.end,{...h},h.id),t.edges.some(d=>d.id===h.id)||t.edges.push(h);if(globalThis.mermaidCaptureSizes){const{captureNodeSizes:h}=await Et(async()=>{const{captureNodeSizes:u}=await import("./chunks/sizeCapture-INFHLROL.Dsb_Hwxo.js");return{captureNodeSizes:u}},__vite__mapDeps([0,1,2]));h(e,t)}return{graph:r,groups:o,nodeElements:l}}p(ny,"createGraphWithElements");var Rt=new Map,ei=new Map,ly=new Map,DF=p(()=>{ei.clear(),ly.clear(),Rt.clear()},"clear"),Es=p((e,t)=>{const r=ei.get(t)||[];return R.trace("In isDescendant",t," ",e," = ",r.includes(e)),r.includes(e)},"isDescendant"),IF=p((e,t)=>{const r=ei.get(t)||[];return R.info("Descendants of ",t," is ",r),R.info("Edge is ",e),e.v===t||e.w===t?!1:r?r.includes(e.v)||Es(e.v,t)||Es(e.w,t)||r.includes(e.w):(R.debug("Tilt, ",t,",not in descendants"),!1)},"edgeInCluster"),hy=p((e,t,r,i)=>{R.debug("Copying children of ",e,"root",i,"data",t.node(e),i);const s=t.children(e)||[];e!==i&&s.push(e),R.debug("Copying (nodes) clusterId",e,"nodes",s),s.forEach(o=>{if(t.children(o).length>0)hy(o,t,r,i);else{const a=t.node(o);R.info("cp ",o," to ",i," with parent ",e),r.setNode(o,a),i!==t.parent(o)&&(R.debug("Setting parent",o,t.parent(o)),r.setParent(o,t.parent(o))),e!==i&&o!==e?(R.debug("Setting parent",o,e),r.setParent(o,e)):(R.info("In copy ",e,"root",i,"data",t.node(e),i),R.debug("Not Setting parent for node=",o,"cluster!==rootId",e!==i,"node!==clusterId",o!==e));const n=t.edges(o);R.debug("Copying Edges",n),n.forEach(l=>{R.info("Edge",l);const c=t.edge(l.v,l.w,l.name);R.info("Edge data",c,i);try{IF(l,i)?(R.info("Copying as ",l.v,l.w,c,l.name),r.setEdge(l.v,l.w,c,l.name),R.info("newGraph edges ",r.edges(),r.edge(r.edges()[0]))):R.info("Skipping copy of edge ",l.v,"-->",l.w," rootId: ",i," clusterId:",e)}catch(h){R.error(h)}})}R.debug("Removing node",o),t.removeNode(o)})},"copy"),cy=p((e,t)=>{const r=t.children(e);let i=[...r];for(const s of r)ly.set(s,e),i=[...i,...cy(s,t)];return i},"extractDescendants"),PF=p((e,t,r)=>{const i=e.edges().filter(l=>l.v===t||l.w===t),s=e.edges().filter(l=>l.v===r||l.w===r),o=i.map(l=>({v:l.v===t?r:l.v,w:l.w===t?t:l.w})),a=s.map(l=>({v:l.v,w:l.w}));return o.filter(l=>a.some(c=>l.v===c.v&&l.w===c.w))},"findCommonEdges"),Yo=p((e,t,r)=>{const i=t.children(e);if(R.trace("Searching children of id ",e,i),i.length<1)return e;let s;for(const o of i){const a=Yo(o,t,r),n=PF(t,r,a);if(a)if(n.length>0)s=a;else return a}return s},"findNonClusterChild"),sd=p(e=>!Rt.has(e)||!Rt.get(e).externalConnections?e:Rt.has(e)?Rt.get(e).id:e,"getAnchorId"),h3=p((e,t)=>{if(!e||t>10){R.debug("Opting out, no graph ");return}else R.debug("Opting in, graph ");e.nodes().forEach(function(r){e.children(r).length>0&&(R.debug("Cluster identified",r," Replacement id in edges: ",Yo(r,e,r)),ei.set(r,cy(r,e)),Rt.set(r,{id:Yo(r,e,r),clusterData:e.node(r)}))}),e.nodes().forEach(function(r){const i=e.children(r),s=e.edges();i.length>0?(R.debug("Cluster identified",r,ei),s.forEach(o=>{const a=Es(o.v,r),n=Es(o.w,r);a^n&&(R.debug("Edge: ",o," leaves cluster ",r),R.debug("Descendants of XXX ",r,": ",ei.get(r)),Rt.get(r).externalConnections=!0)})):R.debug("Not a cluster ",r,ei)});for(let r of Rt.keys()){const i=Rt.get(r).id,s=e.parent(i);s!==r&&Rt.has(s)&&!Rt.get(s).externalConnections&&(Rt.get(r).id=s);const o=e.edges().some(a=>a.v===r);if(i&&Rt.get(r)?.externalConnections&&o&&fy(e,i,r)){const a=RF(e,r,e.parent(i));a&&(Rt.get(r).id=a)}}e.edges().forEach(function(r){const i=e.edge(r);R.debug("Edge "+r.v+" -> "+r.w+": "+JSON.stringify(r)),R.debug("Edge "+r.v+" -> "+r.w+": "+JSON.stringify(e.edge(r)));let s=r.v,o=r.w;if(R.debug("Fix XXX",Rt,"ids:",r.v,r.w,"Translating: ",Rt.get(r.v)," --- ",Rt.get(r.w)),Rt.get(r.v)||Rt.get(r.w)){if(R.debug("Fixing and trying - removing XXX",r.v,r.w,r.name),s=sd(r.v),o=sd(r.w),e.removeEdge(r.v,r.w,r.name),s!==r.v){const a=e.parent(s);Rt.get(a).externalConnections=!0,i.fromCluster=r.v}if(o!==r.w){const a=e.parent(o);Rt.get(a).externalConnections=!0,i.toCluster=r.w}R.debug("Fix Replacing with XXX",s,o,r.name),e.setEdge(s,o,i,r.name)}}),uy(e,0),R.trace(Rt)},"adjustClustersAndEdges"),uy=p((e,t)=>{if(t>10){R.error("Bailing out");return}let r=e.nodes(),i=!1;for(const s of r){const o=e.children(s);i=i||o.length>0}if(!i){R.debug("Done, no node has children",e.nodes());return}R.debug("Nodes = ",r,t);for(const s of r)if(R.debug("Extracting node",s,Rt,Rt.has(s)&&!Rt.get(s).externalConnections,!e.parent(s),e.node(s),e.children("D")," Depth ",t),!Rt.has(s))R.debug("Not a cluster",s,t);else if(!Rt.get(s).externalConnections&&e.children(s)&&e.children(s).length>0){R.debug("Cluster without external connections, without a parent and with children",s,t);let a=e.graph().rankdir==="TB"?"LR":"TB";Rt.get(s)?.clusterData?.dir&&(a=Rt.get(s).clusterData.dir,R.debug("Fixing dir",Rt.get(s).clusterData.dir,a));const n=new fa({multigraph:!0,compound:!0}).setGraph({rankdir:a,nodesep:50,ranksep:50,marginx:8,marginy:8}).setDefaultEdgeLabel(function(){return{}});hy(s,e,n,s),e.setNode(s,{clusterNode:!0,id:s,clusterData:Rt.get(s).clusterData,label:Rt.get(s).label,graph:n})}else R.debug("Cluster ** ",s," **not meeting the criteria !externalConnections:",!Rt.get(s).externalConnections," no parent: ",!e.parent(s)," children ",e.children(s)&&e.children(s).length>0,e.children("D"),t),R.debug(Rt);r=e.nodes(),R.debug("New list of nodes",r);for(const s of r){const o=e.node(s);R.debug(" Now next level",s,o),o?.clusterNode&&uy(o.graph,t+1)}},"extractor"),dy=p((e,t)=>{if(t.length===0)return[];let r=Object.assign([],t);return t.forEach(i=>{const s=e.children(i),o=dy(e,s);r=[...r,...o]}),r},"sorter"),c3=p(e=>dy(e,e.children()),"sortNodesByHierarchy"),fy=p((e,t,r)=>{let i=e.parent(t);for(;i&&i!==r;){const s=Rt.get(i);if(s&&!s.externalConnections)return!0;i=e.parent(i)}return!1},"isNodeInExtractableCluster"),RF=p((e,t,r)=>{const i=e.children(t)??[];for(const s of i){if(s===r||Es(s,r))continue;const o=Yo(s,e,t);if(o&&!fy(e,o,t))return o}return null},"findSafeAnchorNode");function NF({prepareLayout:e,measureLayout:t,runLayoutCore:r,paintLayout:i,afterPaint:s,paintOptions:o}){const a=t??gy;return p(async function(l,c,h,u){const d=c.select("g");(h?.insertMarkers??Pm)(d,l.markers,l.type,l.diagramId),py();const f={element:d,helpers:h,options:u};f.preparedLayout=await e?.(l,f);const m=await a(l,f),y=await r(l,f),x={...f,measure:m};i?await i(l,x,y):await my(l,x,o),await s?.(l,x,y)},"render")}p(NF,"createCommonLayoutRenderer");function py(){rS(),mS(),cS(),DF()}p(py,"clearLayoutRenderState");async function gy(e,{element:t}){return await ny(t,e)}p(gy,"defaultMeasureLayout");async function my(e,t,r={}){const{measure:i}=t,{groups:s}=i;for(const a of r.getNodes?.(e,t)??e.nodes)r.skipNode?.(a,t)||await yy(s,a,t,r);const o=Cy(e.nodes);for(const a of e.edges)by(a,r)||await ky(s,a,o,e,r,t)}p(my,"paintLayoutData");async function yy(e,t,r,i){t.clusterNode?Su(t):xy(t,r,i)?await Em(e.clusters,t):Su(t)}p(yy,"paintLayoutNode");function xy(e,t,r){return e.isGroup===!0&&(r.isCluster?.(e,t)??!0)}p(xy,"shouldPaintAsCluster");function Cy(e){const t=new Map;for(const r of e)r?.id&&t.set(r.id,r);return t}p(Cy,"buildNodeLookup");function by(e,t){return e.isLayoutOnly||!!t.skipEdge?.(e)}p(by,"shouldSkipPaintEdge");async function ky(e,t,r,i,s,o){const a=Om(e.edgePaths,{...t},s.clusterDb??new Map,i.type,al(t.start,t,r,o,s),al(t.end,t,r,o,s),i.diagramId,wy(t,s));Mm(t)&&(Pi.has(t.id)||await nh(e.edgeLabels,t),Ty(t,a))}p(ky,"paintLayoutEdge");function al(e,t,r,i,s){return s.getEdgeNode?.(e,t,i)??(e?r.get(e)??{}:{})}p(al,"getRenderedNode");function wy(e,t){return typeof t.skipIntersect=="function"?t.skipIntersect(e):t.skipIntersect??!1}p(wy,"shouldSkipIntersect");function Ty(e,t){const r=t?.updatedPath??t?.originalPath,i=Zt(),{subGraphTitleTotalMargin:s}=oa({flowchart:i.flowchart??{}});if(e.label){const o=Pi.get(e.id);let a=e.x,n=e.y;if(r){const l=Ce.calcLabelPosition(r);R.debug("Moving label "+e.label+" from (",a,",",n,") to (",l.x,",",l.y,") abc88"),t?.updatedPath&&(a=l.x,n=l.y)}o.attr("transform",`translate(${a}, ${n+s/2})`)}if(e?.startLabelLeft){const o=te.get(e.id).startLeft;let a=e?.x,n=e?.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeStart?10:0,"start_left",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.startLabelRight){const o=te.get(e.id).startRight;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeStart?10:0,"start_right",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.endLabelLeft){const o=te.get(e.id).endLeft;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeEnd?10:0,"end_left",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}if(e.endLabelRight){const o=te.get(e.id).endRight;let a=e.x,n=e.y;if(r){const l=Ce.calcTerminalLabelPosition(e.arrowTypeEnd?10:0,"end_right",r);a=l.x,n=l.y}o.attr("transform",`translate(${a}, ${n})`)}}p(Ty,"positionRenderedEdgeLabel");function _y(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}p(_y,"getDefaultExportFromCjs");var pe={},oo={},Or={},od;function Hi(){if(od)return Or;od=1;function e(a){return typeof a>"u"||a===null}p(e,"isNothing");function t(a){return typeof a=="object"&&a!==null}p(t,"isObject");function r(a){return Array.isArray(a)?a:e(a)?[]:[a]}p(r,"toArray");function i(a,n){if(n){const l=Object.keys(n);for(let c=0,h=l.length;cu&&(c=" ... ",o=n-u+c.length),a-n>u&&(h=" ...",a=n+u-h.length),{str:c+s.slice(o,a).replace(/\t/g,"→")+h,pos:n-o+c.length}}p(t,"getLine");function r(s,o){return e.repeat(" ",o-s.length)+s}p(r,"padStart");function i(s,o){if(o=Object.create(o||null),!s.buffer)return null;o.maxLength||(o.maxLength=79),typeof o.indent!="number"&&(o.indent=1),typeof o.linesBefore!="number"&&(o.linesBefore=3),typeof o.linesAfter!="number"&&(o.linesAfter=2);const a=/\r?\n|\r|\0/g,n=[0],l=[];let c,h=-1;for(;c=a.exec(s.buffer);)l.push(c.index),n.push(c.index+c[0].length),s.position<=c.index&&h<0&&(h=n.length-2);h<0&&(h=n.length-1);let u="";const d=Math.min(s.line+o.linesAfter,l.length).toString().length,f=o.maxLength-(o.indent+d+3);for(let y=1;y<=o.linesBefore&&!(h-y<0);y++){const x=t(s.buffer,n[h-y],l[h-y],s.position-(n[h]-n[h-y]),f);u=e.repeat(" ",o.indent)+r((s.line-y+1).toString(),d)+" | "+x.str+` +`+u}const m=t(s.buffer,n[h],l[h],s.position,f);u+=e.repeat(" ",o.indent)+r((s.line+1).toString(),d)+" | "+m.str+` +`,u+=e.repeat("-",o.indent+d+3+m.pos)+`^ +`;for(let y=1;y<=o.linesAfter&&!(h+y>=l.length);y++){const x=t(s.buffer,n[h+y],l[h+y],s.position-(n[h]-n[h+y]),f);u+=e.repeat(" ",o.indent)+r((s.line+y+1).toString(),d)+" | "+x.str+` +`}return u.replace(/\n$/,"")}return p(i,"makeSnippet"),Ka=i,Ka}p(Sy,"requireSnippet");var Qa,ld;function ke(){if(ld)return Qa;ld=1;const e=Yi(),t=["kind","multi","resolve","construct","instanceOf","predicate","represent","representName","defaultStyle","styleAliases"],r=["scalar","sequence","mapping"];function i(o){const a={};return o!==null&&Object.keys(o).forEach(function(n){o[n].forEach(function(l){a[String(l)]=n})}),a}p(i,"compileStyleAliases");function s(o,a){if(a=a||{},Object.keys(a).forEach(function(n){if(t.indexOf(n)===-1)throw new e('Unknown option "'+n+'" is met in definition of "'+o+'" YAML type.')}),this.options=a,this.tag=o,this.kind=a.kind||null,this.resolve=a.resolve||function(){return!0},this.construct=a.construct||function(n){return n},this.instanceOf=a.instanceOf||null,this.predicate=a.predicate||null,this.represent=a.represent||null,this.representName=a.representName||null,this.defaultStyle=a.defaultStyle||null,this.multi=a.multi||!1,this.styleAliases=i(a.styleAliases||null),r.indexOf(this.kind)===-1)throw new e('Unknown kind "'+this.kind+'" is specified for "'+o+'" YAML type.')}return p(s,"Type2"),Qa=s,Qa}p(ke,"requireType");var Ja,hd;function yh(){if(hd)return Ja;hd=1;const e=Yi(),t=ke();function r(o,a){const n=[];return o[a].forEach(function(l){let c=n.length;n.forEach(function(h,u){h.tag===l.tag&&h.kind===l.kind&&h.multi===l.multi&&(c=u)}),n[c]=l}),n}p(r,"compileList");function i(){const o={scalar:{},sequence:{},mapping:{},fallback:{},multi:{scalar:[],sequence:[],mapping:[],fallback:[]}};function a(n){n.multi?(o.multi[n.kind].push(n),o.multi.fallback.push(n)):o[n.kind][n.tag]=o.fallback[n.tag]=n}p(a,"collectType");for(let n=0,l=arguments.length;n=48&&c<=57||c>=65&&c<=70||c>=97&&c<=102}p(r,"isHexCode");function i(c){return c>=48&&c<=55}p(i,"isOctCode");function s(c){return c>=48&&c<=57}p(s,"isDecCode");function o(c){if(c===null)return!1;const h=c.length;let u=0,d=!1;if(!h)return!1;let f=c[u];if((f==="-"||f==="+")&&(f=c[++u]),f==="0"){if(u+1===h)return!0;if(f=c[++u],f==="b"){for(u++;u=0?"0b"+c.toString(2):"-0b"+c.toString(2).slice(1)},"binary"),octal:p(function(c){return c>=0?"0o"+c.toString(8):"-0o"+c.toString(8).slice(1)},"octal"),decimal:p(function(c){return c.toString(10)},"decimal"),hexadecimal:p(function(c){return c>=0?"0x"+c.toString(16).toUpperCase():"-0x"+c.toString(16).toUpperCase().slice(1)},"hexadecimal")},defaultStyle:"decimal",styleAliases:{binary:[2,"bin"],octal:[8,"oct"],decimal:[10,"dec"],hexadecimal:[16,"hex"]}}),nn}p(_h,"requireInt");var ln,yd;function Sh(){if(yd)return ln;yd=1;const e=Hi(),t=ke(),r=new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"),i=new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");function s(c){return c===null||!r.test(c)?!1:isFinite(parseFloat(c,10))?!0:i.test(c)}p(s,"resolveYamlFloat");function o(c){let h=c.toLowerCase();const u=h[0]==="-"?-1:1;return"+-".indexOf(h[0])>=0&&(h=h.slice(1)),h===".inf"?u===1?Number.POSITIVE_INFINITY:Number.NEGATIVE_INFINITY:h===".nan"?NaN:u*parseFloat(h,10)}p(o,"constructYamlFloat");const a=/^[-+]?[0-9]+e/;function n(c,h){if(isNaN(c))switch(h){case"lowercase":return".nan";case"uppercase":return".NAN";case"camelcase":return".NaN"}else if(Number.POSITIVE_INFINITY===c)switch(h){case"lowercase":return".inf";case"uppercase":return".INF";case"camelcase":return".Inf"}else if(Number.NEGATIVE_INFINITY===c)switch(h){case"lowercase":return"-.inf";case"uppercase":return"-.INF";case"camelcase":return"-.Inf"}else if(e.isNegativeZero(c))return"-0.0";const u=c.toString(10);return a.test(u)?u.replace("e",".e"):u}p(n,"representYamlFloat");function l(c){return Object.prototype.toString.call(c)==="[object Number]"&&(c%1!==0||e.isNegativeZero(c))}return p(l,"isFloat"),ln=new t("tag:yaml.org,2002:float",{kind:"scalar",resolve:s,construct:o,predicate:l,represent:n,defaultStyle:"lowercase"}),ln}p(Sh,"requireFloat");var hn,xd;function vh(){return xd||(xd=1,hn=kh().extend({implicit:[wh(),Th(),_h(),Sh()]})),hn}p(vh,"requireJson");var cn,Cd;function Bh(){return Cd||(Cd=1,cn=vh()),cn}p(Bh,"requireCore");var un,bd;function Lh(){if(bd)return un;bd=1;const e=ke(),t=new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"),r=new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");function i(a){return a===null?!1:t.exec(a)!==null||r.exec(a)!==null}p(i,"resolveYamlTimestamp");function s(a){let n=0,l=null,c=t.exec(a);if(c===null&&(c=r.exec(a)),c===null)throw new Error("Date resolve error");const h=+c[1],u=+c[2]-1,d=+c[3];if(!c[4])return new Date(Date.UTC(h,u,d));const f=+c[4],m=+c[5],y=+c[6];if(c[7]){for(n=c[7].slice(0,3);n.length<3;)n+="0";n=+n}if(c[9]){const C=+c[10],k=+(c[11]||0);l=(C*60+k)*6e4,c[9]==="-"&&(l=-l)}const x=new Date(Date.UTC(h,u,d,f,m,y,n));return l&&x.setTime(x.getTime()-l),x}p(s,"constructYamlTimestamp");function o(a){return a.toISOString()}return p(o,"representYamlTimestamp"),un=new e("tag:yaml.org,2002:timestamp",{kind:"scalar",resolve:i,construct:s,instanceOf:Date,represent:o}),un}p(Lh,"requireTimestamp");var dn,kd;function Fh(){if(kd)return dn;kd=1;const e=ke();function t(r){return r==="<<"||r===null}return p(t,"resolveYamlMerge"),dn=new e("tag:yaml.org,2002:merge",{kind:"scalar",resolve:t}),dn}p(Fh,"requireMerge");var fn,wd;function Ah(){if(wd)return fn;wd=1;const e=ke(),t=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/= +\r`;function r(a){if(a===null)return!1;let n=0;const l=a.length,c=t;for(let h=0;h64)){if(u<0)return!1;n+=6}}return n%8===0}p(r,"resolveYamlBinary");function i(a){const n=a.replace(/[\r\n=]/g,""),l=n.length,c=t;let h=0;const u=[];for(let f=0;f>16&255),u.push(h>>8&255),u.push(h&255)),h=h<<6|c.indexOf(n.charAt(f));const d=l%4*6;return d===0?(u.push(h>>16&255),u.push(h>>8&255),u.push(h&255)):d===18?(u.push(h>>10&255),u.push(h>>2&255)):d===12&&u.push(h>>4&255),new Uint8Array(u)}p(i,"constructYamlBinary");function s(a){let n="",l=0;const c=a.length,h=t;for(let d=0;d>18&63],n+=h[l>>12&63],n+=h[l>>6&63],n+=h[l&63]),l=(l<<8)+a[d];const u=c%3;return u===0?(n+=h[l>>18&63],n+=h[l>>12&63],n+=h[l>>6&63],n+=h[l&63]):u===2?(n+=h[l>>10&63],n+=h[l>>4&63],n+=h[l<<2&63],n+=h[64]):u===1&&(n+=h[l>>2&63],n+=h[l<<4&63],n+=h[64],n+=h[64]),n}p(s,"representYamlBinary");function o(a){return Object.prototype.toString.call(a)==="[object Uint8Array]"}return p(o,"isBinary"),fn=new e("tag:yaml.org,2002:binary",{kind:"scalar",resolve:r,construct:i,predicate:o,represent:s}),fn}p(Ah,"requireBinary");var pn,Td;function Eh(){if(Td)return pn;Td=1;const e=ke(),t=Object.prototype.hasOwnProperty,r=Object.prototype.toString;function i(o){if(o===null)return!0;const a=[],n=o;for(let l=0,c=n.length;l=48&&g<=57)return g-48;const M=g|32;return M>=97&&M<=102?M-97+10:-1}p(A,"fromHexCode");function L(g){return g===120?2:g===117?4:g===85?8:0}p(L,"escapedHexLen");function F(g){return g>=48&&g<=57?g-48:-1}p(F,"fromDecimalCode");function Z(g){switch(g){case 48:return"\0";case 97:return"\x07";case 98:return"\b";case 116:return" ";case 9:return" ";case 110:return` +`;case 118:return"\v";case 102:return"\f";case 114:return"\r";case 101:return"\x1B";case 32:return" ";case 34:return'"';case 47:return"/";case 92:return"\\";case 78:return"…";case 95:return" ";case 76:return"\u2028";case 80:return"\u2029";default:return""}}p(Z,"simpleEscapeSequence");function U(g){return g<=65535?String.fromCharCode(g):String.fromCharCode((g-65536>>10)+55296,(g-65536&1023)+56320)}p(U,"charFromCodepoint");function N(g,M,j){M==="__proto__"?Object.defineProperty(g,M,{configurable:!0,enumerable:!0,writable:!0,value:j}):g[M]=j}p(N,"setProperty");const st=new Array(256),Y=new Array(256);for(let g=0;g<256;g++)st[g]=Z(g)?1:0,Y[g]=Z(g);function $(g,M){this.input=g,this.filename=M.filename||null,this.schema=M.schema||i,this.onWarning=M.onWarning||null,this.legacy=M.legacy||!1,this.json=M.json||!1,this.listener=M.listener||null,this.maxDepth=typeof M.maxDepth=="number"?M.maxDepth:100,this.maxTotalMergeKeys=typeof M.maxTotalMergeKeys=="number"?M.maxTotalMergeKeys:1e4,this.implicitTypes=this.schema.compiledImplicit,this.typeMap=this.schema.compiledTypeMap,this.length=g.length,this.position=0,this.line=0,this.lineStart=0,this.lineIndent=0,this.depth=0,this.totalMergeKeys=0,this.firstTabInLine=-1,this.documents=[],this.anchorMapTransactions=[]}p($,"State");function I(g,M){const j={name:g.filename,buffer:g.input.slice(0,-1),position:g.position,line:g.line,column:g.position-g.lineStart};return j.snippet=r(j),new t(M,j)}p(I,"generateError");function B(g,M){throw I(g,M)}p(B,"throwError");function q(g,M){g.onWarning&&g.onWarning.call(null,I(g,M))}p(q,"throwWarning");function O(g,M,j){const X=g.anchorMapTransactions;if(X.length!==0){const H=X[X.length-1];s.call(H,M)||(H[M]={existed:s.call(g.anchorMap,M),value:g.anchorMap[M]})}g.anchorMap[M]=j}p(O,"storeAnchor");function it(g){g.anchorMapTransactions.push(Object.create(null))}p(it,"beginAnchorTransaction");function tt(g){const M=g.anchorMapTransactions.pop(),j=g.anchorMapTransactions;if(j.length===0)return;const X=j[j.length-1],H=Object.keys(M);for(let rt=0,w=H.length;rt=0;X-=1){const H=M[j[X]];H.existed?g.anchorMap[j[X]]=H.value:delete g.anchorMap[j[X]]}}p(gt,"rollbackAnchorTransaction");function ht(g){return{position:g.position,line:g.line,lineStart:g.lineStart,lineIndent:g.lineIndent,firstTabInLine:g.firstTabInLine,tag:g.tag,anchor:g.anchor,kind:g.kind,result:g.result}}p(ht,"snapshotState");function Tt(g,M){g.position=M.position,g.line=M.line,g.lineStart=M.lineStart,g.lineIndent=M.lineIndent,g.firstTabInLine=M.firstTabInLine,g.tag=M.tag,g.anchor=M.anchor,g.kind=M.kind,g.result=M.result}p(Tt,"restoreState");const Ft={YAML:p(function(M,j,X){M.version!==null&&B(M,"duplication of %YAML directive"),X.length!==1&&B(M,"YAML directive accepts exactly one argument");const H=/^([0-9]+)\.([0-9]+)$/.exec(X[0]);H===null&&B(M,"ill-formed argument of the YAML directive");const rt=parseInt(H[1],10),w=parseInt(H[2],10);rt!==1&&B(M,"unacceptable YAML version of the document"),M.version=X[0],M.checkLineBreaks=w<2,w!==1&&w!==2&&q(M,"unsupported YAML version of the document")},"handleYamlDirective"),TAG:p(function(M,j,X){let H;X.length!==2&&B(M,"TAG directive accepts exactly two arguments");const rt=X[0];H=X[1],y.test(rt)||B(M,"ill-formed tag handle (first argument) of the TAG directive"),s.call(M.tagMap,rt)&&B(M,'there is a previously declared suffix for "'+rt+'" tag handle'),x.test(H)||B(M,"ill-formed tag prefix (second argument) of the TAG directive");try{H=decodeURIComponent(H)}catch{B(M,"tag prefix is malformed: "+H)}M.tagMap[rt]=H},"handleTagDirective")};function Bt(g,M,j,X){if(M=32&&P<=1114111||B(g,"expected valid JSON character")}else d.test(H)&&B(g,"the stream contains non-printable characters");g.result+=H}}p(Bt,"captureSegment");function pt(g,M,j,X){e.isObject(j)||B(g,"cannot merge mappings; the provided source object is unacceptable");const H=Object.keys(j);for(let rt=0,w=H.length;rtg.maxTotalMergeKeys&&B(g,"merge keys exceeded maxTotalMergeKeys ("+g.maxTotalMergeKeys+")"),s.call(M,P)||(N(M,P,j[P]),X[P]=!0)}}p(pt,"mergeMappings");function wt(g,M,j,X,H,rt,w,P,J){if(Array.isArray(H)){H=Array.prototype.slice.call(H);for(let G=0,V=H.length;G1&&(g.result+=e.repeat(` +`,M-1))}p(Wt,"writeFoldedLines");function $t(g,M,j){let X,H,rt,w,P,J;const G=g.kind,V=g.result;let Q=g.input.charCodeAt(g.position);if(S(Q)||v(Q)||Q===35||Q===38||Q===42||Q===33||Q===124||Q===62||Q===39||Q===34||Q===37||Q===64||Q===96)return!1;if(Q===63||Q===45){const K=g.input.charCodeAt(g.position+1);if(S(K)||j&&v(K))return!1}for(g.kind="scalar",g.result="",X=H=g.position,rt=!1;Q!==0;){if(Q===58){const K=g.input.charCodeAt(g.position+1);if(S(K)||j&&v(K))break}else if(Q===35){const K=g.input.charCodeAt(g.position-1);if(S(K))break}else{if(g.position===g.lineStart&&zt(g)||j&&v(Q))break;if(k(Q))if(w=g.line,P=g.lineStart,J=g.lineIndent,_t(g,!1,-1),g.lineIndent>=M){rt=!0,Q=g.input.charCodeAt(g.position);continue}else{g.position=H,g.line=w,g.lineStart=P,g.lineIndent=J;break}}rt&&(Bt(g,X,H,!1),Wt(g,g.line-w),X=H=g.position,rt=!1),T(Q)||(H=g.position+1),Q=g.input.charCodeAt(++g.position)}return Bt(g,X,H,!1),g.result?!0:(g.kind=G,g.result=V,!1)}p($t,"readPlainScalar");function we(g,M){let j,X,H=g.input.charCodeAt(g.position);if(H!==39)return!1;for(g.kind="scalar",g.result="",g.position++,j=X=g.position;(H=g.input.charCodeAt(g.position))!==0;)if(H===39)if(Bt(g,j,g.position,!0),H=g.input.charCodeAt(++g.position),H===39)j=g.position,g.position++,X=g.position;else return!0;else k(H)?(Bt(g,j,X,!0),Wt(g,_t(g,!1,M)),j=X=g.position):g.position===g.lineStart&&zt(g)?B(g,"unexpected end of the document within a single quoted scalar"):(g.position++,T(H)||(X=g.position));B(g,"unexpected end of the stream within a single quoted scalar")}p(we,"readSingleQuotedScalar");function Pt(g,M){let j,X,H,rt=g.input.charCodeAt(g.position);if(rt!==34)return!1;for(g.kind="scalar",g.result="",g.position++,j=X=g.position;(rt=g.input.charCodeAt(g.position))!==0;){if(rt===34)return Bt(g,j,g.position,!0),g.position++,!0;if(rt===92){if(Bt(g,j,g.position,!0),rt=g.input.charCodeAt(++g.position),k(rt))_t(g,!1,M);else if(rt<256&&st[rt])g.result+=Y[rt],g.position++;else if((H=L(rt))>0){let w=H,P=0;for(;w>0;w--)rt=g.input.charCodeAt(++g.position),(H=A(rt))>=0?P=(P<<4)+H:B(g,"expected hexadecimal character");g.result+=U(P),g.position++}else B(g,"unknown escape sequence");j=X=g.position}else k(rt)?(Bt(g,j,X,!0),Wt(g,_t(g,!1,M)),j=X=g.position):g.position===g.lineStart&&zt(g)?B(g,"unexpected end of the document within a double quoted scalar"):(g.position++,T(rt)||(X=g.position))}B(g,"unexpected end of the stream within a double quoted scalar")}p(Pt,"readDoubleQuotedScalar");function pr(g,M){let j=!0,X,H,rt;const w=g.tag;let P;const J=g.anchor;let G,V,Q,K;const ut=Object.create(null);let nt,mt,bt,Dt=g.input.charCodeAt(g.position);if(Dt===91)G=93,K=!1,P=[];else if(Dt===123)G=125,K=!0,P={};else return!1;for(g.anchor!==null&&O(g,g.anchor,P),Dt=g.input.charCodeAt(++g.position);Dt!==0;){if(_t(g,!0,M),Dt=g.input.charCodeAt(g.position),Dt===G)return g.position++,g.tag=w,g.anchor=J,g.kind=K?"mapping":"sequence",g.result=P,!0;if(j?Dt===44&&B(g,"expected the node content, but found ','"):B(g,"missed comma between flow collection entries"),mt=nt=bt=null,V=Q=!1,Dt===63){const Yt=g.input.charCodeAt(g.position+1);S(Yt)&&(V=Q=!0,g.position++,_t(g,!0,M))}X=g.line,H=g.lineStart,rt=g.position,Be(g,M,o,!1,!0),mt=g.tag,nt=g.result,_t(g,!0,M),Dt=g.input.charCodeAt(g.position),(Q||g.line===X)&&Dt===58&&(V=!0,Dt=g.input.charCodeAt(++g.position),_t(g,!0,M),Be(g,M,o,!1,!0),bt=g.result),K?wt(g,P,ut,mt,nt,bt,X,H,rt):V?P.push(wt(g,null,ut,mt,nt,bt,X,H,rt)):P.push(nt),_t(g,!0,M),Dt=g.input.charCodeAt(g.position),Dt===44?(j=!0,Dt=g.input.charCodeAt(++g.position)):j=!1}B(g,"unexpected end of the stream within a flow collection")}p(pr,"readFlowCollection");function jt(g,M){let j,X=c,H=!1,rt=!1,w=M,P=0,J=!1,G,V=g.input.charCodeAt(g.position);if(V===124)j=!1;else if(V===62)j=!0;else return!1;for(g.kind="scalar",g.result="";V!==0;)if(V=g.input.charCodeAt(++g.position),V===43||V===45)c===X?X=V===43?u:h:B(g,"repeat of a chomping mode identifier");else if((G=F(V))>=0)G===0?B(g,"bad explicit indentation width of a block scalar; it cannot be less than one"):rt?B(g,"repeat of an indentation width identifier"):(w=M+G-1,rt=!0);else break;if(T(V)){do V=g.input.charCodeAt(++g.position);while(T(V));if(V===35)do V=g.input.charCodeAt(++g.position);while(!k(V)&&V!==0)}for(;V!==0;){for(Ot(g),g.lineIndent=0,V=g.input.charCodeAt(g.position);(!rt||g.lineIndentw&&(w=g.lineIndent),k(V)){P++;continue}if(!rt&&w===0&&B(g,"missing indentation for block scalar"),g.lineIndentM)&&w!==0)B(g,"bad indentation of a sequence entry");else if(g.lineIndentM)&&(nt&&(H=g.line,rt=g.lineStart,w=g.position),Be(g,M,l,!0,X)&&(nt?K=g.result:ut=g.result),nt||(wt(g,G,V,Q,K,ut,H,rt,w),Q=K=ut=null),_t(g,!0,-1),bt=g.input.charCodeAt(g.position)),(g.line===Yt||g.lineIndent>M)&&bt!==0)B(g,"bad indentation of a mapping entry");else if(g.lineIndent=g.maxDepth&&B(g,"nesting exceeded maxDepth ("+g.maxDepth+")"),g.depth+=1,g.listener!==null&&g.listener("open",g),g.tag=null,g.anchor=null,g.kind=null,g.result=null;const nt=rt=w=l===j||n===j;if(X&&_t(g,!0,-1)&&(J=!0,g.lineIndent>M?P=1:g.lineIndent===M?P=0:g.lineIndentM?P=1:g.lineIndent===M?P=0:g.lineIndent tag; it should be "scalar", not "'+g.kind+'"');for(let mt=0,bt=g.implicitTypes.length;mt"),g.result!==null&&Q.kind!==g.kind&&B(g,"unacceptable node kind for !<"+g.tag+'> tag; it should be "'+Q.kind+'", not "'+g.kind+'"'),Q.resolve(g.result,g.tag)?(g.result=Q.construct(g.result,g.tag),g.anchor!==null&&O(g,g.anchor,g.result)):B(g,"cannot resolve a node with !<"+g.tag+"> explicit tag")}return g.listener!==null&&g.listener("close",g),g.depth-=1,g.tag!==null||g.anchor!==null||G}p(Be,"composeNode");function Le(g){const M=g.position;let j=!1,X;for(g.version=null,g.checkLineBreaks=g.legacy,g.tagMap=Object.create(null),g.anchorMap=Object.create(null);(X=g.input.charCodeAt(g.position))!==0&&(_t(g,!0,-1),X=g.input.charCodeAt(g.position),!(g.lineIndent>0||X!==37));){j=!0,X=g.input.charCodeAt(++g.position);let H=g.position;for(;X!==0&&!S(X);)X=g.input.charCodeAt(++g.position);const rt=g.input.slice(H,g.position),w=[];for(rt.length<1&&B(g,"directive name must not be less than one character in length");X!==0;){for(;T(X);)X=g.input.charCodeAt(++g.position);if(X===35){do X=g.input.charCodeAt(++g.position);while(X!==0&&!k(X));break}if(k(X))break;for(H=g.position;X!==0&&!S(X);)X=g.input.charCodeAt(++g.position);w.push(g.input.slice(H,g.position))}X!==0&&Ot(g),s.call(Ft,rt)?Ft[rt](g,rt,w):q(g,'unknown document directive "'+rt+'"')}if(_t(g,!0,-1),g.lineIndent===0&&g.input.charCodeAt(g.position)===45&&g.input.charCodeAt(g.position+1)===45&&g.input.charCodeAt(g.position+2)===45?(g.position+=3,_t(g,!0,-1)):j&&B(g,"directives end mark is expected"),Be(g,g.lineIndent-1,l,!1,!0),_t(g,!0,-1),g.checkLineBreaks&&f.test(g.input.slice(M,g.position))&&q(g,"non-ASCII line breaks are interpreted as content"),g.documents.push(g.result),g.position===g.lineStart&&zt(g)){g.input.charCodeAt(g.position)===46&&(g.position+=3,_t(g,!0,-1));return}g.position"u"&&(j=M,M=null);const X=Te(g,j);if(typeof M!="function")return X;for(let H=0,rt=X.length;H=32&&w<=126||w>=161&&w<=55295&&w!==8232&&w!==8233||w>=57344&&w<=65533&&w!==o||w>=65536&&w<=1114111}p(pt,"isPrintable");function wt(w){return pt(w)&&w!==o&&w!==l&&w!==n}p(wt,"isNsCharOrWhitespace");function Ot(w,P,J){const G=wt(w),V=G&&!Bt(w);return(J?G:G&&w!==C&&w!==F&&w!==Z&&w!==N&&w!==Y)&&w!==d&&!(P===T&&!V)||wt(P)&&!Bt(P)&&w===d||P===T&&V}p(Ot,"isPlainSafe");function _t(w){return pt(w)&&w!==o&&!Bt(w)&&w!==k&&w!==A&&w!==T&&w!==C&&w!==F&&w!==Z&&w!==N&&w!==Y&&w!==d&&w!==m&&w!==x&&w!==h&&w!==st&&w!==S&&w!==v&&w!==y&&w!==u&&w!==f&&w!==L&&w!==U}p(_t,"isPlainSafeFirst");function zt(w){return!Bt(w)&&w!==T}p(zt,"isPlainSafeLast");function Wt(w,P){const J=w.charCodeAt(P);let G;return J>=55296&&J<=56319&&P+1=56320&&G<=57343)?(J-55296)*1024+G-56320+65536:J}p(Wt,"codePointAt");function $t(w){return/^\n* /.test(w)}p($t,"needIndentIndicator");const we=1,Pt=2,pr=3,jt=4,de=5;function gr(w,P,J,G,V,Q,K,ut){let nt,mt=0,bt=null,Dt=!1,Yt=!1;const Ur=G!==-1;let fe=-1,Ne=_t(Wt(w,0))&&zt(Wt(w,w.length-1));if(P||K)for(nt=0;nt=65536?nt+=2:nt++){if(mt=Wt(w,nt),!pt(mt))return de;Ne=Ne&&Ot(mt,bt,ut),bt=mt}else{for(nt=0;nt=65536?nt+=2:nt++){if(mt=Wt(w,nt),mt===n)Dt=!0,Ur&&(Yt=Yt||nt-fe-1>G&&w[fe+1]!==" ",fe=nt);else if(!pt(mt))return de;Ne=Ne&&Ot(mt,bt,ut),bt=mt}Yt=Yt||Ur&&nt-fe-1>G&&w[fe+1]!==" "}return!Dt&&!Yt?Ne&&!K&&!V(w)?we:Q===tt?de:Pt:J>9&&$t(w)?de:K?Q===tt?de:Pt:Yt?jt:pr}p(gr,"chooseScalarStyle");function ve(w,P,J,G,V){w.dump=(function(){if(P.length===0)return w.quotingType===tt?'""':"''";if(!w.noCompatMode&&(I.indexOf(P)!==-1||B.test(P)))return w.quotingType===tt?'"'+P+'"':"'"+P+"'";const Q=w.indent*Math.max(1,J),K=w.lineWidth===-1?-1:Math.max(Math.min(w.lineWidth,40),w.lineWidth-Q),ut=G||w.flowLevel>-1&&J>=w.flowLevel;function nt(mt){return Ft(w,mt)}switch(p(nt,"testAmbiguity"),gr(P,ut,w.indent,K,nt,w.quotingType,w.forceQuotes&&!G,V)){case we:return P;case Pt:return"'"+P.replace(/'/g,"''")+"'";case pr:return"|"+mr(P,w.indent)+Je(ht(P,Q));case jt:return">"+mr(P,w.indent)+Je(ht(Er(P,K),Q));case de:return'"'+Le(P)+'"';default:throw new t("impossible error: invalid scalar style")}})()}p(ve,"writeScalar");function mr(w,P){const J=$t(w)?String(P):"",G=w[w.length-1]===` +`,Q=G&&(w[w.length-2]===` +`||w===` +`)?"+":G?"":"-";return J+Q+` +`}p(mr,"blockHeader");function Je(w){return w[w.length-1]===` +`?w.slice(0,-1):w}p(Je,"dropEndingNewline");function Er(w,P){const J=/(\n+)([^\n]*)/g;let G=(function(){let ut=w.indexOf(` +`);return ut=ut!==-1?ut:w.length,J.lastIndex=ut,Be(w.slice(0,ut),P)})(),V=w[0]===` +`||w[0]===" ",Q,K;for(;K=J.exec(w);){const ut=K[1],nt=K[2];Q=nt[0]===" ",G+=ut+(!V&&!Q&&nt!==""?` +`:"")+Be(nt,P),V=Q}return G}p(Er,"foldString");function Be(w,P){if(w===""||w[0]===" ")return w;const J=/ [^ ]/g;let G,V=0,Q,K=0,ut=0,nt="";for(;G=J.exec(w);)ut=G.index,ut-V>P&&(Q=K>V?K:ut,nt+=` +`+w.slice(V,Q),V=Q+1),K=ut;return nt+=` +`,w.length-V>P&&K>V?nt+=w.slice(V,K)+` +`+w.slice(K+1):nt+=w.slice(V),nt.slice(1)}p(Be,"foldLine");function Le(w){let P="",J=0;for(let G=0;G=65536?G+=2:G++){J=Wt(w,G);const V=$[J];!V&&pt(J)?(P+=w[G],J>=65536&&(P+=w[G+1])):P+=V||O(J)}return P}p(Le,"escapeString");function Te(w,P,J){let G="";const V=w.tag;for(let Q=0,K=J.length;Q"u"&&j(w,P,null,!1,!1))&&(G!==""&&(G+=","+(w.condenseFlow?"":" ")),G+=w.dump)}w.tag=V,w.dump="["+G+"]"}p(Te,"writeFlowSequence");function Fe(w,P,J,G){let V="";const Q=w.tag;for(let K=0,ut=J.length;K"u"&&j(w,P+1,null,!0,!0,!1,!0))&&((!G||V!=="")&&(V+=Tt(w,P)),w.dump&&n===w.dump.charCodeAt(0)?V+="-":V+="- ",V+=w.dump)}w.tag=Q,w.dump=V||"[]"}p(Fe,"writeBlockSequence");function yr(w,P,J){let G="";const V=w.tag,Q=Object.keys(J);for(let K=0,ut=Q.length;K1024&&(nt+="? "),nt+=w.dump+(w.condenseFlow?'"':"")+":"+(w.condenseFlow?"":" "),j(w,P,bt,!1,!1)&&(nt+=w.dump,G+=nt))}w.tag=V,w.dump="{"+G+"}"}p(yr,"writeFlowMapping");function g(w,P,J,G){let V="";const Q=w.tag,K=Object.keys(J);if(w.sortKeys===!0)K.sort();else if(typeof w.sortKeys=="function")K.sort(w.sortKeys);else if(w.sortKeys)throw new t("sortKeys must be a boolean or a function");for(let ut=0,nt=K.length;ut1024;Yt&&(w.dump&&n===w.dump.charCodeAt(0)?mt+="?":mt+="? "),mt+=w.dump,Yt&&(mt+=Tt(w,P)),j(w,P+1,Dt,!0,Yt)&&(w.dump&&n===w.dump.charCodeAt(0)?mt+=":":mt+=": ",mt+=w.dump,V+=mt)}w.tag=Q,w.dump=V||"{}"}p(g,"writeBlockMapping");function M(w,P,J){const G=J?w.explicitTypes:w.implicitTypes;for(let V=0,Q=G.length;V tag resolver accepts not "'+ut+'" style');w.dump=nt}return!0}}return!1}p(M,"detectType");function j(w,P,J,G,V,Q,K){w.tag=null,w.dump=J,M(w,J,!1)||M(w,J,!0);const ut=i.call(w.dump),nt=G;G&&(G=w.flowLevel<0||w.flowLevel>P);const mt=ut==="[object Object]"||ut==="[object Array]";let bt,Dt;if(mt&&(bt=w.duplicates.indexOf(J),Dt=bt!==-1),(w.tag!==null&&w.tag!=="?"||Dt||w.indent!==2&&P>0)&&(V=!1),Dt&&w.usedDuplicates[bt])w.dump="*ref_"+bt;else{if(mt&&Dt&&!w.usedDuplicates[bt]&&(w.usedDuplicates[bt]=!0),ut==="[object Object]")G&&Object.keys(w.dump).length!==0?(g(w,P,w.dump,V),Dt&&(w.dump="&ref_"+bt+w.dump)):(yr(w,P,w.dump),Dt&&(w.dump="&ref_"+bt+" "+w.dump));else if(ut==="[object Array]")G&&w.dump.length!==0?(w.noArrayIndent&&!K&&P>0?Fe(w,P-1,w.dump,V):Fe(w,P,w.dump,V),Dt&&(w.dump="&ref_"+bt+w.dump)):(Te(w,P,w.dump),Dt&&(w.dump="&ref_"+bt+" "+w.dump));else if(ut==="[object String]")w.tag!=="?"&&ve(w,w.dump,P,Q,nt);else{if(ut==="[object Undefined]")return!1;if(w.skipInvalid)return!1;throw new t("unacceptable kind of an object to dump "+ut)}if(w.tag!==null&&w.tag!=="?"){let Yt=encodeURI(w.tag[0]==="!"?w.tag.slice(1):w.tag).replace(/!/g,"%21");w.tag[0]==="!"?Yt="!"+Yt:Yt.slice(0,18)==="tag:yaml.org,2002:"?Yt="!!"+Yt.slice(18):Yt="!<"+Yt+">",w.dump=Yt+" "+w.dump}}return!0}p(j,"writeNode");function X(w,P){const J=[],G=[];H(w,J,G);const V=G.length;for(let Q=0;Q{for(const t of e)Ms[t.name]=t},"registerLayoutLoaders"),UF=p(()=>{Fy([{name:"dagre",loader:p(async()=>await Et(()=>import("./chunks/dagre-GXQ25YYZ.Bfcz7YMP.js"),__vite__mapDeps([3,4,1,2])),"loader")},{name:"swimlane",loader:p(async()=>await Et(()=>import("./chunks/swimlanes-42K2YHIH.DzZBAVKe.js"),__vite__mapDeps([5,1,2])),"loader")},{name:"cose-bilkent",loader:p(async()=>await Et(()=>import("./chunks/cose-bilkent-JH36ORCC.DH3k0r7k.js"),__vite__mapDeps([6,7,1,2])),"loader")}])},"registerDefaultLayoutLoaders");UF();var T3=p(async(e,t)=>{if(!(e.layoutAlgorithm in Ms))throw new Error(`Unknown layout algorithm: ${e.layoutAlgorithm}`);if(e.diagramId)for(const h of e.nodes){const u=h.domId||h.id;h.domId=`${e.diagramId}-${u}`}const r=Ms[e.layoutAlgorithm],i=await r.loader(),{theme:s,themeVariables:o}=e.config,{useGradient:a,gradientStart:n,gradientStop:l}=o,c=t.attr("id");if(t.append("defs").append("filter").attr("id",`${c}-drop-shadow`).attr("height","130%").attr("width","130%").append("feDropShadow").attr("dx","4").attr("dy","4").attr("stdDeviation",0).attr("flood-opacity","0.06").attr("flood-color",`${s?.includes("dark")?"#FFFFFF":"#000000"}`),t.append("defs").append("filter").attr("id",`${c}-drop-shadow-small`).attr("height","150%").attr("width","150%").append("feDropShadow").attr("dx","2").attr("dy","2").attr("stdDeviation",0).attr("flood-opacity","0.06").attr("flood-color",`${s?.includes("dark")?"#FFFFFF":"#000000"}`),a){const h=t.append("linearGradient").attr("id",t.attr("id")+"-gradient").attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");h.append("svg:stop").attr("offset","0%").attr("stop-color",n).attr("stop-opacity",1),h.append("svg:stop").attr("offset","100%").attr("stop-color",l).attr("stop-opacity",1)}return i.render(e,t,YF,{algorithm:r.algorithm})},"render"),_3=p((e="",{fallback:t="dagre"}={})=>{if(e in Ms)return e;if(t in Ms)return R.warn(`Layout algorithm ${e} is not registered. Using ${t} as fallback.`),t;throw new Error(`Both layout algorithms ${e} and ${t} are not registered.`)},"getRegisteredLayoutAlgorithm"),Oh="comm",Ay="rule",Ey="decl",jF="@media",GF="@import",XF="@supports",VF="@namespace",nl="@keyframes",My="@layer",ZF="@scope",KF=Math.abs,ws=String.fromCharCode;function $y(e){return e.trim()}function ll(e,t,r){return e.replace(t,r)}function Ei(e,t){return e.charCodeAt(t)|0}function Ri(e,t,r){return e.slice(t,r)}function ir(e){return e.length}function Oy(e){return e.length}function ao(e,t){return t.push(e),e}var ga=1,Ni=1,Dy=0,We=0,ee=0,Ui="";function Dh(e,t,r,i,s,o,a,n){return{value:e,root:t,parent:r,type:i,props:s,children:o,line:ga,column:Ni,length:a,return:"",siblings:n}}function QF(){return ee}function JF(){return ee=We>0?Ei(Ui,--We):0,Ni--,ee===10&&(Ni=1,ga--),ee}function Ve(){return ee=We2||$s(ee)>3?"":" "}function iA(e,t){for(;--t&&Ve()&&!(ee<48||ee>102||ee>57&&ee<65||ee>70&&ee<97););return ma(e,yo()+(t<6&&Nr()==32&&Ve()==32))}function hl(e){for(;Ve();)switch(ee){case e:return We;case 34:case 39:e!==34&&e!==39&&hl(ee);break;case 40:e===41&&hl(e);break;case 92:Ve();break}return We}function sA(e,t){for(;Ve()&&e+ee!==57;)if(e+ee===84&&Nr()===47)break;return"/*"+ma(t,We-1)+"*"+ws(e===47?e:Ve())}function oA(e){for(;!$s(Nr());)Ve();return ma(e,We)}function aA(e){return eA(xo("",null,null,null,[""],e=tA(e),0,[0],e))}function xo(e,t,r,i,s,o,a,n,l){for(var c=0,h=0,u=a,d=0,f=0,m=0,y=1,x=1,C=1,k=0,T=0,S="",v=s,A=o,L=i,F=S;x;)switch(m=T,T=Ve()){case 40:m!=108&&Ei(F,u-1)==58?(k++,F+="("):F+=Cn(T);break;case 41:k--,F+=")";break;case 34:case 39:case 91:F+=Cn(T);break;case 9:case 10:case 13:case 32:if(k>0){F+=ws(T);break}F+=rA(m);break;case 92:F+=iA(yo()-1,7);continue;case 47:switch(Nr()){case 42:case 47:ao(nA(sA(Ve(),yo()),t,r,l),l),($s(m||1)==5||$s(Nr()||1)==5)&&ir(F)&&Ri(F,-1,void 0)!==" "&&(F+=" ");break;default:F+="/"}break;case 123*y:n[c++]=ir(F)*C;case 125*y:case 59:case 0:if(k>0&&T){F+=ws(T);break}switch(T){case 0:case 125:x=0;case 59+h:C==-1&&(F=ll(F,/\f/g,"")),f>0&&(ir(F)-u||y===0)&&ao(f>32?Ed(F+";",i,r,u-1,l):Ed(ll(F," ","")+";",i,r,u-2,l),l);break;case 59:F+=";";default:if(ao(L=Ad(F,t,r,c,h,s,n,S,v=[],A=[],u,o),o),T===123)if(h===0)xo(F,t,L,L,v,o,u,n,A);else{switch(d){case 99:if(Ei(F,3)===110)break;case 108:if(Ei(F,2)===97)break;default:h=0;case 100:case 109:case 115:}h?xo(e,L,L,i&&ao(Ad(e,L,L,0,0,s,n,S,s,v=[],u,A),A),s,A,u,n,i?v:A):xo(F,L,L,L,[""],A,0,n,A)}}c=h=f=0,y=C=1,S=F="",u=a;break;case 58:u=1+ir(F),f=m;default:if(y<1){if(T==123)--y;else if(T==125&&y++==0&&JF()==125)continue}switch(F+=ws(T),T*y){case 38:C=h>0?1:(F+="\f",-1);break;case 44:if(k>0)break;n[c++]=(ir(F)-1)*C,C=1;break;case 64:Nr()===45&&(F+=Cn(Ve())),d=Nr(),h=u=ir(S=F+=oA(yo())),T++;break;case 45:m===45&&ir(F)==2&&(y=0)}}return o}function Ad(e,t,r,i,s,o,a,n,l,c,h,u){for(var d=s-1,f=s===0?o:[""],m=Oy(f),y=0,x=0,C=0;y0?f[k]+" "+T:ll(T,/&\f/g,f[k])))&&(l[C++]=S);return Dh(e,t,r,s===0?Ay:n,l,c,h,u)}function nA(e,t,r,i){return Dh(e,t,r,Oh,ws(QF()),Ri(e,2,-2),0,i)}function Ed(e,t,r,i,s){return Dh(e,t,r,Ey,Ri(e,0,i),Ri(e,i+1,-1),i,s)}function cl(e,t){for(var r="",i=0;i/^\s*C4Context|C4Container|C4Component|C4Dynamic|C4Deployment/.test(e),"detector"),uA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/c4Diagram-7LVT6UL2.C1MP3r9C.js");return{diagram:t}},__vite__mapDeps([8,9,1,2]));return{id:Iy,diagram:e}},"loader"),dA={id:Iy,detector:cA,loader:uA},fA=dA,Py="flowchart",pA=p((e,t)=>t?.flowchart?.defaultRenderer==="dagre-wrapper"||t?.flowchart?.defaultRenderer==="elk"?!1:/^\s*graph/.test(e),"detector"),gA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/flowDiagram-HODETNUW.ClPsWLK6.js").then(r=>r.f);return{diagram:t}},__vite__mapDeps([10,11,12,13,9,14]));return{id:Py,diagram:e}},"loader"),mA={id:Py,detector:pA,loader:gA},yA=mA,Ry="flowchart-v2",xA=p((e,t)=>t?.flowchart?.defaultRenderer==="dagre-d3"?!1:(t?.flowchart?.defaultRenderer==="elk"&&(t.layout="elk"),/^\s*graph/.test(e)&&t?.flowchart?.defaultRenderer==="dagre-wrapper"?!0:/^\s*flowchart/.test(e)),"detector"),CA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/flowDiagram-HODETNUW.ClPsWLK6.js").then(r=>r.f);return{diagram:t}},__vite__mapDeps([10,11,12,13,9,14]));return{id:Ry,diagram:e}},"loader"),bA={id:Ry,detector:xA,loader:CA},kA=bA,Ny="swimlane",wA=p(e=>/^\s*swimlane-beta\b/.test(e),"detector"),TA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/swimlanesDiagram-VR7AAH4N.DfLXry6V.js");return{diagram:t}},__vite__mapDeps([15,10,11,12,13,9,14,1,2]));return{id:Ny,diagram:e}},"loader"),_A={id:Ny,detector:wA,loader:TA},SA=_A,qy="er",vA=p(e=>/^\s*erDiagram/.test(e),"detector"),BA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/erDiagram-RLTQ6QDP.BA9x2mfr.js");return{diagram:t}},__vite__mapDeps([16,12,13,14,1,2]));return{id:qy,diagram:e}},"loader"),LA={id:qy,detector:vA,loader:BA},FA=LA,zy="gitGraph",AA=p(e=>/^\s*gitGraph/.test(e),"detector"),EA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/gitGraphDiagram-WWUBYQGX.Cf6cAMBl.js");return{diagram:t}},__vite__mapDeps([17,18,19,20,1,2]));return{id:zy,diagram:e}},"loader"),MA={id:zy,detector:AA,loader:EA},$A=MA,Wy="gantt",OA=p(e=>/^\s*gantt/.test(e),"detector"),DA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/ganttDiagram-EL5Y4UJY.xjuXBlhL.js");return{diagram:t}},__vite__mapDeps([21,22,23,24,1,2]));return{id:Wy,diagram:e}},"loader"),IA={id:Wy,detector:OA,loader:DA},PA=IA,Hy="info",RA=p(e=>/^\s*info/.test(e),"detector"),NA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/infoDiagram-27XIBGKW.C3BlkN34.js");return{diagram:t}},__vite__mapDeps([25,20,1,2]));return{id:Hy,diagram:e}},"loader"),qA={id:Hy,detector:RA,loader:NA},Yy="pie",zA=p(e=>/^\s*pie/.test(e),"detector"),WA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/pieDiagram-E7YTZNPT.C7NYDYqu.js");return{diagram:t}},__vite__mapDeps([26,19,20,1,27,28,23,2]));return{id:Yy,diagram:e}},"loader"),HA={id:Yy,detector:zA,loader:WA},Uy="quadrantChart",YA=p(e=>/^\s*quadrantChart/.test(e),"detector"),UA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/quadrantDiagram-AXDQQJYC.Cm2_JhFa.js");return{diagram:t}},__vite__mapDeps([29,22,23,24,1,2]));return{id:Uy,diagram:e}},"loader"),jA={id:Uy,detector:YA,loader:UA},GA=jA,jy="xychart",XA=p(e=>/^\s*xychart(-beta)?/.test(e),"detector"),VA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/xychartDiagram-S5SC5T6Z.By1ew1_3.js");return{diagram:t}},__vite__mapDeps([30,23,28,22,24,1,2]));return{id:jy,diagram:e}},"loader"),ZA={id:jy,detector:XA,loader:VA},KA=ZA,Gy="requirement",QA=p(e=>/^\s*requirement(Diagram)?/.test(e),"detector"),JA=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/requirementDiagram-BXWQKSXE.BhCYrhyS.js");return{diagram:t}},__vite__mapDeps([31,12,13,1,2]));return{id:Gy,diagram:e}},"loader"),tE={id:Gy,detector:QA,loader:JA},eE=tE,Xy="sequence",rE=p(e=>/^\s*sequenceDiagram/.test(e),"detector"),iE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/sequenceDiagram-WJ2MYXX4.9pY_tZ7u.js");return{diagram:t}},__vite__mapDeps([32,18,9,1,2]));return{id:Xy,diagram:e}},"loader"),sE={id:Xy,detector:rE,loader:iE},oE=sE,Vy="class",aE=p((e,t)=>t?.class?.defaultRenderer==="dagre-wrapper"?!1:/^\s*classDiagram/.test(e),"detector"),nE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/classDiagram-ZZMXUADV.BCySuZ6w.js");return{diagram:t}},__vite__mapDeps([33,34,11,12,13,9,1,2]));return{id:Vy,diagram:e}},"loader"),lE={id:Vy,detector:aE,loader:nE},hE=lE,Zy="classDiagram",cE=p((e,t)=>/^\s*classDiagram/.test(e)&&t?.class?.defaultRenderer==="dagre-wrapper"?!0:/^\s*classDiagram-v2/.test(e),"detector"),uE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/classDiagram-v2-VYDZK3BY.BCySuZ6w.js");return{diagram:t}},__vite__mapDeps([35,34,11,12,13,9,1,2]));return{id:Zy,diagram:e}},"loader"),dE={id:Zy,detector:cE,loader:uE},fE=dE,Ky="state",pE=p((e,t)=>t?.state?.defaultRenderer==="dagre-wrapper"?!1:/^\s*stateDiagram/.test(e),"detector"),gE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/stateDiagram-D77RDMKH.teR48ecX.js");return{diagram:t}},__vite__mapDeps([36,37,12,13,9,4,1,2]));return{id:Ky,diagram:e}},"loader"),mE={id:Ky,detector:pE,loader:gE},yE=mE,Qy="stateDiagram",xE=p((e,t)=>!!(/^\s*stateDiagram-v2/.test(e)||/^\s*stateDiagram/.test(e)&&t?.state?.defaultRenderer==="dagre-wrapper"),"detector"),CE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/stateDiagram-v2-MP3YSRHH.ij9DA5rL.js");return{diagram:t}},__vite__mapDeps([38,37,12,13,9,1,2]));return{id:Qy,diagram:e}},"loader"),bE={id:Qy,detector:xE,loader:CE},kE=bE,Jy="journey",wE=p(e=>/^\s*journey/.test(e),"detector"),TE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/journeyDiagram-3NMN7TZE.NTDjZdp_.js");return{diagram:t}},__vite__mapDeps([39,11,9,27,1,2]));return{id:Jy,diagram:e}},"loader"),_E={id:Jy,detector:wE,loader:TE},SE=_E,vE=p((e,t,r)=>{R.debug(`rendering svg for syntax error +`);const i=j2(t),s=i.append("g");i.attr("viewBox","0 0 2412 512"),nf(i,100,512,!0),s.append("path").attr("class","error-icon").attr("d","m411.313,123.313c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32-9.375,9.375-20.688-20.688c-12.484-12.5-32.766-12.5-45.25,0l-16,16c-1.261,1.261-2.304,2.648-3.31,4.051-21.739-8.561-45.324-13.426-70.065-13.426-105.867,0-192,86.133-192,192s86.133,192 192,192 192-86.133 192-192c0-24.741-4.864-48.327-13.426-70.065 1.402-1.007 2.79-2.049 4.051-3.31l16-16c12.5-12.492 12.5-32.758 0-45.25l-20.688-20.688 9.375-9.375 32.001-31.999zm-219.313,100.687c-52.938,0-96,43.063-96,96 0,8.836-7.164,16-16,16s-16-7.164-16-16c0-70.578 57.422-128 128-128 8.836,0 16,7.164 16,16s-7.164,16-16,16z"),s.append("path").attr("class","error-icon").attr("d","m459.02,148.98c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l16,16c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16.001-16z"),s.append("path").attr("class","error-icon").attr("d","m340.395,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16-16c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l15.999,16z"),s.append("path").attr("class","error-icon").attr("d","m400,64c8.844,0 16-7.164 16-16v-32c0-8.836-7.156-16-16-16-8.844,0-16,7.164-16,16v32c0,8.836 7.156,16 16,16z"),s.append("path").attr("class","error-icon").attr("d","m496,96.586h-32c-8.844,0-16,7.164-16,16 0,8.836 7.156,16 16,16h32c8.844,0 16-7.164 16-16 0-8.836-7.156-16-16-16z"),s.append("path").attr("class","error-icon").attr("d","m436.98,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688l32-32c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32c-6.251,6.25-6.251,16.375-0.001,22.625z"),s.append("text").attr("class","error-text").attr("x",1440).attr("y",250).attr("font-size","150px").style("text-anchor","middle").text("Syntax error in text"),s.append("text").attr("class","error-text").attr("x",1250).attr("y",400).attr("font-size","100px").style("text-anchor","middle").text(`mermaid version ${r}`)},"draw"),t0={draw:vE},BE=t0,LE={db:{},renderer:t0,parser:{parse:p(()=>{},"parse")}},FE=LE,e0="flowchart-elk",AE=p((e,t={})=>/^\s*flowchart-elk/.test(e)||/^\s*(flowchart|graph)/.test(e)&&t?.flowchart?.defaultRenderer==="elk"?(t.layout="elk",!0):!1,"detector"),EE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/flowDiagram-HODETNUW.ClPsWLK6.js").then(r=>r.f);return{diagram:t}},__vite__mapDeps([10,11,12,13,9,14]));return{id:e0,diagram:e}},"loader"),ME={id:e0,detector:AE,loader:EE},$E=ME,r0="timeline",OE=p(e=>/^\s*timeline/.test(e),"detector"),DE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/timeline-definition-24CTP7MA.XH_18yc2.js");return{diagram:t}},__vite__mapDeps([40,27,1,2]));return{id:r0,diagram:e}},"loader"),IE={id:r0,detector:OE,loader:DE},PE=IE,i0="mindmap",RE=p(e=>/^\s*mindmap/.test(e),"detector"),NE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/mindmap-definition-YA3MSWOX.Cc4iPRg4.js");return{diagram:t}},__vite__mapDeps([41,12,13,1,2]));return{id:i0,diagram:e}},"loader"),qE={id:i0,detector:RE,loader:NE},zE=qE,s0="kanban",WE=p(e=>/^\s*kanban/.test(e),"detector"),HE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/kanban-definition-UXKFOSKX.BU_et4EL.js");return{diagram:t}},__vite__mapDeps([42,11,1,2]));return{id:s0,diagram:e}},"loader"),YE={id:s0,detector:WE,loader:HE},UE=YE,o0="sankey",jE=p(e=>/^\s*sankey(-beta)?/.test(e),"detector"),GE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/sankeyDiagram-P5KCCOFB.Dat3kWim.js");return{diagram:t}},__vite__mapDeps([43,28,23,1,2]));return{id:o0,diagram:e}},"loader"),XE={id:o0,detector:jE,loader:GE},VE=XE,a0="packet",ZE=p(e=>/^\s*packet(-beta)?/.test(e),"detector"),KE=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/diagram-Z3DM3KII.CIAlmXh0.js");return{diagram:t}},__vite__mapDeps([44,19,20,1,2]));return{id:a0,diagram:e}},"loader"),QE={id:a0,detector:ZE,loader:KE},n0="radar",JE=p(e=>/^\s*radar-beta/.test(e),"detector"),tM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/diagram-UQ7AKVKN.gzh-btDB.js");return{diagram:t}},__vite__mapDeps([45,19,20,1,2]));return{id:n0,diagram:e}},"loader"),eM={id:n0,detector:JE,loader:tM},l0="block",rM=p(e=>/^\s*block(-beta)?/.test(e),"detector"),iM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/blockDiagram-I7D4REHJ.BO9kROxn.js");return{diagram:t}},__vite__mapDeps([46,11,14,1,2]));return{id:l0,diagram:e}},"loader"),sM={id:l0,detector:rM,loader:iM},oM=sM,h0="treeView",aM=p(e=>/^\s*treeView-beta/.test(e),"detector"),nM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/diagram-S7CK7UJ4.BFoB1FMC.js");return{diagram:t}},__vite__mapDeps([47,18,19,20,1,2]));return{id:h0,diagram:e}},"loader"),lM={id:h0,detector:aM,loader:nM},hM=lM,c0="architecture",cM=p(e=>/^\s*architecture/.test(e),"detector"),uM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/architectureDiagram-5GKGNRK7.BaOScXd6.js");return{diagram:t}},__vite__mapDeps([48,19,20,1,7,2]));return{id:c0,diagram:e}},"loader"),dM={id:c0,detector:cM,loader:uM},fM=dM,u0="eventmodeling",pM=p(e=>/^\s*eventmodeling/.test(e),"detector"),gM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/diagram-VSXAHHWV.BOdI9TU8.js");return{diagram:t}},__vite__mapDeps([49,19,20,1,2]));return{id:u0,diagram:e}},"loader"),mM={id:u0,detector:pM,loader:gM},yM=mM,d0="ishikawa",xM=p(e=>/^\s*ishikawa(-beta)?\b/i.test(e),"detector"),CM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/ishikawaDiagram-5VMMS53U.dqUjFnmd.js");return{diagram:t}},__vite__mapDeps([50,1,2]));return{id:d0,diagram:e}},"loader"),bM={id:d0,detector:xM,loader:CM},f0="venn",kM=p(e=>/^\s*venn-beta/.test(e),"detector"),wM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/vennDiagram-4TSXK5OY.REB-xxGl.js");return{diagram:t}},__vite__mapDeps([51,1,2]));return{id:f0,diagram:e}},"loader"),TM={id:f0,detector:kM,loader:wM},_M=TM,p0="treemap",SM=p(e=>/^\s*treemap/.test(e),"detector"),vM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/diagram-VX7I27RA.CLNxhO1L.js");return{diagram:t}},__vite__mapDeps([52,19,13,20,1,24,28,23,2]));return{id:p0,diagram:e}},"loader"),BM={id:p0,detector:SM,loader:vM},g0="wardley",LM=p(e=>/^\s*wardley-beta/i.test(e),"detector"),FM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/wardleyDiagram-VM6X3IG4.DCCyph2y.js");return{diagram:t}},__vite__mapDeps([53,19,20,1,2]));return{id:g0,diagram:e}},"loader"),AM={id:g0,detector:LM,loader:FM},EM=AM,m0="cynefin",MM=p(e=>/^\s*cynefin-beta(?:[\s:]|$)/.test(e),"detector"),$M=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/cynefinDiagram-5FMLGOSQ.Ebp3fBAZ.js");return{diagram:t}},__vite__mapDeps([54,19,20,1,2]));return{id:m0,diagram:e}},"loader"),OM={id:m0,detector:MM,loader:$M},y0="railroad",DM=p(e=>/^\s*railroad-beta/i.test(e),"detector"),IM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/railroadDiagram-O6MQD6OU.CLUHLRPG.js");return{diagram:t}},__vite__mapDeps([55,56,19,20,1,2]));return{id:y0,diagram:e}},"loader"),PM={id:y0,detector:DM,loader:IM},x0="railroadEbnf",RM=p(e=>/^\s*railroad-ebnf-beta/i.test(e),"detector"),NM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/ebnfDiagram-PWID7BFC.Dni2gpVx.js");return{diagram:t}},__vite__mapDeps([57,56,19,20,1,2]));return{id:x0,diagram:e}},"loader"),qM={id:x0,detector:RM,loader:NM},C0="railroadAbnf",zM=p(e=>/^\s*railroad-abnf-beta/i.test(e),"detector"),WM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/abnfDiagram-VCTEODGH.C-XKIPnK.js");return{diagram:t}},__vite__mapDeps([58,56,19,20,1,2]));return{id:C0,diagram:e}},"loader"),HM={id:C0,detector:zM,loader:WM},b0="railroadPeg",YM=p(e=>/^\s*railroad-peg-beta/i.test(e),"detector"),UM=p(async()=>{const{diagram:e}=await Et(async()=>{const{diagram:t}=await import("./chunks/pegDiagram-XKGWAZYB.kTxCBLbr.js");return{diagram:t}},__vite__mapDeps([59,56,19,20,1,2]));return{id:b0,diagram:e}},"loader"),jM={id:b0,detector:YM,loader:UM},Md=!1,ya=p(()=>{Md||(Md=!0,To("error",FE,e=>e.toLowerCase().trim()==="error"),To("---",{db:{clear:p(()=>{},"clear")},styles:{},renderer:{draw:p(()=>{},"draw")},parser:{parse:p(()=>{throw new Error("Diagrams beginning with --- are not valid. If you were trying to use a YAML front-matter, please ensure that you've correctly opened and closed the YAML front-matter with un-indented `---` blocks")},"parse")},init:p(()=>null,"init")},e=>e.toLowerCase().trimStart().startsWith("---")),vn($E,zE,fM),vn(fA,UE,fE,hE,FA,PA,qA,HA,eE,oE,SA,kA,yA,PE,$A,kE,yE,SE,GA,VE,QE,KA,oM,yM,hM,eM,bM,BM,PM,qM,HM,jM,_M,EM,OM))},"addDiagrams"),GM=p(async()=>{R.debug("Loading registered diagrams");const t=(await Promise.allSettled(Object.entries(si).map(async([r,{detector:i,loader:s}])=>{if(s)try{An(r)}catch{try{const{diagram:o,id:a}=await s();To(a,o,i)}catch(o){throw R.error(`Failed to load external diagram with key ${r}. Removing from detectors.`),delete si[r],o}}}))).filter(r=>r.status==="rejected");if(t.length>0){R.error(`Failed to load ${t.length} external diagrams`);for(const r of t)R.error(r);throw new Error(`Failed to load ${t.length} external diagrams`)}},"loadRegisteredDiagrams"),XM="graphics-document document";function k0(e,t){e.attr("role",XM),t!==""&&e.attr("aria-roledescription",t)}p(k0,"setA11yDiagramInfo");function w0(e,t,r,i){if(e.insert!==void 0){if(r){const s=`chart-desc-${i}`;e.attr("aria-describedby",s),e.insert("desc",":first-child").attr("id",s).text(r)}if(t){const s=`chart-title-${i}`;e.attr("aria-labelledby",s),e.insert("title",":first-child").attr("id",s).text(t)}}}p(w0,"addSVGa11yTitleDescription");var ul=class T0{constructor(t,r,i,s,o){this.type=t,this.text=r,this.db=i,this.parser=s,this.renderer=o}static{p(this,"Diagram")}static async fromText(t,r={}){const i=Zt(),s=gl(t,i);t=mT(t)+` +`;try{An(s)}catch{const c=qC(s);if(!c)throw new tf(`Diagram ${s} not found.`);const{id:h,diagram:u}=await c();To(h,u)}const{db:o,parser:a,renderer:n,init:l}=An(s);return a.parser&&(a.parser.yy=o),o.clear?.(),l?.(i),r.title&&o.setDiagramTitle?.(r.title),await a.parse(t),new T0(s,t,o,a,n)}async render(t,r){await this.renderer.draw(this.text,t,r,this)}getParser(){return this.parser}getType(){return this.type}},$d=[],VM=p(()=>{$d.forEach(e=>{e()}),$d=[]},"attachFunctions"),ZM=p(e=>e.replace(/^\s*%%(?!{)[^\n]+\n?/gm,"").trimStart(),"cleanupComments");function _0(e){const t=e.match(Jd);if(!t)return{text:e,metadata:{}};const r=t[1],i=r?t[2].split(` +`).map(a=>a.startsWith(r)?a.slice(r.length):a).join(` +`):t[2];let s=HF(i,{schema:WF})??{};s=typeof s=="object"&&!Array.isArray(s)?s:{};const o={};return s.displayMode&&(o.displayMode=s.displayMode.toString()),s.title&&(o.title=s.title.toString()),s.config&&(o.config=s.config),{text:e.slice(t[0].length),metadata:o}}p(_0,"extractFrontMatter");var KM=p(e=>e.replace(/\r\n?/g,` +`).replace(/<(\w+)([^>]*)>/g,(t,r,i)=>"<"+r+i.replace(/="([^"]*)"/g,"='$1'")+">"),"cleanupText"),QM=p(e=>{const{text:t,metadata:r}=_0(e),{displayMode:i,title:s,config:o={}}=r;return i&&(o.gantt||(o.gantt={}),o.gantt.displayMode=i),{title:s,config:o,text:t}},"processFrontmatter"),JM=p(e=>{const t=Ce.detectInit(e)??{},r=Ce.detectDirective(e,"wrap");return Array.isArray(r)?t.wrap=r.some(({type:i})=>i==="wrap"):r?.type==="wrap"&&(t.wrap=!0),{text:iT(e),directive:t}},"processDirectives");function Ih(e){const t=KM(e),r=QM(t),i=JM(r.text),s=Wl(r.config,i.directive);return e=ZM(i.text),{code:e,title:r.title,config:s}}p(Ih,"preprocessDiagram");function S0(e){const t=new TextEncoder().encode(e),r=Array.from(t,i=>String.fromCodePoint(i)).join("");return btoa(r)}p(S0,"toBase64");var t5=5e4,e5="graph TB;a[Maximum text size in diagram exceeded];style a fill:#faa",r5="sandbox",i5="loose",s5="http://www.w3.org/2000/svg",o5="http://www.w3.org/1999/xlink",a5="http://www.w3.org/1999/xhtml",n5="100%",l5="100%",h5="border:0;margin:0;",c5="margin:0",u5="allow-top-navigation-by-user-activation allow-popups",d5='The "iframe" tag is not supported by your browser.',f5=["foreignobject"],p5=["dominant-baseline"];function Ph(e){const t=Ih(e);return ko(),IC(t.config??{}),t}p(Ph,"processAndSetConfigs");async function v0(e,t){ya();try{const{code:r,config:i}=Ph(e);return{diagramType:(await L0(r)).type,config:i}}catch(r){if(t?.suppressErrors)return!1;throw r}}p(v0,"parse");var Od=p((e,t,r=[])=>{const i=Xd(`{ ${r.join(" !important; ")} !important; }`);return`.${e} ${t} ${i}`},"cssImportantStyles"),g5=p((e,t=new Map)=>{const r=new CSSStyleSheet;if(e.fontFamily!==void 0&&r.insertRule(`:root { --mermaid-font-family: ${e.fontFamily}}`,r.cssRules.length),e.altFontFamily!==void 0&&r.insertRule(`:root { --mermaid-alt-font-family: ${e.altFontFamily}}`,r.cssRules.length),t instanceof Map){const n=be(e)?["> *","span"]:["rect","polygon","ellipse","circle","path"];t.forEach(l=>{jc(l.styles)||n.forEach(c=>{r.insertRule(Od(l.id,c,l.styles),r.cssRules.length)}),jc(l.textStyles)||r.insertRule(Od(l.id,"tspan",(l?.textStyles||[]).map(c=>c.replace("color","fill"))),r.cssRules.length)})}let i="";if(e.themeCSS!==void 0)if(typeof r.replaceSync=="function"){const s=new CSSStyleSheet;s.replaceSync(e.themeCSS),i=Fn(s)+` +`}else i+=`${e.themeCSS} +`;return i+Fn(r)},"createCssStyles"),m5=p((e,t)=>cl(aA(`${e}{${t}}`),hA([p(function(i,s,o,a){if(i.type==="rule"&&Array.isArray(i.props)){if(i.parent&&i.parent.type===nl)return;i.props=i.props.map(n=>n===e&&Array.isArray(i.children)&&i.children.every(c=>c.type!=="decl"?!1:new Set(["font-family","font-size","fill"]).has(c.props))||(n.startsWith(`${e} `)||n.startsWith(`${e}>`))&&!n.startsWith(`${e} ||`)?n:`${e} ${n}`)}else i.type.startsWith("@")&&([...[jF,XF,My,ZF,"@container","@starting-style"],nl].includes(i.type)||(R.warn(`Removing unsupported at-rule ${i.type} from CSS`),i.type=Oh))},"addNamespace"),lA])),"compileCSS"),y5=p((e,t,r,i)=>{const s=g5(e,r),o=sb(t,s,{...e.themeVariables,theme:e.theme,look:e.look},i);return m5(i,o)},"createUserStyles"),x5=p((e="",t,r)=>{let i=e;return!r&&!t&&(i=i.replace(/marker-end="url\([\d+./:=?A-Za-z-]*?#/g,'marker-end="url(#')),i=Wr(i),i=i.replace(/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "),i},"cleanUpSvgCode"),C5=p((e="",t)=>{const r=t?.viewBox?.baseVal?.height?t.viewBox.baseVal.height+"px":l5,i=S0(`${e}`);return``},"putIntoIFrame"),Dd=p((e,t,r,i,s)=>{const o=e.append("div");o.attr("id",r),i&&o.attr("style",i);const a=o.append("svg").attr("id",t).attr("width","100%").attr("xmlns",s5);return s&&a.attr("xmlns:xlink",s),a.append("g"),e},"appendDivSvgG");function dl(e,t){return e.append("iframe").attr("id",t).attr("style","width: 100%; height: 100%;").attr("sandbox","")}p(dl,"sandboxedIframe");var b5=p((e,t,r,i)=>{e.getElementById(t)?.remove(),e.getElementById(r)?.remove(),e.getElementById(i)?.remove()},"removeExistingElements"),k5=p(async function(e,t,r){ya();const i=Ph(t);t=i.code;const s=Zt();R.debug(s),t.length>(s?.maxTextSize??t5)&&(t=e5);const o=`#${e}`,a="i"+e,n="#"+a,l="d"+e,c="#"+l,h=p(()=>{const $=At(d?n:c).node();$&&"remove"in $&&$.remove()},"removeTempElements");let u=At(document.body);const d=s.securityLevel===r5,f=s.securityLevel===i5,m=s.fontFamily;if(r!==void 0){if(r&&(r.innerHTML=""),d){const Y=dl(At(r),a);u=At(Y.nodes()[0].contentDocument.body),u.node().style.margin="0"}else u=At(r);Dd(u,e,l,`font-family: ${m}`,o5)}else{if(b5(document,e,l,a),d){const Y=dl(At(document.body),a);u=At(Y.nodes()[0].contentDocument.body),u.node().style.margin="0"}else u=At("body");Dd(u,e,l)}let y,x;try{y=await ul.fromText(t,{title:i.title})}catch(Y){if(s.suppressErrorRendering)throw h(),Y;y=await ul.fromText("error"),x=Y}const C=u.select(c).node(),k=y.type,T=C.firstChild,S=T.firstChild,v=y.renderer.getClasses?.(t,y),A=y5(s,k,v,o),L=document.createElement("style");L.innerHTML=A,T.insertBefore(L,S);try{await y.renderer.draw(t,e,"11.17.2",y)}catch(Y){throw s.suppressErrorRendering?h():BE.draw(t,e,"11.17.2"),Y}const F=u.select(`${c} svg`),Z=y.db.getAccTitle?.(),U=y.db.getAccDescription?.();F0(k,F,Z,U);const st=p(()=>{u.select(`[id="${e}"]`).selectAll("foreignobject > *").attr("xmlns",a5);let Y=u.select(c).node().innerHTML;if(R.debug("config.arrowMarkerAbsolute",s.arrowMarkerAbsolute),Y=x5(Y,d,ur(s.arrowMarkerAbsolute)),d){const $=u.select(c+" svg").node();Y=C5(Y,$)}else f||(Y=$i.sanitize(Y,{ADD_TAGS:f5,ADD_ATTR:p5,HTML_INTEGRATION_POINTS:{foreignobject:!0}}));return VM(),Y},"serializeSvg")();if(x)throw x;return h(),{diagramType:k,svg:st,bindFunctions:y.db.bindFunctions}},"render");function B0(e={}){const t=ne({},e);t?.fontFamily&&!t.themeVariables?.fontFamily&&(t.themeVariables||(t.themeVariables={}),t.themeVariables.fontFamily=t.fontFamily),OC(t),t?.theme&&t.theme in Tr?t.themeVariables=Tr[t.theme].getThemeVariables(t.themeVariables):t&&(t.themeVariables=Tr.default.getThemeVariables(t.themeVariables));const r=typeof t=="object"?$C(t):Vd();pl(r.logLevel),ya()}p(B0,"initialize");var L0=p((e,t={})=>{const{code:r}=Ih(e);return ul.fromText(r,t)},"getDiagramFromText");function F0(e,t,r,i){k0(t,e),w0(t,r,i,t.attr("id"))}p(F0,"addA11yInfo");var ci=Object.freeze({render:k5,parse:v0,getDiagramFromText:L0,initialize:B0,getConfig:Zt,setConfig:Zd,getSiteConfig:Vd,updateSiteConfig:DC,reset:p(()=>{ko()},"reset"),globalReset:p(()=>{ko(Oi)},"globalReset"),defaultConfig:Oi});pl(Zt().logLevel);ko(Zt());var w5=p((e,t,r)=>{R.warn(e),zl(e)?(r&&r(e.str,e.hash),t.push({...e,message:e.str,error:e})):(r&&r(e),e instanceof Error&&t.push({str:e.message,message:e.message,hash:e.name,error:e}))},"handleError"),A0=p(async function(e={querySelector:".mermaid"}){try{await T5(e)}catch(t){if(zl(t)&&R.error(t.str),Br.parseError&&Br.parseError(t),!e.suppressErrors)throw R.error("Use the suppressErrors option to suppress these errors"),t}},"run"),T5=p(async function({postRenderCallback:e,querySelector:t,nodes:r}={querySelector:".mermaid"}){const i=ci.getConfig();R.debug(`${e?"":"No "}Callback function found`);let s;if(r)s=r;else if(t)s=document.querySelectorAll(t);else throw new Error("Nodes and querySelector are both undefined");R.debug(`Found ${s.length} diagrams`),i?.startOnLoad!==void 0&&(R.debug("Start On Load: "+i?.startOnLoad),ci.updateSiteConfig({startOnLoad:i?.startOnLoad}));const o=new Ce.InitIDGenerator(i.deterministicIds,i.deterministicIDSeed);let a;const n=[];for(const l of Array.from(s)){if(R.info("Rendering diagram: "+l.id),l.getAttribute("data-processed"))continue;l.setAttribute("data-processed","true");const c=`mermaid-${o.next()}`;a=l.innerHTML,a=Pp(Ce.entityDecode(a)).trim().replace(//gi,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ");const h=Ce.detectInit(a);h&&R.debug("Detected early reinit: ",h);try{const{svg:u,bindFunctions:d}=await O0(c,a,l);l.innerHTML=u,e&&await e(c),d&&d(l)}catch(u){w5(u,n,Br.parseError)}}if(n.length>0)throw n[0]},"runThrowsErrors"),E0=p(function(e){ci.initialize(e)},"initialize"),_5=p(async function(e,t,r){R.warn("mermaid.init is deprecated. Please use run instead."),e&&E0(e);const i={postRenderCallback:r,querySelector:".mermaid"};typeof t=="string"?i.querySelector=t:t&&(t instanceof HTMLElement?i.nodes=[t]:i.nodes=t),await A0(i)},"init"),S5=p(async(e,{lazyLoad:t=!0}={})=>{ya(),vn(...e),t===!1&&await GM()},"registerExternalDiagrams"),M0=p(function(){if(Br.startOnLoad){const{startOnLoad:e}=ci.getConfig();e&&Br.run().catch(t=>R.error("Mermaid failed to initialize",t))}},"contentLoaded");typeof document<"u"&&window.addEventListener("load",M0,!1);var v5=p(function(e){Br.parseError=e},"setParseErrorHandler"),Uo=[],bn=!1,$0=p(async()=>{if(!bn){for(bn=!0;Uo.length>0;){const e=Uo.shift();if(e)try{await e()}catch(t){R.error("Error executing queue",t)}}bn=!1}},"executeQueue"),B5=p(async(e,t)=>new Promise((r,i)=>{const s=p(()=>new Promise((o,a)=>{ci.parse(e,t).then(n=>{o(n),r(n)},n=>{R.error("Error parsing",n),Br.parseError?.(n),a(n),i(n)})}),"performCall");Uo.push(s),$0().catch(i)}),"parse"),O0=p((e,t,r)=>new Promise((i,s)=>{const o=p(()=>new Promise((a,n)=>{ci.render(e,t,r).then(l=>{a(l),i(l)},l=>{R.error("Error parsing",l),Br.parseError?.(l),n(l),s(l)})}),"performCall");Uo.push(o),$0().catch(s)}),"render"),L5=p(()=>Object.keys(si).map(e=>({id:e})),"getRegisteredDiagramsMetadata"),Br={startOnLoad:!0,mermaidAPI:ci,parse:B5,render:O0,init:_5,run:A0,registerExternalDiagrams:S5,registerLayoutLoaders:Fy,initialize:E0,parseError:void 0,contentLoaded:M0,setParseErrorHandler:v5,detectType:gl,registerIconPacks:yw,getRegisteredDiagramsMetadata:L5},jo=Br;/*! Check if previously processed *//*! + * Wait for document loaded before starting the execution + */const F5=async e=>{try{jo.registerExternalDiagrams&&await jo.registerExternalDiagrams(e)}catch(t){console.error(t)}},A5=async(e,t,r)=>{jo.initialize(r);const{svg:i}=await jo.render(e,t);return i},E5=["innerHTML"],M5={__name:"Mermaid",props:{graph:{type:String,required:!0},id:{type:String,required:!0},class:{type:String,required:!1,default:"mermaid"}},setup(e){const t=Zh({securityLevel:"loose",startOnLoad:!1,externalDiagrams:[]}),{page:r}=Id(),{frontmatter:i}=Q0(r.value),s=i.mermaidTheme||"",o=e,a=Zh(null);let n=null;Pd(async()=>{await F5(t.value.externalDiagrams);let c=await Et(()=>import("./chunks/virtual_mermaid-config.DDnGl6nM.js"),[]);c?.default&&(t.value=c.default),n=new MutationObserver(async()=>await l()),n.observe(document.documentElement,{attributes:!0}),await l(),//.exec(decodeURIComponent(o.graph))?.length>0&&setTimeout(()=>{let u=document.getElementsByTagName("img"),d=Array.from(u);d.length&&Promise.all(d.filter(f=>!f.complete).map(f=>new Promise(m=>{f.onload=f.onerror=m}))).then(async()=>{await l()})},100)}),J0(()=>n.disconnect());const l=async()=>{const c=document.documentElement.classList.contains("dark");let h={...t.value};s&&(h.theme=s),c&&(h.theme="dark");let u=await A5(o.id,decodeURIComponent(o.graph),h);const d=Math.random().toString(36).substring(7);a.value=`${u} ${d}`};return(c,h)=>(rx(),tx("div",{innerHTML:a.value,class:ex(o.class)},null,10,E5))}};function D0(e){if(e.extends){const t=D0(e.extends);return{...t,...e,async enhanceApp(r){t.enhanceApp&&await t.enhanceApp(r),e.enhanceApp&&await e.enhanceApp(r)}}}return e}const Mi=D0(Cx),$5=fx({name:"VitePressApp",setup(){const{site:e,lang:t,dir:r}=Id();return Pd(()=>{px(()=>{document.documentElement.lang=t.value,document.documentElement.dir=r.value})}),e.value.router.prefetchLinks&&gx(),mx(),yx(),Mi.setup&&Mi.setup(),()=>xx(Mi.Layout)}});async function O5(){globalThis.__VITEPRESS__=!0;const e=I5(),t=D5();t.provide(sx,e);const r=ox(e.route);return t.provide(ax,r),t.component("Mermaid",M5),t.component("Content",nx),t.component("ClientOnly",lx),Object.defineProperties(t.config.globalProperties,{$frontmatter:{get(){return r.frontmatter.value}},$params:{get(){return r.page.value.params}}}),Mi.enhanceApp&&await Mi.enhanceApp({app:t,router:e,siteData:hx}),{app:t,router:e,data:r}}function D5(){return dx($5)}function I5(){let e=kn;return cx(t=>{let r=ux(t),i=null;return r&&(e&&(r=r.replace(/\.js$/,".lean.js")),i=import(r)),kn&&(e=!1),i},Mi.NotFound)}kn&&O5().then(({app:e,router:t,data:r})=>{t.go().then(()=>{ix(t.route,r.site),e.mount("#app")})});export{WF as $,Zt as A,fb as B,nr as C,Wl as D,Gd as E,lT as F,j2 as G,$2 as H,Oc as I,$c as J,J5 as K,X5 as L,K5 as M,Z5 as N,j5 as O,Ll as P,Q5 as Q,G5 as R,Ci as S,e3 as T,Lt as U,t3 as V,V5 as W,fC as X,H5 as Y,HF as Z,p as _,nb as a,fp as a$,Ts as a0,W5 as a1,Jo as a2,Jw as a3,GC as a4,af as a5,$i as a6,pc as a7,fa as a8,P2 as a9,yS as aA,xe as aB,l_ as aC,Dl as aD,$l as aE,fo as aF,Pw as aG,Iw as aH,Dw as aI,Ow as aJ,vw as aK,cp as aL,Fw as aM,Sw as aN,Mw as aO,up as aP,Lw as aQ,qw as aR,Nw as aS,Rw as aT,Ww as aU,zw as aV,Bw as aW,dp as aX,$w as aY,Ew as aZ,Aw as a_,qn as aa,nT as ab,Ze as ac,z as ad,W as ae,eb as af,lf as ag,Em as ah,ah as ai,Su as aj,Ns as ak,yw as al,ql as am,ct as an,c3 as ao,h3 as ap,NF as aq,Rt as ar,sy as as,dt as at,l3 as au,Yo as av,ay as aw,oa as ax,nh as ay,Om as az,ab as b,aF as b$,Pm as b0,bp as b1,zd as b2,O2 as b3,z5 as b4,wn as b5,fl as b6,Qe as b7,mw as b8,Y5 as b9,Dv as bA,wB as bB,li as bC,Wi as bD,Lr as bE,Vu as bF,lr as bG,wr as bH,yB as bI,Nu as bJ,Ho as bK,_r as bL,Bv as bM,De as bN,Hu as bO,uh as bP,xF as bQ,ha as bR,Wo as bS,gF as bT,iy as bU,sr as bV,Lv as bW,mh as bX,qm as bY,CF as bZ,mF as b_,_l as ba,Ir as bb,vs as bc,Bc as bd,fk as be,ft as bf,sp as bg,Oe as bh,ak as bi,Tl as bj,wf as bk,Rs as bl,Sf as bm,U5 as bn,wx as bo,lh as bp,hh as bq,Ou as br,Hm as bs,la as bt,Wm as bu,Iv as bv,Ym as bw,kB as bx,nL as by,vv as bz,It as c,na as c0,Vm as c1,da as c2,Zm as c3,nF as c4,sL as c5,Vr as c6,ps as c7,vi as c8,so as c9,Xa as ca,BF as cb,eS as cc,O5 as createApp,nf as d,ne as e,vr as f,hb as g,Lm as h,ze as i,At as j,Is as k,R as l,wp as m,Ds as n,Cw as o,cb as p,ub as q,ob as r,lb as s,r3 as t,qr as u,bx as v,uT as w,_3 as x,T3 as y,Ce as z}; diff --git a/packages/tempo/public/v4/assets/chunks/@localSearchIndexroot._Rh608I2.js b/packages/tempo/public/v4/assets/chunks/@localSearchIndexroot._Rh608I2.js new file mode 100644 index 00000000..6417f7b8 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/@localSearchIndexroot._Rh608I2.js @@ -0,0 +1 @@ +const e='{"documentCount":1460,"nextId":1460,"documentIds":{"0":"/magma/v4/CONTRIBUTING.html#contributing-to-tempo","1":"/magma/v4/CONTRIBUTING.html#🏗️-project-architecture","2":"/magma/v4/CONTRIBUTING.html#🛠️-local-development","3":"/magma/v4/CONTRIBUTING.html#prerequisites","4":"/magma/v4/CONTRIBUTING.html#setup","5":"/magma/v4/CONTRIBUTING.html#building","6":"/magma/v4/CONTRIBUTING.html#🧪-testing","7":"/magma/v4/CONTRIBUTING.html#📜-coding-standards","8":"/magma/v4/CONTRIBUTING.html#🚀-pull-request-process","9":"/magma/v4/README.html#⚡-quick-start","10":"/magma/v4/README.html#📦-installation","11":"/magma/v4/README.html#⏳-why-tempo","12":"/magma/v4/README.html#the-missing-domain-layer","13":"/magma/v4/README.html#📚-documentation","14":"/magma/v4/README.html#🧰-the-tempo-ecosystem","15":"/magma/v4/README.html#💬-contact-support","16":"/magma/v4/README.html#🗳️-feedback-reactions","17":"/magma/v4/README.html#⚖️-license","18":"/magma/v4/SECURITY.html#security-policy","19":"/magma/v4/SECURITY.html#supported-versions","20":"/magma/v4/SECURITY.html#reporting-a-vulnerability","21":"/magma/v4/SECURITY.html#how-to-report","22":"/magma/v4/SECURITY.html#what-to-include","23":"/magma/v4/SECURITY.html#response-timeline","24":"/magma/v4/doc/1-getting-started/ai-integration.html#🤖-ai-ide-integration-llms-txt","25":"/magma/v4/doc/1-getting-started/ai-integration.html#🚀-quick-setup-by-ide-tool","26":"/magma/v4/doc/1-getting-started/ai-integration.html#_1-cursor-ide","27":"/magma/v4/doc/1-getting-started/ai-integration.html#_2-vs-code-github-copilot","28":"/magma/v4/doc/1-getting-started/ai-integration.html#_3-antigravity-ai-assistant","29":"/magma/v4/doc/1-getting-started/ai-integration.html#_4-chatgpt-claude-projects","30":"/magma/v4/doc/1-getting-started/ai-integration.html#🛠️-prompting-ai-for-custom-layout-extensions","31":"/magma/v4/doc/1-getting-started/ai-integration.html#sample-prompt","32":"/magma/v4/doc/1-getting-started/ai-integration.html#generated-code-actual-tempo-syntax","33":"/magma/v4/doc/1-getting-started/installation.html#installation-guide","34":"/magma/v4/doc/1-getting-started/installation.html#temporal-polyfill-note","35":"/magma/v4/doc/1-getting-started/installation.html#💻-server-bundlers-node-js-bun-vite","36":"/magma/v4/doc/1-getting-started/installation.html#usage","37":"/magma/v4/doc/1-getting-started/installation.html#node-js-with-native-temporal","38":"/magma/v4/doc/1-getting-started/installation.html#node-js-with-polyfill","39":"/magma/v4/doc/1-getting-started/installation.html#🦕-deno","40":"/magma/v4/doc/1-getting-started/installation.html#usage-1","41":"/magma/v4/doc/1-getting-started/installation.html#🌐-browser-native-environments","42":"/magma/v4/doc/1-getting-started/installation.html#_1-the-global-bundle-standard-usage","43":"/magma/v4/doc/1-getting-started/installation.html#_2-smart-cdns-the-best-of-both-worlds","44":"/magma/v4/doc/1-getting-started/installation.html#_3-static-cdns-production-ready","45":"/magma/v4/doc/1-getting-started/installation.html#📦-browser-global-variable-plugins","46":"/magma/v4/doc/1-getting-started/installation.html#🧪-granular-lite-builds-advanced","47":"/magma/v4/doc/1-getting-started/installation.html#🛡️-versioning-policy","48":"/magma/v4/doc/1-getting-started/installation.html#🤖-ai-ide-integration-llms-txt","49":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#tempo-cookbook","50":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#table-of-contents","51":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#the-basics","52":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#how-do-i-get-the-current-date-and-time","53":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#get-now-in-utc","54":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#how-do-i-format-a-date-for-my-ui","55":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#how-do-i-check-if-a-date-is-valid","56":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#global-configuration","57":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#parsing-challenges","58":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#parsing-ambiguous-digits-us-vs-uk","59":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#handling-relative-strings","60":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#parsing-unix-timestamps","61":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#manipulation-and-calculations","62":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#add-or-subtract-time","63":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#jumping-to-boundaries-start-mid-end","64":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#slick-object-mutations","65":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#how-long-until-a-deadline-until","66":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#relative-time-since","67":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#timezones-and-locales","68":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#convert-time-to-another-zone","69":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#dynamic-multi-tenant-context-functional-options","70":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#business-logic-and-terms","71":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#is-it-the-weekend","72":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#what-fiscal-quarter-are-we-in","73":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#hemispheric-seasons","74":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#formatting-and-localization","75":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#semantic-formatting","76":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#format-modifiers-localization","77":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#ticker-plugin","78":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#format-parse-dialects-plugin-moment-luxon-sql-posix-php","79":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#interoperability","80":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#converting-to-from-native-date","81":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#converting-to-temporal-objects","82":"/magma/v4/doc/1-getting-started/tempo.cookbook.html#sorting-an-array-of-tempos","83":"/magma/v4/doc/1-getting-started/tempo.repl.html#interactive-repl-feature-showcase","84":"/magma/v4/doc/1-getting-started/tempo.repl.html#interactive-feature-showcase","85":"/magma/v4/doc/1-getting-started/tempo.repl.html#freeform-code-repl","86":"/magma/v4/doc/1-getting-started/tempo.repl.html#key-capabilities","87":"/magma/v4/doc/1-getting-started/tempo.repl.html#_1-preloaded-official-plugins","88":"/magma/v4/doc/1-getting-started/tempo.repl.html#_2-dynamic-plugin-loading-presets","89":"/magma/v4/doc/1-getting-started/tempo.repl.html#_3-ai-semantic-parsing-natural-language-scheduling","90":"/magma/v4/doc/1-getting-started/tempo.repl.html#_4-shareable-snippets-presets","91":"/magma/v4/doc/1-getting-started/tempo.repl.html#_5-keyboard-shortcuts","92":"/magma/v4/doc/2-core-concepts/tempo.cache.html#cache-management-guide","93":"/magma/v4/doc/2-core-concepts/tempo.cache.html#🏛️-centralized-cache-architecture","94":"/magma/v4/doc/2-core-concepts/tempo.cache.html#cache-topology-configuration","95":"/magma/v4/doc/2-core-concepts/tempo.cache.html#📖-seeding-appending-glossaries","96":"/magma/v4/doc/2-core-concepts/tempo.cache.html#💡-when-to-use-what-glossary-vs-alias-vs-snippet-layout","97":"/magma/v4/doc/2-core-concepts/tempo.cache.html#decision-tree","98":"/magma/v4/doc/2-core-concepts/tempo.cache.html#🤖-ai-plugin-cache-integration-magmacomputing-tempo-plugin-ai","99":"/magma/v4/doc/2-core-concepts/tempo.cache.html#two-tier-resolution-architecture","100":"/magma/v4/doc/2-core-concepts/tempo.config.html#configuration-guide","101":"/magma/v4/doc/2-core-concepts/tempo.config.html#precedence-hierarchy","102":"/magma/v4/doc/2-core-concepts/tempo.config.html#🏆-best-practice-the-tempo-config-ts-pattern","103":"/magma/v4/doc/2-core-concepts/tempo.config.html#server-node-js-entry-point-zero-config-discovery","104":"/magma/v4/doc/2-core-concepts/tempo.config.html#bundled-frontend-entry-point-vite-webpack","105":"/magma/v4/doc/2-core-concepts/tempo.config.html#cascading-configurations-extends","106":"/magma/v4/doc/2-core-concepts/tempo.config.html#benefits-vs-drawbacks","107":"/magma/v4/doc/2-core-concepts/tempo.config.html#🌟-benefits","108":"/magma/v4/doc/2-core-concepts/tempo.config.html#⚠️-drawbacks","109":"/magma/v4/doc/2-core-concepts/tempo.config.html#🛑-security-reliability-bounds","110":"/magma/v4/doc/2-core-concepts/tempo.config.html#_1-persistent-configuration-tempo","111":"/magma/v4/doc/2-core-concepts/tempo.config.html#_2-global-discovery","112":"/magma/v4/doc/2-core-concepts/tempo.config.html#pre-bootstrap-discovery-globalthis","113":"/magma/v4/doc/2-core-concepts/tempo.config.html#explicit-runtime-registration-not-global-discovery","114":"/magma/v4/doc/2-core-concepts/tempo.config.html#security-and-ergonomics-notes","115":"/magma/v4/doc/2-core-concepts/tempo.config.html#discovery-contract","116":"/magma/v4/doc/2-core-concepts/tempo.config.html#_3-explicit-initialization-tempo-init","117":"/magma/v4/doc/2-core-concepts/tempo.config.html#available-options","118":"/magma/v4/doc/2-core-concepts/tempo.config.html#_4-instance-level-overrides","119":"/magma/v4/doc/2-core-concepts/tempo.config.html#_4-1-dynamic-functional-context-evaluation","120":"/magma/v4/doc/2-core-concepts/tempo.config.html#determinism-and-immutability-guarantees","121":"/magma/v4/doc/2-core-concepts/tempo.config.html#_4-2-geographic-coordinates-location-configuration-geo","122":"/magma/v4/doc/2-core-concepts/tempo.config.html#_5-advanced-parsing-rules","123":"/magma/v4/doc/2-core-concepts/tempo.config.html#📅-5-1-custom-events-and-periods","124":"/magma/v4/doc/2-core-concepts/tempo.config.html#⚡-5-2-deferring-initialization-mode-defer","125":"/magma/v4/doc/2-core-concepts/tempo.config.html#🧹-5-3-noise-word-filtering-ignore","126":"/magma/v4/doc/2-core-concepts/tempo.config.html#🚀-5-4-parse-planner-pre-filtering","127":"/magma/v4/doc/2-core-concepts/tempo.config.html#planner-prefilter-boolean","128":"/magma/v4/doc/2-core-concepts/tempo.config.html#planner-layoutorder-array","129":"/magma/v4/doc/2-core-concepts/tempo.config.html#📊-summary-of-tiers","130":"/magma/v4/doc/2-core-concepts/tempo.format.html#smart-formatting-guide","131":"/magma/v4/doc/2-core-concepts/tempo.format.html#🚀-standalone-formatting-zero-overhead","132":"/magma/v4/doc/2-core-concepts/tempo.format.html#supported-input-types","133":"/magma/v4/doc/2-core-concepts/tempo.format.html#🏗️-class-based-formatting","134":"/magma/v4/doc/2-core-concepts/tempo.format.html#named-formats","135":"/magma/v4/doc/2-core-concepts/tempo.format.html#🧩-modularity-core-vs-full","136":"/magma/v4/doc/2-core-concepts/tempo.format.html#enabling-formatting-in-core","137":"/magma/v4/doc/2-core-concepts/tempo.format.html#🔠-supported-tokens","138":"/magma/v4/doc/2-core-concepts/tempo.format.html#🎛️-token-modifiers","139":"/magma/v4/doc/2-core-concepts/tempo.format.html#🔄-automatic-meridiem","140":"/magma/v4/doc/2-core-concepts/tempo.format.html#📝-common-formatting-examples","141":"/magma/v4/doc/2-core-concepts/tempo.format.html#📍-dynamic-namespace-spatial-tokens-namespace-key","142":"/magma/v4/doc/2-core-concepts/tempo.format.html#geographic-tokens-geo","143":"/magma/v4/doc/2-core-concepts/tempo.format.html#custom-plugin-namespace-tokens","144":"/magma/v4/doc/2-core-concepts/tempo.format.html#modifiers-graceful-fallback","145":"/magma/v4/doc/2-core-concepts/tempo.format.html#🌐-hierarchical-localization-namespace-key-locale","146":"/magma/v4/doc/2-core-concepts/tempo.format.html#🌍-complex-native-intl-formatting","147":"/magma/v4/doc/2-core-concepts/tempo.format.html#🛠️-custom-format-tokens","148":"/magma/v4/doc/2-core-concepts/tempo.getters.html#🧲-core-getters","149":"/magma/v4/doc/2-core-concepts/tempo.getters.html#⚡-native-temporal-gateway","150":"/magma/v4/doc/2-core-concepts/tempo.getters.html#📅-date-properties","151":"/magma/v4/doc/2-core-concepts/tempo.getters.html#⏱️-time-properties","152":"/magma/v4/doc/2-core-concepts/tempo.getters.html#🗓️-iso-week-day-alignments","153":"/magma/v4/doc/2-core-concepts/tempo.getters.html#🔤-named-string-representations","154":"/magma/v4/doc/2-core-concepts/tempo.getters.html#🌍-regional-timezone-system-properties","155":"/magma/v4/doc/2-core-concepts/tempo.getters.html#🎛️-metadata-properties","156":"/magma/v4/doc/2-core-concepts/tempo.duration.html#duration-logic","157":"/magma/v4/doc/2-core-concepts/tempo.duration.html#calculating-durations","158":"/magma/v4/doc/2-core-concepts/tempo.duration.html#until","159":"/magma/v4/doc/2-core-concepts/tempo.duration.html#since","160":"/magma/v4/doc/2-core-concepts/tempo.duration.html#the-duration-object-edo","161":"/magma/v4/doc/2-core-concepts/tempo.duration.html#intelligent-balancing","162":"/magma/v4/doc/2-core-concepts/tempo.duration.html#strict-calendar-math","163":"/magma/v4/doc/2-core-concepts/tempo.duration.html#nominal-commercial-math","164":"/magma/v4/doc/2-core-concepts/tempo.duration.html#balancing-downwards-un-balancing","165":"/magma/v4/doc/2-core-concepts/tempo.duration.html#formatting-absolute-durations","166":"/magma/v4/doc/2-core-concepts/tempo.duration.html#global-configuration","167":"/magma/v4/doc/2-core-concepts/tempo.interval.html#interval","168":"/magma/v4/doc/2-core-concepts/tempo.interval.html#instantiating-an-interval","169":"/magma/v4/doc/2-core-concepts/tempo.interval.html#_1-the-ergonomic-approach-attached-to-tempo","170":"/magma/v4/doc/2-core-concepts/tempo.interval.html#_2-the-purist-approach-tree-shakeable-export","171":"/magma/v4/doc/2-core-concepts/tempo.interval.html#open-ended-boundaries","172":"/magma/v4/doc/2-core-concepts/tempo.interval.html#properties","173":"/magma/v4/doc/2-core-concepts/tempo.interval.html#start-end","174":"/magma/v4/doc/2-core-concepts/tempo.interval.html#startns-endns","175":"/magma/v4/doc/2-core-concepts/tempo.interval.html#set-operations","176":"/magma/v4/doc/2-core-concepts/tempo.interval.html#overlaps","177":"/magma/v4/doc/2-core-concepts/tempo.interval.html#contains","178":"/magma/v4/doc/2-core-concepts/tempo.interval.html#abuts","179":"/magma/v4/doc/2-core-concepts/tempo.interval.html#intersection","180":"/magma/v4/doc/2-core-concepts/tempo.interval.html#union","181":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#mutation-math","182":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#the-add-method","183":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#the-subtract-method","184":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#the-set-method","185":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#navigating-to-boundaries","186":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#week-boundaries-dedicated-iso-invariance","187":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#iso-week-iso-year-mutation-woy-yow","188":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#_1-numeric-iso-week-assignment-woy-isoweek-isoweek","189":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#_2-numeric-iso-year-assignment-shifting-yow-isoyear-isoyear","190":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#_3-iso-year-boundaries-start-mid-end","191":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#slick-object-mutations","192":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#chainability","193":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#relational-vs-navigation-shifting","194":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#_1-navigation-mode-string","195":"/magma/v4/doc/2-core-concepts/tempo.mutate.html#_2-relational-mode-object","196":"/magma/v4/doc/2-core-concepts/tempo.parse.html#smart-parsing-guide","197":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🚀-standalone-parsing-zero-overhead","198":"/magma/v4/doc/2-core-concepts/tempo.parse.html#why-use-standalone-parse","199":"/magma/v4/doc/2-core-concepts/tempo.parse.html#⚠️-standalone-vs-class-based","200":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🏗️-class-based-parsing","201":"/magma/v4/doc/2-core-concepts/tempo.parse.html#supported-formats","202":"/magma/v4/doc/2-core-concepts/tempo.parse.html#historical-era-parsing","203":"/magma/v4/doc/2-core-concepts/tempo.parse.html#📆-ordinals-nth-parsing-3rd-wednesday-of-october","204":"/magma/v4/doc/2-core-concepts/tempo.parse.html#💡-when-to-use-native-ordinal-parsing-vs-magmacomputing-tempo-plugin-ai-parseai","205":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🎭-structured-mask-wildcard-parsing-format","206":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🔢-numeric-epoch-parsing","207":"/magma/v4/doc/2-core-concepts/tempo.parse.html#unit-selection","208":"/magma/v4/doc/2-core-concepts/tempo.parse.html#smart-epoch-detection","209":"/magma/v4/doc/2-core-concepts/tempo.parse.html#fractional-precision","210":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🧩-modularity-core-vs-full","211":"/magma/v4/doc/2-core-concepts/tempo.parse.html#enabling-smart-parsing-in-core","212":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🌍-internationalization-timezone-locale","213":"/magma/v4/doc/2-core-concepts/tempo.parse.html#timezone-offset-parsing","214":"/magma/v4/doc/2-core-concepts/tempo.parse.html#registering-a-custom-leading-timezone-layout","215":"/magma/v4/doc/2-core-concepts/tempo.parse.html#us-style-dates-mm-dd-yyyy","216":"/magma/v4/doc/2-core-concepts/tempo.parse.html#parsing-ambiguous-digits-6-vs-8","217":"/magma/v4/doc/2-core-concepts/tempo.parse.html#manual-resolution-override","218":"/magma/v4/doc/2-core-concepts/tempo.parse.html#customizing-the-month-day-registry","219":"/magma/v4/doc/2-core-concepts/tempo.parse.html#internationalized-parsing-locales","220":"/magma/v4/doc/2-core-concepts/tempo.parse.html#how-it-works-accent-normalization","221":"/magma/v4/doc/2-core-concepts/tempo.parse.html#⚠️-current-limitations-what-is-not-available","222":"/magma/v4/doc/2-core-concepts/tempo.parse.html#localized-parsing-modifiers","223":"/magma/v4/doc/2-core-concepts/tempo.parse.html#custom-aliases-events-periods","224":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🧠-functional-alias-context","225":"/magma/v4/doc/2-core-concepts/tempo.parse.html#example-complex-functional-alias","226":"/magma/v4/doc/2-core-concepts/tempo.parse.html#📍-geographic-context-coordinates-geo-option","227":"/magma/v4/doc/2-core-concepts/tempo.parse.html#deterministic-normalization-validation","228":"/magma/v4/doc/2-core-concepts/tempo.parse.html#🛡️-performance-the-master-guard","229":"/magma/v4/doc/3-extending-tempo/ecosystem.html#plugin-ecosystem","230":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#creating-a-custom-plugin","231":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#the-goal","232":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#_1-the-defineplugin-factory","233":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#_2-extending-the-prototype","234":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#_3-typescript-module-augmentation","235":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#_4-packing-it-as-a-configurable-module","236":"/magma/v4/doc/3-extending-tempo/tempo.extension.html#consuming-the-plugin","237":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#layout-patterns-guide","238":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#what-is-a-snippet","239":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#what-is-a-layout","240":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#available-snippets","241":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#composite-snippets","242":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#built-in-layouts","243":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#customizing-layouts","244":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#instance-specific-layout","245":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#advanced-capture-groups","246":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#prototyping-with-tempo-regexp","247":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#🤖-ai-llm-layout-prompting","248":"/magma/v4/doc/3-extending-tempo/tempo.layout.html#professional-services","249":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#tempo-modularity","250":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#module-activation-quick-guide","251":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#core-vs-full","252":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#available-modules","253":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#duration-module-magmacomputing-tempo-duration","254":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#format-module-magmacomputing-tempo-format","255":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#mutate-module-magmacomputing-tempo-mutate","256":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#parse-module-magmacomputing-tempo-parse","257":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#terms-module-magmacomputing-tempo-term","258":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#_1-the-side-effect-standard-activation","259":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#_2-the-explicit-module-uniform-sync","260":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#_3-the-surgical-strike-data-only","261":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#custom-modules","262":"/magma/v4/doc/3-extending-tempo/tempo.modularity.html#⚠️-the-registration-gotcha","263":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#creating-a-namespace-plugin","264":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#the-lazy-evaluation-advantage","265":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#_1-the-definenamespace-factory","266":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#the-memoized-closure-pattern-methods-with-parameters","267":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#_2-typescript-module-augmentation","268":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#_3-consuming-the-namespace","269":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#the-dual-architecture-oop-vs-fp","270":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#the-best-of-both-worlds","271":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#advanced-symbol-namespaces","272":"/magma/v4/doc/3-extending-tempo/tempo.namespace.html#symbol-discovery-in-the-registry","273":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#extending-tempo-with-plugins","274":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#naming-convention-standard","275":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_1-creating-a-custom-plugin","276":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#type-safety-typescript","277":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#best-practices","278":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_1-selective-immobility","279":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_2-immutability","280":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_3-namespace-respect","281":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_4-error-handling-the-diagnostic-engine","282":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_5-unified-logging-hooks-logwarn-logerror-logdebug","283":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#alternative-standalone-functions-tempo-fns","284":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#distributing-your-plugin","285":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#plugin-factories-with-options","286":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#the-module-aggregator-pattern","287":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#commercial-enterprise-extensions","288":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#consuming-a-plugin","289":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_1-imperative-registration-tempo-use","290":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_2-declarative-configuration-defineconfig-tempo-init","291":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#_3-pluginoptions-—-legacy-shared-fallback","292":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#bulk-registration","293":"/magma/v4/doc/3-extending-tempo/tempo.plugin.html#🤝-need-help-writing-a-plugin","294":"/magma/v4/doc/3-extending-tempo/tempo.registry.html#registries-and-dictionaries","295":"/magma/v4/doc/3-extending-tempo/tempo.registry.html#accessing-registries","296":"/magma/v4/doc/3-extending-tempo/tempo.registry.html#📅-timezone-registry","297":"/magma/v4/doc/3-extending-tempo/tempo.registry.html#other-internal-registries","298":"/magma/v4/doc/3-extending-tempo/tempo.registry.html#registry-merge-contracts","299":"/magma/v4/doc/3-extending-tempo/tempo.term.html#tempo-terms","300":"/magma/v4/doc/3-extending-tempo/tempo.term.html#overview","301":"/magma/v4/doc/3-extending-tempo/tempo.term.html#what-a-term-does","302":"/magma/v4/doc/3-extending-tempo/tempo.term.html#provided-plugin","303":"/magma/v4/doc/3-extending-tempo/tempo.term.html#qtr-quarter-—-fiscal-quarters","304":"/magma/v4/doc/3-extending-tempo/tempo.term.html#szn-season-—-meteorological-seasons","305":"/magma/v4/doc/3-extending-tempo/tempo.term.html#zdc-zodiac-—-astrological-zodiac","306":"/magma/v4/doc/3-extending-tempo/tempo.term.html#tod-timeofday-—-daily-time-periods","307":"/magma/v4/doc/3-extending-tempo/tempo.term.html#inspecting-registered-terms","308":"/magma/v4/doc/3-extending-tempo/tempo.term.html#activating-terms","309":"/magma/v4/doc/3-extending-tempo/tempo.term.html#_1-standard-activation-recommended","310":"/magma/v4/doc/3-extending-tempo/tempo.term.html#_2-explicit-module-uniform-sync","311":"/magma/v4/doc/3-extending-tempo/tempo.term.html#_3-surgical-opt-in-maximum-lite","312":"/magma/v4/doc/3-extending-tempo/tempo.term.html#how-to-define-a-term-plugin","313":"/magma/v4/doc/3-extending-tempo/tempo.term.html#plugin-definition","314":"/magma/v4/doc/3-extending-tempo/tempo.term.html#range-fields","315":"/magma/v4/doc/3-extending-tempo/tempo.term.html#🔄-sync-to-alias-engine","316":"/magma/v4/doc/3-extending-tempo/tempo.term.html#registering-the-plugin","317":"/magma/v4/doc/3-extending-tempo/tempo.term.html#using-custom-configuration-in-terms","318":"/magma/v4/doc/3-extending-tempo/tempo.term.html#🧭-writing-math-aware-terms","319":"/magma/v4/doc/3-extending-tempo/tempo.term.html#the-gettermrange-helper","320":"/magma/v4/doc/3-extending-tempo/tempo.term.html#manual-boundaries","321":"/magma/v4/doc/3-extending-tempo/tempo.term.html#multi-cycle-discovery-traversals-the-resolve-method","322":"/magma/v4/doc/3-extending-tempo/tempo.term.html#🪝-term-lifecycle-hooks-protocol","323":"/magma/v4/doc/3-extending-tempo/tempo.term.html#the-6-lifecycle-hooks","324":"/magma/v4/doc/3-extending-tempo/tempo.term.html#complete-hook-example","325":"/magma/v4/doc/3-extending-tempo/tempo.term.html#zero-overhead-guarantee","326":"/magma/v4/doc/3-extending-tempo/tempo.term.html#🛠️-developer-guide-best-practices","327":"/magma/v4/doc/3-extending-tempo/tempo.term.html#🧭-best-practices-idempotency-side-effects","328":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#sandbox-factory-pattern","329":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#the-problem","330":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#the-solution","331":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#lifecycle-methods","332":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#overloaded-signatures-usage-modes","333":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#mode-1-derived-class-factory","334":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#mode-2-scoped-callback-execution-tempo-create-fn","335":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#mode-3-explicit-resource-management-using","336":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#deterministic-disposal-memory-management","337":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#traceability-collision-management","338":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#hierarchy-of-resolution","339":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#checking-the-trace","340":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#immutability-security","341":"/magma/v4/doc/4-advanced-reference/sandbox-factory.html#best-practices","342":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-debugging-introspection","343":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#static-introspection","344":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-config","345":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-default","346":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-terms","347":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-properties","348":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#tempo-parse","349":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#instance-introspection","350":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#this-config","351":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#this-parse-result","352":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#this-parse-anchor","353":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#this-term","354":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#this-fmt","355":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#primitive-auditing","356":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#debugging-and-console-logging","357":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#the-debug-flag","358":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#the-catch-flag","359":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#⚡-fast-fail-master-guard-debugging","360":"/magma/v4/doc/4-advanced-reference/tempo.debugging.html#invalid-instances","361":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#internationalization-intl-locale-in-tempo","362":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#_1-ambiguity-resolution-date-layout","363":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#_2-multi-lingual-parsing-input","364":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#_3-formatting-output","365":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#regional-calendar-environment-fallbacks","366":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#_4-intl-locale-info-regional-calendar-integration","367":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#inspecting-cultural-metadata-t-intl-info","368":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#opt-in-regional-calendar-math-localeinfo-true","369":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#dedicated-iso-escape-hatches-isoweek-wy","370":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#cultural-formatting-tokens","371":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#_5-high-performance-intl-utility-hub","372":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#pre-bound-formatting-operations","373":"/magma/v4/doc/4-advanced-reference/tempo.intl.html#architectural-benefits","374":"/magma/v4/doc/4-advanced-reference/tempo.planner.html#parse-planner-configuration","375":"/magma/v4/doc/4-advanced-reference/tempo.planner.html#layoutorder","376":"/magma/v4/doc/4-advanced-reference/tempo.planner.html#supported-layouts","377":"/magma/v4/doc/4-advanced-reference/tempo.planner.html#prefilter","378":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#tempo-shorthand-engine","379":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_1-the-three-modes-of-shorthand","380":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#a-navigation-mode-string-shorthand","381":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#b-relational-mode-object-shorthand","382":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#c-structural-mode-boundary-shorthand","383":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_2-navigation-modifiers","384":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_3-proximity-vs-momentum","385":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#proximity-resolution-identifiers","386":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#momentum-resolution-shifters","387":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_4-the-cycle-preservation-guarantee","388":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_5-development-constraints","389":"/magma/v4/doc/4-advanced-reference/tempo.shorthand.html#_6-best-practices","390":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#weekday-parsing","391":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#supported-formats","392":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#_1-simple-weekday-names","393":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#_2-symbolic-modifiers","394":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#strict-vs-inclusive-boundaries","395":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#_3-keyword-modifiers","396":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#_4-count-modifiers","397":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#_5-relative-suffixes","398":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#time-suffixes","399":"/magma/v4/doc/4-advanced-reference/tempo.weekday.html#how-it-works","400":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🏗️-core-architecture","401":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🌐-shared-global-registry","402":"/magma/v4/doc/5-architecture-and-internals/architecture.html#temporuntime-—-single-hardened-bridge","403":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🕵️-decoupled-logging","404":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🛡️-hardened-functional-resolution","405":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🏗️-tempo-architecture-internal-protection-performance","406":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🧭-methodology-comparison","407":"/magma/v4/doc/5-architecture-and-internals/architecture.html#⚡-the-zero-cost-constructor-objective","408":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🔁-iteration-enumerability-delegator-proxies","409":"/magma/v4/doc/5-architecture-and-internals/architecture.html#✅-object-keys-behavior","410":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🛡️-iteration-notes","411":"/magma/v4/doc/5-architecture-and-internals/architecture.html#_1-lazy-evaluation-shadowing","412":"/magma/v4/doc/5-architecture-and-internals/architecture.html#how-it-works","413":"/magma/v4/doc/5-architecture-and-internals/architecture.html#_2-soft-freeze-strategy-proxy","414":"/magma/v4/doc/5-architecture-and-internals/architecture.html#how-it-works-1","415":"/magma/v4/doc/5-architecture-and-internals/architecture.html#⚡-3-master-guard-guarded-lazy-strategy","416":"/magma/v4/doc/5-architecture-and-internals/architecture.html#how-it-works-2","417":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🧩-centralized-alias-management","418":"/magma/v4/doc/5-architecture-and-internals/architecture.html#how-it-works-3","419":"/magma/v4/doc/5-architecture-and-internals/architecture.html#📈-validation-performance","420":"/magma/v4/doc/5-architecture-and-internals/architecture.html#🔄-internal-lifecycle-reactive-sync","421":"/magma/v4/doc/5-architecture-and-internals/architecture.html#reactive-registration","422":"/magma/v4/doc/5-architecture-and-internals/architecture.html#disposable-engine-symbol-dispose","423":"/magma/v4/doc/5-architecture-and-internals/architecture.html#⚖️-summary","424":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#the-immutable-proxy-delegator-lazy-evaluation-pattern","425":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#the-problem-mutating-frozen-state","426":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#the-solution-proxy-delegator-with-memoization","427":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#how-it-works","428":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#summary","429":"/magma/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html#🌈-the-best-of-all-worlds","430":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#soft-freeze-strategy","431":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#the-problem","432":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#the-solution-soft-freeze","433":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#_1-the-proxy-public-shield","434":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#_2-the-target-internal-source-of-truth","435":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#_3-access-control-target-symbol","436":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#implementation-details","437":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#proxy-library-ts","438":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#enumerate-library-ts","439":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#benefits","440":"/magma/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html#the-safe-merge-rule","441":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#🚀-tempo-performance-benchmarks","442":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#📊-summary-of-timings","443":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#🏗️-architectural-impact","444":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#_1-proxy-delegator-delegation","445":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#_2-the-master-guard-fast-fail","446":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#🧪-benchmark-methodology","447":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#📈-self-service-benchmark-module","448":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#usage","449":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#metrics-collected","450":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#indicative-benchmark-results","451":"/magma/v4/doc/5-architecture-and-internals/tempo.benchmarks.html#🔍-key-takeaways","452":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#tempo-enumerators-enumify","453":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_1-how-tempo-enums-are-defined","454":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#array-based-definitions","455":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#object-based-definitions","456":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#type-inference","457":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_2-using-enums-outside-of-tempo","458":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_1-static-properties-on-tempo","459":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_2-canonical-namespace-import","460":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_3-direct-named-import","461":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#static-first-reflection-suite-enum","462":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_3-creating-custom-enums","463":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#basic-custom-enum","464":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#extending-enums-via-prototypal-inheritance-enum-extend","465":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#how-prototypal-inheritance-works-here","466":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_4-how-they-are-used-inside-tempo","467":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#_5-enumify-vs-typescript-enum-the-trade-offs","468":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#the-wins-for-enumify","469":"/magma/v4/doc/6-utility-library/tempo.enumerators.html#the-losses-trade-offs-for-enumify","470":"/magma/v4/doc/6-utility-library/tempo.library.html#tempo-library-functionality","471":"/magma/v4/doc/6-utility-library/tempo.library.html#_1-enumerators-enumify-enum","472":"/magma/v4/doc/6-utility-library/tempo.library.html#_2-serialization-stringify-objectify-cloneify","473":"/magma/v4/doc/6-utility-library/tempo.library.html#_3-high-performance-push-pull-streams-reactive","474":"/magma/v4/doc/6-utility-library/tempo.library.html#_4-deferred-promises-pledge","475":"/magma/v4/doc/6-utility-library/tempo.library.html#key-features","476":"/magma/v4/doc/6-utility-library/tempo.library.html#_5-gc-safety-memory-management-weakcache-finalizer","477":"/magma/v4/doc/6-utility-library/tempo.library.html#_6-functional-evaluation-evaluate-dynamicproxy","478":"/magma/v4/doc/6-utility-library/tempo.library.html#_7-class-decorators-immutable-serializable-static","479":"/magma/v4/doc/6-utility-library/tempo.library.html#_8-exhaustive-api-reference","480":"/magma/v4/doc/6-utility-library/tempo.pledge.html#pledge-advanced-asynchronous-patterns","481":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_1-basic-lifecycle","482":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_2-then-ability","483":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_3-advanced-callbacks","484":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_4-debugging-with-tags","485":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_5-global-configuration","486":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_6-automatic-cleanup-symbol-dispose","487":"/magma/v4/doc/6-utility-library/tempo.pledge.html#_7-state-accessors","488":"/magma/v4/doc/6-utility-library/tempo.reactive.html#reactive-high-performance-push-pull-streams","489":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_1-core-concepts-push-pull-duality","490":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_2-push-based-event-subscriptions","491":"/magma/v4/doc/6-utility-library/tempo.reactive.html#deterministic-disposal-with-using","492":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_3-pull-based-async-iteration","493":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_4-stream-truncation-with-until","494":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_5-resource-management-gc-safety","495":"/magma/v4/doc/6-utility-library/tempo.reactive.html#automatic-finalization","496":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_6-static-factory-methods","497":"/magma/v4/doc/6-utility-library/tempo.reactive.html#_7-stream-state-inspection","498":"/magma/v4/doc/6-utility-library/tempo.serializers.html#tempo-serializers-stringify-objectify-cloneify","499":"/magma/v4/doc/6-utility-library/tempo.serializers.html#_1-the-core-functions","500":"/magma/v4/doc/6-utility-library/tempo.serializers.html#stringify-obj","501":"/magma/v4/doc/6-utility-library/tempo.serializers.html#objectify-str-sentinel","502":"/magma/v4/doc/6-utility-library/tempo.serializers.html#cloneify-obj-sentinel","503":"/magma/v4/doc/6-utility-library/tempo.serializers.html#_2-selling-the-benefits","504":"/magma/v4/doc/6-utility-library/tempo.serializers.html#_3-how-they-are-used-inside-tempo","505":"/magma/v4/doc/6-utility-library/tempo.serializers.html#_4-drawbacks-over-json-methods","506":"/magma/v4/doc/7-ecosystem/comparison.html#🥊-tempo-vs-the-competition","507":"/magma/v4/doc/7-ecosystem/comparison.html#at-a-glance","508":"/magma/v4/doc/7-ecosystem/comparison.html#💎-why-tempo-wins","509":"/magma/v4/doc/7-ecosystem/comparison.html#_1-the-terms-engine-business-intelligence","510":"/magma/v4/doc/7-ecosystem/comparison.html#_2-human-centric-parsing","511":"/magma/v4/doc/7-ecosystem/comparison.html#_3-nanosecond-precision","512":"/magma/v4/doc/7-ecosystem/comparison.html#_4-zero-leaky-abstractions","513":"/magma/v4/doc/7-ecosystem/comparison.html#_5-intelligent-formatting-shorthands","514":"/magma/v4/doc/7-ecosystem/comparison.html#the-temporal-transition-strategy","515":"/magma/v4/doc/7-ecosystem/comparison.html#which-should-you-choose","516":"/magma/v4/doc/7-ecosystem/extending-temporal.html#🤝-extending-native-temporal","517":"/magma/v4/doc/7-ecosystem/extending-temporal.html#_1-parsing-strict-vs-intelligent","518":"/magma/v4/doc/7-ecosystem/extending-temporal.html#_2-formatting-verbose-vs-expressive-tokens","519":"/magma/v4/doc/7-ecosystem/extending-temporal.html#_3-extensibility-domain-specific-logic","520":"/magma/v4/doc/7-ecosystem/extending-temporal.html#_4-duration-logic-strict-math-vs-human-readable","521":"/magma/v4/doc/7-ecosystem/vision.html#the-vision-for-tempo","522":"/magma/v4/doc/7-ecosystem/vision.html#introduction-humanizing-temporal","523":"/magma/v4/doc/7-ecosystem/vision.html#core-value-proposition","524":"/magma/v4/doc/7-ecosystem/vision.html#_1-closing-the-onboarding-gap","525":"/magma/v4/doc/7-ecosystem/vision.html#_2-human-centric-parsing","526":"/magma/v4/doc/7-ecosystem/vision.html#_3-contextual-business-intelligence-via-plugins","527":"/magma/v4/doc/7-ecosystem/vision.html#_4-lean-deterministic-and-hardened","528":"/magma/v4/doc/7-ecosystem/vision.html#conclusion","529":"/magma/v4/doc/8-project-and-support/commercial.html#🤝-magma-computing-solutions-professional-services","530":"/magma/v4/doc/8-project-and-support/commercial.html#🚀-our-services","531":"/magma/v4/doc/8-project-and-support/commercial.html#🧩-custom-plugin-development","532":"/magma/v4/doc/8-project-and-support/commercial.html#🏛️-architecture-migration-consulting","533":"/magma/v4/doc/8-project-and-support/commercial.html#🛡️-enterprise-support-commercial-extensions","534":"/magma/v4/doc/8-project-and-support/commercial.html#📬-contact-us","535":"/magma/v4/doc/8-project-and-support/migration-guide.html#⚠️-migrating-to-tempo-v4-x","536":"/magma/v4/doc/8-project-and-support/migration-guide.html#⚡-dynamic-functional-context-dfc-supplier-options","537":"/magma/v4/doc/8-project-and-support/migration-guide.html#🛠️-plugin-sdk-subpath-magmacomputing-tempo-plugin-sdk","538":"/magma/v4/doc/8-project-and-support/migration-guide.html#📄-zero-await-synchronous-jsonc-config-discovery","539":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔓-100-open-source-community-core","540":"/magma/v4/doc/8-project-and-support/migration-guide.html#🚀-tempo-v4-1-0-updates","541":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔌-configuration-inheritance-extends-plugins-and-pluginoptions","542":"/magma/v4/doc/8-project-and-support/migration-guide.html#example","543":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔒-overloaded-tempo-create-scoped-disposal-using","544":"/magma/v4/doc/8-project-and-support/migration-guide.html#📂-data-augmentation-registry","545":"/magma/v4/doc/8-project-and-support/migration-guide.html#example-migration","546":"/magma/v4/doc/8-project-and-support/migration-guide.html#🧹-deprecated-type-api-cleanup","547":"/magma/v4/doc/8-project-and-support/migration-guide.html#⚠️-migrating-to-tempo-v3-x","548":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-migrating-to-tempo-v3-x-ticker-extraction","549":"/magma/v4/doc/8-project-and-support/migration-guide.html#⚠️-migrating-to-tempo-v2-x","550":"/magma/v4/doc/8-project-and-support/migration-guide.html#📦-modular-architecture","551":"/magma/v4/doc/8-project-and-support/migration-guide.html#if-you-use-the-full-package","552":"/magma/v4/doc/8-project-and-support/migration-guide.html#if-you-want-a-lean-bundle","553":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔌-feature-registration","554":"/magma/v4/doc/8-project-and-support/migration-guide.html#v1-x-automatic","555":"/magma/v4/doc/8-project-and-support/migration-guide.html#v2-x-opt-in-for-core","556":"/magma/v4/doc/8-project-and-support/migration-guide.html#🗓️-term-logic-refactor","557":"/magma/v4/doc/8-project-and-support/migration-guide.html#🚀-tempo-v2-4-0-standalone-utilities-path-deprecation","558":"/magma/v4/doc/8-project-and-support/migration-guide.html#🛠️-standalone-imports","559":"/magma/v4/doc/8-project-and-support/migration-guide.html#⚠️-reorganized-paths","560":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-migrating-from-version-2-4","561":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-migrating-from-version-2-6-0","562":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-migrating-from-version-2-7-0-grouped-options","563":"/magma/v4/doc/8-project-and-support/migration-guide.html#month-day-regional-parsing","564":"/magma/v4/doc/8-project-and-support/migration-guide.html#relative-time","565":"/magma/v4/doc/8-project-and-support/migration-guide.html#action-required","566":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-migrating-to-version-2-9-3","567":"/magma/v4/doc/8-project-and-support/migration-guide.html#📏-bigint-precision-resolution","568":"/magma/v4/doc/8-project-and-support/migration-guide.html#example-1","569":"/magma/v4/doc/8-project-and-support/migration-guide.html#action-required-1","570":"/magma/v4/doc/8-project-and-support/migration-guide.html#🔁-removed-features-v3-0-0","571":"/magma/v4/doc/8-project-and-support/migration-guide.html#deprecated-boolean-debug-flag","572":"/magma/v4/doc/8-project-and-support/migration-guide.html#internationalization-naming","573":"/magma/v4/doc/8-project-and-support/migration-guide.html#🧪-testing-and-stability","574":"/magma/v4/doc/8-project-and-support/releases/#🚀-releases","575":"/magma/v4/doc/8-project-and-support/releases/#release-strategy","576":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#📜-version-0-x-history","577":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#v0-3-0-2025-07-31","578":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#new-features","579":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#bug-fixes","580":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#refactor","581":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#documentation","582":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#chores","583":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#v0-2-0-2024-10-30","584":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#new-features-1","585":"/magma/v4/doc/8-project-and-support/releases/v0.x.html#bug-fixes-1","586":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#📜-version-1-x-history","587":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#v1-1-3-2026-03-31","588":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#new-features","589":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#documentation","590":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#branding","591":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#v1-1-2-2026-03-23","592":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#new-features-1","593":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#bug-fixes","594":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#documentation-1","595":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#v1-1-1-2026-03-22","596":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#new-features-2","597":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#changed","598":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#documentation-2","599":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#v1-1-0-2026-03-19","600":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#new-features-3","601":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#documentation-3","602":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#tests","603":"/magma/v4/doc/8-project-and-support/releases/v1.x.html#chores","604":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📜-version-2-x-history","605":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-11-0-2026-05-25","606":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#new-features","607":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#fixed","608":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-10-1-2026-05-23","609":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#new-features-1","610":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#documentation","611":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-10-0-2026-05-20","612":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#new-features-2","613":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#bug-fixes","614":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#documentation-1","615":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-9-3-2026-05-10","616":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🏗️-engine-stabilization-hardening","617":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-type-safety-environment-engine-hardening","618":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📦-dependency-updates","619":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-9-2-2026-05-08","620":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#new-features-3","621":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#bug-fixes-1","622":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#improvements","623":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#documentation-2","624":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-9-0-2026-05-06","625":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🏗️-alias-architecture-stabilization","626":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-parser-registry-refinement","627":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📚-documentation-fixes","628":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-8-0-2026-04-30","629":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🚨-immutability-system-refined","630":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-parse-planner-configuration","631":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-resilience-bug-fixes","632":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-7-0-2026-04-27","633":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🧩-configuration-rationalization","634":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-resilience-bug-fixes-1","635":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-ci-cd-infrastructure","636":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-6-0-2026-04-25","637":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚠️-migration-notes","638":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-5-0-2026-04-25","639":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#new-features-4","640":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#documentation-3","641":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-4-0-2026-04-24","642":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🧩-parsing-infrastructure","643":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-isolation-sandboxing","644":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-internal-refactoring-type-safety","645":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📊-diagnostics-debug-support","646":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-3-0-2026-04-22","647":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🧩-parsing-innovations","648":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📚-documentation-ux","649":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛠️-refactor-type-safety","650":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-2-6-2026-04-20","651":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🚑-emergency-hotfix","652":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-2-5-2026-04-20","653":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🏗️-modular-hardening","654":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🔍-term-resolution-refinements","655":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📚-documentation-ux-1","656":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-2-4-2026-04-19","657":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-production-safety","658":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-2-3-2026-04-19","659":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#✨-new-features","660":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🐛-bug-fixes","661":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📚-documentation-chores","662":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-2-2-2026-04-18","663":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-registry-stabilization","664":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🔍-hardened-reflection","665":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📦-production-optimization","666":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🎨-premium-documentation-ux","667":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🧬-mutation-engine-state-preservation","668":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🧩-modular-parse-engine","669":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚙️-ci-cd-tooling","670":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-1-3-2026-04-18","671":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📚-documentation-ecosystem","672":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🚀-performance-extensibility","673":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⏱️-temporal-utilities","674":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#v2-1-2-2026-04-16","675":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🏗️-modular-architecture","676":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#📝-improved-logging","677":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⏱️-static-api","678":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🔌-side-effect-registration","679":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🛡️-100-reliability","680":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🗓️-unified-term-logic","681":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#➗-relational-term-math","682":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🔗-fluent-immutable-boundaries","683":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#⚡-ticker-reliability","684":"/magma/v4/doc/8-project-and-support/releases/v2.x.html#🚀-parsing-engine-optimization","685":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📜-version-3-x-history","686":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-11-1-2026-08-10","687":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-dedicated-config-subpath-magmacomputing-tempo-config","688":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-jsonc-configuration-support","689":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-timezone-abbreviations-humanized-offsets","690":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-sql-space-delimited-timestamp-parsing","691":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-cache-inspection-serialization-tojson","692":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-ai-context-ide-integration-llms-txt","693":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-11-0-2026-07-31","694":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-centralized-cache-engine-tempo-cache","695":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-glossary-seeding","696":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#⚡-multi-provider-ai-farm-batching","697":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-enhancements","698":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-10-3-2026-07-29","699":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#⚡-zero-overhead-instantiation-lazy-system-clock","700":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-10-2-2026-07-25","701":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-experimental-ai-parsing","702":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🪲-bug-fixes-stability","703":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-10-0-2026-07-19","704":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new","705":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-enhancements-1","706":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-9-0-2026-07-14","707":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-1","708":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-enhancements-2","709":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🪲-bug-fixes-stability-1","710":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-8-0-2026-07-11","711":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-2","712":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring","713":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-7-1-2026-07-09","714":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🪲-bug-fix","715":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-7-0-2026-07-08","716":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-runtime-version-registry","717":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-1","718":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-6-0-2026-07-05","719":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-shorthand-mutation-keys","720":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-shorthand-duration-keys","721":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-5-2-2026-07-04","722":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-minified-global-bundles","723":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-timezone-formatting-modifiers","724":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-2","725":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-5-1-2026-06-28","726":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-3","727":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-5-0-2026-06-28","728":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-unified-plugin-api","729":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-ecosystem","730":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-4-0-2026-06-26","731":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-dynamic-format-tokens","732":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-compound-token-modifiers","733":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-3-1-2026-06-22","734":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-slick-object-mutations","735":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#⚡-extended-shorthand-modifiers","736":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-3-0-2026-06-21","737":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-localized-modifier-registry","738":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-4","739":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#⚡-slick-modifier-semantics","740":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-2-3-2026-06-20","741":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-—-project-scaffolding","742":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-2-2-2026-06-18","743":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-3","744":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-5","745":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-2-1-2026-06-17","746":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-4","747":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-ecosystem-1","748":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-6","749":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-2-0-2026-06-16","750":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-5","751":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📚-documentation-ecosystem-2","752":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-7","753":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-1-0-2026-06-13","754":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-6","755":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-8","756":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#v3-0-0-2026-06-08","757":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🚨-major-breaking-changes","758":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#✨-what-s-new-7","759":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#📦-migration-path-for-tempo-ticker-users","760":"/magma/v4/doc/8-project-and-support/releases/v3.x.html#🏗️-internal-refactoring-9","761":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#📜-version-4-x-history","762":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-7-0-2026-10-16","763":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-developer-experience","764":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-developer-guide","765":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-roman-numeral-format-modifiers-round-trip-symmetry","766":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-archival-inscription-date-lexing","767":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-smart-sequence-guard-validation","768":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_4-canonical-iso-week-numbering-getters-woy-yow","769":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_5-object-key-assertion-primitives-disambiguation","770":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-6-0-2026-10-11","771":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-developer-experience-1","772":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-protocol-architecture","773":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-well-known-symbol-lifecycle-protocol-termhook","774":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-native-term-units-in-until-since","775":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-standard-celestial-terms-lifecycle-integration","776":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_4-unified-tempo-enums-namespace-extensible-ordinals","777":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_5-shorthand-boundary-mutations","778":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_6-dialect-mask-precision-engine-optimization","779":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-5-1-2026-10-05","780":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-developer-experience-2","781":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-improvements-fixes","782":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-dynamic-plugin-registry-resilience","783":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-5-0-2026-10-02","784":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements","785":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements","786":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-structured-t-intl-sub-namespace-intl-info-intl-locale","787":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-tempo-intl-formatter-hub","788":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-advanced-format-translation-capabilities","789":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-4-4-2026-09-30","790":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-1","791":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-1","792":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-reactive-stream-engine-reactive-t","793":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-ergonomic-type-casting-cast-t","794":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-4-3-2026-09-29","795":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-performance-boosts","796":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-performance","797":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-public-weak-object-cache-tempo-cache-weak","798":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-automated-regular-expression-date-interning","799":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-4-2-2026-09-27","800":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-fixes","801":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-improvements-fixes-1","802":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-unicode-multi-script-keyword-matching","803":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-4-1-2026-09-20","804":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-2","805":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-2","806":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-core-braced-format-mask-parsing-wildcard-matching","807":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-dynamic-evaluable-t-format-dialect-resolution","808":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-dialects-plugin-integration-magmacomputing-tempo-plugin-dialects","809":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-4-0-2026-09-18","810":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-3","811":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-3","812":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-zero-boilerplate-side-effect-imports-install","813":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-3-0-2026-09-16","814":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-4","815":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-4","816":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-colocated-plugin-options-callable-factories","817":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-intl-locale-info-culturally-authentic-calendars-t-intl","818":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-direct-native-temporal-gateway-t-zdt","819":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_4-day-of-year-property-token-t-doy-doy","820":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-2-0-2026-09-09","821":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-5","822":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-5","823":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-dynamic-namespace-spatial-tokens-in-t-format","824":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-universal-geographic-context-hemisphere-inferences","825":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-hardened-static-configuration-resolution","826":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-1-0-2026-09-04","827":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-architectural-enhancements-6","828":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-improvements-6","829":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-remote-cascading-configuration-resolution-resolveconfig","830":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-dedicated-pluginoptions-configuration-slot","831":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-overloaded-tempo-create-deterministic-resource-disposal","832":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_4-architectural-separation-of-extends-and-plugins","833":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🐛-bug-fixes","834":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#v4-0-0-2026-08-27","835":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚀-key-highlights-paradigm-shifts","836":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🚨-major-breaking-changes","837":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🌟-new-features-architectural-modernizations","838":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_1-dynamic-functional-context-dfc-options-evaluation","839":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_2-synchronous-json-jsonc-config-discovery-resolveconfigsync","840":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_3-standardized-plugin-sdk-facade-magmacomputing-tempo-plugin-sdk","841":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_4-expanded-utility-stack-exports-magmacomputing-tempo-library","842":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#_5-api-standardization-for-boundary-mutation-payloads-term-value","843":"/magma/v4/doc/8-project-and-support/releases/v4.x.html#🗑️-api-removals-cleanups","844":"/magma/v4/doc/9-plugins/_setup.index.html#tempo-plugin-setup-guide","845":"/magma/v4/doc/9-plugins/_setup.index.html#_1-overview","846":"/magma/v4/doc/9-plugins/_setup.index.html#_2-installation","847":"/magma/v4/doc/9-plugins/_setup.index.html#_3-registration-activation","848":"/magma/v4/doc/9-plugins/_setup.index.html#option-a-initialization-option-recommended","849":"/magma/v4/doc/9-plugins/_setup.index.html#option-b-explicit-extension-tempo-extend","850":"/magma/v4/doc/9-plugins/_setup.index.html#_4-browser-global-namespace-usage","851":"/magma/v4/doc/9-plugins/_setup.index.html#_5-authoring-custom-plugins","852":"/magma/v4/doc/9-plugins/ai.architecture.html#provider-architecture-security","853":"/magma/v4/doc/9-plugins/ai.architecture.html#bring-your-own-key-byok-zero-config-discovery","854":"/magma/v4/doc/9-plugins/ai.architecture.html#advanced-configuration-custom-models-llm-options","855":"/magma/v4/doc/9-plugins/ai.architecture.html#per-request-lazy-resolution-fallback-defaults","856":"/magma/v4/doc/9-plugins/ai.architecture.html#dynamic-provider-manifests-remote-endpoint-trust","857":"/magma/v4/doc/9-plugins/ai.architecture.html#frontend-security-warning","858":"/magma/v4/doc/9-plugins/ai.architecture.html#browser-client-side-proxy-architecture","859":"/magma/v4/doc/9-plugins/ai.architecture.html#_1-browser-configuration-example","860":"/magma/v4/doc/9-plugins/ai.architecture.html#_2-backend-proxy-handler-example-next-js-cloudflare-worker-express","861":"/magma/v4/doc/9-plugins/ai.architecture.html#🔒-security-privacy-guarantees","862":"/magma/v4/doc/9-plugins/ai.architecture.html#_1-transport-security-https-tls","863":"/magma/v4/doc/9-plugins/ai.architecture.html#_2-ephemeral-processing-cache-retention-controls","864":"/magma/v4/doc/9-plugins/ai.architecture.html#_3-in-memory-credential-redaction-immutability","865":"/magma/v4/doc/9-plugins/ai.architecture.html#_4-deterministic-schema-guardrails-confidence-range-verification","866":"/magma/v4/doc/9-plugins/ai.architecture.html#_5-partitioned-caching-fail-open-storage-resilience","867":"/magma/v4/doc/9-plugins/ai.architecture.html#multi-provider-execution-strategies-aimode","868":"/magma/v4/doc/9-plugins/ai.architecture.html#provider-id-canonicalization","869":"/magma/v4/doc/9-plugins/ai.context.html#contextai-—-context-regional-inference","870":"/magma/v4/doc/9-plugins/ai.context.html#basic-usage","871":"/magma/v4/doc/9-plugins/ai.context.html#configuration-options-aicontextoptions","872":"/magma/v4/doc/9-plugins/ai.context.html#result-schema-tempocontext","873":"/magma/v4/doc/9-plugins/ai.context.html#key-architectural-behaviors","874":"/magma/v4/doc/9-plugins/ai.context.html#_1-workspace-baseline-context","875":"/magma/v4/doc/9-plugins/ai.context.html#_2-strict-confidence-thresholds","876":"/magma/v4/doc/9-plugins/ai.context.html#_3-timezone-validation","877":"/magma/v4/doc/9-plugins/ai.context.html#_4-parallel-batch-processing","878":"/magma/v4/doc/9-plugins/ai.context.html#combining-contextai-with-parseai-the-pivot-flow","879":"/magma/v4/doc/9-plugins/ai.diff.html#diffai-—-contextual-business-date-deltas","880":"/magma/v4/doc/9-plugins/ai.diff.html#basic-usage","881":"/magma/v4/doc/9-plugins/ai.diff.html#configuration-options-aidiffoptions","882":"/magma/v4/doc/9-plugins/ai.diff.html#result-schema-tempoaidiffresult","883":"/magma/v4/doc/9-plugins/ai.diff.html#key-architectural-behaviors","884":"/magma/v4/doc/9-plugins/ai.diff.html#_1-native-grounding-context","885":"/magma/v4/doc/9-plugins/ai.diff.html#_2-public-holiday-exclusions","886":"/magma/v4/doc/9-plugins/ai.diff.html#_3-directional-awareness-reverse-intervals","887":"/magma/v4/doc/9-plugins/ai.diff.html#_4-parallel-batch-processing","888":"/magma/v4/doc/9-plugins/ai.extract.html#extractai-—-unstructured-text-calendar-event-extraction","889":"/magma/v4/doc/9-plugins/ai.extract.html#basic-usage","890":"/magma/v4/doc/9-plugins/ai.extract.html#configuration-options-aiextractoptions","891":"/magma/v4/doc/9-plugins/ai.extract.html#result-schema-tempoaiextractresult","892":"/magma/v4/doc/9-plugins/ai.extract.html#key-architectural-behaviors","893":"/magma/v4/doc/9-plugins/ai.extract.html#_1-mathematical-grounding-hallucination-suppression","894":"/magma/v4/doc/9-plugins/ai.extract.html#_2-native-tempo-instances","895":"/magma/v4/doc/9-plugins/ai.extract.html#_3-multi-tier-distributed-caching","896":"/magma/v4/doc/9-plugins/ai.extract.html#_4-parallel-batch-extraction","897":"/magma/v4/doc/9-plugins/ai.format.html#formatai-—-contextual-narrative-date-formatting","898":"/magma/v4/doc/9-plugins/ai.format.html#basic-usage","899":"/magma/v4/doc/9-plugins/ai.format.html#configuration-options-aiformatoptions","900":"/magma/v4/doc/9-plugins/ai.format.html#result-schema-tempoaiformatresult","901":"/magma/v4/doc/9-plugins/ai.format.html#key-architectural-behaviors","902":"/magma/v4/doc/9-plugins/ai.format.html#_1-native-grounding-context","903":"/magma/v4/doc/9-plugins/ai.format.html#_2-tc39-temporal-universal-interoperability","904":"/magma/v4/doc/9-plugins/ai.format.html#_3-multi-tier-distributed-caching","905":"/magma/v4/doc/9-plugins/ai.format.html#_4-parallel-batch-formatting","906":"/magma/v4/doc/9-plugins/ai.grounding.html#grounding-natural-language-parsing","907":"/magma/v4/doc/9-plugins/ai.grounding.html#temporal-regional-grounding","908":"/magma/v4/doc/9-plugins/ai.grounding.html#custom-grounding-anchors-options","909":"/magma/v4/doc/9-plugins/ai.grounding.html#why-cultural-regional-grounding-is-critical","910":"/magma/v4/doc/9-plugins/ai.grounding.html#the-decoupled-output-bridge","911":"/magma/v4/doc/9-plugins/ai.grounding.html#relative-date-ambiguity-tie-breakers","912":"/magma/v4/doc/9-plugins/ai.grounding.html#confidence-thresholds-metadata-handling","913":"/magma/v4/doc/9-plugins/ai.index.html#magmacomputing-tempo-plugin-ai","914":"/magma/v4/doc/9-plugins/ai.index.html#installation-quickstart","915":"/magma/v4/doc/9-plugins/ai.index.html#two-usage-patterns-namespace-vs-tree-shakeable-functions","916":"/magma/v4/doc/9-plugins/ai.index.html#pattern-a-tempo-ai-cohesive-namespace","917":"/magma/v4/doc/9-plugins/ai.index.html#auto-installation-side-effect-import","918":"/magma/v4/doc/9-plugins/ai.index.html#pattern-b-tree-shakeable-standalone-functions","919":"/magma/v4/doc/9-plugins/ai.index.html#ai-function-catalog","920":"/magma/v4/doc/9-plugins/ai.index.html#summary-of-distinct-return-contracts","921":"/magma/v4/doc/9-plugins/ai.index.html#architecture-infrastructure-guides","922":"/magma/v4/doc/9-plugins/ai.index.html#community-feedback-production-notice","923":"/magma/v4/doc/9-plugins/ai.index.html#licensing","924":"/magma/v4/doc/9-plugins/ai.init.html#initai-—-provider-initialization-farm-configuration","925":"/magma/v4/doc/9-plugins/ai.init.html#zero-config-auto-discovery","926":"/magma/v4/doc/9-plugins/ai.init.html#configuration-resolution-order","927":"/magma/v4/doc/9-plugins/ai.init.html#tempo-config-json-example","928":"/magma/v4/doc/9-plugins/ai.init.html#basic-usage-explicit-configuration","929":"/magma/v4/doc/9-plugins/ai.init.html#single-provider-shorthand","930":"/magma/v4/doc/9-plugins/ai.init.html#multi-provider-configuration","931":"/magma/v4/doc/9-plugins/ai.init.html#global-backend-proxy-endpoint","932":"/magma/v4/doc/9-plugins/ai.init.html#custom-gateway-endpoints","933":"/magma/v4/doc/9-plugins/ai.init.html#dynamic-provider-credentials-context-suppliers","934":"/magma/v4/doc/9-plugins/ai.init.html#execution-modes-multi-provider-options","935":"/magma/v4/doc/9-plugins/ai.init.html#timeout-controls-slas","936":"/magma/v4/doc/9-plugins/ai.init.html#operational-trace-logging-debugging","937":"/magma/v4/doc/9-plugins/ai.init.html#configuration-options-reference","938":"/magma/v4/doc/9-plugins/ai.init.html#typescript-interface","939":"/magma/v4/doc/9-plugins/ai.modes.html#multi-provider-execution-modes-aimode","940":"/magma/v4/doc/9-plugins/ai.modes.html#strategy-comparison","941":"/magma/v4/doc/9-plugins/ai.modes.html#global-telemetry-cooldown-filtering","942":"/magma/v4/doc/9-plugins/ai.modes.html#proactive-cooldown-avoidance","943":"/magma/v4/doc/9-plugins/ai.modes.html#dispatch-decision-guide","944":"/magma/v4/doc/9-plugins/ai.modes.html#mode-deep-dives-code-examples","945":"/magma/v4/doc/9-plugins/ai.modes.html#_1-aimode-fallback-—-sequential-cascade-default","946":"/magma/v4/doc/9-plugins/ai.modes.html#_2-aimode-hedged-—-speculative-latency-hedging","947":"/magma/v4/doc/9-plugins/ai.modes.html#_3-aimode-roundrobin-—-multi-key-cyclic-load-balancing","948":"/magma/v4/doc/9-plugins/ai.modes.html#_4-aimode-adaptive-—-rate-limit-telemetry-prioritization","949":"/magma/v4/doc/9-plugins/ai.modes.html#_5-aimode-race-—-speculative-parallel-execution","950":"/magma/v4/doc/9-plugins/ai.modes.html#_6-aimode-consensus-—-multi-llm-cross-validation","951":"/magma/v4/doc/9-plugins/ai.onboarding.html#ai-configuration-onboarding-guide","952":"/magma/v4/doc/9-plugins/ai.onboarding.html#_3-tier-configuration-architecture","953":"/magma/v4/doc/9-plugins/ai.onboarding.html#tier-comparison-matrix","954":"/magma/v4/doc/9-plugins/ai.onboarding.html#tier-1-tempo-trial-sandbox-evaluation","955":"/magma/v4/doc/9-plugins/ai.onboarding.html#tier-2-backend-proxy-recommended-for-web-apps","956":"/magma/v4/doc/9-plugins/ai.onboarding.html#tier-3-direct-keys-environment-variables-server-side","957":"/magma/v4/doc/9-plugins/ai.onboarding.html#method-a-environment-variables-auto-discovery","958":"/magma/v4/doc/9-plugins/ai.onboarding.html#method-b-explicit-initai","959":"/magma/v4/doc/9-plugins/ai.onboarding.html#configuration-parameter-reference","960":"/magma/v4/doc/9-plugins/ai.parse.html#parseai-—-natural-language-point-in-time-parsing","961":"/magma/v4/doc/9-plugins/ai.parse.html#basic-usage","962":"/magma/v4/doc/9-plugins/ai.parse.html#options-overrides","963":"/magma/v4/doc/9-plugins/ai.parse.html#multi-provider-execution-modes","964":"/magma/v4/doc/9-plugins/ai.parse.html#batch-array-parsing","965":"/magma/v4/doc/9-plugins/ai.parse.html#diagnostic-metadata-ai","966":"/magma/v4/doc/9-plugins/ai.rate-limits.html#rate-limits-cache-management","967":"/magma/v4/doc/9-plugins/ai.rate-limits.html#tracking-quota-real-time","968":"/magma/v4/doc/9-plugins/ai.rate-limits.html#_1-request-locked-instance-metadata-dt-ai-limits","969":"/magma/v4/doc/9-plugins/ai.rate-limits.html#_2-global-state-utility-getairatelimits","970":"/magma/v4/doc/9-plugins/ai.rate-limits.html#handling-quota-exhaustion-429s","971":"/magma/v4/doc/9-plugins/ai.rate-limits.html#cache-management","972":"/magma/v4/doc/9-plugins/ai.rate-limits.html#array-processing-token-economics","973":"/magma/v4/doc/9-plugins/ai.rate-limits.html#soft-errors-in-array-batches","974":"/magma/v4/doc/9-plugins/ai.rate-limits.html#static-glossary-seeding","975":"/magma/v4/doc/9-plugins/ai.rate-limits.html#bypassing-cache-forcing-network-requests","976":"/magma/v4/doc/9-plugins/ai.rate-limits.html#evicting-bad-parses","977":"/magma/v4/doc/9-plugins/ai.rate-limits.html#forcing-a-refresh","978":"/magma/v4/doc/9-plugins/ai.rate-limits.html#extensible-caching-async-storage-adapters-aicacheadapter","979":"/magma/v4/doc/9-plugins/ai.rate-limits.html#cascading-ttl-resolution-policies","980":"/magma/v4/doc/9-plugins/ai.rate-limits.html#fail-open-cache-resilience","981":"/magma/v4/doc/9-plugins/ai.recurrence.html#recurrenceai-—-recurrence-rules-schedule-translation","982":"/magma/v4/doc/9-plugins/ai.recurrence.html#basic-usage","983":"/magma/v4/doc/9-plugins/ai.recurrence.html#stateful-paged-batching-take-n","984":"/magma/v4/doc/9-plugins/ai.recurrence.html#native-rrule-parsing-zero-network-overhead","985":"/magma/v4/doc/9-plugins/ai.recurrence.html#lazy-iteration-for-of","986":"/magma/v4/doc/9-plugins/ai.recurrence.html#result-interface","987":"/magma/v4/doc/9-plugins/ai.schedule.html#scheduleai-—-intelligent-appointment-booking-conflict-resolution","988":"/magma/v4/doc/9-plugins/ai.schedule.html#basic-usage","989":"/magma/v4/doc/9-plugins/ai.schedule.html#configuration-options-temposcheduleoptions","990":"/magma/v4/doc/9-plugins/ai.schedule.html#tempointerval-interface","991":"/magma/v4/doc/9-plugins/ai.schedule.html#event-input-shape-scheduleeventinput","992":"/magma/v4/doc/9-plugins/ai.schedule.html#result-schema-temposcheduleresult","993":"/magma/v4/doc/9-plugins/ai.schedule.html#internal-conflict-bumping-engine","994":"/magma/v4/doc/9-plugins/ai.security.html#security-privacy-architecture","995":"/magma/v4/doc/9-plugins/ai.security.html#_1-smart-debug-telemetry-pii-hardening","996":"/magma/v4/doc/9-plugins/ai.security.html#universal-environment-detection-zero-config-safety","997":"/magma/v4/doc/9-plugins/ai.security.html#automatic-pii-redaction","998":"/magma/v4/doc/9-plugins/ai.security.html#_2-tamper-resistant-proxy-introspection","999":"/magma/v4/doc/9-plugins/ai.security.html#_3-transport-security-network-hardening","1000":"/magma/v4/doc/9-plugins/ai.security.html#enforced-https-tls","1001":"/magma/v4/doc/9-plugins/ai.security.html#dynamic-manifest-host-verification","1002":"/magma/v4/doc/9-plugins/ai.security.html#_4-credential-isolation-byok-architecture","1003":"/magma/v4/doc/9-plugins/ai.security.html#automated-in-memory-key-redaction","1004":"/magma/v4/doc/9-plugins/ai.security.html#dynamic-secret-vaults-automated-key-rotation","1005":"/magma/v4/doc/9-plugins/ai.security.html#frontend-zero-storage-principle","1006":"/magma/v4/doc/9-plugins/ai.security.html#_5-ephemeral-processing-partitioned-caching-trial-gateway-data-handling","1007":"/magma/v4/doc/9-plugins/ai.security.html#local-libraries-zero-telemetry-architecture","1008":"/magma/v4/doc/9-plugins/ai.security.html#trial-sandbox-gateway-provider-tempo-data-handling-diagnostics","1009":"/magma/v4/doc/9-plugins/ai.security.html#partitioned-multi-tier-caching","1010":"/magma/v4/doc/9-plugins/ai.security.html#_6-schema-enforcement-hallucination-defense","1011":"/magma/v4/doc/9-plugins/ai.security.html#_7-residual-risks-threat-model-matrix","1012":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1013":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#_1-natural-language-booking-ambiguous-input-to-validated-tempo","1014":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#_2-converting-natural-language-recurrence-to-rfc-5545-rrule","1015":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#_3-conflict-free-slot-scheduling-around-busy-calendar-events","1016":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#_4-contextual-narrative-summaries-for-customer-notifications","1017":"/magma/v4/doc/9-plugins/ai.use-cases-and-patterns.html#_5-enterprise-pii-masking-air-gapped-fallback","1018":"/magma/v4/doc/9-plugins/batch.index.html#magmacomputing-tempo-plugin-batch","1019":"/magma/v4/doc/9-plugins/batch.index.html#🚀-installation-quickstart","1020":"/magma/v4/doc/9-plugins/batch.index.html#zero-boilerplate-auto-installation-side-effect-import","1021":"/magma/v4/doc/9-plugins/batch.index.html#📚-api-surface-catalog","1022":"/magma/v4/doc/9-plugins/batch.index.html#configuration-options-batchoptions","1023":"/magma/v4/doc/9-plugins/batch.index.html#supported-mutation-operations","1024":"/magma/v4/doc/9-plugins/batch.index.html#📖-architecture-specialized-guides","1025":"/magma/v4/doc/9-plugins/batch.index.html#📄-licensing","1026":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1027":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#_1-high-throughput-iot-telemetry-skew-normalization","1028":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#problem-statement","1029":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#architectural-solution","1030":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#production-implementation","1031":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#_2-financial-tick-data-backtesting-interval-rolling","1032":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#problem-statement-1","1033":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#architectural-solution-1","1034":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#_3-large-scale-csv-payroll-date-processing","1035":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#problem-statement-2","1036":"/magma/v4/doc/9-plugins/batch.use-cases-and-patterns.html#architectural-solution-2","1037":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#parallel-worker-pool-sharedarraybuffer-architecture","1038":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#dual-mode-execution-engine","1039":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#mode-a-lock-free-sharedarraybuffer-high-throughput","1040":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#mode-b-postmessage-structural-cloning-graceful-degradation","1041":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#worker-process-isolation-cli-flag-sanitization","1042":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#performance-trade-off-raw-epochs-vs-hydration","1043":"/magma/v4/doc/9-plugins/batch.worker-architecture.html#benchmark-guidance","1044":"/magma/v4/doc/9-plugins/celestial.astro.html#astronomical-seasons-solstices-equinoxes","1045":"/magma/v4/doc/9-plugins/celestial.astro.html#overview","1046":"/magma/v4/doc/9-plugins/celestial.astro.html#events-and-quarters","1047":"/magma/v4/doc/9-plugins/celestial.astro.html#astronomy-details","1048":"/magma/v4/doc/9-plugins/celestial.astro.html#specific-events","1049":"/magma/v4/doc/9-plugins/celestial.astro.html#standalone","1050":"/magma/v4/doc/9-plugins/celestial.index.html#magmacomputing-tempo-plugin-celestial","1051":"/magma/v4/doc/9-plugins/celestial.index.html#installation","1052":"/magma/v4/doc/9-plugins/celestial.index.html#documentation-guide","1053":"/magma/v4/doc/9-plugins/celestial.index.html#features-overview","1054":"/magma/v4/doc/9-plugins/celestial.index.html#geographic-coordinates-null-contract","1055":"/magma/v4/doc/9-plugins/celestial.index.html#quickstart","1056":"/magma/v4/doc/9-plugins/celestial.index.html#auto-installation-side-effect-import","1057":"/magma/v4/doc/9-plugins/celestial.index.html#licensing","1058":"/magma/v4/doc/9-plugins/celestial.lunar.html#lunar-ephemeris-phases-topocentric-position","1059":"/magma/v4/doc/9-plugins/celestial.lunar.html#_1-lunar-phase-cycles-t-term-moon-t-term-lunar","1060":"/magma/v4/doc/9-plugins/celestial.lunar.html#_2-hemisphere-aware-visual-emoji-lunar-emoji","1061":"/magma/v4/doc/9-plugins/celestial.lunar.html#_3-location-aware-horizon-transit-events","1062":"/magma/v4/doc/9-plugins/celestial.lunar.html#_4-real-time-topocentric-sky-position","1063":"/magma/v4/doc/9-plugins/celestial.lunar.html#_5-crescent-tilt-bright-limb-angle-lunar-crescenttiltdeg","1064":"/magma/v4/doc/9-plugins/celestial.lunar.html#_6-distance-apparent-size-supermoons-micromoons","1065":"/magma/v4/doc/9-plugins/celestial.lunar.html#_7-local-solar-lunar-eclipse-obscuration-lunar-eclipse-lunar-obscuration","1066":"/magma/v4/doc/9-plugins/celestial.solar.html#solar-day-cycles-ephemeris-apparent-solar-time","1067":"/magma/v4/doc/9-plugins/celestial.solar.html#solar-phase-states","1068":"/magma/v4/doc/9-plugins/celestial.solar.html#solar-noon","1069":"/magma/v4/doc/9-plugins/celestial.solar.html#apparent-solar-time","1070":"/magma/v4/doc/9-plugins/celestial.solar.html#elevation-dip","1071":"/magma/v4/doc/9-plugins/celestial.solar.html#solar-coordinates","1072":"/magma/v4/doc/9-plugins/celestial.solar.html#polar-regions","1073":"/magma/v4/doc/9-plugins/celestial.solar.html#twilight-windows","1074":"/magma/v4/doc/9-plugins/celestial.tidal.html#astronomical-tidal-mechanics-coastal-predictions","1075":"/magma/v4/doc/9-plugins/celestial.tidal.html#astronomical-calculations","1076":"/magma/v4/doc/9-plugins/celestial.tidal.html#tidal-states","1077":"/magma/v4/doc/9-plugins/celestial.tidal.html#king-tides","1078":"/magma/v4/doc/9-plugins/celestial.tidal.html#coastal-predictions","1079":"/magma/v4/doc/9-plugins/celestial.tidal.html#lunar-tidal-cycle","1080":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1081":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#_1-photovoltaic-pv-solar-inverter-battery-storage-orchestration","1082":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#_2-smart-agriculture-greenhouse-supplemental-lighting","1083":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#_3-maritime-shipping-coastal-keel-clearance-windows","1084":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#_4-drone-surveying-architectural-golden-hour-scheduling","1085":"/magma/v4/doc/9-plugins/celestial.use-cases-and-patterns.html#_5-wildlife-tracking-nocturnal-ecological-monitoring","1086":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#design-strategy-deliberate-omissions","1087":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#🏛️-part-a-the-token-modifier-design-strategy","1088":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_1-the-all-lowercase-principle-eliminating-the-capitalization-trap","1089":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_2-getter-to-token-symmetry-zero-context-switching","1090":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_3-composable-modifiers-vs-combinatorial-token-explosion","1091":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_4-braced-architecture-vs-literal-escaping-nightmares","1092":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#🚫-part-b-deliberate-omissions-architectural-boundaries","1093":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_1-non-iso-locale-week-numbering-years-moment-gggg-gg","1094":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_2-confusing-1–24-and-0–11-hour-systems-ldml-k-k","1095":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_3-duplicate-standalone-vs-format-inflections-ldml-llll-vs-mmmm-cccc-vs-eeee","1096":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_4-mnemonic-reference-date-formatting-go-time-format","1097":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#_5-hardcoded-business-fiscal-quarter-assumptions","1098":"/magma/v4/doc/9-plugins/dialects.design-philosophy-and-omissions.html#📊-summary-comparison","1099":"/magma/v4/doc/9-plugins/dialects.index.html#magmacomputing-tempo-plugin-dialects","1100":"/magma/v4/doc/9-plugins/dialects.index.html#🚀-installation-quickstart","1101":"/magma/v4/doc/9-plugins/dialects.index.html#registration","1102":"/magma/v4/doc/9-plugins/dialects.index.html#zero-boilerplate-auto-installation-side-effect-import","1103":"/magma/v4/doc/9-plugins/dialects.index.html#🔤-supported-dialects","1104":"/magma/v4/doc/9-plugins/dialects.index.html#📚-api-surface-catalog","1105":"/magma/v4/doc/9-plugins/dialects.index.html#📖-architecture-specialized-guides","1106":"/magma/v4/doc/9-plugins/dialects.index.html#⚡-performance-lazy-evaluation","1107":"/magma/v4/doc/9-plugins/dialects.index.html#📄-licensing","1108":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#migration-legacy-compatibility","1109":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#the-migration-challenge-token-traps-gotchas","1110":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#_1-the-year-trap-yyyy-vs-yyyy","1111":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#_2-month-vs-minute-mm-vs-mm-vs-mi","1112":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#_3-escaping-literals-quotes-vs-brackets","1113":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#automated-migration-engine-tempo-dialects-explain","1114":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#programmatic-mask-upgrades-in-build-pipelines","1115":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#exporting-dialect-models-tempo-dialects-export","1116":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#universal-cross-dialect-conversion-tempo-dialects-convert","1117":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#drop-in-api-compatibility-shims","1118":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#_1-luxon-drop-in-t-toformat","1119":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#_2-static-parsers-tempo-fromformat-tempo-fromformats","1120":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#performance-comparison-native-tempo-vs-dialects","1121":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#why-native-syntax-is-faster","1122":"/magma/v4/doc/9-plugins/dialects.migration-and-compatibility.html#recommended-migration-strategy","1123":"/magma/v4/doc/9-plugins/dialects.token-specification.html#token-specification-cross-ecosystem-matrix","1124":"/magma/v4/doc/9-plugins/dialects.token-specification.html#_1-interactive-dialect-token-navigator","1125":"/magma/v4/doc/9-plugins/dialects.token-specification.html#_2-core-standards-comparison-matrix","1126":"/magma/v4/doc/9-plugins/dialects.token-specification.html#_3-literal-text-escaping-rules","1127":"/magma/v4/doc/9-plugins/dialects.token-specification.html#a-unicode-ldml-luxon-ldml","1128":"/magma/v4/doc/9-plugins/dialects.token-specification.html#b-moment-js-day-js-moment","1129":"/magma/v4/doc/9-plugins/dialects.token-specification.html#c-posix-strftime-mysql-strftime-mysql","1130":"/magma/v4/doc/9-plugins/dialects.token-specification.html#d-net-c-dotnet","1131":"/magma/v4/doc/9-plugins/dialects.token-specification.html#e-excel-google-sheets-sheet","1132":"/magma/v4/doc/9-plugins/dialects.token-specification.html#f-native-tempo-core","1133":"/magma/v4/doc/9-plugins/dialects.token-specification.html#_4-ecosystem-specific-nuances","1134":"/magma/v4/doc/9-plugins/dialects.token-specification.html#a-context-sensitive-mm-in-spreadsheets","1135":"/magma/v4/doc/9-plugins/dialects.token-specification.html#b-standard-net-single-character-specifiers","1136":"/magma/v4/doc/9-plugins/dialects.token-specification.html#c-hour-normalization-24-00-midnight","1137":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1138":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#_1-heterogeneous-third-party-webhook-ingestion","1139":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#problem-statement","1140":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#architectural-solution","1141":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#production-implementation","1142":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#_2-enterprise-syslog-audit-trail-compliance-posix-strftime","1143":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#problem-statement-1","1144":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#architectural-solution-1","1145":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#_3-zero-downtime-gradual-modernization-pipeline","1146":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#problem-statement-2","1147":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#architectural-solution-2","1148":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#_4-cross-ecosystem-format-transpilation-convert-export","1149":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#problem-statement-3","1150":"/magma/v4/doc/9-plugins/dialects.use-cases-and-patterns.html#architectural-solution-3","1151":"/magma/v4/doc/9-plugins/finance.index.html#magmacomputing-tempo-plugin-finance","1152":"/magma/v4/doc/9-plugins/finance.index.html#installation","1153":"/magma/v4/doc/9-plugins/finance.index.html#usage","1154":"/magma/v4/doc/9-plugins/finance.index.html#auto-installation-side-effect-import","1155":"/magma/v4/doc/9-plugins/finance.index.html#licensing","1156":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#cultural-locale-synchronization","1157":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#_1-the-challenge-of-geographic-formatting","1158":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#_2-automatic-cultural-sync-t-geolocate-setlocale","1159":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#call-site-preference-priority","1160":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#_3-pure-cultural-locale-inference-resolveculturallocale","1161":"/magma/v4/doc/9-plugins/geo.cultural-sync.html#_4-internationalization-synergy-with-magmacomputing-library","1162":"/magma/v4/doc/9-plugins/geo.index.html#magmacomputing-tempo-plugin-geo","1163":"/magma/v4/doc/9-plugins/geo.index.html#installation","1164":"/magma/v4/doc/9-plugins/geo.index.html#architecture-namespacing","1165":"/magma/v4/doc/9-plugins/geo.index.html#auto-installation-side-effect-import","1166":"/magma/v4/doc/9-plugins/geo.index.html#documentation-guide","1167":"/magma/v4/doc/9-plugins/geo.index.html#which-method-should-i-choose","1168":"/magma/v4/doc/9-plugins/geo.index.html#comprehensive-tempo-geo-api-surface","1169":"/magma/v4/doc/9-plugins/geo.index.html#fluent-instance-methods","1170":"/magma/v4/doc/9-plugins/geo.index.html#quickstart-examples","1171":"/magma/v4/doc/9-plugins/geo.index.html#_1-fluent-oop-with-tempo-geo","1172":"/magma/v4/doc/9-plugins/geo.index.html#_2-reverse-geocoding-and-instance-enrichment","1173":"/magma/v4/doc/9-plugins/geo.index.html#security-immutability","1174":"/magma/v4/doc/9-plugins/geo.index.html#licensing","1175":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#pluggable-geocoding-provider-gateway","1176":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#_1-overview-geoprovider-interface","1177":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#_2-registering-a-provider","1178":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#a-global-static-registration-tempo-geo-setprovider","1179":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#b-plugin-installation-options","1180":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#c-call-site-override","1181":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#_3-forward-reverse-geocoding-examples","1182":"/magma/v4/doc/9-plugins/geo.provider-gateway.html#_4-built-in-caching-automatic-failover","1183":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#storage-multi-tenant-caching","1184":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#_1-ambient-stashing-24-hour-bounded-cache","1185":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#_2-multi-tenant-partitioning-keyoropts","1186":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#solution-a-keyed-partitioning","1187":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#solution-b-instance-level-scoping-recommended","1188":"/magma/v4/doc/9-plugins/geo.storage-and-caching.html#_3-server-ip-vs-client-location-operational-warnings","1189":"/magma/v4/doc/9-plugins/geo.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1190":"/magma/v4/doc/9-plugins/geo.use-cases-and-patterns.html#_1-multi-tenant-saas-cultural-locale-synchronization","1191":"/magma/v4/doc/9-plugins/geo.use-cases-and-patterns.html#_2-pluggable-resilient-geocoding-gateway-custom-provider","1192":"/magma/v4/doc/9-plugins/geo.use-cases-and-patterns.html#_3-multi-tenant-partitioned-geo-storage-24h-caching","1193":"/magma/v4/doc/9-plugins/geo.use-cases-and-patterns.html#_4-server-side-edge-middleware-request-localization","1194":"/magma/v4/doc/9-plugins/holidays.business-days.html#business-days-sla-arithmetic","1195":"/magma/v4/doc/9-plugins/holidays.business-days.html#determining-working-business-days","1196":"/magma/v4/doc/9-plugins/holidays.business-days.html#navigating-business-days","1197":"/magma/v4/doc/9-plugins/holidays.business-days.html#t-holidays-nextbusinessday-and-t-holidays-prevbusinessday","1198":"/magma/v4/doc/9-plugins/holidays.business-days.html#adding-business-days","1199":"/magma/v4/doc/9-plugins/holidays.business-days.html#t-holidays-addbusinessdays-amount-options","1200":"/magma/v4/doc/9-plugins/holidays.business-days.html#counting-business-days-between-dates","1201":"/magma/v4/doc/9-plugins/holidays.business-days.html#t-holidays-businessdaysuntil-target-options","1202":"/magma/v4/doc/9-plugins/holidays.business-days.html#sla-working-hours-calculation","1203":"/magma/v4/doc/9-plugins/holidays.business-days.html#t-holidays-workinghoursuntil-deadline-options","1204":"/magma/v4/doc/9-plugins/holidays.business-days.html#custom-work-hour-windows","1205":"/magma/v4/doc/9-plugins/holidays.business-days.html#cultural-locale-weekend-awareness","1206":"/magma/v4/doc/9-plugins/holidays.index.html#magmacomputing-tempo-plugin-holidays","1207":"/magma/v4/doc/9-plugins/holidays.index.html#key-features","1208":"/magma/v4/doc/9-plugins/holidays.index.html#installation","1209":"/magma/v4/doc/9-plugins/holidays.index.html#quickstart","1210":"/magma/v4/doc/9-plugins/holidays.index.html#topic-guides","1211":"/magma/v4/doc/9-plugins/holidays.index.html#license","1212":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#regional-calendars-dynamic-preloading","1213":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#supported-offline-built-in-calendars","1214":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#resolution-hierarchy-geo-cohesion","1215":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#dynamic-long-tail-preloading-storage-caching","1216":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#using-static-async-tempo-holidays-preload","1217":"/magma/v4/doc/9-plugins/holidays.regional-calendars.html#using-instance-method-t-holidays-preload","1218":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1219":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_1-multi-tenant-saas-sla-resolution-engine","1220":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#architecture-pattern","1221":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_2-financial-t-2-settlement-trade-value-dates","1222":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_3-payroll-automated-invoicing-preceding-vs-following-conventions","1223":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_4-hr-leave-balance-vacation-day-accounting","1224":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_5-corporate-calendar-overlays-floating-shutdowns","1225":"/magma/v4/doc/9-plugins/holidays.use-cases-and-patterns.html#_6-zero-latency-synchronous-resolution","1226":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#cristian-s-algorithm-precision-engineering","1227":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#_1-cristian-s-algorithm-over-http","1228":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#round-trip-time-rtt","1229":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#estimated-server-timestamp-at-reception","1230":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#clock-drift-offset","1231":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#uncertainty-window","1232":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#_2-sub-millisecond-precision-via-server-timing","1233":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#_3-statistical-jitter-rejection-filtering","1234":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#_4-exponential-moving-average-ema-smoothing","1235":"/magma/v4/doc/9-plugins/ntp.algorithms-and-precision.html#_5-monotonic-time-progression-with-zero-o-n-overhead","1236":"/magma/v4/doc/9-plugins/ntp.index.html#magmacomputing-tempo-plugin-ntp","1237":"/magma/v4/doc/9-plugins/ntp.index.html#installation","1238":"/magma/v4/doc/9-plugins/ntp.index.html#architecture-registration","1239":"/magma/v4/doc/9-plugins/ntp.index.html#plugin-installation","1240":"/magma/v4/doc/9-plugins/ntp.index.html#configuration-options-ntpsyncoptions","1241":"/magma/v4/doc/9-plugins/ntp.index.html#auto-installation-side-effect-import","1242":"/magma/v4/doc/9-plugins/ntp.index.html#documentation-guide","1243":"/magma/v4/doc/9-plugins/ntp.index.html#interactive-repl","1244":"/magma/v4/doc/9-plugins/ntp.index.html#comprehensive-api-reference","1245":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-now-timezone-string-tempo","1246":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-sync-endpoint-string-promise-clockdriftstate","1247":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-offset-number","1248":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-drift-clockdriftstate","1249":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-iscalibrated-boolean","1250":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-ntp-reset-void","1251":"/magma/v4/doc/9-plugins/ntp.index.html#tempo-tontptime-tempo","1252":"/magma/v4/doc/9-plugins/ntp.index.html#licensing","1253":"/magma/v4/doc/9-plugins/ntp.ticker-integration.html#ticker-integration-atomic-clocks","1254":"/magma/v4/doc/9-plugins/ntp.ticker-integration.html#_1-ntp-compensated-cadence-ntp-true","1255":"/magma/v4/doc/9-plugins/ntp.ticker-integration.html#_2-distributed-wall-clock-aligned-schedules","1256":"/magma/v4/doc/9-plugins/ntp.ticker-integration.html#_3-explicit-resource-management-lifecycle","1257":"/magma/v4/doc/9-plugins/ntp.ticker-integration.html#_4-fallback-behavior","1258":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1259":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#_1-anti-cheat-live-countdowns-flash-sales","1260":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#the-problem-with-uncalibrated-timers","1261":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#the-calibrated-solution","1262":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#_2-zero-overhead-passive-calibration-interceptfetch-origin-hardening","1263":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#trust-boundaries-origin-hardening","1264":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#production-ingestion-flow","1265":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#_3-distributed-telemetry-client-log-correlation","1266":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#_4-time-based-one-time-passwords-totp-2fa","1267":"/magma/v4/doc/9-plugins/ntp.use-cases-and-patterns.html#_5-drift-convergence-high-frequency-queries","1268":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#classical-fasti-lunar-anchors","1269":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#the-three-lunar-anchor-points","1270":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#inclusive-backward-counting-ante-diem","1271":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#leap-year-intercalation-the-bissextile-day","1272":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#ab-urbe-condita-auc-calculations","1273":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#consular-chronology-fasti-consulares","1274":"/magma/v4/doc/9-plugins/roman.calendar-mechanics.html#see-also","1275":"/magma/v4/doc/9-plugins/roman.index.html#magmacomputing-tempo-plugin-roman","1276":"/magma/v4/doc/9-plugins/roman.index.html#key-features","1277":"/magma/v4/doc/9-plugins/roman.index.html#installation-import-paths","1278":"/magma/v4/doc/9-plugins/roman.index.html#choose-your-import-path","1279":"/magma/v4/doc/9-plugins/roman.index.html#quickstart","1280":"/magma/v4/doc/9-plugins/roman.index.html#option-a-lean-core-plugin-zero-boilerplate","1281":"/magma/v4/doc/9-plugins/roman.index.html#option-b-full-consular-fasti-single-import","1282":"/magma/v4/doc/9-plugins/roman.index.html#option-c-explicit-plugin-registration","1283":"/magma/v4/doc/9-plugins/roman.index.html#api-reference","1284":"/magma/v4/doc/9-plugins/roman.index.html#tempo-toromanclassical-options-romancalculationoptions-classicalromandate","1285":"/magma/v4/doc/9-plugins/roman.index.html#tempo-toauc-number","1286":"/magma/v4/doc/9-plugins/roman.index.html#tempo-auc-number","1287":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-toclassical-date-options-classicalromandate","1288":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-fromclassical-anchor-anchormonth-anchoryear-relation-count-isbissextile-isjulian-year-month-day","1289":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-parse-input-string-options-romanparseoptions-tempo","1290":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-parsedate-input-string-options-romanparseoptions-parsedromandate","1291":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-getconsuls-year-number-readonly-string-undefined","1292":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-formatconsuls-year-number-style-ablative-nominative-string-undefined","1293":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-findconsuls-query-string-consularpair","1294":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-yeartoauc-year-number-era-ce-bce-number","1295":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-auctoyear-auc-number-format-astronomical-historical","1296":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-getnonesday-month-number-number","1297":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-getidesday-month-number-number","1298":"/magma/v4/doc/9-plugins/roman.index.html#tempo-roman-isleapyear-year-number-isjulian-boolean-boolean","1299":"/magma/v4/doc/9-plugins/roman.index.html#topic-guides","1300":"/magma/v4/doc/9-plugins/roman.index.html#license","1301":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#use-cases-production-patterns","1302":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#_1-digital-epigraphy-classical-inscription-parsing","1303":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#the-challenge","1304":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#implementation-pattern","1305":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#_2-numismatics-ancient-coin-provenance","1306":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#the-challenge-1","1307":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#implementation-pattern-1","1308":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#_3-academic-manuscript-dating-legal-charters","1309":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#the-challenge-2","1310":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#implementation-pattern-2","1311":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#_4-consular-dating-fasti-chronology","1312":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#the-challenge-3","1313":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#implementation-pattern-3","1314":"/magma/v4/doc/9-plugins/roman.use-cases-and-patterns.html#see-also","1315":"/magma/v4/doc/9-plugins/snap.index.html#magmacomputing-tempo-plugin-snap","1316":"/magma/v4/doc/9-plugins/snap.index.html#🚀-installation-quickstart","1317":"/magma/v4/doc/9-plugins/snap.index.html#zero-boilerplate-auto-installation-side-effect-import","1318":"/magma/v4/doc/9-plugins/snap.index.html#📚-api-surface-catalog","1319":"/magma/v4/doc/9-plugins/snap.index.html#supported-units-snapkey","1320":"/magma/v4/doc/9-plugins/snap.index.html#📖-architecture-specialized-guides","1321":"/magma/v4/doc/9-plugins/snap.index.html#📄-licensing","1322":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1323":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#_1-interactive-calendar-drag-and-drop-grid-snapping","1324":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#problem-statement","1325":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#architectural-solution","1326":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#production-implementation","1327":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#_2-high-frequency-metric-telemetry-downsampling-influxdb-prometheus","1328":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#problem-statement-1","1329":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#architectural-solution-1","1330":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#_3-multimedia-frame-boundary-alignment-60fps-25fps","1331":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#problem-statement-2","1332":"/magma/v4/doc/9-plugins/snap.use-cases-and-patterns.html#architectural-solution-2","1333":"/magma/v4/doc/9-plugins/spatial.geofencing.html#spatial-geofencing-bounding-boxes","1334":"/magma/v4/doc/9-plugins/spatial.geofencing.html#_1-circular-proximity-tempo-spatial-iswithin-iswithin-t-iswithin","1335":"/magma/v4/doc/9-plugins/spatial.geofencing.html#code-examples","1336":"/magma/v4/doc/9-plugins/spatial.geofencing.html#_2-rectangular-bounding-box-tempo-spatial-inboundingbox-inboundingbox-t-inboundingbox","1337":"/magma/v4/doc/9-plugins/spatial.geofencing.html#standard-geographic-bounding-box","1338":"/magma/v4/doc/9-plugins/spatial.geofencing.html#antimeridian-crossing-support","1339":"/magma/v4/doc/9-plugins/spatial.index.html#magmacomputing-tempo-plugin-spatial","1340":"/magma/v4/doc/9-plugins/spatial.index.html#installation","1341":"/magma/v4/doc/9-plugins/spatial.index.html#architecture-namespacing","1342":"/magma/v4/doc/9-plugins/spatial.index.html#auto-installation-side-effect-import","1343":"/magma/v4/doc/9-plugins/spatial.index.html#documentation-guide","1344":"/magma/v4/doc/9-plugins/spatial.index.html#comprehensive-tempo-spatial-api-surface","1345":"/magma/v4/doc/9-plugins/spatial.index.html#fluent-instance-methods","1346":"/magma/v4/doc/9-plugins/spatial.index.html#quickstart-examples","1347":"/magma/v4/doc/9-plugins/spatial.index.html#_1-great-circle-distance-bearing","1348":"/magma/v4/doc/9-plugins/spatial.index.html#_2-impossible-travel-anomaly-detection","1349":"/magma/v4/doc/9-plugins/spatial.index.html#license","1350":"/magma/v4/doc/9-plugins/spatial.solar-offset.html#natural-solar-time-offset","1351":"/magma/v4/doc/9-plugins/spatial.solar-offset.html#_1-natural-solar-time-vs-clock-time","1352":"/magma/v4/doc/9-plugins/spatial.solar-offset.html#_2-api-usage-tempo-spatial-solaroffset-t-spatialsolaroffset-solaroffset","1353":"/magma/v4/doc/9-plugins/spatial.solar-offset.html#_3-dual-tier-architecture-spatial-vs-celestial","1354":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#transit-velocity-impossible-travel-navigation","1355":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#_1-great-circle-distance-haversinedistance-tempo-spatial-distance","1356":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#supported-distance-units","1357":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#code-examples","1358":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#_2-compass-bearing-tempo-spatial-bearing-calculatebearing","1359":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#_3-geographic-midpoint-tempo-spatial-midpoint-calculatemidpoint","1360":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#_4-transit-velocity-speed-modeling-tempo-spatial-velocity","1361":"/magma/v4/doc/9-plugins/spatial.transit-and-navigation.html#_5-impossible-travel-anomaly-detection-tempo-spatial-isimpossibletravel","1362":"/magma/v4/doc/9-plugins/spatial.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1363":"/magma/v4/doc/9-plugins/spatial.use-cases-and-patterns.html#_1-zero-trust-security-impossible-travel-anomaly-detection","1364":"/magma/v4/doc/9-plugins/spatial.use-cases-and-patterns.html#_2-fleet-geofencing-depot-arrival-service-zone-boundaries","1365":"/magma/v4/doc/9-plugins/spatial.use-cases-and-patterns.html#_3-flight-route-planning-great-circle-distance-forward-azimuth","1366":"/magma/v4/doc/9-plugins/spatial.use-cases-and-patterns.html#_4-physical-solar-noon-vs-civil-timezone-offset","1367":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#lock-free-atomics-memory-architecture","1368":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#the-shared-memory-layout","1369":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#_1-master-clock-writer-atomicclock","1370":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#_2-lock-free-worker-reader-atomicreader","1371":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#dual-layer-lifecycle-management","1372":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#_1-native-timer-unreferencing-unref","1373":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#_2-explicit-deterministic-resource-management-using","1374":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#_3-gc-finalization-registry-safety-net","1375":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#browser-security-constraints-cross-origin-isolation","1376":"/magma/v4/doc/9-plugins/sync.atomic-architecture.html#environment-compatibility-matrix","1377":"/magma/v4/doc/9-plugins/sync.index.html#magmacomputing-tempo-plugin-sync","1378":"/magma/v4/doc/9-plugins/sync.index.html#🚀-installation-quickstart","1379":"/magma/v4/doc/9-plugins/sync.index.html#master-process-initializing-the-atomic-clock","1380":"/magma/v4/doc/9-plugins/sync.index.html#zero-boilerplate-auto-installation-side-effect-import","1381":"/magma/v4/doc/9-plugins/sync.index.html#worker-process-lock-free-reading","1382":"/magma/v4/doc/9-plugins/sync.index.html#📚-api-surface-catalog","1383":"/magma/v4/doc/9-plugins/sync.index.html#📖-architecture-specialized-guides","1384":"/magma/v4/doc/9-plugins/sync.index.html#📄-licensing","1385":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1386":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#_1-high-frequency-trading-hft-worker-thread-risk-cluster","1387":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#problem-statement","1388":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#architectural-solution","1389":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#production-implementation","1390":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#_2-authoritative-multiplayer-game-simulation-ticks","1391":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#problem-statement-1","1392":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#architectural-solution-1","1393":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#_3-real-time-audio-dsp-buffer-synchronization","1394":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#problem-statement-2","1395":"/magma/v4/doc/9-plugins/sync.use-cases-and-patterns.html#architectural-solution-2","1396":"/magma/v4/doc/9-plugins/ticker.index.html#magmacomputing-tempo-plugin-ticker","1397":"/magma/v4/doc/9-plugins/ticker.index.html#installation","1398":"/magma/v4/doc/9-plugins/ticker.index.html#architecture-registration","1399":"/magma/v4/doc/9-plugins/ticker.index.html#plugin-installation","1400":"/magma/v4/doc/9-plugins/ticker.index.html#auto-installation-side-effect-import","1401":"/magma/v4/doc/9-plugins/ticker.index.html#documentation-guide","1402":"/magma/v4/doc/9-plugins/ticker.index.html#comprehensive-ticker-api-surface","1403":"/magma/v4/doc/9-plugins/ticker.index.html#creation-tempo-ticker-intervaloroptions-callback","1404":"/magma/v4/doc/9-plugins/ticker.index.html#ticker-options-configuration","1405":"/magma/v4/doc/9-plugins/ticker.index.html#tickerinstance-object","1406":"/magma/v4/doc/9-plugins/ticker.index.html#static-ticker-namespace","1407":"/magma/v4/doc/9-plugins/ticker.index.html#quickstart-examples","1408":"/magma/v4/doc/9-plugins/ticker.index.html#_1-disposer-pattern-zero-leakage","1409":"/magma/v4/doc/9-plugins/ticker.index.html#_2-async-generator-stream","1410":"/magma/v4/doc/9-plugins/ticker.index.html#license","1411":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#intervals-scheduling-engines","1412":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_1-semantic-duration-intervals","1413":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#supported-shorthand-units","1414":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_2-calendar-term-driven-intervals","1415":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#boundary-snapping-vs-relative-shifting-1","1416":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_3-cron-expressions-standard-5-field-syntax","1417":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#passing-cron-strings","1418":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_4-rfc-5545-recurrence-rules-rrule","1419":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_5-virtual-clocks-seeding","1420":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_6-backwards-tickers-countdowns","1421":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_7-one-shot-timers-meeting-alerts","1422":"/magma/v4/doc/9-plugins/ticker.intervals-and-scheduling.html#_8-network-time-clock-drift-compensation-ntp-true","1423":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#event-streams-reactive-clocks","1424":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#_1-event-listeners-on","1425":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#event-reference","1426":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#_2-active-ticker-registry-telemetry-ticker-active","1427":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#snapshot-structure-ticker-snapshot","1428":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#_3-master-clock-synchronization-zero-drift-architecture","1429":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#a-reactive-ui-signals-preact-solid-vue","1430":"/magma/v4/doc/9-plugins/ticker.reactive-clocks-and-events.html#b-async-generator-multi-clock-stream-framework-agnostic","1431":"/magma/v4/doc/9-plugins/ticker.resource-management.html#resource-management-lifecycle","1432":"/magma/v4/doc/9-plugins/ticker.resource-management.html#_1-explicit-resource-management-using-await-using","1433":"/magma/v4/doc/9-plugins/ticker.resource-management.html#synchronous-disposer-using","1434":"/magma/v4/doc/9-plugins/ticker.resource-management.html#asynchronous-disposer-await-using","1435":"/magma/v4/doc/9-plugins/ticker.resource-management.html#_2-async-generator-streaming-for-await-of","1436":"/magma/v4/doc/9-plugins/ticker.resource-management.html#_3-programmatic-lifecycle-controls","1437":"/magma/v4/doc/9-plugins/ticker.resource-management.html#_4-bounded-termination-conditions","1438":"/magma/v4/doc/9-plugins/ticker.resource-management.html#a-pulse-count-limit-limit","1439":"/magma/v4/doc/9-plugins/ticker.resource-management.html#b-stop-boundary-until","1440":"/magma/v4/doc/9-plugins/ticker.resource-management.html#_5-dual-layer-lifecycle-architecture-gc-safety-net","1441":"/magma/v4/doc/9-plugins/ticker.resource-management.html#layer-1-deterministic-cleanup-using-stop","1442":"/magma/v4/doc/9-plugins/ticker.resource-management.html#layer-2-best-effort-gc-finalization-finalizationregistry","1443":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#production-use-cases-architectural-patterns","1444":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#_1-zero-drift-telemetry-heartbeat-loops","1445":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#_2-preventing-zombie-leaks-with-explicit-resource-management-using","1446":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#_3-streaming-financial-market-feeds-for-await-of","1447":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#_4-multi-timezone-market-opening-closing-schedules","1448":"/magma/v4/doc/9-plugins/ticker.use-cases-and-patterns.html#_5-mobile-laptop-sleep-recovery-catch-true","1449":"/magma/v4/src/plugin/extend/README.html#🛠️-tempo-prototype-extension-mixins-src-plugin-extend","1450":"/magma/v4/src/plugin/extend/README.html#🚫-why-barrel-index-ts-files-are-omitted","1451":"/magma/v4/src/plugin/extend/README.html#📦-how-to-import-mixins","1452":"/magma/v4/src/plugin/extend/README.html#✍️-how-to-author-a-prototype-mixin","1453":"/magma/v4/test/README.html#tempo-test-suite","1454":"/magma/v4/test/README.html#directory-structure","1455":"/magma/v4/test/README.html#running-tests","1456":"/magma/v4/test/README.html#all-tests","1457":"/magma/v4/test/README.html#specific-domain","1458":"/magma/v4/test/README.html#ci-simulation","1459":"/magma/v4/test/README.html#conventions"},"fieldIds":{"title":0,"titles":1,"text":2},"fieldLength":{"0":[3,1,39],"1":[3,3,37],"2":[3,3,1],"3":[1,6,31],"4":[1,6,12],"5":[1,6,16],"6":[2,3,70],"7":[3,3,57],"8":[4,3,53],"9":[3,1,79],"10":[2,1,114],"11":[4,1,58],"12":[4,4,85],"13":[2,1,32],"14":[4,1,45],"15":[4,1,27],"16":[4,1,15],"17":[2,1,11],"18":[2,1,1],"19":[2,2,23],"20":[3,2,25],"21":[3,5,34],"22":[3,5,46],"23":[2,5,50],"24":[8,1,60],"25":[6,8,1],"26":[3,12,50],"27":[6,12,74],"28":[4,12,35],"29":[5,12,24],"30":[7,8,35],"31":[3,13,34],"32":[6,13,32],"33":[2,1,31],"34":[3,2,124],"35":[9,2,22],"36":[1,11,12],"37":[6,11,18],"38":[5,11,29],"39":[2,2,49],"40":[1,4,10],"41":[5,2,53],"42":[7,7,68],"43":[10,7,215],"44":[6,7,114],"45":[6,2,99],"46":[7,2,69],"47":[3,2,40],"48":[8,2,51],"49":[2,1,14],"50":[3,2,16],"51":[2,2,1],"52":[10,4,31],"53":[5,4,8],"54":[10,4,23],"55":[10,4,10],"56":[2,4,27],"57":[2,2,1],"58":[8,4,33],"59":[3,4,36],"60":[3,4,15],"61":[3,2,1],"62":[4,5,45],"63":[7,5,61],"64":[3,5,69],"65":[6,5,16],"66":[4,5,19],"67":[3,2,1],"68":[5,5,26],"69":[7,5,66],"70":[4,2,1],"71":[5,6,65],"72":[7,6,29],"73":[2,6,35],"74":[3,2,1],"75":[2,5,33],"76":[4,5,152],"77":[2,5,57],"78":[11,5,111],"79":[1,2,1],"80":[5,3,10],"81":[4,3,17],"82":[5,3,13],"83":[5,1,65],"84":[4,5,33],"85":[4,5,30],"86":[2,5,1],"87":[4,7,50],"88":[6,7,38],"89":[8,7,123],"90":[5,7,31],"91":[3,7,21],"92":[3,1,32],"93":[4,3,68],"94":[4,6,64],"95":[5,3,60],"96":[10,3,89],"97":[2,13,77],"98":[10,3,56],"99":[4,12,48],"100":[2,1,33],"101":[2,2,58],"102":[8,2,214],"103":[9,10,45],"104":[7,10,26],"105":[5,10,38],"106":[3,10,29],"107":[2,13,70],"108":[2,13,22],"109":[5,13,136],"110":[5,2,68],"111":[3,2,52],"112":[5,5,71],"113":[7,5,47],"114":[4,5,69],"115":[2,5,79],"116":[6,2,105],"117":[2,8,230],"118":[4,2,39],"119":[7,2,114],"120":[4,9,73],"121":[9,2,90],"122":[4,2,26],"123":[7,6,61],"124":[8,6,105],"125":[8,6,104],"126":[8,6,16],"127":[4,13,55],"128":[4,13,65],"129":[4,2,106],"130":[3,1,19],"131":[6,3,76],"132":[3,8,39],"133":[4,3,35],"134":[2,6,41],"135":[5,3,29],"136":[4,8,21],"137":[3,3,286],"138":[3,6,454],"139":[3,6,103],"140":[4,6,68],"141":[9,3,33],"142":[4,12,73],"143":[5,12,40],"144":[4,12,75],"145":[7,12,79],"146":[5,3,182],"147":[4,3,113],"148":[3,1,63],"149":[4,3,53],"150":[3,3,109],"151":[3,3,41],"152":[6,3,76],"153":[4,3,20],"154":[6,3,96],"155":[3,3,63],"156":[2,1,36],"157":[2,2,128],"158":[2,4,128],"159":[2,4,85],"160":[5,2,29],"161":[2,2,111],"162":[3,4,44],"163":[3,4,59],"164":[5,4,75],"165":[3,2,76],"166":[2,5,45],"167":[1,1,62],"168":[3,1,24],"169":[8,3,52],"170":[8,3,82],"171":[3,3,37],"172":[1,1,12],"173":[3,2,44],"174":[3,2,53],"175":[2,1,13],"176":[2,3,38],"177":[2,3,42],"178":[2,3,24],"179":[2,3,38],"180":[2,3,36],"181":[3,1,64],"182":[3,3,20],"183":[3,3,31],"184":[3,3,19],"185":[3,6,36],"186":[6,9,74],"187":[8,9,15],"188":[9,15,49],"189":[11,15,55],"190":[8,15,44],"191":[3,6,159],"192":[1,3,56],"193":[4,3,19],"194":[5,7,29],"195":[5,7,55],"196":[3,1,30],"197":[6,3,56],"198":[5,8,88],"199":[5,8,89],"200":[4,3,23],"201":[2,6,39],"202":[3,6,91],"203":[11,6,94],"204":[14,16,89],"205":[8,6,123],"206":[5,3,26],"207":[2,7,36],"208":[3,7,42],"209":[2,7,25],"210":[5,3,42],"211":[5,8,34],"212":[5,3,13],"213":[4,8,68],"214":[6,9,69],"215":[7,8,83],"216":[8,15,66],"217":[3,15,35],"218":[5,15,36],"219":[4,8,116],"220":[6,11,57],"221":[8,11,79],"222":[3,8,66],"223":[6,8,55],"224":[4,8,79],"225":[4,12,31],"226":[8,3,49],"227":[4,11,85],"228":[5,3,72],"229":[2,1,95],"230":[4,1,81],"231":[2,4,41],"232":[4,4,43],"233":[4,4,141],"234":[4,4,51],"235":[7,4,74],"236":[3,4,66],"237":[3,1,31],"238":[5,3,19],"239":[5,3,34],"240":[2,3,131],"241":[2,5,21],"242":[3,3,42],"243":[2,3,100],"244":[3,5,12],"245":[3,3,45],"246":[5,3,60],"247":[6,3,82],"248":[2,3,37],"249":[2,1,31],"250":[4,2,73],"251":[3,2,54],"252":[2,2,1],"253":[6,4,16],"254":[6,4,11],"255":[6,4,14],"256":[6,4,23],"257":[6,4,18],"258":[7,10,19],"259":[7,10,17],"260":[7,10,41],"261":[2,2,94],"262":[6,2,93],"263":[4,1,48],"264":[4,4,43],"265":[4,4,98],"266":[8,8,125],"267":[4,4,43],"268":[4,4,58],"269":[7,4,75],"270":[5,11,91],"271":[3,4,99],"272":[5,7,33],"273":[4,1,99],"274":[3,4,110],"275":[5,4,41],"276":[4,4,179],"277":[2,4,1],"278":[3,6,41],"279":[2,6,36],"280":[3,6,57],"281":[7,6,128],"282":[8,6,80],"283":[6,4,76],"284":[3,4,16],"285":[5,7,94],"286":[4,7,44],"287":[4,7,24],"288":[3,4,54],"289":[6,7,57],"290":[7,7,62],"291":[5,7,92],"292":[2,4,51],"293":[7,4,59],"294":[3,1,46],"295":[2,3,71],"296":[3,3,130],"297":[3,3,73],"298":[3,5,84],"299":[2,1,1],"300":[1,2,130],"301":[4,2,89],"302":[2,2,24],"303":[4,4,40],"304":[4,4,42],"305":[4,4,52],"306":[5,4,49],"307":[3,2,37],"308":[2,2,19],"309":[5,3,23],"310":[6,3,25],"311":[7,3,39],"312":[6,2,29],"313":[2,8,94],"314":[2,8,34],"315":[5,8,101],"316":[3,8,41],"317":[5,8,82],"318":[5,2,25],"319":[3,6,51],"320":[2,6,32],"321":[9,6,83],"322":[5,2,53],"323":[4,7,78],"324":[3,7,111],"325":[3,7,59],"326":[5,2,230],"327":[7,2,58],"328":[3,1,40],"329":[2,3,42],"330":[2,3,27],"331":[2,5,93],"332":[5,5,41],"333":[5,10,65],"334":[9,10,70],"335":[7,10,65],"336":[5,5,56],"337":[4,3,26],"338":[3,7,46],"339":[3,7,33],"340":[3,3,43],"341":[2,3,50],"342":[4,1,45],"343":[2,4,23],"344":[2,5,27],"345":[2,5,23],"346":[2,5,22],"347":[2,5,12],"348":[2,5,21],"349":[2,4,23],"350":[2,5,25],"351":[3,5,94],"352":[3,5,27],"353":[2,5,17],"354":[2,5,16],"355":[2,5,39],"356":[4,4,23],"357":[3,7,102],"358":[3,7,54],"359":[6,7,86],"360":[2,7,39],"361":[6,1,98],"362":[6,6,86],"363":[6,6,138],"364":[4,6,69],"365":[5,10,152],"366":[8,6,48],"367":[7,11,133],"368":[8,11,64],"369":[7,11,38],"370":[3,11,164],"371":[6,6,67],"372":[4,11,58],"373":[2,11,52],"374":[3,1,36],"375":[1,3,70],"376":[2,4,28],"377":[1,3,63],"378":[3,1,43],"379":[6,3,16],"380":[6,8,39],"381":[6,8,61],"382":[6,8,33],"383":[3,3,46],"384":[4,3,15],"385":[4,7,36],"386":[4,7,27],"387":[6,3,71],"388":[3,3,80],"389":[3,3,48],"390":[2,1,35],"391":[2,2,13],"392":[4,4,18],"393":[3,4,62],"394":[4,4,42],"395":[3,4,27],"396":[3,4,27],"397":[3,4,24],"398":[2,2,33],"399":[3,2,64],"400":[3,1,19],"401":[4,3,1],"402":[4,7,191],"403":[3,3,81],"404":[4,3,61],"405":[7,3,29],"406":[3,3,86],"407":[7,3,140],"408":[7,3,59],"409":[4,10,94],"410":[3,10,46],"411":[5,3,37],"412":[4,8,75],"413":[6,3,35],"414":[4,9,71],"415":[8,3,40],"416":[4,11,132],"417":[4,3,14],"418":[4,7,100],"419":[4,7,71],"420":[6,3,14],"421":[2,9,61],"422":[5,9,52],"423":[2,3,55],"424":[7,1,76],"425":[5,7,67],"426":[6,7,76],"427":[3,10,119],"428":[1,10,26],"429":[6,7,95],"430":[3,1,44],"431":[2,3,64],"432":[4,3,13],"433":[6,5,25],"434":[8,5,29],"435":[6,5,24],"436":[2,3,1],"437":[3,5,67],"438":[3,5,50],"439":[1,3,78],"440":[5,3,93],"441":[4,1,32],"442":[4,4,66],"443":[3,4,1],"444":[6,7,63],"445":[7,7,46],"446":[3,4,86],"447":[5,4,47],"448":[1,9,59],"449":[2,9,56],"450":[3,9,92],"451":[3,11,131],"452":[4,1,49],"453":[6,4,89],"454":[3,8,35],"455":[3,8,26],"456":[2,8,85],"457":[6,4,43],"458":[5,8,56],"459":[4,8,21],"460":[4,8,19],"461":[6,8,93],"462":[4,4,32],"463":[3,7,31],"464":[8,7,73],"465":[6,14,90],"466":[7,4,64],"467":[9,4,35],"468":[4,11,136],"469":[6,11,118],"470":[3,1,55],"471":[5,3,73],"472":[6,3,75],"473":[8,3,92],"474":[5,3,27],"475":[2,8,66],"476":[9,3,52],"477":[6,3,119],"478":[7,3,25],"479":[4,3,108],"480":[4,1,24],"481":[3,4,64],"482":[3,4,43],"483":[3,4,55],"484":[4,4,43],"485":[3,4,24],"486":[6,4,49],"487":[3,4,24],"488":[6,1,38],"489":[6,6,103],"490":[5,6,36],"491":[4,10,46],"492":[5,6,29],"493":[6,6,37],"494":[6,6,27],"495":[2,12,29],"496":[4,6,28],"497":[4,6,24],"498":[6,1,52],"499":[4,6,16],"500":[3,9,55],"501":[4,9,45],"502":[4,9,56],"503":[4,6,103],"504":[7,6,93],"505":[6,6,82],"506":[5,1,49],"507":[3,5,64],"508":[4,5,1],"509":[8,8,44],"510":[4,8,56],"511":[3,8,43],"512":[6,8,39],"513":[5,8,87],"514":[4,5,105],"515":[5,5,106],"516":[4,1,103],"517":[5,4,64],"518":[6,4,76],"519":[5,4,130],"520":[8,4,137],"521":[4,1,1],"522":[3,4,132],"523":[3,4,1],"524":[5,7,43],"525":[4,7,44],"526":[7,7,54],"527":[5,7,37],"528":[1,4,34],"529":[6,1,31],"530":[3,6,1],"531":[4,8,54],"532":[5,8,37],"533":[6,8,25],"534":[3,6,47],"535":[6,1,26],"536":[8,6,63],"537":[9,6,47],"538":[7,6,43],"539":[6,6,55],"540":[6,1,23],"541":[7,6,89],"542":[2,13,32],"543":[9,6,55],"544":[5,6,48],"545":[3,11,22],"546":[6,6,45],"547":[6,1,16],"548":[9,6,39],"549":[6,1,29],"550":[3,6,12],"551":[7,9,24],"552":[7,9,30],"553":[3,6,12],"554":[4,9,9],"555":[7,9,17],"556":[4,6,57],"557":[10,6,14],"558":[3,14,25],"559":[3,14,83],"560":[6,6,67],"561":[7,6,40],"562":[10,6,27],"563":[5,15,32],"564":[2,15,23],"565":[3,15,61],"566":[7,6,1],"567":[4,11,35],"568":[2,15,14],"569":[3,15,23],"570":[6,6,1],"571":[4,12,42],"572":[2,12,36],"573":[4,6,35],"574":[2,1,48],"575":[2,2,21],"576":[5,1,1],"577":[7,5,1],"578":[2,10,31],"579":[2,10,9],"580":[1,10,26],"581":[1,10,12],"582":[1,10,12],"583":[7,5,1],"584":[2,10,16],"585":[2,10,9],"586":[5,1,1],"587":[7,5,1],"588":[2,10,48],"589":[1,10,11],"590":[1,10,15],"591":[7,5,1],"592":[2,10,30],"593":[2,10,18],"594":[1,10,20],"595":[6,5,1],"596":[2,9,25],"597":[1,9,30],"598":[1,9,12],"599":[7,5,1],"600":[2,10,19],"601":[1,10,14],"602":[1,10,12],"603":[1,10,7],"604":[5,1,1],"605":[7,5,1],"606":[2,11,83],"607":[1,11,29],"608":[7,5,1],"609":[2,11,31],"610":[1,11,29],"611":[7,5,1],"612":[2,11,30],"613":[2,11,23],"614":[1,11,18],"615":[7,5,1],"616":[5,11,71],"617":[7,11,100],"618":[3,11,23],"619":[7,5,1],"620":[2,10,21],"621":[2,10,24],"622":[1,10,22],"623":[1,10,13],"624":[7,5,1],"625":[4,11,75],"626":[5,11,40],"627":[3,11,33],"628":[7,5,1],"629":[4,11,33],"630":[4,11,32],"631":[5,11,75],"632":[7,5,1],"633":[3,11,44],"634":[5,11,63],"635":[5,11,36],"636":[7,5,1],"637":[3,11,98],"638":[7,5,1],"639":[2,11,52],"640":[1,11,24],"641":[7,5,1],"642":[3,11,78],"643":[4,11,44],"644":[6,11,91],"645":[5,11,24],"646":[7,5,1],"647":[3,11,61],"648":[4,11,56],"649":[5,11,70],"650":[7,5,1],"651":[3,10,82],"652":[7,5,1],"653":[3,10,51],"654":[4,10,31],"655":[4,10,26],"656":[7,5,1],"657":[3,10,28],"658":[7,5,1],"659":[3,10,35],"660":[3,10,22],"661":[4,10,33],"662":[6,5,1],"663":[3,9,29],"664":[3,9,26],"665":[3,9,39],"666":[5,9,40],"667":[6,9,54],"668":[4,9,46],"669":[5,9,47],"670":[7,5,1],"671":[4,11,38],"672":[4,11,37],"673":[3,11,14],"674":[7,5,17],"675":[3,10,27],"676":[3,10,22],"677":[3,10,16],"678":[4,10,31],"679":[3,10,21],"680":[4,10,38],"681":[4,10,31],"682":[4,10,24],"683":[3,10,22],"684":[4,10,40],"685":[5,1,1],"686":[7,5,1],"687":[8,11,46],"688":[4,11,31],"689":[6,11,48],"690":[7,11,36],"691":[7,11,30],"692":[9,11,39],"693":[7,5,1],"694":[7,11,35],"695":[3,11,50],"696":[7,11,33],"697":[3,11,23],"698":[7,5,1],"699":[8,10,84],"700":[7,5,1],"701":[4,11,58],"702":[5,11,93],"703":[7,5,1],"704":[4,11,42],"705":[3,11,53],"706":[7,5,1],"707":[4,11,76],"708":[3,11,47],"709":[5,11,104],"710":[7,5,1],"711":[4,11,89],"712":[3,11,56],"713":[7,5,1],"714":[3,11,30],"715":[7,5,1],"716":[7,11,57],"717":[3,11,33],"718":[7,5,1],"719":[7,11,33],"720":[7,11,37],"721":[7,5,1],"722":[7,11,68],"723":[7,11,49],"724":[3,11,49],"725":[7,5,1],"726":[3,11,45],"727":[7,5,1],"728":[7,11,61],"729":[4,11,55],"730":[7,5,1],"731":[7,11,68],"732":[4,11,52],"733":[7,5,1],"734":[7,10,93],"735":[4,10,46],"736":[7,5,1],"737":[7,10,109],"738":[3,10,116],"739":[4,10,62],"740":[7,5,1],"741":[6,10,60],"742":[6,5,1],"743":[4,10,39],"744":[3,10,43],"745":[7,5,1],"746":[4,11,42],"747":[4,11,73],"748":[3,11,24],"749":[7,5,1],"750":[4,11,89],"751":[4,11,53],"752":[3,11,85],"753":[7,5,1],"754":[4,11,83],"755":[3,11,51],"756":[6,5,1],"757":[4,10,88],"758":[4,10,45],"759":[7,10,39],"760":[3,10,43],"761":[5,1,1],"762":[7,5,1],"763":[6,11,122],"764":[6,11,1],"765":[9,17,50],"766":[6,17,60],"767":[5,17,55],"768":[10,17,61],"769":[7,17,51],"770":[7,5,1],"771":[6,11,157],"772":[6,11,1],"773":[8,17,81],"774":[9,17,39],"775":[7,17,107],"776":[8,17,124],"777":[4,17,24],"778":[7,17,67],"779":[7,5,1],"780":[6,11,32],"781":[4,11,1],"782":[5,15,65],"783":[7,5,1],"784":[6,11,23],"785":[5,11,1],"786":[10,16,71],"787":[5,16,58],"788":[6,16,34],"789":[6,5,1],"790":[6,9,24],"791":[5,9,1],"792":[8,14,83],"793":[9,14,30],"794":[7,5,1],"795":[6,10,23],"796":[5,10,1],"797":[9,15,25],"798":[7,15,46],"799":[7,5,1],"800":[5,10,18],"801":[4,10,1],"802":[6,14,48],"803":[7,5,1],"804":[6,10,29],"805":[5,10,1],"806":[9,15,77],"807":[10,15,30],"808":[9,15,24],"809":[7,5,1],"810":[6,10,29],"811":[5,10,1],"812":[8,15,67],"813":[7,5,1],"814":[6,11,26],"815":[5,11,1],"816":[7,16,48],"817":[11,16,84],"818":[8,16,27],"819":[10,16,15],"820":[6,5,1],"821":[6,10,18],"822":[5,10,1],"823":[10,15,32],"824":[7,15,30],"825":[5,15,19],"826":[7,5,1],"827":[6,11,31],"828":[5,11,1],"829":[8,16,101],"830":[5,16,52],"831":[8,16,77],"832":[7,16,47],"833":[3,11,58],"834":[6,5,1],"835":[6,10,35],"836":[4,10,110],"837":[6,10,1],"838":[8,16,47],"839":[9,16,42],"840":[10,16,28],"841":[9,16,31],"842":[11,16,35],"843":[5,10,16],"844":[4,1,15],"845":[2,4,49],"846":[2,4,33],"847":[4,4,14],"848":[5,8,36],"849":[7,8,35],"850":[6,4,66],"851":[4,4,28],"852":[4,1,28],"853":[9,4,67],"854":[8,12,104],"855":[7,12,90],"856":[7,12,195],"857":[3,12,69],"858":[6,4,36],"859":[4,8,78],"860":[11,8,165],"861":[5,4,57],"862":[6,7,51],"863":[7,7,63],"864":[7,7,68],"865":[8,7,62],"866":[8,7,57],"867":[6,4,124],"868":[3,9,31],"869":[5,1,90],"870":[2,5,65],"871":[4,5,117],"872":[4,5,66],"873":[3,5,1],"874":[4,8,36],"875":[4,8,48],"876":[3,8,35],"877":[4,8,25],"878":[8,8,84],"879":[6,1,53],"880":[2,6,60],"881":[4,6,117],"882":[4,6,70],"883":[3,6,1],"884":[4,9,63],"885":[4,9,55],"886":[6,9,32],"887":[4,9,34],"888":[7,1,69],"889":[2,7,98],"890":[4,7,133],"891":[4,7,78],"892":[3,7,1],"893":[6,10,37],"894":[4,10,50],"895":[5,10,43],"896":[4,10,35],"897":[6,1,64],"898":[2,6,59],"899":[4,6,129],"900":[4,6,34],"901":[3,6,1],"902":[4,9,52],"903":[6,9,40],"904":[5,9,51],"905":[4,9,30],"906":[5,1,46],"907":[4,5,60],"908":[5,7,74],"909":[7,7,108],"910":[4,5,116],"911":[5,9,46],"912":[5,9,106],"913":[5,1,100],"914":[3,5,7],"915":[8,5,49],"916":[6,13,37],"917":[6,17,20],"918":[6,13,53],"919":[3,5,132],"920":[5,8,88],"921":[4,5,101],"922":[5,5,90],"923":[1,5,20],"924":[6,1,23],"925":[4,6,67],"926":[3,10,47],"927":[4,10,49],"928":[5,6,1],"929":[3,10,39],"930":[3,10,50],"931":[5,10,47],"932":[3,10,84],"933":[6,10,87],"934":[6,6,133],"935":[4,6,50],"936":[5,6,119],"937":[3,6,137],"938":[2,8,153],"939":[6,1,82],"940":[2,6,48],"941":[5,6,30],"942":[3,10,112],"943":[3,6,2],"944":[6,6,1],"945":[7,11,52],"946":[6,11,81],"947":[8,11,60],"948":[7,11,93],"949":[6,11,51],"950":[7,11,108],"951":[5,1,66],"952":[4,5,9],"953":[3,8,99],"954":[7,5,152],"955":[9,5,204],"956":[10,5,1],"957":[7,14,48],"958":[4,14,100],"959":[3,5,78],"960":[7,1,20],"961":[2,7,45],"962":[3,7,67],"963":[4,7,40],"964":[3,7,35],"965":[4,7,35],"966":[5,1,34],"967":[4,5,13],"968":[9,9,74],"969":[6,9,47],"970":[5,5,85],"971":[2,5,29],"972":[5,5,179],"973":[5,5,101],"974":[3,5,70],"975":[6,5,49],"976":[3,5,38],"977":[3,5,29],"978":[8,5,133],"979":[4,5,37],"980":[4,5,43],"981":[6,1,33],"982":[2,6,74],"983":[6,6,62],"984":[7,6,38],"985":[5,6,58],"986":[2,6,84],"987":[7,1,44],"988":[2,7,76],"989":[4,7,91],"990":[2,11,7],"991":[5,11,33],"992":[4,7,58],"993":[4,7,97],"994":[4,1,56],"995":[7,4,48],"996":[7,10,59],"997":[3,10,121],"998":[5,4,123],"999":[6,4,1],"1000":[3,8,45],"1001":[4,8,45],"1002":[6,4,1],"1003":[5,8,34],"1004":[7,8,155],"1005":[4,8,79],"1006":[10,4,1],"1007":[5,13,50],"1008":[9,13,202],"1009":[4,13,80],"1010":[6,4,87],"1011":[7,4,206],"1012":[6,1,90],"1013":[9,6,93],"1014":[9,6,86],"1015":[9,6,80],"1016":[7,6,75],"1017":[8,6,85],"1018":[5,1,46],"1019":[4,5,58],"1020":[8,9,18],"1021":[4,5,48],"1022":[4,9,35],"1023":[3,9,33],"1024":[5,5,46],"1025":[2,5,23],"1026":[6,1,23],"1027":[7,6,1],"1028":[2,13,60],"1029":[2,13,53],"1030":[2,13,82],"1031":[8,6,1],"1032":[2,13,43],"1033":[2,13,74],"1034":[7,6,1],"1035":[2,13,47],"1036":[2,13,69],"1037":[6,1,29],"1038":[4,6,41],"1039":[8,10,98],"1040":[8,10,47],"1041":[7,6,87],"1042":[7,6,71],"1043":[2,13,21],"1044":[5,1,19],"1045":[4,5,54],"1046":[5,5,89],"1047":[8,5,53],"1048":[10,5,33],"1049":[3,5,40],"1050":[5,1,27],"1051":[1,5,7],"1052":[2,5,125],"1053":[2,5,101],"1054":[5,5,161],"1055":[1,5,141],"1056":[6,6,30],"1057":[1,5,20],"1058":[6,1,41],"1059":[9,6,88],"1060":[8,6,45],"1061":[7,6,53],"1062":[6,6,84],"1063":[10,6,80],"1064":[7,6,87],"1065":[11,6,84],"1066":[7,1,36],"1067":[9,7,153],"1068":[9,7,51],"1069":[10,7,94],"1070":[7,7,64],"1071":[8,7,105],"1072":[9,7,92],"1073":[4,7,30],"1074":[6,1,29],"1075":[4,6,55],"1076":[9,6,96],"1077":[9,6,56],"1078":[8,6,90],"1079":[7,6,30],"1080":[6,1,90],"1081":[9,6,109],"1082":[7,6,109],"1083":[8,6,120],"1084":[8,6,85],"1085":[7,6,96],"1086":[5,1,86],"1087":[8,5,11],"1088":[9,11,173],"1089":[8,11,124],"1090":[7,11,167],"1091":[7,11,116],"1092":[8,5,30],"1093":[11,10,102],"1094":[13,10,76],"1095":[12,10,79],"1096":[9,10,67],"1097":[6,10,91],"1098":[3,5,146],"1099":[5,1,69],"1100":[4,5,7],"1101":[1,9,53],"1102":[8,10,27],"1103":[3,5,177],"1104":[4,5,180],"1105":[5,5,101],"1106":[5,5,66],"1107":[2,5,23],"1108":[4,1,38],"1109":[7,4,22],"1110":[7,9,82],"1111":[7,9,46],"1112":[6,9,55],"1113":[7,4,119],"1114":[6,10,57],"1115":[7,4,73],"1116":[8,4,69],"1117":[5,4,23],"1118":[7,8,44],"1119":[8,8,39],"1120":[6,4,59],"1121":[5,10,48],"1122":[3,10,47],"1123":[6,1,75],"1124":[5,6,37],"1125":[5,6,288],"1126":[5,6,13],"1127":[7,11,38],"1128":[7,11,36],"1129":[7,11,39],"1130":[5,11,37],"1131":[6,11,49],"1132":[4,11,47],"1133":[4,6,1],"1134":[6,9,51],"1135":[6,9,56],"1136":[7,9,74],"1137":[6,1,24],"1138":[6,6,1],"1139":[2,12,63],"1140":[2,12,61],"1141":[2,12,98],"1142":[10,6,1],"1143":[2,15,58],"1144":[2,15,99],"1145":[6,6,1],"1146":[2,12,46],"1147":[2,12,148],"1148":[9,6,1],"1149":[2,14,64],"1150":[2,14,92],"1151":[5,1,15],"1152":[1,5,7],"1153":[1,5,33],"1154":[6,6,28],"1155":[1,5,20],"1156":[3,1,25],"1157":[6,3,69],"1158":[8,3,118],"1159":[4,10,24],"1160":[7,3,66],"1161":[6,3,28],"1162":[5,1,44],"1163":[1,5,7],"1164":[3,5,22],"1165":[6,8,10],"1166":[2,5,67],"1167":[6,5,68],"1168":[5,5,140],"1169":[3,9,39],"1170":[2,5,1],"1171":[6,7,67],"1172":[6,7,51],"1173":[3,5,51],"1174":[1,5,20],"1175":[4,1,28],"1176":[5,4,71],"1177":[4,4,1],"1178":[8,7,198],"1179":[4,7,14],"1180":[4,7,24],"1181":[6,4,65],"1182":[7,4,48],"1183":[5,1,23],"1184":[8,5,56],"1185":[6,5,42],"1186":[4,9,43],"1187":[7,9,27],"1188":[8,5,94],"1189":[6,1,92],"1190":[7,6,110],"1191":[8,6,98],"1192":[9,6,76],"1193":[7,6,70],"1194":[5,1,25],"1195":[4,5,70],"1196":[3,5,1],"1197":[6,6,56],"1198":[3,5,1],"1199":[6,6,48],"1200":[5,5,1],"1201":[6,8,31],"1202":[4,5,1],"1203":[6,8,80],"1204":[4,8,21],"1205":[4,5,58],"1206":[5,1,22],"1207":[2,5,96],"1208":[1,5,7],"1209":[1,5,74],"1210":[2,5,48],"1211":[1,5,23],"1212":[5,1,22],"1213":[5,5,217],"1214":[5,5,77],"1215":[7,5,53],"1216":[7,9,40],"1217":[7,9,29],"1218":[6,1,81],"1219":[7,6,77],"1220":[2,13,118],"1221":[8,6,119],"1222":[10,6,133],"1223":[8,6,125],"1224":[7,6,119],"1225":[5,6,55],"1226":[6,1,38],"1227":[6,6,37],"1228":[5,9,2],"1229":[7,9,12],"1230":[5,9,2],"1231":[4,9,9],"1232":[7,6,69],"1233":[6,6,61],"1234":[6,6,52],"1235":[9,6,45],"1236":[5,1,38],"1237":[1,5,7],"1238":[3,5,1],"1239":[2,8,43],"1240":[4,8,93],"1241":[6,8,22],"1242":[2,5,77],"1243":[2,5,67],"1244":[3,5,1],"1245":[5,8,14],"1246":[10,8,22],"1247":[4,8,14],"1248":[4,8,16],"1249":[4,8,14],"1250":[4,8,11],"1251":[3,8,16],"1252":[1,5,20],"1253":[5,1,23],"1254":[7,5,85],"1255":[6,5,71],"1256":[6,5,39],"1257":[3,5,41],"1258":[6,1,52],"1259":[8,6,41],"1260":[5,13,29],"1261":[3,13,48],"1262":[9,6,56],"1263":[5,14,93],"1264":[3,14,55],"1265":[7,6,87],"1266":[8,6,62],"1267":[7,6,48],"1268":[5,1,36],"1269":[5,5,99],"1270":[6,5,109],"1271":[6,5,99],"1272":[5,5,69],"1273":[5,5,98],"1274":[2,5,12],"1275":[5,1,32],"1276":[2,5,121],"1277":[4,5,7],"1278":[4,9,65],"1279":[1,5,1],"1280":[8,6,105],"1281":[8,6,53],"1282":[5,6,11],"1283":[2,5,1],"1284":[5,7,19],"1285":[3,7,11],"1286":[3,7,7],"1287":[6,7,19],"1288":[14,7,11],"1289":[7,7,25],"1290":[8,7,18],"1291":[9,7,17],"1292":[11,7,21],"1293":[7,7,14],"1294":[9,7,13],"1295":[10,7,13],"1296":[5,7,15],"1297":[5,7,15],"1298":[7,7,11],"1299":[2,5,30],"1300":[1,5,20],"1301":[5,1,25],"1302":[7,5,1],"1303":[2,11,47],"1304":[2,11,99],"1305":[6,5,1],"1306":[2,10,30],"1307":[2,10,74],"1308":[7,5,1],"1309":[2,11,34],"1310":[2,11,66],"1311":[6,5,1],"1312":[2,10,45],"1313":[2,10,96],"1314":[2,5,26],"1315":[5,1,54],"1316":[4,5,62],"1317":[8,9,26],"1318":[4,5,49],"1319":[4,9,83],"1320":[5,5,28],"1321":[2,5,23],"1322":[6,1,26],"1323":[8,6,1],"1324":[2,14,43],"1325":[2,14,47],"1326":[2,14,74],"1327":[9,6,1],"1328":[2,15,52],"1329":[2,15,135],"1330":[8,6,1],"1331":[2,14,54],"1332":[2,14,74],"1333":[5,1,20],"1334":[8,5,22],"1335":[2,13,67],"1336":[9,5,31],"1337":[4,13,48],"1338":[3,13,55],"1339":[5,1,47],"1340":[1,5,7],"1341":[3,5,29],"1342":[6,8,10],"1343":[2,5,64],"1344":[5,5,104],"1345":[3,9,55],"1346":[2,5,1],"1347":[6,7,48],"1348":[5,7,48],"1349":[1,5,23],"1350":[4,1,19],"1351":[6,4,58],"1352":[9,4,67],"1353":[7,4,71],"1354":[6,1,25],"1355":[9,6,32],"1356":[3,15,9],"1357":[2,15,54],"1358":[8,6,70],"1359":[8,6,49],"1360":[10,6,87],"1361":[9,6,88],"1362":[6,1,79],"1363":[8,6,147],"1364":[9,6,97],"1365":[10,6,78],"1366":[8,6,103],"1367":[6,1,58],"1368":[4,6,91],"1369":[6,9,57],"1370":[7,9,65],"1371":[4,6,33],"1372":[6,10,42],"1373":[7,10,38],"1374":[6,10,32],"1375":[6,6,35],"1376":[3,12,83],"1377":[5,1,64],"1378":[4,5,76],"1379":[6,9,33],"1380":[8,15,16],"1381":[5,9,52],"1382":[4,5,79],"1383":[5,5,49],"1384":[2,5,23],"1385":[6,1,22],"1386":[9,6,1],"1387":[2,15,49],"1388":[2,15,68],"1389":[2,15,107],"1390":[6,6,1],"1391":[2,12,46],"1392":[2,12,84],"1393":[7,6,1],"1394":[2,13,50],"1395":[2,13,69],"1396":[5,1,54],"1397":[1,5,7],"1398":[3,5,1],"1399":[2,8,11],"1400":[6,8,14],"1401":[2,5,89],"1402":[4,5,1],"1403":[6,9,31],"1404":[3,9,82],"1405":[2,9,67],"1406":[3,9,20],"1407":[2,5,1],"1408":[6,7,42],"1409":[4,7,28],"1410":[1,5,23],"1411":[4,1,34],"1412":[4,4,89],"1413":[3,7,46],"1414":[5,4,19],"1415":[8,8,79],"1416":[8,4,20],"1417":[3,12,74],"1418":[7,4,49],"1419":[5,4,59],"1420":[5,4,48],"1421":[7,4,89],"1422":[10,4,113],"1423":[5,1,27],"1424":[5,5,51],"1425":[2,9,34],"1426":[8,5,56],"1427":[4,12,53],"1428":[8,5,37],"1429":[8,13,72],"1430":[9,13,40],"1431":[4,1,29],"1432":[8,4,18],"1433":[4,9,40],"1434":[5,9,38],"1435":[8,4,55],"1436":[4,4,60],"1437":[4,4,10],"1438":[6,8,35],"1439":[5,8,37],"1440":[9,4,46],"1441":[8,11,41],"1442":[8,11,96],"1443":[6,1,102],"1444":[7,6,116],"1445":[10,6,105],"1446":[9,6,85],"1447":[8,6,92],"1448":[9,6,87],"1449":[9,1,18],"1450":[8,9,57],"1451":[5,9,28],"1452":[7,9,43],"1453":[3,1,16],"1454":[2,3,71],"1455":[2,3,1],"1456":[2,5,3],"1457":[2,5,16],"1458":[2,5,14],"1459":[1,3,73]},"averageFieldLength":[4.869863013698628,6.714383561643835,51.397945205479495],"storedFields":{"0":{"title":"Contributing to Tempo","titles":[]},"1":{"title":"🏗️ Project Architecture","titles":["Contributing to Tempo"]},"2":{"title":"🛠️ Local Development","titles":["Contributing to Tempo"]},"3":{"title":"Prerequisites","titles":["Contributing to Tempo","🛠️ Local Development"]},"4":{"title":"Setup","titles":["Contributing to Tempo","🛠️ Local Development"]},"5":{"title":"Building","titles":["Contributing to Tempo","🛠️ Local Development"]},"6":{"title":"🧪 Testing","titles":["Contributing to Tempo"]},"7":{"title":"📜 Coding Standards","titles":["Contributing to Tempo"]},"8":{"title":"🚀 Pull Request Process","titles":["Contributing to Tempo"]},"9":{"title":"⚡ Quick Start","titles":[]},"10":{"title":"📦 Installation","titles":[]},"11":{"title":"⏳ Why Tempo?","titles":[]},"12":{"title":"The Missing Domain Layer","titles":["⏳ Why Tempo?"]},"13":{"title":"📚 Documentation","titles":[]},"14":{"title":"🧰 The Tempo Ecosystem","titles":[]},"15":{"title":"💬 Contact & Support","titles":[]},"16":{"title":"🗳️ Feedback & Reactions","titles":[]},"17":{"title":"⚖️ License","titles":[]},"18":{"title":"Security Policy","titles":[]},"19":{"title":"Supported Versions","titles":["Security Policy"]},"20":{"title":"Reporting a Vulnerability","titles":["Security Policy"]},"21":{"title":"How to Report","titles":["Security Policy","Reporting a Vulnerability"]},"22":{"title":"What to Include","titles":["Security Policy","Reporting a Vulnerability"]},"23":{"title":"Response Timeline","titles":["Security Policy","Reporting a Vulnerability"]},"24":{"title":"🤖 AI & IDE Integration (llms.txt)","titles":[]},"25":{"title":"🚀 Quick Setup by IDE / Tool","titles":["🤖 AI & IDE Integration (llms.txt)"]},"26":{"title":"1. Cursor IDE","titles":["🤖 AI & IDE Integration (llms.txt)","🚀 Quick Setup by IDE / Tool"]},"27":{"title":"2. VS Code & GitHub Copilot","titles":["🤖 AI & IDE Integration (llms.txt)","🚀 Quick Setup by IDE / Tool"]},"28":{"title":"3. Antigravity AI Assistant","titles":["🤖 AI & IDE Integration (llms.txt)","🚀 Quick Setup by IDE / Tool"]},"29":{"title":"4. ChatGPT & Claude Projects","titles":["🤖 AI & IDE Integration (llms.txt)","🚀 Quick Setup by IDE / Tool"]},"30":{"title":"🛠️ Prompting AI for Custom Layout Extensions","titles":["🤖 AI & IDE Integration (llms.txt)"]},"31":{"title":"Sample Prompt:","titles":["🤖 AI & IDE Integration (llms.txt)","🛠️ Prompting AI for Custom Layout Extensions"]},"32":{"title":"Generated Code (Actual Tempo Syntax):","titles":["🤖 AI & IDE Integration (llms.txt)","🛠️ Prompting AI for Custom Layout Extensions"]},"33":{"title":"Installation Guide","titles":[]},"34":{"title":"Temporal Polyfill Note","titles":["Installation Guide"]},"35":{"title":"💻 Server & Bundlers (Node.js, Bun, Vite)","titles":["Installation Guide"]},"36":{"title":"Usage","titles":["Installation Guide","💻 Server & Bundlers (Node.js, Bun, Vite)"]},"37":{"title":"Node.js (with Native Temporal)","titles":["Installation Guide","💻 Server & Bundlers (Node.js, Bun, Vite)"]},"38":{"title":"Node.js (with Polyfill)","titles":["Installation Guide","💻 Server & Bundlers (Node.js, Bun, Vite)"]},"39":{"title":"🦕 Deno","titles":["Installation Guide"]},"40":{"title":"Usage","titles":["Installation Guide","🦕 Deno"]},"41":{"title":"🌐 Browser & Native Environments","titles":["Installation Guide"]},"42":{"title":"1. The Global Bundle (Standard Usage)","titles":["Installation Guide","🌐 Browser & Native Environments"]},"43":{"title":"2. Smart CDNs (The "Best-of-Both-Worlds")","titles":["Installation Guide","🌐 Browser & Native Environments"]},"44":{"title":"3. Static CDNs (Production-Ready)","titles":["Installation Guide","🌐 Browser & Native Environments"]},"45":{"title":"📦 Browser (Global Variable / Plugins)","titles":["Installation Guide"]},"46":{"title":"🧪 Granular "Lite" Builds (Advanced)","titles":["Installation Guide"]},"47":{"title":"🛡️ Versioning Policy","titles":["Installation Guide"]},"48":{"title":"🤖 AI & IDE Integration (llms.txt)","titles":["Installation Guide"]},"49":{"title":"Tempo Cookbook","titles":[]},"50":{"title":"Table of Contents","titles":["Tempo Cookbook"]},"51":{"title":"The Basics","titles":["Tempo Cookbook"]},"52":{"title":"How do I get the current date and time?","titles":["Tempo Cookbook","The Basics"]},"53":{"title":"Get "Now" in UTC","titles":["Tempo Cookbook","The Basics"]},"54":{"title":"How do I format a date for my UI?","titles":["Tempo Cookbook","The Basics"]},"55":{"title":"How do I check if a date is valid?","titles":["Tempo Cookbook","The Basics"]},"56":{"title":"Global Configuration","titles":["Tempo Cookbook","The Basics"]},"57":{"title":"Parsing Challenges","titles":["Tempo Cookbook"]},"58":{"title":"Parsing "Ambiguous" Digits (US vs UK)","titles":["Tempo Cookbook","Parsing Challenges"]},"59":{"title":"Handling Relative Strings","titles":["Tempo Cookbook","Parsing Challenges"]},"60":{"title":"Parsing Unix Timestamps","titles":["Tempo Cookbook","Parsing Challenges"]},"61":{"title":"Manipulation and Calculations","titles":["Tempo Cookbook"]},"62":{"title":"Add or Subtract Time","titles":["Tempo Cookbook","Manipulation and Calculations"]},"63":{"title":"Jumping to Boundaries (start, mid, end)","titles":["Tempo Cookbook","Manipulation and Calculations"]},"64":{"title":"Slick Object Mutations","titles":["Tempo Cookbook","Manipulation and Calculations"]},"65":{"title":"How long until a deadline? (until)","titles":["Tempo Cookbook","Manipulation and Calculations"]},"66":{"title":"Relative Time (since)","titles":["Tempo Cookbook","Manipulation and Calculations"]},"67":{"title":"Timezones and Locales","titles":["Tempo Cookbook"]},"68":{"title":"Convert Time to Another Zone","titles":["Tempo Cookbook","Timezones and Locales"]},"69":{"title":"Dynamic / Multi-Tenant Context (Functional Options)","titles":["Tempo Cookbook","Timezones and Locales"]},"70":{"title":"Business Logic and Terms","titles":["Tempo Cookbook"]},"71":{"title":"Is it the weekend?","titles":["Tempo Cookbook","Business Logic and Terms"]},"72":{"title":"What Fiscal Quarter are we in?","titles":["Tempo Cookbook","Business Logic and Terms"]},"73":{"title":"Hemispheric Seasons","titles":["Tempo Cookbook","Business Logic and Terms"]},"74":{"title":"Formatting and Localization","titles":["Tempo Cookbook"]},"75":{"title":"Semantic Formatting","titles":["Tempo Cookbook","Formatting and Localization"]},"76":{"title":"Format Modifiers & Localization","titles":["Tempo Cookbook","Formatting and Localization"]},"77":{"title":"Ticker Plugin","titles":["Tempo Cookbook","Formatting and Localization"]},"78":{"title":"Format & Parse Dialects Plugin (Moment, Luxon, SQL, POSIX, PHP)","titles":["Tempo Cookbook","Formatting and Localization"]},"79":{"title":"Interoperability","titles":["Tempo Cookbook"]},"80":{"title":"Converting to / from Native Date","titles":["Tempo Cookbook","Interoperability"]},"81":{"title":"Converting to Temporal Objects","titles":["Tempo Cookbook","Interoperability"]},"82":{"title":"Sorting an array of Tempos","titles":["Tempo Cookbook","Interoperability"]},"83":{"title":"Interactive REPL & Feature Showcase","titles":[]},"84":{"title":"🎨 Interactive Feature Showcase","titles":["Interactive REPL & Feature Showcase"]},"85":{"title":"⚡ Freeform Code REPL","titles":["Interactive REPL & Feature Showcase"]},"86":{"title":"Key Capabilities","titles":["Interactive REPL & Feature Showcase"]},"87":{"title":"1. Preloaded Official Plugins","titles":["Interactive REPL & Feature Showcase","Key Capabilities"]},"88":{"title":"2. Dynamic Plugin Loading & Presets","titles":["Interactive REPL & Feature Showcase","Key Capabilities"]},"89":{"title":"3. AI Semantic Parsing & Natural Language Scheduling","titles":["Interactive REPL & Feature Showcase","Key Capabilities"]},"90":{"title":"4. Shareable Snippets & Presets","titles":["Interactive REPL & Feature Showcase","Key Capabilities"]},"91":{"title":"5. Keyboard Shortcuts","titles":["Interactive REPL & Feature Showcase","Key Capabilities"]},"92":{"title":"Cache Management Guide","titles":[]},"93":{"title":"🏛️ Centralized Cache Architecture","titles":["Cache Management Guide"]},"94":{"title":"Cache Topology & Configuration","titles":["Cache Management Guide","🏛️ Centralized Cache Architecture"]},"95":{"title":"📖 Seeding & Appending Glossaries","titles":["Cache Management Guide"]},"96":{"title":"💡 When to Use What: Glossary vs. Alias vs. Snippet/Layout","titles":["Cache Management Guide"]},"97":{"title":"Decision Tree","titles":["Cache Management Guide","💡 When to Use What: Glossary vs. Alias vs. Snippet/Layout"]},"98":{"title":"🤖 AI Plugin Cache Integration (@magmacomputing/tempo-plugin-ai)","titles":["Cache Management Guide"]},"99":{"title":"Two-Tier Resolution Architecture","titles":["Cache Management Guide","🤖 AI Plugin Cache Integration (@magmacomputing/tempo-plugin-ai)"]},"100":{"title":"Configuration Guide","titles":[]},"101":{"title":"Precedence Hierarchy","titles":["Configuration Guide"]},"102":{"title":"🏆 Best Practice: The tempo.config.ts Pattern","titles":["Configuration Guide"]},"103":{"title":"Server / Node.js Entry Point (Zero-Config Discovery)","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern"]},"104":{"title":"Bundled Frontend Entry Point (Vite / Webpack)","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern"]},"105":{"title":"Cascading Configurations ("extends")","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern"]},"106":{"title":"Benefits vs. Drawbacks","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern"]},"107":{"title":"🌟 Benefits","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern","Benefits vs. Drawbacks"]},"108":{"title":"⚠️ Drawbacks","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern","Benefits vs. Drawbacks"]},"109":{"title":"🛑 Security & Reliability Bounds","titles":["Configuration Guide","🏆 Best Practice: The tempo.config.ts Pattern","Benefits vs. Drawbacks"]},"110":{"title":"1. Persistent Configuration ($Tempo)","titles":["Configuration Guide"]},"111":{"title":"2. Global Discovery","titles":["Configuration Guide"]},"112":{"title":"Pre-Bootstrap Discovery (globalThis)","titles":["Configuration Guide","2. Global Discovery"]},"113":{"title":"Explicit Runtime Registration (Not Global Discovery)","titles":["Configuration Guide","2. Global Discovery"]},"114":{"title":"Security and Ergonomics Notes","titles":["Configuration Guide","2. Global Discovery"]},"115":{"title":"Discovery Contract","titles":["Configuration Guide","2. Global Discovery"]},"116":{"title":"3. Explicit Initialization (Tempo.init)","titles":["Configuration Guide"]},"117":{"title":"Available Options","titles":["Configuration Guide","3. Explicit Initialization (Tempo.init)"]},"118":{"title":"4. Instance-Level Overrides","titles":["Configuration Guide"]},"119":{"title":"4.1 Dynamic & Functional Context Evaluation","titles":["Configuration Guide"]},"120":{"title":"Determinism and Immutability Guarantees","titles":["Configuration Guide","4.1 Dynamic & Functional Context Evaluation"]},"121":{"title":"4.2 Geographic Coordinates & Location Configuration (geo)","titles":["Configuration Guide"]},"122":{"title":"5. Advanced Parsing Rules","titles":["Configuration Guide"]},"123":{"title":"📅 5.1 Custom Events and Periods","titles":["Configuration Guide","5. Advanced Parsing Rules"]},"124":{"title":"⚡ 5.2 Deferring Initialization (mode: \'defer\')","titles":["Configuration Guide","5. Advanced Parsing Rules"]},"125":{"title":"🧹 5.3 Noise Word Filtering (ignore)","titles":["Configuration Guide","5. Advanced Parsing Rules"]},"126":{"title":"🚀 5.4 Parse Planner & Pre-filtering","titles":["Configuration Guide","5. Advanced Parsing Rules"]},"127":{"title":"planner.preFilter (Boolean)","titles":["Configuration Guide","5. Advanced Parsing Rules","🚀 5.4 Parse Planner & Pre-filtering"]},"128":{"title":"planner.layoutOrder (Array)","titles":["Configuration Guide","5. Advanced Parsing Rules","🚀 5.4 Parse Planner & Pre-filtering"]},"129":{"title":"📊 Summary of Tiers","titles":["Configuration Guide"]},"130":{"title":"Smart Formatting Guide","titles":[]},"131":{"title":"🚀 Standalone Formatting (Zero-Overhead)","titles":["Smart Formatting Guide"]},"132":{"title":"Supported Input Types","titles":["Smart Formatting Guide","🚀 Standalone Formatting (Zero-Overhead)"]},"133":{"title":"🏗️ Class-Based Formatting","titles":["Smart Formatting Guide"]},"134":{"title":"Named Formats","titles":["Smart Formatting Guide","🏗️ Class-Based Formatting"]},"135":{"title":"🧩 Modularity: Core vs. Full","titles":["Smart Formatting Guide"]},"136":{"title":"Enabling Formatting in Core","titles":["Smart Formatting Guide","🧩 Modularity: Core vs. Full"]},"137":{"title":"🔠 Supported Tokens","titles":["Smart Formatting Guide"]},"138":{"title":"🎛️ Token Modifiers","titles":["Smart Formatting Guide","🔠 Supported Tokens"]},"139":{"title":"🔄 Automatic Meridiem","titles":["Smart Formatting Guide","🔠 Supported Tokens"]},"140":{"title":"📝 Common Formatting Examples","titles":["Smart Formatting Guide","🔠 Supported Tokens"]},"141":{"title":"📍 Dynamic Namespace & Spatial Tokens ({namespace.key})","titles":["Smart Formatting Guide"]},"142":{"title":"Geographic Tokens ({geo.*})","titles":["Smart Formatting Guide","📍 Dynamic Namespace & Spatial Tokens ({namespace.key})"]},"143":{"title":"Custom & Plugin Namespace Tokens","titles":["Smart Formatting Guide","📍 Dynamic Namespace & Spatial Tokens ({namespace.key})"]},"144":{"title":"Modifiers & Graceful Fallback","titles":["Smart Formatting Guide","📍 Dynamic Namespace & Spatial Tokens ({namespace.key})"]},"145":{"title":"🌐 Hierarchical Localization ({namespace.key:locale})","titles":["Smart Formatting Guide","📍 Dynamic Namespace & Spatial Tokens ({namespace.key})"]},"146":{"title":"🌍 Complex Native Intl Formatting","titles":["Smart Formatting Guide"]},"147":{"title":"🛠️ Custom Format Tokens","titles":["Smart Formatting Guide"]},"148":{"title":"🧲 Core Getters","titles":[]},"149":{"title":"⚡ Native Temporal Gateway","titles":["🧲 Core Getters"]},"150":{"title":"📅 Date Properties","titles":["🧲 Core Getters"]},"151":{"title":"⏱️ Time Properties","titles":["🧲 Core Getters"]},"152":{"title":"🗓️ ISO Week & Day Alignments","titles":["🧲 Core Getters"]},"153":{"title":"🔤 Named String Representations","titles":["🧲 Core Getters"]},"154":{"title":"🌍 Regional, Timezone & System Properties","titles":["🧲 Core Getters"]},"155":{"title":"🎛️ Metadata Properties","titles":["🧲 Core Getters"]},"156":{"title":"Duration Logic","titles":[]},"157":{"title":"Calculating Durations","titles":["Duration Logic"]},"158":{"title":".until()","titles":["Duration Logic","Calculating Durations"]},"159":{"title":".since()","titles":["Duration Logic","Calculating Durations"]},"160":{"title":"The Duration Object (EDO)","titles":["Duration Logic"]},"161":{"title":"Intelligent Balancing","titles":["Duration Logic"]},"162":{"title":"Strict Calendar Math","titles":["Duration Logic","Intelligent Balancing"]},"163":{"title":"Nominal (Commercial) Math","titles":["Duration Logic","Intelligent Balancing"]},"164":{"title":"Balancing Downwards (Un-balancing)","titles":["Duration Logic","Intelligent Balancing"]},"165":{"title":"Formatting Absolute Durations","titles":["Duration Logic"]},"166":{"title":"Global Configuration","titles":["Duration Logic","Formatting Absolute Durations"]},"167":{"title":"Interval","titles":[]},"168":{"title":"Instantiating an Interval","titles":["Interval"]},"169":{"title":"1. The Ergonomic Approach (Attached to Tempo)","titles":["Interval","Instantiating an Interval"]},"170":{"title":"2. The Purist Approach (Tree-Shakeable Export)","titles":["Interval","Instantiating an Interval"]},"171":{"title":"Open-Ended Boundaries","titles":["Interval","Instantiating an Interval"]},"172":{"title":"Properties","titles":["Interval"]},"173":{"title":"start & end","titles":["Interval","Properties"]},"174":{"title":"startNs & endNs","titles":["Interval","Properties"]},"175":{"title":"Set Operations","titles":["Interval"]},"176":{"title":"overlaps()","titles":["Interval","Set Operations"]},"177":{"title":"contains()","titles":["Interval","Set Operations"]},"178":{"title":"abuts()","titles":["Interval","Set Operations"]},"179":{"title":"intersection()","titles":["Interval","Set Operations"]},"180":{"title":"union()","titles":["Interval","Set Operations"]},"181":{"title":"Mutation & Math","titles":[]},"182":{"title":"The .add() Method","titles":["Mutation & Math"]},"183":{"title":"The .subtract() Method","titles":["Mutation & Math"]},"184":{"title":"The .set() Method","titles":["Mutation & Math"]},"185":{"title":"Navigating to Boundaries","titles":["Mutation & Math","The .set() Method"]},"186":{"title":"Week Boundaries & Dedicated ISO Invariance","titles":["Mutation & Math","The .set() Method","Navigating to Boundaries"]},"187":{"title":"ISO Week & ISO Year Mutation (woy, yow)","titles":["Mutation & Math","The .set() Method","Navigating to Boundaries"]},"188":{"title":"1. Numeric ISO Week Assignment (woy, isoWeek, isoweek)","titles":["Mutation & Math","The .set() Method","Navigating to Boundaries","ISO Week & ISO Year Mutation (woy, yow)"]},"189":{"title":"2. Numeric ISO Year Assignment & Shifting (yow, isoYear, isoyear)","titles":["Mutation & Math","The .set() Method","Navigating to Boundaries","ISO Week & ISO Year Mutation (woy, yow)"]},"190":{"title":"3. ISO Year Boundaries (start, mid, end)","titles":["Mutation & Math","The .set() Method","Navigating to Boundaries","ISO Week & ISO Year Mutation (woy, yow)"]},"191":{"title":"Slick Object Mutations","titles":["Mutation & Math","The .set() Method"]},"192":{"title":"Chainability","titles":["Mutation & Math"]},"193":{"title":"Relational vs. Navigation Shifting","titles":["Mutation & Math"]},"194":{"title":"1. Navigation Mode (String)","titles":["Mutation & Math","Relational vs. Navigation Shifting"]},"195":{"title":"2. Relational Mode (Object)","titles":["Mutation & Math","Relational vs. Navigation Shifting"]},"196":{"title":"Smart Parsing Guide","titles":[]},"197":{"title":"🚀 Standalone Parsing (Zero-Overhead)","titles":["Smart Parsing Guide"]},"198":{"title":"Why use Standalone Parse?","titles":["Smart Parsing Guide","🚀 Standalone Parsing (Zero-Overhead)"]},"199":{"title":"⚠️ Standalone vs. Class-Based","titles":["Smart Parsing Guide","🚀 Standalone Parsing (Zero-Overhead)"]},"200":{"title":"🏗️ Class-Based Parsing","titles":["Smart Parsing Guide"]},"201":{"title":"Supported Formats","titles":["Smart Parsing Guide","🏗️ Class-Based Parsing"]},"202":{"title":"Historical Era Parsing","titles":["Smart Parsing Guide","🏗️ Class-Based Parsing"]},"203":{"title":"📆 Ordinals & Nth Parsing ("3rd Wednesday of October")","titles":["Smart Parsing Guide","🏗️ Class-Based Parsing"]},"204":{"title":"💡 When to use Native Ordinal Parsing vs. @magmacomputing/tempo-plugin-ai (parseAI)","titles":["Smart Parsing Guide","🏗️ Class-Based Parsing","📆 Ordinals & Nth Parsing ("3rd Wednesday of October")"]},"205":{"title":"🎭 Structured Mask & Wildcard Parsing ({format: \'...\'})","titles":["Smart Parsing Guide","🏗️ Class-Based Parsing"]},"206":{"title":"🔢 Numeric & Epoch Parsing","titles":["Smart Parsing Guide"]},"207":{"title":"Unit Selection","titles":["Smart Parsing Guide","🔢 Numeric & Epoch Parsing"]},"208":{"title":"Smart Epoch Detection","titles":["Smart Parsing Guide","🔢 Numeric & Epoch Parsing"]},"209":{"title":"Fractional Precision","titles":["Smart Parsing Guide","🔢 Numeric & Epoch Parsing"]},"210":{"title":"🧩 Modularity: Core vs. Full","titles":["Smart Parsing Guide"]},"211":{"title":"Enabling Smart Parsing in Core","titles":["Smart Parsing Guide","🧩 Modularity: Core vs. Full"]},"212":{"title":"🌍 Internationalization, TimeZone & Locale","titles":["Smart Parsing Guide"]},"213":{"title":"TimeZone & Offset Parsing","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"214":{"title":"Registering a Custom Leading Timezone Layout","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","TimeZone & Offset Parsing"]},"215":{"title":"US-Style Dates (MM/DD/YYYY)","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"216":{"title":"Parsing "Ambiguous" Digits (6 vs 8)","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","US-Style Dates (MM/DD/YYYY)"]},"217":{"title":"Manual Resolution Override","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","US-Style Dates (MM/DD/YYYY)"]},"218":{"title":"Customizing the MONTH_DAY Registry","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","US-Style Dates (MM/DD/YYYY)"]},"219":{"title":"Internationalized Parsing (Locales)","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"220":{"title":"How it Works & Accent Normalization","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","Internationalized Parsing (Locales)"]},"221":{"title":"⚠️ Current Limitations (What is NOT Available)","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","Internationalized Parsing (Locales)"]},"222":{"title":"Localized Parsing Modifiers","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"223":{"title":"Custom Aliases (Events & Periods)","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"224":{"title":"🧠 Functional Alias Context","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale"]},"225":{"title":"Example: Complex Functional Alias","titles":["Smart Parsing Guide","🌍 Internationalization, TimeZone & Locale","🧠 Functional Alias Context"]},"226":{"title":"📍 Geographic Context & Coordinates (geo Option)","titles":["Smart Parsing Guide"]},"227":{"title":"Deterministic Normalization & Validation","titles":["Smart Parsing Guide","📍 Geographic Context & Coordinates (geo Option)"]},"228":{"title":"🛡️ Performance: The Master Guard","titles":["Smart Parsing Guide"]},"229":{"title":"Plugin Ecosystem","titles":[]},"230":{"title":"Creating a Custom Plugin","titles":[]},"231":{"title":"The Goal","titles":["Creating a Custom Plugin"]},"232":{"title":"1. The definePlugin Factory","titles":["Creating a Custom Plugin"]},"233":{"title":"2. Extending the Prototype","titles":["Creating a Custom Plugin"]},"234":{"title":"3. TypeScript Module Augmentation","titles":["Creating a Custom Plugin"]},"235":{"title":"4. Packing it as a Configurable Module","titles":["Creating a Custom Plugin"]},"236":{"title":"Consuming the Plugin","titles":["Creating a Custom Plugin"]},"237":{"title":"Layout Patterns Guide","titles":[]},"238":{"title":"What is a Snippet?","titles":["Layout Patterns Guide"]},"239":{"title":"What is a Layout?","titles":["Layout Patterns Guide"]},"240":{"title":"Available Snippets","titles":["Layout Patterns Guide"]},"241":{"title":"Composite Snippets","titles":["Layout Patterns Guide","Available Snippets"]},"242":{"title":"Built-in Layouts","titles":["Layout Patterns Guide"]},"243":{"title":"Customizing Layouts","titles":["Layout Patterns Guide"]},"244":{"title":"Instance-Specific Layout","titles":["Layout Patterns Guide","Customizing Layouts"]},"245":{"title":"Advanced Capture Groups","titles":["Layout Patterns Guide"]},"246":{"title":"Prototyping with Tempo.regexp()","titles":["Layout Patterns Guide"]},"247":{"title":"🤖 AI & LLM Layout Prompting","titles":["Layout Patterns Guide"]},"248":{"title":"Professional Services","titles":["Layout Patterns Guide"]},"249":{"title":"Tempo Modularity","titles":[]},"250":{"title":"Module Activation Quick Guide","titles":["Tempo Modularity"]},"251":{"title":"Core vs. Full","titles":["Tempo Modularity"]},"252":{"title":"Available Modules","titles":["Tempo Modularity"]},"253":{"title":"Duration Module (@magmacomputing/tempo/duration)","titles":["Tempo Modularity","Available Modules"]},"254":{"title":"Format Module (@magmacomputing/tempo/format)","titles":["Tempo Modularity","Available Modules"]},"255":{"title":"Mutate Module (@magmacomputing/tempo/mutate)","titles":["Tempo Modularity","Available Modules"]},"256":{"title":"Parse Module (@magmacomputing/tempo/parse)","titles":["Tempo Modularity","Available Modules"]},"257":{"title":"Terms Module (@magmacomputing/tempo/term)","titles":["Tempo Modularity","Available Modules"]},"258":{"title":"1. The Side-Effect (Standard Activation)","titles":["Tempo Modularity","Available Modules","Terms Module (@magmacomputing/tempo/term)"]},"259":{"title":"2. The Explicit Module (Uniform Sync)","titles":["Tempo Modularity","Available Modules","Terms Module (@magmacomputing/tempo/term)"]},"260":{"title":"3. The Surgical Strike (Data-Only)","titles":["Tempo Modularity","Available Modules","Terms Module (@magmacomputing/tempo/term)"]},"261":{"title":"Custom Modules","titles":["Tempo Modularity"]},"262":{"title":"⚠️ The Registration "Gotcha"","titles":["Tempo Modularity"]},"263":{"title":"Creating a Namespace Plugin","titles":[]},"264":{"title":"The Lazy-Evaluation Advantage","titles":["Creating a Namespace Plugin"]},"265":{"title":"1. The defineNamespace Factory","titles":["Creating a Namespace Plugin"]},"266":{"title":"The Memoized Closure Pattern (Methods with Parameters)","titles":["Creating a Namespace Plugin","1. The defineNamespace Factory"]},"267":{"title":"2. TypeScript Module Augmentation","titles":["Creating a Namespace Plugin"]},"268":{"title":"3. Consuming the Namespace","titles":["Creating a Namespace Plugin"]},"269":{"title":"The Dual Architecture (OOP vs FP)","titles":["Creating a Namespace Plugin"]},"270":{"title":"The Best of Both Worlds","titles":["Creating a Namespace Plugin","The Dual Architecture (OOP vs FP)"]},"271":{"title":"Advanced: Symbol Namespaces","titles":["Creating a Namespace Plugin"]},"272":{"title":"Symbol Discovery in the Registry","titles":["Creating a Namespace Plugin","Advanced: Symbol Namespaces"]},"273":{"title":"Extending Tempo with Plugins","titles":[]},"274":{"title":"Naming Convention Standard","titles":["Extending Tempo with Plugins"]},"275":{"title":"1. Creating a Custom Plugin","titles":["Extending Tempo with Plugins"]},"276":{"title":"Type Safety (TypeScript)","titles":["Extending Tempo with Plugins"]},"277":{"title":"Best Practices","titles":["Extending Tempo with Plugins"]},"278":{"title":"1. Selective Immobility","titles":["Extending Tempo with Plugins","Best Practices"]},"279":{"title":"2. Immutability","titles":["Extending Tempo with Plugins","Best Practices"]},"280":{"title":"3. Namespace Respect","titles":["Extending Tempo with Plugins","Best Practices"]},"281":{"title":"4. Error Handling & The Diagnostic Engine","titles":["Extending Tempo with Plugins","Best Practices"]},"282":{"title":"5. Unified Logging Hooks (logWarn, logError, logDebug)","titles":["Extending Tempo with Plugins","Best Practices"]},"283":{"title":"Alternative: Standalone Functions (tempo-fns)","titles":["Extending Tempo with Plugins"]},"284":{"title":"Distributing Your Plugin","titles":["Extending Tempo with Plugins"]},"285":{"title":"Plugin Factories (with Options)","titles":["Extending Tempo with Plugins","Distributing Your Plugin"]},"286":{"title":"The Module Aggregator Pattern","titles":["Extending Tempo with Plugins","Distributing Your Plugin"]},"287":{"title":"Commercial & Enterprise Extensions","titles":["Extending Tempo with Plugins","Distributing Your Plugin"]},"288":{"title":"Consuming a Plugin","titles":["Extending Tempo with Plugins"]},"289":{"title":"1. Imperative Registration (Tempo.use)","titles":["Extending Tempo with Plugins","Consuming a Plugin"]},"290":{"title":"2. Declarative Configuration (defineConfig / Tempo.init)","titles":["Extending Tempo with Plugins","Consuming a Plugin"]},"291":{"title":"3. pluginOptions — Legacy / Shared Fallback","titles":["Extending Tempo with Plugins","Consuming a Plugin"]},"292":{"title":"Bulk Registration","titles":["Extending Tempo with Plugins"]},"293":{"title":"🤝 Need Help Writing a Plugin?","titles":["Extending Tempo with Plugins"]},"294":{"title":"Registries and Dictionaries","titles":[]},"295":{"title":"Accessing Registries","titles":["Registries and Dictionaries"]},"296":{"title":"📅 TIMEZONE Registry","titles":["Registries and Dictionaries"]},"297":{"title":"Other Internal Registries","titles":["Registries and Dictionaries"]},"298":{"title":"Registry Merge Contracts","titles":["Registries and Dictionaries","Other Internal Registries"]},"299":{"title":"Tempo Terms","titles":[]},"300":{"title":"Overview","titles":["Tempo Terms"]},"301":{"title":"What a Term Does","titles":["Tempo Terms"]},"302":{"title":"Provided Plugin","titles":["Tempo Terms"]},"303":{"title":"qtr / quarter — Fiscal Quarters","titles":["Tempo Terms","Provided Plugin"]},"304":{"title":"szn / season — Meteorological Seasons","titles":["Tempo Terms","Provided Plugin"]},"305":{"title":"zdc / zodiac — Astrological Zodiac","titles":["Tempo Terms","Provided Plugin"]},"306":{"title":"tod / timeOfDay — Daily Time Periods","titles":["Tempo Terms","Provided Plugin"]},"307":{"title":"Inspecting Registered Terms","titles":["Tempo Terms"]},"308":{"title":"Activating Terms","titles":["Tempo Terms"]},"309":{"title":"1. Standard Activation (Recommended)","titles":["Tempo Terms","Activating Terms"]},"310":{"title":"2. Explicit Module (Uniform Sync)","titles":["Tempo Terms","Activating Terms"]},"311":{"title":"3. Surgical Opt-in (Maximum Lite)","titles":["Tempo Terms","Activating Terms"]},"312":{"title":"How to Define a Term Plugin","titles":["Tempo Terms"]},"313":{"title":"Plugin Definition","titles":["Tempo Terms","How to Define a Term Plugin"]},"314":{"title":"Range fields","titles":["Tempo Terms","How to Define a Term Plugin"]},"315":{"title":"🔄 Sync to Alias Engine","titles":["Tempo Terms","How to Define a Term Plugin"]},"316":{"title":"Registering the plugin","titles":["Tempo Terms","How to Define a Term Plugin"]},"317":{"title":"Using Custom Configuration in Terms","titles":["Tempo Terms","How to Define a Term Plugin"]},"318":{"title":"🧭 Writing Math-Aware Terms","titles":["Tempo Terms"]},"319":{"title":"The getTermRange Helper","titles":["Tempo Terms","🧭 Writing Math-Aware Terms"]},"320":{"title":"Manual Boundaries","titles":["Tempo Terms","🧭 Writing Math-Aware Terms"]},"321":{"title":"Multi-Cycle Discovery & Traversals (The resolve method)","titles":["Tempo Terms","🧭 Writing Math-Aware Terms"]},"322":{"title":"🪝 Term Lifecycle Hooks Protocol","titles":["Tempo Terms"]},"323":{"title":"The 6 Lifecycle Hooks","titles":["Tempo Terms","🪝 Term Lifecycle Hooks Protocol"]},"324":{"title":"Complete Hook Example","titles":["Tempo Terms","🪝 Term Lifecycle Hooks Protocol"]},"325":{"title":"Zero-Overhead Guarantee","titles":["Tempo Terms","🪝 Term Lifecycle Hooks Protocol"]},"326":{"title":"🛠️ Developer Guide: Best Practices","titles":["Tempo Terms"]},"327":{"title":"🧭 Best Practices: Idempotency & Side-Effects","titles":["Tempo Terms"]},"328":{"title":"Sandbox Factory Pattern","titles":[]},"329":{"title":"The Problem","titles":["Sandbox Factory Pattern"]},"330":{"title":"The Solution","titles":["Sandbox Factory Pattern"]},"331":{"title":"Lifecycle Methods","titles":["Sandbox Factory Pattern","The Solution"]},"332":{"title":"Overloaded Signatures & Usage Modes","titles":["Sandbox Factory Pattern","The Solution"]},"333":{"title":"Mode 1: Derived Class Factory","titles":["Sandbox Factory Pattern","The Solution","Overloaded Signatures & Usage Modes"]},"334":{"title":"Mode 2: Scoped Callback Execution (Tempo.create(fn))","titles":["Sandbox Factory Pattern","The Solution","Overloaded Signatures & Usage Modes"]},"335":{"title":"Mode 3: Explicit Resource Management (using)","titles":["Sandbox Factory Pattern","The Solution","Overloaded Signatures & Usage Modes"]},"336":{"title":"Deterministic Disposal & Memory Management","titles":["Sandbox Factory Pattern","The Solution"]},"337":{"title":"Traceability & Collision Management","titles":["Sandbox Factory Pattern"]},"338":{"title":"Hierarchy of Resolution","titles":["Sandbox Factory Pattern","Traceability & Collision Management"]},"339":{"title":"Checking the Trace","titles":["Sandbox Factory Pattern","Traceability & Collision Management"]},"340":{"title":"Immutability & Security","titles":["Sandbox Factory Pattern"]},"341":{"title":"Best Practices","titles":["Sandbox Factory Pattern"]},"342":{"title":"Tempo Debugging & Introspection","titles":[]},"343":{"title":"Static Introspection","titles":["Tempo Debugging & Introspection"]},"344":{"title":"Tempo.config","titles":["Tempo Debugging & Introspection","Static Introspection"]},"345":{"title":"Tempo.default","titles":["Tempo Debugging & Introspection","Static Introspection"]},"346":{"title":"Tempo.terms","titles":["Tempo Debugging & Introspection","Static Introspection"]},"347":{"title":"Tempo.properties","titles":["Tempo Debugging & Introspection","Static Introspection"]},"348":{"title":"Tempo.parse","titles":["Tempo Debugging & Introspection","Static Introspection"]},"349":{"title":"Instance Introspection","titles":["Tempo Debugging & Introspection"]},"350":{"title":"this.config","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"351":{"title":"this.parse.result","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"352":{"title":"this.parse.anchor","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"353":{"title":"this.term","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"354":{"title":"this.fmt","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"355":{"title":"Primitive Auditing","titles":["Tempo Debugging & Introspection","Instance Introspection"]},"356":{"title":"Debugging and Console Logging","titles":["Tempo Debugging & Introspection"]},"357":{"title":"The debug Flag","titles":["Tempo Debugging & Introspection","Debugging and Console Logging"]},"358":{"title":"The catch Flag","titles":["Tempo Debugging & Introspection","Debugging and Console Logging"]},"359":{"title":"⚡ Fast-Fail (Master Guard) Debugging","titles":["Tempo Debugging & Introspection","Debugging and Console Logging"]},"360":{"title":"Invalid Instances","titles":["Tempo Debugging & Introspection","Debugging and Console Logging"]},"361":{"title":"Internationalization (Intl) & Locale in Tempo","titles":[]},"362":{"title":"1. Ambiguity Resolution (Date Layout)","titles":["Internationalization (Intl) & Locale in Tempo"]},"363":{"title":"2. Multi-Lingual Parsing (Input)","titles":["Internationalization (Intl) & Locale in Tempo"]},"364":{"title":"3. Formatting (Output)","titles":["Internationalization (Intl) & Locale in Tempo"]},"365":{"title":"Regional Calendar & Environment Fallbacks","titles":["Internationalization (Intl) & Locale in Tempo","3. Formatting (Output)"]},"366":{"title":"4. Intl.Locale Info & Regional Calendar Integration","titles":["Internationalization (Intl) & Locale in Tempo"]},"367":{"title":"Inspecting Cultural Metadata (t.intl.info)","titles":["Internationalization (Intl) & Locale in Tempo","4. Intl.Locale Info & Regional Calendar Integration"]},"368":{"title":"Opt-in Regional Calendar Math (localeInfo: true)","titles":["Internationalization (Intl) & Locale in Tempo","4. Intl.Locale Info & Regional Calendar Integration"]},"369":{"title":"Dedicated ISO Escape Hatches (isoWeek, wy)","titles":["Internationalization (Intl) & Locale in Tempo","4. Intl.Locale Info & Regional Calendar Integration"]},"370":{"title":"Cultural Formatting Tokens","titles":["Internationalization (Intl) & Locale in Tempo","4. Intl.Locale Info & Regional Calendar Integration"]},"371":{"title":"5. High-Performance Intl Utility Hub","titles":["Internationalization (Intl) & Locale in Tempo"]},"372":{"title":"Pre-Bound Formatting Operations","titles":["Internationalization (Intl) & Locale in Tempo","5. High-Performance Intl Utility Hub"]},"373":{"title":"Architectural Benefits","titles":["Internationalization (Intl) & Locale in Tempo","5. High-Performance Intl Utility Hub"]},"374":{"title":"Parse Planner Configuration","titles":[]},"375":{"title":"layoutOrder","titles":["Parse Planner Configuration"]},"376":{"title":"Supported Layouts","titles":["Parse Planner Configuration","layoutOrder"]},"377":{"title":"preFilter","titles":["Parse Planner Configuration"]},"378":{"title":"Tempo Shorthand Engine","titles":[]},"379":{"title":"1. The Three Modes of Shorthand","titles":["Tempo Shorthand Engine"]},"380":{"title":"A. Navigation Mode (String Shorthand)","titles":["Tempo Shorthand Engine","1. The Three Modes of Shorthand"]},"381":{"title":"B. Relational Mode (Object Shorthand)","titles":["Tempo Shorthand Engine","1. The Three Modes of Shorthand"]},"382":{"title":"C. Structural Mode (Boundary Shorthand)","titles":["Tempo Shorthand Engine","1. The Three Modes of Shorthand"]},"383":{"title":"2. Navigation Modifiers","titles":["Tempo Shorthand Engine"]},"384":{"title":"3. Proximity vs. Momentum","titles":["Tempo Shorthand Engine"]},"385":{"title":"Proximity Resolution (Identifiers)","titles":["Tempo Shorthand Engine","3. Proximity vs. Momentum"]},"386":{"title":"Momentum Resolution (Shifters)","titles":["Tempo Shorthand Engine","3. Proximity vs. Momentum"]},"387":{"title":"4. The "Cycle Preservation" Guarantee","titles":["Tempo Shorthand Engine"]},"388":{"title":"5. Development Constraints","titles":["Tempo Shorthand Engine"]},"389":{"title":"6. Best Practices","titles":["Tempo Shorthand Engine"]},"390":{"title":"Weekday Parsing","titles":[]},"391":{"title":"Supported Formats","titles":["Weekday Parsing"]},"392":{"title":"1. Simple Weekday Names","titles":["Weekday Parsing","Supported Formats"]},"393":{"title":"2. Symbolic Modifiers","titles":["Weekday Parsing","Supported Formats"]},"394":{"title":"Strict vs Inclusive Boundaries","titles":["Weekday Parsing","Supported Formats"]},"395":{"title":"3. Keyword Modifiers","titles":["Weekday Parsing","Supported Formats"]},"396":{"title":"4. Count Modifiers","titles":["Weekday Parsing","Supported Formats"]},"397":{"title":"5. Relative Suffixes","titles":["Weekday Parsing","Supported Formats"]},"398":{"title":"Time Suffixes","titles":["Weekday Parsing"]},"399":{"title":"How it Works","titles":["Weekday Parsing"]},"400":{"title":"🏗️ Core Architecture","titles":[]},"401":{"title":"🌐 Shared Global Registry","titles":["🏗️ Core Architecture"]},"402":{"title":"TempoRuntime — single hardened bridge","titles":["🏗️ Core Architecture","🌐 Shared Global Registry"]},"403":{"title":"🕵️ Decoupled Logging","titles":["🏗️ Core Architecture"]},"404":{"title":"🛡️ Hardened Functional Resolution","titles":["🏗️ Core Architecture"]},"405":{"title":"🏗️ Tempo Architecture: Internal Protection & Performance","titles":["🏗️ Core Architecture"]},"406":{"title":"🧭 Methodology Comparison","titles":["🏗️ Core Architecture"]},"407":{"title":"⚡ The "Zero-Cost Constructor" Objective","titles":["🏗️ Core Architecture"]},"408":{"title":"🔁 Iteration & Enumerability (Delegator Proxies)","titles":["🏗️ Core Architecture"]},"409":{"title":"✅ Object.keys() Behavior","titles":["🏗️ Core Architecture","🔁 Iteration & Enumerability (Delegator Proxies)"]},"410":{"title":"🛡️ Iteration Notes","titles":["🏗️ Core Architecture","🔁 Iteration & Enumerability (Delegator Proxies)"]},"411":{"title":"1. Lazy Evaluation (Shadowing)","titles":["🏗️ Core Architecture"]},"412":{"title":"How it works:","titles":["🏗️ Core Architecture","1. Lazy Evaluation (Shadowing)"]},"413":{"title":"2. Soft Freeze Strategy (Proxy)","titles":["🏗️ Core Architecture"]},"414":{"title":"How it works:","titles":["🏗️ Core Architecture","2. Soft Freeze Strategy (Proxy)"]},"415":{"title":"⚡ 3. Master Guard (Guarded-Lazy Strategy)","titles":["🏗️ Core Architecture"]},"416":{"title":"How it works:","titles":["🏗️ Core Architecture","⚡ 3. Master Guard (Guarded-Lazy Strategy)"]},"417":{"title":"🧩 Centralized Alias Management","titles":["🏗️ Core Architecture"]},"418":{"title":"How it works:","titles":["🏗️ Core Architecture","🧩 Centralized Alias Management"]},"419":{"title":"📈 Validation & Performance","titles":["🏗️ Core Architecture","🧩 Centralized Alias Management"]},"420":{"title":"🔄 Internal Lifecycle & Reactive Sync","titles":["🏗️ Core Architecture"]},"421":{"title":"Reactive Registration","titles":["🏗️ Core Architecture","🔄 Internal Lifecycle & Reactive Sync"]},"422":{"title":"Disposable Engine (Symbol.dispose)","titles":["🏗️ Core Architecture","🔄 Internal Lifecycle & Reactive Sync"]},"423":{"title":"⚖️ Summary","titles":["🏗️ Core Architecture"]},"424":{"title":"The Immutable Proxy-Delegator Lazy Evaluation Pattern","titles":[]},"425":{"title":"The Problem: Mutating Frozen State","titles":["The Immutable Proxy-Delegator Lazy Evaluation Pattern"]},"426":{"title":"The Solution: Proxy-Delegator with Memoization","titles":["The Immutable Proxy-Delegator Lazy Evaluation Pattern"]},"427":{"title":"How it Works","titles":["The Immutable Proxy-Delegator Lazy Evaluation Pattern","The Solution: Proxy-Delegator with Memoization"]},"428":{"title":"Summary","titles":["The Immutable Proxy-Delegator Lazy Evaluation Pattern","The Solution: Proxy-Delegator with Memoization"]},"429":{"title":"🌈 The Best of All Worlds","titles":["The Immutable Proxy-Delegator Lazy Evaluation Pattern"]},"430":{"title":"Soft Freeze Strategy","titles":[]},"431":{"title":"The Problem","titles":["Soft Freeze Strategy"]},"432":{"title":"The Solution: Soft Freeze","titles":["Soft Freeze Strategy"]},"433":{"title":"1. The Proxy (Public Shield)","titles":["Soft Freeze Strategy","The Solution: Soft Freeze"]},"434":{"title":"2. The Target (Internal Source of Truth)","titles":["Soft Freeze Strategy","The Solution: Soft Freeze"]},"435":{"title":"3. Access Control ($Target Symbol)","titles":["Soft Freeze Strategy","The Solution: Soft Freeze"]},"436":{"title":"Implementation Details","titles":["Soft Freeze Strategy"]},"437":{"title":"proxy.library.ts","titles":["Soft Freeze Strategy","Implementation Details"]},"438":{"title":"enumerate.library.ts","titles":["Soft Freeze Strategy","Implementation Details"]},"439":{"title":"Benefits","titles":["Soft Freeze Strategy"]},"440":{"title":"The "Safe Merge" Rule","titles":["Soft Freeze Strategy"]},"441":{"title":"🚀 Tempo Performance Benchmarks","titles":[]},"442":{"title":"📊 Summary of Timings","titles":["🚀 Tempo Performance Benchmarks"]},"443":{"title":"🏗️ Architectural Impact","titles":["🚀 Tempo Performance Benchmarks"]},"444":{"title":"1. Proxy-Delegator Delegation (O(1))","titles":["🚀 Tempo Performance Benchmarks","🏗️ Architectural Impact"]},"445":{"title":"2. The Master Guard (Fast-Fail)","titles":["🚀 Tempo Performance Benchmarks","🏗️ Architectural Impact"]},"446":{"title":"🧪 Benchmark Methodology","titles":["🚀 Tempo Performance Benchmarks"]},"447":{"title":"📈 Self-Service Benchmark Module","titles":["🚀 Tempo Performance Benchmarks"]},"448":{"title":"Usage","titles":["🚀 Tempo Performance Benchmarks","📈 Self-Service Benchmark Module"]},"449":{"title":"Metrics Collected","titles":["🚀 Tempo Performance Benchmarks","📈 Self-Service Benchmark Module"]},"450":{"title":"Indicative Benchmark Results","titles":["🚀 Tempo Performance Benchmarks","📈 Self-Service Benchmark Module"]},"451":{"title":"🔍 Key Takeaways","titles":["🚀 Tempo Performance Benchmarks","📈 Self-Service Benchmark Module","Indicative Benchmark Results"]},"452":{"title":"Tempo Enumerators (enumify)","titles":[]},"453":{"title":"1. How Tempo Enums are Defined","titles":["Tempo Enumerators (enumify)"]},"454":{"title":"Array-based Definitions","titles":["Tempo Enumerators (enumify)","1. How Tempo Enums are Defined"]},"455":{"title":"Object-based Definitions","titles":["Tempo Enumerators (enumify)","1. How Tempo Enums are Defined"]},"456":{"title":"Type Inference","titles":["Tempo Enumerators (enumify)","1. How Tempo Enums are Defined"]},"457":{"title":"2. Using Enums Outside of Tempo","titles":["Tempo Enumerators (enumify)"]},"458":{"title":"1. Static Properties on Tempo","titles":["Tempo Enumerators (enumify)","2. Using Enums Outside of Tempo"]},"459":{"title":"2. Canonical Namespace Import","titles":["Tempo Enumerators (enumify)","2. Using Enums Outside of Tempo"]},"460":{"title":"3. Direct Named Import","titles":["Tempo Enumerators (enumify)","2. Using Enums Outside of Tempo"]},"461":{"title":"Static-First Reflection Suite (Enum.*)","titles":["Tempo Enumerators (enumify)","2. Using Enums Outside of Tempo"]},"462":{"title":"3. Creating Custom Enums","titles":["Tempo Enumerators (enumify)"]},"463":{"title":"Basic Custom Enum","titles":["Tempo Enumerators (enumify)","3. Creating Custom Enums"]},"464":{"title":"Extending Enums via Prototypal Inheritance (Enum.extend())","titles":["Tempo Enumerators (enumify)","3. Creating Custom Enums"]},"465":{"title":"How Prototypal Inheritance Works Here:","titles":["Tempo Enumerators (enumify)","3. Creating Custom Enums","Extending Enums via Prototypal Inheritance (Enum.extend())"]},"466":{"title":"4. How They Are Used Inside Tempo","titles":["Tempo Enumerators (enumify)"]},"467":{"title":"5. enumify vs. TypeScript enum (The Trade-Offs)","titles":["Tempo Enumerators (enumify)"]},"468":{"title":"The Wins for enumify","titles":["Tempo Enumerators (enumify)","5. enumify vs. TypeScript enum (The Trade-Offs)"]},"469":{"title":"The Losses (Trade-offs) for enumify","titles":["Tempo Enumerators (enumify)","5. enumify vs. TypeScript enum (The Trade-Offs)"]},"470":{"title":"Tempo Library Functionality","titles":[]},"471":{"title":"1. Enumerators (enumify, Enum.*)","titles":["Tempo Library Functionality"]},"472":{"title":"2. Serialization (stringify, objectify, cloneify)","titles":["Tempo Library Functionality"]},"473":{"title":"3. High-Performance Push/Pull Streams (Reactive)","titles":["Tempo Library Functionality"]},"474":{"title":"4. Deferred Promises (Pledge)","titles":["Tempo Library Functionality"]},"475":{"title":"Key Features","titles":["Tempo Library Functionality","4. Deferred Promises (Pledge)"]},"476":{"title":"5. GC Safety & Memory Management (WeakCache, Finalizer)","titles":["Tempo Library Functionality"]},"477":{"title":"6. Functional Evaluation (evaluate, dynamicProxy)","titles":["Tempo Library Functionality"]},"478":{"title":"7. Class Decorators (@Immutable, @Serializable, @Static)","titles":["Tempo Library Functionality"]},"479":{"title":"8. Exhaustive API Reference","titles":["Tempo Library Functionality"]},"480":{"title":"Pledge: Advanced Asynchronous Patterns","titles":[]},"481":{"title":"1. Basic Lifecycle","titles":["Pledge: Advanced Asynchronous Patterns"]},"482":{"title":"2. Then-ability","titles":["Pledge: Advanced Asynchronous Patterns"]},"483":{"title":"3. Advanced Callbacks","titles":["Pledge: Advanced Asynchronous Patterns"]},"484":{"title":"4. Debugging with Tags","titles":["Pledge: Advanced Asynchronous Patterns"]},"485":{"title":"5. Global Configuration","titles":["Pledge: Advanced Asynchronous Patterns"]},"486":{"title":"6. Automatic Cleanup (Symbol.dispose)","titles":["Pledge: Advanced Asynchronous Patterns"]},"487":{"title":"7. State Accessors","titles":["Pledge: Advanced Asynchronous Patterns"]},"488":{"title":"Reactive: High-Performance Push/Pull Streams","titles":[]},"489":{"title":"1. Core Concepts: Push/Pull Duality","titles":["Reactive: High-Performance Push/Pull Streams"]},"490":{"title":"2. Push-Based Event Subscriptions","titles":["Reactive: High-Performance Push/Pull Streams"]},"491":{"title":"Deterministic Disposal with using","titles":["Reactive: High-Performance Push/Pull Streams","2. Push-Based Event Subscriptions"]},"492":{"title":"3. Pull-Based Async Iteration","titles":["Reactive: High-Performance Push/Pull Streams"]},"493":{"title":"4. Stream Truncation with .until()","titles":["Reactive: High-Performance Push/Pull Streams"]},"494":{"title":"5. Resource Management & GC Safety","titles":["Reactive: High-Performance Push/Pull Streams"]},"495":{"title":"Automatic Finalization","titles":["Reactive: High-Performance Push/Pull Streams","5. Resource Management & GC Safety"]},"496":{"title":"6. Static Factory Methods","titles":["Reactive: High-Performance Push/Pull Streams"]},"497":{"title":"7. Stream State Inspection","titles":["Reactive: High-Performance Push/Pull Streams"]},"498":{"title":"Tempo Serializers (stringify, objectify, cloneify)","titles":[]},"499":{"title":"1. The Core Functions","titles":["Tempo Serializers (stringify, objectify, cloneify)"]},"500":{"title":"stringify(obj)","titles":["Tempo Serializers (stringify, objectify, cloneify)","1. The Core Functions"]},"501":{"title":"objectify(str, sentinel?)","titles":["Tempo Serializers (stringify, objectify, cloneify)","1. The Core Functions"]},"502":{"title":"cloneify(obj, sentinel?)","titles":["Tempo Serializers (stringify, objectify, cloneify)","1. The Core Functions"]},"503":{"title":"2. Selling the Benefits","titles":["Tempo Serializers (stringify, objectify, cloneify)"]},"504":{"title":"3. How They Are Used Inside Tempo","titles":["Tempo Serializers (stringify, objectify, cloneify)"]},"505":{"title":"4. Drawbacks (Over JSON Methods)","titles":["Tempo Serializers (stringify, objectify, cloneify)"]},"506":{"title":"🥊 Tempo vs. The Competition","titles":[]},"507":{"title":"At a Glance","titles":["🥊 Tempo vs. The Competition"]},"508":{"title":"💎 Why Tempo Wins","titles":["🥊 Tempo vs. The Competition"]},"509":{"title":"1. The "Terms" Engine (Business Intelligence)","titles":["🥊 Tempo vs. The Competition","💎 Why Tempo Wins"]},"510":{"title":"2. Human-Centric Parsing","titles":["🥊 Tempo vs. The Competition","💎 Why Tempo Wins"]},"511":{"title":"3. Nanosecond Precision","titles":["🥊 Tempo vs. The Competition","💎 Why Tempo Wins"]},"512":{"title":"4. Zero "Leaky Abstractions"","titles":["🥊 Tempo vs. The Competition","💎 Why Tempo Wins"]},"513":{"title":"5. Intelligent Formatting & Shorthands","titles":["🥊 Tempo vs. The Competition","💎 Why Tempo Wins"]},"514":{"title":"The Temporal Transition Strategy","titles":["🥊 Tempo vs. The Competition"]},"515":{"title":"Which should you choose?","titles":["🥊 Tempo vs. The Competition"]},"516":{"title":"🤝 Extending Native Temporal","titles":[]},"517":{"title":"1. Parsing: Strict vs. Intelligent","titles":["🤝 Extending Native Temporal"]},"518":{"title":"2. Formatting: Verbose vs. Expressive Tokens","titles":["🤝 Extending Native Temporal"]},"519":{"title":"3. Extensibility: Domain-Specific Logic","titles":["🤝 Extending Native Temporal"]},"520":{"title":"4. Duration Logic: Strict Math vs. Human Readable","titles":["🤝 Extending Native Temporal"]},"521":{"title":"The Vision for Tempo","titles":[]},"522":{"title":"Introduction: Humanizing Temporal","titles":["The Vision for Tempo"]},"523":{"title":"Core Value Proposition","titles":["The Vision for Tempo"]},"524":{"title":"1. Closing the Onboarding Gap","titles":["The Vision for Tempo","Core Value Proposition"]},"525":{"title":"2. Human-Centric Parsing","titles":["The Vision for Tempo","Core Value Proposition"]},"526":{"title":"3. Contextual & Business Intelligence via Plugins","titles":["The Vision for Tempo","Core Value Proposition"]},"527":{"title":"4. Lean, Deterministic, and Hardened","titles":["The Vision for Tempo","Core Value Proposition"]},"528":{"title":"Conclusion","titles":["The Vision for Tempo"]},"529":{"title":"🤝 Magma Computing Solutions: Professional Services","titles":[]},"530":{"title":"🚀 Our Services","titles":["🤝 Magma Computing Solutions: Professional Services"]},"531":{"title":"🧩 Custom Plugin Development","titles":["🤝 Magma Computing Solutions: Professional Services","🚀 Our Services"]},"532":{"title":"🏛️ Architecture & Migration Consulting","titles":["🤝 Magma Computing Solutions: Professional Services","🚀 Our Services"]},"533":{"title":"🛡️ Enterprise Support & Commercial Extensions","titles":["🤝 Magma Computing Solutions: Professional Services","🚀 Our Services"]},"534":{"title":"📬 Contact Us","titles":["🤝 Magma Computing Solutions: Professional Services"]},"535":{"title":"⚠️ Migrating to Tempo v4.x","titles":[]},"536":{"title":"⚡ Dynamic Functional Context (DFC) & Supplier Options","titles":["⚠️ Migrating to Tempo v4.x"]},"537":{"title":"🛠️ Plugin SDK Subpath (@magmacomputing/tempo/plugin/sdk)","titles":["⚠️ Migrating to Tempo v4.x"]},"538":{"title":"📄 Zero-await Synchronous JSONC Config Discovery","titles":["⚠️ Migrating to Tempo v4.x"]},"539":{"title":"🔓 100% Open-Source Community Core","titles":["⚠️ Migrating to Tempo v4.x"]},"540":{"title":"🚀 Tempo v4.1.0 Updates","titles":[]},"541":{"title":"🔌 Configuration Inheritance (extends), plugins, and pluginOptions","titles":["🚀 Tempo v4.1.0 Updates"]},"542":{"title":"Example:","titles":["🚀 Tempo v4.1.0 Updates","🔌 Configuration Inheritance (extends), plugins, and pluginOptions"]},"543":{"title":"🔒 Overloaded Tempo.create() & Scoped Disposal (using)","titles":["🚀 Tempo v4.1.0 Updates"]},"544":{"title":"📂 Data Augmentation (registry: { ... })","titles":["🚀 Tempo v4.1.0 Updates"]},"545":{"title":"Example Migration:","titles":["🚀 Tempo v4.1.0 Updates","📂 Data Augmentation (registry: { ... })"]},"546":{"title":"🧹 Deprecated Type & API Cleanup","titles":["🚀 Tempo v4.1.0 Updates"]},"547":{"title":"⚠️ Migrating to Tempo v3.x","titles":[]},"548":{"title":"🔁 Migrating to Tempo v3.x (Ticker Extraction)","titles":["⚠️ Migrating to Tempo v3.x"]},"549":{"title":"⚠️ Migrating to Tempo v2.x","titles":[]},"550":{"title":"📦 Modular Architecture","titles":["⚠️ Migrating to Tempo v2.x"]},"551":{"title":"If you use the full package:","titles":["⚠️ Migrating to Tempo v2.x","📦 Modular Architecture"]},"552":{"title":"If you want a lean bundle:","titles":["⚠️ Migrating to Tempo v2.x","📦 Modular Architecture"]},"553":{"title":"🔌 Feature Registration","titles":["⚠️ Migrating to Tempo v2.x"]},"554":{"title":"v1.x (Automatic)","titles":["⚠️ Migrating to Tempo v2.x","🔌 Feature Registration"]},"555":{"title":"v2.x (Opt-in for Core)","titles":["⚠️ Migrating to Tempo v2.x","🔌 Feature Registration"]},"556":{"title":"🗓️ Term Logic Refactor","titles":["⚠️ Migrating to Tempo v2.x"]},"557":{"title":"🚀 Tempo v2.4.0: Standalone Utilities & Path Deprecation","titles":["⚠️ Migrating to Tempo v2.x"]},"558":{"title":"🛠️ Standalone Imports","titles":["⚠️ Migrating to Tempo v2.x","🚀 Tempo v2.4.0: Standalone Utilities & Path Deprecation"]},"559":{"title":"⚠️ Reorganized Paths","titles":["⚠️ Migrating to Tempo v2.x","🚀 Tempo v2.4.0: Standalone Utilities & Path Deprecation"]},"560":{"title":"🔁 Migrating from version 2.4","titles":["⚠️ Migrating to Tempo v2.x"]},"561":{"title":"🔁 Migrating from version 2.6.0","titles":["⚠️ Migrating to Tempo v2.x"]},"562":{"title":"🔁 Migrating from version 2.7.0 (Grouped Options)","titles":["⚠️ Migrating to Tempo v2.x"]},"563":{"title":"Month-Day (Regional Parsing)","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating from version 2.7.0 (Grouped Options)"]},"564":{"title":"Relative Time","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating from version 2.7.0 (Grouped Options)"]},"565":{"title":"Action Required:","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating from version 2.7.0 (Grouped Options)"]},"566":{"title":"🔁 Migrating to version 2.9.3","titles":["⚠️ Migrating to Tempo v2.x"]},"567":{"title":"📏 BigInt Precision Resolution","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating to version 2.9.3"]},"568":{"title":"Example:","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating to version 2.9.3","📏 BigInt Precision Resolution"]},"569":{"title":"Action Required:","titles":["⚠️ Migrating to Tempo v2.x","🔁 Migrating to version 2.9.3","📏 BigInt Precision Resolution"]},"570":{"title":"🔁 Removed Features (v3.0.0)","titles":["⚠️ Migrating to Tempo v2.x"]},"571":{"title":"Deprecated Boolean Debug Flag","titles":["⚠️ Migrating to Tempo v2.x","🔁 Removed Features (v3.0.0)"]},"572":{"title":"Internationalization Naming","titles":["⚠️ Migrating to Tempo v2.x","🔁 Removed Features (v3.0.0)"]},"573":{"title":"🧪 Testing and Stability","titles":["⚠️ Migrating to Tempo v2.x"]},"574":{"title":"🚀 Releases","titles":[]},"575":{"title":"Release Strategy","titles":["🚀 Releases"]},"576":{"title":"📜 Version 0.x History","titles":[]},"577":{"title":"[v0.3.0] - 2025-07-31","titles":["📜 Version 0.x History"]},"578":{"title":"New Features","titles":["📜 Version 0.x History","[v0.3.0] - 2025-07-31"]},"579":{"title":"Bug Fixes","titles":["📜 Version 0.x History","[v0.3.0] - 2025-07-31"]},"580":{"title":"Refactor","titles":["📜 Version 0.x History","[v0.3.0] - 2025-07-31"]},"581":{"title":"Documentation","titles":["📜 Version 0.x History","[v0.3.0] - 2025-07-31"]},"582":{"title":"Chores","titles":["📜 Version 0.x History","[v0.3.0] - 2025-07-31"]},"583":{"title":"[v0.2.0] - 2024-10-30","titles":["📜 Version 0.x History"]},"584":{"title":"New Features","titles":["📜 Version 0.x History","[v0.2.0] - 2024-10-30"]},"585":{"title":"Bug Fixes","titles":["📜 Version 0.x History","[v0.2.0] - 2024-10-30"]},"586":{"title":"📜 Version 1.x History","titles":[]},"587":{"title":"[v1.1.3] - 2026-03-31","titles":["📜 Version 1.x History"]},"588":{"title":"New Features","titles":["📜 Version 1.x History","[v1.1.3] - 2026-03-31"]},"589":{"title":"Documentation","titles":["📜 Version 1.x History","[v1.1.3] - 2026-03-31"]},"590":{"title":"Branding","titles":["📜 Version 1.x History","[v1.1.3] - 2026-03-31"]},"591":{"title":"[v1.1.2] - 2026-03-23","titles":["📜 Version 1.x History"]},"592":{"title":"New Features","titles":["📜 Version 1.x History","[v1.1.2] - 2026-03-23"]},"593":{"title":"Bug Fixes","titles":["📜 Version 1.x History","[v1.1.2] - 2026-03-23"]},"594":{"title":"Documentation","titles":["📜 Version 1.x History","[v1.1.2] - 2026-03-23"]},"595":{"title":"[v1.1.1] - 2026-03-22","titles":["📜 Version 1.x History"]},"596":{"title":"New Features","titles":["📜 Version 1.x History","[v1.1.1] - 2026-03-22"]},"597":{"title":"Changed","titles":["📜 Version 1.x History","[v1.1.1] - 2026-03-22"]},"598":{"title":"Documentation","titles":["📜 Version 1.x History","[v1.1.1] - 2026-03-22"]},"599":{"title":"[v1.1.0] - 2026-03-19","titles":["📜 Version 1.x History"]},"600":{"title":"New Features","titles":["📜 Version 1.x History","[v1.1.0] - 2026-03-19"]},"601":{"title":"Documentation","titles":["📜 Version 1.x History","[v1.1.0] - 2026-03-19"]},"602":{"title":"Tests","titles":["📜 Version 1.x History","[v1.1.0] - 2026-03-19"]},"603":{"title":"Chores","titles":["📜 Version 1.x History","[v1.1.0] - 2026-03-19"]},"604":{"title":"📜 Version 2.x History","titles":[]},"605":{"title":"[v2.11.0] - 2026-05-25","titles":["📜 Version 2.x History"]},"606":{"title":"New Features","titles":["📜 Version 2.x History","[v2.11.0] - 2026-05-25"]},"607":{"title":"Fixed","titles":["📜 Version 2.x History","[v2.11.0] - 2026-05-25"]},"608":{"title":"[v2.10.1] - 2026-05-23","titles":["📜 Version 2.x History"]},"609":{"title":"New Features","titles":["📜 Version 2.x History","[v2.10.1] - 2026-05-23"]},"610":{"title":"Documentation","titles":["📜 Version 2.x History","[v2.10.1] - 2026-05-23"]},"611":{"title":"[v2.10.0] - 2026-05-20","titles":["📜 Version 2.x History"]},"612":{"title":"New Features","titles":["📜 Version 2.x History","[v2.10.0] - 2026-05-20"]},"613":{"title":"Bug Fixes","titles":["📜 Version 2.x History","[v2.10.0] - 2026-05-20"]},"614":{"title":"Documentation","titles":["📜 Version 2.x History","[v2.10.0] - 2026-05-20"]},"615":{"title":"[v2.9.3] - 2026-05-10","titles":["📜 Version 2.x History"]},"616":{"title":"🏗️ Engine Stabilization & Hardening","titles":["📜 Version 2.x History","[v2.9.3] - 2026-05-10"]},"617":{"title":"⚙️ Type Safety & Environment Engine Hardening","titles":["📜 Version 2.x History","[v2.9.3] - 2026-05-10"]},"618":{"title":"📦 Dependency Updates","titles":["📜 Version 2.x History","[v2.9.3] - 2026-05-10"]},"619":{"title":"[v2.9.2] - 2026-05-08","titles":["📜 Version 2.x History"]},"620":{"title":"New Features","titles":["📜 Version 2.x History","[v2.9.2] - 2026-05-08"]},"621":{"title":"Bug Fixes","titles":["📜 Version 2.x History","[v2.9.2] - 2026-05-08"]},"622":{"title":"Improvements","titles":["📜 Version 2.x History","[v2.9.2] - 2026-05-08"]},"623":{"title":"Documentation","titles":["📜 Version 2.x History","[v2.9.2] - 2026-05-08"]},"624":{"title":"[v2.9.0] - 2026-05-06","titles":["📜 Version 2.x History"]},"625":{"title":"🏗️ Alias Architecture Stabilization","titles":["📜 Version 2.x History","[v2.9.0] - 2026-05-06"]},"626":{"title":"⚙️ Parser & Registry Refinement","titles":["📜 Version 2.x History","[v2.9.0] - 2026-05-06"]},"627":{"title":"📚 Documentation Fixes","titles":["📜 Version 2.x History","[v2.9.0] - 2026-05-06"]},"628":{"title":"[v2.8.0] - 2026-04-30","titles":["📜 Version 2.x History"]},"629":{"title":"🚨 Immutability System Refined","titles":["📜 Version 2.x History","[v2.8.0] - 2026-04-30"]},"630":{"title":"⚙️ Parse Planner Configuration","titles":["📜 Version 2.x History","[v2.8.0] - 2026-04-30"]},"631":{"title":"🛡️ Resilience & Bug Fixes","titles":["📜 Version 2.x History","[v2.8.0] - 2026-04-30"]},"632":{"title":"[v2.7.0] - 2026-04-27","titles":["📜 Version 2.x History"]},"633":{"title":"🧩 Configuration Rationalization","titles":["📜 Version 2.x History","[v2.7.0] - 2026-04-27"]},"634":{"title":"🛡️ Resilience & Bug Fixes","titles":["📜 Version 2.x History","[v2.7.0] - 2026-04-27"]},"635":{"title":"⚙️ CI/CD & Infrastructure","titles":["📜 Version 2.x History","[v2.7.0] - 2026-04-27"]},"636":{"title":"[v2.6.0] - 2026-04-25","titles":["📜 Version 2.x History"]},"637":{"title":"⚠️ Migration Notes","titles":["📜 Version 2.x History","[v2.6.0] - 2026-04-25"]},"638":{"title":"[v2.5.0] - 2026-04-25","titles":["📜 Version 2.x History"]},"639":{"title":"New Features","titles":["📜 Version 2.x History","[v2.5.0] - 2026-04-25"]},"640":{"title":"Documentation","titles":["📜 Version 2.x History","[v2.5.0] - 2026-04-25"]},"641":{"title":"[v2.4.0] - 2026-04-24","titles":["📜 Version 2.x History"]},"642":{"title":"🧩 Parsing Infrastructure","titles":["📜 Version 2.x History","[v2.4.0] - 2026-04-24"]},"643":{"title":"🛡️ Isolation & Sandboxing","titles":["📜 Version 2.x History","[v2.4.0] - 2026-04-24"]},"644":{"title":"⚙️ Internal Refactoring & Type Safety","titles":["📜 Version 2.x History","[v2.4.0] - 2026-04-24"]},"645":{"title":"📊 Diagnostics & Debug Support","titles":["📜 Version 2.x History","[v2.4.0] - 2026-04-24"]},"646":{"title":"[v2.3.0] - 2026-04-22","titles":["📜 Version 2.x History"]},"647":{"title":"🧩 Parsing Innovations","titles":["📜 Version 2.x History","[v2.3.0] - 2026-04-22"]},"648":{"title":"📚 Documentation & UX","titles":["📜 Version 2.x History","[v2.3.0] - 2026-04-22"]},"649":{"title":"🛠️ Refactor & Type Safety","titles":["📜 Version 2.x History","[v2.3.0] - 2026-04-22"]},"650":{"title":"[v2.2.6] - 2026-04-20","titles":["📜 Version 2.x History"]},"651":{"title":"🚑 Emergency Hotfix","titles":["📜 Version 2.x History","[v2.2.6] - 2026-04-20"]},"652":{"title":"[v2.2.5] - 2026-04-20","titles":["📜 Version 2.x History"]},"653":{"title":"🏗️ Modular Hardening","titles":["📜 Version 2.x History","[v2.2.5] - 2026-04-20"]},"654":{"title":"🔍 Term Resolution Refinements","titles":["📜 Version 2.x History","[v2.2.5] - 2026-04-20"]},"655":{"title":"📚 Documentation & UX","titles":["📜 Version 2.x History","[v2.2.5] - 2026-04-20"]},"656":{"title":"[v2.2.4] - 2026-04-19","titles":["📜 Version 2.x History"]},"657":{"title":"🛡️ Production Safety","titles":["📜 Version 2.x History","[v2.2.4] - 2026-04-19"]},"658":{"title":"[v2.2.3] - 2026-04-19","titles":["📜 Version 2.x History"]},"659":{"title":"✨ New Features","titles":["📜 Version 2.x History","[v2.2.3] - 2026-04-19"]},"660":{"title":"🐛 Bug Fixes","titles":["📜 Version 2.x History","[v2.2.3] - 2026-04-19"]},"661":{"title":"📚 Documentation & Chores","titles":["📜 Version 2.x History","[v2.2.3] - 2026-04-19"]},"662":{"title":"[v2.2.2] - 2026-04-18","titles":["📜 Version 2.x History"]},"663":{"title":"🛡️ Registry Stabilization","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"664":{"title":"🔍 Hardened Reflection","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"665":{"title":"📦 Production Optimization","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"666":{"title":"🎨 Premium Documentation & UX","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"667":{"title":"🧬 Mutation Engine & State Preservation","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"668":{"title":"🧩 Modular Parse Engine","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"669":{"title":"⚙️ CI/CD & Tooling","titles":["📜 Version 2.x History","[v2.2.2] - 2026-04-18"]},"670":{"title":"[v2.1.3] - 2026-04-18","titles":["📜 Version 2.x History"]},"671":{"title":"📚 Documentation & Ecosystem","titles":["📜 Version 2.x History","[v2.1.3] - 2026-04-18"]},"672":{"title":"🚀 Performance & Extensibility","titles":["📜 Version 2.x History","[v2.1.3] - 2026-04-18"]},"673":{"title":"⏱️ Temporal Utilities","titles":["📜 Version 2.x History","[v2.1.3] - 2026-04-18"]},"674":{"title":"[v2.1.2] - 2026-04-16","titles":["📜 Version 2.x History"]},"675":{"title":"🏗️ Modular Architecture","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"676":{"title":"📝 Improved Logging","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"677":{"title":"⏱️ Static API","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"678":{"title":"🔌 Side Effect Registration","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"679":{"title":"🛡️ 100% Reliability","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"680":{"title":"🗓️ Unified Term Logic","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"681":{"title":"➗ Relational Term Math","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"682":{"title":"🔗 Fluent Immutable Boundaries","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"683":{"title":"⚡ Ticker Reliability","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"684":{"title":"🚀 Parsing Engine Optimization","titles":["📜 Version 2.x History","[v2.1.2] - 2026-04-16"]},"685":{"title":"📜 Version 3.x History","titles":[]},"686":{"title":"[v3.11.1] - 2026-08-10","titles":["📜 Version 3.x History"]},"687":{"title":"✨ Dedicated Config Subpath (@magmacomputing/tempo/config)","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"688":{"title":"✨ JSONC Configuration Support","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"689":{"title":"✨ Timezone Abbreviations & Humanized Offsets","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"690":{"title":"✨ SQL & Space-Delimited Timestamp Parsing","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"691":{"title":"✨ Cache Inspection & Serialization (toJSON)","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"692":{"title":"📚 AI Context & IDE Integration (llms.txt)","titles":["📜 Version 3.x History","[v3.11.1] - 2026-08-10"]},"693":{"title":"[v3.11.0] - 2026-07-31","titles":["📜 Version 3.x History"]},"694":{"title":"✨ Centralized Cache Engine (Tempo.cache)","titles":["📜 Version 3.x History","[v3.11.0] - 2026-07-31"]},"695":{"title":"✨ Glossary Seeding","titles":["📜 Version 3.x History","[v3.11.0] - 2026-07-31"]},"696":{"title":"⚡ Multi-Provider AI Farm & Batching","titles":["📜 Version 3.x History","[v3.11.0] - 2026-07-31"]},"697":{"title":"📚 Documentation Enhancements","titles":["📜 Version 3.x History","[v3.11.0] - 2026-07-31"]},"698":{"title":"[v3.10.3] - 2026-07-29","titles":["📜 Version 3.x History"]},"699":{"title":"⚡ Zero-Overhead Instantiation & Lazy System Clock","titles":["📜 Version 3.x History","[v3.10.3] - 2026-07-29"]},"700":{"title":"[v3.10.2] - 2026-07-25","titles":["📜 Version 3.x History"]},"701":{"title":"✨ Experimental AI Parsing","titles":["📜 Version 3.x History","[v3.10.2] - 2026-07-25"]},"702":{"title":"🪲 Bug Fixes & Stability","titles":["📜 Version 3.x History","[v3.10.2] - 2026-07-25"]},"703":{"title":"[v3.10.0] - 2026-07-19","titles":["📜 Version 3.x History"]},"704":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.10.0] - 2026-07-19"]},"705":{"title":"📚 Documentation Enhancements","titles":["📜 Version 3.x History","[v3.10.0] - 2026-07-19"]},"706":{"title":"[v3.9.0] - 2026-07-14","titles":["📜 Version 3.x History"]},"707":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.9.0] - 2026-07-14"]},"708":{"title":"📚 Documentation Enhancements","titles":["📜 Version 3.x History","[v3.9.0] - 2026-07-14"]},"709":{"title":"🪲 Bug Fixes & Stability","titles":["📜 Version 3.x History","[v3.9.0] - 2026-07-14"]},"710":{"title":"[v3.8.0] - 2026-07-11","titles":["📜 Version 3.x History"]},"711":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.8.0] - 2026-07-11"]},"712":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.8.0] - 2026-07-11"]},"713":{"title":"[v3.7.1] - 2026-07-09","titles":["📜 Version 3.x History"]},"714":{"title":"🪲 Bug Fix","titles":["📜 Version 3.x History","[v3.7.1] - 2026-07-09"]},"715":{"title":"[v3.7.0] - 2026-07-08","titles":["📜 Version 3.x History"]},"716":{"title":"✨ What\'s New — Runtime Version Registry","titles":["📜 Version 3.x History","[v3.7.0] - 2026-07-08"]},"717":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.7.0] - 2026-07-08"]},"718":{"title":"[v3.6.0] - 2026-07-05","titles":["📜 Version 3.x History"]},"719":{"title":"✨ What\'s New — Shorthand Mutation Keys","titles":["📜 Version 3.x History","[v3.6.0] - 2026-07-05"]},"720":{"title":"✨ What\'s New — Shorthand Duration Keys","titles":["📜 Version 3.x History","[v3.6.0] - 2026-07-05"]},"721":{"title":"[v3.5.2] - 2026-07-04","titles":["📜 Version 3.x History"]},"722":{"title":"✨ What\'s New — Minified Global Bundles","titles":["📜 Version 3.x History","[v3.5.2] - 2026-07-04"]},"723":{"title":"✨ What\'s New — Timezone Formatting Modifiers","titles":["📜 Version 3.x History","[v3.5.2] - 2026-07-04"]},"724":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.5.2] - 2026-07-04"]},"725":{"title":"[v3.5.1] - 2026-06-28","titles":["📜 Version 3.x History"]},"726":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.5.1] - 2026-06-28"]},"727":{"title":"[v3.5.0] - 2026-06-28","titles":["📜 Version 3.x History"]},"728":{"title":"✨ What\'s New — Unified Plugin API","titles":["📜 Version 3.x History","[v3.5.0] - 2026-06-28"]},"729":{"title":"📚 Documentation & Ecosystem","titles":["📜 Version 3.x History","[v3.5.0] - 2026-06-28"]},"730":{"title":"[v3.4.0] - 2026-06-26","titles":["📜 Version 3.x History"]},"731":{"title":"✨ What\'s New — Dynamic Format Tokens","titles":["📜 Version 3.x History","[v3.4.0] - 2026-06-26"]},"732":{"title":"✨ Compound Token Modifiers","titles":["📜 Version 3.x History","[v3.4.0] - 2026-06-26"]},"733":{"title":"[v3.3.1] - 2026-06-22","titles":["📜 Version 3.x History"]},"734":{"title":"✨ What\'s New — Slick Object Mutations","titles":["📜 Version 3.x History","[v3.3.1] - 2026-06-22"]},"735":{"title":"⚡ Extended Shorthand Modifiers","titles":["📜 Version 3.x History","[v3.3.1] - 2026-06-22"]},"736":{"title":"[v3.3.0] - 2026-06-21","titles":["📜 Version 3.x History"]},"737":{"title":"✨ What\'s New — Localized Modifier Registry","titles":["📜 Version 3.x History","[v3.3.0] - 2026-06-21"]},"738":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.3.0] - 2026-06-21"]},"739":{"title":"⚡ Slick Modifier Semantics","titles":["📜 Version 3.x History","[v3.3.0] - 2026-06-21"]},"740":{"title":"[v3.2.3] - 2026-06-20","titles":["📜 Version 3.x History"]},"741":{"title":"✨ What\'s New — Project Scaffolding","titles":["📜 Version 3.x History","[v3.2.3] - 2026-06-20"]},"742":{"title":"[v3.2.2] - 2026-06-18","titles":["📜 Version 3.x History"]},"743":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.2.2] - 2026-06-18"]},"744":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.2.2] - 2026-06-18"]},"745":{"title":"[v3.2.1] - 2026-06-17","titles":["📜 Version 3.x History"]},"746":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.2.1] - 2026-06-17"]},"747":{"title":"📚 Documentation & Ecosystem","titles":["📜 Version 3.x History","[v3.2.1] - 2026-06-17"]},"748":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.2.1] - 2026-06-17"]},"749":{"title":"[v3.2.0] - 2026-06-16","titles":["📜 Version 3.x History"]},"750":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.2.0] - 2026-06-16"]},"751":{"title":"📚 Documentation & Ecosystem","titles":["📜 Version 3.x History","[v3.2.0] - 2026-06-16"]},"752":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.2.0] - 2026-06-16"]},"753":{"title":"[v3.1.0] - 2026-06-13","titles":["📜 Version 3.x History"]},"754":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.1.0] - 2026-06-13"]},"755":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.1.0] - 2026-06-13"]},"756":{"title":"[v3.0.0] - 2026-06-08","titles":["📜 Version 3.x History"]},"757":{"title":"🚨 Major Breaking Changes","titles":["📜 Version 3.x History","[v3.0.0] - 2026-06-08"]},"758":{"title":"✨ What\'s New","titles":["📜 Version 3.x History","[v3.0.0] - 2026-06-08"]},"759":{"title":"📦 Migration Path for Tempo.ticker() Users","titles":["📜 Version 3.x History","[v3.0.0] - 2026-06-08"]},"760":{"title":"🏗️ Internal Refactoring","titles":["📜 Version 3.x History","[v3.0.0] - 2026-06-08"]},"761":{"title":"📜 Version 4.x History","titles":[]},"762":{"title":"[v4.7.0] - 2026-10-16","titles":["📜 Version 4.x History"]},"763":{"title":"🚀 Key Highlights & Developer Experience","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16"]},"764":{"title":"🌟 New Features & Developer Guide","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16"]},"765":{"title":"1. Roman Numeral Format Modifiers & Round-Trip Symmetry","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16","🌟 New Features & Developer Guide"]},"766":{"title":"2. Archival & Inscription Date Lexing","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16","🌟 New Features & Developer Guide"]},"767":{"title":"3. Smart Sequence Guard Validation","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16","🌟 New Features & Developer Guide"]},"768":{"title":"4. Canonical ISO Week-Numbering Getters (.woy & .yow)","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16","🌟 New Features & Developer Guide"]},"769":{"title":"5. Object Key Assertion Primitives & Disambiguation","titles":["📜 Version 4.x History","[v4.7.0] - 2026-10-16","🌟 New Features & Developer Guide"]},"770":{"title":"[v4.6.0] - 2026-10-11","titles":["📜 Version 4.x History"]},"771":{"title":"🚀 Key Highlights & Developer Experience","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11"]},"772":{"title":"🌟 New Features & Protocol Architecture","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11"]},"773":{"title":"1. Well-Known Symbol Lifecycle Protocol (TermHook)","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"774":{"title":"2. Native Term Units in .until() & .since()","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"775":{"title":"3. Standard & Celestial Terms Lifecycle Integration","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"776":{"title":"4. Unified Tempo.enums Namespace & Extensible Ordinals","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"777":{"title":"5. Shorthand Boundary Mutations","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"778":{"title":"6. Dialect Mask Precision & Engine Optimization","titles":["📜 Version 4.x History","[v4.6.0] - 2026-10-11","🌟 New Features & Protocol Architecture"]},"779":{"title":"[v4.5.1] - 2026-10-05","titles":["📜 Version 4.x History"]},"780":{"title":"🚀 Key Highlights & Developer Experience","titles":["📜 Version 4.x History","[v4.5.1] - 2026-10-05"]},"781":{"title":"🌟 Improvements & Fixes","titles":["📜 Version 4.x History","[v4.5.1] - 2026-10-05"]},"782":{"title":"1. Dynamic Plugin Registry Resilience","titles":["📜 Version 4.x History","[v4.5.1] - 2026-10-05","🌟 Improvements & Fixes"]},"783":{"title":"[v4.5.0] - 2026-10-02","titles":["📜 Version 4.x History"]},"784":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.5.0] - 2026-10-02"]},"785":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.5.0] - 2026-10-02"]},"786":{"title":"1. Structured t.intl Sub-Namespace (intl.info & intl.locale)","titles":["📜 Version 4.x History","[v4.5.0] - 2026-10-02","🌟 New Features & Improvements"]},"787":{"title":"2. Tempo.intl Formatter Hub","titles":["📜 Version 4.x History","[v4.5.0] - 2026-10-02","🌟 New Features & Improvements"]},"788":{"title":"3. Advanced Format & Translation Capabilities","titles":["📜 Version 4.x History","[v4.5.0] - 2026-10-02","🌟 New Features & Improvements"]},"789":{"title":"[v4.4.4] - 2026-09-30","titles":["📜 Version 4.x History"]},"790":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.4.4] - 2026-09-30"]},"791":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.4.4] - 2026-09-30"]},"792":{"title":"1. Reactive Stream Engine (Reactive<T>)","titles":["📜 Version 4.x History","[v4.4.4] - 2026-09-30","🌟 New Features & Improvements"]},"793":{"title":"2. Ergonomic Type Casting (cast<T>())","titles":["📜 Version 4.x History","[v4.4.4] - 2026-09-30","🌟 New Features & Improvements"]},"794":{"title":"[v4.4.3] - 2026-09-29","titles":["📜 Version 4.x History"]},"795":{"title":"🚀 Key Highlights & Performance Boosts","titles":["📜 Version 4.x History","[v4.4.3] - 2026-09-29"]},"796":{"title":"🌟 New Features & Performance","titles":["📜 Version 4.x History","[v4.4.3] - 2026-09-29"]},"797":{"title":"1. Public Weak Object Cache (Tempo.cache.weak)","titles":["📜 Version 4.x History","[v4.4.3] - 2026-09-29","🌟 New Features & Performance"]},"798":{"title":"2. Automated Regular Expression & Date Interning","titles":["📜 Version 4.x History","[v4.4.3] - 2026-09-29","🌟 New Features & Performance"]},"799":{"title":"[v4.4.2] - 2026-09-27","titles":["📜 Version 4.x History"]},"800":{"title":"🚀 Key Highlights & Fixes","titles":["📜 Version 4.x History","[v4.4.2] - 2026-09-27"]},"801":{"title":"🌟 Improvements & Fixes","titles":["📜 Version 4.x History","[v4.4.2] - 2026-09-27"]},"802":{"title":"1. Unicode Multi-Script Keyword Matching","titles":["📜 Version 4.x History","[v4.4.2] - 2026-09-27","🌟 Improvements & Fixes"]},"803":{"title":"[v4.4.1] - 2026-09-20","titles":["📜 Version 4.x History"]},"804":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.4.1] - 2026-09-20"]},"805":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.4.1] - 2026-09-20"]},"806":{"title":"1. Core Braced Format Mask Parsing & Wildcard Matching","titles":["📜 Version 4.x History","[v4.4.1] - 2026-09-20","🌟 New Features & Improvements"]},"807":{"title":"2. Dynamic Evaluable<T> Format & Dialect Resolution","titles":["📜 Version 4.x History","[v4.4.1] - 2026-09-20","🌟 New Features & Improvements"]},"808":{"title":"3. Dialects Plugin Integration (@magmacomputing/tempo-plugin-dialects)","titles":["📜 Version 4.x History","[v4.4.1] - 2026-09-20","🌟 New Features & Improvements"]},"809":{"title":"[v4.4.0] - 2026-09-18","titles":["📜 Version 4.x History"]},"810":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.4.0] - 2026-09-18"]},"811":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.4.0] - 2026-09-18"]},"812":{"title":"1. Zero-Boilerplate Side-Effect Imports (/install)","titles":["📜 Version 4.x History","[v4.4.0] - 2026-09-18","🌟 New Features & Improvements"]},"813":{"title":"[v4.3.0] - 2026-09-16","titles":["📜 Version 4.x History"]},"814":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16"]},"815":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16"]},"816":{"title":"1. Colocated Plugin Options & Callable Factories","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16","🌟 New Features & Improvements"]},"817":{"title":"2. Intl.Locale Info & Culturally Authentic Calendars (t.intl)","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16","🌟 New Features & Improvements"]},"818":{"title":"3. Direct Native Temporal Gateway (t.zdt)","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16","🌟 New Features & Improvements"]},"819":{"title":"4. Day-of-Year Property & Token (t.doy, {doy})","titles":["📜 Version 4.x History","[v4.3.0] - 2026-09-16","🌟 New Features & Improvements"]},"820":{"title":"[v4.2.0] - 2026-09-09","titles":["📜 Version 4.x History"]},"821":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.2.0] - 2026-09-09"]},"822":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.2.0] - 2026-09-09"]},"823":{"title":"1. Dynamic Namespace & Spatial Tokens in t.format()","titles":["📜 Version 4.x History","[v4.2.0] - 2026-09-09","🌟 New Features & Improvements"]},"824":{"title":"2. Universal Geographic Context & Hemisphere Inferences","titles":["📜 Version 4.x History","[v4.2.0] - 2026-09-09","🌟 New Features & Improvements"]},"825":{"title":"3. Hardened Static Configuration Resolution","titles":["📜 Version 4.x History","[v4.2.0] - 2026-09-09","🌟 New Features & Improvements"]},"826":{"title":"[v4.1.0] - 2026-09-04","titles":["📜 Version 4.x History"]},"827":{"title":"🚀 Key Highlights & Architectural Enhancements","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04"]},"828":{"title":"🌟 New Features & Improvements","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04"]},"829":{"title":"1. Remote & Cascading Configuration Resolution (resolveConfig)","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04","🌟 New Features & Improvements"]},"830":{"title":"2. Dedicated pluginOptions Configuration Slot","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04","🌟 New Features & Improvements"]},"831":{"title":"3. Overloaded Tempo.create() & Deterministic Resource Disposal","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04","🌟 New Features & Improvements"]},"832":{"title":"4. Architectural Separation of extends and plugins","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04","🌟 New Features & Improvements"]},"833":{"title":"🐛 Bug Fixes","titles":["📜 Version 4.x History","[v4.1.0] - 2026-09-04"]},"834":{"title":"[v4.0.0] - 2026-08-27","titles":["📜 Version 4.x History"]},"835":{"title":"🚀 Key Highlights & Paradigm Shifts","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27"]},"836":{"title":"🚨 Major Breaking Changes","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27"]},"837":{"title":"🌟 New Features & Architectural Modernizations","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27"]},"838":{"title":"1. Dynamic Functional Context (DFC) & Options Evaluation","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27","🌟 New Features & Architectural Modernizations"]},"839":{"title":"2. Synchronous JSON & JSONC Config Discovery (resolveConfigSync)","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27","🌟 New Features & Architectural Modernizations"]},"840":{"title":"3. Standardized Plugin SDK Facade (@magmacomputing/tempo/plugin/sdk)","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27","🌟 New Features & Architectural Modernizations"]},"841":{"title":"4. Expanded Utility Stack Exports (@magmacomputing/tempo/library)","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27","🌟 New Features & Architectural Modernizations"]},"842":{"title":"5. API Standardization for Boundary & Mutation Payloads ({Term: Value})","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27","🌟 New Features & Architectural Modernizations"]},"843":{"title":"🗑️ API Removals & Cleanups","titles":["📜 Version 4.x History","[v4.0.0] - 2026-08-27"]},"844":{"title":"Tempo Plugin Setup Guide","titles":[]},"845":{"title":"1. Overview","titles":["Tempo Plugin Setup Guide"]},"846":{"title":"2. Installation","titles":["Tempo Plugin Setup Guide"]},"847":{"title":"3. Registration & Activation","titles":["Tempo Plugin Setup Guide"]},"848":{"title":"Option A: Initialization Option (Recommended)","titles":["Tempo Plugin Setup Guide","3. Registration & Activation"]},"849":{"title":"Option B: Explicit Extension (Tempo.extend)","titles":["Tempo Plugin Setup Guide","3. Registration & Activation"]},"850":{"title":"4. Browser & Global Namespace Usage","titles":["Tempo Plugin Setup Guide"]},"851":{"title":"5. Authoring Custom Plugins","titles":["Tempo Plugin Setup Guide"]},"852":{"title":"Provider Architecture & Security","titles":[]},"853":{"title":"Bring Your Own Key (BYOK) & Zero-Config Discovery","titles":["Provider Architecture & Security"]},"854":{"title":"Advanced Configuration (Custom Models & LLM Options)","titles":["Provider Architecture & Security","Bring Your Own Key (BYOK) & Zero-Config Discovery"]},"855":{"title":"Per-Request Lazy Resolution & Fallback Defaults","titles":["Provider Architecture & Security","Bring Your Own Key (BYOK) & Zero-Config Discovery"]},"856":{"title":"Dynamic Provider Manifests & Remote Endpoint Trust","titles":["Provider Architecture & Security","Bring Your Own Key (BYOK) & Zero-Config Discovery"]},"857":{"title":"Frontend Security Warning","titles":["Provider Architecture & Security","Bring Your Own Key (BYOK) & Zero-Config Discovery"]},"858":{"title":"Browser & Client-Side Proxy Architecture","titles":["Provider Architecture & Security"]},"859":{"title":"1. Browser Configuration Example","titles":["Provider Architecture & Security","Browser & Client-Side Proxy Architecture"]},"860":{"title":"2. Backend Proxy Handler Example (Next.js / Cloudflare Worker / Express)","titles":["Provider Architecture & Security","Browser & Client-Side Proxy Architecture"]},"861":{"title":"🔒 Security & Privacy Guarantees","titles":["Provider Architecture & Security"]},"862":{"title":"1. Transport Security (HTTPS / TLS)","titles":["Provider Architecture & Security","🔒 Security & Privacy Guarantees"]},"863":{"title":"2. Ephemeral Processing & Cache Retention Controls","titles":["Provider Architecture & Security","🔒 Security & Privacy Guarantees"]},"864":{"title":"3. In-Memory Credential Redaction & Immutability","titles":["Provider Architecture & Security","🔒 Security & Privacy Guarantees"]},"865":{"title":"4. Deterministic Schema Guardrails & Confidence Range Verification","titles":["Provider Architecture & Security","🔒 Security & Privacy Guarantees"]},"866":{"title":"5. Partitioned Caching & Fail-Open Storage Resilience","titles":["Provider Architecture & Security","🔒 Security & Privacy Guarantees"]},"867":{"title":"Multi-Provider Execution Strategies (AiMode)","titles":["Provider Architecture & Security"]},"868":{"title":"Provider ID Canonicalization","titles":["Provider Architecture & Security","Multi-Provider Execution Strategies (AiMode)"]},"869":{"title":"contextAI — Context & Regional Inference","titles":[]},"870":{"title":"Basic Usage","titles":["contextAI — Context & Regional Inference"]},"871":{"title":"Configuration Options (AiContextOptions)","titles":["contextAI — Context & Regional Inference"]},"872":{"title":"Result Schema (TempoContext)","titles":["contextAI — Context & Regional Inference"]},"873":{"title":"Key Architectural Behaviors","titles":["contextAI — Context & Regional Inference"]},"874":{"title":"1. Workspace Baseline Context","titles":["contextAI — Context & Regional Inference","Key Architectural Behaviors"]},"875":{"title":"2. Strict Confidence Thresholds","titles":["contextAI — Context & Regional Inference","Key Architectural Behaviors"]},"876":{"title":"3. Timezone Validation","titles":["contextAI — Context & Regional Inference","Key Architectural Behaviors"]},"877":{"title":"4. Parallel Batch Processing","titles":["contextAI — Context & Regional Inference","Key Architectural Behaviors"]},"878":{"title":"Combining contextAI with parseAI (The Pivot Flow)","titles":["contextAI — Context & Regional Inference","Key Architectural Behaviors"]},"879":{"title":"diffAI — Contextual & Business Date Deltas","titles":[]},"880":{"title":"Basic Usage","titles":["diffAI — Contextual & Business Date Deltas"]},"881":{"title":"Configuration Options (AiDiffOptions)","titles":["diffAI — Contextual & Business Date Deltas"]},"882":{"title":"Result Schema (TempoAiDiffResult)","titles":["diffAI — Contextual & Business Date Deltas"]},"883":{"title":"Key Architectural Behaviors","titles":["diffAI — Contextual & Business Date Deltas"]},"884":{"title":"1. Native Grounding Context","titles":["diffAI — Contextual & Business Date Deltas","Key Architectural Behaviors"]},"885":{"title":"2. Public Holiday Exclusions","titles":["diffAI — Contextual & Business Date Deltas","Key Architectural Behaviors"]},"886":{"title":"3. Directional Awareness & Reverse Intervals","titles":["diffAI — Contextual & Business Date Deltas","Key Architectural Behaviors"]},"887":{"title":"4. Parallel Batch Processing","titles":["diffAI — Contextual & Business Date Deltas","Key Architectural Behaviors"]},"888":{"title":"extractAI — Unstructured Text & Calendar Event Extraction","titles":[]},"889":{"title":"Basic Usage","titles":["extractAI — Unstructured Text & Calendar Event Extraction"]},"890":{"title":"Configuration Options (AiExtractOptions)","titles":["extractAI — Unstructured Text & Calendar Event Extraction"]},"891":{"title":"Result Schema (TempoAiExtractResult)","titles":["extractAI — Unstructured Text & Calendar Event Extraction"]},"892":{"title":"Key Architectural Behaviors","titles":["extractAI — Unstructured Text & Calendar Event Extraction"]},"893":{"title":"1. Mathematical Grounding & Hallucination Suppression","titles":["extractAI — Unstructured Text & Calendar Event Extraction","Key Architectural Behaviors"]},"894":{"title":"2. Native Tempo Instances","titles":["extractAI — Unstructured Text & Calendar Event Extraction","Key Architectural Behaviors"]},"895":{"title":"3. Multi-Tier Distributed Caching","titles":["extractAI — Unstructured Text & Calendar Event Extraction","Key Architectural Behaviors"]},"896":{"title":"4. Parallel Batch Extraction","titles":["extractAI — Unstructured Text & Calendar Event Extraction","Key Architectural Behaviors"]},"897":{"title":"formatAI — Contextual & Narrative Date Formatting","titles":[]},"898":{"title":"Basic Usage","titles":["formatAI — Contextual & Narrative Date Formatting"]},"899":{"title":"Configuration Options (AiFormatOptions)","titles":["formatAI — Contextual & Narrative Date Formatting"]},"900":{"title":"Result Schema (TempoAiFormatResult)","titles":["formatAI — Contextual & Narrative Date Formatting"]},"901":{"title":"Key Architectural Behaviors","titles":["formatAI — Contextual & Narrative Date Formatting"]},"902":{"title":"1. Native Grounding Context","titles":["formatAI — Contextual & Narrative Date Formatting","Key Architectural Behaviors"]},"903":{"title":"2. TC39 Temporal & Universal Interoperability","titles":["formatAI — Contextual & Narrative Date Formatting","Key Architectural Behaviors"]},"904":{"title":"3. Multi-Tier Distributed Caching","titles":["formatAI — Contextual & Narrative Date Formatting","Key Architectural Behaviors"]},"905":{"title":"4. Parallel Batch Formatting","titles":["formatAI — Contextual & Narrative Date Formatting","Key Architectural Behaviors"]},"906":{"title":"Grounding & Natural Language Parsing","titles":[]},"907":{"title":"Temporal & Regional Grounding","titles":["Grounding & Natural Language Parsing"]},"908":{"title":"Custom Grounding Anchors & Options","titles":["Grounding & Natural Language Parsing","Temporal & Regional Grounding"]},"909":{"title":"Why Cultural & Regional Grounding is Critical","titles":["Grounding & Natural Language Parsing","Temporal & Regional Grounding"]},"910":{"title":"The Decoupled Output Bridge","titles":["Grounding & Natural Language Parsing"]},"911":{"title":"Relative Date Ambiguity Tie-Breakers","titles":["Grounding & Natural Language Parsing","The Decoupled Output Bridge"]},"912":{"title":"Confidence Thresholds & Metadata Handling","titles":["Grounding & Natural Language Parsing","The Decoupled Output Bridge"]},"913":{"title":"@magmacomputing/tempo-plugin-ai","titles":[]},"914":{"title":"Installation & Quickstart","titles":["@magmacomputing/tempo-plugin-ai"]},"915":{"title":"Two Usage Patterns: Namespace vs Tree-Shakeable Functions","titles":["@magmacomputing/tempo-plugin-ai"]},"916":{"title":"Pattern A: Tempo.ai Cohesive Namespace","titles":["@magmacomputing/tempo-plugin-ai","Two Usage Patterns: Namespace vs Tree-Shakeable Functions"]},"917":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-ai","Two Usage Patterns: Namespace vs Tree-Shakeable Functions","Pattern A: Tempo.ai Cohesive Namespace"]},"918":{"title":"Pattern B: Tree-Shakeable Standalone Functions","titles":["@magmacomputing/tempo-plugin-ai","Two Usage Patterns: Namespace vs Tree-Shakeable Functions"]},"919":{"title":"AI Function Catalog","titles":["@magmacomputing/tempo-plugin-ai"]},"920":{"title":"Summary of Distinct Return Contracts","titles":["@magmacomputing/tempo-plugin-ai","AI Function Catalog"]},"921":{"title":"Architecture & Infrastructure Guides","titles":["@magmacomputing/tempo-plugin-ai"]},"922":{"title":"Community Feedback & Production Notice","titles":["@magmacomputing/tempo-plugin-ai"]},"923":{"title":"Licensing","titles":["@magmacomputing/tempo-plugin-ai"]},"924":{"title":"initAI — Provider Initialization & Farm Configuration","titles":[]},"925":{"title":"Zero-Config Auto-Discovery","titles":["initAI — Provider Initialization & Farm Configuration"]},"926":{"title":"Configuration Resolution Order","titles":["initAI — Provider Initialization & Farm Configuration","Zero-Config Auto-Discovery"]},"927":{"title":"tempo.config.json Example","titles":["initAI — Provider Initialization & Farm Configuration","Zero-Config Auto-Discovery"]},"928":{"title":"Basic Usage (Explicit Configuration)","titles":["initAI — Provider Initialization & Farm Configuration"]},"929":{"title":"Single Provider Shorthand","titles":["initAI — Provider Initialization & Farm Configuration","Basic Usage (Explicit Configuration)"]},"930":{"title":"Multi-Provider Configuration","titles":["initAI — Provider Initialization & Farm Configuration","Basic Usage (Explicit Configuration)"]},"931":{"title":"Global Backend Proxy (endpoint)","titles":["initAI — Provider Initialization & Farm Configuration","Basic Usage (Explicit Configuration)"]},"932":{"title":"Custom Gateway Endpoints","titles":["initAI — Provider Initialization & Farm Configuration","Basic Usage (Explicit Configuration)"]},"933":{"title":"Dynamic Provider Credentials & Context Suppliers","titles":["initAI — Provider Initialization & Farm Configuration","Basic Usage (Explicit Configuration)"]},"934":{"title":"Execution Modes & Multi-Provider Options","titles":["initAI — Provider Initialization & Farm Configuration"]},"935":{"title":"Timeout Controls & SLAs","titles":["initAI — Provider Initialization & Farm Configuration"]},"936":{"title":"Operational Trace Logging & Debugging","titles":["initAI — Provider Initialization & Farm Configuration"]},"937":{"title":"Configuration Options Reference","titles":["initAI — Provider Initialization & Farm Configuration"]},"938":{"title":"TypeScript Interface","titles":["initAI — Provider Initialization & Farm Configuration","Configuration Options Reference"]},"939":{"title":"Multi-Provider Execution Modes (AiMode)","titles":[]},"940":{"title":"Strategy Comparison","titles":["Multi-Provider Execution Modes (AiMode)"]},"941":{"title":"Global Telemetry & Cooldown Filtering","titles":["Multi-Provider Execution Modes (AiMode)"]},"942":{"title":"Proactive Cooldown Avoidance","titles":["Multi-Provider Execution Modes (AiMode)","Global Telemetry & Cooldown Filtering"]},"943":{"title":"Dispatch Decision Guide","titles":["Multi-Provider Execution Modes (AiMode)"]},"944":{"title":"Mode Deep-Dives & Code Examples","titles":["Multi-Provider Execution Modes (AiMode)"]},"945":{"title":"1. AiMode.Fallback — Sequential Cascade (Default)","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"946":{"title":"2. AiMode.Hedged — Speculative Latency Hedging","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"947":{"title":"3. AiMode.RoundRobin — Multi-Key Cyclic Load Balancing","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"948":{"title":"4. AiMode.Adaptive — Rate-Limit Telemetry Prioritization","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"949":{"title":"5. AiMode.Race — Speculative Parallel Execution","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"950":{"title":"6. AiMode.Consensus — Multi-LLM Cross-Validation","titles":["Multi-Provider Execution Modes (AiMode)","Mode Deep-Dives & Code Examples"]},"951":{"title":"AI Configuration & Onboarding Guide","titles":[]},"952":{"title":"3-Tier Configuration Architecture","titles":["AI Configuration & Onboarding Guide"]},"953":{"title":"Tier Comparison Matrix","titles":["AI Configuration & Onboarding Guide","3-Tier Configuration Architecture"]},"954":{"title":"Tier 1: Tempo Trial Sandbox (Evaluation)","titles":["AI Configuration & Onboarding Guide"]},"955":{"title":"Tier 2: Backend Proxy (Recommended for Web Apps)","titles":["AI Configuration & Onboarding Guide"]},"956":{"title":"Tier 3: Direct Keys & Environment Variables (Server-Side)","titles":["AI Configuration & Onboarding Guide"]},"957":{"title":"Method A: Environment Variables (Auto-Discovery)","titles":["AI Configuration & Onboarding Guide","Tier 3: Direct Keys & Environment Variables (Server-Side)"]},"958":{"title":"Method B: Explicit initAI","titles":["AI Configuration & Onboarding Guide","Tier 3: Direct Keys & Environment Variables (Server-Side)"]},"959":{"title":"Configuration Parameter Reference","titles":["AI Configuration & Onboarding Guide"]},"960":{"title":"parseAI — Natural Language Point-in-Time Parsing","titles":[]},"961":{"title":"Basic Usage","titles":["parseAI — Natural Language Point-in-Time Parsing"]},"962":{"title":"Options & Overrides","titles":["parseAI — Natural Language Point-in-Time Parsing"]},"963":{"title":"Multi-Provider Execution Modes","titles":["parseAI — Natural Language Point-in-Time Parsing"]},"964":{"title":"Batch Array Parsing","titles":["parseAI — Natural Language Point-in-Time Parsing"]},"965":{"title":"Diagnostic Metadata (.ai)","titles":["parseAI — Natural Language Point-in-Time Parsing"]},"966":{"title":"Rate Limits & Cache Management","titles":[]},"967":{"title":"Tracking Quota Real-time","titles":["Rate Limits & Cache Management"]},"968":{"title":"1. Request-Locked Instance Metadata (dt.ai.limits)","titles":["Rate Limits & Cache Management","Tracking Quota Real-time"]},"969":{"title":"2. Global State Utility (getAiRateLimits())","titles":["Rate Limits & Cache Management","Tracking Quota Real-time"]},"970":{"title":"Handling Quota Exhaustion (429s)","titles":["Rate Limits & Cache Management"]},"971":{"title":"Cache Management","titles":["Rate Limits & Cache Management"]},"972":{"title":"Array Processing & Token Economics","titles":["Rate Limits & Cache Management","Cache Management"]},"973":{"title":"Soft Errors in Array Batches","titles":["Rate Limits & Cache Management","Cache Management"]},"974":{"title":"Static Glossary Seeding","titles":["Rate Limits & Cache Management","Cache Management"]},"975":{"title":"Bypassing Cache & Forcing Network Requests","titles":["Rate Limits & Cache Management","Cache Management"]},"976":{"title":"Evicting Bad Parses","titles":["Rate Limits & Cache Management","Cache Management"]},"977":{"title":"Forcing a Refresh","titles":["Rate Limits & Cache Management","Cache Management"]},"978":{"title":"Extensible Caching & Async Storage Adapters (AiCacheAdapter)","titles":["Rate Limits & Cache Management","Cache Management"]},"979":{"title":"Cascading TTL Resolution Policies","titles":["Rate Limits & Cache Management","Cache Management"]},"980":{"title":"Fail-Open Cache Resilience","titles":["Rate Limits & Cache Management","Cache Management"]},"981":{"title":"recurrenceAI — Recurrence Rules & Schedule Translation","titles":[]},"982":{"title":"Basic Usage","titles":["recurrenceAI — Recurrence Rules & Schedule Translation"]},"983":{"title":"Stateful Paged Batching (.take(n))","titles":["recurrenceAI — Recurrence Rules & Schedule Translation"]},"984":{"title":"Native RRULE Parsing (Zero Network Overhead)","titles":["recurrenceAI — Recurrence Rules & Schedule Translation"]},"985":{"title":"Lazy Iteration (for...of)","titles":["recurrenceAI — Recurrence Rules & Schedule Translation"]},"986":{"title":"Result Interface","titles":["recurrenceAI — Recurrence Rules & Schedule Translation"]},"987":{"title":"scheduleAI — Intelligent Appointment Booking & Conflict Resolution","titles":[]},"988":{"title":"Basic Usage","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution"]},"989":{"title":"Configuration Options (TempoScheduleOptions)","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution"]},"990":{"title":"TempoInterval Interface","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution","Configuration Options (TempoScheduleOptions)"]},"991":{"title":"Event Input Shape (ScheduleEventInput)","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution","Configuration Options (TempoScheduleOptions)"]},"992":{"title":"Result Schema (TempoScheduleResult)","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution"]},"993":{"title":"Internal Conflict Bumping Engine","titles":["scheduleAI — Intelligent Appointment Booking & Conflict Resolution"]},"994":{"title":"Security & Privacy Architecture","titles":[]},"995":{"title":"1. Smart Debug Telemetry & PII Hardening","titles":["Security & Privacy Architecture"]},"996":{"title":"Universal Environment Detection & Zero-Config Safety","titles":["Security & Privacy Architecture","1. Smart Debug Telemetry & PII Hardening"]},"997":{"title":"Automatic PII Redaction","titles":["Security & Privacy Architecture","1. Smart Debug Telemetry & PII Hardening"]},"998":{"title":"2. Tamper-Resistant Proxy Introspection","titles":["Security & Privacy Architecture"]},"999":{"title":"3. Transport Security & Network Hardening","titles":["Security & Privacy Architecture"]},"1000":{"title":"Enforced HTTPS / TLS","titles":["Security & Privacy Architecture","3. Transport Security & Network Hardening"]},"1001":{"title":"Dynamic Manifest Host Verification","titles":["Security & Privacy Architecture","3. Transport Security & Network Hardening"]},"1002":{"title":"4. Credential Isolation & BYOK Architecture","titles":["Security & Privacy Architecture"]},"1003":{"title":"Automated In-Memory Key Redaction","titles":["Security & Privacy Architecture","4. Credential Isolation & BYOK Architecture"]},"1004":{"title":"Dynamic Secret Vaults & Automated Key Rotation","titles":["Security & Privacy Architecture","4. Credential Isolation & BYOK Architecture"]},"1005":{"title":"Frontend Zero-Storage Principle","titles":["Security & Privacy Architecture","4. Credential Isolation & BYOK Architecture"]},"1006":{"title":"5. Ephemeral Processing, Partitioned Caching & Trial Gateway Data Handling","titles":["Security & Privacy Architecture"]},"1007":{"title":"Local Libraries Zero Telemetry Architecture","titles":["Security & Privacy Architecture","5. Ephemeral Processing, Partitioned Caching & Trial Gateway Data Handling"]},"1008":{"title":"Trial Sandbox Gateway (provider: \'tempo\') Data Handling & Diagnostics","titles":["Security & Privacy Architecture","5. Ephemeral Processing, Partitioned Caching & Trial Gateway Data Handling"]},"1009":{"title":"Partitioned Multi-Tier Caching","titles":["Security & Privacy Architecture","5. Ephemeral Processing, Partitioned Caching & Trial Gateway Data Handling"]},"1010":{"title":"6. Schema Enforcement & Hallucination Defense","titles":["Security & Privacy Architecture"]},"1011":{"title":"7. Residual Risks & Threat Model Matrix","titles":["Security & Privacy Architecture"]},"1012":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1013":{"title":"1. Natural Language Booking: Ambiguous Input to Validated Tempo","titles":["Production Use Cases & Architectural Patterns"]},"1014":{"title":"2. Converting Natural Language Recurrence to RFC 5545 RRULE","titles":["Production Use Cases & Architectural Patterns"]},"1015":{"title":"3. Conflict-Free Slot Scheduling Around Busy Calendar Events","titles":["Production Use Cases & Architectural Patterns"]},"1016":{"title":"4. Contextual Narrative Summaries for Customer Notifications","titles":["Production Use Cases & Architectural Patterns"]},"1017":{"title":"5. Enterprise PII Masking & Air-Gapped Fallback","titles":["Production Use Cases & Architectural Patterns"]},"1018":{"title":"@magmacomputing/tempo-plugin-batch","titles":[]},"1019":{"title":"🚀 Installation & Quickstart","titles":["@magmacomputing/tempo-plugin-batch"]},"1020":{"title":"Zero-Boilerplate Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-batch","🚀 Installation & Quickstart"]},"1021":{"title":"📚 API Surface Catalog","titles":["@magmacomputing/tempo-plugin-batch"]},"1022":{"title":"Configuration Options (BatchOptions)","titles":["@magmacomputing/tempo-plugin-batch","📚 API Surface Catalog"]},"1023":{"title":"Supported Mutation Operations","titles":["@magmacomputing/tempo-plugin-batch","📚 API Surface Catalog"]},"1024":{"title":"📖 Architecture & Specialized Guides","titles":["@magmacomputing/tempo-plugin-batch"]},"1025":{"title":"📄 Licensing","titles":["@magmacomputing/tempo-plugin-batch"]},"1026":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1027":{"title":"1. High-Throughput IoT Telemetry Skew Normalization","titles":["Production Use Cases & Architectural Patterns"]},"1028":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","1. High-Throughput IoT Telemetry Skew Normalization"]},"1029":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","1. High-Throughput IoT Telemetry Skew Normalization"]},"1030":{"title":"Production Implementation","titles":["Production Use Cases & Architectural Patterns","1. High-Throughput IoT Telemetry Skew Normalization"]},"1031":{"title":"2. Financial Tick Data Backtesting & Interval Rolling","titles":["Production Use Cases & Architectural Patterns"]},"1032":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","2. Financial Tick Data Backtesting & Interval Rolling"]},"1033":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","2. Financial Tick Data Backtesting & Interval Rolling"]},"1034":{"title":"3. Large-Scale CSV Payroll Date Processing","titles":["Production Use Cases & Architectural Patterns"]},"1035":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","3. Large-Scale CSV Payroll Date Processing"]},"1036":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","3. Large-Scale CSV Payroll Date Processing"]},"1037":{"title":"Parallel Worker Pool & SharedArrayBuffer Architecture","titles":[]},"1038":{"title":"Dual-Mode Execution Engine","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture"]},"1039":{"title":"Mode A: Lock-Free SharedArrayBuffer (High Throughput)","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture","Dual-Mode Execution Engine"]},"1040":{"title":"Mode B: postMessage Structural Cloning (Graceful Degradation)","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture","Dual-Mode Execution Engine"]},"1041":{"title":"Worker Process Isolation & CLI Flag Sanitization","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture"]},"1042":{"title":"Performance Trade-Off: Raw Epochs vs Hydration","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture"]},"1043":{"title":"Benchmark Guidance","titles":["Parallel Worker Pool & SharedArrayBuffer Architecture","Performance Trade-Off: Raw Epochs vs Hydration"]},"1044":{"title":"Astronomical Seasons, Solstices & Equinoxes","titles":[]},"1045":{"title":"1. Overview & Mechanics","titles":["Astronomical Seasons, Solstices & Equinoxes"]},"1046":{"title":"2. Astronomical Events & Quarters","titles":["Astronomical Seasons, Solstices & Equinoxes"]},"1047":{"title":"3. Scoped Ephemeris Details (t.term.astronomy)","titles":["Astronomical Seasons, Solstices & Equinoxes"]},"1048":{"title":"4. Querying Specific Astronomical Events (t.term.equinox / t.term.solstice)","titles":["Astronomical Seasons, Solstices & Equinoxes"]},"1049":{"title":"5. Standalone Usage","titles":["Astronomical Seasons, Solstices & Equinoxes"]},"1050":{"title":"@magmacomputing/tempo-plugin-celestial","titles":[]},"1051":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-celestial"]},"1052":{"title":"Documentation Guide","titles":["@magmacomputing/tempo-plugin-celestial"]},"1053":{"title":"Features Overview","titles":["@magmacomputing/tempo-plugin-celestial"]},"1054":{"title":"Geographic Coordinates & Null Contract","titles":["@magmacomputing/tempo-plugin-celestial"]},"1055":{"title":"Quickstart","titles":["@magmacomputing/tempo-plugin-celestial"]},"1056":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-celestial","Quickstart"]},"1057":{"title":"Licensing","titles":["@magmacomputing/tempo-plugin-celestial"]},"1058":{"title":"Lunar Ephemeris, Phases & Topocentric Position","titles":[]},"1059":{"title":"1. Lunar Phase Cycles (t.term.moon / t.term.lunar)","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1060":{"title":"2. Hemisphere-Aware Visual Emoji (lunar.emoji)","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1061":{"title":"3. Location-Aware Horizon & Transit Events","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1062":{"title":"4. Real-Time Topocentric Sky Position","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1063":{"title":"5. Crescent Tilt & Bright Limb Angle (lunar.crescentTiltDeg)","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1064":{"title":"6. Distance, Apparent Size, Supermoons & Micromoons","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1065":{"title":"7. Local Solar & Lunar Eclipse Obscuration (lunar.eclipse & lunar.obscuration)","titles":["Lunar Ephemeris, Phases & Topocentric Position"]},"1066":{"title":"Solar Day Cycles, Ephemeris & Apparent Solar Time","titles":[]},"1067":{"title":"1. Solar Phase States (t.term.sun / t.term.solar)","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1068":{"title":"2. Apparent Solar Noon (t.term.solar.noon)","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1069":{"title":"3. Local Apparent Solar Time (t.term.solar.solarTime)","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1070":{"title":"4. Atmospheric Elevation Dip Correction (elevation)","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1071":{"title":"5. Real-Time Solar Coordinates & Photometric Hours","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1072":{"title":"6. Polar Regions Handling (Midnight Sun & Polar Night)","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1073":{"title":"7. Twilight Range Boundaries","titles":["Solar Day Cycles, Ephemeris & Apparent Solar Time"]},"1074":{"title":"Astronomical Tidal Mechanics & Coastal Predictions","titles":[]},"1075":{"title":"1. Deterministic Astronomical Calculations","titles":["Astronomical Tidal Mechanics & Coastal Predictions"]},"1076":{"title":"2. Tidal States (t.term.tide / t.term.tides.state)","titles":["Astronomical Tidal Mechanics & Coastal Predictions"]},"1077":{"title":"3. King Tides & Perigee Factor (isKingTide / perigeeFactor)","titles":["Astronomical Tidal Mechanics & Coastal Predictions"]},"1078":{"title":"4. Local Coastal Tide Predictions & Port Calibration","titles":["Astronomical Tidal Mechanics & Coastal Predictions"]},"1079":{"title":"5. Lunar Tidal Cycle Minutes (lunarTideMinute)","titles":["Astronomical Tidal Mechanics & Coastal Predictions"]},"1080":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1081":{"title":"1. Photovoltaic (PV) Solar Inverter & Battery Storage Orchestration","titles":["Production Use Cases & Architectural Patterns"]},"1082":{"title":"2. Smart Agriculture & Greenhouse Supplemental Lighting","titles":["Production Use Cases & Architectural Patterns"]},"1083":{"title":"3. Maritime Shipping & Coastal Keel Clearance Windows","titles":["Production Use Cases & Architectural Patterns"]},"1084":{"title":"4. Drone Surveying & Architectural Golden Hour Scheduling","titles":["Production Use Cases & Architectural Patterns"]},"1085":{"title":"5. Wildlife Tracking & Nocturnal Ecological Monitoring","titles":["Production Use Cases & Architectural Patterns"]},"1086":{"title":"Design Strategy & Deliberate Omissions","titles":[]},"1087":{"title":"🏛️ Part A: The Token:Modifier Design Strategy","titles":["Design Strategy & Deliberate Omissions"]},"1088":{"title":"1. The All-Lowercase Principle: Eliminating the Capitalization Trap","titles":["Design Strategy & Deliberate Omissions","🏛️ Part A: The Token:Modifier Design Strategy"]},"1089":{"title":"2. Getter-to-Token Symmetry: Zero Context Switching","titles":["Design Strategy & Deliberate Omissions","🏛️ Part A: The Token:Modifier Design Strategy"]},"1090":{"title":"3. Composable Modifiers vs. Combinatorial Token Explosion","titles":["Design Strategy & Deliberate Omissions","🏛️ Part A: The Token:Modifier Design Strategy"]},"1091":{"title":"4. Braced Architecture vs. Literal Escaping Nightmares","titles":["Design Strategy & Deliberate Omissions","🏛️ Part A: The Token:Modifier Design Strategy"]},"1092":{"title":"🚫 Part B: Deliberate Omissions & Architectural Boundaries","titles":["Design Strategy & Deliberate Omissions"]},"1093":{"title":"1. Non-ISO Locale Week-Numbering Years (Moment gggg / gg)","titles":["Design Strategy & Deliberate Omissions","🚫 Part B: Deliberate Omissions & Architectural Boundaries"]},"1094":{"title":"2. Confusing 1–24 and 0–11 Hour Systems (LDML k / K)","titles":["Design Strategy & Deliberate Omissions","🚫 Part B: Deliberate Omissions & Architectural Boundaries"]},"1095":{"title":"3. Duplicate Standalone vs. Format Inflections (LDML LLLL vs MMMM, cccc vs EEEE)","titles":["Design Strategy & Deliberate Omissions","🚫 Part B: Deliberate Omissions & Architectural Boundaries"]},"1096":{"title":"4. Mnemonic Reference Date Formatting (Go time.Format)","titles":["Design Strategy & Deliberate Omissions","🚫 Part B: Deliberate Omissions & Architectural Boundaries"]},"1097":{"title":"5. Hardcoded Business / Fiscal Quarter Assumptions","titles":["Design Strategy & Deliberate Omissions","🚫 Part B: Deliberate Omissions & Architectural Boundaries"]},"1098":{"title":"📊 Summary Comparison","titles":["Design Strategy & Deliberate Omissions"]},"1099":{"title":"@magmacomputing/tempo-plugin-dialects","titles":[]},"1100":{"title":"🚀 Installation & Quickstart","titles":["@magmacomputing/tempo-plugin-dialects"]},"1101":{"title":"Registration","titles":["@magmacomputing/tempo-plugin-dialects","🚀 Installation & Quickstart"]},"1102":{"title":"Zero-Boilerplate Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-dialects","🚀 Installation & Quickstart","Registration"]},"1103":{"title":"🔤 Supported Dialects","titles":["@magmacomputing/tempo-plugin-dialects"]},"1104":{"title":"📚 API Surface Catalog","titles":["@magmacomputing/tempo-plugin-dialects"]},"1105":{"title":"📖 Architecture & Specialized Guides","titles":["@magmacomputing/tempo-plugin-dialects"]},"1106":{"title":"⚡ Performance & Lazy Evaluation","titles":["@magmacomputing/tempo-plugin-dialects"]},"1107":{"title":"📄 Licensing","titles":["@magmacomputing/tempo-plugin-dialects"]},"1108":{"title":"Migration & Legacy Compatibility","titles":[]},"1109":{"title":"The Migration Challenge: Token Traps & Gotchas","titles":["Migration & Legacy Compatibility"]},"1110":{"title":"1. The Year Trap: YYYY vs yyyy","titles":["Migration & Legacy Compatibility","The Migration Challenge: Token Traps & Gotchas"]},"1111":{"title":"2. Month vs Minute: MM vs mm vs mi","titles":["Migration & Legacy Compatibility","The Migration Challenge: Token Traps & Gotchas"]},"1112":{"title":"3. Escaping Literals: Quotes vs Brackets","titles":["Migration & Legacy Compatibility","The Migration Challenge: Token Traps & Gotchas"]},"1113":{"title":"Automated Migration Engine: Tempo.dialects.explain()","titles":["Migration & Legacy Compatibility"]},"1114":{"title":"Programmatic Mask Upgrades in Build Pipelines","titles":["Migration & Legacy Compatibility","Automated Migration Engine: Tempo.dialects.explain()"]},"1115":{"title":"Exporting Dialect Models: Tempo.dialects.export()","titles":["Migration & Legacy Compatibility"]},"1116":{"title":"Universal Cross-Dialect Conversion: Tempo.dialects.convert()","titles":["Migration & Legacy Compatibility"]},"1117":{"title":"Drop-In API Compatibility Shims","titles":["Migration & Legacy Compatibility"]},"1118":{"title":"1. Luxon Drop-In: t.toFormat()","titles":["Migration & Legacy Compatibility","Drop-In API Compatibility Shims"]},"1119":{"title":"2. Static Parsers: Tempo.fromFormat() & Tempo.fromFormats()","titles":["Migration & Legacy Compatibility","Drop-In API Compatibility Shims"]},"1120":{"title":"Performance Comparison: Native Tempo vs Dialects","titles":["Migration & Legacy Compatibility"]},"1121":{"title":"Why Native Syntax is Faster","titles":["Migration & Legacy Compatibility","Performance Comparison: Native Tempo vs Dialects"]},"1122":{"title":"Recommended Migration Strategy","titles":["Migration & Legacy Compatibility","Performance Comparison: Native Tempo vs Dialects"]},"1123":{"title":"Token Specification & Cross-Ecosystem Matrix","titles":[]},"1124":{"title":"1. Interactive Dialect Token Navigator","titles":["Token Specification & Cross-Ecosystem Matrix"]},"1125":{"title":"2. Core Standards Comparison Matrix","titles":["Token Specification & Cross-Ecosystem Matrix"]},"1126":{"title":"3. Literal Text Escaping Rules","titles":["Token Specification & Cross-Ecosystem Matrix"]},"1127":{"title":"A. Unicode LDML & Luxon (ldml)","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1128":{"title":"B. Moment.js & Day.js (moment)","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1129":{"title":"C. POSIX strftime & MySQL (strftime, mysql)","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1130":{"title":"D. .NET / C# (dotnet)","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1131":{"title":"E. Excel / Google Sheets (sheet)","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1132":{"title":"F. Native Tempo Core","titles":["Token Specification & Cross-Ecosystem Matrix","3. Literal Text Escaping Rules"]},"1133":{"title":"4. Ecosystem-Specific Nuances","titles":["Token Specification & Cross-Ecosystem Matrix"]},"1134":{"title":"A. Context-Sensitive mm in Spreadsheets","titles":["Token Specification & Cross-Ecosystem Matrix","4. Ecosystem-Specific Nuances"]},"1135":{"title":"B. Standard .NET Single-Character Specifiers","titles":["Token Specification & Cross-Ecosystem Matrix","4. Ecosystem-Specific Nuances"]},"1136":{"title":"C. Hour Normalization (24:00 Midnight)","titles":["Token Specification & Cross-Ecosystem Matrix","4. Ecosystem-Specific Nuances"]},"1137":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1138":{"title":"1. Heterogeneous Third-Party Webhook Ingestion","titles":["Production Use Cases & Architectural Patterns"]},"1139":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","1. Heterogeneous Third-Party Webhook Ingestion"]},"1140":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","1. Heterogeneous Third-Party Webhook Ingestion"]},"1141":{"title":"Production Implementation","titles":["Production Use Cases & Architectural Patterns","1. Heterogeneous Third-Party Webhook Ingestion"]},"1142":{"title":"2. Enterprise Syslog & Audit Trail Compliance (POSIX strftime)","titles":["Production Use Cases & Architectural Patterns"]},"1143":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","2. Enterprise Syslog & Audit Trail Compliance (POSIX strftime)"]},"1144":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","2. Enterprise Syslog & Audit Trail Compliance (POSIX strftime)"]},"1145":{"title":"3. Zero-Downtime Gradual Modernization Pipeline","titles":["Production Use Cases & Architectural Patterns"]},"1146":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","3. Zero-Downtime Gradual Modernization Pipeline"]},"1147":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","3. Zero-Downtime Gradual Modernization Pipeline"]},"1148":{"title":"4. Cross-Ecosystem Format Transpilation (.convert() & .export())","titles":["Production Use Cases & Architectural Patterns"]},"1149":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","4. Cross-Ecosystem Format Transpilation (.convert() & .export())"]},"1150":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","4. Cross-Ecosystem Format Transpilation (.convert() & .export())"]},"1151":{"title":"@magmacomputing/tempo-plugin-finance","titles":[]},"1152":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-finance"]},"1153":{"title":"Usage","titles":["@magmacomputing/tempo-plugin-finance"]},"1154":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-finance","Usage"]},"1155":{"title":"Licensing","titles":["@magmacomputing/tempo-plugin-finance"]},"1156":{"title":"Cultural Locale Synchronization","titles":[]},"1157":{"title":"1. The Challenge of Geographic Formatting","titles":["Cultural Locale Synchronization"]},"1158":{"title":"2. Automatic Cultural Sync (t.geoLocate({ setLocale }))","titles":["Cultural Locale Synchronization"]},"1159":{"title":"Call-Site Preference Priority","titles":["Cultural Locale Synchronization","2. Automatic Cultural Sync (t.geoLocate({ setLocale }))"]},"1160":{"title":"3. Pure Cultural Locale Inference (resolveCulturalLocale)","titles":["Cultural Locale Synchronization"]},"1161":{"title":"4. Internationalization Synergy with @magmacomputing/library","titles":["Cultural Locale Synchronization"]},"1162":{"title":"@magmacomputing/tempo-plugin-geo","titles":[]},"1163":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-geo"]},"1164":{"title":"Architecture & Namespacing","titles":["@magmacomputing/tempo-plugin-geo"]},"1165":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-geo","Architecture & Namespacing"]},"1166":{"title":"Documentation Guide","titles":["@magmacomputing/tempo-plugin-geo"]},"1167":{"title":"Which Method Should I Choose?","titles":["@magmacomputing/tempo-plugin-geo"]},"1168":{"title":"Comprehensive Tempo.geo API Surface","titles":["@magmacomputing/tempo-plugin-geo"]},"1169":{"title":"Fluent Instance Methods","titles":["@magmacomputing/tempo-plugin-geo","Comprehensive Tempo.geo API Surface"]},"1170":{"title":"Quickstart Examples","titles":["@magmacomputing/tempo-plugin-geo"]},"1171":{"title":"1. Fluent OOP with Tempo.geo","titles":["@magmacomputing/tempo-plugin-geo","Quickstart Examples"]},"1172":{"title":"2. Reverse Geocoding and Instance Enrichment","titles":["@magmacomputing/tempo-plugin-geo","Quickstart Examples"]},"1173":{"title":"Security & Immutability","titles":["@magmacomputing/tempo-plugin-geo"]},"1174":{"title":"Licensing","titles":["@magmacomputing/tempo-plugin-geo"]},"1175":{"title":"Pluggable Geocoding Provider Gateway","titles":[]},"1176":{"title":"1. Overview & GeoProvider Interface","titles":["Pluggable Geocoding Provider Gateway"]},"1177":{"title":"2. Registering a Provider","titles":["Pluggable Geocoding Provider Gateway"]},"1178":{"title":"A. Global Static Registration (Tempo.geo.setProvider)","titles":["Pluggable Geocoding Provider Gateway","2. Registering a Provider"]},"1179":{"title":"B. Plugin Installation Options","titles":["Pluggable Geocoding Provider Gateway","2. Registering a Provider"]},"1180":{"title":"C. Call-Site Override","titles":["Pluggable Geocoding Provider Gateway","2. Registering a Provider"]},"1181":{"title":"3. Forward & Reverse Geocoding Examples","titles":["Pluggable Geocoding Provider Gateway"]},"1182":{"title":"4. Built-in Caching & Automatic Failover","titles":["Pluggable Geocoding Provider Gateway"]},"1183":{"title":"Storage & Multi-Tenant Caching","titles":[]},"1184":{"title":"1. Ambient Stashing & 24-Hour Bounded Cache","titles":["Storage & Multi-Tenant Caching"]},"1185":{"title":"2. Multi-Tenant Partitioning (keyOrOpts)","titles":["Storage & Multi-Tenant Caching"]},"1186":{"title":"Solution A: Keyed Partitioning","titles":["Storage & Multi-Tenant Caching","2. Multi-Tenant Partitioning (keyOrOpts)"]},"1187":{"title":"Solution B: Instance-Level Scoping (Recommended)","titles":["Storage & Multi-Tenant Caching","2. Multi-Tenant Partitioning (keyOrOpts)"]},"1188":{"title":"3. Server IP vs. Client Location Operational Warnings","titles":["Storage & Multi-Tenant Caching"]},"1189":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1190":{"title":"1. Multi-Tenant SaaS Cultural Locale Synchronization","titles":["Production Use Cases & Architectural Patterns"]},"1191":{"title":"2. Pluggable Resilient Geocoding Gateway (Custom Provider)","titles":["Production Use Cases & Architectural Patterns"]},"1192":{"title":"3. Multi-Tenant Partitioned Geo Storage & 24h Caching","titles":["Production Use Cases & Architectural Patterns"]},"1193":{"title":"4. Server-Side Edge Middleware Request Localization","titles":["Production Use Cases & Architectural Patterns"]},"1194":{"title":"Business Days & SLA Arithmetic","titles":[]},"1195":{"title":"Determining Working Business Days","titles":["Business Days & SLA Arithmetic"]},"1196":{"title":"Navigating Business Days","titles":["Business Days & SLA Arithmetic"]},"1197":{"title":"t.holidays.nextBusinessDay() and t.holidays.prevBusinessDay()","titles":["Business Days & SLA Arithmetic","Navigating Business Days"]},"1198":{"title":"Adding Business Days","titles":["Business Days & SLA Arithmetic"]},"1199":{"title":"t.holidays.addBusinessDays(amount, options?)","titles":["Business Days & SLA Arithmetic","Adding Business Days"]},"1200":{"title":"Counting Business Days Between Dates","titles":["Business Days & SLA Arithmetic"]},"1201":{"title":"t.holidays.businessDaysUntil(target, options?)","titles":["Business Days & SLA Arithmetic","Counting Business Days Between Dates"]},"1202":{"title":"SLA Working Hours Calculation","titles":["Business Days & SLA Arithmetic"]},"1203":{"title":"t.holidays.workingHoursUntil(deadline, options?)","titles":["Business Days & SLA Arithmetic","SLA Working Hours Calculation"]},"1204":{"title":"Custom Work Hour Windows","titles":["Business Days & SLA Arithmetic","SLA Working Hours Calculation"]},"1205":{"title":"Cultural Locale Weekend Awareness","titles":["Business Days & SLA Arithmetic"]},"1206":{"title":"@magmacomputing/tempo-plugin-holidays","titles":[]},"1207":{"title":"Key Features","titles":["@magmacomputing/tempo-plugin-holidays"]},"1208":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-holidays"]},"1209":{"title":"Quickstart","titles":["@magmacomputing/tempo-plugin-holidays"]},"1210":{"title":"Topic Guides","titles":["@magmacomputing/tempo-plugin-holidays"]},"1211":{"title":"License","titles":["@magmacomputing/tempo-plugin-holidays"]},"1212":{"title":"Regional Calendars & Dynamic Preloading","titles":[]},"1213":{"title":"Supported Offline Built-in Calendars","titles":["Regional Calendars & Dynamic Preloading"]},"1214":{"title":"Resolution Hierarchy & Geo Cohesion","titles":["Regional Calendars & Dynamic Preloading"]},"1215":{"title":"Dynamic Long-Tail Preloading & Storage Caching","titles":["Regional Calendars & Dynamic Preloading"]},"1216":{"title":"Using Static / Async Tempo.holidays.preload()","titles":["Regional Calendars & Dynamic Preloading","Dynamic Long-Tail Preloading & Storage Caching"]},"1217":{"title":"Using Instance Method t.holidays.preload()","titles":["Regional Calendars & Dynamic Preloading","Dynamic Long-Tail Preloading & Storage Caching"]},"1218":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1219":{"title":"1. Multi-Tenant SaaS SLA Resolution Engine","titles":["Production Use Cases & Architectural Patterns"]},"1220":{"title":"Architecture Pattern","titles":["Production Use Cases & Architectural Patterns","1. Multi-Tenant SaaS SLA Resolution Engine"]},"1221":{"title":"2. Financial T+2 Settlement & Trade Value Dates","titles":["Production Use Cases & Architectural Patterns"]},"1222":{"title":"3. Payroll & Automated Invoicing (Preceding vs. Following Conventions)","titles":["Production Use Cases & Architectural Patterns"]},"1223":{"title":"4. HR Leave Balance & Vacation Day Accounting","titles":["Production Use Cases & Architectural Patterns"]},"1224":{"title":"5. Corporate Calendar Overlays & Floating Shutdowns","titles":["Production Use Cases & Architectural Patterns"]},"1225":{"title":"6. Zero-Latency Synchronous Resolution","titles":["Production Use Cases & Architectural Patterns"]},"1226":{"title":"Cristian\'s Algorithm & Precision Engineering","titles":[]},"1227":{"title":"1. Cristian\'s Algorithm Over HTTP","titles":["Cristian\'s Algorithm & Precision Engineering"]},"1228":{"title":"Round-Trip Time (RTT)","titles":["Cristian\'s Algorithm & Precision Engineering","1. Cristian\'s Algorithm Over HTTP"]},"1229":{"title":"Estimated Server Timestamp at Reception (T1)","titles":["Cristian\'s Algorithm & Precision Engineering","1. Cristian\'s Algorithm Over HTTP"]},"1230":{"title":"Clock Drift Offset (θ)","titles":["Cristian\'s Algorithm & Precision Engineering","1. Cristian\'s Algorithm Over HTTP"]},"1231":{"title":"Uncertainty Window (±E)","titles":["Cristian\'s Algorithm & Precision Engineering","1. Cristian\'s Algorithm Over HTTP"]},"1232":{"title":"2. Sub-Millisecond Precision via Server-Timing","titles":["Cristian\'s Algorithm & Precision Engineering"]},"1233":{"title":"3. Statistical Jitter Rejection & Filtering","titles":["Cristian\'s Algorithm & Precision Engineering"]},"1234":{"title":"4. Exponential Moving Average (EMA) Smoothing","titles":["Cristian\'s Algorithm & Precision Engineering"]},"1235":{"title":"5. Monotonic Time Progression with Zero O(N) Overhead","titles":["Cristian\'s Algorithm & Precision Engineering"]},"1236":{"title":"@magmacomputing/tempo-plugin-ntp","titles":[]},"1237":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-ntp"]},"1238":{"title":"Architecture & Registration","titles":["@magmacomputing/tempo-plugin-ntp"]},"1239":{"title":"Plugin Installation","titles":["@magmacomputing/tempo-plugin-ntp","Architecture & Registration"]},"1240":{"title":"Configuration Options (NtpSyncOptions)","titles":["@magmacomputing/tempo-plugin-ntp","Architecture & Registration"]},"1241":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-ntp","Architecture & Registration"]},"1242":{"title":"Documentation Guide","titles":["@magmacomputing/tempo-plugin-ntp"]},"1243":{"title":"Interactive REPL","titles":["@magmacomputing/tempo-plugin-ntp"]},"1244":{"title":"Comprehensive API Reference","titles":["@magmacomputing/tempo-plugin-ntp"]},"1245":{"title":"Tempo.ntp.now(timeZone?: string): Tempo","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1246":{"title":"Tempo.ntp.sync(endpoint?: string): Promise<ClockDriftState>","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1247":{"title":"Tempo.ntp.offset: number","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1248":{"title":"Tempo.ntp.drift: ClockDriftState","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1249":{"title":"Tempo.ntp.isCalibrated: boolean","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1250":{"title":"Tempo.ntp.reset(): void","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1251":{"title":"tempo.toNtpTime(): Tempo","titles":["@magmacomputing/tempo-plugin-ntp","Comprehensive API Reference"]},"1252":{"title":"Licensing","titles":["@magmacomputing/tempo-plugin-ntp"]},"1253":{"title":"Ticker Integration & Atomic Clocks","titles":[]},"1254":{"title":"1. NTP-Compensated Cadence (ntp: true)","titles":["Ticker Integration & Atomic Clocks"]},"1255":{"title":"2. Distributed Wall-Clock Aligned Schedules","titles":["Ticker Integration & Atomic Clocks"]},"1256":{"title":"3. Explicit Resource Management & Lifecycle","titles":["Ticker Integration & Atomic Clocks"]},"1257":{"title":"4. Fallback Behavior","titles":["Ticker Integration & Atomic Clocks"]},"1258":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1259":{"title":"1. Anti-Cheat Live Countdowns & Flash Sales","titles":["Production Use Cases & Architectural Patterns"]},"1260":{"title":"The Problem with Uncalibrated Timers","titles":["Production Use Cases & Architectural Patterns","1. Anti-Cheat Live Countdowns & Flash Sales"]},"1261":{"title":"The Calibrated Solution","titles":["Production Use Cases & Architectural Patterns","1. Anti-Cheat Live Countdowns & Flash Sales"]},"1262":{"title":"2. Zero-Overhead Passive Calibration (interceptFetch) & Origin Hardening","titles":["Production Use Cases & Architectural Patterns"]},"1263":{"title":"Trust Boundaries & Origin Hardening","titles":["Production Use Cases & Architectural Patterns","2. Zero-Overhead Passive Calibration (interceptFetch) & Origin Hardening"]},"1264":{"title":"Production Ingestion Flow","titles":["Production Use Cases & Architectural Patterns","2. Zero-Overhead Passive Calibration (interceptFetch) & Origin Hardening"]},"1265":{"title":"3. Distributed Telemetry & Client Log Correlation","titles":["Production Use Cases & Architectural Patterns"]},"1266":{"title":"4. Time-Based One-Time Passwords (TOTP / 2FA)","titles":["Production Use Cases & Architectural Patterns"]},"1267":{"title":"5. Drift Convergence & High-Frequency Queries","titles":["Production Use Cases & Architectural Patterns"]},"1268":{"title":"Classical Fasti & Lunar Anchors","titles":[]},"1269":{"title":"The Three Lunar Anchor Points","titles":["Classical Fasti & Lunar Anchors"]},"1270":{"title":"Inclusive Backward Counting (Ante Diem)","titles":["Classical Fasti & Lunar Anchors"]},"1271":{"title":"Leap Year Intercalation: The Bissextile Day","titles":["Classical Fasti & Lunar Anchors"]},"1272":{"title":"Ab Urbe Condita (AUC) Calculations","titles":["Classical Fasti & Lunar Anchors"]},"1273":{"title":"Consular Chronology (Fasti Consulares)","titles":["Classical Fasti & Lunar Anchors"]},"1274":{"title":"See Also","titles":["Classical Fasti & Lunar Anchors"]},"1275":{"title":"@magmacomputing/tempo-plugin-roman","titles":[]},"1276":{"title":"Key Features","titles":["@magmacomputing/tempo-plugin-roman"]},"1277":{"title":"Installation & Import Paths","titles":["@magmacomputing/tempo-plugin-roman"]},"1278":{"title":"Choose Your Import Path","titles":["@magmacomputing/tempo-plugin-roman","Installation & Import Paths"]},"1279":{"title":"Quickstart","titles":["@magmacomputing/tempo-plugin-roman"]},"1280":{"title":"Option A: Lean Core Plugin (Zero-Boilerplate)","titles":["@magmacomputing/tempo-plugin-roman","Quickstart"]},"1281":{"title":"Option B: Full Consular Fasti (Single Import)","titles":["@magmacomputing/tempo-plugin-roman","Quickstart"]},"1282":{"title":"Option C: Explicit Plugin Registration","titles":["@magmacomputing/tempo-plugin-roman","Quickstart"]},"1283":{"title":"API Reference","titles":["@magmacomputing/tempo-plugin-roman"]},"1284":{"title":"tempo.toRomanClassical(options?: RomanCalculationOptions): ClassicalRomanDate","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1285":{"title":"tempo.toAUC(): number","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1286":{"title":"tempo.auc: number","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1287":{"title":"Tempo.roman.toClassical(date, options?): ClassicalRomanDate","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1288":{"title":"Tempo.roman.fromClassical(anchor, anchorMonth, anchorYear, relation, count?, isBissextile?, isJulian?): { year, month, day }","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1289":{"title":"Tempo.roman.parse(input: string, options?: RomanParseOptions): Tempo","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1290":{"title":"Tempo.roman.parseDate(input: string, options?: RomanParseOptions): ParsedRomanDate","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1291":{"title":"Tempo.roman.getConsuls(year: number): readonly string[] | undefined","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1292":{"title":"Tempo.roman.formatConsuls(year: number, style?: \'ablative\' | \'nominative\'): string | undefined","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1293":{"title":"Tempo.roman.findConsuls(query: string): ConsularPair[]","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1294":{"title":"Tempo.roman.yearToAuc(year: number, era?: \'CE\' | \'BCE\'): number","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1295":{"title":"Tempo.roman.aucToYear(auc: number, format?: \'astronomical\' | \'historical\')","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1296":{"title":"Tempo.roman.getNonesDay(month: number): number","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1297":{"title":"Tempo.roman.getIdesDay(month: number): number","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1298":{"title":"Tempo.roman.isLeapYear(year: number, isJulian?: boolean): boolean","titles":["@magmacomputing/tempo-plugin-roman","API Reference"]},"1299":{"title":"Topic Guides","titles":["@magmacomputing/tempo-plugin-roman"]},"1300":{"title":"License","titles":["@magmacomputing/tempo-plugin-roman"]},"1301":{"title":"Use Cases & Production Patterns","titles":[]},"1302":{"title":"1. Digital Epigraphy & Classical Inscription Parsing","titles":["Use Cases & Production Patterns"]},"1303":{"title":"The Challenge","titles":["Use Cases & Production Patterns","1. Digital Epigraphy & Classical Inscription Parsing"]},"1304":{"title":"Implementation Pattern","titles":["Use Cases & Production Patterns","1. Digital Epigraphy & Classical Inscription Parsing"]},"1305":{"title":"2. Numismatics & Ancient Coin Provenance","titles":["Use Cases & Production Patterns"]},"1306":{"title":"The Challenge","titles":["Use Cases & Production Patterns","2. Numismatics & Ancient Coin Provenance"]},"1307":{"title":"Implementation Pattern","titles":["Use Cases & Production Patterns","2. Numismatics & Ancient Coin Provenance"]},"1308":{"title":"3. Academic Manuscript Dating & Legal Charters","titles":["Use Cases & Production Patterns"]},"1309":{"title":"The Challenge","titles":["Use Cases & Production Patterns","3. Academic Manuscript Dating & Legal Charters"]},"1310":{"title":"Implementation Pattern","titles":["Use Cases & Production Patterns","3. Academic Manuscript Dating & Legal Charters"]},"1311":{"title":"4. Consular Dating & Fasti Chronology","titles":["Use Cases & Production Patterns"]},"1312":{"title":"The Challenge","titles":["Use Cases & Production Patterns","4. Consular Dating & Fasti Chronology"]},"1313":{"title":"Implementation Pattern","titles":["Use Cases & Production Patterns","4. Consular Dating & Fasti Chronology"]},"1314":{"title":"See Also","titles":["Use Cases & Production Patterns"]},"1315":{"title":"@magmacomputing/tempo-plugin-snap","titles":[]},"1316":{"title":"🚀 Installation & Quickstart","titles":["@magmacomputing/tempo-plugin-snap"]},"1317":{"title":"Zero-Boilerplate Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-snap","🚀 Installation & Quickstart"]},"1318":{"title":"📚 API Surface Catalog","titles":["@magmacomputing/tempo-plugin-snap"]},"1319":{"title":"Supported Units (SnapKey)","titles":["@magmacomputing/tempo-plugin-snap","📚 API Surface Catalog"]},"1320":{"title":"📖 Architecture & Specialized Guides","titles":["@magmacomputing/tempo-plugin-snap"]},"1321":{"title":"📄 Licensing","titles":["@magmacomputing/tempo-plugin-snap"]},"1322":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1323":{"title":"1. Interactive Calendar Drag-and-Drop Grid Snapping","titles":["Production Use Cases & Architectural Patterns"]},"1324":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","1. Interactive Calendar Drag-and-Drop Grid Snapping"]},"1325":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","1. Interactive Calendar Drag-and-Drop Grid Snapping"]},"1326":{"title":"Production Implementation","titles":["Production Use Cases & Architectural Patterns","1. Interactive Calendar Drag-and-Drop Grid Snapping"]},"1327":{"title":"2. High-Frequency Metric Telemetry Downsampling (InfluxDB / Prometheus)","titles":["Production Use Cases & Architectural Patterns"]},"1328":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","2. High-Frequency Metric Telemetry Downsampling (InfluxDB / Prometheus)"]},"1329":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","2. High-Frequency Metric Telemetry Downsampling (InfluxDB / Prometheus)"]},"1330":{"title":"3. Multimedia Frame Boundary Alignment (60fps / 25fps)","titles":["Production Use Cases & Architectural Patterns"]},"1331":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","3. Multimedia Frame Boundary Alignment (60fps / 25fps)"]},"1332":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","3. Multimedia Frame Boundary Alignment (60fps / 25fps)"]},"1333":{"title":"Spatial Geofencing & Bounding Boxes","titles":[]},"1334":{"title":"1. Circular Proximity (Tempo.spatial.isWithin / isWithin / t.isWithin)","titles":["Spatial Geofencing & Bounding Boxes"]},"1335":{"title":"Code Examples","titles":["Spatial Geofencing & Bounding Boxes","1. Circular Proximity (Tempo.spatial.isWithin / isWithin / t.isWithin)"]},"1336":{"title":"2. Rectangular Bounding Box (Tempo.spatial.inBoundingBox / inBoundingBox / t.inBoundingBox)","titles":["Spatial Geofencing & Bounding Boxes"]},"1337":{"title":"Standard Geographic Bounding Box","titles":["Spatial Geofencing & Bounding Boxes","2. Rectangular Bounding Box (Tempo.spatial.inBoundingBox / inBoundingBox / t.inBoundingBox)"]},"1338":{"title":"Antimeridian Crossing Support","titles":["Spatial Geofencing & Bounding Boxes","2. Rectangular Bounding Box (Tempo.spatial.inBoundingBox / inBoundingBox / t.inBoundingBox)"]},"1339":{"title":"@magmacomputing/tempo-plugin-spatial","titles":[]},"1340":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-spatial"]},"1341":{"title":"Architecture & Namespacing","titles":["@magmacomputing/tempo-plugin-spatial"]},"1342":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-spatial","Architecture & Namespacing"]},"1343":{"title":"Documentation Guide","titles":["@magmacomputing/tempo-plugin-spatial"]},"1344":{"title":"Comprehensive Tempo.spatial API Surface","titles":["@magmacomputing/tempo-plugin-spatial"]},"1345":{"title":"Fluent Instance Methods","titles":["@magmacomputing/tempo-plugin-spatial","Comprehensive Tempo.spatial API Surface"]},"1346":{"title":"Quickstart Examples","titles":["@magmacomputing/tempo-plugin-spatial"]},"1347":{"title":"1. Great-Circle Distance & Bearing","titles":["@magmacomputing/tempo-plugin-spatial","Quickstart Examples"]},"1348":{"title":"2. Impossible Travel Anomaly Detection","titles":["@magmacomputing/tempo-plugin-spatial","Quickstart Examples"]},"1349":{"title":"License","titles":["@magmacomputing/tempo-plugin-spatial"]},"1350":{"title":"Natural Solar Time Offset","titles":[]},"1351":{"title":"1. Natural Solar Time vs. Clock Time","titles":["Natural Solar Time Offset"]},"1352":{"title":"2. API Usage (Tempo.spatial.solarOffset / t.spatialSolarOffset / solarOffset)","titles":["Natural Solar Time Offset"]},"1353":{"title":"3. Dual-Tier Architecture: spatial vs celestial","titles":["Natural Solar Time Offset"]},"1354":{"title":"Transit Velocity, Impossible Travel & Navigation","titles":[]},"1355":{"title":"1. Great-Circle Distance (haversineDistance / Tempo.spatial.distance)","titles":["Transit Velocity, Impossible Travel & Navigation"]},"1356":{"title":"Supported Distance Units","titles":["Transit Velocity, Impossible Travel & Navigation","1. Great-Circle Distance (haversineDistance / Tempo.spatial.distance)"]},"1357":{"title":"Code Examples","titles":["Transit Velocity, Impossible Travel & Navigation","1. Great-Circle Distance (haversineDistance / Tempo.spatial.distance)"]},"1358":{"title":"2. Compass Bearing (Tempo.spatial.bearing / calculateBearing)","titles":["Transit Velocity, Impossible Travel & Navigation"]},"1359":{"title":"3. Geographic Midpoint (Tempo.spatial.midpoint / calculateMidpoint)","titles":["Transit Velocity, Impossible Travel & Navigation"]},"1360":{"title":"4. Transit Velocity & Speed Modeling (Tempo.spatial.velocity)","titles":["Transit Velocity, Impossible Travel & Navigation"]},"1361":{"title":"5. Impossible Travel Anomaly Detection (Tempo.spatial.isImpossibleTravel)","titles":["Transit Velocity, Impossible Travel & Navigation"]},"1362":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1363":{"title":"1. Zero-Trust Security: Impossible Travel Anomaly Detection","titles":["Production Use Cases & Architectural Patterns"]},"1364":{"title":"2. Fleet Geofencing: Depot Arrival & Service Zone Boundaries","titles":["Production Use Cases & Architectural Patterns"]},"1365":{"title":"3. Flight Route Planning: Great-Circle Distance & Forward Azimuth","titles":["Production Use Cases & Architectural Patterns"]},"1366":{"title":"4. Physical Solar Noon vs. Civil Timezone Offset","titles":["Production Use Cases & Architectural Patterns"]},"1367":{"title":"Lock-Free Atomics & Memory Architecture","titles":[]},"1368":{"title":"The Shared Memory Layout","titles":["Lock-Free Atomics & Memory Architecture"]},"1369":{"title":"1. Master Clock Writer (AtomicClock)","titles":["Lock-Free Atomics & Memory Architecture","The Shared Memory Layout"]},"1370":{"title":"2. Lock-Free Worker Reader (AtomicReader)","titles":["Lock-Free Atomics & Memory Architecture","The Shared Memory Layout"]},"1371":{"title":"Dual-Layer Lifecycle Management","titles":["Lock-Free Atomics & Memory Architecture"]},"1372":{"title":"1. Native Timer Unreferencing (unref())","titles":["Lock-Free Atomics & Memory Architecture","Dual-Layer Lifecycle Management"]},"1373":{"title":"2. Explicit Deterministic Resource Management (using)","titles":["Lock-Free Atomics & Memory Architecture","Dual-Layer Lifecycle Management"]},"1374":{"title":"3. GC Finalization Registry Safety Net","titles":["Lock-Free Atomics & Memory Architecture","Dual-Layer Lifecycle Management"]},"1375":{"title":"Browser Security Constraints: Cross-Origin Isolation","titles":["Lock-Free Atomics & Memory Architecture"]},"1376":{"title":"Environment Compatibility Matrix","titles":["Lock-Free Atomics & Memory Architecture","Browser Security Constraints: Cross-Origin Isolation"]},"1377":{"title":"@magmacomputing/tempo-plugin-sync","titles":[]},"1378":{"title":"🚀 Installation & Quickstart","titles":["@magmacomputing/tempo-plugin-sync"]},"1379":{"title":"Master Process: Initializing the Atomic Clock","titles":["@magmacomputing/tempo-plugin-sync","🚀 Installation & Quickstart"]},"1380":{"title":"Zero-Boilerplate Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-sync","🚀 Installation & Quickstart","Master Process: Initializing the Atomic Clock"]},"1381":{"title":"Worker Process: Lock-Free Reading","titles":["@magmacomputing/tempo-plugin-sync","🚀 Installation & Quickstart"]},"1382":{"title":"📚 API Surface Catalog","titles":["@magmacomputing/tempo-plugin-sync"]},"1383":{"title":"📖 Architecture & Specialized Guides","titles":["@magmacomputing/tempo-plugin-sync"]},"1384":{"title":"📄 Licensing","titles":["@magmacomputing/tempo-plugin-sync"]},"1385":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1386":{"title":"1. High-Frequency Trading (HFT) Worker Thread Risk Cluster","titles":["Production Use Cases & Architectural Patterns"]},"1387":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","1. High-Frequency Trading (HFT) Worker Thread Risk Cluster"]},"1388":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","1. High-Frequency Trading (HFT) Worker Thread Risk Cluster"]},"1389":{"title":"Production Implementation","titles":["Production Use Cases & Architectural Patterns","1. High-Frequency Trading (HFT) Worker Thread Risk Cluster"]},"1390":{"title":"2. Authoritative Multiplayer Game Simulation Ticks","titles":["Production Use Cases & Architectural Patterns"]},"1391":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","2. Authoritative Multiplayer Game Simulation Ticks"]},"1392":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","2. Authoritative Multiplayer Game Simulation Ticks"]},"1393":{"title":"3. Real-Time Audio DSP Buffer Synchronization","titles":["Production Use Cases & Architectural Patterns"]},"1394":{"title":"Problem Statement","titles":["Production Use Cases & Architectural Patterns","3. Real-Time Audio DSP Buffer Synchronization"]},"1395":{"title":"Architectural Solution","titles":["Production Use Cases & Architectural Patterns","3. Real-Time Audio DSP Buffer Synchronization"]},"1396":{"title":"@magmacomputing/tempo-plugin-ticker","titles":[]},"1397":{"title":"Installation","titles":["@magmacomputing/tempo-plugin-ticker"]},"1398":{"title":"Architecture & Registration","titles":["@magmacomputing/tempo-plugin-ticker"]},"1399":{"title":"Plugin Installation","titles":["@magmacomputing/tempo-plugin-ticker","Architecture & Registration"]},"1400":{"title":"Auto-Installation (Side-Effect Import)","titles":["@magmacomputing/tempo-plugin-ticker","Architecture & Registration"]},"1401":{"title":"Documentation Guide","titles":["@magmacomputing/tempo-plugin-ticker"]},"1402":{"title":"Comprehensive Ticker API Surface","titles":["@magmacomputing/tempo-plugin-ticker"]},"1403":{"title":"Creation: Tempo.ticker(intervalOrOptions?, callback?)","titles":["@magmacomputing/tempo-plugin-ticker","Comprehensive Ticker API Surface"]},"1404":{"title":"Ticker.Options Configuration","titles":["@magmacomputing/tempo-plugin-ticker","Comprehensive Ticker API Surface"]},"1405":{"title":"TickerInstance Object","titles":["@magmacomputing/tempo-plugin-ticker","Comprehensive Ticker API Surface"]},"1406":{"title":"Static Ticker Namespace","titles":["@magmacomputing/tempo-plugin-ticker","Comprehensive Ticker API Surface"]},"1407":{"title":"Quickstart Examples","titles":["@magmacomputing/tempo-plugin-ticker"]},"1408":{"title":"1. Disposer Pattern (Zero Leakage)","titles":["@magmacomputing/tempo-plugin-ticker","Quickstart Examples"]},"1409":{"title":"2. Async Generator Stream","titles":["@magmacomputing/tempo-plugin-ticker","Quickstart Examples"]},"1410":{"title":"License","titles":["@magmacomputing/tempo-plugin-ticker"]},"1411":{"title":"Intervals & Scheduling Engines","titles":[]},"1412":{"title":"1. Semantic Duration Intervals","titles":["Intervals & Scheduling Engines"]},"1413":{"title":"Supported Shorthand Units","titles":["Intervals & Scheduling Engines","1. Semantic Duration Intervals"]},"1414":{"title":"2. Calendar Term-Driven Intervals","titles":["Intervals & Scheduling Engines"]},"1415":{"title":"Boundary Snapping (>) vs. Relative Shifting (1)","titles":["Intervals & Scheduling Engines","2. Calendar Term-Driven Intervals"]},"1416":{"title":"3. Cron Expressions (Standard 5-Field Syntax)","titles":["Intervals & Scheduling Engines"]},"1417":{"title":"Passing Cron Strings","titles":["Intervals & Scheduling Engines","3. Cron Expressions (Standard 5-Field Syntax)"]},"1418":{"title":"4. RFC 5545 Recurrence Rules (RRULE)","titles":["Intervals & Scheduling Engines"]},"1419":{"title":"5. Virtual Clocks & Seeding","titles":["Intervals & Scheduling Engines"]},"1420":{"title":"6. Backwards Tickers (Countdowns)","titles":["Intervals & Scheduling Engines"]},"1421":{"title":"7. One-Shot Timers & Meeting Alerts","titles":["Intervals & Scheduling Engines"]},"1422":{"title":"8. Network Time & Clock Drift Compensation (ntp: true)","titles":["Intervals & Scheduling Engines"]},"1423":{"title":"Event Streams & Reactive Clocks","titles":[]},"1424":{"title":"1. Event Listeners (.on)","titles":["Event Streams & Reactive Clocks"]},"1425":{"title":"Event Reference","titles":["Event Streams & Reactive Clocks","1. Event Listeners (.on)"]},"1426":{"title":"2. Active Ticker Registry & Telemetry (Ticker.active)","titles":["Event Streams & Reactive Clocks"]},"1427":{"title":"Snapshot Structure (Ticker.Snapshot)","titles":["Event Streams & Reactive Clocks","2. Active Ticker Registry & Telemetry (Ticker.active)"]},"1428":{"title":"3. Master Clock Synchronization (Zero-Drift Architecture)","titles":["Event Streams & Reactive Clocks"]},"1429":{"title":"A. Reactive UI Signals (Preact, Solid, Vue)","titles":["Event Streams & Reactive Clocks","3. Master Clock Synchronization (Zero-Drift Architecture)"]},"1430":{"title":"B. Async Generator Multi-Clock Stream (Framework-Agnostic)","titles":["Event Streams & Reactive Clocks","3. Master Clock Synchronization (Zero-Drift Architecture)"]},"1431":{"title":"Resource Management & Lifecycle","titles":[]},"1432":{"title":"1. Explicit Resource Management (using & await using)","titles":["Resource Management & Lifecycle"]},"1433":{"title":"Synchronous Disposer (using)","titles":["Resource Management & Lifecycle","1. Explicit Resource Management (using & await using)"]},"1434":{"title":"Asynchronous Disposer (await using)","titles":["Resource Management & Lifecycle","1. Explicit Resource Management (using & await using)"]},"1435":{"title":"2. Async Generator Streaming (for await ... of)","titles":["Resource Management & Lifecycle"]},"1436":{"title":"3. Programmatic Lifecycle Controls","titles":["Resource Management & Lifecycle"]},"1437":{"title":"4. Bounded Termination Conditions","titles":["Resource Management & Lifecycle"]},"1438":{"title":"A. Pulse Count Limit (limit)","titles":["Resource Management & Lifecycle","4. Bounded Termination Conditions"]},"1439":{"title":"B. Stop Boundary (until)","titles":["Resource Management & Lifecycle","4. Bounded Termination Conditions"]},"1440":{"title":"5. Dual-Layer Lifecycle Architecture & GC Safety-Net","titles":["Resource Management & Lifecycle"]},"1441":{"title":"Layer 1: Deterministic Cleanup (using & .stop())","titles":["Resource Management & Lifecycle","5. Dual-Layer Lifecycle Architecture & GC Safety-Net"]},"1442":{"title":"Layer 2: Best-Effort GC Finalization (FinalizationRegistry)","titles":["Resource Management & Lifecycle","5. Dual-Layer Lifecycle Architecture & GC Safety-Net"]},"1443":{"title":"Production Use Cases & Architectural Patterns","titles":[]},"1444":{"title":"1. Zero-Drift Telemetry & Heartbeat Loops","titles":["Production Use Cases & Architectural Patterns"]},"1445":{"title":"2. Preventing Zombie Leaks with Explicit Resource Management (using)","titles":["Production Use Cases & Architectural Patterns"]},"1446":{"title":"3. Streaming Financial Market Feeds (for await...of)","titles":["Production Use Cases & Architectural Patterns"]},"1447":{"title":"4. Multi-Timezone Market Opening & Closing Schedules","titles":["Production Use Cases & Architectural Patterns"]},"1448":{"title":"5. Mobile & Laptop Sleep Recovery (catch: true)","titles":["Production Use Cases & Architectural Patterns"]},"1449":{"title":"🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)","titles":[]},"1450":{"title":"🚫 Why Barrel (index.ts) Files are Omitted","titles":["🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)"]},"1451":{"title":"📦 How to Import Mixins","titles":["🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)"]},"1452":{"title":"✍️ How to Author a Prototype Mixin","titles":["🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)"]},"1453":{"title":"Tempo Test Suite","titles":[]},"1454":{"title":"Directory Structure","titles":["Tempo Test Suite"]},"1455":{"title":"Running Tests","titles":["Tempo Test Suite"]},"1456":{"title":"All Tests","titles":["Tempo Test Suite","Running Tests"]},"1457":{"title":"Specific Domain","titles":["Tempo Test Suite","Running Tests"]},"1458":{"title":"CI Simulation","titles":["Tempo Test Suite","Running Tests"]},"1459":{"title":"Conventions","titles":["Tempo Test Suite"]}},"dirtCount":0,"index":[["✍️",{"0":{"1452":1}}],["▲",{"2":{"1368":1}}],["────►",{"2":{"1368":1}}],["───►",{"2":{"1038":2,"1325":2}}],["◄────────────────",{"2":{"1368":1}}],["δ",{"2":{"1360":1}}],["δλ",{"2":{"1069":1,"1075":1,"1076":2,"1353":1}}],["°",{"2":{"1347":1}}],["⟹",{"2":{"1270":4}}],["⋅θt−1where",{"2":{"1234":1}}],["θ0=θsample",{"2":{"1234":1}}],["θt=α⋅θsample+",{"2":{"1234":1}}],["θ=testimated−t1=tserver−t0+t12",{"2":{"1230":1}}],["θ",{"0":{"1230":1},"2":{"1235":1}}],["振替休日",{"2":{"1213":1}}],["勤労感謝の日",{"2":{"1213":1}}],["文化の日",{"2":{"1213":1}}],["スポーツの日",{"2":{"1213":1}}],["秋分の日",{"2":{"1213":1}}],["敬老の日",{"2":{"1213":1}}],["山の日",{"2":{"1213":1}}],["海の日",{"2":{"1213":1}}],["こどもの日",{"2":{"1213":1}}],["みどりの日",{"2":{"1213":1}}],["憲法記念日",{"2":{"1213":1}}],["昭和の日",{"2":{"1213":1}}],["春分の日",{"2":{"1213":1}}],["天皇誕生日",{"2":{"1213":1}}],["建国記念の日",{"2":{"1213":1}}],["成人の日",{"2":{"1213":1}}],["元日",{"2":{"1213":1}}],["étienne",{"2":{"1213":1}}],["équateur",{"2":{"145":1}}],["يونيو",{"2":{"1158":1,"1171":1}}],["الأحد",{"2":{"1158":1,"1171":1}}],["الأربعاء",{"2":{"146":1}}],["████",{"2":{"1120":1}}],["█████████",{"2":{"1120":1}}],["██████████",{"2":{"1120":1}}],["████████████████████",{"2":{"1120":1}}],["┌──────────────┼──────────────┐",{"2":{"1388":1}}],["┌────────────────────────────────────────────────────────┐",{"2":{"1140":1,"1368":1}}],["┌────────────────────────────────────────────────────────────────────────┐",{"2":{"1120":1,"1440":1}}],["┌───────────┼───────────┐",{"2":{"1029":1}}],["⟷",{"2":{"1098":2}}],["√",{"2":{"1070":1}}],["×",{"2":{"1069":1,"1070":1,"1353":1}}],["α∈",{"2":{"1234":1}}],["α",{"2":{"1067":6}}],["≥",{"2":{"1064":1,"1067":1}}],["└───────────────────────────────────┴────────────────────────────────────┘",{"2":{"1440":1}}],["└────────────────────────────────────────────────────────┘",{"2":{"1140":1,"1368":1}}],["└────────────────────────────────────────────────────────────────────────┘",{"2":{"1120":1}}],["└───",{"2":{"1038":1,"1325":1}}],["├───────────────────────────────────┬────────────────────────────────────┤",{"2":{"1440":1}}],["├────────────────────────────────────────────────────────┤",{"2":{"1368":1}}],["├────────────────────────────────────────────────────────────────────────┤",{"2":{"1120":1}}],["├───",{"2":{"1038":1,"1325":1}}],["▼",{"2":{"1029":5,"1140":2,"1388":3}}],["│",{"2":{"1029":3,"1038":1,"1120":9,"1140":14,"1325":2,"1368":11,"1388":5,"1440":14}}],["à",{"2":{"982":1}}],["©",{"2":{"763":1,"766":2}}],["\\t",{"2":{"731":1}}],["\\t\\t",{"2":{"731":1}}],["\\t\\t\\t\\treturn",{"2":{"731":1}}],["\\t\\t\\t\\tconst",{"2":{"731":1}}],["\\t\\t\\t",{"2":{"731":2}}],["\\t\\ttokens",{"2":{"731":1}}],["\\tregistry",{"2":{"731":1}}],["\\tlocale",{"2":{"731":1}}],["\\t→",{"2":{"158":3}}],["➗",{"0":{"681":1}}],["⚙️",{"0":{"617":1,"626":1,"630":1,"635":1,"644":1,"669":1}}],["µs",{"2":{"442":1,"449":1,"450":5,"451":1}}],["١٠",{"2":{"370":1}}],["←",{"2":{"300":1}}],["➡️",{"2":{"274":3}}],["^",{"2":{"243":1,"246":1,"388":1}}],["±$",{"2":{"1243":1}}],["±500ms",{"2":{"1232":1}}],["±e",{"0":{"1231":1}}],["±1",{"2":{"313":1}}],["±hh",{"2":{"240":1}}],["±0",{"2":{"227":1}}],["≈10",{"2":{"1370":1}}],["≈rtt",{"2":{"1229":1}}],["≈",{"2":{"227":1,"1069":1,"1070":1,"1076":2,"1079":1,"1229":1,"1351":1,"1352":1}}],["≤",{"2":{"227":4,"1064":1,"1067":3}}],["~713",{"2":{"1357":3}}],["~70",{"2":{"1278":1}}],["~443",{"2":{"1357":1}}],["~4",{"2":{"1352":2}}],["~406",{"2":{"1064":1}}],["~67",{"2":{"1335":1}}],["~65",{"2":{"444":1}}],["~95",{"2":{"1360":1}}],["~92",{"2":{"1063":1}}],["~99",{"2":{"798":1}}],["~110",{"2":{"1366":1}}],["~16988",{"2":{"1347":1}}],["~17ms",{"2":{"1332":1}}],["~152",{"2":{"1360":2}}],["~15",{"2":{"1278":2}}],["~148",{"2":{"1358":2}}],["~14",{"2":{"1059":1}}],["~100",{"2":{"972":1}}],["~1",{"2":{"867":1,"940":1,"1335":1}}],["~0",{"2":{"450":3,"451":1,"1352":1}}],["~24",{"2":{"1421":1}}],["~20",{"2":{"1278":1}}],["~290",{"2":{"1352":1}}],["~29",{"2":{"1055":1,"1064":1}}],["~2",{"2":{"442":1}}],["~33",{"2":{"1064":1}}],["~357",{"2":{"1064":1}}],["~356",{"2":{"1064":1}}],["~359µs",{"2":{"407":1,"419":1}}],["~302",{"2":{"1347":1}}],["~30",{"2":{"445":1}}],["~32",{"2":{"158":1}}],["~5500",{"2":{"1361":1}}],["~5570",{"2":{"1348":1}}],["~523µs",{"2":{"407":1,"419":1}}],["~500ms+",{"2":{"93":1}}],["⏱️",{"0":{"151":1,"673":1,"677":1}}],["令和6年12月25日",{"2":{"146":1}}],["ديسمبر",{"2":{"146":1}}],["٢١",{"2":{"1158":1,"1171":1}}],["٢٤",{"2":{"370":1}}],["٢٠٢٤",{"2":{"146":1}}],["٢٠٢٦",{"2":{"138":1,"370":1,"817":1,"1158":1,"1171":1}}],["٢٥",{"2":{"146":1}}],["→",{"2":{"138":72,"144":3,"145":3,"157":3,"158":6,"159":4,"290":1,"303":3,"304":3,"305":3,"306":2,"307":1,"317":1,"394":2,"515":1,"519":2,"520":5,"633":2,"739":3,"763":1,"775":2,"947":3,"997":3,"1127":1,"1129":1,"1158":1,"1176":2,"1190":3,"1214":3}}],["−62",{"2":{"1273":1}}],["−43=44",{"2":{"1272":1}}],["−180",{"2":{"121":1}}],["−90",{"2":{"121":1}}],["9ms",{"2":{"1394":1}}],["9f",{"2":{"1125":1}}],["9937",{"2":{"1083":1}}],["9903",{"2":{"1070":1}}],["99",{"2":{"1059":2}}],["999999999",{"2":{"186":2,"190":1,"368":1,"369":1}}],["9999",{"2":{"174":1}}],["999",{"2":{"63":1,"151":3,"192":1}}],["959",{"2":{"1355":1}}],["9553",{"2":{"1072":2}}],["95",{"2":{"912":1,"1364":1}}],["9631",{"2":{"1357":1}}],["96",{"2":{"880":1,"1065":1}}],["98",{"2":{"870":1,"898":1,"961":1,"965":1,"997":1}}],["946684800",{"2":{"207":1,"208":1}}],["9am",{"2":{"158":1,"896":1,"978":1,"982":1,"1220":1,"1417":2}}],["9",{"0":{"566":1,"615":1,"619":1,"624":1,"706":1},"1":{"567":1,"568":1,"569":1,"616":1,"617":1,"618":1,"620":1,"621":1,"622":1,"623":1,"625":1,"626":1,"627":1,"707":1,"708":1,"709":1},"2":{"137":1,"138":2,"167":1,"208":1,"228":1,"240":6,"313":2,"324":1,"567":2,"568":2,"613":1,"618":1,"798":1,"859":1,"875":2,"880":1,"1083":1,"1203":1,"1220":1,"1401":1,"1417":1,"1447":4}}],["900",{"2":{"1344":1,"1361":1,"1363":3}}],["900000",{"2":{"978":1,"979":1}}],["90°",{"2":{"227":2,"1046":1,"1062":3,"1071":3,"1076":1,"1358":1}}],["90",{"2":{"121":1,"1336":4}}],["82",{"2":{"1366":1}}],["83",{"2":{"1359":1}}],["833°",{"2":{"1067":2}}],["8136",{"2":{"1357":1}}],["8198",{"2":{"1063":1}}],["8863",{"2":{"1335":1}}],["8x",{"2":{"1120":1}}],["8b",{"2":{"1017":1}}],["8584",{"2":{"1366":1}}],["8566",{"2":{"1160":1,"1181":1,"1358":1,"1360":1}}],["85",{"2":{"912":1,"927":1,"934":1,"945":1,"962":2,"1010":1,"1043":1}}],["890z",{"2":{"1329":1}}],["89",{"2":{"787":2}}],["84°",{"2":{"1062":1}}],["84",{"2":{"450":1,"1352":3}}],["8pm",{"2":{"223":1}}],["8",{"0":{"216":1,"479":1,"628":1,"710":1,"1422":1},"1":{"629":1,"630":1,"631":1,"711":1,"712":1},"2":{"214":2,"216":1,"418":1,"450":1,"461":1,"519":1,"639":1,"758":1,"1033":3,"1039":2,"1052":1,"1053":1,"1059":6,"1065":1,"1199":1,"1204":2,"1215":1,"1221":1,"1329":2,"1360":2,"1368":2,"1369":1,"1382":1,"1383":1,"1388":1,"1421":1}}],["800",{"2":{"934":1,"937":1}}],["800ms",{"2":{"871":1,"934":1,"938":1,"946":1}}],["80",{"2":{"116":1}}],["867",{"2":{"997":1}}],["869",{"2":{"144":1,"226":1}}],["86399",{"2":{"138":2}}],["8601",{"2":{"132":1,"137":1,"154":1,"159":1,"186":2,"187":1,"365":1,"366":1,"368":1,"369":1,"375":1,"517":3,"522":1,"690":1,"910":1,"971":1,"1016":1,"1093":3,"1098":1,"1125":1,"1135":1,"1139":1}}],["8688",{"2":{"121":1,"142":1,"154":1,"226":1,"1046":1,"1061":1,"1071":1,"1076":1,"1078":2,"1160":1,"1172":2,"1347":1,"1352":4,"1357":1,"1364":1}}],["86",{"2":{"87":1,"824":1,"895":1,"1072":1,"1192":1,"1218":1,"1223":1}}],["↗",{"2":{"84":1,"85":1,"236":1}}],["$env",{"2":{"927":1}}],["$extends",{"2":{"402":1}}],["$updatescopestatus",{"2":{"836":1}}],["$pendingautoinstalls",{"2":{"812":1}}],["$internal",{"2":{"667":1}}],["$setevents",{"2":{"634":1}}],["$setconfig",{"2":{"631":1}}],["$set",{"2":{"505":1}}],["$bigint",{"2":{"500":1}}],["$type",{"2":{"501":1}}],["$target",{"0":{"435":1},"2":{"435":1,"437":1}}],["$terms",{"2":{"402":1}}],["$tempo",{"0":{"110":1},"2":{"101":1,"110":1,"111":1,"112":1,"117":2,"402":1,"439":1,"544":1}}],["$register",{"2":{"421":1}}],["$logconfig",{"2":{"403":1}}],["$modules",{"2":{"402":1}}],["$0",{"2":{"98":1,"1131":2,"1132":1}}],["$",{"2":{"72":1,"243":1,"246":1,"271":1,"281":1,"324":1,"355":1,"388":1,"774":1,"860":1,"889":6,"894":1,"927":1,"955":2,"968":3,"969":3,"970":1,"973":1,"978":5,"1132":1,"1141":1,"1192":1,"1221":1,"1223":1,"1243":2,"1254":2,"1255":1,"1264":2,"1280":4,"1326":1,"1389":2,"1415":2,"1417":2,"1419":1,"1420":1,"1421":1,"1426":3,"1435":1,"1438":1,"1445":2,"1447":1,"1448":1}}],["67ms",{"2":{"1331":1}}],["6762",{"2":{"1160":1,"1359":1}}],["62",{"2":{"1313":1}}],["6238",{"2":{"1266":1}}],["63",{"2":{"1273":1,"1313":1}}],["6503",{"2":{"1160":1,"1359":1}}],["65°",{"2":{"1072":1}}],["6f",{"2":{"1125":1}}],["69",{"2":{"1072":3}}],["66",{"2":{"1072":1}}],["6°",{"2":{"1067":2,"1071":1,"1084":1}}],["6413",{"2":{"1365":1}}],["6492",{"2":{"1072":2}}],["64",{"2":{"419":2,"1039":1,"1368":1}}],["60fps",{"0":{"1330":1},"1":{"1331":1,"1332":1},"2":{"1320":1,"1332":1}}],["600ms",{"2":{"946":1}}],["600",{"2":{"904":1,"946":2,"979":1,"1070":1,"1082":1}}],["60",{"2":{"94":2,"694":2,"1065":1,"1266":1,"1329":1,"1331":1,"1332":4}}],["6",{"0":{"216":1,"323":1,"389":1,"477":1,"486":1,"496":1,"561":1,"636":1,"650":1,"718":1,"770":1,"778":1,"950":1,"1010":1,"1064":1,"1072":1,"1225":1,"1420":1},"1":{"637":1,"651":1,"719":1,"720":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1},"2":{"71":6,"137":1,"138":10,"152":1,"213":2,"216":1,"304":1,"313":2,"322":1,"324":1,"365":1,"367":1,"370":1,"519":1,"563":1,"564":1,"637":1,"639":1,"642":1,"689":2,"732":1,"743":1,"771":1,"786":1,"1088":1,"1096":1,"1125":3,"1197":1,"1199":1,"1221":1,"1222":1,"1355":2}}],["q$",{"2":{"1415":1}}],["qld",{"2":{"1213":2}}],["q=$",{"2":{"1178":1,"1191":1}}],["q4",{"2":{"739":1}}],["q",{"2":{"143":1}}],["q1",{"2":{"72":1,"194":1,"195":1,"303":2,"323":1,"326":1,"380":2,"381":1,"386":1,"388":2,"519":1,"773":1,"1097":1}}],["qtr",{"0":{"303":1},"2":{"72":3,"77":1,"185":1,"194":1,"195":1,"222":1,"301":1,"303":2,"307":1,"309":1,"326":1,"380":1,"381":3,"382":3,"406":1,"412":1,"416":1,"519":1,"682":1,"726":1,"734":1,"737":1,"739":2,"771":2,"773":2,"775":9,"842":1}}],["qtrmid",{"2":{"63":1}}],["qtrend",{"2":{"63":1}}],["q3",{"2":{"62":1,"95":1,"303":1,"739":3,"957":1,"974":2,"977":1}}],["q2",{"2":{"62":1,"72":1,"195":1,"381":1,"739":2,"775":1,"1097":1}}],["quite",{"2":{"510":1}}],["quirks",{"2":{"471":1,"573":1}}],["quickstart",{"0":{"914":1,"1019":1,"1055":1,"1100":1,"1170":1,"1209":1,"1279":1,"1316":1,"1346":1,"1378":1,"1407":1},"1":{"1020":1,"1056":1,"1101":1,"1102":1,"1171":1,"1172":1,"1280":1,"1281":1,"1282":1,"1317":1,"1347":1,"1348":1,"1379":1,"1380":1,"1381":1,"1408":1,"1409":1}}],["quickly",{"2":{"22":1,"377":1,"954":1,"1124":1}}],["quick",{"0":{"9":1,"25":1,"250":1},"1":{"26":1,"27":1,"28":1,"29":1},"2":{"41":1,"89":1,"515":1,"648":1,"810":1,"969":1,"1421":1}}],["quadrature",{"2":{"1052":1,"1074":1,"1076":2}}],["quantization",{"2":{"1232":1}}],["quantitative",{"2":{"1032":1}}],["quantifier",{"2":{"243":1}}],["quality",{"2":{"467":1}}],["quarterterm",{"2":{"260":2,"311":2}}],["quarterlyticker",{"2":{"1415":1}}],["quarterly",{"2":{"77":2,"948":1,"957":1}}],["quarter",{"0":{"72":1,"303":1,"1097":1},"2":{"62":1,"63":2,"72":2,"75":3,"77":2,"87":1,"97":1,"143":1,"185":1,"195":1,"257":1,"260":1,"303":2,"307":2,"311":1,"318":1,"381":2,"382":3,"387":1,"416":1,"427":1,"429":1,"519":3,"522":1,"556":4,"680":3,"681":1,"711":1,"737":1,"774":1,"775":2,"948":1,"1046":1,"1047":3,"1059":4,"1076":3,"1085":1,"1097":2,"1098":1,"1269":1,"1414":1,"1415":6}}],["quartersremaining",{"2":{"774":1}}],["quarters",{"0":{"303":1,"1046":1},"2":{"12":1,"193":1,"230":1,"302":1,"303":1,"378":1,"509":1,"526":1,"556":2,"680":1,"771":1,"1044":1,"1052":1,"1097":2}}],["queen",{"2":{"1191":1}}],["queues",{"2":{"810":1,"1443":1,"1448":1}}],["queued",{"2":{"497":1}}],["queue",{"2":{"376":1,"812":1,"970":1,"1368":1}}],["question",{"2":{"301":1}}],["questions",{"2":{"15":1,"522":1}}],["queries",{"0":{"1267":1},"2":{"99":1,"881":1,"890":1,"899":1,"906":1,"934":2,"953":1,"954":1,"964":1,"971":1,"1017":1,"1048":1,"1094":1,"1188":1,"1215":1,"1227":1,"1442":1,"1444":1}}],["querying",{"0":{"1048":1},"2":{"934":1,"1084":1,"1239":1}}],["query",{"0":{"1293":1},"2":{"43":1,"716":1,"871":2,"881":1,"890":1,"899":1,"907":1,"908":1,"920":3,"934":2,"977":1,"1069":1,"1081":1,"1149":1,"1167":1,"1168":2,"1176":3,"1178":3,"1181":1,"1191":2,"1241":1,"1243":1,"1267":1,"1392":1}}],["quote",{"2":{"1127":1}}],["quoted",{"2":{"1105":1}}],["quotes",{"0":{"1112":1},"2":{"1091":3,"1098":1,"1112":3,"1127":2,"1130":2,"1131":1}}],["quotas",{"2":{"860":1,"867":1,"921":1,"953":1,"970":1}}],["quota",{"0":{"967":1,"970":1},"1":{"968":1,"969":1},"2":{"857":1,"860":1,"867":1,"920":1,"939":1,"940":1,"942":1,"948":2,"953":1,"967":1,"970":1}}],["quot",{"0":{"43":2,"46":2,"53":2,"58":2,"105":2,"203":2,"216":2,"262":2,"387":2,"407":2,"440":2,"509":2,"512":2},"1":{"204":2},"2":{"11":2,"12":4,"13":2,"31":2,"33":2,"46":2,"89":2,"97":4,"99":2,"105":2,"109":4,"110":2,"124":2,"125":8,"128":2,"129":2,"138":4,"145":8,"146":2,"157":10,"158":2,"161":2,"163":2,"164":4,"167":4,"197":2,"198":2,"202":2,"204":6,"211":2,"214":2,"219":4,"220":6,"221":8,"228":2,"229":2,"230":2,"246":2,"251":2,"273":6,"276":4,"279":2,"281":2,"293":4,"296":2,"297":8,"301":2,"315":2,"321":2,"331":2,"338":6,"351":2,"352":2,"359":2,"363":4,"370":4,"378":2,"380":2,"381":2,"384":4,"387":4,"389":4,"390":4,"399":2,"402":4,"403":2,"404":2,"407":4,"408":2,"409":2,"413":2,"414":2,"416":2,"418":2,"421":2,"423":4,"424":2,"427":2,"429":4,"431":2,"435":2,"440":4,"441":2,"444":2,"468":6,"469":2,"482":2,"500":4,"505":4,"509":2,"510":4,"514":2,"520":2,"522":6,"524":2,"525":6,"532":2,"573":2,"617":4,"626":2,"627":2,"642":4,"644":2,"647":2,"648":2,"651":2,"666":2,"669":4,"680":2,"681":2,"684":4,"705":2,"707":4,"724":2,"739":4,"750":2,"752":2,"757":2,"771":4,"775":4,"776":8,"802":2,"827":2,"829":4,"874":2,"875":2,"886":2,"888":6,"906":4,"909":8,"910":2,"911":12,"922":4,"951":12,"981":2,"987":2,"994":2,"1012":6,"1013":4,"1016":2,"1063":2,"1089":2,"1130":2,"1131":2,"1157":4,"1167":12,"1219":4,"1269":4,"1271":2,"1272":2,"1292":2,"1312":2,"1391":2}}],["⚠️",{"0":{"108":1,"199":1,"221":1,"262":1,"535":1,"547":1,"549":1,"559":1,"637":1},"1":{"536":1,"537":1,"538":1,"539":1,"548":1,"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":1,"559":1,"560":1,"561":1,"562":1,"563":1,"564":1,"565":1,"566":1,"567":1,"568":1,"569":1,"570":1,"571":1,"572":1,"573":1},"2":{"43":1,"191":1,"1260":1}}],["371",{"2":{"1355":2}}],["37",{"2":{"1335":3,"1337":1,"1357":1,"1359":1,"1361":1}}],["3f",{"2":{"1125":2}}],["320",{"2":{"1083":1}}],["32",{"2":{"1065":1,"1337":1,"1387":1,"1421":1}}],["34ms",{"2":{"1332":1}}],["34",{"2":{"1064":1,"1085":1,"1332":1}}],["3522",{"2":{"1160":1,"1181":1,"1358":1,"1360":1}}],["3521",{"2":{"1063":1}}],["35",{"2":{"1099":1,"1103":1,"1123":1,"1125":1,"1160":1,"1359":1}}],["359",{"2":{"442":2}}],["384",{"2":{"669":2}}],["3+",{"2":{"567":1}}],["3999",{"2":{"766":1}}],["39",{"2":{"450":1,"1070":1}}],["395",{"2":{"165":1}}],["3rd",{"0":{"203":1},"1":{"204":1},"2":{"203":3,"204":1,"323":1,"324":1,"773":1,"775":1,"1076":1,"1213":2}}],["364",{"2":{"1064":1}}],["362",{"2":{"1064":1}}],["360°",{"2":{"1055":1,"1062":1,"1063":1,"1071":1,"1076":1,"1344":1,"1358":1}}],["3600000",{"2":{"687":1,"978":1,"979":1,"1030":1}}],["36",{"2":{"450":1,"451":1,"1078":1}}],["36y",{"2":{"157":2,"159":1}}],["365d",{"2":{"165":1}}],["365",{"2":{"138":3,"161":2,"162":2,"163":3,"164":1,"606":1}}],["366",{"2":{"137":1,"138":2,"150":1,"152":1,"164":2,"819":1,"1125":1}}],["31−16+2=17⟹ante",{"2":{"1270":1}}],["3164",{"2":{"1143":1,"1144":1}}],["31st",{"2":{"192":2,"1110":1,"1113":1}}],["31",{"0":{"577":1,"587":1,"693":1},"1":{"578":1,"579":1,"580":1,"581":1,"582":1,"588":1,"589":1,"590":1,"694":1,"695":1,"696":1,"697":1},"2":{"137":2,"138":2,"149":1,"150":4,"240":2,"450":1,"451":1,"1088":5,"1110":1,"1125":2,"1158":1,"1171":1,"1220":1,"1222":2,"1224":1,"1268":1,"1270":2,"1329":1}}],["31t23",{"2":{"97":1}}],["31t14",{"2":{"52":1}}],["3382",{"2":{"1335":1}}],["330",{"2":{"305":1}}],["3339",{"2":{"154":1}}],["33",{"2":{"87":1,"121":1,"142":1,"144":1,"154":1,"226":2,"824":1,"880":1,"1046":1,"1061":1,"1071":1,"1076":1,"1078":2,"1160":1,"1172":2,"1347":1,"1352":4,"1357":1,"1364":3}}],["303",{"2":{"1365":1}}],["30z",{"2":{"1329":1}}],["30s",{"2":{"1266":1,"1319":1}}],["30m",{"2":{"1030":1,"1320":1,"1325":1,"1412":1}}],["30000",{"2":{"1266":2}}],["3000",{"2":{"935":1,"962":1}}],["30d",{"2":{"162":1,"165":1}}],["30am",{"2":{"859":1}}],["30a",{"2":{"139":1,"707":1}}],["30pm",{"2":{"139":2,"140":1,"916":1,"917":1,"1013":1}}],["30",{"0":{"583":1,"628":1,"789":1},"1":{"584":1,"585":1,"629":1,"630":1,"631":1,"790":1,"791":1,"792":1,"793":1},"2":{"63":1,"76":1,"78":2,"96":1,"97":1,"102":1,"123":2,"133":1,"137":2,"138":2,"139":3,"140":1,"144":4,"146":3,"149":1,"151":1,"154":1,"163":2,"176":1,"191":2,"214":2,"226":1,"306":1,"333":2,"370":2,"398":1,"689":2,"690":1,"707":1,"739":1,"806":2,"889":1,"953":1,"954":1,"1008":1,"1016":1,"1091":1,"1101":3,"1102":1,"1118":2,"1119":1,"1127":1,"1128":1,"1129":1,"1130":1,"1141":6,"1143":2,"1144":5,"1147":2,"1158":1,"1171":1,"1219":1,"1220":1,"1224":1,"1266":2,"1316":1,"1319":1,"1324":1,"1325":1,"1326":4,"1363":3,"1364":1,"1412":2,"1419":1,"1447":3}}],["3",{"0":{"28":1,"44":1,"89":1,"116":1,"125":1,"190":1,"234":1,"260":1,"268":1,"280":1,"291":1,"311":1,"335":1,"364":1,"384":1,"395":1,"415":1,"435":1,"460":1,"462":1,"473":1,"483":1,"492":1,"504":1,"511":1,"519":1,"526":1,"566":1,"577":1,"587":1,"615":1,"646":1,"658":1,"670":1,"685":1,"698":1,"733":1,"736":1,"740":1,"767":1,"775":1,"788":1,"794":1,"808":1,"813":1,"818":1,"825":1,"831":1,"840":1,"847":1,"864":1,"876":1,"886":1,"895":1,"904":1,"947":1,"952":1,"956":1,"999":1,"1015":1,"1034":1,"1047":1,"1061":1,"1069":1,"1077":1,"1083":1,"1090":1,"1095":1,"1112":1,"1126":1,"1145":1,"1160":1,"1181":1,"1188":1,"1192":1,"1222":1,"1233":1,"1256":1,"1265":1,"1308":1,"1330":1,"1353":1,"1359":1,"1365":1,"1374":1,"1393":1,"1416":1,"1428":1,"1436":1,"1446":1},"1":{"117":1,"365":1,"385":1,"386":1,"416":1,"463":1,"464":1,"465":1,"567":1,"568":1,"569":1,"578":1,"579":1,"580":1,"581":1,"582":1,"588":1,"589":1,"590":1,"616":1,"617":1,"618":1,"647":1,"648":1,"649":1,"659":1,"660":1,"661":1,"671":1,"672":1,"673":1,"686":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"693":1,"694":1,"695":1,"696":1,"697":1,"698":1,"699":2,"700":1,"701":1,"702":1,"703":1,"704":1,"705":1,"706":1,"707":1,"708":1,"709":1,"710":1,"711":1,"712":1,"713":1,"714":1,"715":1,"716":1,"717":1,"718":1,"719":1,"720":1,"721":1,"722":1,"723":1,"724":1,"725":1,"726":1,"727":1,"728":1,"729":1,"730":1,"731":1,"732":1,"733":1,"734":2,"735":2,"736":1,"737":2,"738":2,"739":2,"740":1,"741":2,"742":1,"743":1,"744":1,"745":1,"746":1,"747":1,"748":1,"749":1,"750":1,"751":1,"752":1,"753":1,"754":1,"755":1,"756":1,"757":1,"758":1,"759":1,"760":1,"795":1,"796":1,"797":1,"798":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"848":1,"849":1,"953":1,"957":1,"958":1,"1000":1,"1001":1,"1035":1,"1036":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1146":1,"1147":1,"1309":1,"1310":1,"1331":1,"1332":1,"1394":1,"1395":1,"1417":1,"1429":1,"1430":1},"2":{"45":2,"97":1,"102":1,"121":1,"125":1,"137":3,"138":11,"139":2,"158":1,"159":1,"192":2,"213":1,"226":1,"227":2,"265":1,"268":1,"276":2,"288":1,"313":3,"321":1,"324":1,"332":1,"368":1,"372":3,"390":1,"396":1,"397":1,"398":1,"399":1,"407":1,"450":1,"469":1,"481":1,"505":1,"519":2,"520":3,"567":1,"568":2,"574":1,"618":1,"689":1,"734":2,"737":1,"775":2,"795":1,"814":1,"819":1,"829":1,"859":2,"860":1,"862":1,"878":1,"904":1,"921":1,"932":2,"934":1,"935":2,"947":2,"951":1,"953":1,"954":2,"955":1,"962":1,"979":1,"1000":1,"1007":1,"1008":3,"1012":1,"1029":1,"1046":1,"1047":1,"1059":2,"1064":1,"1082":1,"1096":1,"1122":1,"1125":2,"1140":1,"1141":1,"1147":2,"1153":1,"1154":1,"1178":1,"1192":1,"1195":1,"1197":1,"1199":5,"1201":2,"1203":1,"1220":1,"1221":1,"1222":1,"1234":1,"1240":1,"1243":1,"1254":1,"1280":1,"1304":1,"1313":1,"1355":1,"1357":1,"1363":1,"1365":2,"1381":1,"1388":1,"1429":1,"1436":1}}],["3pm",{"2":{"9":1,"11":1,"12":1,"125":2,"197":1,"525":1,"888":1,"939":1,"981":1,"1209":1}}],["`nyse",{"2":{"1447":1}}],["`new",{"2":{"448":1,"1415":2}}],["`weakref`",{"2":{"1440":1}}],["`workday",{"2":{"1417":1}}],["`using`",{"2":{"1440":1}}],["`uncertainty",{"2":{"1243":1}}],["`meeting",{"2":{"1421":1}}],["`measured",{"2":{"1243":1}}],["`healthcheck",{"2":{"1417":1}}],["`https",{"2":{"1178":2}}],["`year",{"2":{"1280":1}}],["`roman",{"2":{"1280":1}}],["`recovering",{"2":{"1448":1}}],["`resets",{"2":{"968":1}}],["`remaining",{"2":{"968":2,"969":2}}],["`calibrated",{"2":{"1254":1,"1264":1}}],["`custom",{"2":{"281":1}}],["`current",{"2":{"72":1}}],["`epochs`",{"2":{"1019":1}}],["`limits",{"2":{"969":1}}],["`lite`",{"2":{"276":1}}],["`await",{"2":{"1440":1}}],["`active",{"2":{"1426":1}}],["`anchor",{"2":{"1280":1}}],["`abbreviated",{"2":{"1280":1}}],["`atomic",{"2":{"1254":1}}],["`all",{"2":{"970":1}}],["`ai",{"2":{"955":1}}],["`audited",{"2":{"271":1}}],["`finalizationregistry`",{"2":{"1440":1}}],["`format",{"2":{"973":1}}],["`false`",{"2":{"938":1}}],["`fy$",{"2":{"317":1}}],["`polling",{"2":{"1445":1}}],["`pulse",{"2":{"1438":1}}],["`provider`",{"2":{"938":1}}],["`pledge`",{"2":{"481":1}}],["`plugins`",{"2":{"291":1}}],["`stream",{"2":{"1435":1}}],["`simulated",{"2":{"1419":1}}],["`set",{"2":{"894":1}}],["`sprint",{"2":{"324":1}}],["`bearer",{"2":{"860":1,"955":1}}],["`q$",{"2":{"519":1}}],["`ticker",{"2":{"1426":1,"1440":1}}],["`t",{"2":{"1420":1}}],["`true",{"2":{"1243":1}}],["`trade",{"2":{"1221":1}}],["`tenant",{"2":{"1192":1}}],["`tempo",{"2":{"978":6}}],["`temporal`",{"2":{"27":1}}],["`tempo`",{"2":{"27":2}}],["`target`",{"2":{"426":1}}],["`t`",{"2":{"377":1}}],["`$",{"2":{"65":1,"1082":1,"1085":1,"1223":1,"1307":1,"1326":1}}],["`date`",{"2":{"27":1}}],["`",{"2":{"27":7,"62":2,"72":1,"271":1,"281":1,"317":1,"324":1,"426":1,"448":1,"519":1,"860":1,"889":10,"894":1,"955":2,"968":3,"969":3,"970":1,"973":1,"978":6,"1141":2,"1191":4,"1192":1,"1221":1,"1223":1,"1243":1,"1254":1,"1255":2,"1264":1,"1280":3,"1326":1,"1389":2,"1415":2,"1417":2,"1419":1,"1421":1,"1426":2,"1435":1,"1438":1,"1440":1,"1445":1,"1447":1,"1448":1}}],["➔",{"2":{"26":1}}],["++count",{"2":{"1409":1}}],["+θbecause",{"2":{"1235":1}}],["+6°",{"2":{"1071":1}}],["+90°",{"2":{"1071":1}}],["+30m",{"2":{"1023":1}}],["+8",{"2":{"1023":1}}],["+4",{"2":{"1023":1,"1352":1}}],["+5",{"2":{"689":1}}],["+0800",{"2":{"1125":1}}],["+08",{"2":{"637":1,"1125":2}}],["+00",{"2":{"138":2,"296":1}}],["+2",{"2":{"396":1,"1023":1,"1028":1,"1032":1}}],["+mon",{"2":{"393":1}}],["+tempo",{"2":{"355":1}}],["+16",{"2":{"1069":1}}],["+14d",{"2":{"1036":1}}],["+12s",{"2":{"1029":1,"1030":1}}],["+12",{"2":{"1028":1}}],["+1y",{"2":{"1023":1}}],["+1mo",{"2":{"1023":1}}],["+1h",{"2":{"1023":1,"1030":1}}],["+1d",{"2":{"1023":1}}],["+1w",{"2":{"1019":1,"1020":1,"1023":1,"1033":1}}],["+1",{"2":{"997":1,"1032":2}}],["+11",{"2":{"149":1}}],["+10",{"2":{"138":7,"214":1}}],["+100000",{"2":{"138":1}}],["+1000",{"2":{"138":3}}],["+n",{"2":{"138":1}}],["+",{"2":{"26":3,"91":2,"139":1,"214":2,"240":1,"243":1,"265":1,"324":2,"332":1,"359":1,"363":1,"383":1,"388":1,"393":1,"406":2,"507":1,"588":1,"735":1,"738":1,"904":1,"919":3,"940":3,"972":2,"1062":1,"1071":1,"1089":1,"1158":1,"1178":1,"1209":2,"1219":1,"1220":2,"1221":1,"1223":2,"1247":1,"1267":1,"1278":1,"1325":1,"1329":2,"1347":1,"1389":1}}],["73",{"2":{"1365":1}}],["7392",{"2":{"1070":1}}],["7th",{"2":{"1269":1}}],["7833",{"2":{"1335":1}}],["78",{"2":{"1071":1}}],["789",{"2":{"137":1,"151":1}}],["7970",{"2":{"1065":1}}],["74",{"2":{"1055":1,"1056":1,"1064":1,"1065":1,"1067":1,"1068":1,"1069":2,"1337":1,"1348":1,"1361":1,"1363":1}}],["745",{"2":{"1052":1,"1055":1,"1079":1}}],["72",{"2":{"1008":1}}],["7200000",{"2":{"978":1,"979":1}}],["7ms",{"2":{"451":1}}],["70b",{"2":{"859":1,"932":1}}],["70",{"2":{"451":1}}],["700",{"2":{"450":1,"1064":1}}],["70ms",{"2":{"450":2}}],["704",{"2":{"450":1}}],["7749",{"2":{"1335":1,"1337":1,"1359":1,"1361":1}}],["7767",{"2":{"1065":1}}],["77ms",{"2":{"450":1}}],["7781",{"2":{"1365":1}}],["778",{"2":{"450":1}}],["7x",{"2":{"442":1}}],["7134",{"2":{"1338":1}}],["710",{"2":{"1276":1,"1280":2,"1289":1}}],["7128",{"2":{"1055":1,"1056":1,"1064":1,"1065":1,"1067":1,"1068":1,"1069":2,"1337":1,"1348":1,"1361":1,"1363":1}}],["71",{"2":{"158":1,"450":3,"451":1}}],["7=sun",{"2":{"137":1,"1125":1}}],["753",{"2":{"1272":2}}],["754",{"2":{"1039":1}}],["75",{"2":{"117":1,"1077":1,"1364":1}}],["7+",{"2":{"34":1}}],["7",{"0":{"478":1,"487":1,"497":1,"562":1,"632":1,"713":1,"715":1,"762":1,"1011":1,"1065":1,"1073":1,"1421":1},"1":{"563":1,"564":1,"565":1,"633":1,"634":1,"635":1,"714":1,"716":1,"717":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1},"2":{"23":1,"39":1,"62":1,"71":3,"137":1,"138":4,"152":1,"163":1,"233":1,"266":2,"268":1,"317":1,"333":1,"365":1,"367":2,"450":2,"563":1,"564":1,"763":1,"786":1,"1059":4,"1125":1,"1199":1,"1218":1,"1221":1,"1269":1,"1296":1}}],["⚖️",{"0":{"17":1,"423":1}}],["⭐",{"2":{"16":1}}],["|lat|",{"2":{"1063":1,"1072":1}}],["||",{"2":{"69":2,"119":2,"235":1,"324":2,"519":1,"860":3,"955":1,"1178":1,"1263":1}}],["|",{"0":{"1291":1,"1292":2,"1294":1,"1295":1},"2":{"16":3,"102":1,"115":3,"117":15,"119":1,"154":5,"243":2,"285":1,"323":10,"326":6,"367":1,"382":2,"415":1,"456":6,"461":6,"473":2,"477":1,"489":1,"712":3,"750":1,"773":2,"777":2,"824":2,"832":2,"838":1,"872":3,"881":1,"882":5,"890":1,"891":7,"899":1,"900":1,"919":15,"937":13,"938":23,"959":6,"991":5,"1004":1,"1021":1,"1055":1,"1071":6,"1078":6,"1081":2,"1083":4,"1176":3,"1222":1,"1227":9,"1240":8,"1295":1,"1304":4,"1318":1,"1332":1,"1368":7,"1403":1,"1404":4}}],["🪲",{"0":{"702":1,"709":1,"714":1}}],["🧬",{"0":{"667":1}}],["🥊",{"0":{"506":1},"1":{"507":1,"508":1,"509":1,"510":1,"511":1,"512":1,"513":1,"514":1,"515":1}}],["🪝",{"0":{"322":1},"1":{"323":1,"324":1,"325":1}}],["🧭",{"0":{"318":1,"327":1,"406":1},"1":{"319":1,"320":1,"321":1}}],["🤝",{"0":{"293":1,"516":1,"529":1},"1":{"517":1,"518":1,"519":1,"520":1,"530":1,"531":1,"532":1,"533":1,"534":1}}],["🧠",{"0":{"224":1},"1":{"225":1}}],["🧲",{"0":{"148":1},"1":{"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"155":1}}],["🥇",{"2":{"129":1}}],["🥈",{"2":{"129":1}}],["🥉",{"2":{"129":1}}],["🧹",{"0":{"125":1,"546":1},"2":{"1256":1}}],["🦕",{"0":{"39":1},"1":{"40":1}}],["🤖",{"0":{"24":1,"48":1,"98":1,"247":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1,"99":1}}],["🧰",{"0":{"14":1}}],["🧩",{"0":{"135":1,"210":1,"417":1,"531":1,"633":1,"642":1,"647":1,"668":1},"1":{"136":1,"211":1,"418":1,"419":1},"2":{"12":1}}],["🧪",{"0":{"6":1,"46":1,"446":1,"573":1}}],["✅",{"0":{"409":1},"2":{"11":2,"19":1,"199":5,"243":2,"517":1,"536":1,"537":1,"542":2,"545":1,"559":2,"737":3,"1376":3,"1441":2}}],["❌",{"2":{"11":2,"19":1,"199":5,"243":1,"517":1,"537":1,"545":1,"559":2,"1376":1}}],["✨",{"0":{"659":1,"687":1,"688":1,"689":1,"690":1,"691":1,"694":1,"695":1,"701":1,"704":1,"707":1,"711":1,"716":1,"719":1,"720":1,"722":1,"723":1,"728":1,"731":1,"732":1,"734":1,"737":1,"741":1,"743":1,"746":1,"750":1,"754":1,"758":1},"2":{"11":1}}],["zweiter",{"2":{"1213":1}}],["zendesk",{"2":{"1219":1}}],["zenith",{"2":{"1063":3,"1071":2,"1366":1}}],["zealand",{"2":{"1207":1,"1213":1}}],["zeroticker",{"2":{"1438":1}}],["zero",{"0":{"103":1,"131":1,"197":1,"325":1,"407":1,"512":1,"538":1,"699":1,"812":1,"853":1,"925":1,"984":1,"996":1,"1005":1,"1007":1,"1020":1,"1089":1,"1102":1,"1145":1,"1225":1,"1235":1,"1262":1,"1280":1,"1317":1,"1363":1,"1380":1,"1408":1,"1428":1,"1444":1},"1":{"132":1,"198":1,"199":1,"854":1,"855":1,"856":1,"857":1,"926":1,"927":1,"1146":1,"1147":1,"1263":1,"1264":1,"1429":1,"1430":1},"2":{"6":1,"12":3,"24":1,"76":1,"78":1,"83":1,"96":1,"99":1,"102":1,"116":1,"117":1,"120":1,"124":2,"137":11,"138":20,"147":1,"148":2,"149":2,"150":1,"165":1,"203":1,"204":1,"227":1,"233":1,"266":1,"269":1,"271":1,"274":2,"276":1,"357":1,"370":1,"371":1,"403":1,"407":1,"419":2,"421":1,"423":1,"427":1,"428":1,"441":1,"444":1,"454":1,"465":1,"477":1,"489":1,"516":1,"527":1,"538":1,"642":1,"699":1,"704":1,"707":1,"708":1,"709":1,"716":1,"755":1,"760":1,"771":1,"792":1,"802":1,"810":1,"812":1,"818":1,"835":1,"839":1,"853":1,"857":1,"863":1,"870":1,"913":1,"925":2,"929":1,"951":2,"953":1,"954":1,"958":1,"1004":1,"1005":2,"1007":2,"1008":6,"1009":1,"1024":1,"1029":1,"1038":2,"1042":1,"1080":1,"1086":1,"1088":4,"1089":1,"1090":1,"1103":1,"1105":1,"1106":2,"1108":1,"1111":2,"1113":1,"1121":3,"1125":5,"1147":2,"1154":1,"1207":1,"1213":1,"1215":1,"1225":1,"1235":1,"1242":1,"1250":1,"1261":1,"1267":1,"1275":1,"1276":1,"1318":1,"1339":1,"1343":1,"1353":1,"1362":1,"1370":2,"1385":1,"1392":1,"1395":1,"1396":1,"1401":2,"1423":1,"1429":1,"1438":1}}],["zdc",{"0":{"305":1},"2":{"301":1,"305":1,"307":1,"309":1,"771":1,"775":2}}],["zdt",{"0":{"818":1},"2":{"81":2,"131":2,"132":1,"138":1,"146":1,"147":6,"149":8,"150":3,"197":2,"224":2,"233":1,"731":2,"814":1,"818":1,"903":2,"1121":3}}],["zombie",{"0":{"1445":1},"2":{"1401":1,"1443":1}}],["zoom",{"2":{"266":1}}],["zodiacs",{"2":{"556":1}}],["zodiac",{"0":{"305":2},"2":{"257":1,"305":4,"307":2,"385":1,"509":1,"637":2}}],["zones",{"2":{"296":1,"507":1,"1054":1,"1258":1,"1351":1,"1364":1,"1366":1}}],["zone",{"0":{"68":1,"1364":1},"2":{"117":2,"137":1,"154":1,"240":2,"399":1,"617":1,"788":1,"872":1,"1364":1}}],["zoneddatetimelike",{"2":{"351":1}}],["zoneddatetimeiso",{"2":{"131":1}}],["zoneddatetime",{"2":{"11":2,"81":1,"120":1,"131":1,"132":1,"147":2,"149":2,"150":1,"170":1,"173":1,"197":2,"199":1,"201":1,"224":1,"233":1,"323":2,"342":1,"617":1,"818":1,"903":2,"1121":1}}],["zzzzz",{"2":{"723":1,"1125":1}}],["zzzz",{"2":{"723":1,"1114":1}}],["zzz",{"2":{"138":1,"723":1,"1125":2}}],["zz",{"2":{"138":1,"723":1,"1125":2}}],["z",{"2":{"138":6,"214":1,"240":2,"359":1,"723":1,"910":1,"1125":8,"1329":1}}],["41",{"2":{"1365":1}}],["4167",{"2":{"1335":1}}],["4194",{"2":{"1335":1,"1337":1,"1359":1,"1361":1}}],["415",{"2":{"1307":1}}],["44",{"2":{"1272":1,"1273":1,"1280":2,"1307":1,"1359":1,"1394":1}}],["46",{"2":{"1078":1}}],["4°",{"2":{"1063":1,"1071":2,"1084":1}}],["4pm",{"2":{"935":1}}],["4a",{"2":{"889":1}}],["40ms",{"2":{"1331":1}}],["4050",{"2":{"1160":1}}],["40",{"2":{"1055":1,"1056":1,"1064":1,"1065":2,"1067":1,"1068":1,"1069":2,"1332":2,"1337":1,"1348":1,"1361":1,"1363":1,"1365":1}}],["403",{"2":{"955":1}}],["400",{"2":{"860":1,"895":1,"1064":1,"1072":1,"1192":1,"1218":1,"1223":1,"1357":1}}],["4096",{"2":{"860":1}}],["401",{"2":{"860":1,"955":1}}],["404",{"2":{"627":2,"1064":1}}],["4th",{"2":{"215":1,"362":1,"878":1,"1213":1}}],["49",{"2":{"158":1,"972":1,"1059":2}}],["4543",{"2":{"1365":1}}],["45m",{"2":{"1361":1}}],["450z",{"2":{"1329":1}}],["450123z",{"2":{"1328":1}}],["45z",{"2":{"1141":1}}],["45°",{"2":{"1081":1}}],["4567",{"2":{"997":2}}],["456",{"2":{"137":1,"151":1}}],["45",{"2":{"137":2,"151":1,"370":2,"387":2,"806":1,"987":1,"988":3,"1013":2,"1047":1,"1055":1,"1081":1,"1101":3,"1102":1,"1118":2,"1129":1,"1130":1,"1141":1,"1143":2,"1144":5,"1147":2,"1232":1,"1271":1,"1361":2}}],["43",{"2":{"137":1,"152":1,"158":1,"1064":1,"1280":1}}],["4700",{"2":{"1365":1}}],["4713",{"2":{"138":1,"150":2}}],["47",{"2":{"117":1,"154":1,"158":1,"872":1,"890":1,"899":1,"1158":2,"1159":1,"1160":1,"1168":1,"1207":1,"1214":1,"1359":1}}],["4o",{"2":{"89":2,"927":1,"930":1,"958":1}}],["42ms",{"2":{"1332":1}}],["422",{"2":{"871":1,"875":2,"876":1,"881":1,"890":1,"899":1,"912":2,"920":1}}],["429s",{"0":{"970":1}}],["429",{"2":{"860":1,"920":1,"921":1,"942":1,"948":1,"954":1,"970":2}}],["420",{"2":{"157":1,"158":1}}],["42",{"2":{"52":1,"142":1,"497":1,"854":1,"1062":1,"1307":1,"1332":2,"1337":1}}],["48h",{"2":{"1219":1}}],["48",{"2":{"23":1,"158":1,"164":1,"1016":1,"1160":1,"1181":1,"1218":1,"1358":1,"1360":1,"1366":1}}],["4",{"0":{"29":1,"90":1,"118":1,"119":1,"121":1,"126":1,"235":1,"281":1,"366":1,"387":1,"396":1,"466":1,"474":1,"484":1,"493":1,"505":1,"512":1,"520":1,"527":1,"557":1,"560":1,"641":1,"656":1,"730":1,"761":1,"768":1,"776":1,"789":2,"794":1,"799":1,"803":1,"809":1,"819":1,"832":1,"841":1,"850":1,"865":1,"877":1,"887":1,"896":1,"905":1,"948":1,"1002":1,"1016":1,"1048":1,"1062":1,"1070":1,"1078":1,"1084":1,"1091":1,"1096":1,"1133":1,"1148":1,"1161":1,"1182":1,"1193":1,"1223":1,"1234":1,"1257":1,"1266":1,"1311":1,"1360":1,"1366":1,"1418":1,"1437":1,"1447":1},"1":{"120":1,"127":1,"128":1,"367":1,"368":1,"369":1,"370":1,"475":1,"558":1,"559":1,"642":1,"643":1,"644":1,"645":1,"657":1,"731":1,"732":1,"762":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"770":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"779":1,"780":1,"781":1,"782":1,"783":1,"784":1,"785":1,"786":1,"787":1,"788":1,"789":1,"790":3,"791":3,"792":3,"793":3,"794":1,"795":2,"796":2,"797":2,"798":2,"799":1,"800":2,"801":2,"802":2,"803":1,"804":2,"805":2,"806":2,"807":2,"808":2,"809":1,"810":2,"811":2,"812":2,"813":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"820":1,"821":1,"822":1,"823":1,"824":1,"825":1,"826":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"834":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1,"1003":1,"1004":1,"1005":1,"1134":1,"1135":1,"1136":1,"1149":1,"1150":1,"1312":1,"1313":1,"1438":1,"1439":1},"2":{"10":1,"12":1,"19":2,"22":1,"34":1,"42":1,"43":1,"44":4,"45":1,"47":2,"137":2,"138":3,"150":2,"152":1,"158":1,"165":2,"166":1,"215":1,"240":1,"243":1,"324":1,"372":1,"450":3,"464":1,"506":1,"557":1,"571":1,"574":1,"689":1,"768":1,"790":2,"795":1,"800":1,"804":1,"810":1,"850":1,"860":1,"875":1,"934":1,"955":1,"1019":1,"1030":1,"1059":2,"1069":1,"1088":2,"1089":1,"1090":2,"1093":1,"1096":1,"1110":1,"1113":1,"1125":2,"1140":1,"1197":1,"1203":2,"1204":1,"1209":1,"1219":2,"1220":1,"1221":1,"1222":1,"1223":1,"1280":1,"1313":1,"1319":1,"1329":2,"1344":1,"1351":1,"1352":1,"1353":1,"1357":2,"1389":1}}],["5ms",{"2":{"1368":1}}],["541",{"2":{"1273":3,"1276":1,"1278":1,"1281":1,"1291":1,"1313":1}}],["5424",{"2":{"1143":1,"1144":1}}],["5x│",{"2":{"1120":1}}],["5°",{"2":{"1063":1,"1071":1,"1072":1,"1358":2}}],["5d",{"2":{"1023":1}}],["5540",{"2":{"1365":1}}],["5545",{"0":{"1014":1,"1418":1},"2":{"981":1,"984":1,"986":1,"1014":1,"1401":1,"1404":1,"1411":1,"1418":1,"1427":1}}],["5511",{"2":{"1083":1}}],["555",{"2":{"997":2}}],["55845",{"2":{"138":1}}],["5pm",{"2":{"896":1,"909":1,"951":1,"1220":1}}],["5s",{"2":{"854":1,"935":1}}],["567",{"2":{"787":1}}],["57",{"2":{"450":1,"1068":1}}],["508",{"2":{"1273":1}}],["509",{"2":{"1273":2,"1276":1,"1278":1,"1281":1,"1291":1,"1313":1}}],["502",{"2":{"860":1}}],["504",{"2":{"860":1,"955":1,"962":1}}],["50",{"2":{"665":1,"972":1,"1043":1,"1059":2,"1319":1}}],["500µs",{"2":{"1387":1}}],["500m",{"2":{"1364":1}}],["500k",{"2":{"1029":1}}],["5000",{"2":{"289":1,"290":1,"477":1,"816":1,"854":1,"927":1,"930":1,"935":1,"958":1}}],["500",{"2":{"289":1,"291":1,"450":1,"541":1,"542":1,"687":1,"860":1,"920":1,"955":1,"1028":1,"1319":1,"1364":2}}],["5074",{"2":{"121":1,"1062":1,"1347":1,"1348":1,"1358":1,"1360":1,"1363":1}}],["5th",{"2":{"140":1,"362":1,"878":1,"1269":1}}],["5309",{"2":{"997":2}}],["53",{"2":{"138":1,"152":1,"188":2,"189":2,"190":1,"768":1,"1055":1,"1059":2,"1083":1,"1125":1}}],["5200",{"2":{"1160":1}}],["523",{"2":{"442":2}}],["52",{"2":{"138":2,"188":2,"189":2,"190":1,"370":1,"1160":1,"1365":1}}],["51°",{"2":{"1365":1}}],["51µs",{"2":{"442":1}}],["51ms",{"2":{"442":1}}],["51",{"2":{"121":1,"1059":2,"1062":1,"1347":1,"1348":1,"1358":1,"1360":1,"1363":1,"1365":1}}],["5=trace",{"2":{"117":1}}],["59z",{"2":{"97":1}}],["59",{"2":{"63":2,"97":1,"151":2,"186":4,"190":2,"192":2,"320":1,"368":2,"369":2,"450":1,"1088":2,"1111":1,"1113":1,"1125":2}}],["5",{"0":{"91":1,"122":1,"123":1,"124":1,"125":1,"126":1,"282":1,"371":1,"388":1,"397":1,"467":1,"476":1,"485":1,"494":1,"513":1,"638":1,"652":1,"721":1,"725":1,"727":1,"769":1,"777":1,"779":1,"783":1,"842":1,"851":1,"866":1,"949":1,"1006":1,"1017":1,"1049":1,"1063":1,"1071":1,"1079":1,"1085":1,"1097":1,"1224":1,"1235":1,"1267":1,"1361":1,"1416":1,"1419":1,"1440":1,"1448":1},"1":{"123":1,"124":1,"125":1,"126":1,"127":2,"128":2,"372":1,"373":1,"468":1,"469":1,"495":1,"639":1,"640":1,"653":1,"654":1,"655":1,"722":1,"723":1,"724":1,"726":1,"728":1,"729":1,"780":1,"781":1,"782":1,"784":1,"785":1,"786":1,"787":1,"788":1,"1007":1,"1008":1,"1009":1,"1417":1,"1441":1,"1442":1},"2":{"10":1,"42":1,"43":1,"44":1,"45":1,"71":2,"117":1,"137":1,"138":6,"140":1,"167":1,"182":2,"183":6,"188":1,"209":2,"213":1,"240":2,"292":1,"296":1,"324":1,"328":1,"335":1,"359":1,"372":1,"446":1,"484":1,"485":1,"519":1,"645":1,"720":1,"728":1,"780":1,"784":1,"831":1,"850":1,"860":1,"880":2,"885":1,"886":2,"889":1,"898":4,"902":1,"930":1,"982":1,"983":6,"985":1,"1042":1,"1059":3,"1067":1,"1090":1,"1096":1,"1140":1,"1197":1,"1203":1,"1221":1,"1223":1,"1255":2,"1256":1,"1269":1,"1296":1,"1335":3,"1337":2,"1351":1,"1373":2,"1379":1,"1401":2,"1404":1,"1409":1,"1411":1,"1413":2,"1416":1,"1417":2,"1422":1,"1427":1,"1432":1,"1438":2,"1447":2,"1448":1}}],[">|",{"2":{"1227":1}}],[">3",{"2":{"734":1}}],[">afternoon",{"2":{"194":1,"380":1}}],[">q1",{"2":{"194":1,"380":1}}],[">=mon",{"2":{"735":1}}],[">=",{"2":{"71":1,"233":1,"235":1,"317":1,"519":2,"1178":1,"1261":1,"1409":1}}],[">fri",{"2":{"64":1,"191":2,"734":1}}],[">2",{"2":{"64":1,"191":2,"734":1}}],[">",{"2":{"10":2,"42":2,"43":4,"44":1,"45":6,"69":1,"76":1,"98":1,"222":1,"233":1,"235":1,"324":1,"737":1,"850":5,"860":1,"938":1,"978":1,"982":1,"985":1,"1013":1,"1014":2,"1015":1,"1029":1,"1030":1,"1033":1,"1036":1,"1081":4,"1178":3,"1181":2,"1329":1,"1389":1,"1415":2}}],["y≤0",{"2":{"1272":1}}],["ybce≥1",{"2":{"1272":1}}],["y≥1",{"2":{"1272":1}}],["yw",{"2":{"370":1,"768":1}}],["yang",{"2":{"305":1}}],["yarn",{"2":{"10":2,"35":2,"648":1,"846":2}}],["yinyang",{"2":{"305":1}}],["yin",{"2":{"305":2}}],["yield",{"2":{"1446":1}}],["yielding",{"2":{"138":1,"707":1,"910":1,"986":1}}],["yields",{"2":{"138":4,"450":1,"504":1,"1089":1}}],["yr",{"2":{"165":1,"166":2}}],["ymd6",{"2":{"743":1}}],["ymd",{"2":{"128":1,"137":1,"242":1,"376":1,"732":1,"758":1}}],["y",{"2":{"78":1,"372":1,"1089":1,"1101":1,"1103":3,"1104":3,"1112":1,"1115":1,"1116":3,"1120":1,"1125":2,"1129":2,"1144":1,"1149":1,"1150":1}}],["yes",{"2":{"1038":1}}],["yesterday",{"2":{"59":1,"66":1,"82":1,"157":1,"159":4,"220":1,"363":1,"1157":1}}],["yet",{"2":{"413":1,"464":1,"515":1,"1257":1}}],["ye",{"2":{"242":1}}],["yearauc",{"2":{"1304":3,"1307":1}}],["yeartoauc",{"0":{"1294":1}}],["yearlylicense",{"2":{"164":2}}],["year",{"0":{"187":1,"189":1,"190":1,"819":1,"1110":1,"1271":1,"1288":1,"1291":1,"1292":1,"1294":1,"1298":1},"1":{"188":1,"189":1,"190":1},"2":{"95":1,"137":14,"138":14,"146":2,"150":5,"152":5,"161":1,"162":1,"163":2,"164":3,"165":1,"173":1,"174":2,"184":1,"188":4,"189":7,"190":2,"192":1,"202":3,"203":1,"205":3,"216":2,"240":2,"242":5,"245":1,"268":1,"296":1,"301":1,"303":1,"305":1,"313":1,"315":1,"317":5,"321":2,"333":1,"362":2,"370":3,"381":1,"518":1,"606":1,"654":1,"732":1,"743":2,"763":2,"766":5,"768":2,"776":1,"823":1,"842":2,"885":1,"909":2,"1047":1,"1069":1,"1088":8,"1089":5,"1093":2,"1098":1,"1105":1,"1110":5,"1113":1,"1121":1,"1124":1,"1125":11,"1151":1,"1213":7,"1217":1,"1222":2,"1223":1,"1224":2,"1271":1,"1272":1,"1275":2,"1276":2,"1278":1,"1280":3,"1285":1,"1286":1,"1287":1,"1290":1,"1291":1,"1294":2,"1295":2,"1298":1,"1304":4,"1310":3,"1312":1,"1313":2}}],["years",{"0":{"1093":1},"2":{"63":1,"76":1,"117":1,"156":1,"157":1,"159":1,"160":1,"161":2,"162":1,"163":1,"164":1,"202":1,"321":2,"519":1,"531":1,"654":2,"704":1,"766":1,"964":1,"1023":1,"1045":1,"1093":1,"1097":1,"1098":1,"1105":1,"1271":1,"1272":4,"1273":3,"1276":2,"1278":1,"1281":2,"1293":1,"1306":1,"1319":1,"1404":2,"1412":2,"1413":2}}],["yyww",{"2":{"743":1}}],["yywy",{"2":{"743":1}}],["yy>",{"2":{"243":1,"246":1}}],["yy",{"2":{"30":1,"32":1,"64":1,"137":1,"148":1,"150":1,"190":2,"191":1,"207":1,"224":1,"233":1,"240":1,"242":5,"243":3,"244":1,"245":1,"246":1,"247":1,"265":1,"317":1,"351":1,"719":1,"732":2,"734":1,"763":1,"765":2,"985":1,"1088":1,"1089":4,"1098":2,"1125":4,"1404":1,"1413":2}}],["yyyyddd",{"2":{"138":1}}],["yyyymmdd",{"2":{"137":1}}],["yyyy",{"0":{"215":1,"1110":2},"1":{"216":1,"217":1,"218":1},"2":{"9":1,"54":1,"76":1,"78":4,"96":1,"112":1,"113":1,"119":1,"124":1,"131":1,"134":1,"137":7,"138":7,"140":1,"205":7,"207":1,"271":1,"295":2,"325":1,"370":2,"513":1,"518":1,"545":2,"680":1,"806":6,"817":1,"881":1,"882":1,"889":2,"897":1,"918":1,"961":1,"964":2,"972":1,"985":1,"988":2,"1036":1,"1083":2,"1088":7,"1089":5,"1090":1,"1091":3,"1098":2,"1101":2,"1102":1,"1103":5,"1104":3,"1105":2,"1110":5,"1112":3,"1113":4,"1114":2,"1115":3,"1116":3,"1118":1,"1119":4,"1120":2,"1125":7,"1127":3,"1128":2,"1130":1,"1131":2,"1132":1,"1134":2,"1135":4,"1136":2,"1139":2,"1140":5,"1141":5,"1146":2,"1147":3,"1149":1,"1150":4,"1190":2,"1197":2,"1199":2,"1209":1,"1220":1,"1221":3,"1222":2,"1223":1,"1224":1,"1243":1,"1254":1,"1255":1,"1265":2,"1280":1,"1304":2,"1307":1,"1310":1,"1313":1,"1329":1,"1412":1,"1417":1,"1419":1,"1422":1,"1444":1,"1446":1,"1447":1}}],["yow",{"0":{"187":1,"189":1,"768":1},"1":{"188":1,"189":1,"190":1},"2":{"137":1,"138":7,"152":1,"187":1,"188":1,"189":3,"190":3,"370":2,"763":3,"768":2,"1088":1,"1089":2,"1093":3,"1098":2,"1110":1,"1125":1}}],["york",{"2":{"6":1,"9":1,"58":1,"68":1,"73":1,"110":2,"215":1,"296":2,"448":1,"690":1,"872":1,"889":1,"898":2,"907":1,"988":2,"1054":1,"1055":2,"1065":1,"1067":2,"1254":1,"1348":1,"1361":1,"1363":1,"1429":2,"1430":1,"1447":2}}],["yourapp",{"2":{"1178":2}}],["yourdomain",{"2":{"931":1,"938":1,"953":1,"955":1}}],["yourself",{"2":{"11":1,"76":1,"169":1}}],["your",{"0":{"284":1,"853":1,"1278":1},"1":{"285":1,"286":1,"287":1,"854":1,"855":1,"856":1,"857":1},"2":{"0":1,"6":1,"8":3,"23":1,"24":2,"26":1,"27":1,"28":2,"34":1,"41":1,"43":7,"45":1,"47":1,"48":1,"58":1,"64":1,"84":1,"90":2,"96":1,"102":5,"107":1,"109":2,"114":1,"118":1,"123":1,"128":1,"131":1,"134":1,"139":1,"146":1,"147":1,"166":1,"191":5,"195":1,"197":1,"198":2,"212":1,"214":1,"215":2,"219":4,"222":1,"228":1,"229":4,"230":1,"234":2,"235":2,"236":2,"243":2,"246":1,"248":2,"249":1,"261":2,"264":2,"266":1,"267":1,"268":2,"269":1,"270":1,"271":1,"272":1,"274":1,"276":3,"279":1,"280":1,"281":3,"284":1,"285":1,"286":1,"288":1,"293":2,"296":1,"317":1,"319":1,"320":1,"321":2,"326":8,"327":1,"334":1,"341":3,"362":1,"364":1,"365":2,"368":1,"381":2,"387":2,"389":3,"447":1,"448":2,"451":1,"462":2,"463":1,"470":1,"482":1,"503":1,"510":1,"515":1,"517":1,"519":2,"520":1,"531":1,"532":1,"534":1,"548":1,"559":3,"560":3,"565":1,"572":1,"681":1,"728":1,"731":1,"737":2,"741":2,"746":1,"759":3,"844":1,"846":1,"847":1,"851":1,"852":1,"853":1,"854":2,"856":2,"859":4,"860":2,"862":1,"870":1,"907":1,"909":2,"913":1,"927":1,"931":2,"952":1,"953":1,"954":1,"955":2,"957":1,"966":1,"970":3,"972":1,"993":1,"998":2,"1007":2,"1008":3,"1011":1,"1114":1,"1122":1,"1188":2,"1189":1,"1235":1,"1263":2,"1379":1,"1415":1,"1459":1}}],["you",{"0":{"515":1,"551":1,"552":1},"2":{"0":1,"6":1,"7":1,"8":1,"10":1,"11":2,"15":1,"20":2,"21":1,"23":1,"28":1,"33":2,"34":3,"39":2,"43":7,"44":2,"45":2,"46":5,"56":1,"59":1,"62":1,"63":2,"64":1,"76":2,"78":1,"87":1,"89":1,"93":1,"94":1,"95":1,"97":2,"100":1,"102":4,"107":1,"108":1,"109":3,"112":1,"114":1,"118":1,"121":1,"123":1,"124":3,"125":1,"126":1,"128":2,"131":4,"134":1,"135":1,"136":2,"137":1,"138":4,"139":1,"142":1,"146":5,"147":4,"148":1,"150":1,"157":2,"160":1,"161":9,"163":3,"164":2,"165":2,"166":1,"168":1,"169":1,"170":2,"173":1,"183":2,"185":1,"191":4,"192":1,"195":2,"197":2,"205":2,"207":1,"210":3,"211":2,"214":1,"215":1,"216":1,"217":2,"218":1,"219":1,"221":1,"222":2,"223":1,"226":1,"229":2,"230":4,"233":4,"234":3,"235":1,"236":2,"237":1,"239":1,"243":2,"246":1,"249":2,"250":3,"260":1,"261":4,"263":1,"265":1,"266":3,"267":1,"269":2,"270":1,"271":4,"276":1,"278":1,"281":3,"287":1,"292":1,"293":1,"294":1,"295":2,"296":1,"298":1,"308":1,"311":2,"315":2,"316":1,"317":1,"320":2,"338":1,"339":1,"343":1,"349":1,"355":1,"357":1,"358":2,"359":3,"360":1,"361":1,"363":1,"369":1,"374":1,"375":3,"378":1,"379":1,"381":2,"385":2,"386":2,"387":2,"388":1,"390":1,"392":1,"394":2,"396":1,"397":1,"398":1,"425":2,"451":1,"452":1,"454":1,"455":2,"456":1,"458":1,"462":1,"468":1,"469":1,"474":1,"479":1,"482":2,"483":1,"485":1,"486":1,"491":1,"502":1,"503":1,"505":1,"506":2,"509":2,"512":2,"513":1,"515":6,"517":2,"519":4,"520":1,"548":1,"551":1,"552":4,"558":1,"559":1,"561":2,"569":2,"573":2,"675":2,"691":1,"695":1,"720":1,"728":2,"731":1,"734":1,"737":2,"739":3,"759":2,"853":1,"854":1,"856":2,"877":1,"878":1,"885":1,"887":1,"908":2,"909":1,"927":1,"931":1,"932":1,"954":2,"970":1,"972":3,"976":1,"977":1,"978":1,"1017":1,"1048":1,"1049":2,"1088":1,"1089":4,"1114":1,"1116":1,"1150":1,"1178":1,"1179":1,"1181":1,"1191":1,"1263":1,"1412":1,"1422":1,"1435":2,"1436":2,"1459":1}}],["⏳",{"0":{"11":1},"1":{"12":1},"2":{"9":1}}],["=fri",{"2":{"393":1}}],["=wed",{"2":{"393":1,"394":1}}],["==",{"2":{"107":1,"860":2,"978":2}}],["===",{"2":{"34":1,"265":2,"266":2,"270":2,"281":1,"324":5,"490":1,"519":1,"860":1,"869":1,"912":1,"920":1,"936":1,"942":2,"970":1,"973":1,"985":1,"996":1,"1077":1,"1178":1,"1191":2,"1222":1,"1332":1,"1372":1,"1420":1}}],["=>",{"2":{"69":2,"119":4,"147":2,"223":1,"235":1,"261":2,"265":5,"266":2,"267":1,"270":4,"271":2,"286":1,"332":2,"334":2,"426":1,"437":2,"477":3,"482":2,"483":3,"485":1,"490":3,"491":1,"536":2,"543":1,"731":1,"792":1,"807":1,"860":1,"885":1,"933":4,"938":5,"955":3,"958":1,"978":4,"998":2,"1004":3,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1178":1,"1254":1,"1255":1,"1256":1,"1263":1,"1264":1,"1307":1,"1329":1,"1408":2,"1412":2,"1415":2,"1417":2,"1418":1,"1419":1,"1420":1,"1421":2,"1422":1,"1424":4,"1429":5,"1433":1,"1438":2,"1439":1,"1441":2,"1444":1,"1447":1,"1448":2}}],["=",{"2":{"9":3,"10":3,"32":1,"36":1,"38":1,"40":1,"42":1,"45":2,"46":1,"52":1,"53":1,"54":1,"55":1,"58":1,"62":4,"63":3,"64":1,"65":2,"66":1,"68":2,"69":3,"71":8,"72":1,"73":2,"75":1,"76":1,"77":1,"78":1,"80":2,"81":3,"82":1,"87":1,"88":1,"95":1,"96":2,"98":2,"103":1,"112":2,"115":1,"117":1,"118":1,"119":3,"121":1,"123":1,"124":1,"125":1,"131":2,"133":1,"134":1,"137":1,"138":1,"140":1,"144":2,"145":1,"146":5,"147":3,"149":1,"150":2,"152":2,"158":3,"159":4,"160":1,"162":2,"163":4,"164":2,"165":1,"166":1,"169":1,"170":1,"171":2,"176":1,"177":1,"178":2,"179":3,"180":3,"182":1,"186":1,"191":2,"192":1,"197":1,"200":1,"205":2,"214":1,"215":2,"217":2,"222":1,"223":2,"226":1,"231":1,"232":1,"233":10,"235":10,"236":2,"243":1,"244":1,"246":1,"261":3,"265":5,"266":3,"268":1,"270":2,"271":3,"276":1,"281":1,"285":3,"286":1,"295":1,"303":2,"304":2,"305":1,"306":1,"313":6,"315":2,"317":4,"323":6,"324":5,"333":3,"334":3,"335":2,"336":1,"339":1,"357":1,"358":1,"360":1,"363":2,"367":1,"368":1,"370":7,"372":2,"377":1,"383":2,"388":1,"393":2,"394":1,"426":2,"431":1,"437":3,"438":2,"448":1,"454":1,"455":1,"456":2,"458":4,"459":3,"461":6,"463":4,"464":2,"473":1,"477":5,"481":2,"482":1,"483":1,"484":1,"486":1,"489":3,"491":1,"493":4,"494":1,"496":2,"500":2,"501":1,"502":1,"518":2,"519":11,"520":8,"536":1,"543":2,"695":1,"731":2,"734":1,"735":3,"737":1,"738":1,"765":3,"768":1,"774":2,"786":1,"792":2,"793":1,"797":1,"806":4,"807":2,"831":1,"838":1,"848":1,"849":1,"850":2,"855":1,"859":1,"860":8,"870":1,"875":1,"877":1,"878":3,"880":3,"885":2,"887":1,"889":3,"894":3,"895":1,"896":2,"898":3,"903":2,"904":1,"905":1,"908":2,"912":1,"916":1,"917":1,"918":1,"925":1,"934":3,"935":1,"937":6,"939":1,"945":1,"946":1,"948":1,"949":1,"950":3,"954":1,"955":10,"957":1,"959":4,"961":1,"962":1,"964":1,"968":1,"969":1,"970":1,"973":2,"974":2,"975":1,"977":1,"978":7,"982":1,"983":5,"984":1,"985":1,"988":1,"991":1,"997":1,"998":2,"1004":2,"1013":2,"1014":1,"1015":1,"1016":2,"1019":2,"1020":2,"1030":3,"1033":2,"1036":2,"1039":3,"1041":2,"1046":7,"1047":2,"1048":2,"1049":1,"1054":1,"1055":3,"1056":1,"1059":1,"1060":2,"1061":1,"1062":5,"1063":1,"1064":1,"1065":2,"1067":1,"1068":2,"1069":3,"1070":1,"1071":5,"1072":2,"1073":1,"1076":1,"1077":1,"1078":2,"1081":3,"1082":2,"1083":3,"1084":2,"1085":2,"1089":1,"1097":2,"1101":1,"1102":1,"1113":1,"1114":2,"1115":2,"1116":3,"1118":1,"1119":2,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1136":2,"1141":5,"1144":1,"1147":3,"1150":5,"1153":1,"1154":1,"1158":3,"1159":1,"1171":3,"1172":3,"1178":17,"1180":2,"1181":3,"1184":3,"1186":1,"1187":1,"1188":2,"1190":4,"1191":7,"1192":3,"1193":3,"1195":2,"1197":3,"1199":3,"1201":2,"1203":8,"1204":1,"1205":2,"1209":4,"1214":1,"1216":1,"1217":1,"1220":5,"1221":5,"1222":4,"1223":8,"1224":3,"1239":1,"1241":1,"1243":1,"1247":1,"1254":1,"1255":1,"1256":1,"1260":1,"1261":1,"1264":1,"1265":1,"1266":1,"1271":2,"1273":1,"1280":6,"1281":1,"1304":4,"1307":3,"1310":4,"1313":3,"1316":7,"1317":1,"1326":5,"1329":8,"1332":6,"1334":1,"1335":7,"1337":4,"1338":2,"1347":5,"1348":4,"1351":2,"1352":4,"1355":1,"1357":6,"1358":9,"1359":3,"1360":6,"1361":4,"1363":5,"1364":4,"1365":6,"1366":2,"1373":1,"1379":2,"1380":1,"1381":4,"1389":10,"1392":5,"1395":2,"1400":1,"1403":2,"1408":1,"1409":2,"1412":3,"1415":2,"1417":2,"1418":2,"1419":1,"1420":1,"1422":1,"1424":1,"1425":5,"1426":1,"1429":7,"1430":2,"1433":1,"1434":1,"1435":1,"1436":1,"1438":2,"1439":1,"1441":2,"1444":2,"1445":1,"1446":1,"1447":1,"1448":1,"1452":1}}],["🌘",{"2":{"1060":1}}],["🌒",{"2":{"1060":1}}],["🌈",{"0":{"429":1}}],["🎭",{"0":{"205":1}}],["🎛️",{"0":{"138":1,"155":1}}],["🏅",{"2":{"129":1}}],["🌟",{"0":{"107":1,"764":1,"772":1,"781":1,"785":1,"791":1,"796":1,"801":1,"805":1,"811":1,"815":1,"822":1,"828":1,"837":1},"1":{"765":1,"766":1,"767":1,"768":1,"769":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"782":1,"786":1,"787":1,"788":1,"792":1,"793":1,"797":1,"798":1,"802":1,"806":1,"807":1,"808":1,"812":1,"816":1,"817":1,"818":1,"819":1,"823":1,"824":1,"825":1,"829":1,"830":1,"831":1,"832":1,"838":1,"839":1,"840":1,"841":1,"842":1}}],["🏆",{"0":{"102":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1}}],["🏛️",{"0":{"93":1,"532":1,"1087":1},"1":{"94":1,"1088":1,"1089":1,"1090":1,"1091":1}}],["🎨",{"0":{"84":1,"666":1},"2":{"83":1}}],["🌍",{"0":{"146":1,"154":1,"212":1},"1":{"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1},"2":{"12":1}}],["🌐",{"0":{"41":1,"145":1,"401":1},"1":{"42":1,"43":1,"44":1,"402":1},"2":{"10":1}}],["🌌",{"2":{"9":1}}],["🎯",{"2":{"9":1}}],["🏗️",{"0":{"1":1,"133":1,"200":1,"400":1,"405":1,"443":1,"616":1,"625":1,"653":1,"675":1,"712":1,"717":1,"724":1,"726":1,"738":1,"744":1,"748":1,"752":1,"755":1,"760":1},"1":{"134":1,"201":1,"202":1,"203":1,"204":1,"205":1,"401":1,"402":1,"403":1,"404":1,"405":1,"406":1,"407":1,"408":1,"409":1,"410":1,"411":1,"412":1,"413":1,"414":1,"415":1,"416":1,"417":1,"418":1,"419":1,"420":1,"421":1,"422":1,"423":1,"444":1,"445":1},"2":{"12":1}}],["⚡",{"0":{"9":1,"85":1,"124":1,"149":1,"359":1,"407":1,"415":1,"536":1,"683":1,"696":1,"699":1,"735":1,"739":1,"1106":1},"1":{"416":1},"2":{"83":1,"1408":1,"1433":1,"1434":1}}],["🚫",{"0":{"1092":1,"1450":1},"1":{"1093":1,"1094":1,"1095":1,"1096":1,"1097":1}}],["🟡",{"2":{"940":4}}],["🗑️",{"0":{"843":1}}],["🔗",{"0":{"682":1}}],["🐛",{"0":{"660":1,"833":1}}],["🚑",{"0":{"651":1}}],["🚨",{"0":{"629":1,"757":1,"836":1}}],["📏",{"0":{"567":1},"1":{"568":1,"569":1}}],["📂",{"0":{"544":1},"1":{"545":1}}],["🔒",{"0":{"543":1,"861":1},"1":{"862":1,"863":1,"864":1,"865":1,"866":1},"2":{"913":1}}],["🔓",{"0":{"539":1}}],["📄",{"0":{"538":1,"1025":1,"1107":1,"1321":1,"1384":1}}],["📬",{"0":{"534":1}}],["🐢",{"2":{"518":1,"519":1,"520":1}}],["💎",{"0":{"508":1},"1":{"509":1,"510":1,"511":1,"512":1,"513":1},"2":{"507":1}}],["🔍",{"0":{"451":1,"654":1,"664":1}}],["📈",{"0":{"419":1,"447":1},"1":{"448":1,"449":1,"450":1,"451":1}}],["🔁",{"0":{"408":1,"548":1,"560":1,"561":1,"562":1,"566":1,"570":1},"1":{"409":1,"410":1,"563":1,"564":1,"565":1,"567":1,"568":1,"569":1,"571":1,"572":1}}],["🕵️",{"0":{"403":1}}],["🔢",{"0":{"206":1},"1":{"207":1,"208":1,"209":1}}],["📆",{"0":{"203":1},"1":{"204":1}}],["🔤",{"0":{"153":1,"1103":1}}],["🗓️",{"0":{"152":1,"556":1,"680":1}}],["🟢",{"2":{"146":1,"940":12}}],["🔴",{"2":{"146":1,"940":2}}],["📍",{"0":{"141":1,"226":1},"1":{"142":1,"143":1,"144":1,"145":1,"227":1}}],["🔠",{"0":{"137":1},"1":{"138":1,"139":1,"140":1}}],["🐚",{"2":{"129":1}}],["📊",{"0":{"129":1,"442":1,"645":1,"1098":1}}],["📅",{"0":{"123":1,"150":1,"296":1}}],["🛑",{"0":{"109":1}}],["📖",{"0":{"95":1,"1024":1,"1105":1,"1320":1,"1383":1}}],["📋",{"2":{"89":1,"90":2}}],["🛡️",{"0":{"47":1,"228":1,"404":1,"410":1,"533":1,"631":1,"634":1,"643":1,"657":1,"663":1,"679":1}}],["💻",{"0":{"35":1},"1":{"36":1,"37":1,"38":1}}],["👉",{"2":{"29":1,"48":1,"56":1,"58":1,"59":1,"64":1,"69":1,"76":3,"77":1,"78":1,"195":1,"230":1,"275":1,"280":1,"471":1,"472":1,"473":1,"475":1,"867":1}}],["🐞",{"2":{"16":1}}],["💡",{"0":{"96":1,"204":1},"1":{"97":1},"2":{"16":1,"191":1}}],["🗳️",{"0":{"16":1}}],["💬",{"0":{"15":1}}],["📚",{"0":{"13":1,"627":1,"648":1,"655":1,"661":1,"671":1,"692":1,"697":1,"705":1,"708":1,"729":1,"747":1,"751":1,"1021":1,"1104":1,"1318":1,"1382":1},"1":{"1022":1,"1023":1,"1319":1}}],["🗣️",{"2":{"12":1}}],["📦",{"0":{"10":1,"45":1,"550":1,"618":1,"665":1,"759":1,"1451":1},"1":{"551":1,"552":1}}],["📝",{"0":{"140":1,"676":1},"2":{"9":1}}],["🔄",{"0":{"139":1,"315":1,"420":1},"1":{"421":1,"422":1},"2":{"9":1}}],["🔌",{"0":{"541":1,"553":1,"678":1},"1":{"542":1,"554":1,"555":1},"2":{"9":1}}],["🚀",{"0":{"8":1,"25":1,"126":1,"131":1,"197":1,"441":1,"530":1,"540":1,"557":1,"574":1,"672":1,"684":1,"763":1,"771":1,"780":1,"784":1,"790":1,"795":1,"800":1,"804":1,"810":1,"814":1,"821":1,"827":1,"835":1,"1019":1,"1100":1,"1316":1,"1378":1},"1":{"26":1,"27":1,"28":1,"29":1,"127":1,"128":1,"132":1,"198":1,"199":1,"442":1,"443":1,"444":1,"445":1,"446":1,"447":1,"448":1,"449":1,"450":1,"451":1,"531":1,"532":1,"533":1,"541":1,"542":1,"543":1,"544":1,"545":1,"546":1,"558":1,"559":1,"575":1,"1020":1,"1101":1,"1102":1,"1317":1,"1379":1,"1380":1,"1381":1},"2":{"16":1,"84":1,"85":1,"518":1,"519":1,"520":1,"1420":1}}],["📜",{"0":{"7":1,"576":1,"586":1,"604":1,"685":1,"761":1},"1":{"577":1,"578":1,"579":1,"580":1,"581":1,"582":1,"583":1,"584":1,"585":1,"587":1,"588":1,"589":1,"590":1,"591":1,"592":1,"593":1,"594":1,"595":1,"596":1,"597":1,"598":1,"599":1,"600":1,"601":1,"602":1,"603":1,"605":1,"606":1,"607":1,"608":1,"609":1,"610":1,"611":1,"612":1,"613":1,"614":1,"615":1,"616":1,"617":1,"618":1,"619":1,"620":1,"621":1,"622":1,"623":1,"624":1,"625":1,"626":1,"627":1,"628":1,"629":1,"630":1,"631":1,"632":1,"633":1,"634":1,"635":1,"636":1,"637":1,"638":1,"639":1,"640":1,"641":1,"642":1,"643":1,"644":1,"645":1,"646":1,"647":1,"648":1,"649":1,"650":1,"651":1,"652":1,"653":1,"654":1,"655":1,"656":1,"657":1,"658":1,"659":1,"660":1,"661":1,"662":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"670":1,"671":1,"672":1,"673":1,"674":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"686":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"693":1,"694":1,"695":1,"696":1,"697":1,"698":1,"699":1,"700":1,"701":1,"702":1,"703":1,"704":1,"705":1,"706":1,"707":1,"708":1,"709":1,"710":1,"711":1,"712":1,"713":1,"714":1,"715":1,"716":1,"717":1,"718":1,"719":1,"720":1,"721":1,"722":1,"723":1,"724":1,"725":1,"726":1,"727":1,"728":1,"729":1,"730":1,"731":1,"732":1,"733":1,"734":1,"735":1,"736":1,"737":1,"738":1,"739":1,"740":1,"741":1,"742":1,"743":1,"744":1,"745":1,"746":1,"747":1,"748":1,"749":1,"750":1,"751":1,"752":1,"753":1,"754":1,"755":1,"756":1,"757":1,"758":1,"759":1,"760":1,"762":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"770":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"779":1,"780":1,"781":1,"782":1,"783":1,"784":1,"785":1,"786":1,"787":1,"788":1,"789":1,"790":1,"791":1,"792":1,"793":1,"794":1,"795":1,"796":1,"797":1,"798":1,"799":1,"800":1,"801":1,"802":1,"803":1,"804":1,"805":1,"806":1,"807":1,"808":1,"809":1,"810":1,"811":1,"812":1,"813":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"820":1,"821":1,"822":1,"823":1,"824":1,"825":1,"826":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"834":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1}}],["🛠️",{"0":{"2":1,"30":1,"147":1,"326":1,"537":1,"558":1,"649":1,"1449":1},"1":{"3":1,"4":1,"5":1,"31":1,"32":1,"1450":1,"1451":1,"1452":1}}],["kb",{"2":{"1278":3}}],["kyūjitsu",{"2":{"1213":1}}],["kyoto",{"2":{"877":1}}],["kk",{"2":{"1136":5}}],["kkkk",{"2":{"1088":1}}],["km",{"2":{"1064":6,"1335":5,"1344":3,"1347":3,"1348":2,"1355":1,"1356":1,"1357":3,"1360":3,"1361":3,"1363":4,"1365":2}}],["kv",{"2":{"866":1,"890":1,"895":1,"899":1,"904":1,"937":1,"938":1,"1009":1}}],["kal",{"2":{"1270":2,"1271":1,"1276":2,"1280":2,"1303":1,"1304":3}}],["kalendas",{"2":{"1270":2,"1271":5,"1276":1,"1280":2,"1310":1}}],["kalendae",{"2":{"1269":1}}],["kalendis",{"2":{"1269":3,"1270":1}}],["kalends",{"2":{"1269":4,"1270":2,"1271":1,"1273":1,"1275":1,"1276":2,"1280":1,"1299":1,"1304":2}}],["karfreitag",{"2":{"1213":1}}],["kafka",{"2":{"1042":1}}],["kanji",{"2":{"752":1}}],["kathmandu",{"2":{"296":1}}],["k",{"0":{"1094":2},"2":{"476":1,"1094":2,"1125":3,"1136":1}}],["kolkata",{"2":{"296":1}}],["kilometers",{"2":{"1064":1,"1356":1}}],["kicks",{"2":{"948":1}}],["kickoff",{"2":{"695":1}}],["kind",{"2":{"922":1,"1125":2}}],["king",{"0":{"1077":1},"2":{"233":1,"1052":1,"1074":1,"1077":2,"1080":1,"1213":3}}],["kingdom",{"2":{"121":1,"1207":1,"1213":1}}],["kit",{"2":{"514":1}}],["ki",{"2":{"28":1}}],["know",{"2":{"128":1,"164":1,"234":1,"337":1,"909":1}}],["knows",{"2":{"44":1}}],["knowledge",{"2":{"28":1,"418":1,"661":1}}],["known",{"0":{"773":1},"2":{"3":1,"144":1,"322":2,"467":1,"752":1,"773":1,"1119":1}}],["keplerian",{"2":{"1353":1}}],["kept",{"2":{"426":1,"1005":1,"1442":1}}],["keel",{"0":{"1083":1},"2":{"1052":1,"1083":1}}],["keeps",{"2":{"139":1,"280":1,"711":1,"734":1,"942":1,"1158":1}}],["keeping",{"2":{"107":1,"412":1,"429":1,"465":1,"468":1,"479":1,"705":1,"972":1,"1029":1,"1043":1,"1121":1,"1173":1}}],["keep",{"2":{"23":1,"43":1,"129":1,"197":1,"326":3,"331":1,"427":2,"447":1,"515":1,"732":1,"1011":1,"1030":1,"1122":1,"1371":1,"1408":1}}],["key=",{"2":{"957":2}}],["key>",{"2":{"854":1}}],["keyname",{"2":{"461":1}}],["keyoropts",{"0":{"1185":1},"1":{"1186":1,"1187":1},"2":{"1168":3}}],["keyof",{"2":{"456":1,"461":1}}],["keyonly",{"2":{"313":3,"315":1,"317":2,"319":2,"320":1}}],["keyed",{"0":{"1186":1},"2":{"115":1,"117":1}}],["keyboard",{"0":{"91":1}}],["key",{"0":{"86":1,"141":1,"145":1,"451":1,"475":1,"763":1,"769":1,"771":1,"780":1,"784":1,"790":1,"795":1,"800":1,"804":1,"810":1,"814":1,"821":1,"827":1,"835":1,"853":1,"873":1,"883":1,"892":1,"901":1,"947":1,"1003":1,"1004":1,"1207":1,"1276":1},"1":{"87":1,"88":1,"89":1,"90":1,"91":1,"142":1,"143":1,"144":1,"145":1,"854":1,"855":1,"856":1,"857":1,"874":1,"875":1,"876":1,"877":1,"878":1,"884":1,"885":1,"886":1,"887":1,"893":1,"894":1,"895":1,"896":1,"902":1,"903":1,"904":1,"905":1},"2":{"75":1,"76":1,"89":3,"95":1,"102":2,"105":1,"110":3,"111":2,"116":1,"117":2,"123":1,"141":1,"142":1,"155":1,"190":1,"204":1,"242":1,"271":1,"281":1,"301":4,"303":1,"304":1,"305":1,"306":2,"307":4,"313":9,"314":1,"315":3,"317":2,"320":1,"324":2,"326":8,"379":1,"388":1,"409":1,"437":4,"453":1,"461":7,"465":1,"469":1,"476":1,"477":1,"500":1,"539":1,"541":2,"549":1,"609":2,"644":1,"744":1,"769":3,"836":2,"845":1,"852":1,"853":13,"854":4,"855":2,"856":4,"857":1,"859":1,"860":6,"864":2,"866":1,"867":1,"870":2,"880":2,"889":2,"898":2,"913":1,"925":5,"926":4,"927":4,"929":2,"930":4,"932":2,"933":3,"934":4,"935":2,"937":1,"938":1,"939":4,"947":9,"953":1,"955":2,"957":2,"958":3,"959":3,"961":2,"972":2,"974":2,"978":9,"982":2,"988":2,"997":2,"1003":1,"1004":10,"1017":2,"1046":2,"1047":1,"1059":1,"1067":1,"1072":3,"1088":1,"1185":1,"1213":1,"1319":1,"1329":1}}],["keys",{"0":{"409":1,"719":1,"720":1,"956":1},"1":{"957":1,"958":1},"2":{"64":1,"76":1,"89":4,"92":1,"129":1,"185":1,"190":1,"191":5,"281":1,"294":1,"298":2,"315":1,"326":2,"388":3,"403":1,"409":6,"410":3,"439":1,"440":1,"454":1,"456":1,"460":2,"461":2,"463":1,"464":1,"465":4,"466":1,"468":4,"469":1,"471":1,"476":1,"539":1,"565":2,"616":1,"720":1,"734":2,"744":1,"769":5,"775":1,"788":1,"853":1,"856":1,"857":2,"859":1,"863":1,"867":1,"870":2,"904":1,"913":1,"919":1,"929":1,"931":1,"942":1,"947":1,"953":1,"954":1,"978":3,"1004":3,"1005":2,"1007":1,"1008":3,"1009":2,"1011":1,"1054":1,"1185":1,"1186":1,"1331":1}}],["keywords",{"2":{"221":1,"363":1,"395":1,"737":2,"738":1}}],["keyword",{"0":{"395":1,"802":1},"2":{"6":1,"109":1,"229":1,"335":1,"395":1,"422":1,"469":1,"486":1,"738":1,"833":1,"1124":1}}],["vm",{"2":{"1041":1}}],["vllm",{"2":{"939":1}}],["vulnerable",{"2":{"1005":1,"1260":1}}],["vulnerabilities",{"2":{"21":1,"23":1,"503":1}}],["vulnerability",{"0":{"20":1},"1":{"21":1,"22":1,"23":1},"2":{"20":1,"22":1,"23":1,"857":1}}],["vue",{"0":{"1429":1},"2":{"709":2,"857":1,"1005":1}}],["v0",{"0":{"577":1,"583":1},"1":{"578":1,"579":1,"580":1,"581":1,"582":1,"584":1,"585":1}}],["v18+",{"2":{"1376":1}}],["v1",{"0":{"554":1,"587":1,"591":1,"595":1,"599":1},"1":{"588":1,"589":1,"590":1,"592":1,"593":1,"594":1,"596":1,"597":1,"598":1,"600":1,"601":1,"602":1,"603":1},"2":{"549":1,"551":1,"554":1,"556":1,"573":1,"808":1,"854":2,"856":1,"859":1,"860":1,"932":1,"937":1,"955":1,"958":2,"1261":1}}],["v3",{"0":{"547":1,"548":1,"570":1,"686":1,"693":1,"698":1,"700":1,"703":1,"706":1,"710":1,"713":1,"715":1,"718":1,"721":1,"725":1,"727":1,"730":1,"733":1,"736":1,"740":1,"742":1,"745":1,"749":1,"753":1,"756":1},"1":{"548":1,"571":1,"572":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"694":1,"695":1,"696":1,"697":1,"699":1,"701":1,"702":1,"704":1,"705":1,"707":1,"708":1,"709":1,"711":1,"712":1,"714":1,"716":1,"717":1,"719":1,"720":1,"722":1,"723":1,"724":1,"726":1,"728":1,"729":1,"731":1,"732":1,"734":1,"735":1,"737":1,"738":1,"739":1,"741":1,"743":1,"744":1,"746":1,"747":1,"748":1,"750":1,"751":1,"752":1,"754":1,"755":1,"757":1,"758":1,"759":1,"760":1},"2":{"535":1,"537":1,"545":1,"547":1,"572":1,"695":1,"728":1,"734":1,"737":1,"836":1}}],["v",{"2":{"476":1,"1089":2,"1125":2,"1273":1,"1280":1,"1312":1,"1313":2,"1329":2}}],["v8",{"2":{"412":1,"446":1,"729":1}}],["v22+",{"2":{"446":1}}],["v24",{"2":{"419":2}}],["v2",{"0":{"549":1,"555":1,"557":1,"605":1,"608":1,"611":1,"615":1,"619":1,"624":1,"628":1,"632":1,"636":1,"638":1,"641":1,"646":1,"650":1,"652":1,"656":1,"658":1,"662":1,"670":1,"674":1},"1":{"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":2,"559":2,"560":1,"561":1,"562":1,"563":1,"564":1,"565":1,"566":1,"567":1,"568":1,"569":1,"570":1,"571":1,"572":1,"573":1,"606":1,"607":1,"609":1,"610":1,"612":1,"613":1,"614":1,"616":1,"617":1,"618":1,"620":1,"621":1,"622":1,"623":1,"625":1,"626":1,"627":1,"629":1,"630":1,"631":1,"633":1,"634":1,"635":1,"637":1,"639":1,"640":1,"642":1,"643":1,"644":1,"645":1,"647":1,"648":1,"649":1,"651":1,"653":1,"654":1,"655":1,"657":1,"659":1,"660":1,"661":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"671":1,"672":1,"673":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1},"2":{"300":1,"328":1,"429":1,"440":1,"444":1,"549":1,"556":1,"557":1,"563":2,"564":2,"567":2,"568":2,"573":2,"588":1,"637":1,"674":1,"759":1}}],["v4",{"0":{"535":1,"540":1,"762":1,"770":1,"779":1,"783":1,"789":1,"794":1,"799":1,"803":1,"809":1,"813":1,"820":1,"826":1,"834":1},"1":{"536":1,"537":1,"538":1,"539":1,"541":1,"542":1,"543":1,"544":1,"545":1,"546":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"780":1,"781":1,"782":1,"784":1,"785":1,"786":1,"787":1,"788":1,"790":1,"791":1,"792":1,"793":1,"795":1,"796":1,"797":1,"798":1,"800":1,"801":1,"802":1,"804":1,"805":1,"806":1,"807":1,"808":1,"810":1,"811":1,"812":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"821":1,"822":1,"823":1,"824":1,"825":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"288":1,"322":1,"367":1,"535":1,"536":2,"537":2,"538":1,"539":1,"540":1,"541":1,"542":1,"543":1,"545":1,"763":1,"771":1,"776":1,"780":1,"784":1,"786":1,"790":1,"795":1,"800":1,"804":1,"810":1,"814":1,"821":1,"827":1,"835":1}}],["vehicles",{"2":{"1362":1}}],["vehicle",{"2":{"1361":1}}],["velocity",{"0":{"1354":1,"1360":2},"1":{"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1},"2":{"1339":1,"1343":1,"1344":1,"1345":1,"1348":2,"1354":1,"1360":3,"1362":1,"1363":2}}],["veterans",{"2":{"1213":1}}],["vendor",{"2":{"1139":1,"1189":1,"1191":1}}],["vendredi",{"2":{"219":1,"222":1,"737":1,"982":1,"1213":1}}],["vessel",{"2":{"1083":1}}],["vessels",{"2":{"1083":1}}],["vector",{"2":{"1011":1}}],["vectors",{"2":{"825":1,"1011":1}}],["vercel",{"2":{"1193":1}}],["vertical",{"2":{"1063":1,"1071":1}}],["vertex",{"2":{"1004":1}}],["vernal",{"2":{"1046":1,"1047":1,"1048":1,"1213":1}}],["verbose",{"0":{"518":1},"2":{"146":1,"469":1,"507":1,"513":2,"518":1,"522":1,"701":1}}],["verbosity",{"2":{"117":1,"282":1,"571":2}}],["very",{"2":{"102":1,"266":1,"427":1,"468":1,"739":1,"1234":1}}],["versatile",{"2":{"932":1}}],["versa",{"2":{"331":1}}],["versus",{"2":{"43":1,"729":1}}],["versioned",{"2":{"228":1,"416":1}}],["versioning",{"0":{"47":1},"2":{"575":1,"585":1}}],["version",{"0":{"560":1,"561":1,"562":1,"566":1,"576":1,"586":1,"604":1,"685":1,"716":1,"761":1},"1":{"563":1,"564":1,"565":1,"567":1,"568":1,"569":1,"577":1,"578":1,"579":1,"580":1,"581":1,"582":1,"583":1,"584":1,"585":1,"587":1,"588":1,"589":1,"590":1,"591":1,"592":1,"593":1,"594":1,"595":1,"596":1,"597":1,"598":1,"599":1,"600":1,"601":1,"602":1,"603":1,"605":1,"606":1,"607":1,"608":1,"609":1,"610":1,"611":1,"612":1,"613":1,"614":1,"615":1,"616":1,"617":1,"618":1,"619":1,"620":1,"621":1,"622":1,"623":1,"624":1,"625":1,"626":1,"627":1,"628":1,"629":1,"630":1,"631":1,"632":1,"633":1,"634":1,"635":1,"636":1,"637":1,"638":1,"639":1,"640":1,"641":1,"642":1,"643":1,"644":1,"645":1,"646":1,"647":1,"648":1,"649":1,"650":1,"651":1,"652":1,"653":1,"654":1,"655":1,"656":1,"657":1,"658":1,"659":1,"660":1,"661":1,"662":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"670":1,"671":1,"672":1,"673":1,"674":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"686":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"693":1,"694":1,"695":1,"696":1,"697":1,"698":1,"699":1,"700":1,"701":1,"702":1,"703":1,"704":1,"705":1,"706":1,"707":1,"708":1,"709":1,"710":1,"711":1,"712":1,"713":1,"714":1,"715":1,"716":1,"717":1,"718":1,"719":1,"720":1,"721":1,"722":1,"723":1,"724":1,"725":1,"726":1,"727":1,"728":1,"729":1,"730":1,"731":1,"732":1,"733":1,"734":1,"735":1,"736":1,"737":1,"738":1,"739":1,"740":1,"741":1,"742":1,"743":1,"744":1,"745":1,"746":1,"747":1,"748":1,"749":1,"750":1,"751":1,"752":1,"753":1,"754":1,"755":1,"756":1,"757":1,"758":1,"759":1,"760":1,"762":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"770":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"779":1,"780":1,"781":1,"782":1,"783":1,"784":1,"785":1,"786":1,"787":1,"788":1,"789":1,"790":1,"791":1,"792":1,"793":1,"794":1,"795":1,"796":1,"797":1,"798":1,"799":1,"800":1,"801":1,"802":1,"803":1,"804":1,"805":1,"806":1,"807":1,"808":1,"809":1,"810":1,"811":1,"812":1,"813":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"820":1,"821":1,"822":1,"823":1,"824":1,"825":1,"826":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"834":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"19":1,"22":1,"43":1,"44":1,"47":3,"135":1,"210":2,"228":2,"251":1,"276":2,"416":1,"418":1,"559":2,"574":6,"584":1,"603":1,"625":1,"716":2,"729":1}}],["versions",{"0":{"19":1},"2":{"19":1,"44":1,"47":1,"272":1,"276":1,"402":1,"558":1,"565":1,"582":1,"618":1,"716":2,"862":1}}],["verifiable",{"2":{"865":1}}],["verification",{"0":{"865":1,"1001":1},"2":{"836":1,"856":1,"865":2,"867":1,"939":1,"987":1}}],["verifies",{"2":{"769":1,"993":1}}],["verified",{"2":{"23":2,"856":1,"1001":1,"1010":1,"1309":1}}],["verifycharterdating",{"2":{"1310":3}}],["verifyusersession",{"2":{"955":1}}],["verifying",{"2":{"769":3,"1426":1}}],["verify",{"2":{"34":1,"293":1,"346":1,"702":1,"955":2,"1011":1,"1309":1,"1310":2,"1364":1,"1376":1}}],["v5",{"2":{"138":2,"152":2,"768":1}}],["vocabularies",{"2":{"1098":1}}],["vocabulary",{"2":{"273":1}}],["voting",{"2":{"940":1}}],["volumes",{"2":{"947":1}}],["volume",{"2":{"122":1,"124":1,"228":1,"699":1,"1026":1,"1082":1}}],["void>",{"2":{"493":1,"1445":1}}],["void",{"0":{"1250":1},"2":{"117":1,"276":1,"389":1,"404":1,"856":1,"919":1,"932":1,"986":1,"1382":1,"1403":2,"1405":3,"1425":5}}],["vacation",{"0":{"1223":1},"2":{"1223":1}}],["vacuum",{"2":{"906":1}}],["vaults",{"0":{"1004":1},"2":{"1004":2}}],["vault",{"2":{"477":2,"933":3,"1004":2}}],["vanilla",{"2":{"468":1}}],["vancouver",{"2":{"218":1}}],["varro",{"2":{"1272":1}}],["varying",{"2":{"1189":1}}],["vary",{"2":{"446":1,"922":1}}],["variety",{"2":{"375":1}}],["various",{"2":{"342":1,"479":1,"723":1,"1168":1}}],["variance",{"2":{"911":1,"1069":1}}],["variants",{"2":{"758":1}}],["variations",{"2":{"138":2,"139":1,"363":1,"1090":1,"1098":1,"1125":1}}],["variables",{"0":{"956":1,"957":1},"1":{"957":1,"958":1},"2":{"266":2,"297":1,"500":1,"622":1,"717":1,"853":1,"855":1,"925":1,"926":1,"957":1}}],["variable",{"0":{"45":1},"2":{"41":1,"97":1,"156":1,"403":1,"722":1,"927":1,"1011":1,"1412":1}}],["vast",{"2":{"196":1}}],["valuable",{"2":{"970":1}}],["valued",{"2":{"477":1}}],["valueof",{"2":{"453":1,"456":1,"468":1}}],["values",{"2":{"117":1,"120":1,"125":1,"138":1,"146":1,"158":1,"183":1,"239":1,"265":1,"294":2,"295":1,"315":1,"317":1,"409":2,"454":1,"456":4,"461":2,"465":3,"468":1,"469":2,"471":1,"476":1,"477":6,"502":1,"571":1,"856":1,"864":1,"932":1,"1003":1,"1329":3,"1404":1}}],["value",{"0":{"523":1,"842":1,"1221":1},"1":{"524":1,"525":1,"526":1,"527":1},"2":{"95":1,"129":1,"145":1,"185":1,"221":1,"240":1,"281":2,"300":1,"301":1,"324":1,"326":1,"327":1,"339":1,"342":1,"351":2,"355":1,"381":1,"409":2,"412":1,"424":1,"425":2,"426":5,"427":1,"461":3,"463":1,"469":1,"487":1,"489":6,"492":2,"500":1,"501":1,"755":1,"792":1,"793":1,"835":1,"836":1,"842":1,"978":3,"1041":1,"1392":1,"1427":1,"1429":5}}],["valves",{"2":{"649":1}}],["val",{"2":{"121":1,"324":5,"338":1,"437":2,"461":2,"482":2,"483":2}}],["validmidnight",{"2":{"1136":2}}],["validdate",{"2":{"973":1}}],["validator",{"2":{"836":1}}],["validating",{"2":{"445":1,"922":1}}],["validation",{"0":{"227":1,"419":1,"767":1,"876":1,"950":1},"2":{"121":1,"199":1,"216":1,"227":2,"228":1,"281":1,"402":1,"416":1,"461":1,"539":1,"602":1,"612":1,"751":1,"767":1,"836":1,"856":1,"860":1,"865":1,"922":1,"950":1,"1010":1,"1012":1,"1109":1,"1276":1}}],["validateusersession",{"2":{"860":1}}],["validatelicensestate",{"2":{"836":1}}],["validate",{"2":{"281":1,"1035":1}}],["validates",{"2":{"146":1,"419":1,"860":1,"1161":1}}],["validated",{"0":{"1013":1},"2":{"109":1,"216":1,"419":1,"653":1,"709":1,"856":1,"860":1,"876":1,"910":1,"1010":1,"1014":1,"1140":2}}],["valid",{"0":{"55":1},"2":{"99":1,"132":1,"154":1,"208":1,"233":1,"326":1,"416":2,"449":1,"767":1,"871":1,"893":1,"934":2,"946":2,"989":1,"1014":1,"1197":1,"1209":1,"1221":2,"1222":1,"1249":1}}],["vs",{"0":{"27":1,"58":1,"96":2,"106":1,"135":1,"193":1,"199":1,"204":1,"210":1,"216":1,"251":1,"269":1,"384":1,"394":1,"467":1,"506":1,"517":1,"518":1,"520":1,"915":1,"1042":1,"1090":1,"1091":1,"1095":3,"1110":1,"1111":3,"1112":1,"1120":1,"1188":1,"1222":1,"1351":1,"1353":1,"1366":1,"1415":1},"1":{"97":2,"107":1,"108":1,"109":1,"136":1,"194":1,"195":1,"211":1,"270":1,"385":1,"386":1,"468":1,"469":1,"507":1,"508":1,"509":1,"510":1,"511":1,"512":1,"513":1,"514":1,"515":1,"916":1,"917":1,"918":1,"1043":1,"1121":1,"1122":1},"2":{"24":1,"27":2,"48":1,"93":1,"102":1,"116":2,"138":1,"146":1,"150":2,"213":1,"216":1,"270":1,"276":1,"405":1,"418":1,"546":1,"654":1,"697":1,"729":1,"921":1,"1024":1,"1075":1,"1088":5,"1098":2,"1105":1,"1166":1,"1188":1,"1316":1,"1352":1}}],["violation",{"2":{"1389":1}}],["violations",{"2":{"1389":1}}],["violating",{"2":{"667":1}}],["vital",{"2":{"1361":1}}],["vitepress",{"2":{"617":1,"627":1,"666":1,"671":1,"709":2,"712":1,"751":1}}],["vite",{"0":{"35":1,"104":1},"1":{"36":1,"37":1,"38":1},"2":{"41":1,"43":1,"102":2,"285":1,"468":1,"726":1,"741":1,"816":1}}],["vitest",{"2":{"6":2,"446":1,"450":1,"618":1,"669":1,"702":1,"726":1,"760":1,"1454":1,"1457":1}}],["vi",{"2":{"1271":1,"1276":1,"1280":1,"1304":1}}],["virginia",{"2":{"1188":2}}],["virtually",{"2":{"755":1}}],["virtual",{"0":{"1419":1},"2":{"321":1,"716":1,"1368":2,"1404":1,"1411":1,"1419":1,"1422":1}}],["video",{"2":{"1084":1,"1331":2,"1332":1}}],["victoire",{"2":{"1213":1}}],["victoria",{"2":{"1213":1}}],["victory",{"2":{"482":1}}],["vic",{"2":{"1213":2,"1214":2,"1220":1}}],["vice",{"2":{"331":1}}],["visits",{"2":{"1190":1}}],["visitortimezone",{"2":{"1193":1}}],["visitorcountry",{"2":{"1190":3,"1193":1}}],["visitor",{"2":{"1189":1,"1190":1}}],["vision",{"0":{"521":1},"1":{"522":1,"523":1,"524":1,"525":1,"526":1,"527":1,"528":1}}],["visibility",{"2":{"409":1}}],["visible",{"2":{"300":1,"1062":1,"1067":3,"1070":1,"1072":2,"1404":1}}],["visual",{"0":{"1060":1},"2":{"83":1,"90":1,"712":1,"743":1,"1060":1,"1063":1,"1064":1}}],["viewer",{"2":{"464":4}}],["views",{"2":{"301":1,"1429":1}}],["view",{"2":{"155":1,"272":1,"410":1,"998":1,"1039":1,"1124":1,"1369":2,"1370":1}}],["via",{"0":{"464":1,"526":1,"1232":1},"1":{"465":1},"2":{"7":1,"8":1,"9":1,"35":1,"39":1,"42":1,"44":1,"73":1,"76":1,"78":1,"83":1,"92":1,"95":1,"99":1,"101":3,"102":1,"105":1,"107":1,"117":2,"125":3,"129":1,"137":2,"142":2,"143":1,"147":1,"157":1,"199":2,"203":2,"205":1,"207":1,"227":1,"243":1,"250":1,"262":1,"288":2,"291":1,"301":1,"322":1,"323":1,"326":1,"335":1,"338":1,"340":1,"345":1,"346":1,"355":1,"357":1,"367":3,"403":3,"408":1,"412":2,"414":1,"419":1,"421":1,"424":1,"431":1,"438":1,"439":1,"445":1,"453":1,"457":1,"458":2,"459":1,"466":1,"471":1,"473":1,"477":1,"491":1,"497":1,"519":1,"538":2,"541":1,"543":1,"552":1,"556":1,"578":1,"592":2,"596":1,"600":1,"606":1,"609":1,"631":1,"639":1,"668":1,"687":1,"701":1,"711":1,"716":1,"731":1,"737":2,"741":1,"754":2,"757":1,"773":1,"775":3,"776":3,"777":1,"782":1,"792":3,"795":1,"807":1,"816":1,"817":1,"829":1,"831":1,"832":1,"833":2,"840":1,"841":1,"848":1,"850":1,"853":1,"854":1,"855":1,"856":2,"864":2,"867":1,"884":1,"885":1,"915":1,"919":1,"926":1,"936":2,"949":1,"958":1,"968":1,"996":1,"998":1,"1001":1,"1003":1,"1008":2,"1040":1,"1041":1,"1046":1,"1093":2,"1098":1,"1106":1,"1125":3,"1147":2,"1150":1,"1169":1,"1172":1,"1173":1,"1181":1,"1193":1,"1205":1,"1207":2,"1232":1,"1262":1,"1263":2,"1267":1,"1276":1,"1278":1,"1352":1,"1368":1,"1370":1,"1373":1,"1388":1,"1394":1,"1401":1,"1411":1,"1412":1,"1418":1,"1442":1,"1451":1,"1452":1,"1459":1}}],["v9+",{"2":{"3":1}}],["cmos",{"2":{"1258":1}}],["cmd",{"2":{"26":1,"91":1}}],["cf",{"2":{"1188":1,"1193":3}}],["cfy",{"2":{"317":2,"326":1}}],["cccc",{"0":{"1095":1},"2":{"1095":1,"1098":1}}],["cyclic",{"0":{"947":1},"2":{"867":1,"934":1,"940":2,"942":1,"947":1}}],["cycle",{"0":{"321":1,"387":1,"1079":1},"2":{"107":1,"195":2,"313":1,"321":1,"324":1,"381":1,"445":1,"654":1,"771":2,"775":2,"1035":1,"1036":1,"1050":1,"1055":1,"1078":1,"1079":1,"1085":1,"1415":1,"1443":1}}],["cycles",{"0":{"1059":1,"1066":1},"1":{"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1},"2":{"12":1,"77":1,"185":1,"264":1,"364":1,"377":1,"378":1,"526":2,"531":1,"660":1,"771":1,"776":1,"947":1,"1052":2,"1053":1,"1058":1,"1080":1,"1097":1,"1106":1,"1258":1}}],["cyrillic",{"2":{"802":1}}],["csharp",{"2":{"1103":1}}],["csv",{"0":{"1034":1},"1":{"1035":1,"1036":1},"2":{"1024":1,"1035":1}}],["css",{"2":{"709":1}}],["cst",{"2":{"296":1}}],["cjs",{"2":{"538":1,"836":1}}],["cb",{"2":{"473":1,"1405":1}}],["c++",{"2":{"450":1,"505":1}}],["ctx",{"2":{"324":2}}],["ctrl",{"2":{"26":1,"91":1}}],["cn",{"2":{"305":1,"637":1}}],["cpus",{"2":{"1022":1}}],["cpu",{"2":{"264":1,"377":1,"1030":1,"1106":1,"1369":1,"1370":1}}],["c",{"0":{"382":1,"1129":1,"1130":1,"1136":1,"1180":1,"1282":1},"2":{"138":1,"240":1,"292":1,"642":1,"1088":1,"1099":1,"1103":4,"1104":1,"1123":3,"1125":4,"1263":1,"1273":1,"1280":1,"1292":1,"1304":1,"1312":1,"1313":4}}],["ceases",{"2":{"1439":1}}],["ce⟹2779",{"2":{"1272":1}}],["ce⟹754",{"2":{"1272":1}}],["cell",{"2":{"1233":1}}],["celestial",{"0":{"775":1,"1050":1,"1353":1},"1":{"1051":1,"1052":1,"1053":1,"1054":1,"1055":1,"1056":1,"1057":1},"2":{"9":1,"44":2,"45":2,"84":1,"87":2,"102":1,"289":1,"290":1,"334":1,"771":2,"775":2,"846":4,"849":1,"850":2,"937":1,"938":1,"1044":1,"1045":1,"1046":1,"1049":2,"1051":1,"1052":1,"1054":1,"1055":1,"1056":1,"1058":1,"1059":1,"1066":1,"1067":1,"1068":1,"1074":1,"1075":1,"1076":1,"1080":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1353":1}}],["celestialplugin",{"2":{"9":2,"102":2,"289":2,"290":2,"334":2,"541":1,"542":1,"543":1,"708":1,"816":1,"849":2,"1046":2,"1054":1,"1055":2,"1059":2,"1067":2,"1076":2,"1081":2,"1082":2,"1083":2,"1084":2,"1085":2}}],["certainty",{"2":{"875":1}}],["certain",{"2":{"374":1,"560":1,"872":1,"882":1}}],["ceremony",{"2":{"149":1,"233":1,"818":1}}],["ceiling",{"2":{"1316":1}}],["ceil",{"2":{"324":1,"519":1,"1039":1,"1325":1}}],["cest",{"2":{"296":1,"1366":1}}],["cette",{"2":{"222":1,"737":1}}],["cet",{"2":{"213":1,"296":1,"689":1,"1125":1}}],["cen",{"2":{"137":1,"138":1}}],["cents",{"2":{"972":1}}],["centric",{"0":{"510":1,"525":1},"2":{"507":1,"510":1,"515":1}}],["centralizing",{"2":{"625":1}}],["centralizes",{"2":{"728":1}}],["centralize",{"2":{"102":1}}],["centralized",{"0":{"93":1,"417":1,"694":1},"1":{"94":1,"418":1,"419":1},"2":{"92":1,"402":1,"403":1,"439":1,"556":1,"647":1,"741":1,"754":1,"995":1,"1178":1}}],["centralised",{"2":{"580":1}}],["central",{"2":{"102":1,"104":1,"356":1,"829":1,"1364":1,"1366":1}}],["centrally",{"2":{"93":1}}],["century",{"2":{"137":2,"138":3}}],["center",{"2":{"63":1,"1067":1}}],["ce",{"0":{"1294":1},"2":{"137":1,"150":1,"202":2,"222":1,"707":1,"737":1,"1273":2,"1276":2,"1278":1,"1281":1,"1291":1,"1295":1,"1306":1,"1313":1}}],["chunked",{"2":{"1040":1}}],["chunk",{"2":{"1040":1}}],["chunks",{"2":{"1040":1}}],["chunksize",{"2":{"1039":1}}],["chunking",{"2":{"1033":1}}],["churn",{"2":{"119":1}}],["cheat",{"0":{"1259":1},"1":{"1260":1,"1261":1}}],["cheap",{"2":{"407":1}}],["cheshire",{"2":{"1063":1}}],["checkers",{"2":{"1367":1}}],["checked",{"2":{"99":1,"216":1,"539":1}}],["checkportkeelclearance",{"2":{"1083":2}}],["checkpoints",{"2":{"190":1}}],["checkuserratelimit",{"2":{"860":1}}],["checking",{"0":{"339":1},"2":{"128":1,"215":1,"268":1,"326":1,"338":1,"367":1,"649":1,"1343":1}}],["checks",{"2":{"71":1,"110":1,"174":1,"176":1,"177":1,"178":1,"276":1,"282":1,"539":1,"612":1,"653":1,"845":1,"942":1,"969":1,"1011":1,"1333":1,"1336":1,"1344":2,"1345":2,"1361":1}}],["check",{"0":{"55":1},"2":{"34":1,"93":1,"228":1,"236":1,"266":1,"359":1,"360":1,"362":1,"559":1,"653":1,"757":1,"769":3,"851":1,"993":1,"1192":1,"1335":2,"1363":3,"1364":1,"1436":1}}],["children",{"2":{"1213":1}}],["child",{"2":{"465":3,"829":1,"1041":1}}],["chinese",{"2":{"305":1,"561":3,"637":3,"802":1}}],["chicago",{"2":{"119":2,"296":1}}],["chose",{"2":{"1086":3,"1092":1}}],["chosen",{"2":{"452":1,"941":1}}],["chores",{"0":{"582":1,"603":1,"661":1}}],["choose",{"0":{"515":1,"1167":1,"1278":1},"2":{"270":2,"274":1,"320":1,"326":1,"515":5,"952":1}}],["choosing",{"2":{"96":1,"506":1}}],["choice",{"2":{"269":1,"276":1,"467":1,"846":1,"1008":1,"1103":1}}],["christi",{"2":{"1213":1}}],["christmas",{"2":{"157":3,"158":6,"510":1,"525":1,"885":1,"912":3,"975":1,"1213":6,"1223":2,"1224":1,"1421":1}}],["chronology",{"0":{"1273":1,"1311":1},"1":{"1312":1,"1313":1}}],["chronological",{"2":{"194":1,"314":1,"386":1,"654":2,"911":1}}],["chronologically",{"2":{"82":1}}],["chrono",{"2":{"510":1}}],["chrome",{"2":{"34":1}}],["channel",{"2":{"1375":1}}],["changing",{"2":{"191":1,"1118":1}}],["changed",{"0":{"597":1}}],["changelog",{"2":{"8":1}}],["change",{"2":{"7":1,"43":1,"76":1,"119":1,"181":1,"298":1,"449":1,"481":1,"560":1,"567":1,"625":1,"1095":1,"1447":1}}],["changes",{"0":{"757":1,"836":1},"2":{"7":1,"8":1,"120":1,"191":1,"331":1,"379":1,"549":1,"551":1,"575":1,"637":2,"816":1,"1088":1,"1147":1}}],["chaps",{"2":{"1221":1}}],["challenge",{"0":{"1109":1,"1157":1,"1303":1,"1306":1,"1309":1,"1312":1},"1":{"1110":1,"1111":1,"1112":1}}],["challenges",{"0":{"57":1},"1":{"58":1,"59":1,"60":1},"2":{"49":1,"50":1,"1137":1,"1189":1,"1443":1}}],["chaque",{"2":{"982":1}}],["charter",{"2":{"1310":1}}],["charters",{"0":{"1308":1},"1":{"1309":1,"1310":1},"2":{"1309":1}}],["chargeabledays++",{"2":{"1223":1}}],["chargeabledays",{"2":{"1223":2}}],["chargeableleavedays",{"2":{"1223":3}}],["charges",{"2":{"1223":1}}],["charging",{"2":{"1081":2}}],["chars",{"2":{"1011":1}}],["characteristics",{"2":{"786":1,"1042":1}}],["character",{"0":{"1135":1},"2":{"240":1,"802":1,"997":1,"1098":1,"1131":1}}],["characters",{"2":{"138":1,"243":3,"359":2,"377":1,"388":1,"503":1,"997":1,"1091":1,"1128":1,"1129":1,"1130":1,"1131":1}}],["char",{"2":{"78":1,"1086":1,"1099":1,"1103":1,"1115":2,"1116":1,"1123":1,"1149":1,"1150":1}}],["chainable",{"2":{"351":1,"1090":1,"1098":1}}],["chainability",{"0":{"192":1},"2":{"181":1}}],["chains",{"2":{"199":1}}],["chain",{"2":{"138":1,"145":1,"161":2,"192":1,"351":1,"411":1,"418":1,"465":1,"482":1,"562":1,"664":1,"701":1,"825":1,"833":1,"878":1}}],["chained",{"2":{"76":1,"83":1,"84":1,"138":2,"158":1,"283":1,"704":1,"754":1}}],["chaining",{"2":{"64":1,"138":1,"161":1,"181":1,"191":1,"367":2,"515":1,"516":1,"682":1,"707":1}}],["chatbots",{"2":{"867":1,"946":1,"1013":1}}],["chat",{"2":{"26":1,"27":2,"28":1,"204":1,"854":2,"859":1,"860":1,"888":1,"932":1,"955":1,"958":1,"959":1}}],["chatgpt",{"0":{"29":1},"2":{"24":1,"48":1,"247":2,"692":1}}],["cumulative",{"2":{"1443":1,"1444":1}}],["cumulatively",{"2":{"138":2}}],["cue",{"2":{"1331":1,"1332":2}}],["cues",{"2":{"1331":1}}],["culture",{"2":{"1158":1,"1171":1,"1213":1}}],["cultural",{"0":{"367":1,"370":1,"909":1,"1156":1,"1158":1,"1160":1,"1190":1,"1205":1},"1":{"1157":1,"1158":1,"1159":2,"1160":1,"1161":1},"2":{"154":1,"326":1,"366":2,"367":1,"368":1,"522":1,"750":1,"951":1,"1156":1,"1157":1,"1158":1,"1162":1,"1166":2,"1167":1,"1168":1,"1169":1,"1171":1,"1189":2,"1195":1,"1207":2}}],["culturally",{"0":{"817":1},"2":{"146":1,"364":1,"817":1,"906":1}}],["culminations",{"2":{"1075":1,"1079":1}}],["culmination",{"2":{"1061":1}}],["cup",{"2":{"951":1,"955":1,"1213":1,"1214":1}}],["cutting",{"2":{"483":1}}],["cutoff",{"2":{"117":1,"1012":1}}],["customholidays",{"2":{"1195":1,"1224":2}}],["customerorganization",{"2":{"1220":2}}],["customer",{"0":{"1016":1},"2":{"878":1,"1016":1,"1017":1,"1190":1,"1219":2,"1220":9}}],["customconfig>",{"2":{"793":1}}],["customdate",{"2":{"545":2}}],["customplugin",{"2":{"335":2}}],["customize",{"2":{"294":1,"637":1,"771":1,"1176":1}}],["customization",{"2":{"278":1,"610":1,"659":1}}],["customizing",{"0":{"218":1,"243":1},"1":{"244":1}}],["custom",{"0":{"30":1,"123":1,"143":1,"147":1,"214":1,"223":1,"230":1,"261":1,"275":1,"317":1,"462":1,"463":1,"531":1,"851":1,"854":1,"908":1,"932":1,"1191":1,"1204":1},"1":{"31":1,"32":1,"231":1,"232":1,"233":1,"234":1,"235":1,"236":1,"463":1,"464":1,"465":1},"2":{"27":1,"30":1,"31":1,"32":2,"76":2,"85":1,"88":1,"95":1,"96":1,"97":1,"102":1,"115":2,"117":1,"122":1,"123":2,"141":1,"142":2,"145":1,"147":4,"159":1,"174":1,"185":1,"193":1,"203":1,"205":1,"214":2,"218":1,"221":2,"228":1,"230":1,"235":1,"243":2,"246":1,"247":2,"248":1,"254":1,"275":1,"276":1,"282":1,"287":1,"293":1,"294":1,"295":2,"297":2,"313":1,"315":1,"316":1,"317":4,"323":1,"324":2,"326":2,"329":1,"331":1,"332":1,"333":1,"335":1,"341":1,"363":1,"364":1,"388":1,"402":1,"415":1,"416":1,"452":1,"470":1,"471":1,"475":1,"478":1,"498":1,"509":1,"518":2,"525":2,"531":1,"533":1,"534":1,"537":1,"544":2,"631":1,"639":1,"661":1,"666":1,"684":1,"704":3,"705":1,"728":1,"731":1,"746":1,"763":1,"771":2,"773":2,"774":2,"776":2,"841":1,"845":1,"851":2,"854":1,"856":1,"863":1,"866":1,"871":1,"881":1,"890":1,"899":1,"921":1,"930":1,"932":2,"937":1,"938":1,"958":3,"970":1,"978":2,"980":1,"998":3,"1008":1,"1041":1,"1078":1,"1097":1,"1103":1,"1104":2,"1158":1,"1159":3,"1166":1,"1168":3,"1172":1,"1175":1,"1176":1,"1182":2,"1191":1,"1203":1,"1204":1,"1224":1,"1263":1,"1361":1,"1378":2}}],["curvature",{"2":{"1365":1}}],["currency",{"2":{"787":1,"1221":1}}],["currenttick",{"2":{"1448":2}}],["currenttime",{"2":{"1081":2}}],["currentms",{"2":{"1389":2,"1392":4}}],["currentmonth",{"2":{"265":2,"266":2}}],["currentnano",{"2":{"1389":2}}],["currentlogin",{"2":{"1363":4}}],["currently",{"2":{"19":1,"34":1,"75":2,"155":1,"167":1,"221":1,"321":1,"331":1,"346":1,"354":1,"383":1,"385":1,"642":1,"942":1,"1062":1,"1406":1,"1426":1}}],["currentrequestcontext",{"2":{"933":2}}],["currentday",{"2":{"265":2,"266":2}}],["current",{"0":{"52":1,"221":1},"2":{"34":1,"52":1,"64":1,"69":1,"90":1,"91":1,"97":1,"123":1,"138":1,"143":1,"150":3,"158":3,"185":2,"190":2,"191":1,"203":4,"215":1,"224":3,"265":1,"297":1,"304":1,"313":2,"319":1,"324":3,"326":1,"327":1,"331":1,"344":1,"348":1,"351":1,"352":1,"381":1,"382":4,"383":4,"385":1,"387":1,"389":1,"390":1,"393":1,"395":1,"442":1,"519":1,"560":1,"565":1,"574":1,"699":1,"708":1,"716":1,"776":1,"874":1,"888":1,"890":1,"899":1,"911":1,"989":1,"1013":1,"1069":1,"1079":1,"1168":2,"1184":1,"1223":8,"1227":1,"1235":1,"1247":1,"1251":1,"1326":1,"1369":1,"1377":1,"1382":1,"1388":1,"1404":1,"1413":1,"1415":1,"1418":1,"1427":1}}],["curated",{"2":{"692":1,"1273":1}}],["curly",{"2":{"137":1,"1091":1,"1132":1}}],["cursor",{"0":{"26":1},"2":{"24":1,"26":3,"48":1,"247":2,"383":3,"692":1,"978":4,"983":1,"986":1}}],["caesare",{"2":{"1273":1,"1280":1,"1281":2,"1312":1,"1313":2}}],["caesar",{"2":{"1273":1,"1278":1,"1307":1}}],["cadence",{"0":{"1254":1}}],["caution",{"2":{"857":1,"950":1}}],["causes",{"2":{"1028":1,"1064":1,"1094":1,"1218":1}}],["caused",{"2":{"709":1,"1110":1}}],["cause",{"2":{"468":1,"1041":1,"1086":1,"1185":1,"1233":1,"1234":1,"1331":1,"1371":1}}],["causing",{"2":{"157":1,"702":1,"709":1}}],["cargo",{"2":{"1083":1}}],["cardinal",{"2":{"471":1}}],["carries",{"2":{"269":1}}],["careful",{"2":{"191":1,"329":1}}],["carefully",{"2":{"146":1}}],["ca=iso8601",{"2":{"240":1}}],["capping",{"2":{"1421":1}}],["capped",{"2":{"511":1}}],["capodanno",{"2":{"1216":5}}],["cap",{"2":{"829":1}}],["capitalization",{"0":{"1088":1},"2":{"1086":1,"1088":1,"1111":1}}],["capitalized",{"2":{"326":1,"1090":1}}],["capinit",{"2":{"326":1}}],["captures",{"2":{"1392":1}}],["captured",{"2":{"442":1,"1011":1}}],["capture",{"0":{"245":1},"2":{"237":1,"245":1,"752":1,"897":1,"1008":1,"1011":3}}],["capturing",{"2":{"205":1}}],["capability",{"2":{"464":1,"490":1}}],["capabilities",{"0":{"86":1,"788":1},"1":{"87":1,"88":1,"89":1,"90":1,"91":1},"2":{"102":1,"462":1,"516":1,"648":1,"704":1,"747":1,"916":1,"1052":1,"1103":1,"1166":1,"1343":1,"1401":1}}],["capable",{"2":{"363":1,"527":1,"750":1,"909":1,"1411":1}}],["capacity",{"2":{"94":1,"95":1,"694":1,"1009":1}}],["cat",{"2":{"1063":1}}],["catastrophe",{"2":{"1088":1}}],["catastrophic",{"2":{"416":1,"647":1,"1011":1,"1086":1,"1110":1}}],["catalognumber",{"2":{"1304":2}}],["catalogs",{"2":{"1303":1}}],["cataloging",{"2":{"1299":1}}],["catalog",{"0":{"919":1,"1021":1,"1104":1,"1318":1,"1382":1},"1":{"920":1,"1022":1,"1023":1,"1319":1},"2":{"163":1,"229":2,"851":1,"1273":2,"1276":2,"1278":1,"1314":1}}],["categories",{"2":{"890":2}}],["categorical",{"2":{"418":1}}],["categorization",{"2":{"315":1}}],["category",{"2":{"372":1,"681":1,"746":1,"891":1,"920":1,"1168":1,"1344":1,"1457":1}}],["catches",{"2":{"146":1,"412":1}}],["catch",{"0":{"358":1,"1448":1},"2":{"117":2,"281":4,"282":3,"358":2,"360":1,"389":1,"404":2,"427":1,"482":2,"484":1,"860":1,"955":1,"970":1,"1011":1,"1136":1,"1139":1,"1401":1,"1405":1,"1424":2,"1425":1,"1444":3,"1448":4}}],["ca",{"2":{"146":1,"218":2,"899":1,"1213":2,"1214":2,"1220":1}}],["cairo",{"2":{"146":2,"1157":1,"1158":2,"1171":1}}],["caching",{"0":{"866":1,"895":1,"904":1,"978":1,"1006":1,"1009":1,"1182":1,"1183":1,"1192":1,"1215":1},"1":{"1007":1,"1008":1,"1009":1,"1184":1,"1185":1,"1186":1,"1187":1,"1188":1,"1216":1,"1217":1},"2":{"93":4,"504":1,"701":1,"863":1,"871":1,"881":1,"890":1,"895":1,"899":1,"904":1,"921":1,"924":1,"975":1,"994":1,"1162":1,"1166":3,"1178":1,"1183":1,"1189":2,"1207":1}}],["cacheadapter",{"2":{"871":1,"881":1,"890":1,"895":1,"899":1,"904":1,"937":1,"938":1,"959":1,"978":1}}],["cached",{"2":{"95":1,"99":1,"300":2,"327":2,"372":1,"695":1,"787":1,"798":1,"871":1,"881":1,"890":1,"895":1,"899":1,"912":1,"965":1,"976":1,"978":1,"1009":1,"1106":2,"1120":2,"1168":1,"1171":1,"1184":2,"1192":3}}],["caches",{"2":{"44":1,"295":1,"414":1,"866":1,"921":1,"1184":2,"1187":1,"1369":1}}],["cache",{"0":{"92":1,"93":1,"94":1,"98":1,"691":1,"694":2,"797":2,"863":1,"966":1,"971":1,"975":1,"980":1,"1184":1},"1":{"93":1,"94":2,"95":1,"96":1,"97":1,"98":1,"99":2,"967":1,"968":1,"969":1,"970":1,"971":1,"972":2,"973":2,"974":2,"975":2,"976":2,"977":2,"978":2,"979":2,"980":2},"2":{"44":1,"92":1,"93":5,"94":3,"95":8,"96":1,"97":1,"98":3,"99":3,"121":1,"227":1,"371":1,"373":1,"416":2,"476":1,"503":1,"672":1,"687":1,"691":3,"694":1,"695":2,"697":3,"714":1,"776":1,"795":2,"797":3,"798":1,"857":1,"863":4,"866":3,"871":5,"872":1,"881":4,"882":1,"890":4,"891":1,"895":1,"899":4,"900":1,"904":2,"913":1,"921":1,"937":4,"938":3,"959":2,"962":1,"968":2,"971":1,"972":5,"974":3,"975":5,"976":1,"977":1,"978":1,"979":1,"1005":1,"1008":5,"1009":5,"1011":2,"1120":1,"1144":1,"1168":1,"1182":2,"1184":1,"1192":1,"1448":1}}],["casual",{"2":{"899":1,"904":1,"973":1}}],["cascades",{"2":{"855":1,"945":1}}],["cascade",{"0":{"945":1},"2":{"606":1,"867":1,"942":1,"1207":1,"1214":1}}],["cascading",{"0":{"105":1,"829":1,"979":1},"2":{"102":1,"107":1,"145":1,"477":1,"535":1,"540":1,"541":1,"606":1,"827":1,"829":1}}],["casting",{"0":{"793":1},"2":{"649":1,"790":1,"793":1}}],["casts",{"2":{"489":1}}],["cast",{"0":{"793":1},"2":{"489":3,"505":1,"790":1,"792":2,"793":2}}],["cases",{"0":{"1012":1,"1026":1,"1080":1,"1137":1,"1189":1,"1218":1,"1258":1,"1301":1,"1322":1,"1362":1,"1385":1,"1443":1},"1":{"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":1,"1033":1,"1034":1,"1035":1,"1036":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":1,"1144":1,"1145":1,"1146":1,"1147":1,"1148":1,"1149":1,"1150":1,"1190":1,"1191":1,"1192":1,"1193":1,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1259":1,"1260":1,"1261":1,"1262":1,"1263":1,"1264":1,"1265":1,"1266":1,"1267":1,"1302":1,"1303":1,"1304":1,"1305":1,"1306":1,"1307":1,"1308":1,"1309":1,"1310":1,"1311":1,"1312":1,"1313":1,"1314":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1363":1,"1364":1,"1365":1,"1366":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"146":1,"250":1,"422":1,"921":1,"922":1,"954":1,"1008":1,"1024":1,"1052":1,"1094":1,"1105":1,"1166":1,"1210":1,"1242":2,"1274":1,"1299":1,"1320":1,"1343":1,"1353":1,"1383":1,"1401":1,"1454":1}}],["case",{"2":{"76":1,"137":1,"188":1,"189":1,"205":1,"239":1,"326":1,"399":1,"456":1,"726":1,"867":1,"868":1,"1095":2,"1098":1,"1270":1}}],["casing",{"2":{"76":1,"326":2,"754":1,"1090":1}}],["californiabbox",{"2":{"1337":4}}],["calibrate",{"2":{"1239":2,"1422":1}}],["calibratedepoch",{"2":{"1266":2}}],["calibrated",{"0":{"1261":1},"2":{"1028":1,"1235":1,"1239":1,"1241":1,"1243":1,"1245":1,"1264":1,"1266":1,"1267":1}}],["calibration",{"0":{"1078":1,"1262":1},"1":{"1263":1,"1264":1},"2":{"1074":1,"1078":1,"1233":1,"1234":1,"1242":1,"1250":1,"1261":1}}],["calare",{"2":{"1269":1}}],["calc",{"2":{"1103":1,"1123":1,"1134":1}}],["calculators",{"2":{"845":1,"909":1}}],["calculatemidpoint",{"0":{"1359":1}}],["calculatebearing",{"0":{"1358":1}}],["calculateleavededuction",{"2":{"1223":2}}],["calculatetradesettlement",{"2":{"1221":2}}],["calculate",{"2":{"233":1,"326":1,"519":2,"520":1,"885":1,"989":1,"1015":1,"1054":1,"1084":1,"1209":1,"1325":1,"1365":1,"1366":1}}],["calculates",{"2":{"158":1,"159":1,"319":1,"387":1,"519":2,"773":1,"893":1,"979":1,"1045":1,"1053":2,"1078":1,"1085":1,"1201":1,"1203":1,"1207":1,"1223":1,"1257":1,"1267":1,"1345":2,"1355":1,"1359":1,"1363":1,"1366":1}}],["calculatedspeedkmh",{"2":{"1363":3}}],["calculated",{"2":{"96":1,"97":1,"352":1,"354":1,"399":1,"992":2,"1270":1}}],["calculating",{"0":{"157":1},"1":{"158":1,"159":1},"2":{"156":1,"157":1,"313":1,"520":1,"774":1,"775":1,"1284":1}}],["calculation",{"0":{"1202":1},"1":{"1203":1,"1204":1},"2":{"118":1,"322":1,"323":1,"399":1,"407":1,"679":1,"771":1,"881":1,"950":1,"1207":2,"1235":2,"1261":1,"1287":1}}],["calculations",{"0":{"61":1,"1075":1,"1272":1},"1":{"62":1,"63":1,"64":1,"65":1,"66":1},"2":{"50":1,"124":1,"129":1,"137":1,"157":1,"164":1,"186":1,"334":1,"516":1,"532":1,"673":1,"775":1,"845":1,"879":1,"899":1,"962":1,"1010":2,"1037":1,"1044":1,"1045":1,"1052":1,"1053":1,"1054":1,"1080":1,"1093":1,"1206":1,"1210":1,"1225":1,"1242":1,"1301":1,"1339":1,"1343":1,"1350":1,"1354":1}}],["calendly",{"2":{"1015":1,"1324":1}}],["calendrical",{"2":{"138":1}}],["calendars",{"0":{"817":1,"1212":1,"1213":1},"1":{"1213":1,"1214":1,"1215":1,"1216":1,"1217":1},"2":{"248":1,"326":1,"366":1,"527":1,"771":1,"951":1,"1097":1,"1207":2,"1210":1,"1212":1,"1215":1}}],["calendar",{"0":{"162":1,"365":1,"366":1,"368":1,"888":1,"1015":1,"1224":1,"1323":1,"1414":1},"1":{"367":1,"368":1,"369":1,"370":1,"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1,"1324":1,"1325":1,"1326":1,"1415":1},"2":{"69":1,"117":2,"119":1,"120":1,"137":4,"138":1,"146":2,"150":2,"154":1,"161":2,"162":1,"163":2,"173":1,"187":1,"202":2,"205":1,"229":1,"233":1,"240":1,"242":1,"303":1,"361":1,"365":1,"366":1,"367":1,"371":1,"458":1,"479":1,"519":1,"522":3,"526":1,"536":1,"606":1,"617":1,"620":1,"621":1,"660":1,"667":1,"763":1,"802":1,"814":1,"838":1,"855":1,"866":1,"869":2,"870":1,"872":2,"880":1,"882":2,"884":1,"888":2,"890":2,"893":1,"897":1,"902":1,"905":1,"907":2,"909":2,"910":1,"911":1,"919":2,"921":1,"933":1,"937":2,"938":2,"972":1,"987":1,"989":1,"994":1,"1009":1,"1010":1,"1012":1,"1014":3,"1088":3,"1093":1,"1110":3,"1125":3,"1156":1,"1157":1,"1158":2,"1167":1,"1222":1,"1223":1,"1224":1,"1268":1,"1269":1,"1271":1,"1275":1,"1276":2,"1278":2,"1284":1,"1288":2,"1290":1,"1298":1,"1301":1,"1303":1,"1304":2,"1309":2,"1312":1,"1315":1,"1319":1,"1320":1,"1322":1,"1324":1,"1326":1,"1396":1,"1401":1,"1403":1,"1404":1,"1411":1,"1412":1,"1413":1,"1415":1,"1443":1}}],["cal",{"2":{"137":1,"138":1,"154":1,"224":1,"907":1,"1015":1}}],["callbacks",{"0":{"483":1},"2":{"475":2,"476":1,"1446":1}}],["callback",{"0":{"334":1,"1403":1},"2":{"331":1,"332":2,"334":4,"489":1,"543":1,"600":1,"602":1,"637":1,"831":2,"833":1,"856":1,"1395":1,"1403":2,"1417":1,"1425":1,"1433":1}}],["caller",{"2":{"330":1,"868":1,"910":1,"955":4,"972":1,"1008":1,"1009":1,"1158":1,"1159":1}}],["called",{"2":{"228":1,"294":1,"301":1,"326":1,"435":1,"471":1,"474":1,"483":2,"491":1,"543":1,"855":1,"1395":1,"1425":1}}],["callable",{"0":{"816":1},"2":{"265":1,"268":1,"285":1,"816":1,"932":1}}],["calls",{"2":{"98":1,"102":1,"108":1,"120":1,"166":1,"262":1,"266":1,"272":1,"321":1,"325":1,"606":1,"699":1,"931":1,"948":1,"955":1,"971":1,"980":1,"984":1,"1118":1,"1147":1,"1184":1,"1191":1,"1216":1,"1240":1,"1263":1,"1372":1,"1387":1,"1391":1,"1417":1}}],["calling",{"2":{"89":1,"161":1,"226":1,"364":1,"422":1,"425":1,"465":1,"481":1,"853":1,"856":1,"864":1,"870":1,"925":1,"932":1,"983":1,"1003":1,"1158":1,"1188":2,"1192":1,"1235":1}}],["call",{"0":{"1159":1,"1180":1},"2":{"6":1,"46":1,"98":1,"101":1,"109":1,"116":1,"135":1,"149":1,"160":1,"161":1,"199":1,"204":1,"210":1,"233":1,"235":1,"250":1,"288":1,"289":2,"290":1,"292":1,"371":1,"387":1,"406":1,"426":1,"428":1,"482":1,"738":2,"776":1,"807":1,"816":1,"853":1,"918":1,"925":1,"926":1,"932":1,"935":2,"948":1,"978":1,"979":1,"997":2,"998":1,"1116":1,"1117":1,"1146":2,"1147":1,"1166":1,"1180":1,"1184":1,"1262":1,"1264":2,"1269":1,"1357":1,"1363":1,"1374":1,"1435":1,"1442":1}}],["canvas",{"2":{"1063":1}}],["canada",{"2":{"218":1,"365":1,"1207":1,"1213":2}}],["cancellations",{"2":{"1387":1}}],["cancelled",{"2":{"949":1}}],["cancel",{"2":{"158":1}}],["canonicalmask",{"2":{"1150":3}}],["canonicalization",{"0":{"868":1}}],["canonical",{"0":{"459":1,"768":1},"2":{"121":1,"138":2,"145":2,"152":5,"763":2,"1103":1,"1115":2,"1150":2,"1167":1,"1168":1}}],["candidates",{"2":{"208":1,"1119":1}}],["candidate",{"2":{"78":1,"205":1,"313":1,"477":1,"769":3,"806":2,"942":1,"950":1,"1099":1,"1104":4,"1105":1,"1119":1,"1140":3,"1141":3}}],["cannot",{"2":{"43":1,"107":1,"127":1,"281":1,"326":1,"359":1,"425":1,"431":1,"439":1,"468":1,"469":1,"475":1,"505":1,"506":1,"514":2,"897":1,"906":1,"1003":1,"1090":1,"1091":1,"1115":1,"1221":1,"1367":1,"1376":1,"1378":1}}],["caniuse",{"2":{"34":1}}],["can",{"2":{"15":1,"28":1,"34":2,"39":1,"43":3,"46":1,"56":1,"59":1,"62":1,"63":1,"64":1,"76":1,"87":1,"94":1,"95":1,"100":1,"102":2,"105":1,"107":1,"111":1,"118":1,"121":1,"122":1,"123":1,"124":2,"126":1,"128":1,"131":1,"132":1,"134":1,"138":4,"140":1,"142":1,"143":1,"146":1,"147":2,"158":1,"161":1,"163":2,"164":1,"165":1,"166":1,"168":1,"169":1,"170":1,"183":1,"185":1,"191":3,"192":1,"196":1,"197":1,"198":1,"201":1,"203":1,"205":1,"206":1,"207":1,"214":1,"217":1,"218":1,"219":2,"221":1,"223":1,"226":1,"229":2,"233":1,"235":1,"236":1,"237":1,"238":1,"243":1,"246":1,"261":1,"263":1,"266":3,"268":1,"270":2,"271":1,"285":2,"288":1,"293":2,"294":1,"295":1,"296":1,"298":1,"315":1,"317":2,"321":1,"322":1,"326":2,"335":1,"339":1,"342":1,"343":1,"349":1,"357":1,"358":1,"360":1,"363":1,"364":1,"369":1,"371":1,"388":1,"392":1,"393":1,"395":1,"396":1,"397":1,"398":1,"402":1,"407":1,"414":1,"418":1,"426":1,"427":1,"435":1,"439":2,"451":1,"456":1,"458":1,"462":1,"465":2,"466":1,"468":2,"469":1,"477":1,"479":1,"482":1,"483":1,"484":1,"485":1,"486":1,"491":1,"503":1,"504":1,"505":1,"522":1,"532":1,"552":1,"558":1,"678":1,"687":1,"695":1,"704":1,"720":1,"734":1,"737":1,"752":1,"754":1,"771":1,"777":1,"780":1,"782":1,"812":1,"823":1,"853":1,"854":1,"856":2,"857":1,"867":1,"875":1,"877":1,"878":1,"885":1,"887":1,"908":1,"922":1,"927":1,"931":1,"932":1,"939":1,"946":1,"967":1,"974":1,"976":1,"978":1,"993":1,"1004":1,"1009":1,"1010":1,"1011":1,"1013":1,"1017":1,"1041":1,"1048":1,"1049":1,"1084":1,"1090":1,"1114":1,"1116":1,"1118":1,"1150":1,"1178":1,"1179":1,"1180":1,"1181":1,"1193":1,"1233":1,"1235":1,"1240":1,"1262":1,"1267":1,"1371":1,"1395":1,"1412":1,"1414":1,"1422":1,"1436":1,"1446":1,"1454":1,"1459":1}}],["clusters",{"2":{"1383":1}}],["cluster",{"0":{"1386":1},"1":{"1387":1,"1388":1,"1389":1},"2":{"978":1}}],["clunky",{"2":{"522":1}}],["clutter",{"2":{"263":1}}],["cldr",{"2":{"365":3,"367":1,"371":1,"373":1,"1103":2,"1123":1}}],["cloudwatch",{"2":{"995":1,"1143":1}}],["cloud",{"2":{"955":2,"1004":2,"1017":2,"1067":1,"1143":1,"1189":1}}],["cloudflare",{"0":{"860":1},"2":{"858":1,"860":2,"866":1,"890":1,"895":1,"899":1,"904":1,"978":1,"1005":1,"1193":1}}],["clobbering",{"2":{"744":1}}],["cloning",{"0":{"1040":1},"2":{"470":1,"504":1,"667":1,"1024":1,"1038":2,"1039":1,"1368":1}}],["clones",{"2":{"660":1,"667":1}}],["cloneify",{"0":{"472":1,"498":1,"502":1},"1":{"499":1,"500":1,"501":1,"502":1,"503":1,"504":1,"505":1},"2":{"472":1,"502":3,"503":1,"504":1}}],["cloned",{"2":{"279":1,"502":1,"738":1}}],["clone",{"2":{"4":1,"233":2,"300":1,"331":1,"503":1}}],["clockoptions",{"2":{"1382":1}}],["clockdriftstate",{"0":{"1246":1,"1248":1},"2":{"1248":1}}],["clock=",{"2":{"1232":1,"1240":1}}],["clock=1727856900123",{"2":{"1232":1}}],["clocks",{"0":{"1253":1,"1419":1,"1423":1},"1":{"1254":1,"1255":1,"1256":1,"1257":1,"1424":1,"1425":1,"1426":1,"1427":1,"1428":1,"1429":1,"1430":1},"2":{"1094":1,"1136":1,"1242":1,"1258":1,"1401":1,"1404":1,"1422":1,"1428":2}}],["clockstream",{"2":{"792":4}}],["clock",{"0":{"699":1,"1230":1,"1255":1,"1351":1,"1369":1,"1379":1,"1422":1,"1428":1,"1430":1},"1":{"1380":1,"1429":1,"1430":1},"2":{"125":5,"139":1,"189":1,"242":1,"418":2,"600":1,"617":1,"625":2,"648":1,"666":1,"699":3,"907":1,"1024":1,"1028":1,"1035":1,"1069":2,"1080":1,"1081":1,"1088":2,"1113":1,"1125":4,"1157":1,"1226":1,"1231":1,"1234":1,"1236":1,"1247":1,"1251":1,"1253":1,"1254":2,"1258":2,"1259":1,"1260":1,"1263":1,"1264":2,"1266":1,"1332":1,"1366":1,"1372":2,"1373":2,"1374":3,"1379":3,"1380":1,"1382":3,"1387":1,"1389":3,"1392":1,"1396":1,"1411":1,"1413":1,"1419":2,"1422":1,"1429":1,"1439":1,"1443":1,"1445":3}}],["closing",{"0":{"524":1,"1447":1},"2":{"1035":1,"1036":1}}],["closures",{"2":{"102":1,"266":1,"1106":1,"1153":1,"1224":1}}],["closure",{"0":{"266":1},"2":{"102":1,"266":1,"285":1,"288":1,"289":1,"290":1,"579":1,"663":1,"1106":1,"1120":1,"1224":3}}],["closed",{"2":{"1221":1}}],["closest",{"2":{"219":1,"1077":2}}],["close",{"2":{"97":1,"102":1,"333":1,"955":2,"1136":1,"1218":1}}],["cleared",{"2":{"1318":1,"1433":2}}],["clearer",{"2":{"768":1}}],["clearly",{"2":{"1067":1}}],["clearance",{"0":{"1083":1},"2":{"1052":1,"1083":1}}],["cleartimeout",{"2":{"860":1,"955":1}}],["clears",{"2":{"831":1,"1405":1}}],["clear",{"2":{"404":1,"416":1,"642":1,"806":1,"976":2,"978":1,"1009":1,"1168":1,"1186":2}}],["clearing",{"2":{"95":1,"418":1,"625":1,"1221":2}}],["cleans",{"2":{"728":1,"831":1,"833":1,"1445":1}}],["cleaner",{"2":{"644":1,"676":1,"734":1,"760":1}}],["cleaned",{"2":{"336":1,"634":1,"760":1,"1408":1}}],["cleanups",{"0":{"843":1}}],["cleanup",{"0":{"486":1,"546":1,"1441":1},"2":{"329":1,"483":1,"540":1,"543":1,"616":1,"738":1,"792":1,"860":1,"1373":1,"1440":2,"1441":1,"1442":1}}],["cleanly",{"2":{"120":1,"144":1,"465":1,"468":2,"493":1,"541":1,"559":1,"702":1,"763":1,"771":1,"778":1,"786":1,"1435":1}}],["clean",{"2":{"43":2,"45":1,"76":1,"102":1,"107":1,"129":1,"152":1,"268":1,"280":1,"336":1,"373":1,"422":1,"468":1,"542":1,"688":1,"711":1,"732":1,"786":1,"793":1,"830":1,"848":1,"910":1,"1324":1,"1426":1}}],["cli",{"0":{"1041":1},"2":{"116":1,"709":2,"741":1,"953":1,"1024":1,"1041":1}}],["clientip",{"2":{"1188":1}}],["clientmask",{"2":{"1150":2}}],["clients",{"2":{"852":1,"1011":1,"1265":1}}],["client",{"0":{"858":1,"1188":1,"1265":1},"1":{"859":1,"860":1},"2":{"83":1,"116":1,"522":1,"857":2,"858":1,"860":1,"861":1,"862":1,"913":2,"915":1,"931":2,"953":1,"955":5,"998":2,"1005":3,"1008":2,"1011":1,"1093":1,"1166":1,"1188":2,"1219":2,"1227":4,"1236":1,"1253":1,"1258":1,"1259":1,"1265":2,"1266":1}}],["clicks",{"2":{"1326":1,"1394":1}}],["click",{"2":{"26":1,"89":1,"90":2,"705":1}}],["claiming",{"2":{"1012":1}}],["claims",{"2":{"729":1,"836":1}}],["clause",{"2":{"985":1}}],["claude",{"0":{"29":1},"2":{"24":1,"48":1,"247":1,"692":1}}],["clarified",{"2":{"610":1,"637":1,"747":1}}],["clarify",{"2":{"546":1,"729":1}}],["clarity",{"2":{"582":1,"1098":1}}],["clashes",{"2":{"403":1}}],["classstates",{"2":{"336":1,"831":1}}],["classes",{"2":{"261":1,"335":1,"340":1,"402":1,"404":1,"478":1,"479":2,"503":1,"597":1,"657":1,"664":1,"787":1,"833":1}}],["classifies",{"2":{"306":1,"1067":1}}],["classifications",{"2":{"642":1,"1066":1}}],["classification",{"2":{"127":1,"642":2,"644":2,"891":1,"1065":1,"1074":1}}],["classicalromandate",{"0":{"1284":1,"1287":1},"2":{"1284":1,"1287":1}}],["classical",{"0":{"1268":1,"1302":1},"1":{"1269":1,"1270":1,"1271":1,"1272":1,"1273":1,"1274":1,"1303":1,"1304":1},"2":{"1271":1,"1275":1,"1276":4,"1280":6,"1284":1,"1288":1,"1289":1,"1290":1,"1292":1,"1299":1,"1301":2,"1304":2,"1307":1,"1310":5,"1313":2,"1314":1}}],["classic",{"2":{"230":1,"771":1}}],["class",{"0":{"133":1,"199":1,"200":1,"333":1,"478":1},"1":{"134":1,"201":1,"202":1,"203":1,"204":1,"205":1},"2":{"13":1,"46":1,"111":1,"116":1,"131":2,"132":1,"133":1,"148":1,"155":1,"168":1,"169":1,"170":2,"171":1,"175":1,"197":1,"198":2,"199":3,"200":1,"230":1,"234":1,"262":1,"270":1,"276":5,"326":1,"330":1,"331":2,"332":1,"336":1,"340":2,"341":1,"342":1,"343":1,"347":1,"378":1,"407":1,"422":1,"478":1,"482":1,"503":1,"504":1,"507":2,"515":1,"546":1,"558":1,"565":1,"584":1,"668":1,"707":2,"709":1,"711":1,"763":1,"776":1,"817":1,"833":1,"970":1,"1021":1,"1033":1,"1106":1,"1144":1,"1164":1,"1329":1,"1341":1,"1382":1,"1389":1,"1392":1,"1395":1,"1426":1,"1435":1,"1452":1,"1454":1}}],["clamps",{"2":{"188":1,"189":1}}],["criteria",{"2":{"1437":1}}],["critical",{"0":{"909":1},"2":{"33":1,"43":2,"44":1,"342":1,"362":1,"422":1,"476":1,"533":1,"833":1,"909":1,"922":1,"972":1,"1098":1,"1122":1,"1183":1,"1219":1,"1363":1,"1412":1,"1422":1}}],["cristian",{"0":{"1226":1,"1227":1},"1":{"1227":1,"1228":2,"1229":2,"1230":2,"1231":2,"1232":1,"1233":1,"1234":1,"1235":1},"2":{"1226":1,"1236":1,"1242":1}}],["cron",{"0":{"1416":1,"1417":1},"1":{"1417":1},"2":{"1255":2,"1396":1,"1401":2,"1403":1,"1404":2,"1411":1,"1416":1,"1417":4,"1427":2,"1447":2}}],["crops",{"2":{"1082":1}}],["crop",{"2":{"1080":1}}],["crosses",{"2":{"1045":1,"1338":1}}],["crossing",{"0":{"1338":1},"2":{"158":1,"1343":1,"1344":1}}],["cross",{"0":{"950":1,"1116":1,"1123":1,"1148":1,"1375":1},"1":{"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":1,"1135":1,"1136":1,"1149":1,"1150":1,"1376":1},"2":{"7":1,"78":1,"114":1,"116":1,"137":1,"161":1,"219":1,"362":1,"483":1,"606":1,"614":1,"634":1,"653":1,"667":1,"752":1,"773":1,"857":1,"866":2,"867":1,"909":1,"950":1,"1024":1,"1039":1,"1105":1,"1123":1,"1150":1,"1338":1,"1367":1,"1375":2,"1377":1,"1378":4,"1441":1,"1459":1}}],["crescenttiltdeg",{"0":{"1063":1},"2":{"1052":1,"1053":1,"1054":1,"1063":2}}],["crescent",{"0":{"1063":1},"2":{"1052":1,"1053":1,"1055":2,"1058":1,"1059":4,"1060":3,"1063":4,"1269":1}}],["credential",{"0":{"864":1,"1002":1},"1":{"1003":1,"1004":1,"1005":1},"2":{"1363":1}}],["credentials",{"0":{"933":1},"2":{"853":1,"857":1,"913":1,"930":1,"954":2,"1004":2,"1005":1}}],["creators",{"2":{"514":1}}],["creating",{"0":{"230":1,"263":1,"275":1,"462":1},"1":{"231":1,"232":1,"233":1,"234":1,"235":1,"236":1,"264":1,"265":1,"266":1,"267":1,"268":1,"269":1,"270":1,"271":1,"272":1,"463":1,"464":1,"465":1},"2":{"124":1,"224":1,"273":1,"407":1,"411":1,"468":1,"561":1,"851":2,"1324":1,"1452":1}}],["creation",{"0":{"1403":1},"2":{"117":1,"120":1,"124":1,"331":1,"446":1,"677":1,"684":1}}],["createrequestcontext",{"2":{"1193":1}}],["createdeliverynotification",{"2":{"1016":1}}],["created",{"2":{"162":1,"312":1,"316":1,"335":1,"340":1,"343":1,"475":1,"708":1,"1417":1}}],["createscoped",{"2":{"402":1}}],["creates",{"2":{"45":1,"76":1,"446":2,"465":1,"502":1,"1093":1,"1146":1,"1191":1,"1220":1,"1391":1,"1420":1}}],["create",{"0":{"334":1,"543":1,"831":1},"2":{"8":1,"45":1,"116":3,"173":1,"238":1,"261":1,"315":1,"330":1,"331":4,"332":4,"333":2,"334":3,"335":2,"336":1,"338":1,"340":1,"341":2,"402":1,"406":1,"438":2,"442":1,"453":1,"465":1,"471":1,"489":1,"518":1,"540":1,"543":3,"631":1,"637":1,"639":1,"643":1,"827":1,"831":5,"1254":1}}],["cryptography",{"2":{"504":1}}],["crashing",{"2":{"980":1}}],["crash",{"2":{"864":1,"1041":1,"1265":1}}],["crashes",{"2":{"404":1,"751":1,"980":1}}],["crafting",{"2":{"205":1,"245":1}}],["cil",{"2":{"1304":1}}],["ciceroentries",{"2":{"1313":2}}],["cicero",{"2":{"1273":1,"1278":1,"1313":2}}],["cicerone",{"2":{"1273":1,"1276":1,"1289":1,"1292":1,"1313":2}}],["civic",{"2":{"1213":1,"1273":1}}],["civil",{"0":{"1366":1},"2":{"526":1,"763":1,"767":1,"1052":1,"1053":1,"1067":2,"1072":2,"1073":6,"1080":1,"1082":3,"1309":1,"1312":1,"1351":1,"1362":1,"1366":3}}],["circadian",{"2":{"1343":1,"1353":1,"1366":1}}],["circle",{"0":{"1347":1,"1355":1,"1365":1},"1":{"1356":1,"1357":1},"2":{"1162":1,"1334":1,"1339":1,"1343":1,"1344":2,"1345":1,"1354":1,"1355":1,"1358":1,"1359":1,"1362":1,"1363":1,"1365":1}}],["circuited",{"2":{"477":1}}],["circuiting",{"2":{"477":2}}],["circular",{"0":{"1334":1},"1":{"1335":1},"2":{"276":1,"404":1,"472":1,"829":1,"1333":1,"1362":1,"1364":1}}],["cinematography",{"2":{"1084":1}}],["cipher",{"2":{"479":1,"504":1,"841":1}}],["city",{"2":{"117":1,"121":2,"142":3,"143":1,"144":4,"145":3,"226":1,"823":2,"1055":1,"1103":1,"1167":3,"1168":1,"1171":1,"1172":2,"1176":1,"1178":4,"1181":3,"1272":1}}],["ci",{"0":{"635":1,"669":1,"1458":1},"2":{"6":2,"215":1,"607":1,"614":1,"635":1,"1054":1,"1067":1,"1147":1,"1458":2}}],["cdt",{"2":{"296":1}}],["cdns",{"0":{"43":1,"44":1},"2":{"10":2,"41":2,"43":2,"44":2,"729":3}}],["cdn",{"2":{"10":2,"42":2,"43":2,"44":8,"45":3,"47":2,"722":1,"840":1,"850":3,"1193":2}}],["cd",{"0":{"635":1,"669":1},"2":{"4":1}}],["coincollection",{"2":{"1307":2}}],["coincided",{"2":{"1269":2}}],["coincides",{"2":{"1077":1}}],["coincide",{"2":{"767":1}}],["coinage",{"2":{"1306":1}}],["coin",{"0":{"1305":1},"1":{"1306":1,"1307":1},"2":{"1306":1,"1307":6}}],["coss",{"2":{"1273":1,"1276":2,"1280":1,"1281":2,"1289":1,"1292":1,"1312":1,"1313":4}}],["costs",{"2":{"98":1,"204":1,"407":1,"416":1,"445":1,"1368":1}}],["cost",{"0":{"407":1},"2":{"12":1,"24":1,"96":1,"98":1,"117":1,"124":2,"138":1,"148":3,"150":1,"357":1,"373":1,"407":1,"419":2,"421":1,"423":1,"427":1,"441":1,"444":1,"469":2,"707":1,"708":1,"867":1,"940":1,"945":1,"949":1,"951":1,"972":1,"1353":1}}],["coarse",{"2":{"1232":1}}],["coastal",{"0":{"1074":1,"1078":1,"1083":1},"1":{"1075":1,"1076":1,"1077":1,"1078":1,"1079":1},"2":{"1074":1,"1080":1}}],["coalesce",{"2":{"477":1}}],["cohesion",{"0":{"1214":1}}],["cohesive",{"0":{"916":1},"1":{"917":1},"2":{"915":1,"919":1,"1104":1}}],["cohorts",{"2":{"365":1}}],["cot",{"2":{"701":1,"1071":1}}],["covers",{"2":{"1058":1,"1066":1,"1183":1,"1354":1,"1423":1}}],["coverage",{"2":{"644":1,"665":1,"1207":1,"1215":1}}],["covering",{"2":{"602":1,"648":1}}],["covered",{"2":{"365":1}}],["coep",{"2":{"1024":1,"1376":1,"1383":1}}],["coerces",{"2":{"750":1}}],["coerce",{"2":{"593":1,"1168":1}}],["coercion",{"2":{"355":2,"479":1}}],["coexist",{"2":{"408":1}}],["courier",{"2":{"1364":2}}],["courierlocation",{"2":{"1364":3}}],["couriers",{"2":{"1364":1}}],["counted",{"2":{"1270":2}}],["counterparts",{"2":{"739":1}}],["counter",{"2":{"138":2,"228":1,"416":1}}],["counters",{"2":{"138":4,"885":1}}],["countries",{"2":{"1205":1,"1207":1,"1210":1,"1212":1,"1213":1,"1215":1,"1447":1}}],["countrycode",{"2":{"1160":2}}],["country",{"2":{"117":1,"121":2,"142":4,"144":3,"226":1,"823":2,"1157":1,"1158":1,"1160":2,"1167":2,"1168":3,"1171":1,"1172":2,"1176":1,"1178":6,"1181":3,"1190":2,"1191":1,"1193":4,"1195":3,"1197":1,"1199":1,"1201":2,"1203":2,"1205":2,"1207":2,"1209":3,"1210":1,"1213":1,"1214":5,"1216":1,"1217":1,"1219":1,"1220":6,"1221":1,"1222":2,"1223":3,"1224":1,"1225":1}}],["count=daysinmonth−day+2for",{"2":{"1270":1}}],["count=anchorday−day+1for",{"2":{"1270":1}}],["count=12",{"2":{"984":1}}],["count=10",{"2":{"983":1,"1014":2}}],["count=2",{"2":{"983":1}}],["counting",{"0":{"1200":1,"1270":1},"1":{"1201":1},"2":{"771":1,"1268":1,"1269":1,"1270":1,"1299":1}}],["counts",{"2":{"634":1,"683":1,"886":1,"950":1,"954":1,"1008":1,"1276":1,"1412":1,"1420":1}}],["countdowns",{"0":{"1259":1,"1420":1},"1":{"1260":1,"1261":1},"2":{"165":1,"879":1,"897":1,"1016":1,"1242":1,"1401":1,"1404":1,"1411":1}}],["countdown",{"2":{"164":1,"898":1,"899":1,"1254":1,"1259":1,"1260":1,"1420":1,"1422":1}}],["count",{"0":{"396":1,"1288":1,"1438":1},"2":{"138":2,"150":1,"233":1,"240":1,"323":1,"324":2,"388":1,"391":1,"396":1,"399":1,"448":1,"461":2,"464":1,"465":1,"500":1,"978":1,"982":1,"985":1,"986":3,"997":1,"1250":1,"1270":2,"1304":3,"1389":2,"1404":2,"1409":1,"1420":1}}],["could",{"2":{"43":3,"139":2,"329":1,"431":1,"738":1,"1234":1}}],["columbus",{"2":{"1213":1}}],["color",{"2":{"622":1}}],["colocated",{"0":{"816":1},"2":{"285":1,"288":1,"289":1,"290":1,"291":1,"814":1}}],["colons",{"2":{"127":1}}],["colon",{"2":{"76":1,"127":1,"138":1,"642":1,"1090":1,"1125":2}}],["colloquialisms",{"2":{"951":1}}],["collaborative",{"2":{"1255":1}}],["collapsing",{"2":{"690":1}}],["collator",{"2":{"361":1}}],["collect",{"2":{"1007":1}}],["collects",{"2":{"954":1,"1008":1,"1028":1}}],["collector",{"2":{"473":1,"1374":1}}],["collected",{"0":{"449":1},"2":{"476":1,"495":1}}],["collections",{"2":{"496":1}}],["collection",{"2":{"49":1,"344":1,"345":1,"348":1,"350":1,"353":1,"354":1,"449":1,"450":1,"465":1,"476":1,"486":1,"798":1,"1043":1,"1370":1,"1395":1,"1442":1}}],["colliding",{"2":{"213":1}}],["collisions",{"2":{"138":1,"213":1,"219":1,"263":1,"271":1,"280":1,"326":3,"341":1,"468":1,"546":1,"617":1,"631":1,"643":1,"702":1,"726":1,"752":1,"773":1}}],["collision",{"0":{"337":1},"1":{"338":1,"339":1},"2":{"45":1,"152":1,"219":1,"453":1,"461":1,"612":1,"722":1,"748":2,"802":1,"1009":1,"1096":1}}],["coords",{"2":{"1168":2,"1176":1,"1178":5,"1181":6,"1184":1,"1191":9,"1344":2,"1353":1}}],["coordinateinput",{"2":{"1176":1}}],["coordinate",{"2":{"227":1,"282":1,"908":1,"1084":1,"1160":1,"1162":1,"1166":1,"1167":1,"1168":1,"1176":2,"1182":1,"1183":1,"1303":1,"1325":1,"1336":1,"1344":1,"1359":1}}],["coordinates",{"0":{"121":1,"226":1,"1054":1,"1071":1},"1":{"227":1},"2":{"117":1,"121":1,"142":2,"154":1,"187":1,"227":2,"357":1,"824":1,"893":1,"906":1,"907":3,"1046":1,"1054":5,"1055":1,"1060":1,"1061":1,"1065":1,"1066":1,"1067":1,"1071":2,"1078":2,"1079":1,"1083":1,"1160":1,"1167":3,"1168":7,"1169":2,"1172":1,"1176":4,"1178":2,"1181":4,"1184":1,"1185":1,"1186":3,"1187":2,"1188":1,"1189":1,"1192":1,"1288":1,"1290":1,"1312":1,"1324":1,"1334":1,"1344":2,"1345":5,"1355":1,"1363":1,"1365":1}}],["coordinated",{"2":{"23":1}}],["coop",{"2":{"1024":1,"1376":1,"1383":1}}],["cooper",{"2":{"998":2}}],["cooperative",{"2":{"476":1}}],["cooling",{"2":{"942":1}}],["cooldown",{"0":{"941":1,"942":1},"1":{"942":1},"2":{"940":4,"942":2}}],["cookbook",{"0":{"49":1},"1":{"50":1,"51":1,"52":1,"53":1,"54":1,"55":1,"56":1,"57":1,"58":1,"59":1,"60":1,"61":1,"62":1,"63":1,"64":1,"65":1,"66":1,"67":1,"68":1,"69":1,"70":1,"71":1,"72":1,"73":1,"74":1,"75":1,"76":1,"77":1,"78":1,"79":1,"80":1,"81":1,"82":1},"2":{"589":1,"640":1,"661":1,"705":2,"747":2}}],["copies",{"2":{"158":1,"402":1,"504":1,"1011":1}}],["copilot",{"0":{"27":1},"2":{"24":1,"27":3,"48":1,"247":1,"692":1}}],["copyable",{"2":{"1124":1}}],["copyright",{"2":{"763":1,"766":3}}],["copy",{"2":{"29":1,"90":2,"472":1,"502":1,"738":1,"782":2,"1024":1,"1029":1,"1030":1,"1038":2}}],["codemod",{"2":{"1147":1}}],["codemods",{"2":{"1105":1}}],["codes",{"2":{"354":1,"709":1,"1160":1,"1266":1}}],["codebases",{"2":{"514":1,"1086":1,"1108":1,"1117":1}}],["codebase",{"2":{"137":1,"191":1,"205":1,"515":2,"1114":1,"1146":1,"1450":1}}],["code=",{"2":{"89":1,"90":1}}],["code",{"0":{"27":1,"32":1,"85":1,"944":1,"1335":1,"1357":1},"1":{"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"2":{"22":1,"24":2,"27":2,"43":2,"48":1,"78":1,"83":3,"84":1,"85":1,"88":1,"90":4,"91":1,"102":1,"109":2,"113":1,"114":1,"142":1,"271":1,"335":1,"340":1,"367":1,"402":1,"413":1,"435":1,"457":2,"465":1,"468":1,"469":1,"526":1,"560":1,"592":1,"644":1,"712":1,"728":1,"830":1,"859":1,"936":1,"970":1,"973":2,"998":4,"1089":2,"1114":1,"1124":1,"1147":1,"1160":1,"1168":1,"1178":4,"1189":1,"1213":1,"1441":1,"1445":1}}],["coding",{"0":{"7":1},"2":{"24":1,"692":1,"1139":1,"1191":1}}],["coral",{"2":{"1085":1}}],["corpus",{"2":{"1303":1}}],["corporatecalendar",{"2":{"1224":3}}],["corporate",{"0":{"1224":1},"2":{"1175":1,"1224":3}}],["corp",{"2":{"932":1,"958":1,"1375":1,"1376":1,"1378":1}}],["corrupting",{"2":{"972":1}}],["corruption",{"2":{"413":1,"431":1,"503":1,"649":1,"702":1}}],["corrupt",{"2":{"865":1}}],["correlating",{"2":{"1265":1}}],["correlation",{"0":{"1265":1}}],["correction",{"0":{"1070":1},"2":{"1024":1,"1028":1,"1052":1}}],["correcting",{"2":{"617":1}}],["corrected",{"2":{"579":1,"616":1,"627":1,"660":1,"1062":1}}],["correctness",{"2":{"522":2,"752":1,"904":1}}],["correct",{"2":{"146":1,"243":2,"312":1,"387":1,"707":1,"1095":1,"1276":1}}],["correctly",{"2":{"125":1,"202":1,"208":1,"364":1,"631":1,"634":1,"651":1,"653":1,"660":1,"667":1,"709":1,"724":1,"738":1,"750":1,"878":1,"1338":1}}],["corresponding",{"2":{"6":1,"7":1,"678":1}}],["cors",{"2":{"89":1,"1243":1,"1422":1}}],["cores",{"2":{"1030":1,"1369":1}}],["core",{"0":{"135":1,"136":1,"148":1,"210":1,"211":1,"251":1,"400":1,"489":1,"499":1,"523":1,"539":1,"555":1,"806":1,"1125":1,"1132":1,"1280":1},"1":{"136":1,"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"155":1,"211":1,"401":1,"402":1,"403":1,"404":1,"405":1,"406":1,"407":1,"408":1,"409":1,"410":1,"411":1,"412":1,"413":1,"414":1,"415":1,"416":1,"417":1,"418":1,"419":1,"420":1,"421":1,"422":1,"423":1,"500":1,"501":1,"502":1,"524":1,"525":1,"526":1,"527":1},"2":{"10":1,"14":2,"42":1,"45":1,"46":2,"87":1,"93":4,"96":1,"119":1,"135":1,"136":2,"138":2,"167":1,"198":1,"210":1,"211":2,"229":1,"233":1,"234":2,"236":1,"249":1,"251":2,"256":1,"258":1,"259":1,"260":1,"261":1,"262":1,"265":1,"267":1,"268":2,"271":2,"273":2,"274":3,"276":6,"278":1,"279":1,"281":1,"283":2,"298":1,"308":1,"310":1,"311":1,"313":1,"316":1,"321":1,"322":2,"325":1,"402":1,"419":1,"421":1,"437":1,"439":1,"440":1,"446":1,"447":1,"453":1,"458":2,"470":1,"504":1,"534":1,"536":1,"539":2,"548":1,"550":1,"552":2,"555":1,"574":1,"597":1,"607":3,"618":1,"629":2,"635":1,"644":3,"668":1,"669":1,"672":1,"675":1,"676":1,"678":2,"697":2,"702":2,"705":1,"707":1,"708":1,"709":2,"711":1,"712":1,"716":1,"720":1,"722":2,"724":1,"726":1,"737":1,"738":1,"757":1,"778":1,"835":1,"836":2,"841":1,"850":1,"879":1,"897":1,"922":1,"951":1,"1007":1,"1026":1,"1037":1,"1054":1,"1087":1,"1097":1,"1103":1,"1110":1,"1112":1,"1120":1,"1121":1,"1123":1,"1147":1,"1273":1,"1276":1,"1278":1,"1313":1,"1319":1,"1339":1,"1429":1,"1454":1,"1459":2}}],["condita",{"0":{"1272":1},"2":{"1272":1,"1275":1,"1276":1,"1285":1}}],["condition",{"2":{"261":1,"985":1}}],["conditions",{"0":{"1437":1},"1":{"1438":1,"1439":1},"2":{"109":1,"407":1,"1425":1}}],["conditional",{"2":{"38":1}}],["conjunction",{"2":{"769":1}}],["concatenation",{"2":{"1143":1}}],["concrete",{"2":{"1137":1}}],["concise",{"2":{"929":1,"936":1,"1016":1,"1412":3}}],["concurrency",{"2":{"696":1,"871":1,"881":1,"890":1,"899":1,"934":1,"989":1}}],["concurrently",{"2":{"877":1,"887":1,"896":1,"905":1,"934":2,"949":1,"950":1,"1019":1,"1037":1,"1387":1}}],["concurrent",{"2":{"489":1,"934":2,"946":1,"1033":1,"1178":1,"1185":1,"1361":1,"1362":1}}],["conclusion",{"0":{"528":1}}],["concerns",{"2":{"483":1,"626":1}}],["concerned",{"2":{"46":1}}],["concepts",{"0":{"489":1},"2":{"378":1,"471":1,"697":1,"705":1,"708":1,"712":1,"1097":1}}],["concept",{"2":{"22":1,"331":3,"1089":1,"1353":1}}],["conferred",{"2":{"1307":1}}],["confidence",{"0":{"865":1,"875":1,"912":1},"2":{"865":1,"870":1,"871":1,"872":2,"875":1,"880":1,"881":1,"882":2,"889":2,"890":1,"891":4,"898":1,"899":1,"900":2,"912":4,"919":2,"920":2,"922":1,"934":2,"936":2,"937":1,"938":1,"950":2,"961":1,"962":1,"965":1,"986":2,"989":1,"992":1,"993":1,"997":1,"1010":1}}],["confirms",{"2":{"1113":1}}],["confirm",{"2":{"588":1}}],["configs",{"2":{"103":1,"107":2,"109":1,"291":1,"303":1,"590":1,"829":1}}],["configfile",{"2":{"103":1,"109":1}}],["config",{"0":{"102":1,"103":1,"344":1,"350":1,"538":1,"687":2,"839":1,"853":1,"925":1,"927":1,"996":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"854":1,"855":1,"856":1,"857":1,"926":1,"927":1},"2":{"78":1,"102":10,"103":1,"104":1,"105":2,"106":1,"108":1,"109":1,"117":1,"121":1,"129":1,"147":3,"155":1,"199":1,"224":1,"250":1,"281":3,"282":6,"290":2,"291":2,"317":3,"327":1,"350":1,"361":1,"389":2,"403":1,"413":1,"477":3,"538":1,"541":1,"687":2,"688":3,"708":1,"731":3,"738":1,"741":7,"747":1,"793":1,"829":3,"830":1,"835":1,"836":1,"839":1,"853":1,"870":2,"907":1,"919":1,"925":1,"926":3,"927":1,"937":2,"1167":1,"1168":1}}],["configuring",{"2":{"374":1,"787":1,"932":1,"1060":1}}],["configurability",{"2":{"516":1}}],["configurable",{"0":{"235":1},"2":{"402":1,"426":2,"647":1,"694":1,"1010":1,"1203":1,"1233":1,"1315":1,"1376":1}}],["configuration",{"0":{"56":1,"94":1,"100":1,"110":1,"121":1,"166":1,"290":1,"317":1,"374":1,"485":1,"541":1,"630":1,"633":1,"688":1,"825":1,"829":1,"830":1,"854":1,"859":1,"871":1,"881":1,"890":1,"899":1,"924":1,"926":1,"928":1,"930":1,"937":1,"951":1,"952":1,"959":1,"989":1,"1022":1,"1240":1,"1404":1},"1":{"101":1,"102":1,"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"110":1,"111":1,"112":1,"113":1,"114":1,"115":1,"116":1,"117":1,"118":1,"119":1,"120":1,"121":1,"122":1,"123":1,"124":1,"125":1,"126":1,"127":1,"128":1,"129":1,"375":1,"376":1,"377":1,"542":1,"925":1,"926":1,"927":1,"928":1,"929":2,"930":2,"931":2,"932":2,"933":2,"934":1,"935":1,"936":1,"937":1,"938":2,"952":1,"953":2,"954":1,"955":1,"956":1,"957":1,"958":1,"959":1,"990":1,"991":1},"2":{"30":1,"56":1,"69":1,"77":1,"89":1,"100":1,"101":1,"102":6,"103":2,"104":1,"105":1,"107":4,"109":2,"111":1,"114":2,"115":6,"117":5,"118":1,"119":1,"120":1,"123":1,"137":1,"154":1,"155":2,"166":1,"199":2,"212":1,"222":1,"246":1,"250":1,"262":3,"273":1,"276":1,"281":3,"282":1,"285":1,"288":1,"291":3,"292":1,"297":1,"302":1,"317":1,"326":1,"327":1,"330":1,"331":1,"337":1,"343":1,"344":1,"350":1,"356":1,"361":1,"375":1,"402":1,"422":1,"431":1,"466":1,"477":1,"504":1,"516":1,"535":2,"536":2,"538":2,"540":2,"541":6,"542":1,"562":1,"565":1,"567":1,"571":1,"572":1,"578":1,"580":1,"582":1,"585":1,"592":1,"606":1,"616":1,"617":1,"637":1,"643":1,"648":1,"649":1,"651":1,"668":1,"687":2,"688":1,"701":1,"702":1,"717":1,"731":1,"738":1,"741":1,"747":1,"750":1,"757":3,"804":1,"807":1,"824":1,"825":1,"827":3,"829":1,"830":1,"832":1,"833":1,"836":4,"838":1,"839":1,"845":1,"855":1,"860":1,"862":1,"867":1,"869":2,"871":1,"874":1,"908":1,"909":1,"924":1,"926":1,"932":1,"933":1,"934":1,"939":1,"953":1,"959":1,"963":1,"970":1,"982":1,"1000":1,"1003":1,"1008":1,"1011":1,"1042":1,"1054":1,"1168":1,"1376":1,"1427":1,"1454":1}}],["configurations",{"0":{"105":1},"2":{"10":1,"105":1,"109":1,"328":1,"329":2,"331":1,"333":1,"362":1,"513":1,"572":1,"630":1,"639":1,"643":1,"644":1,"648":1,"669":1,"729":1,"747":1,"754":1,"829":1,"856":1,"864":1,"927":1,"932":1}}],["configures",{"2":{"1421":1}}],["configured",{"2":{"85":1,"104":1,"111":1,"132":1,"134":1,"138":1,"208":1,"332":1,"364":1,"447":1,"567":1,"616":1,"863":1,"867":1,"919":1,"937":1,"938":1,"939":1,"942":1,"945":1,"947":1,"949":1,"959":1,"963":1,"1007":1,"1254":1,"1378":1,"1427":4}}],["configure",{"2":{"27":1,"69":1,"94":1,"102":1,"109":1,"114":1,"121":1,"199":1,"207":1,"374":1,"448":1,"776":1,"859":1,"954":1,"955":3,"1008":1,"1017":1,"1097":1,"1376":1,"1412":1}}],["conforming",{"2":{"491":1}}],["conformed",{"2":{"359":1}}],["conflicting",{"2":{"1086":1,"1109":1}}],["conflictbumped",{"2":{"919":1,"988":1,"992":1,"993":1}}],["conflict",{"0":{"987":1,"993":1,"1015":1},"1":{"988":1,"989":1,"990":1,"991":1,"992":1,"993":1},"2":{"338":1,"950":1,"987":1,"992":1,"993":1}}],["conflicts",{"2":{"176":1,"1146":1}}],["confusing",{"0":{"1094":1},"2":{"139":1}}],["confusion",{"2":{"137":1,"157":1,"1094":1}}],["connect",{"2":{"931":1,"1175":1}}],["connection",{"2":{"860":1,"1085":1}}],["connections",{"2":{"44":1,"1029":1}}],["connecting",{"2":{"854":1,"1188":1,"1359":1}}],["connectors",{"2":{"125":1}}],["conventions",{"0":{"1222":1,"1459":1},"2":{"368":1,"522":1,"541":1,"832":1,"1094":1,"1125":1,"1126":1,"1149":1,"1156":1,"1157":1,"1190":1,"1210":1}}],["convention",{"0":{"274":1},"2":{"741":1,"1190":1,"1222":4}}],["convenience",{"2":{"78":1,"138":1,"150":2,"168":1,"205":1,"479":1,"516":1,"786":1,"1104":2,"1117":1}}],["convenient",{"2":{"72":1,"114":1,"457":1,"677":1,"967":1}}],["convergence",{"0":{"1267":1}}],["conversions",{"2":{"798":1,"1272":1,"1275":1,"1278":1}}],["conversion",{"0":{"1116":1},"2":{"202":1,"1190":1,"1276":1,"1299":1}}],["conversational",{"2":{"89":1,"204":3,"897":1,"909":1,"921":1,"1013":1}}],["conversation",{"2":{"26":1}}],["convertresult",{"2":{"1104":2}}],["converters",{"2":{"522":1}}],["converted",{"2":{"125":1,"1147":1}}],["converts",{"2":{"138":5,"162":1,"1014":1,"1104":1,"1158":1,"1294":1,"1295":1}}],["converting",{"0":{"80":1,"81":1,"1014":1},"2":{"606":1,"960":1,"1091":1}}],["convert",{"0":{"68":1,"1116":1,"1148":1},"1":{"1149":1,"1150":1},"2":{"496":1,"1099":1,"1104":4,"1114":1,"1116":6,"1150":3,"1167":2,"1304":1}}],["consecutive",{"2":{"983":1,"1127":1}}],["consensus",{"0":{"950":1},"2":{"696":1,"867":2,"871":1,"881":1,"890":1,"899":1,"921":2,"934":4,"937":1,"938":2,"939":1,"940":1,"950":2,"959":1,"963":1,"989":1}}],["consolidates",{"2":{"417":1,"776":1}}],["consolidated",{"2":{"297":1,"402":1,"544":1,"563":1,"564":1,"616":1,"626":1,"633":1,"653":1}}],["consolidation",{"2":{"402":1,"757":1}}],["console",{"0":{"356":1},"1":{"357":1,"358":1,"359":1,"360":1},"2":{"9":3,"42":1,"45":1,"52":1,"58":1,"65":1,"66":1,"68":2,"72":1,"73":4,"75":1,"83":1,"87":2,"88":1,"89":1,"117":1,"124":1,"125":1,"128":1,"129":1,"131":1,"133":1,"134":1,"146":2,"149":5,"160":3,"163":2,"164":1,"165":1,"177":1,"197":1,"214":1,"226":3,"231":1,"246":1,"268":2,"271":1,"282":3,"295":1,"300":1,"317":1,"335":1,"336":2,"339":1,"341":1,"356":1,"357":1,"360":1,"367":10,"403":1,"429":1,"448":1,"460":1,"461":1,"464":5,"482":2,"483":3,"490":3,"491":1,"492":2,"631":1,"702":1,"748":1,"765":1,"768":2,"786":5,"792":1,"848":1,"849":1,"850":1,"869":1,"870":5,"871":1,"880":5,"885":2,"889":4,"894":1,"898":3,"912":1,"918":1,"936":3,"950":1,"954":1,"961":2,"964":2,"968":3,"969":3,"970":1,"973":3,"982":4,"983":2,"984":3,"985":1,"988":4,"996":2,"997":1,"998":2,"1011":4,"1019":1,"1030":2,"1033":2,"1036":1,"1046":9,"1047":10,"1048":2,"1049":1,"1055":15,"1056":1,"1059":6,"1060":2,"1061":3,"1062":3,"1063":1,"1064":4,"1065":4,"1067":4,"1068":1,"1069":2,"1070":2,"1071":5,"1072":5,"1073":2,"1076":4,"1077":2,"1078":4,"1083":1,"1101":3,"1102":1,"1113":3,"1114":1,"1115":2,"1116":3,"1118":2,"1119":3,"1136":2,"1141":3,"1144":2,"1147":3,"1150":3,"1153":3,"1154":1,"1158":5,"1159":1,"1160":6,"1171":4,"1172":2,"1181":4,"1184":1,"1190":2,"1191":1,"1195":2,"1197":2,"1199":2,"1201":2,"1203":1,"1205":2,"1209":5,"1214":4,"1216":3,"1217":1,"1220":1,"1221":1,"1222":2,"1223":3,"1224":2,"1243":3,"1254":2,"1255":1,"1264":1,"1271":3,"1273":1,"1280":10,"1281":2,"1304":2,"1307":1,"1310":2,"1313":4,"1316":1,"1317":1,"1326":3,"1329":1,"1332":2,"1335":3,"1337":3,"1338":1,"1347":3,"1348":2,"1352":4,"1357":1,"1358":1,"1359":1,"1360":1,"1361":2,"1363":2,"1365":3,"1366":1,"1381":1,"1389":1,"1408":1,"1409":1,"1412":3,"1415":2,"1417":2,"1418":1,"1419":1,"1420":2,"1421":2,"1422":1,"1424":4,"1426":2,"1434":1,"1435":1,"1436":2,"1438":2,"1439":1,"1444":1,"1445":1,"1447":1,"1448":1,"1459":4}}],["cons",{"2":{"269":2,"431":1}}],["consul",{"2":{"1273":1,"1278":1,"1281":1,"1313":2}}],["consulibus⟹63",{"2":{"1273":1}}],["consules",{"2":{"1273":1}}],["consularpair",{"0":{"1293":1}}],["consulares",{"0":{"1273":1},"2":{"1276":1,"1278":1,"1281":1,"1291":1,"1293":1,"1313":2}}],["consular",{"0":{"1273":1,"1281":1,"1311":1},"1":{"1312":1,"1313":1},"2":{"1273":1,"1281":1,"1312":1,"1313":1}}],["consuls",{"2":{"1272":1,"1273":4,"1276":2,"1278":1,"1280":1,"1281":2,"1291":1,"1292":1,"1312":1,"1313":4}}],["consult",{"2":{"1105":1}}],["consulted",{"2":{"93":1}}],["consulting",{"0":{"532":1},"2":{"8":1}}],["consumption",{"2":{"920":1,"1043":1,"1081":1,"1365":1,"1451":1}}],["consumable",{"2":{"492":1}}],["consuming",{"0":{"236":1,"268":1,"288":1},"1":{"289":1,"290":1,"291":1},"2":{"1106":1}}],["consumed",{"2":{"1412":1,"1446":1}}],["consumes",{"2":{"972":1}}],["consumers",{"2":{"274":1,"285":3,"425":1,"452":1,"457":1,"489":1,"1450":1}}],["consumer",{"2":{"266":3,"271":2,"326":1,"452":1,"489":4,"494":1,"649":1,"1446":1}}],["consume",{"2":{"228":1,"416":2,"444":1,"445":1,"792":1,"1435":1}}],["consist",{"2":{"391":1}}],["consistent",{"2":{"137":1,"205":1,"261":1,"273":1,"274":1,"326":1,"462":1,"466":1,"616":1,"625":1,"1093":1}}],["consistently",{"2":{"34":1,"102":1,"1090":1}}],["consistency",{"2":{"121":1,"259":1,"326":1,"634":1,"663":1,"720":1,"758":1,"1258":1,"1369":1,"1383":1}}],["considered",{"2":{"1195":1}}],["consider",{"2":{"43":1,"280":1,"283":1,"549":1}}],["constitution",{"2":{"1213":1}}],["constants",{"2":{"439":1,"580":2}}],["constant",{"2":{"296":1,"414":1,"446":1,"1090":1,"1103":1,"1329":1,"1370":1,"1377":1}}],["constrained",{"2":{"893":1,"948":1}}],["constraint",{"2":{"399":1,"989":1}}],["constraints",{"0":{"388":1,"1375":1},"1":{"1376":1},"2":{"43":1,"146":1,"273":1,"752":1,"884":1,"902":1,"919":1,"992":1,"993":1}}],["constructs",{"2":{"737":1,"910":1}}],["constructively",{"2":{"1076":1}}],["construction",{"2":{"340":1,"416":1,"626":1,"639":1,"699":1,"734":1,"910":1,"1010":1}}],["constructing",{"2":{"226":1,"699":1,"902":1,"1290":1}}],["constructed",{"2":{"120":1,"349":1,"699":1,"816":1}}],["construct",{"2":{"69":1,"161":1,"274":1,"513":1,"860":1,"1080":1}}],["constructors",{"2":{"402":1}}],["constructor",{"0":{"407":1},"2":{"52":1,"101":1,"116":1,"118":1,"124":3,"125":2,"169":1,"200":1,"211":1,"371":1,"373":1,"402":1,"407":2,"415":1,"421":1,"423":1,"429":1,"441":1,"442":1,"444":2,"453":1,"468":1,"565":2,"593":1,"661":1,"702":1,"744":1,"776":1,"787":1,"908":1,"1392":1,"1395":1,"1454":1}}],["const",{"2":{"9":3,"10":1,"32":1,"36":1,"38":1,"40":1,"42":1,"45":2,"46":1,"62":3,"63":3,"65":1,"68":1,"69":2,"71":5,"73":1,"77":1,"78":1,"80":1,"81":2,"98":2,"103":1,"112":1,"118":1,"119":2,"121":1,"123":1,"124":1,"125":1,"131":2,"133":1,"134":1,"137":1,"144":1,"145":1,"146":4,"147":3,"158":3,"159":3,"162":2,"164":1,"165":1,"166":1,"169":1,"170":1,"171":1,"178":1,"179":2,"180":2,"191":1,"197":1,"200":1,"205":2,"214":1,"215":1,"217":2,"223":2,"232":1,"233":2,"235":2,"236":2,"243":1,"246":1,"261":1,"265":4,"266":2,"268":1,"270":1,"271":3,"276":1,"281":1,"285":3,"286":1,"313":6,"317":4,"324":5,"333":3,"334":3,"335":1,"358":1,"363":2,"368":1,"372":1,"426":2,"437":1,"438":1,"448":1,"454":1,"455":1,"458":4,"459":3,"461":7,"463":4,"464":2,"469":1,"477":3,"481":2,"484":1,"489":4,"492":1,"493":3,"496":2,"500":2,"501":1,"502":1,"519":2,"520":7,"731":1,"765":3,"774":1,"792":2,"793":1,"806":1,"848":1,"849":1,"850":2,"859":1,"860":8,"870":1,"878":2,"880":3,"885":2,"889":4,"894":2,"896":1,"898":3,"903":2,"908":2,"916":1,"917":1,"918":1,"925":1,"934":3,"935":1,"939":1,"950":2,"954":1,"955":10,"957":1,"961":1,"969":1,"970":1,"973":2,"974":1,"975":1,"978":5,"982":1,"983":4,"985":1,"988":1,"997":1,"998":1,"1004":1,"1013":2,"1014":1,"1015":1,"1016":2,"1019":2,"1020":2,"1030":3,"1033":1,"1036":2,"1039":1,"1041":1,"1046":3,"1047":1,"1048":1,"1049":1,"1055":3,"1056":1,"1059":1,"1060":1,"1065":2,"1067":1,"1068":1,"1069":2,"1070":1,"1072":2,"1076":1,"1078":1,"1081":3,"1082":2,"1083":3,"1084":2,"1085":2,"1101":1,"1102":1,"1113":1,"1114":2,"1115":2,"1116":3,"1119":2,"1136":1,"1141":5,"1144":1,"1147":3,"1150":5,"1153":1,"1154":1,"1158":3,"1159":1,"1171":3,"1172":3,"1178":15,"1180":1,"1181":3,"1184":3,"1186":1,"1188":1,"1190":4,"1191":7,"1192":3,"1193":3,"1195":2,"1197":3,"1199":2,"1201":1,"1203":3,"1204":1,"1205":2,"1209":4,"1214":1,"1216":1,"1220":5,"1221":3,"1222":3,"1223":4,"1224":3,"1239":1,"1241":1,"1243":1,"1254":1,"1255":1,"1260":1,"1261":1,"1264":1,"1265":1,"1266":1,"1271":1,"1273":1,"1280":5,"1281":1,"1304":4,"1307":3,"1310":4,"1313":3,"1316":7,"1317":1,"1326":4,"1329":7,"1332":4,"1335":7,"1337":4,"1338":1,"1347":5,"1348":3,"1352":4,"1357":6,"1358":4,"1359":3,"1360":4,"1361":4,"1363":5,"1364":4,"1365":6,"1366":2,"1379":2,"1380":1,"1381":4,"1389":7,"1392":2,"1395":1,"1400":1,"1405":1,"1409":1,"1412":1,"1424":1,"1426":2,"1429":6,"1430":2,"1434":1,"1435":1,"1444":2,"1446":2,"1447":1,"1448":1}}],["contiguous",{"2":{"1040":1}}],["continually",{"2":{"954":1}}],["continuously",{"2":{"958":1,"1072":2,"1235":1,"1267":1,"1351":1,"1382":1}}],["continuous",{"2":{"138":1,"167":1,"991":1,"1242":1,"1253":1,"1254":1,"1272":2,"1396":1,"1411":1}}],["continue",{"2":{"109":1,"325":1,"778":1,"839":1,"973":1,"1147":1}}],["continues",{"2":{"109":1,"370":1,"816":1}}],["contrast",{"2":{"331":1,"565":1,"1093":1}}],["contracted",{"2":{"1220":1}}],["contracts",{"0":{"298":1,"920":1},"2":{"910":1,"920":1,"1218":1,"1219":1}}],["contract",{"0":{"115":1,"1054":1},"2":{"867":1,"920":1,"950":2,"1054":1}}],["controller",{"2":{"493":3,"642":2,"860":4,"955":5}}],["controlled",{"2":{"114":1,"414":1,"423":1,"434":1,"1008":1}}],["control",{"0":{"435":1},"2":{"216":1,"375":1,"383":1,"503":1,"600":1,"625":1,"630":1,"639":1,"659":1,"701":1,"854":1,"1081":1,"1082":1,"1436":1}}],["controls",{"0":{"863":1,"935":1,"1436":1},"2":{"117":2,"204":1,"994":1,"1008":1,"1009":1,"1158":1,"1401":1,"1446":1}}],["contributors",{"2":{"1":1}}],["contributing",{"0":{"0":1},"1":{"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1},"2":{"0":1}}],["contemporary",{"2":{"120":1}}],["content",{"2":{"89":1,"705":1,"860":4,"955":1,"1232":1,"1444":1}}],["contents",{"0":{"50":1}}],["context2",{"2":{"877":1}}],["context1",{"2":{"877":1}}],["contexts",{"2":{"633":1,"748":1,"752":1,"877":1}}],["contextual",{"0":{"526":1,"879":1,"897":1,"1016":1},"1":{"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1,"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1},"2":{"655":1,"870":1,"882":1,"897":2,"919":1,"1009":1,"1016":2}}],["contextaitempo",{"2":{"919":1}}],["contextai",{"0":{"869":1,"878":1},"1":{"870":1,"871":1,"872":1,"873":1,"874":1,"875":1,"876":1,"877":1,"878":1},"2":{"93":1,"869":1,"870":2,"874":1,"875":1,"876":1,"877":1,"878":2,"910":1,"912":1,"936":1,"973":1}}],["context",{"0":{"69":1,"119":1,"224":1,"226":1,"536":1,"692":1,"824":1,"838":1,"869":1,"874":1,"884":1,"902":1,"933":1,"1089":1,"1134":1},"1":{"120":1,"225":1,"227":1,"870":1,"871":1,"872":1,"873":1,"874":1,"875":1,"876":1,"877":1,"878":1},"2":{"28":1,"29":1,"48":1,"69":2,"119":1,"144":1,"147":1,"204":1,"224":4,"247":1,"269":1,"270":1,"301":1,"313":1,"323":2,"373":2,"403":2,"526":1,"536":2,"561":1,"574":1,"609":1,"617":2,"626":2,"649":1,"665":1,"676":1,"692":2,"701":1,"702":1,"814":1,"821":1,"835":1,"838":1,"855":1,"863":1,"869":1,"870":6,"871":1,"875":3,"878":2,"881":1,"890":1,"893":1,"899":1,"910":1,"919":3,"921":1,"933":3,"936":1,"937":4,"938":4,"962":2,"1004":3,"1008":1,"1016":1,"1095":1,"1189":2,"1193":2,"1220":1,"1368":1,"1382":1,"1448":1}}],["containment",{"2":{"1333":1}}],["containers",{"2":{"365":1,"427":1}}],["container",{"2":{"141":1,"365":1,"782":1,"829":1,"1083":1,"1178":1}}],["contains",{"0":{"177":1},"2":{"139":1,"177":1,"351":1,"377":1,"383":2,"642":1,"699":1,"711":1,"738":1,"1232":1,"1269":1,"1449":1,"1453":1}}],["contain",{"2":{"125":1,"351":1,"388":1,"1093":1}}],["containing",{"2":{"64":1,"111":1,"191":1,"353":1,"354":1,"363":1,"370":1,"383":1,"412":1,"501":1,"869":1,"888":1,"911":1,"912":1,"974":1,"995":1,"997":1,"1035":1,"1091":1,"1093":1,"1096":1}}],["contacting",{"2":{"99":1}}],["contact",{"0":{"15":1,"534":1},"2":{"8":1,"15":1,"236":1,"248":1,"293":1,"534":1,"1178":3}}],["contamination",{"2":{"6":1}}],["combat",{"2":{"1391":1}}],["combinatorial",{"0":{"1090":1},"2":{"1086":1}}],["combination",{"2":{"938":1}}],["combinations",{"2":{"466":1}}],["combines",{"2":{"239":1,"429":1}}],["combine",{"2":{"191":1,"975":1}}],["combined",{"2":{"117":1,"146":1,"238":1,"404":1,"788":1,"1178":1,"1253":1}}],["combining",{"0":{"878":1},"2":{"124":1,"428":1}}],["comfortable",{"2":{"515":1}}],["coming",{"2":{"157":1,"1213":1}}],["comes",{"2":{"134":1}}],["committing",{"2":{"922":1}}],["committee",{"2":{"34":1,"157":1}}],["commas",{"2":{"688":1}}],["commands",{"2":{"420":1}}],["command",{"2":{"39":1}}],["comment",{"2":{"1459":1}}],["comments",{"2":{"688":2}}],["commemorative",{"2":{"1306":1}}],["commerce",{"2":{"1016":1,"1190":1,"1259":1}}],["commercially",{"2":{"236":1}}],["commercialdur",{"2":{"163":3}}],["commercial",{"0":{"163":1,"287":1,"533":1},"2":{"8":1,"161":1,"287":2,"533":1,"539":2,"836":3,"923":1,"1025":1,"1057":1,"1081":1,"1082":1,"1107":1,"1155":1,"1174":1,"1178":2,"1211":1,"1252":1,"1300":1,"1321":1,"1344":1,"1349":1,"1361":1,"1363":3,"1384":1,"1410":1}}],["common",{"0":{"140":1},"2":{"49":1,"137":2,"176":1,"202":1,"205":1,"296":1,"359":1,"376":1,"424":1,"479":1,"516":1,"524":1,"689":1,"767":1,"1103":1,"1125":1,"1272":3,"1392":1,"1445":1}}],["communicates",{"2":{"361":1,"1394":1}}],["communication",{"2":{"7":1,"862":1,"1000":1,"1367":1}}],["community",{"0":{"539":1,"922":1},"2":{"14":1,"45":1,"77":1,"78":1,"137":1,"205":1,"229":1,"284":1,"467":1,"539":3,"548":1,"574":1,"716":1,"722":1,"757":1,"812":1,"835":1,"836":2,"845":1,"913":1,"922":2,"923":1,"953":1,"1008":1,"1018":1,"1025":1,"1050":1,"1057":1,"1107":1,"1155":1,"1162":1,"1174":1,"1211":1,"1236":1,"1252":1,"1275":1,"1300":1,"1315":1,"1321":1,"1339":1,"1349":1,"1377":1,"1384":1,"1396":1,"1410":1}}],["compensate",{"2":{"1254":1}}],["compensated",{"0":{"1254":1},"2":{"1242":1,"1253":1,"1254":1}}],["compensation",{"0":{"1422":1},"2":{"1236":1,"1422":2}}],["competition",{"0":{"506":1},"1":{"507":1,"508":1,"509":1,"510":1,"511":1,"512":1,"513":1,"514":1,"515":1},"2":{"509":1,"510":1,"511":1,"513":1}}],["compromised",{"2":{"857":1}}],["compromise",{"2":{"522":1}}],["comprehensively",{"2":{"422":1}}],["comprehensive",{"0":{"1168":1,"1244":1,"1344":1,"1402":1},"1":{"1169":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1345":1,"1403":1,"1404":1,"1405":1,"1406":1},"2":{"10":1,"518":1,"520":1,"598":1,"614":1,"644":1,"648":1,"751":1,"934":1,"963":1,"1123":1,"1339":1,"1403":1}}],["computus",{"2":{"1225":1}}],["compute",{"2":{"909":1,"1008":1,"1040":1,"1093":2,"1220":1,"1266":1,"1280":1,"1303":1,"1309":1,"1363":1}}],["computesladeadline",{"2":{"1220":2}}],["computes",{"2":{"884":1,"902":1,"1053":1,"1054":1,"1062":1,"1344":1,"1345":2,"1352":1,"1358":1,"1360":1}}],["computeddata>",{"2":{"797":1}}],["computed",{"2":{"300":1,"423":1,"424":1,"428":1,"797":1,"1054":1,"1268":1,"1429":5}}],["computations",{"2":{"711":1,"1007":1}}],["computationally",{"2":{"407":2,"412":1}}],["computational",{"2":{"407":1}}],["computation",{"2":{"300":1,"409":1}}],["computing",{"0":{"529":1},"1":{"530":1,"531":1,"532":1,"533":1,"534":1},"2":{"8":1,"20":1,"96":1,"236":1,"248":2,"283":1,"293":1,"357":1,"406":1,"409":1,"424":2,"529":1,"922":1,"1007":1,"1362":1}}],["compound",{"0":{"732":1},"2":{"732":1}}],["component",{"2":{"139":1,"158":1,"765":1,"1125":1,"1319":1,"1445":1}}],["components",{"2":{"138":1,"158":1,"173":1,"184":1,"202":1,"224":2,"286":1,"351":2,"399":1,"622":1,"707":1,"732":1,"1125":1,"1315":2,"1319":1,"1436":1,"1443":1}}],["composite",{"0":{"241":1},"2":{"350":1,"788":1}}],["compose",{"2":{"138":1,"370":3}}],["composed",{"2":{"138":1,"140":1,"297":1,"357":1,"468":1}}],["composable",{"0":{"1090":1},"2":{"138":1,"1090":1}}],["composability",{"2":{"138":1}}],["compatible",{"2":{"618":1,"630":1}}],["compatibility",{"0":{"1108":1,"1117":1,"1376":1},"1":{"1109":1,"1110":1,"1111":1,"1112":1,"1113":1,"1114":1,"1115":1,"1116":1,"1117":1,"1118":2,"1119":2,"1120":1,"1121":1,"1122":1},"2":{"291":1,"367":1,"468":1,"514":1,"532":1,"539":1,"549":1,"565":2,"629":1,"635":1,"657":1,"668":1,"732":1,"760":1,"768":1,"771":2,"776":1,"778":1,"786":1,"832":1,"836":1,"842":1,"1092":1,"1098":1,"1099":1,"1105":2}}],["companion",{"2":{"514":1}}],["company",{"2":{"266":1,"974":1,"997":3,"1224":4}}],["compass",{"0":{"1358":1},"2":{"313":8,"458":2,"459":2,"460":3,"471":1,"1062":1,"1071":2,"1343":1,"1344":1,"1345":1,"1347":1,"1354":1,"1358":1,"1365":1}}],["compact",{"2":{"137":4,"138":9,"159":1,"216":3,"639":1,"743":2,"758":2,"899":1,"903":1,"1125":2,"1412":1}}],["comparable",{"2":{"412":1}}],["comparative",{"2":{"9":1}}],["comparisons",{"2":{"720":1}}],["comparison",{"0":{"406":1,"940":1,"953":1,"1098":1,"1120":1,"1125":1},"1":{"1121":1,"1122":1},"2":{"442":1,"471":1,"516":1,"1120":1}}],["comparing",{"2":{"174":2,"447":1,"1123":1}}],["compares",{"2":{"950":1}}],["compare",{"2":{"82":1,"442":1,"448":1}}],["compared",{"2":{"43":1,"469":1,"472":1,"902":1,"1125":1}}],["compilation",{"2":{"471":1,"694":1,"709":1,"913":1,"1106":1}}],["compiling",{"2":{"44":1}}],["compile",{"2":{"774":1,"793":1,"1150":1}}],["compiler",{"2":{"709":1}}],["compilers",{"2":{"468":1}}],["compiled",{"2":{"6":1,"243":2,"246":1,"468":1,"669":1,"724":1,"776":1,"798":1,"855":1,"856":2,"1106":2,"1120":1,"1144":1}}],["compiles",{"2":{"5":1,"363":1,"1135":1}}],["compliant",{"2":{"1144":1,"1223":1}}],["compliance",{"0":{"1142":1},"1":{"1143":1,"1144":1},"2":{"1388":1}}],["complicates",{"2":{"43":1}}],["complemented",{"2":{"763":1}}],["complement",{"2":{"516":1,"534":1}}],["complementary",{"2":{"405":1,"951":1}}],["completions",{"2":{"854":2,"859":1,"860":1,"912":1,"932":1,"955":1,"958":1,"959":1,"1010":1}}],["completion",{"2":{"490":1,"543":1,"831":1,"856":1,"1008":2,"1039":1}}],["completed",{"2":{"490":1,"494":1,"497":1,"625":1}}],["completes",{"2":{"334":1,"490":1,"493":1,"910":1,"983":1}}],["completely",{"2":{"139":1,"147":1,"216":1,"221":1,"360":1,"407":1,"416":1,"447":1,"453":1,"465":1,"468":1,"479":1,"643":1,"651":1,"712":1,"716":1,"729":1,"731":1,"737":1,"836":1,"870":1,"875":1,"923":1,"925":1,"972":1,"1025":1,"1057":1,"1098":1,"1107":1,"1155":1,"1174":1,"1211":1,"1252":1,"1300":1,"1321":1,"1349":1,"1384":1,"1410":1,"1444":1}}],["complete",{"0":{"324":1},"2":{"76":1,"103":1,"146":1,"321":1,"370":1,"679":1,"704":1,"778":1,"904":1,"915":1,"1033":1,"1047":1,"1086":1,"1273":1,"1278":1,"1281":1,"1284":1,"1314":1,"1372":1}}],["complexities",{"2":{"527":1,"921":1}}],["complexity",{"2":{"43":1,"446":1,"526":1,"668":1}}],["complex",{"0":{"146":1,"225":1},"2":{"43":1,"191":1,"192":1,"236":1,"248":1,"266":1,"281":1,"283":1,"293":1,"328":1,"342":1,"351":1,"377":1,"378":1,"400":1,"402":1,"416":1,"424":1,"440":1,"451":1,"472":1,"498":1,"500":1,"504":2,"510":1,"513":1,"515":1,"517":1,"519":1,"520":1,"525":1,"531":1,"532":1,"617":1,"649":1,"667":1,"679":1,"690":1,"731":1,"750":1,"806":1,"908":1,"909":2,"913":1,"951":1,"960":1,"1418":1}}],["com",{"2":{"4":1,"15":1,"21":1,"26":1,"27":2,"28":1,"31":1,"34":1,"247":2,"534":2,"692":1,"846":1,"854":1,"856":2,"859":1,"860":1,"931":1,"938":1,"953":1,"955":2,"997":2,"998":3,"1015":1,"1178":2,"1239":1,"1263":3,"1264":1}}],["wnw",{"2":{"1347":1}}],["w01",{"2":{"768":1}}],["w05",{"2":{"97":1}}],["wy",{"0":{"369":1},"2":{"369":1,"743":2,"768":1,"817":1}}],["wrong",{"2":{"191":1}}],["wrapped",{"2":{"298":1,"400":1,"404":2,"432":1,"453":2,"505":1,"738":1,"980":1}}],["wrappers",{"2":{"864":1,"998":1}}],["wrapper",{"2":{"270":1,"283":1,"408":1,"468":1,"469":1,"474":1,"480":1,"506":1,"514":1,"515":1,"516":1,"588":1,"750":1,"836":1,"854":1}}],["wrapping",{"2":{"169":1,"663":1}}],["wraps",{"2":{"156":1,"370":1,"477":1}}],["wrap",{"2":{"147":1,"235":1,"270":2,"286":1}}],["writableended",{"2":{"955":1}}],["writable",{"2":{"402":2,"426":1,"912":1}}],["written",{"2":{"203":3,"771":1,"776":1,"1086":1,"1091":1}}],["writing",{"0":{"293":1,"318":1},"1":{"319":1,"320":1,"321":1},"2":{"76":1,"84":1,"174":1,"525":1,"871":1,"881":1,"890":1,"899":1,"975":2,"1089":2,"1143":1,"1382":1}}],["writer",{"0":{"1369":1}}],["writes",{"2":{"453":1,"738":1,"1369":1}}],["writestore",{"2":{"110":2,"117":1}}],["write",{"2":{"27":1,"110":2,"111":1,"247":1,"266":1,"270":1,"293":1,"431":1,"468":1,"509":1,"517":1,"519":2,"738":1,"782":2}}],["would",{"2":{"329":1,"431":1,"1271":1,"1450":1}}],["wood",{"2":{"305":1}}],["won",{"2":{"157":1,"198":1,"481":1}}],["wom",{"2":{"137":1,"138":6}}],["woy",{"0":{"187":1,"188":1,"768":1},"1":{"188":1,"189":1,"190":1},"2":{"137":2,"138":8,"152":2,"186":1,"187":1,"188":1,"189":2,"370":3,"763":5,"768":5,"1089":2,"1093":2,"1098":2,"1125":1}}],["worry",{"2":{"265":1}}],["wordpress",{"2":{"1103":2,"1123":1}}],["wording",{"2":{"729":1}}],["wordlist",{"2":{"407":1,"416":3}}],["words",{"2":{"125":3,"221":1,"223":1,"294":1,"431":1,"647":1,"737":2,"738":1,"763":1,"767":1,"771":1,"776":1,"1096":1}}],["word",{"0":{"125":1},"2":{"117":1,"125":1,"145":1,"203":1,"219":1,"240":1,"297":2,"544":2,"776":1}}],["world",{"2":{"83":1,"140":1,"230":1,"270":1,"326":1,"365":1,"366":1,"451":1,"525":1,"526":1,"1026":1,"1097":1,"1137":1,"1212":1,"1218":1,"1242":1,"1362":1}}],["worlds",{"0":{"43":1,"270":1,"429":1}}],["workweeks",{"2":{"1207":1}}],["workload",{"2":{"1039":1}}],["workloads",{"2":{"407":1,"1018":1}}],["workerid",{"2":{"1389":1}}],["workerdata",{"2":{"1370":1,"1381":2,"1389":3}}],["worker",{"0":{"860":1,"1037":1,"1041":1,"1370":1,"1381":1,"1386":1},"1":{"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1,"1387":1,"1388":1,"1389":1},"2":{"858":1,"860":2,"1005":1,"1018":1,"1019":1,"1021":1,"1022":1,"1024":2,"1029":4,"1036":1,"1037":1,"1039":1,"1041":5,"1368":2,"1370":2,"1373":1,"1376":1,"1377":1,"1381":2,"1382":6,"1383":1,"1387":2,"1388":5,"1389":9,"1392":2}}],["workerscriptpath",{"2":{"1389":2}}],["workers",{"2":{"857":1,"861":1,"913":1,"978":1,"1019":1,"1030":1,"1033":1,"1039":1,"1040":2,"1193":1,"1368":1,"1377":1,"1379":1,"1387":1,"1389":3,"1391":2,"1392":2,"1395":1}}],["workflow",{"2":{"635":2,"1364":1}}],["workflows",{"2":{"480":1,"489":1,"929":1,"1011":1,"1015":1,"1274":1,"1299":1,"1422":1}}],["workinghoursuntil",{"0":{"1203":1},"2":{"1203":1,"1204":1,"1207":1,"1209":1,"1210":1,"1220":1}}],["workinghours",{"2":{"988":1,"989":1,"1015":1}}],["working",{"0":{"1195":1,"1202":1},"1":{"1203":1,"1204":1},"2":{"231":1,"768":1,"877":1,"879":1,"880":1,"882":1,"884":1,"987":2,"993":1,"1015":1,"1147":1,"1194":1,"1197":1,"1199":1,"1203":5,"1204":1,"1205":4,"1206":1,"1207":2,"1209":1,"1210":1,"1219":1,"1220":1,"1222":1,"1223":1,"1224":1}}],["workbench",{"2":{"83":1}}],["workstations",{"2":{"1394":1}}],["workstation",{"2":{"874":1,"989":1}}],["works",{"0":{"220":1,"399":1,"412":1,"414":1,"416":1,"418":1,"427":1,"465":1},"2":{"39":1,"98":1,"135":1,"210":1,"222":1,"288":1,"551":1,"739":1}}],["workspaces",{"2":{"760":1}}],["workspace",{"0":{"874":1},"2":{"3":1,"27":1,"669":1,"702":1,"708":1,"709":1}}],["work",{"0":{"1204":1},"2":{"16":1,"34":1,"137":1,"407":1,"416":1,"816":1,"1256":1,"1443":1}}],["wkd",{"2":{"64":2,"76":1,"127":1,"137":1,"138":1,"140":2,"147":2,"153":1,"191":4,"240":1,"370":1,"731":2,"734":2,"735":2,"1095":1,"1125":1}}],["www",{"2":{"137":1,"153":1,"231":1,"240":1,"242":3,"1125":1,"1418":1}}],["ww",{"2":{"64":1,"137":1,"138":3,"152":2,"191":1,"719":1,"734":1,"743":1,"758":1,"768":1,"1089":2,"1125":5,"1413":2}}],["wire",{"2":{"759":1,"853":1}}],["wiring",{"2":{"373":1}}],["wiping",{"2":{"425":1,"833":1}}],["widget",{"2":{"1378":1}}],["widely",{"2":{"1094":1}}],["wide",{"2":{"410":1,"420":1,"1351":2,"1366":1}}],["width",{"2":{"138":5,"819":1,"1090":1}}],["wish",{"2":{"954":1}}],["wishing",{"2":{"275":1}}],["wise",{"2":{"305":1}}],["wildly",{"2":{"1139":1}}],["wildlife",{"0":{"1085":1},"2":{"1085":1}}],["wildcards",{"2":{"205":1,"804":1}}],["wildcard",{"0":{"205":1,"806":1},"2":{"205":1,"806":1}}],["will",{"2":{"23":2,"24":1,"39":1,"43":1,"46":1,"47":1,"76":1,"109":1,"110":1,"120":2,"125":1,"138":2,"139":1,"146":1,"152":1,"161":2,"166":1,"174":1,"191":1,"195":1,"219":1,"220":1,"230":1,"234":1,"246":1,"265":1,"271":1,"274":1,"276":1,"278":1,"281":1,"295":1,"296":1,"300":2,"316":1,"326":1,"327":1,"331":1,"351":1,"357":1,"358":1,"359":2,"377":2,"398":1,"429":1,"451":1,"481":1,"484":1,"486":1,"495":1,"505":1,"514":1,"565":1,"637":1,"707":1,"759":1,"768":1,"853":1,"856":1,"874":1,"878":1,"931":1,"970":2,"973":1,"1091":1,"1185":1,"1188":1,"1219":1,"1259":1,"1266":1,"1372":1,"1415":1,"1428":1,"1429":1}}],["winning",{"2":{"752":1}}],["wins",{"0":{"468":1,"508":1},"1":{"509":1,"510":1,"511":1,"512":1,"513":1},"2":{"219":1,"461":1,"946":1}}],["wintersouth",{"2":{"1046":4}}],["winter",{"2":{"73":2,"304":1,"313":2,"326":2,"455":2,"456":2,"519":2,"1046":6,"1072":1}}],["windowshift",{"2":{"1033":2}}],["windows",{"0":{"1083":1,"1204":1},"2":{"91":1,"1032":1,"1052":1,"1082":1,"1083":1,"1084":1,"1207":1,"1328":1}}],["window",{"0":{"1231":1},"2":{"26":1,"45":3,"479":1,"722":3,"942":2,"989":1,"1033":1,"1081":1,"1243":1,"1417":1,"1448":1}}],["withresolvers",{"2":{"474":1,"480":1}}],["withcalendar",{"2":{"146":1}}],["withtimezone",{"2":{"146":2}}],["without",{"2":{"41":1,"44":1,"52":1,"84":1,"87":1,"95":1,"97":1,"99":1,"110":1,"118":1,"119":1,"131":1,"138":2,"139":2,"144":1,"149":1,"158":1,"161":1,"169":1,"188":1,"197":1,"202":1,"205":1,"220":1,"261":1,"265":1,"296":1,"300":1,"316":1,"325":1,"326":1,"327":1,"328":1,"356":1,"370":1,"402":1,"409":1,"427":1,"439":1,"444":1,"446":1,"465":1,"466":1,"468":1,"471":1,"476":2,"486":1,"488":1,"503":1,"513":1,"514":1,"515":1,"519":1,"525":1,"528":1,"536":1,"539":1,"543":1,"558":1,"634":1,"643":1,"644":1,"647":1,"649":1,"651":1,"667":1,"676":1,"677":1,"688":1,"711":1,"716":1,"752":1,"776":1,"778":1,"780":1,"787":1,"797":1,"802":1,"806":2,"816":1,"818":1,"833":1,"838":1,"845":1,"855":1,"856":2,"869":1,"910":1,"918":1,"922":1,"932":1,"933":1,"942":1,"954":1,"974":1,"980":1,"1004":2,"1011":1,"1012":1,"1045":1,"1049":1,"1054":1,"1067":1,"1085":1,"1097":1,"1109":1,"1118":1,"1125":2,"1134":1,"1141":1,"1147":1,"1188":1,"1189":1,"1224":1,"1233":1,"1257":1,"1262":1,"1270":1,"1290":1,"1313":1,"1324":1,"1329":1,"1363":1,"1369":1,"1376":1,"1395":2,"1421":1,"1422":1,"1435":1,"1438":1,"1446":1}}],["within",{"2":{"23":2,"137":1,"138":2,"150":2,"152":1,"177":1,"224":1,"260":1,"281":1,"301":1,"311":1,"327":1,"342":1,"351":1,"381":1,"387":2,"446":1,"470":1,"643":1,"681":1,"858":1,"882":1,"911":1,"927":1,"942":1,"946":1,"989":1,"993":1,"998":1,"1008":1,"1015":1,"1039":1,"1079":1,"1112":1,"1178":1,"1219":2,"1329":1,"1334":1,"1335":3,"1344":1,"1345":1,"1364":3,"1395":1,"1433":1,"1459":1}}],["with",{"0":{"37":1,"38":1,"246":1,"266":1,"273":1,"285":1,"426":1,"484":1,"491":1,"493":1,"878":1,"1161":1,"1171":1,"1235":1,"1260":1,"1445":1},"1":{"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1,"284":1,"285":1,"286":1,"287":1,"288":1,"289":1,"290":1,"291":1,"292":1,"293":1,"427":1,"428":1},"2":{"1":1,"6":1,"8":1,"9":1,"10":1,"12":2,"23":1,"33":1,"34":1,"39":1,"41":1,"43":1,"46":1,"76":1,"83":2,"85":1,"87":1,"89":2,"92":1,"97":1,"98":1,"99":1,"104":1,"107":1,"109":2,"112":1,"116":1,"117":1,"119":1,"122":1,"125":1,"128":1,"131":2,"134":1,"138":7,"139":3,"146":1,"148":1,"158":2,"181":1,"202":2,"203":1,"205":2,"209":1,"213":1,"215":1,"216":1,"224":1,"227":1,"228":1,"229":2,"230":1,"233":1,"238":1,"243":2,"247":1,"249":1,"259":1,"264":1,"266":1,"270":2,"273":1,"274":3,"276":2,"285":1,"287":1,"288":1,"289":1,"300":2,"301":2,"315":3,"317":1,"321":1,"325":1,"326":3,"330":2,"331":2,"334":1,"345":1,"366":1,"367":1,"368":1,"370":3,"388":1,"402":1,"403":1,"404":1,"407":1,"414":1,"418":1,"421":1,"424":1,"425":2,"428":1,"429":2,"430":1,"435":1,"439":1,"440":1,"444":1,"453":1,"456":1,"464":1,"465":1,"468":3,"471":1,"473":1,"475":1,"477":5,"483":2,"486":2,"489":1,"490":1,"492":1,"503":1,"516":1,"519":1,"522":1,"526":1,"527":1,"531":1,"534":2,"540":1,"546":1,"560":1,"561":1,"565":1,"567":1,"572":1,"573":1,"588":1,"592":1,"594":1,"600":1,"601":1,"606":2,"609":2,"612":2,"613":1,"616":1,"617":1,"620":2,"621":1,"622":2,"623":1,"629":1,"634":2,"637":1,"640":2,"642":2,"644":1,"648":1,"649":1,"651":1,"653":1,"655":2,"666":2,"671":2,"673":1,"681":2,"687":1,"688":1,"691":1,"701":1,"707":1,"708":1,"709":1,"712":1,"719":1,"726":1,"729":1,"737":1,"743":1,"751":1,"763":1,"765":2,"767":1,"768":2,"771":3,"775":2,"776":2,"778":1,"782":1,"786":1,"792":2,"793":1,"798":1,"812":2,"817":1,"819":1,"823":1,"827":2,"856":1,"860":1,"864":3,"865":1,"866":1,"867":2,"891":1,"894":1,"896":1,"898":1,"905":1,"907":1,"910":1,"912":1,"919":1,"920":1,"929":1,"930":1,"932":1,"933":1,"934":1,"936":1,"937":1,"938":1,"942":1,"948":1,"950":2,"953":1,"954":1,"955":3,"971":1,"972":1,"973":2,"974":1,"975":1,"977":1,"978":1,"989":1,"993":2,"994":2,"997":5,"1000":4,"1003":1,"1008":2,"1009":1,"1012":2,"1014":1,"1016":1,"1017":1,"1021":1,"1039":2,"1041":1,"1055":1,"1067":1,"1073":1,"1077":1,"1080":1,"1090":1,"1095":1,"1098":1,"1103":2,"1104":2,"1110":1,"1113":2,"1116":1,"1118":1,"1120":1,"1125":1,"1139":1,"1140":1,"1141":2,"1144":1,"1147":1,"1150":1,"1156":1,"1158":1,"1167":1,"1168":1,"1169":1,"1171":1,"1173":1,"1178":2,"1182":1,"1191":1,"1192":1,"1194":1,"1207":1,"1213":1,"1215":3,"1219":1,"1220":1,"1226":1,"1235":1,"1242":1,"1253":1,"1261":1,"1263":1,"1265":1,"1267":1,"1269":2,"1276":4,"1294":1,"1307":1,"1312":1,"1313":2,"1318":1,"1328":1,"1329":1,"1331":1,"1332":1,"1344":2,"1355":1,"1362":1,"1363":1,"1366":1,"1369":1,"1370":1,"1373":1,"1374":1,"1378":1,"1381":1,"1387":1,"1392":2,"1394":1,"1396":2,"1401":1,"1417":1,"1422":3,"1423":1,"1429":1,"1442":1,"1443":1,"1444":3,"1445":1,"1447":1,"1448":2}}],["wholly",{"2":{"560":1}}],["whole",{"2":{"129":1,"158":2}}],["whose",{"2":{"314":1,"408":1,"465":1,"1422":1}}],["who",{"2":{"229":1,"357":1,"528":1,"675":1,"1273":1,"1450":1}}],["whitelists",{"2":{"1263":1}}],["whitelist",{"2":{"1240":1,"1263":1}}],["whitespace",{"2":{"690":1}}],["which",{"0":{"515":1,"1167":1},"2":{"39":1,"41":1,"43":1,"71":1,"101":1,"102":1,"128":1,"161":1,"210":1,"233":1,"276":2,"296":1,"301":1,"337":1,"339":1,"346":1,"352":1,"375":1,"412":1,"427":1,"431":1,"437":1,"456":1,"502":1,"512":1,"541":1,"716":1,"729":1,"732":1,"738":1,"989":1,"1093":1,"1136":1,"1232":1,"1234":1,"1271":1,"1366":1}}],["while",{"2":{"11":1,"43":2,"109":1,"137":2,"146":2,"150":1,"157":1,"167":1,"184":1,"188":1,"189":2,"195":1,"196":1,"221":1,"230":1,"233":1,"235":1,"262":1,"273":1,"278":1,"281":1,"282":1,"300":1,"326":1,"367":1,"381":1,"404":1,"408":1,"412":1,"414":1,"418":1,"430":1,"439":1,"440":2,"451":2,"465":1,"470":1,"479":1,"503":1,"506":1,"513":1,"514":1,"516":2,"518":1,"524":1,"527":1,"535":1,"549":1,"556":1,"643":1,"668":1,"690":1,"705":1,"711":1,"771":1,"832":1,"868":1,"879":1,"897":1,"909":1,"922":1,"932":1,"936":1,"964":1,"975":1,"978":1,"993":1,"1004":1,"1008":1,"1017":1,"1067":1,"1088":2,"1089":1,"1093":1,"1096":1,"1098":1,"1103":1,"1110":1,"1111":1,"1120":1,"1125":1,"1136":1,"1158":1,"1190":1,"1223":1,"1331":1,"1442":1,"1445":1}}],["whereas",{"2":{"109":1,"137":1,"138":1,"296":1,"1093":1}}],["where",{"2":{"44":1,"101":1,"109":1,"124":1,"129":1,"164":1,"199":1,"215":2,"265":1,"301":2,"328":1,"351":1,"370":1,"377":1,"386":1,"410":1,"474":1,"480":1,"498":1,"522":1,"631":1,"702":1,"726":1,"833":1,"931":1,"948":1,"949":1,"950":1,"968":1,"983":1,"1004":1,"1005":1,"1026":1,"1040":1,"1062":1,"1071":1,"1088":1,"1094":2,"1117":1,"1137":1,"1167":1,"1338":1,"1367":1,"1385":1,"1412":1}}],["whether",{"2":{"33":1,"63":1,"93":1,"96":1,"283":1,"336":1,"379":1,"861":1,"909":1,"1088":1,"1095":1,"1249":1,"1309":1,"1334":1,"1336":1,"1344":3}}],["whenever",{"2":{"216":1,"414":1,"649":1,"738":1,"1394":1}}],["when",{"0":{"96":1,"204":1},"1":{"97":1},"2":{"27":1,"30":1,"44":1,"46":1,"52":1,"77":1,"89":2,"93":1,"94":1,"97":3,"109":1,"114":2,"116":1,"120":1,"124":2,"127":1,"129":1,"131":1,"133":1,"142":1,"145":1,"146":1,"157":1,"158":1,"160":1,"161":3,"169":1,"173":1,"174":1,"178":1,"186":1,"189":1,"193":1,"199":1,"200":1,"202":1,"208":1,"216":1,"220":1,"226":1,"228":1,"233":1,"239":1,"240":1,"245":1,"247":1,"250":1,"256":1,"262":1,"263":1,"264":1,"266":1,"269":1,"272":1,"276":1,"279":1,"281":1,"282":2,"283":1,"298":1,"315":2,"321":1,"326":2,"331":1,"333":1,"334":2,"336":1,"337":1,"338":1,"341":1,"357":2,"361":1,"362":1,"363":1,"364":2,"365":1,"367":1,"369":1,"370":2,"374":1,"375":1,"376":1,"377":1,"385":1,"386":1,"387":2,"388":1,"393":1,"394":1,"402":1,"403":1,"404":1,"409":1,"411":1,"412":1,"416":2,"421":1,"424":1,"429":1,"434":1,"440":1,"450":1,"454":1,"455":1,"468":1,"475":1,"483":2,"491":1,"493":1,"498":1,"512":1,"536":1,"538":1,"549":1,"607":1,"631":1,"645":1,"668":1,"699":1,"702":4,"707":1,"737":1,"738":1,"748":1,"774":1,"782":2,"792":1,"850":1,"854":1,"855":1,"856":1,"886":1,"912":5,"925":2,"932":1,"934":2,"936":1,"954":1,"958":1,"965":1,"966":1,"972":3,"973":1,"983":1,"985":1,"993":1,"998":1,"1001":1,"1007":1,"1008":1,"1011":2,"1012":1,"1015":1,"1022":2,"1039":1,"1040":1,"1045":1,"1054":3,"1055":1,"1061":1,"1064":2,"1071":4,"1072":2,"1077":2,"1078":1,"1079":1,"1082":1,"1084":1,"1086":1,"1089":1,"1092":1,"1094":1,"1110":1,"1126":1,"1134":1,"1136":1,"1157":1,"1158":1,"1179":1,"1183":1,"1190":1,"1214":1,"1222":1,"1223":1,"1227":2,"1240":1,"1253":1,"1254":1,"1262":1,"1265":1,"1315":1,"1362":1,"1364":1,"1372":2,"1374":1,"1389":1,"1392":1,"1417":1,"1422":3,"1425":3,"1428":1,"1435":1,"1439":2,"1442":2,"1443":1,"1445":2,"1447":1,"1448":2,"1450":1,"1452":1,"1459":1}}],["whatsoever",{"2":{"1091":1}}],["whatever",{"2":{"225":1}}],["what",{"0":{"22":1,"72":1,"96":1,"221":1,"238":1,"239":1,"301":1,"704":1,"707":1,"711":1,"716":1,"719":1,"720":1,"722":1,"723":1,"728":1,"731":1,"734":1,"737":1,"741":1,"743":1,"746":1,"750":1,"754":1,"758":1},"1":{"97":1},"2":{"45":1,"260":1,"321":2,"349":1,"424":1,"498":1,"519":1,"522":1,"675":1,"716":1,"1278":1}}],["why",{"0":{"11":1,"198":1,"508":1,"909":1,"1121":1,"1450":1},"1":{"12":1,"509":1,"510":1,"511":1,"512":1,"513":1},"2":{"139":1,"147":1,"191":1,"342":1,"406":1,"452":1,"503":1,"1086":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1105":2}}],["wake",{"2":{"1444":1}}],["wa",{"2":{"1213":1}}],["waitangi",{"2":{"1213":1}}],["wait",{"2":{"1178":3}}],["waiters",{"2":{"489":2,"495":1,"792":1}}],["waiter",{"2":{"489":1}}],["waning",{"2":{"1059":4}}],["wants",{"2":{"321":1}}],["want",{"0":{"552":1},"2":{"10":1,"43":1,"45":1,"128":1,"131":1,"138":1,"139":1,"146":1,"161":2,"163":1,"170":1,"197":1,"217":1,"229":1,"231":1,"235":1,"265":1,"271":1,"358":1,"515":2,"528":1,"977":1}}],["waxing",{"2":{"1055":2,"1059":4,"1060":2}}],["walking",{"2":{"664":1}}],["wall",{"0":{"1255":1},"2":{"189":1,"617":1,"1254":1,"1413":1,"1419":1,"1439":1}}],["warehouse",{"2":{"1224":1,"1364":1}}],["warranty",{"2":{"922":1}}],["warm",{"2":{"407":1,"419":2,"524":1,"1071":1,"1084":1}}],["warn",{"2":{"117":1,"281":4,"282":1,"631":1,"950":1,"970":1,"973":1,"996":1,"1077":1,"1389":1,"1424":1,"1448":1}}],["warnings",{"0":{"1188":1},"2":{"282":1,"341":1,"669":1,"738":1,"747":1,"748":1,"802":2,"1041":2,"1166":1,"1183":1}}],["warning",{"0":{"857":1},"2":{"34":1,"46":1,"89":1,"109":1,"131":1,"191":1,"198":1,"202":1,"213":1,"219":1,"243":1,"261":1,"281":1,"295":1,"327":1,"388":2,"481":1,"909":1,"972":1,"980":1,"1054":1,"1077":1}}],["washington",{"2":{"1213":1}}],["waste",{"2":{"1262":1}}],["wasted",{"2":{"942":1}}],["wasteful",{"2":{"424":1}}],["was",{"2":{"225":1,"349":2,"402":2,"452":1,"458":1,"512":1,"567":1,"709":1,"738":2,"836":1,"855":1,"891":1,"986":1,"992":1,"1088":1,"1221":1,"1271":1}}],["water",{"2":{"1076":1,"1080":1,"1083":2}}],["waterfalls",{"2":{"43":1}}],["waterfall",{"2":{"42":1}}],["watch",{"2":{"6":1}}],["ways",{"2":{"257":1,"308":1,"520":1,"967":1}}],["way",{"2":{"42":1,"124":1,"169":2,"230":1,"232":1,"258":1,"293":1,"309":1,"387":1,"390":1,"556":1,"711":1,"728":2}}],["weather",{"2":{"1084":1}}],["weak",{"0":{"797":2},"2":{"795":1,"797":1,"798":1,"1442":1,"1445":1}}],["weakref",{"2":{"505":1,"1442":1}}],["weakset",{"2":{"505":1}}],["weakcache",{"0":{"476":1},"2":{"476":1}}],["weakmap",{"2":{"340":1,"505":1}}],["wet",{"2":{"1063":1}}],["west",{"2":{"1062":1,"1071":1,"1273":1,"1338":1,"1358":1}}],["western",{"2":{"305":1,"315":1,"1336":1,"1366":1}}],["welcome",{"2":{"922":1}}],["well",{"0":{"773":1},"2":{"213":1,"253":1,"322":2,"536":1,"689":1,"773":1,"884":1,"933":1,"1108":1}}],["weihnachtstag",{"2":{"1213":2}}],["weirdness",{"2":{"512":1}}],["weight",{"2":{"415":1,"505":1}}],["wed",{"2":{"203":2,"392":1,"394":1,"395":1,"396":1,"397":1,"398":1,"454":1,"1199":1}}],["wednesdays",{"2":{"390":1,"396":1,"397":1}}],["wednesday",{"0":{"203":1},"1":{"204":1},"2":{"186":1,"203":2,"204":2,"368":2,"392":1,"393":1,"394":2,"771":1,"776":1,"859":1,"946":1,"987":1,"988":1,"993":1,"1013":1,"1220":1,"1221":1,"1222":2}}],["were",{"2":{"128":1,"173":1,"442":1,"506":1,"554":1,"556":1,"567":1,"573":1,"631":1,"702":1,"737":1,"1054":1,"1105":1,"1268":1,"1272":1,"1273":1,"1312":2}}],["weeklyteamsync",{"2":{"1418":1}}],["weekdaymap",{"2":{"752":1}}],["weekdaysync",{"2":{"1417":1}}],["weekdays",{"2":{"203":2,"219":1,"220":1,"222":1,"228":1,"363":2,"453":1,"458":1,"471":1,"737":1,"754":1}}],["weekday",{"0":{"390":1,"392":1},"1":{"391":1,"392":1,"393":1,"394":1,"395":1,"396":1,"397":1,"398":1,"399":1},"2":{"137":2,"138":1,"146":1,"147":1,"152":1,"153":2,"189":1,"203":1,"221":1,"233":1,"235":1,"240":2,"390":1,"391":2,"392":1,"393":1,"394":1,"398":2,"399":2,"454":1,"458":1,"460":1,"461":5,"731":1,"752":1,"911":4,"1012":1,"1089":1,"1095":2,"1125":6}}],["week",{"0":{"152":1,"186":1,"187":1,"188":1,"768":1,"1093":1},"1":{"188":1,"189":1,"190":1},"2":{"117":2,"137":9,"138":25,"152":3,"163":1,"186":10,"187":1,"188":5,"189":7,"190":3,"205":1,"233":1,"324":1,"365":2,"368":5,"369":1,"370":11,"393":5,"395":4,"743":2,"763":6,"768":5,"817":2,"893":1,"902":2,"909":1,"911":1,"1032":1,"1088":9,"1089":2,"1093":8,"1098":2,"1110":3,"1125":7,"1189":1,"1319":1,"1416":1}}],["weekends",{"2":{"231":1,"366":1,"882":1,"1197":1,"1207":1,"1209":1,"1218":1,"1220":1,"1221":1,"1223":1}}],["weekend",{"0":{"71":1,"1205":1},"2":{"71":6,"365":3,"367":2,"531":1,"786":1,"817":1,"884":1,"1158":1,"1195":3,"1197":1,"1203":3,"1205":4,"1206":1,"1207":2,"1213":1,"1218":1,"1221":1,"1222":2,"1224":1}}],["weeksinyear",{"2":{"233":1}}],["weeks",{"2":{"59":1,"137":1,"158":3,"188":1,"221":1,"245":1,"366":1,"370":1,"393":1,"396":1,"399":1,"957":1,"982":1,"1023":2,"1032":1,"1205":1,"1413":2,"1447":1}}],["webpreferences",{"2":{"1376":1}}],["webpack",{"0":{"104":1},"2":{"41":1,"43":1,"102":1}}],["webaudio",{"2":{"1331":1,"1394":1}}],["webhooks",{"2":{"1139":1,"1263":1}}],["webhook",{"0":{"1138":1},"1":{"1139":1,"1140":1,"1141":1},"2":{"1105":1,"1140":1,"1141":4}}],["webtoken",{"2":{"841":1}}],["websocket",{"2":{"1388":1}}],["webstorage",{"2":{"503":1}}],["websites",{"2":{"1084":1}}],["website",{"2":{"13":1,"1375":1}}],["web",{"0":{"955":1},"2":{"29":1,"946":1,"953":1,"1005":2,"1110":1,"1255":1,"1258":1,"1368":1,"1375":1,"1376":1,"1377":1}}],["we",{"0":{"72":1},"2":{"6":1,"20":1,"23":2,"34":1,"47":1,"75":2,"177":1,"229":2,"231":1,"233":1,"235":1,"265":1,"266":1,"270":1,"293":1,"313":1,"407":1,"426":1,"427":1,"438":1,"522":1,"529":1,"531":1,"533":1,"549":1,"559":1,"729":1,"857":1,"913":1,"921":1,"922":1,"972":1,"1005":1,"1013":1,"1086":2,"1092":2,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1098":1,"1418":1}}],["w",{"2":{"5":1,"138":3,"768":1,"1389":2}}],["mwf",{"2":{"1418":1}}],["mfa",{"2":{"1363":1}}],["mph",{"2":{"1360":2}}],["mlk",{"2":{"1213":1}}],["mnemonic",{"0":{"1096":1}}],["mqtt",{"2":{"1029":1}}],["mcmxciv",{"2":{"763":1,"766":1}}],["mjs",{"2":{"538":1,"836":1,"839":1}}],["mts",{"2":{"538":1,"836":1,"839":1}}],["mth",{"2":{"166":2}}],["mb",{"2":{"450":4,"451":1}}],["m10",{"2":{"149":1}}],["ms`",{"2":{"1243":2,"1254":1}}],["mst",{"2":{"296":1,"1096":1}}],["msg",{"2":{"281":3}}],["ms",{"2":{"117":2,"137":1,"138":2,"151":1,"154":1,"418":1,"567":1,"979":1,"1030":1,"1069":1,"1072":2,"1089":2,"1114":1,"1125":1,"1192":1,"1223":4,"1240":1,"1243":1,"1261":4,"1264":1,"1265":2,"1266":1,"1316":1,"1319":2,"1332":6,"1379":1,"1381":1,"1444":1}}],["m",{"2":{"78":1,"138":2,"139":2,"227":1,"707":2,"870":1,"1089":3,"1090":4,"1101":2,"1103":4,"1104":3,"1112":1,"1115":2,"1116":5,"1120":1,"1125":7,"1129":3,"1134":1,"1144":4,"1149":2,"1150":2,"1273":1,"1280":1,"1292":1,"1312":1,"1313":4,"1335":1,"1344":2,"1356":1,"1357":2,"1364":1}}],["meltdown",{"2":{"1375":1}}],["melb",{"2":{"1214":5}}],["melbourne",{"2":{"877":1,"951":1,"955":1,"1191":1,"1213":1,"1214":1,"1357":5}}],["mental",{"2":{"1089":1,"1224":1}}],["mentioned",{"2":{"891":1}}],["mention",{"2":{"878":1}}],["meeus",{"2":{"1045":1,"1052":1}}],["meet",{"2":{"407":1,"1013":1}}],["meetinginterval",{"2":{"1412":1}}],["meeting",{"0":{"1421":1},"2":{"169":1,"170":1,"176":2,"224":2,"225":2,"875":1,"888":1,"890":1,"894":2,"955":1,"988":1,"989":1,"992":1,"994":1,"997":3,"1013":1,"1326":1,"1401":1,"1412":1,"1418":1,"1421":1}}],["medieval",{"2":{"1309":1}}],["medical",{"2":{"531":1,"922":1}}],["medium",{"2":{"129":1,"1011":2,"1067":1}}],["message",{"2":{"955":1,"1377":1,"1387":1}}],["messages",{"2":{"484":1,"661":1,"860":2,"1042":1,"1394":1}}],["messy",{"2":{"468":1,"525":1}}],["measures",{"2":{"1351":1}}],["measurements",{"2":{"1233":1}}],["measurement",{"2":{"451":1}}],["measureddriftms",{"2":{"1265":1}}],["measured",{"2":{"419":2,"1069":1,"1254":1,"1422":1}}],["measure",{"2":{"378":1,"442":1,"446":1,"449":1,"520":1,"1246":1}}],["meant",{"2":{"219":1,"329":1}}],["mean",{"2":{"139":2}}],["means",{"2":{"137":1,"148":1,"158":1,"169":1,"202":1,"215":1,"220":1,"269":1,"296":1,"300":1,"739":1}}],["meaning",{"2":{"43":1,"383":1,"393":1,"395":1,"407":1,"469":1,"526":1,"1270":1}}],["member",{"2":{"340":1,"546":1}}],["memorial",{"2":{"1213":1}}],["memorizing",{"2":{"1090":1}}],["memorize",{"2":{"1090":1}}],["memorable",{"2":{"1096":1}}],["memory",{"0":{"336":1,"476":1,"864":1,"1003":1,"1367":1,"1368":1},"1":{"1368":1,"1369":2,"1370":2,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1},"2":{"300":1,"336":1,"373":1,"406":1,"411":1,"422":1,"423":1,"427":1,"447":1,"449":2,"450":1,"451":3,"475":1,"476":2,"495":1,"504":1,"505":2,"514":1,"519":1,"616":1,"649":1,"702":1,"797":1,"863":1,"895":1,"904":1,"926":1,"936":1,"937":1,"978":1,"994":1,"998":2,"1004":1,"1011":1,"1018":1,"1029":1,"1038":1,"1039":2,"1041":1,"1106":1,"1121":1,"1187":1,"1213":1,"1215":1,"1225":1,"1235":1,"1267":1,"1368":2,"1369":1,"1371":1,"1381":1,"1382":1,"1383":2,"1389":1,"1431":1,"1442":1,"1443":2,"1445":1}}],["memoize",{"2":{"426":2,"755":1}}],["memoizes",{"2":{"409":1,"426":1,"513":1,"1161":1}}],["memoized",{"0":{"266":1},"2":{"230":1,"266":1,"268":1,"293":1,"327":1,"367":2,"372":1,"373":1,"429":1,"444":1,"606":1,"754":1,"798":1}}],["memoization",{"0":{"426":1},"1":{"427":1,"428":1},"2":{"326":1,"371":1,"409":1,"410":1,"427":1,"428":1,"476":1,"672":1,"795":1}}],["memoised",{"2":{"300":1}}],["meridian",{"2":{"1052":1,"1053":1,"1058":1,"1061":2,"1068":1,"1069":1,"1075":1,"1078":1,"1080":1,"1338":1,"1343":1,"1344":1,"1350":1,"1351":2,"1352":1,"1353":2}}],["meridiem",{"0":{"139":1},"2":{"137":2,"138":2,"139":7,"245":1,"370":1,"707":2,"1125":1}}],["mermaid",{"2":{"867":1}}],["merging",{"2":{"440":1,"562":1,"633":1,"667":1,"747":1,"830":1,"856":1,"1001":1,"1449":1}}],["merged",{"2":{"115":2,"737":1,"829":1}}],["merges",{"2":{"111":1,"129":1,"298":1,"856":1}}],["merge",{"0":{"298":1,"440":1},"2":{"101":1,"125":1,"262":1,"298":1,"331":1,"440":1,"631":1,"634":1,"744":1,"1146":1}}],["mercredi",{"2":{"372":2}}],["merely",{"2":{"191":1}}],["mer",{"2":{"137":1,"138":3,"139":3,"144":1,"245":1,"894":1,"1113":2,"1125":1,"1147":1}}],["metropolitan",{"2":{"1364":1}}],["metroboundingbox",{"2":{"1364":2}}],["metricbucketaggregator",{"2":{"1329":2}}],["metric",{"0":{"1327":1},"1":{"1328":1,"1329":1},"2":{"1077":1,"1232":1,"1444":1}}],["metrics",{"0":{"449":1},"2":{"157":1,"447":1,"884":1,"902":2,"1010":1,"1071":1,"1328":1}}],["meticulously",{"2":{"405":1}}],["meteorological",{"0":{"304":1},"2":{"301":1,"302":1,"304":1,"307":1,"471":1,"504":1,"509":1,"519":3,"526":1}}],["meters",{"2":{"142":1,"1070":3,"1335":1,"1355":1,"1356":1,"1364":1}}],["meta",{"2":{"243":3}}],["metadata",{"0":{"155":1,"367":1,"912":1,"965":1,"968":1},"2":{"117":1,"121":1,"137":1,"141":1,"142":2,"146":1,"154":1,"224":1,"227":1,"301":1,"315":1,"326":1,"362":1,"365":1,"366":1,"367":1,"370":1,"371":1,"403":1,"418":1,"612":1,"625":1,"655":1,"782":1,"786":1,"797":1,"817":1,"864":2,"868":1,"912":2,"937":1,"938":1,"941":1,"942":1,"962":1,"965":1,"967":1,"992":1,"998":1,"1016":1,"1104":1,"1113":1,"1168":1,"1176":2,"1181":1,"1189":1,"1306":1,"1307":1,"1363":1}}],["methodology",{"0":{"406":1,"446":1},"2":{"419":1}}],["methodologies",{"2":{"405":1}}],["methods",{"0":{"266":1,"331":1,"496":1,"505":1,"1169":1,"1345":1},"2":{"27":1,"46":1,"157":2,"175":1,"181":2,"192":1,"198":1,"199":1,"230":3,"233":1,"253":1,"255":1,"261":3,"264":1,"265":1,"273":1,"276":2,"278":1,"279":2,"280":1,"285":1,"322":1,"331":1,"452":1,"456":1,"465":2,"468":1,"470":1,"471":1,"472":2,"481":1,"490":1,"498":2,"597":1,"617":1,"653":1,"709":1,"724":1,"1098":1,"1117":1,"1173":1,"1436":1,"1450":1,"1454":1}}],["method",{"0":{"182":1,"183":1,"184":1,"321":1,"957":1,"958":1,"1167":1,"1217":1},"1":{"185":1,"186":1,"187":1,"188":1,"189":1,"190":1,"191":1},"2":{"7":1,"13":1,"54":1,"63":1,"131":1,"133":1,"146":1,"149":1,"161":1,"165":1,"181":1,"182":1,"183":1,"184":1,"231":1,"233":3,"234":1,"246":1,"254":1,"266":2,"268":1,"271":1,"276":1,"281":1,"316":1,"321":4,"323":1,"389":1,"442":1,"516":1,"518":1,"541":1,"592":1,"596":1,"606":2,"643":1,"668":2,"677":1,"750":1,"752":1,"818":1,"832":1,"860":1,"919":1,"955":1,"993":1,"1021":2,"1042":1,"1089":1,"1104":1,"1118":1,"1147":1,"1167":1,"1168":1,"1169":1,"1251":1,"1264":1,"1284":1,"1285":1,"1318":2,"1335":1,"1337":1,"1344":1,"1345":1,"1352":1,"1357":1,"1358":1,"1360":1,"1382":1,"1405":1,"1444":1}}],["mechanical",{"2":{"1016":1}}],["mechanically",{"2":{"522":1}}],["mechanics",{"0":{"1045":1,"1074":1},"1":{"1075":1,"1076":1,"1077":1,"1078":1,"1079":1},"2":{"84":1,"711":1,"1050":1,"1052":1,"1053":1,"1054":1,"1055":1,"1075":1,"1080":1,"1454":1}}],["mechanism",{"2":{"96":1,"109":1,"113":1,"298":1,"300":1,"406":1,"408":1,"634":1,"751":1,"1076":1,"1091":1}}],["mechanisms",{"2":{"96":1,"336":1,"342":1,"408":1,"913":1}}],["mycorp",{"2":{"1239":1}}],["mycompany",{"2":{"859":1,"1263":2}}],["mycustommethod",{"2":{"1452":2}}],["mycustomformat",{"2":{"243":2}}],["mycustomtermplugin",{"2":{"112":1,"113":1}}],["myenum",{"2":{"468":1}}],["mykey",{"2":{"326":1}}],["myterm",{"2":{"320":2}}],["mytz",{"2":{"112":1,"113":1}}],["myretailseason",{"2":{"316":1}}],["myretailseasonterm",{"2":{"313":1,"316":2}}],["myfeatureplugin",{"2":{"286":1}}],["myformat",{"2":{"112":1,"113":1}}],["mysql",{"0":{"1129":2},"2":{"1103":3,"1104":4,"1123":2}}],["mystaticmethod",{"2":{"276":1}}],["mysettings",{"2":{"110":3}}],["myplugin",{"2":{"271":1,"274":2,"282":1,"543":1}}],["mymodule",{"2":{"261":1}}],["myday",{"2":{"147":2}}],["my",{"0":{"54":1},"2":{"37":1,"157":1,"204":1,"236":1,"261":1,"274":2,"854":1,"859":1}}],["mm>",{"2":{"243":1,"246":1}}],["mmddyy",{"2":{"216":1}}],["mmddyyyy",{"2":{"137":1}}],["mmxxvi",{"2":{"138":1,"763":1,"766":4,"767":1}}],["mmmmm",{"2":{"1090":1}}],["mmmm",{"0":{"1095":1},"2":{"1090":1,"1095":1,"1098":1,"1101":1,"1113":2,"1125":3,"1131":1}}],["mmm",{"2":{"137":1,"140":1,"153":1,"205":1,"518":1,"682":1,"1090":2,"1111":1,"1125":4,"1135":1,"1144":1}}],["mm",{"0":{"215":1,"1111":2,"1134":1},"1":{"216":1,"217":1,"218":1},"2":{"30":1,"32":1,"64":2,"78":5,"96":1,"112":1,"113":1,"137":4,"138":7,"150":1,"190":2,"191":4,"205":4,"207":1,"224":1,"233":1,"240":2,"241":1,"242":3,"243":3,"244":1,"245":1,"246":2,"247":1,"265":3,"266":1,"270":1,"271":1,"295":2,"317":1,"325":1,"351":1,"370":2,"513":1,"545":2,"680":1,"734":3,"758":1,"763":1,"765":2,"806":6,"881":1,"882":1,"889":2,"897":1,"918":1,"961":1,"964":2,"972":1,"985":1,"988":2,"989":1,"1036":1,"1083":2,"1088":7,"1089":4,"1090":3,"1091":3,"1098":3,"1101":2,"1103":9,"1104":3,"1111":4,"1112":3,"1113":2,"1114":3,"1115":3,"1116":4,"1118":1,"1119":8,"1120":2,"1125":8,"1127":3,"1128":3,"1130":2,"1131":1,"1132":1,"1134":4,"1135":7,"1136":4,"1139":3,"1140":9,"1141":9,"1144":1,"1146":1,"1147":3,"1149":1,"1150":5,"1190":2,"1197":2,"1199":2,"1209":1,"1220":1,"1221":3,"1222":2,"1223":1,"1224":1,"1243":1,"1254":1,"1255":1,"1265":2,"1280":1,"1304":2,"1307":1,"1310":1,"1313":1,"1329":1,"1404":1,"1412":1,"1413":2,"1417":1,"1419":1,"1422":1,"1444":1,"1446":1,"1447":1}}],["mirror",{"2":{"1098":1}}],["mirroring",{"2":{"461":1,"541":1,"832":1}}],["mirrors",{"2":{"102":1,"642":1,"739":1,"741":1}}],["miles",{"2":{"1335":2,"1344":2,"1355":1,"1356":2,"1357":2,"1360":1}}],["milestone",{"2":{"674":1,"835":1}}],["millions",{"2":{"1019":2,"1032":1,"1235":1,"1267":1,"1328":1}}],["million",{"2":{"972":1}}],["millisecond",{"0":{"1232":1},"2":{"151":1,"324":3,"451":2,"1039":1,"1089":1,"1213":1,"1225":1,"1226":1,"1232":2,"1242":1,"1319":2,"1332":1,"1396":1,"1412":1,"1429":1}}],["milliseconds",{"2":{"60":2,"94":1,"137":1,"138":2,"151":1,"201":1,"207":2,"209":2,"355":1,"451":1,"507":3,"511":1,"568":1,"871":3,"881":1,"890":1,"899":1,"937":3,"938":3,"959":1,"1125":2,"1218":1,"1240":1,"1247":1,"1315":1,"1319":1,"1381":1,"1382":1,"1412":1,"1443":1}}],["militant",{"2":{"407":1}}],["mixin",{"0":{"1452":1},"2":{"1451":1,"1452":2}}],["mixins",{"0":{"1449":1,"1451":1},"1":{"1450":1,"1451":1,"1452":1},"2":{"1449":1,"1450":2,"1451":1}}],["mixes",{"2":{"1098":1}}],["mixed",{"2":{"191":1,"450":1,"702":1,"726":1,"867":1,"948":1,"1078":1}}],["mix",{"2":{"222":1,"289":1,"292":1,"654":1,"763":1,"767":1}}],["might",{"2":{"221":1,"351":1,"425":1,"1157":1,"1190":1}}],["migratelegacymask",{"2":{"1114":2}}],["migrate",{"2":{"515":1,"572":1}}],["migrated",{"2":{"102":1,"541":1,"565":1,"672":1}}],["migrationresult",{"2":{"1147":3}}],["migrations",{"2":{"532":1}}],["migration",{"0":{"532":1,"545":1,"637":1,"759":1,"1108":1,"1109":1,"1113":1,"1122":1},"1":{"1109":1,"1110":2,"1111":2,"1112":2,"1113":1,"1114":2,"1115":1,"1116":1,"1117":1,"1118":1,"1119":1,"1120":1,"1121":1,"1122":1},"2":{"137":1,"205":1,"589":1,"594":1,"625":1,"629":1,"637":1,"671":1,"1086":1,"1098":1,"1105":1,"1108":1,"1137":1,"1147":1}}],["migrating",{"0":{"535":1,"547":1,"548":1,"549":1,"560":1,"561":1,"562":1,"566":1},"1":{"536":1,"537":1,"538":1,"539":1,"548":1,"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":1,"559":1,"560":1,"561":1,"562":1,"563":2,"564":2,"565":2,"566":1,"567":2,"568":2,"569":2,"570":1,"571":1,"572":1,"573":1},"2":{"78":1,"137":1,"205":1,"1146":1}}],["microtasks",{"2":{"1367":1}}],["micromoons",{"0":{"1064":1}}],["micromoon",{"2":{"1058":1,"1064":1}}],["microgrids",{"2":{"1081":1}}],["microgrid",{"2":{"1052":1}}],["microsoft",{"2":{"1103":1}}],["microservice",{"2":{"1191":1,"1377":1}}],["microservices",{"2":{"291":1,"915":1,"953":1,"1328":1}}],["microsecperop",{"2":{"449":1}}],["microseconds",{"2":{"137":1,"138":1,"151":1,"207":1,"209":1,"449":1,"1125":1,"1315":1,"1319":1}}],["microsecond",{"2":{"93":1,"151":1,"1125":1,"1143":1,"1144":1,"1319":2,"1328":1,"1387":1,"1388":1,"1440":1}}],["microscopic",{"2":{"181":1,"469":1}}],["micro",{"2":{"111":1,"114":1,"119":1,"129":1,"442":1,"610":1,"780":1}}],["midi",{"2":{"1395":1}}],["midday",{"2":{"306":3,"1072":2}}],["middleware",{"0":{"1193":1},"2":{"1166":1,"1193":1}}],["middle",{"2":{"62":2,"71":1,"186":1,"365":1,"366":1,"1093":1,"1205":1,"1207":1}}],["midmorning",{"2":{"306":1}}],["midnightsun",{"2":{"1072":4}}],["midnight",{"0":{"1072":1,"1136":1},"2":{"138":1,"240":1,"306":1,"315":1,"338":1,"896":1,"972":2,"1094":3,"1136":1}}],["midpointcoord",{"2":{"1365":2}}],["midpoints",{"2":{"1354":1,"1362":1}}],["midpoint",{"0":{"1359":2},"2":{"63":1,"382":2,"1343":1,"1344":2,"1347":2,"1359":2,"1365":7}}],["mid",{"0":{"63":1,"190":1},"2":{"63":1,"117":1,"123":3,"186":2,"190":1,"323":2,"368":1,"369":1,"382":2,"771":1,"773":2,"777":3,"1055":1,"1347":3,"1359":2}}],["miscalculated",{"2":{"1218":1}}],["miscalculate",{"2":{"1012":1}}],["misconfigured",{"2":{"1011":1}}],["missedtick",{"2":{"1448":3}}],["missed",{"2":{"1331":1,"1448":3}}],["miss",{"2":{"972":1}}],["mission",{"2":{"43":1,"522":1,"533":1,"1422":1}}],["missing",{"0":{"12":1},"2":{"47":1,"144":1,"202":2,"281":2,"282":1,"469":1,"665":1,"860":1,"955":1,"1012":1}}],["misalignment",{"2":{"972":1}}],["mistral",{"2":{"853":1,"925":1,"926":1,"939":1}}],["misidentification",{"2":{"616":1}}],["misidentified",{"2":{"404":1}}],["mismatch",{"2":{"146":2}}],["mismatched",{"2":{"44":1}}],["mi",{"0":{"1111":1},"2":{"30":1,"54":1,"68":2,"78":1,"137":1,"138":8,"139":6,"140":1,"144":2,"151":1,"224":1,"240":1,"241":1,"245":1,"247":1,"295":1,"320":1,"719":1,"720":3,"734":1,"806":2,"889":2,"894":1,"968":1,"969":1,"988":2,"1061":3,"1069":2,"1073":2,"1082":4,"1083":2,"1085":1,"1088":1,"1089":3,"1090":1,"1091":1,"1103":1,"1104":1,"1111":1,"1113":2,"1114":1,"1115":3,"1116":1,"1125":1,"1147":1,"1149":1,"1150":3,"1243":1,"1254":1,"1255":1,"1265":2,"1316":3,"1317":1,"1319":2,"1325":1,"1326":5,"1329":1,"1344":1,"1404":1,"1408":1,"1412":3,"1413":2,"1415":1,"1417":2,"1418":1,"1421":1,"1422":1,"1424":2,"1434":1,"1439":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1}}],["minus",{"2":{"1420":1}}],["minutes",{"0":{"1079":1},"2":{"137":1,"138":1,"151":1,"157":1,"158":1,"894":1,"978":1,"992":1,"1013":1,"1023":1,"1069":1,"1078":1,"1079":1,"1088":1,"1111":1,"1134":1,"1260":1,"1315":1,"1316":1,"1319":1,"1326":1,"1344":1,"1351":1,"1352":4,"1363":1,"1366":4,"1404":2,"1412":1,"1413":3,"1415":2,"1417":1,"1448":1}}],["minute",{"0":{"1111":1},"2":{"9":1,"138":2,"151":1,"191":1,"225":1,"240":1,"245":1,"315":1,"324":3,"970":1,"1045":1,"1047":2,"1052":2,"1078":1,"1079":2,"1088":3,"1089":1,"1111":2,"1113":1,"1125":2,"1255":2,"1315":1,"1319":2,"1324":2,"1326":1,"1328":1,"1329":1,"1416":1,"1417":1}}],["minlng",{"2":{"1336":1,"1337":1,"1338":2,"1364":1}}],["minlat",{"2":{"1336":1,"1337":1,"1338":1,"1364":1}}],["mintid",{"2":{"1307":5}}],["mins",{"2":{"1023":1,"1361":1,"1363":1}}],["minconfidence",{"2":{"871":1,"875":2,"881":1,"890":1,"899":1,"912":2,"920":1,"927":1,"934":1,"937":1,"938":1,"945":2,"962":1,"989":1,"1010":2}}],["minor",{"2":{"575":1}}],["mind",{"2":{"515":1}}],["mindset",{"2":{"407":1}}],["minified",{"0":{"722":1},"2":{"722":1,"1278":1}}],["minimum",{"2":{"867":2,"871":1,"881":1,"890":1,"899":1,"937":1,"938":1,"989":1,"1076":1}}],["minimaldays",{"2":{"370":2}}],["minimal",{"2":{"365":2,"367":1,"642":1,"915":1,"1121":1}}],["minimizes",{"2":{"280":1}}],["minimize",{"2":{"24":1,"1365":1}}],["mini",{"2":{"89":1,"927":1,"958":1}}],["min",{"2":{"45":2,"138":2,"722":1,"850":2,"987":1,"988":1,"1055":1,"1069":1,"1344":1,"1352":1,"1353":1}}],["mitigation",{"2":{"1011":1,"1375":1,"1442":1}}],["mitigations",{"2":{"22":1,"1011":1}}],["mitigates",{"2":{"995":1}}],["mit",{"2":{"17":1,"534":1,"659":1,"845":1,"923":1,"1025":1,"1057":1,"1107":1,"1155":1,"1174":1,"1211":1,"1300":1,"1321":1,"1349":1,"1384":1,"1410":1}}],["museum",{"2":{"1303":1}}],["must",{"2":{"6":2,"7":1,"43":1,"102":1,"108":1,"109":1,"112":1,"114":1,"131":1,"135":1,"136":1,"146":2,"191":1,"210":1,"211":1,"234":1,"243":1,"256":1,"261":1,"267":1,"269":1,"271":2,"295":1,"314":1,"318":1,"320":1,"327":1,"362":1,"388":3,"406":1,"407":1,"413":1,"426":1,"468":1,"552":1,"565":1,"569":1,"757":1,"856":1,"863":1,"909":1,"913":1,"931":1,"989":2,"1000":1,"1005":2,"1015":1,"1028":1,"1083":1,"1218":1,"1222":1,"1306":1,"1331":1,"1376":1,"1444":1}}],["much",{"2":{"560":1,"705":1}}],["mutex",{"2":{"1369":1}}],["mutableobject",{"2":{"546":2}}],["mutable",{"2":{"426":1,"427":1,"430":1,"432":1,"434":1,"435":1,"437":2,"527":1,"546":3,"738":1}}],["mutated",{"2":{"468":1,"504":1,"1019":1,"1029":1,"1040":1}}],["mutates",{"2":{"414":1,"416":1}}],["mutate",{"0":{"255":2},"2":{"46":1,"233":1,"251":2,"279":1,"295":1,"472":1,"560":1,"644":1,"705":1,"1019":1,"1091":1,"1450":1,"1454":1}}],["mutatemodule",{"2":{"46":2,"251":2,"667":1}}],["mutation",{"0":{"181":1,"187":1,"667":1,"719":1,"842":1,"1023":1},"1":{"182":1,"183":1,"184":1,"185":1,"186":1,"187":1,"188":2,"189":2,"190":2,"191":1,"192":1,"193":1,"194":1,"195":1},"2":{"117":1,"119":1,"158":1,"181":1,"193":1,"199":1,"228":1,"331":1,"407":1,"416":1,"418":1,"433":1,"437":2,"465":1,"466":1,"553":1,"617":2,"629":2,"635":1,"660":1,"667":2,"835":1,"842":1,"855":1,"864":1,"1018":1,"1021":1,"1030":1}}],["mutations",{"0":{"64":1,"191":1,"734":1,"777":1},"2":{"9":1,"64":1,"83":1,"84":1,"192":1,"368":1,"434":1,"625":1,"667":1,"705":1,"719":1,"773":1,"777":1,"1037":1}}],["mutating",{"0":{"425":1},"2":{"27":1,"174":1,"468":1,"833":1,"855":1,"1039":1}}],["mutualfreetime",{"2":{"179":1}}],["mutual",{"2":{"179":1}}],["multimedia",{"0":{"1330":1},"1":{"1331":1,"1332":1},"2":{"1315":1,"1320":1,"1322":1}}],["multiplayer",{"0":{"1390":1},"1":{"1391":1,"1392":1},"2":{"1255":1,"1377":1,"1383":1,"1391":1}}],["multiplying",{"2":{"1218":1}}],["multiplier",{"2":{"1071":2}}],["multiple",{"2":{"41":1,"96":1,"138":1,"206":1,"219":1,"230":1,"263":1,"286":1,"292":1,"321":2,"326":1,"329":1,"402":1,"465":1,"520":1,"522":1,"726":1,"750":1,"806":1,"877":1,"887":1,"905":1,"947":1,"950":1,"964":1,"1032":1,"1255":1,"1391":1,"1424":1,"1428":1}}],["multicast",{"2":{"792":1}}],["multicasts",{"2":{"489":1}}],["multi",{"0":{"69":1,"321":1,"363":1,"696":1,"802":1,"867":1,"895":1,"904":1,"930":1,"934":1,"939":1,"947":1,"950":1,"963":1,"1009":1,"1183":1,"1185":1,"1190":1,"1192":1,"1219":1,"1430":1,"1447":1},"1":{"868":1,"940":1,"941":1,"942":1,"943":1,"944":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"1184":1,"1185":1,"1186":2,"1187":2,"1188":1,"1220":1},"2":{"12":1,"78":1,"89":1,"100":1,"116":1,"119":1,"165":1,"205":1,"219":1,"313":1,"333":1,"361":1,"373":1,"402":1,"465":1,"536":1,"588":1,"643":1,"644":1,"688":1,"696":1,"750":1,"800":1,"838":1,"867":3,"871":1,"881":1,"888":1,"890":1,"895":1,"899":1,"904":1,"909":1,"921":3,"924":1,"933":1,"934":2,"937":2,"939":1,"948":1,"963":2,"981":1,"989":1,"994":1,"1004":1,"1009":1,"1017":1,"1026":1,"1037":1,"1099":1,"1104":2,"1105":1,"1119":1,"1139":1,"1162":1,"1166":2,"1168":1,"1178":1,"1182":1,"1183":1,"1185":2,"1186":1,"1189":2,"1210":1,"1367":1,"1368":1,"1385":1,"1396":1,"1401":2,"1412":1,"1423":1,"1428":1,"1429":1}}],["mdt",{"2":{"296":1}}],["mdy6",{"2":{"743":1}}],["mdylayouts",{"2":{"563":1,"565":1,"633":1}}],["mdylocales",{"2":{"563":2,"565":1,"633":1}}],["mdy",{"2":{"137":1,"217":1,"218":1,"242":1,"362":2,"375":2,"376":1,"563":1,"630":1,"732":1,"758":1}}],["md",{"2":{"7":1,"8":1,"27":1,"275":1,"697":1,"705":3,"708":2,"747":2,"751":1,"861":1,"867":1}}],["mouse",{"2":{"1324":1,"1325":1,"1326":1}}],["mountain",{"2":{"1213":1}}],["mount",{"2":{"263":1}}],["mounted",{"2":{"143":1,"1039":1}}],["mounts",{"2":{"78":1,"916":1,"1021":1,"1104":1,"1164":1,"1341":1}}],["mom",{"2":{"1269":3,"1296":1,"1297":1}}],["moments",{"2":{"1045":1,"1054":1}}],["momentum",{"0":{"384":1,"386":1},"1":{"385":1,"386":1},"2":{"194":1,"386":1}}],["moment",{"0":{"78":1,"1093":1,"1128":2},"2":{"78":4,"120":1,"137":4,"157":1,"191":1,"205":2,"507":2,"514":1,"532":1,"778":1,"808":1,"907":1,"1068":1,"1069":2,"1086":1,"1088":2,"1089":1,"1090":1,"1091":1,"1093":1,"1098":1,"1099":1,"1101":1,"1103":3,"1105":1,"1108":1,"1110":1,"1112":1,"1113":3,"1116":2,"1120":1,"1123":3,"1125":3,"1128":1,"1136":1,"1146":2,"1147":2,"1149":1,"1150":2,"1433":1,"1445":1}}],["moselle",{"2":{"1213":1}}],["most",{"2":{"35":1,"116":1,"232":1,"266":1,"296":1,"351":1,"375":1,"385":1,"509":1,"911":1,"945":1,"969":2,"1103":1,"1110":1,"1125":1,"1445":1}}],["mockrestore",{"2":{"1459":1}}],["mockgeoprovider",{"2":{"1166":1}}],["mock",{"2":{"1000":1}}],["mobile",{"0":{"1448":1},"2":{"953":1,"1258":1,"1262":1,"1443":1,"1448":1}}],["moonphase",{"2":{"1085":1}}],["moonlight",{"2":{"1085":1}}],["moonset",{"2":{"1052":1,"1053":1,"1054":1,"1058":1,"1061":3,"1080":1,"1085":1}}],["moonrise",{"2":{"1052":1,"1053":1,"1054":1,"1055":2,"1058":1,"1061":3,"1080":1,"1085":3}}],["moon",{"0":{"1059":1},"2":{"771":1,"775":1,"1050":1,"1054":1,"1055":8,"1059":7,"1060":1,"1062":2,"1063":3,"1064":6,"1075":2,"1076":4,"1077":2,"1269":3}}],["moving",{"0":{"1234":1},"2":{"526":1,"626":1,"1226":1,"1234":1,"1236":1,"1240":1,"1246":1,"1267":1}}],["moved",{"2":{"402":1,"544":2,"630":1,"705":1}}],["move",{"2":{"189":1,"409":1}}],["mois",{"2":{"372":1}}],["morninglightsoff",{"2":{"1082":1}}],["morning",{"2":{"306":1,"315":1,"387":2,"889":1,"1415":2,"1417":1,"1421":1}}],["more",{"2":{"14":1,"17":1,"44":1,"56":1,"58":1,"59":1,"64":1,"69":1,"76":3,"77":1,"78":1,"195":1,"229":1,"236":1,"280":1,"363":1,"395":1,"469":2,"517":1,"519":2,"549":1,"559":1,"560":1,"573":1,"626":1,"633":1,"674":1,"684":1,"712":1,"954":1,"1019":1,"1266":1}}],["mo",{"2":{"165":1}}],["monastic",{"2":{"1309":1}}],["monotonic",{"0":{"1235":1},"2":{"1226":1,"1236":1,"1369":1}}],["monorepos",{"2":{"402":1}}],["monorepo",{"2":{"3":1,"400":1,"402":1,"618":1,"702":1,"709":1}}],["monumental",{"2":{"522":1}}],["monitorjobqueue",{"2":{"1445":2}}],["monitor",{"2":{"635":1,"701":1}}],["monitoring",{"0":{"1085":1},"2":{"418":1,"625":1,"936":1,"969":1,"1426":1}}],["monitors",{"2":{"416":1,"941":1,"1003":1}}],["monkey",{"2":{"322":1,"1011":1,"1173":1}}],["mondayisation",{"2":{"1213":1}}],["mondays",{"2":{"396":1,"397":2}}],["monday",{"2":{"64":1,"137":1,"140":2,"186":4,"190":1,"191":1,"201":1,"203":1,"233":2,"352":1,"363":1,"365":2,"368":1,"369":2,"370":3,"390":1,"392":1,"393":1,"395":1,"399":1,"734":1,"735":3,"786":1,"817":2,"880":1,"889":1,"934":1,"945":1,"978":1,"1014":1,"1016":1,"1093":1,"1195":1,"1197":2,"1203":2,"1213":3,"1220":1,"1221":2,"1222":2,"1224":2,"1417":1,"1447":1}}],["monthly",{"2":{"1035":1,"1412":2,"1413":1}}],["monthmap",{"2":{"752":1}}],["monthindex",{"2":{"458":1,"459":1}}],["monthcode",{"2":{"149":1}}],["monthday",{"2":{"117":2,"217":2,"218":1,"563":3,"565":1,"631":3,"633":1}}],["month",{"0":{"218":1,"563":1,"1111":1,"1288":1,"1296":1,"1297":1},"2":{"63":1,"137":7,"138":12,"146":2,"150":5,"152":1,"153":2,"156":1,"163":1,"165":1,"173":1,"184":1,"185":2,"190":1,"192":1,"202":1,"203":2,"204":1,"213":1,"215":1,"216":2,"217":1,"218":1,"221":1,"240":1,"242":3,"245":1,"265":2,"266":1,"294":1,"301":1,"303":1,"304":1,"305":1,"313":8,"315":1,"362":3,"364":1,"372":1,"416":1,"458":2,"459":2,"460":1,"461":1,"518":1,"519":9,"752":1,"766":1,"771":1,"776":2,"842":1,"968":1,"970":1,"981":1,"983":2,"1013":1,"1014":1,"1032":1,"1047":1,"1059":1,"1075":1,"1088":8,"1089":1,"1095":2,"1097":1,"1111":4,"1113":2,"1121":1,"1125":8,"1143":1,"1157":1,"1222":1,"1268":1,"1269":2,"1270":5,"1271":1,"1287":1,"1290":1,"1304":2,"1310":2,"1319":1,"1396":1,"1412":2,"1413":1,"1416":2}}],["monthstart",{"2":{"63":1}}],["months",{"2":{"62":1,"63":1,"160":1,"161":1,"163":1,"191":2,"192":2,"202":1,"219":1,"220":1,"221":1,"222":1,"228":1,"296":1,"303":1,"325":1,"363":2,"453":1,"458":1,"471":1,"512":1,"519":1,"734":1,"737":1,"754":1,"767":1,"1023":1,"1097":1,"1105":1,"1111":1,"1134":1,"1269":6,"1296":2,"1297":2,"1319":1,"1401":1,"1404":2,"1412":2,"1413":2}}],["mon",{"2":{"9":1,"42":1,"54":1,"58":1,"76":4,"119":1,"131":1,"134":1,"137":1,"138":9,"140":1,"146":1,"152":1,"153":1,"203":1,"240":2,"363":1,"364":1,"370":1,"392":1,"396":1,"397":2,"398":1,"399":1,"454":2,"461":1,"754":1,"1090":6,"1091":1,"1095":1,"1096":1,"1098":1,"1111":1,"1113":2,"1125":1,"1199":1,"1209":1,"1213":5,"1418":1}}],["mod",{"2":{"240":1,"242":2,"1114":1,"1147":1}}],["modifications",{"2":{"345":1,"778":1}}],["modification",{"2":{"340":1}}],["modified",{"2":{"139":1,"329":1}}],["modifiers",{"0":{"76":1,"138":1,"144":1,"222":1,"383":1,"393":1,"395":1,"396":1,"723":1,"732":1,"735":1,"765":1,"1090":1},"2":{"76":4,"109":1,"115":1,"117":1,"138":8,"139":1,"140":1,"144":1,"145":1,"191":2,"221":1,"222":3,"363":1,"364":1,"383":1,"544":1,"704":2,"707":2,"723":1,"735":1,"737":2,"738":1,"739":1,"754":1,"788":2,"823":1,"1090":3,"1098":1,"1103":1,"1125":1}}],["modifier",{"0":{"737":1,"739":1,"1087":1},"1":{"1088":1,"1089":1,"1090":1,"1091":1},"2":{"64":1,"138":5,"139":1,"146":1,"191":1,"240":1,"297":1,"363":1,"380":1,"383":1,"388":1,"391":1,"393":2,"396":1,"399":1,"732":1,"738":4,"754":1,"765":1,"775":1,"1086":2,"1088":1,"1090":1,"1105":1}}],["modifies",{"2":{"6":1,"233":1}}],["modify",{"2":{"181":1,"279":1,"327":1}}],["modifying",{"2":{"181":1,"316":1,"341":1,"1224":1}}],["modularized",{"2":{"626":1}}],["modularity",{"0":{"135":1,"210":1,"249":1},"1":{"136":1,"211":1,"250":1,"251":1,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1,"261":1,"262":1},"2":{"640":1,"642":1}}],["modular",{"0":{"550":1,"653":1,"668":1,"675":1},"1":{"551":1,"552":1},"2":{"12":1,"115":1,"135":1,"147":1,"210":1,"249":1,"262":1,"507":1,"526":1,"549":1,"553":1,"574":1,"623":1,"643":1,"644":1,"659":1,"668":1,"672":1,"1097":1}}],["modules",{"0":{"252":1,"261":1},"1":{"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1},"2":{"44":1,"46":1,"83":1,"88":1,"102":1,"250":2,"251":1,"259":1,"261":1,"271":1,"276":1,"328":1,"333":1,"479":1,"541":3,"550":1,"559":2,"560":2,"622":1,"644":1,"668":1,"675":1,"678":1,"702":1,"716":1,"830":1,"839":1,"1041":1,"1454":3,"1459":1}}],["module",{"0":{"234":1,"235":1,"250":1,"253":1,"254":1,"255":1,"256":1,"257":1,"259":1,"267":1,"286":1,"310":1,"447":1},"1":{"258":1,"259":1,"260":1,"448":1,"449":1,"450":1,"451":1},"2":{"7":1,"10":2,"42":1,"43":3,"44":1,"46":1,"106":1,"111":1,"112":3,"234":1,"250":5,"261":4,"262":2,"267":1,"274":1,"276":2,"278":1,"284":1,"286":1,"326":1,"402":2,"415":1,"446":1,"447":1,"448":1,"468":1,"537":1,"538":1,"555":1,"559":2,"578":1,"607":1,"637":1,"642":1,"644":3,"651":2,"655":1,"661":1,"663":2,"667":1,"671":1,"678":1,"712":1,"724":3,"726":1,"757":1,"758":1,"812":1,"836":1,"839":1,"1450":1,"1452":1,"1454":1}}],["moderate",{"2":{"940":4,"1076":2}}],["modernpattern",{"2":{"1114":2}}],["modernizations",{"0":{"837":1},"1":{"838":1,"839":1,"840":1,"841":1,"842":1}}],["modernization",{"0":{"1145":1},"1":{"1146":1,"1147":1},"2":{"836":1,"1105":1}}],["modernized",{"2":{"655":1,"717":1}}],["modern",{"2":{"24":1,"33":1,"34":2,"35":1,"102":1,"106":1,"119":1,"156":1,"157":2,"276":1,"300":1,"335":1,"365":2,"402":1,"418":1,"461":1,"474":1,"480":1,"488":1,"524":1,"671":1,"692":1,"836":1,"1000":1,"1088":1,"1110":1,"1189":1,"1226":1,"1258":1,"1268":1,"1288":1,"1303":1,"1306":1,"1370":1,"1378":1,"1445":1}}],["modes",{"0":{"332":1,"379":1,"934":1,"939":1,"963":1},"1":{"333":1,"334":1,"335":1,"380":1,"381":1,"382":1,"940":1,"941":1,"942":1,"943":1,"944":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"2":{"448":1,"696":1,"867":2,"871":1,"881":1,"890":1,"899":1,"921":1,"924":1,"934":2,"939":1,"942":1,"963":2,"989":1,"1017":1,"1052":1,"1081":1}}],["modeling",{"0":{"1360":1},"2":{"1350":1,"1353":1,"1354":1,"1366":1}}],["models",{"0":{"854":1,"1115":1},"2":{"89":1,"854":3,"868":1,"909":1,"913":1,"922":2,"942":1,"948":1,"958":1,"972":3,"1010":1,"1012":2,"1017":1,"1042":1,"1059":1,"1099":1,"1104":1,"1115":1,"1150":1,"1242":1}}],["model",{"0":{"1011":1},"2":{"30":1,"96":1,"285":1,"515":1,"854":4,"855":1,"856":1,"859":1,"860":1,"907":1,"909":3,"911":1,"927":1,"930":1,"932":1,"933":1,"953":1,"954":1,"958":6,"959":2,"1004":1,"1008":2,"1017":1,"1104":2,"1115":1,"1150":1,"1371":1,"1440":1}}],["mode",{"0":{"124":1,"194":1,"195":1,"333":1,"334":1,"335":1,"380":1,"381":1,"382":1,"944":1,"1038":1,"1039":1,"1040":1},"1":{"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"1039":1,"1040":1},"2":{"6":1,"102":1,"117":1,"124":5,"137":1,"155":1,"198":1,"209":2,"262":1,"281":2,"291":1,"332":2,"333":1,"341":1,"416":1,"450":1,"451":2,"507":1,"515":1,"543":1,"602":2,"643":1,"655":1,"757":1,"776":1,"831":1,"833":1,"867":1,"871":1,"881":1,"890":1,"899":1,"926":1,"927":1,"934":8,"937":2,"938":3,"939":2,"940":1,"941":1,"945":2,"946":1,"947":1,"948":1,"949":1,"950":2,"958":1,"959":1,"989":1,"997":1,"1011":1,"1017":1,"1038":2,"1081":5,"1168":1,"1190":3,"1443":1,"1448":1,"1458":1}}],["magnitude",{"2":{"1067":1}}],["magic",{"2":{"716":1,"1096":1}}],["magma",{"0":{"529":1},"1":{"530":1,"531":1,"532":1,"533":1,"534":1},"2":{"4":2,"8":1,"19":1,"20":1,"45":5,"236":1,"248":2,"283":1,"293":1,"529":1,"709":1,"722":3,"850":2,"922":2,"1007":1,"1186":1,"1215":1}}],["magmacomputing",{"0":{"98":1,"204":1,"253":1,"254":1,"255":1,"256":1,"257":1,"537":1,"687":1,"808":1,"840":1,"841":1,"913":1,"1018":1,"1050":1,"1099":1,"1151":1,"1161":1,"1162":1,"1206":1,"1236":1,"1275":1,"1315":1,"1339":1,"1377":1,"1396":1},"1":{"99":1,"258":1,"259":1,"260":1,"914":1,"915":1,"916":1,"917":1,"918":1,"919":1,"920":1,"921":1,"922":1,"923":1,"1019":1,"1020":1,"1021":1,"1022":1,"1023":1,"1024":1,"1025":1,"1051":1,"1052":1,"1053":1,"1054":1,"1055":1,"1056":1,"1057":1,"1100":1,"1101":1,"1102":1,"1103":1,"1104":1,"1105":1,"1106":1,"1107":1,"1152":1,"1153":1,"1154":1,"1155":1,"1163":1,"1164":1,"1165":1,"1166":1,"1167":1,"1168":1,"1169":1,"1170":1,"1171":1,"1172":1,"1173":1,"1174":1,"1207":1,"1208":1,"1209":1,"1210":1,"1211":1,"1237":1,"1238":1,"1239":1,"1240":1,"1241":1,"1242":1,"1243":1,"1244":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1252":1,"1276":1,"1277":1,"1278":1,"1279":1,"1280":1,"1281":1,"1282":1,"1283":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1299":1,"1300":1,"1316":1,"1317":1,"1318":1,"1319":1,"1320":1,"1321":1,"1340":1,"1341":1,"1342":1,"1343":1,"1344":1,"1345":1,"1346":1,"1347":1,"1348":1,"1349":1,"1378":1,"1379":1,"1380":1,"1381":1,"1382":1,"1383":1,"1384":1,"1397":1,"1398":1,"1399":1,"1400":1,"1401":1,"1402":1,"1403":1,"1404":1,"1405":1,"1406":1,"1407":1,"1408":1,"1409":1,"1410":1},"2":{"4":1,"5":1,"9":2,"10":8,"14":3,"15":1,"20":1,"21":1,"22":1,"26":1,"27":3,"28":1,"31":1,"32":1,"35":4,"36":1,"38":1,"39":1,"40":1,"42":3,"43":6,"44":8,"45":2,"46":2,"47":2,"78":2,"87":2,"88":3,"89":1,"94":1,"98":3,"102":3,"103":1,"104":1,"112":1,"113":1,"116":1,"119":1,"131":1,"133":1,"136":3,"137":3,"158":1,"169":1,"170":1,"197":1,"200":1,"203":1,"204":1,"205":3,"211":3,"232":1,"234":2,"236":1,"247":2,"250":2,"251":8,"258":1,"259":2,"260":2,"261":5,"262":1,"265":2,"267":2,"268":1,"271":4,"274":3,"276":9,"282":2,"283":3,"285":2,"286":1,"289":5,"290":3,"295":1,"309":1,"310":2,"311":2,"312":1,"313":2,"316":1,"319":1,"322":1,"324":1,"326":1,"333":2,"334":2,"335":1,"363":1,"375":1,"421":1,"448":2,"457":2,"458":1,"459":1,"460":1,"461":2,"463":1,"464":1,"477":1,"481":1,"489":1,"500":1,"501":1,"502":1,"515":1,"534":2,"536":1,"537":4,"539":1,"548":5,"551":1,"552":1,"555":2,"558":2,"559":8,"560":4,"590":1,"618":1,"651":1,"678":3,"687":2,"692":1,"696":1,"701":1,"702":1,"728":3,"741":1,"757":1,"759":3,"765":1,"773":1,"775":1,"776":1,"792":2,"793":1,"804":1,"806":1,"812":3,"836":1,"840":1,"841":1,"846":12,"848":2,"849":2,"850":2,"852":1,"853":2,"856":3,"859":1,"861":1,"867":1,"870":2,"878":1,"880":2,"885":2,"889":2,"898":2,"903":1,"914":1,"915":2,"916":2,"917":2,"918":1,"922":2,"924":1,"925":2,"929":1,"930":1,"931":1,"933":1,"939":2,"954":1,"955":1,"957":1,"958":1,"961":1,"969":1,"970":1,"973":1,"976":1,"978":1,"982":1,"988":1,"994":1,"995":1,"997":1,"1007":2,"1010":1,"1012":1,"1013":2,"1014":2,"1015":2,"1016":2,"1017":2,"1019":3,"1020":2,"1026":1,"1030":2,"1033":2,"1036":2,"1037":1,"1044":1,"1045":1,"1046":2,"1049":2,"1051":1,"1055":2,"1056":2,"1058":1,"1059":2,"1066":1,"1067":2,"1074":1,"1076":2,"1080":1,"1081":2,"1082":2,"1083":2,"1084":2,"1085":2,"1086":1,"1092":1,"1098":1,"1100":1,"1101":2,"1102":2,"1108":1,"1113":2,"1120":1,"1122":1,"1137":1,"1141":2,"1144":2,"1147":2,"1150":2,"1152":1,"1153":2,"1154":2,"1156":1,"1158":2,"1160":1,"1162":1,"1163":1,"1164":2,"1165":2,"1171":2,"1172":2,"1175":1,"1176":1,"1178":2,"1183":1,"1184":3,"1189":1,"1190":2,"1191":3,"1192":2,"1193":2,"1195":2,"1207":1,"1208":1,"1209":2,"1214":2,"1215":1,"1216":2,"1218":1,"1220":2,"1221":2,"1222":2,"1223":2,"1224":2,"1226":1,"1237":1,"1239":2,"1241":2,"1242":1,"1243":2,"1253":2,"1254":3,"1255":1,"1258":1,"1261":2,"1263":2,"1265":1,"1266":1,"1271":1,"1273":1,"1277":1,"1278":3,"1280":2,"1281":2,"1282":2,"1301":1,"1304":2,"1307":2,"1310":2,"1313":3,"1316":3,"1317":2,"1322":1,"1326":2,"1329":2,"1332":2,"1333":1,"1335":2,"1337":2,"1339":1,"1340":1,"1341":2,"1342":2,"1347":2,"1350":1,"1352":2,"1354":1,"1357":2,"1358":2,"1359":2,"1360":2,"1361":2,"1362":1,"1363":2,"1364":2,"1365":2,"1366":2,"1367":1,"1378":1,"1379":2,"1380":2,"1381":1,"1385":1,"1389":3,"1392":2,"1395":1,"1397":1,"1399":2,"1400":2,"1408":2,"1411":1,"1412":2,"1416":1,"1422":5,"1423":1,"1424":2,"1426":1,"1429":2,"1430":2,"1433":2,"1443":1,"1444":2,"1445":2,"1446":2,"1447":2,"1448":2,"1451":1,"1453":1}}],["malformed",{"2":{"709":1,"865":1}}],["malicious",{"2":{"468":1,"647":1,"857":1}}],["macroscopic",{"2":{"410":1}}],["machines",{"2":{"1093":1,"1422":1}}],["machine",{"2":{"368":1,"370":1,"525":1,"649":1,"865":1,"1167":1}}],["macos",{"2":{"91":1}}],["made",{"2":{"331":1,"345":1,"592":1,"972":1}}],["maketemplate",{"2":{"592":1}}],["makes",{"2":{"274":1,"433":1,"468":1,"516":1,"734":1,"1263":1,"1363":1}}],["make",{"2":{"273":1,"281":1,"284":1,"747":1,"1387":1}}],["making",{"2":{"129":1,"298":1,"402":1,"403":1,"412":1,"492":1,"712":1,"1189":1,"1225":1}}],["margin",{"2":{"1387":2}}],["marcus",{"2":{"1272":1}}],["march",{"2":{"192":2,"213":1,"219":1,"1046":1,"1269":3,"1270":4,"1271":1,"1276":1,"1280":2,"1296":1,"1297":1,"1307":2,"1313":1}}],["martias",{"2":{"1270":2,"1271":5,"1280":1,"1310":1}}],["martiis",{"2":{"1270":1,"1276":1,"1280":1,"1289":1,"1313":2}}],["mart",{"2":{"1270":2,"1271":1,"1276":2,"1280":2,"1289":1,"1303":1}}],["mariadb",{"2":{"1103":2,"1104":1,"1123":1}}],["marine",{"2":{"1085":1,"1213":1}}],["maritime",{"0":{"1083":1},"2":{"1052":1,"1080":1}}],["mardi",{"2":{"372":2}}],["marshall",{"2":{"213":1}}],["mar",{"2":{"213":1,"305":1,"1097":1}}],["marks",{"2":{"993":1}}],["marked",{"2":{"138":1,"152":1,"291":1,"830":1,"832":1,"1269":1}}],["markers",{"2":{"370":1}}],["marker",{"2":{"137":1,"240":1,"315":1,"326":2,"1113":1}}],["marketclocks",{"2":{"1430":2}}],["marketcountry",{"2":{"1221":2}}],["marketsummary>",{"2":{"1446":1}}],["marketsummary",{"2":{"1446":1}}],["markets",{"2":{"1218":1}}],["marketplace",{"2":{"1139":1}}],["market",{"0":{"1446":1,"1447":1},"2":{"97":1,"102":2,"333":4,"339":2,"531":1,"1221":1,"1387":1,"1401":1}}],["markdown",{"2":{"27":1,"651":1,"751":1}}],["masking",{"0":{"1017":1},"2":{"921":1}}],["masked",{"2":{"869":1,"997":2,"998":1}}],["mask",{"0":{"205":1,"778":1,"806":1,"1114":1},"2":{"137":1,"763":1,"765":1,"804":1,"808":1,"1088":1,"1104":42,"1113":2,"1122":1,"1134":1,"1140":1,"1144":1,"1150":1}}],["masks",{"2":{"137":1,"205":2,"364":1,"763":1,"778":2,"798":1,"806":2,"936":1,"1096":1,"1098":1,"1101":1,"1103":1,"1104":6,"1106":1,"1110":1,"1114":1,"1115":2,"1116":1,"1121":1,"1126":1,"1140":1,"1141":2,"1147":2,"1149":1,"1150":2}}],["massive",{"2":{"411":1,"423":1,"444":1,"754":1,"795":1,"972":2,"1018":2,"1019":1,"1037":1,"1146":1}}],["mass",{"2":{"124":2,"441":1}}],["masterticker",{"2":{"1429":1}}],["mastertime",{"2":{"1429":6}}],["master",{"0":{"228":1,"359":1,"415":1,"445":1,"1369":1,"1379":1,"1428":1},"1":{"416":1,"1380":1,"1429":1,"1430":1},"2":{"124":2,"228":2,"359":1,"407":1,"414":1,"419":4,"421":1,"423":1,"442":1,"445":1,"446":1,"1039":1,"1368":1,"1369":1,"1372":1,"1379":1,"1382":6,"1388":2,"1389":1,"1392":4,"1428":1,"1429":3,"1430":2}}],["matariki",{"2":{"1213":1}}],["matrices",{"2":{"697":1,"1105":1}}],["matrix",{"0":{"953":1,"1011":1,"1123":1,"1125":1,"1376":1},"1":{"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":1,"1135":1,"1136":1},"2":{"138":1,"1011":1,"1105":1,"1123":1}}],["mathjax",{"2":{"617":1}}],["mathematics",{"2":{"167":1,"361":1,"520":1,"606":1,"1299":1,"1339":1}}],["mathematically",{"2":{"161":1,"163":1,"167":1,"202":1,"271":1,"321":1,"387":1,"403":1,"412":1,"418":1,"422":1,"512":1,"516":1,"520":1,"711":1,"888":1}}],["mathematical",{"0":{"893":1},"2":{"137":1,"157":1,"174":1,"187":1,"266":1,"366":1,"423":1,"522":2,"606":1,"681":1,"897":1,"1080":1,"1242":1,"1272":1}}],["math",{"0":{"162":1,"163":1,"181":1,"318":1,"368":1,"520":1,"681":1},"1":{"182":1,"183":1,"184":1,"185":1,"186":1,"187":1,"188":1,"189":1,"190":1,"191":1,"192":1,"193":1,"194":1,"195":1,"319":1,"320":1,"321":1},"2":{"121":1,"147":1,"157":1,"161":4,"162":1,"163":1,"165":1,"191":1,"229":1,"233":2,"235":1,"265":1,"324":2,"326":1,"507":4,"519":3,"520":1,"588":1,"606":1,"679":1,"699":1,"731":1,"734":1,"747":1,"894":1,"909":3,"913":1,"921":1,"993":1,"1039":1,"1054":1,"1081":3,"1084":1,"1085":1,"1162":1,"1178":1,"1218":1,"1223":1,"1266":1,"1363":1,"1365":2}}],["matched",{"2":{"351":1,"752":1}}],["matches",{"2":{"158":1,"241":2,"274":1,"351":1,"363":2,"634":1,"667":1,"757":1,"767":1}}],["matchers",{"2":{"798":1}}],["matcher",{"2":{"96":1,"1140":1}}],["match",{"2":{"127":2,"138":1,"145":2,"155":1,"220":1,"239":1,"240":1,"289":1,"292":1,"337":1,"339":1,"351":3,"394":1,"416":1,"469":1,"506":1,"647":1,"660":1,"738":3,"806":1,"978":1,"988":1,"1119":1,"1157":1,"1195":1,"1309":1,"1312":1}}],["matching",{"0":{"802":1,"806":1},"2":{"32":1,"93":1,"126":1,"138":10,"150":2,"221":1,"301":2,"363":1,"365":1,"416":3,"571":1,"771":1,"802":1,"806":1,"882":1,"1104":1,"1135":1,"1140":1,"1263":1,"1265":1,"1293":1,"1454":1}}],["maxcommercialspeedkmh",{"2":{"1363":1}}],["maxspeed",{"2":{"1361":1}}],["maxsize",{"2":{"94":2,"687":1,"694":2}}],["maxdist",{"2":{"1344":1,"1345":1}}],["maxdistance",{"2":{"1334":1}}],["maxlng",{"2":{"1336":1,"1337":1,"1338":2,"1364":1}}],["maxlat",{"2":{"1336":1,"1337":1,"1338":1,"1364":1}}],["maxacceptablerttms",{"2":{"1233":1,"1240":1}}],["max",{"2":{"1041":1,"1178":1}}],["maximize",{"2":{"367":1,"1042":1,"1098":1}}],["maximum",{"0":{"311":1},"2":{"94":1,"137":1,"260":1,"311":1,"400":1,"940":1,"1030":1,"1076":1,"1083":1,"1231":1,"1240":1,"1344":1,"1404":1}}],["maintenance",{"2":{"507":1,"515":1,"958":1,"1224":1}}],["maintainability",{"2":{"1098":1}}],["maintainers",{"2":{"922":1}}],["maintained",{"2":{"8":1,"529":1,"559":1,"1235":1,"1267":1}}],["maintaining",{"2":{"451":1,"462":1,"514":1,"524":1,"527":1,"869":1,"1149":1}}],["maintains",{"2":{"215":1,"407":1,"410":1,"423":1,"642":1,"643":1,"983":1,"1426":1}}],["maintain",{"2":{"0":1,"102":1,"138":1,"370":1,"387":1,"514":1,"519":2,"668":1,"1143":1}}],["mainframe",{"2":{"138":1}}],["main",{"2":{"102":2,"103":1,"104":1,"260":1,"291":1,"311":1,"623":1,"671":1,"1028":1,"1029":1,"1040":1,"1042":2,"1388":1,"1389":1,"1394":1,"1395":1,"1443":1}}],["mai",{"2":{"76":2,"219":1,"737":1,"752":1}}],["major",{"0":{"757":1,"836":1},"2":{"44":1,"47":1,"365":1,"574":1,"575":1,"674":1,"835":1,"995":1,"1123":1,"1212":1,"1306":1}}],["manuscript",{"0":{"1308":1},"1":{"1309":1,"1310":1},"2":{"1299":1,"1301":1}}],["manual",{"0":{"217":1,"320":1},"2":{"11":1,"119":1,"139":1,"282":1,"373":2,"507":4,"519":1,"631":1,"716":1,"729":1,"1113":1,"1134":1,"1143":1}}],["manually",{"2":{"6":1,"46":1,"128":1,"146":1,"161":1,"162":1,"269":1,"280":1,"320":1,"446":1,"466":1,"491":1,"552":1,"787":1,"1149":1,"1258":1,"1405":1,"1436":1}}],["manipulates",{"2":{"1259":1}}],["manipulating",{"2":{"378":1}}],["manipulation",{"0":{"61":1},"1":{"62":1,"63":1,"64":1,"65":1,"66":1},"2":{"50":1,"255":1,"273":1,"361":1,"402":1,"1319":1}}],["manifests",{"0":{"856":1},"2":{"1001":2,"1011":1}}],["manifest",{"0":{"1001":1},"2":{"855":1,"856":7,"932":2,"937":1,"938":1,"958":3}}],["mangles",{"2":{"503":1}}],["mangle",{"2":{"498":1}}],["mandates",{"2":{"1017":1}}],["mandate",{"2":{"283":1}}],["managing",{"2":{"281":1,"694":1,"924":1,"1436":1,"1446":1}}],["manages",{"2":{"953":1}}],["manage",{"2":{"474":1}}],["managedstream",{"2":{"494":1}}],["managed",{"2":{"93":1,"953":1}}],["management",{"0":{"92":1,"335":1,"336":1,"337":1,"417":1,"476":1,"494":1,"966":1,"971":1,"1256":1,"1371":1,"1373":1,"1431":1,"1432":1,"1445":1},"1":{"93":1,"94":1,"95":1,"96":1,"97":1,"98":1,"99":1,"338":1,"339":1,"418":1,"419":1,"495":1,"967":1,"968":1,"969":1,"970":1,"971":1,"972":2,"973":2,"974":2,"975":2,"976":2,"977":2,"978":2,"979":2,"980":2,"1372":1,"1373":1,"1374":1,"1432":1,"1433":2,"1434":2,"1435":1,"1436":1,"1437":1,"1438":1,"1439":1,"1440":1,"1441":1,"1442":1},"2":{"94":1,"251":1,"373":1,"402":1,"422":1,"473":1,"475":2,"480":1,"491":1,"539":1,"543":2,"580":1,"612":1,"614":1,"649":1,"697":1,"717":1,"754":1,"792":1,"831":1,"836":1,"921":1,"955":1,"1008":1,"1221":1,"1256":1,"1373":1,"1383":1,"1396":1,"1401":2,"1431":1,"1432":1,"1442":1,"1443":1,"1445":1,"1454":1}}],["manager",{"2":{"35":1,"836":1,"846":1,"1004":1}}],["many",{"2":{"128":1,"158":1,"164":1,"233":1,"280":1,"402":1,"479":1,"522":1,"860":1,"948":1,"970":1,"1097":1}}],["may",{"2":{"21":1,"34":1,"64":1,"76":1,"124":1,"157":1,"191":1,"197":1,"200":1,"201":2,"203":4,"210":1,"219":1,"328":1,"362":1,"446":1,"479":1,"560":1,"573":1,"726":1,"734":1,"737":1,"776":1,"863":1,"878":1,"908":1,"909":1,"968":1,"975":1,"1008":1,"1065":1,"1072":1,"1149":1,"1213":2,"1269":3,"1296":1,"1297":1,"1422":1}}],["mapbox",{"2":{"1168":1,"1175":1,"1178":2,"1189":1,"1191":1}}],["maps",{"2":{"304":1,"559":3,"560":1,"588":1,"798":1,"1042":1,"1160":1,"1175":1,"1189":1,"1276":1}}],["mapping",{"2":{"425":1,"466":1,"621":1,"776":1,"843":1,"869":2,"1105":1,"1121":1}}],["mappings",{"2":{"117":1,"203":1,"357":1,"455":1,"468":1,"544":2,"559":1,"695":1,"1012":1}}],["mapped",{"2":{"297":4,"348":1,"1113":1,"1115":1,"1319":1}}],["map",{"2":{"10":1,"43":5,"44":1,"95":4,"96":1,"223":1,"294":1,"296":3,"466":1,"468":1,"472":1,"498":1,"500":2,"501":1,"503":1,"505":1,"519":1,"642":1,"695":1,"712":1,"752":1,"854":1,"885":1,"937":2,"938":2,"974":2,"1121":1,"1307":1,"1329":1}}],["hft",{"0":{"1386":1},"1":{"1387":1,"1388":1,"1389":1},"2":{"1367":1}}],["hw",{"2":{"1083":1}}],["hmac",{"2":{"954":1,"1008":3}}],["hmr",{"2":{"402":1,"653":1,"663":1,"668":1}}],["hms",{"2":{"127":1,"137":1,"758":1}}],["h23",{"2":{"370":2,"1094":1}}],["h24",{"2":{"137":1,"139":2,"370":1,"1094":1}}],["h11",{"2":{"370":1,"1094":1}}],["h12",{"2":{"54":1,"137":1,"138":2,"139":11,"140":1,"144":1,"367":1,"370":2,"707":2,"786":1,"894":1,"1088":1,"1094":2,"1113":2,"1125":2,"1147":1}}],["hydrodynamic",{"2":{"1078":2}}],["hydrate",{"2":{"1193":1,"1381":2,"1389":2}}],["hydrates",{"2":{"910":1,"1382":1}}],["hydration",{"0":{"1042":1},"1":{"1043":1},"2":{"117":1,"129":1,"709":2,"910":1}}],["hybrida",{"2":{"1292":1,"1313":2}}],["hybrid",{"2":{"283":1,"668":1,"814":1,"816":1}}],["hr",{"0":{"1223":1},"2":{"166":1,"953":1,"1210":1}}],["hues",{"2":{"1084":1}}],["huntersmoon",{"2":{"1064":5}}],["hundreds",{"2":{"415":1,"1035":1,"1090":1,"1098":1}}],["hundredths",{"2":{"138":2}}],["hub",{"0":{"371":1,"787":1},"1":{"372":1,"373":1},"2":{"371":1,"373":1,"784":1}}],["humanities",{"2":{"1301":1}}],["humanizing",{"0":{"522":1}}],["humanized",{"0":{"689":1},"2":{"146":1,"373":1,"750":1}}],["humanize",{"2":{"146":1,"522":1,"528":1}}],["human",{"0":{"510":1,"520":1,"525":1},"2":{"59":1,"66":1,"125":1,"157":2,"159":1,"196":1,"213":1,"364":1,"368":1,"507":1,"510":1,"515":1,"517":1,"520":4,"522":2,"525":1,"688":1,"879":1,"882":1,"897":2,"982":2,"986":1,"1014":1,"1016":1,"1080":1}}],["himmelfahrt",{"2":{"1213":1}}],["hipaa",{"2":{"1017":1}}],["hint",{"2":{"899":1}}],["hi",{"2":{"889":1}}],["historians",{"2":{"1272":1,"1312":1}}],["historicalepochs",{"2":{"1033":2}}],["historically",{"2":{"329":1,"402":1,"1110":1}}],["historical",{"0":{"202":1,"1295":1},"2":{"202":2,"240":1,"654":1,"707":3,"1032":1,"1033":1,"1045":1,"1086":2,"1088":1,"1090":1,"1091":1,"1105":1,"1273":2,"1274":1,"1276":1,"1281":1,"1306":1,"1312":1}}],["history",{"0":{"576":1,"586":1,"604":1,"685":1,"761":1},"1":{"577":1,"578":1,"579":1,"580":1,"581":1,"582":1,"583":1,"584":1,"585":1,"587":1,"588":1,"589":1,"590":1,"591":1,"592":1,"593":1,"594":1,"595":1,"596":1,"597":1,"598":1,"599":1,"600":1,"601":1,"602":1,"603":1,"605":1,"606":1,"607":1,"608":1,"609":1,"610":1,"611":1,"612":1,"613":1,"614":1,"615":1,"616":1,"617":1,"618":1,"619":1,"620":1,"621":1,"622":1,"623":1,"624":1,"625":1,"626":1,"627":1,"628":1,"629":1,"630":1,"631":1,"632":1,"633":1,"634":1,"635":1,"636":1,"637":1,"638":1,"639":1,"640":1,"641":1,"642":1,"643":1,"644":1,"645":1,"646":1,"647":1,"648":1,"649":1,"650":1,"651":1,"652":1,"653":1,"654":1,"655":1,"656":1,"657":1,"658":1,"659":1,"660":1,"661":1,"662":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"670":1,"671":1,"672":1,"673":1,"674":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"686":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"693":1,"694":1,"695":1,"696":1,"697":1,"698":1,"699":1,"700":1,"701":1,"702":1,"703":1,"704":1,"705":1,"706":1,"707":1,"708":1,"709":1,"710":1,"711":1,"712":1,"713":1,"714":1,"715":1,"716":1,"717":1,"718":1,"719":1,"720":1,"721":1,"722":1,"723":1,"724":1,"725":1,"726":1,"727":1,"728":1,"729":1,"730":1,"731":1,"732":1,"733":1,"734":1,"735":1,"736":1,"737":1,"738":1,"739":1,"740":1,"741":1,"742":1,"743":1,"744":1,"745":1,"746":1,"747":1,"748":1,"749":1,"750":1,"751":1,"752":1,"753":1,"754":1,"755":1,"756":1,"757":1,"758":1,"759":1,"760":1,"762":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"770":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"779":1,"780":1,"781":1,"782":1,"783":1,"784":1,"785":1,"786":1,"787":1,"788":1,"789":1,"790":1,"791":1,"792":1,"793":1,"794":1,"795":1,"796":1,"797":1,"798":1,"799":1,"800":1,"801":1,"802":1,"803":1,"804":1,"805":1,"806":1,"807":1,"808":1,"809":1,"810":1,"811":1,"812":1,"813":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"820":1,"821":1,"822":1,"823":1,"824":1,"825":1,"826":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"834":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"351":1,"574":1,"659":1,"1086":1}}],["hierarchies",{"2":{"465":1,"1095":1}}],["hierarchical",{"0":{"145":1},"2":{"145":1,"418":1,"775":1,"784":1,"788":1}}],["hierarchy",{"0":{"101":1,"338":1,"1214":1},"2":{"935":1,"979":1}}],["hidden",{"2":{"129":1,"931":1}}],["hitting",{"2":{"974":1}}],["hits",{"2":{"895":1,"968":1,"1188":1,"1260":1}}],["hit",{"2":{"98":1,"121":1,"755":1}}],["higher",{"2":{"1070":1}}],["highest",{"2":{"129":1,"290":1,"338":1,"948":1,"950":1,"1061":1,"1068":1,"1076":1}}],["highlights",{"0":{"763":1,"771":1,"780":1,"784":1,"790":1,"795":1,"800":1,"804":1,"810":1,"814":1,"821":1,"827":1,"835":1},"2":{"763":1,"771":1,"1125":1}}],["highlight",{"2":{"648":1}}],["highly",{"2":{"3":1,"44":1,"114":1,"147":1,"156":1,"165":1,"167":1,"221":1,"234":1,"271":1,"273":1,"377":1,"405":1,"409":1,"413":1,"418":1,"423":1,"424":1,"451":1,"505":1,"513":2,"520":1,"527":1,"606":1,"722":1,"750":1,"852":1,"869":1,"970":1,"1120":1}}],["high",{"0":{"371":1,"473":1,"488":1,"1027":1,"1039":1,"1267":1,"1327":1,"1386":1},"1":{"372":1,"373":1,"489":1,"490":1,"491":1,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1,"1028":1,"1029":1,"1030":1,"1328":1,"1329":1,"1387":1,"1388":1,"1389":1},"2":{"0":1,"92":1,"122":1,"124":1,"125":1,"126":1,"129":1,"228":1,"293":1,"336":1,"361":1,"363":1,"378":1,"407":2,"414":1,"415":1,"416":1,"418":1,"441":1,"449":1,"467":1,"476":1,"511":1,"515":1,"528":1,"529":1,"531":1,"532":1,"616":1,"666":1,"673":1,"694":1,"699":2,"711":1,"737":1,"754":1,"784":1,"792":1,"798":1,"867":2,"940":1,"947":1,"950":2,"953":1,"1011":1,"1026":1,"1045":1,"1072":1,"1076":2,"1077":1,"1078":2,"1080":1,"1083":4,"1098":1,"1106":1,"1122":1,"1125":1,"1140":1,"1143":1,"1144":2,"1191":1,"1212":1,"1225":1,"1226":1,"1232":1,"1233":1,"1235":1,"1236":1,"1267":1,"1301":1,"1322":1,"1328":1,"1367":1,"1368":1,"1376":1,"1377":1,"1381":1,"1382":1,"1383":1,"1396":1}}],["h",{"2":{"78":1,"885":2,"1089":2,"1090":1,"1101":1,"1103":3,"1104":2,"1115":1,"1116":2,"1125":9,"1129":1,"1134":1,"1136":1,"1144":3,"1149":1,"1150":1,"1344":1,"1348":2,"1360":3,"1361":3,"1363":3}}],["hhmiss",{"2":{"216":1,"758":1}}],["hh24",{"2":{"78":1,"1103":1,"1104":1,"1115":1,"1116":1,"1149":1,"1150":2}}],["hh",{"2":{"30":1,"68":2,"78":1,"117":1,"137":1,"138":9,"139":4,"144":1,"151":1,"224":1,"233":1,"240":1,"241":1,"245":1,"247":1,"295":1,"351":1,"364":1,"370":2,"734":1,"806":2,"817":1,"889":2,"968":1,"969":1,"988":2,"989":1,"1061":3,"1069":2,"1073":2,"1082":4,"1083":2,"1085":1,"1088":2,"1089":5,"1091":1,"1094":2,"1098":1,"1101":1,"1103":5,"1104":2,"1111":1,"1113":2,"1114":2,"1115":2,"1116":1,"1118":1,"1119":3,"1125":8,"1127":1,"1128":1,"1130":1,"1134":2,"1135":2,"1136":2,"1139":1,"1140":3,"1141":3,"1144":1,"1147":1,"1150":2,"1243":1,"1254":1,"1255":1,"1265":2,"1316":2,"1317":1,"1319":2,"1326":4,"1329":1,"1344":1,"1352":1,"1363":1,"1404":1,"1408":1,"1412":3,"1413":2,"1415":1,"1417":2,"1418":1,"1421":1,"1422":1,"1424":2,"1434":1,"1439":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1}}],["honored",{"2":{"1438":1}}],["horizon",{"0":{"1061":1},"2":{"1052":1,"1053":1,"1058":1,"1062":2,"1066":1,"1067":3,"1070":2,"1071":2,"1072":3,"1081":1}}],["horizontal",{"2":{"709":1,"1062":1,"1066":1,"1071":1}}],["home",{"2":{"874":1,"1157":1,"1314":1}}],["hoisting",{"2":{"848":1}}],["hot",{"2":{"747":1,"755":1,"1122":1,"1371":1}}],["hotfix",{"0":{"651":1}}],["hood",{"2":{"453":1,"470":1,"499":1,"513":1,"516":1,"524":1,"1186":1}}],["hook",{"0":{"324":1},"2":{"323":1,"325":1,"402":1,"420":1,"421":1,"653":1,"704":1,"778":2,"856":2,"938":1,"998":1,"1001":1,"1405":2}}],["hooks",{"0":{"282":1,"322":1,"323":1},"1":{"323":1,"324":1,"325":1},"2":{"69":1,"119":1,"282":1,"322":1,"325":2,"421":1,"475":1,"483":1,"539":2,"771":2,"773":1,"775":1,"836":1,"998":1,"1011":1,"1055":1,"1440":1}}],["holds",{"2":{"301":1}}],["holding",{"2":{"102":1,"830":1,"1312":1}}],["holidayoptions",{"2":{"276":1}}],["holiday",{"0":{"885":1},"2":{"274":1,"280":1,"285":2,"291":2,"531":1,"881":1,"882":1,"909":1,"1195":2,"1203":1,"1206":1,"1207":1,"1209":1,"1213":5,"1214":1,"1215":1,"1219":1,"1220":2,"1222":5,"1224":1,"1225":1}}],["holidaypluginoptions",{"2":{"285":2}}],["holidayplugin",{"2":{"274":2,"285":5,"289":2,"291":1}}],["holidaysincluded",{"2":{"1223":5}}],["holidays",{"0":{"1197":2,"1199":1,"1201":1,"1203":1,"1206":1,"1216":1,"1217":1},"1":{"1207":1,"1208":1,"1209":1,"1210":1,"1211":1},"2":{"235":1,"289":1,"881":1,"882":2,"884":1,"885":4,"919":1,"950":1,"1194":2,"1195":3,"1197":3,"1199":2,"1201":2,"1203":2,"1204":1,"1205":2,"1206":1,"1207":2,"1208":1,"1209":7,"1212":1,"1213":2,"1214":7,"1215":2,"1216":6,"1217":3,"1218":3,"1219":2,"1220":4,"1221":6,"1222":4,"1223":5,"1224":3,"1225":1}}],["houses",{"2":{"1221":1}}],["house",{"2":{"142":1,"1181":1}}],["hour",{"0":{"1084":1,"1094":1,"1136":1,"1184":1,"1204":1},"2":{"137":3,"138":4,"139":5,"151":2,"191":1,"225":1,"240":1,"245":1,"306":1,"315":1,"320":2,"324":3,"364":1,"370":4,"639":1,"689":1,"694":1,"775":1,"904":1,"954":1,"978":1,"979":1,"987":1,"1047":2,"1052":1,"1063":1,"1082":1,"1084":2,"1088":2,"1089":1,"1094":3,"1113":1,"1124":1,"1125":8,"1134":1,"1136":3,"1139":1,"1141":1,"1182":2,"1183":1,"1207":2,"1215":1,"1255":1,"1319":2,"1348":1,"1353":1,"1416":1}}],["hourcycle",{"2":{"137":1,"138":1,"367":1,"370":1,"786":1,"817":1,"1094":1}}],["hoursinday",{"2":{"149":1,"818":1}}],["hours",{"0":{"1071":1,"1202":1},"1":{"1203":1,"1204":1},"2":{"9":1,"23":1,"62":1,"94":1,"158":2,"161":1,"164":1,"165":2,"167":1,"177":1,"221":1,"224":1,"225":2,"370":1,"387":1,"522":1,"639":1,"880":2,"882":2,"884":1,"895":1,"902":1,"919":1,"978":1,"987":1,"988":1,"993":1,"1008":1,"1015":1,"1016":1,"1023":2,"1028":1,"1072":1,"1079":1,"1094":2,"1136":2,"1184":1,"1192":2,"1194":1,"1203":9,"1204":1,"1206":1,"1207":2,"1209":2,"1218":2,"1219":2,"1220":1,"1315":1,"1319":2,"1344":1,"1352":3,"1360":1,"1366":1,"1404":2,"1412":1,"1413":3,"1448":1}}],["hoc",{"2":{"129":1,"556":1}}],["hosting",{"2":{"1378":1}}],["hosted",{"2":{"858":1,"1005":1,"1178":1,"1189":1}}],["hosts",{"2":{"109":1,"856":1,"1001":1,"1376":1}}],["host",{"0":{"1001":1},"2":{"34":1,"114":1,"365":3,"367":1,"617":1,"626":1,"856":3,"874":1,"937":2,"1038":1,"1054":1,"1106":1,"1375":1,"1376":1}}],["however",{"2":{"161":1,"233":1,"358":1,"363":1,"407":1,"424":1,"464":1,"522":1,"854":1,"863":1,"1041":1,"1086":1,"1351":1}}],["how",{"0":{"21":1,"52":1,"54":1,"55":1,"65":1,"220":1,"312":1,"399":1,"412":1,"414":1,"416":1,"418":1,"427":1,"453":1,"465":1,"466":1,"504":1,"1451":1,"1452":1},"1":{"313":1,"314":1,"315":1,"316":1,"317":1,"454":1,"455":1,"456":1},"2":{"44":1,"128":1,"140":1,"157":2,"158":1,"164":1,"233":1,"246":1,"262":1,"265":1,"274":1,"275":1,"294":2,"349":1,"361":4,"363":1,"374":1,"452":2,"498":1,"516":1,"522":1,"711":1,"739":1,"844":1,"851":1,"908":1,"921":1,"986":1,"1089":2,"1158":1,"1175":1,"1322":1,"1444":1}}],["havok",{"2":{"1391":1}}],["haversine",{"2":{"1344":1,"1355":1,"1360":1}}],["haversinedistance",{"0":{"1355":1},"1":{"1356":1,"1357":1},"2":{"1334":1,"1357":2}}],["have",{"2":{"20":1,"34":1,"43":1,"46":1,"97":1,"131":1,"161":1,"165":1,"229":2,"233":1,"260":1,"293":1,"308":1,"311":1,"316":1,"346":1,"387":1,"505":1,"509":1,"514":1,"515":2,"517":2,"519":2,"537":1,"539":1,"541":1,"559":1,"563":1,"564":1,"584":1,"729":1,"732":1,"738":1,"757":1,"856":1,"1011":1,"1086":1,"1089":1,"1205":1,"1232":1,"1271":1}}],["hackathons",{"2":{"1224":1}}],["hacks",{"2":{"439":1}}],["hamburg",{"2":{"1083":2}}],["hanging",{"2":{"935":1}}],["hangs",{"2":{"683":1,"829":1,"1431":1}}],["handoffs",{"2":{"1233":1}}],["handoff",{"2":{"114":1}}],["hand",{"2":{"98":2,"559":1,"1139":1}}],["handleaiproxy",{"2":{"955":1}}],["handler",{"0":{"860":1},"2":{"408":1,"409":1,"412":1,"860":1,"955":1,"1168":2}}],["handlers",{"2":{"119":1,"478":1,"980":1,"1443":1}}],["handled",{"2":{"200":1,"288":1,"480":1,"556":1,"565":1,"1338":1}}],["handle",{"2":{"122":1,"313":1,"324":1,"367":1,"470":1,"527":1,"1029":1,"1112":1,"1362":1,"1442":1}}],["handles",{"2":{"41":1,"43":1,"60":1,"146":1,"206":1,"232":1,"256":1,"312":1,"326":1,"363":1,"408":1,"411":1,"517":1,"939":1,"955":1,"993":1,"1008":1,"1396":1,"1431":1,"1441":1,"1442":3,"1445":1}}],["handling",{"0":{"59":1,"281":1,"912":1,"970":1,"1006":1,"1008":1,"1072":1},"1":{"1007":1,"1008":1,"1009":1},"2":{"43":1,"125":1,"156":1,"499":1,"510":1,"517":1,"565":1,"567":1,"593":1,"620":1,"621":1,"622":1,"637":1,"644":1,"654":1,"681":1,"684":1,"714":1,"763":1,"920":1,"921":1,"953":1,"1066":1,"1105":1,"1185":1,"1189":1,"1227":1,"1275":1,"1446":1}}],["hallucinates",{"2":{"976":1}}],["hallucinate",{"2":{"972":1,"1010":1}}],["hallucinated",{"2":{"893":1,"909":1,"1012":1}}],["hallucination",{"0":{"893":1,"1010":1},"2":{"867":1,"950":1}}],["hallucinations",{"2":{"24":1,"48":1,"884":1,"902":1,"909":2,"921":1,"972":1,"1008":1}}],["half",{"2":{"639":1,"689":1}}],["halts",{"2":{"1382":1}}],["halted",{"2":{"1374":1}}],["halt",{"2":{"490":1}}],["hatches",{"0":{"369":1},"2":{"522":1}}],["hazards",{"2":{"773":1,"1012":1}}],["hazard",{"2":{"261":1}}],["harmonized",{"2":{"666":1}}],["harmonize",{"2":{"567":1}}],["harmony",{"2":{"34":1}}],["harnesses",{"2":{"402":1}}],["hardcode",{"2":{"1097":1}}],["hardcoded",{"0":{"1097":1},"2":{"215":1,"737":1,"738":1}}],["hardware",{"2":{"407":1,"419":1,"1168":1,"1169":1,"1176":1,"1367":1,"1369":1,"1370":1,"1378":1,"1383":1,"1422":1}}],["hardening",{"0":{"616":1,"617":1,"653":1,"995":1,"999":1,"1262":1,"1263":1},"1":{"996":1,"997":1,"1000":1,"1001":1,"1263":1,"1264":1},"2":{"402":1,"574":1,"617":1,"633":1,"825":1}}],["hardened",{"0":{"402":1,"404":1,"527":1,"664":1,"825":1},"2":{"340":1,"402":2,"573":1,"616":1,"625":1,"631":1,"649":2,"665":1,"668":1,"702":1,"724":1,"726":1,"729":1,"744":1,"748":1}}],["hard",{"2":{"331":1,"414":1,"431":1,"437":2,"935":1,"1143":1,"1191":1}}],["happens",{"2":{"112":1,"315":1,"321":1,"409":1}}],["hasnativeformatbraces",{"2":{"778":1}}],["hasnoneof",{"2":{"769":1}}],["hasanyof",{"2":{"769":1}}],["haskeys",{"2":{"769":1}}],["haskey",{"2":{"769":1}}],["hasown",{"2":{"461":2,"464":2}}],["hasownproperty",{"2":{"453":1}}],["hashicorp",{"2":{"1004":1}}],["hashing",{"2":{"504":1,"1008":1}}],["hashes",{"2":{"954":1,"1008":1}}],["hashed",{"2":{"866":1,"1008":1}}],["hash",{"2":{"89":1,"90":1}}],["has",{"2":{"3":1,"34":1,"102":1,"170":1,"188":1,"228":1,"234":1,"314":1,"336":1,"342":1,"365":1,"385":1,"451":1,"461":1,"463":1,"464":1,"467":1,"468":1,"526":1,"541":1,"544":2,"546":3,"548":1,"556":1,"560":1,"561":1,"562":1,"571":1,"573":1,"699":1,"702":1,"705":1,"712":1,"717":1,"722":1,"734":1,"735":1,"757":3,"758":1,"812":1,"836":2,"912":1,"942":1,"986":1,"1088":1,"1091":1,"1110":1,"1146":1,"1249":1,"1257":2}}],["heterogeneous",{"0":{"1138":1},"1":{"1139":1,"1140":1,"1141":1}}],["hedge",{"2":{"937":1,"938":1,"946":1}}],["hedgedelay",{"2":{"871":1,"934":1,"937":1,"938":1,"946":4}}],["hedged",{"0":{"946":1},"2":{"696":1,"867":2,"871":2,"881":1,"890":1,"899":1,"921":1,"934":5,"937":2,"938":3,"939":1,"940":1,"942":2,"946":1,"959":1,"963":1,"989":1}}],["hedging",{"0":{"946":1},"2":{"871":1,"934":1,"939":1}}],["hero",{"2":{"666":1}}],["here",{"0":{"465":1},"2":{"38":1,"41":1,"140":1,"232":1,"266":1,"276":1,"335":1,"479":1,"516":1,"1433":1,"1445":1}}],["hebrew",{"2":{"370":1,"802":1,"890":1}}],["heuristic",{"2":{"365":1}}],["heuristics",{"2":{"361":1,"365":1,"375":1,"631":1}}],["hence",{"2":{"240":1,"397":2,"737":2}}],["heartbeat",{"0":{"1444":1},"2":{"1444":5}}],["heartbeats",{"2":{"1401":1,"1444":1}}],["healing",{"2":{"1443":1}}],["healthcheck",{"2":{"1417":2,"1444":1}}],["healthcare",{"2":{"1017":1}}],["health",{"2":{"1011":1,"1224":1}}],["heap",{"2":{"451":1,"798":1,"1041":1}}],["heapuseddeltamb",{"2":{"449":1,"451":1}}],["heading",{"2":{"1347":2,"1358":2,"1365":1}}],["headroom",{"2":{"948":1}}],["headless",{"2":{"367":1}}],["headerssent",{"2":{"955":1}}],["headers",{"2":{"536":1,"838":1,"860":5,"948":1,"955":2,"966":1,"968":2,"1178":2,"1188":1,"1193":5,"1226":1,"1232":1,"1236":1,"1240":1,"1242":1,"1262":1,"1264":1,"1375":1,"1376":3,"1378":2,"1444":1}}],["header",{"2":{"90":1,"948":1,"1144":1,"1178":1,"1232":1}}],["heavier",{"2":{"505":1}}],["heavily",{"2":{"137":1,"361":1,"364":1,"466":1,"471":2,"499":1,"515":1,"1233":1}}],["heavy",{"2":{"12":1,"127":1,"199":1,"416":1,"488":1,"504":1,"751":1,"909":1,"1018":1}}],["hemispheres",{"2":{"326":1,"1060":1}}],["hemisphere",{"0":{"824":1,"1060":1},"2":{"73":1,"84":1,"117":1,"121":1,"142":1,"154":1,"227":2,"302":1,"303":3,"304":3,"364":1,"519":3,"649":1,"824":1,"869":1,"872":1,"907":2,"1044":1,"1046":5,"1052":2,"1053":1,"1054":1,"1058":1,"1344":1,"1365":2}}],["hemispheric",{"0":{"73":1}}],["helsinki",{"2":{"296":1}}],["helps",{"2":{"331":1}}],["helper",{"0":{"319":1},"2":{"319":1,"427":1,"456":1,"461":1,"507":1,"513":1,"588":1,"793":1}}],["helpers",{"2":{"14":1,"463":1,"471":1,"588":2,"666":1,"743":1,"769":1,"787":1,"790":1,"1341":1}}],["helping",{"2":{"23":1,"645":1,"747":1}}],["help",{"0":{"293":1},"2":{"22":1,"293":1,"342":1,"407":1,"529":1}}],["hello",{"2":{"15":1,"261":1}}],["httpcross",{"2":{"1375":1}}],["httphttp",{"2":{"1232":1}}],["http",{"0":{"1227":1},"1":{"1228":1,"1229":1,"1230":1,"1231":1},"2":{"109":1,"588":1,"829":4,"854":1,"855":1,"862":1,"933":1,"942":1,"948":1,"966":1,"968":1,"970":1,"1000":2,"1004":2,"1011":3,"1017":1,"1029":1,"1189":1,"1192":1,"1226":1,"1227":4,"1232":2,"1236":1,"1240":1,"1246":1,"1262":2,"1375":1,"1378":1,"1443":1}}],["https",{"0":{"862":1,"1000":1},"2":{"4":1,"10":2,"26":1,"27":2,"28":1,"31":1,"42":2,"43":3,"44":5,"45":3,"47":2,"247":2,"829":1,"850":3,"854":1,"856":4,"859":1,"860":1,"862":1,"921":1,"931":1,"932":1,"938":1,"953":1,"955":2,"958":1,"1000":2,"1239":1,"1263":2,"1264":1}}],["html5",{"2":{"655":1}}],["html",{"2":{"10":1,"42":2,"43":1,"44":1,"45":1,"651":1,"709":1,"741":1,"850":2}}],["xxx",{"2":{"1125":1}}],["xxvi",{"2":{"763":1,"765":1}}],["xss",{"2":{"857":1,"1005":1}}],["xiv",{"2":{"767":1}}],["xii",{"2":{"766":1}}],["xvii",{"2":{"1270":1,"1276":2,"1280":2,"1303":1,"1304":3}}],["xvi",{"2":{"763":1,"765":1}}],["x86",{"2":{"419":2,"1370":1}}],["xmas",{"2":{"240":1,"338":1,"351":1}}],["x26",{"2":{"78":1,"146":1,"222":1,"265":2,"266":2,"270":2,"274":2,"313":1,"363":1,"381":1,"461":2,"519":4,"542":1,"737":1,"787":1,"850":1,"860":1,"955":2,"958":1,"962":2,"970":2,"978":1,"982":1,"1055":4,"1178":5,"1184":1,"1191":5,"1209":1,"1221":1}}],["x3c",{"2":{"10":4,"42":4,"43":6,"44":2,"45":11,"69":1,"119":1,"222":1,"233":1,"235":1,"243":3,"246":5,"324":2,"332":2,"394":2,"437":1,"456":2,"481":1,"483":1,"489":1,"492":1,"493":1,"494":1,"519":3,"734":1,"737":1,"792":1,"793":1,"797":1,"850":10,"854":1,"938":10,"978":1,"986":1,"991":1,"992":2,"1013":1,"1014":1,"1015":1,"1016":1,"1030":1,"1033":1,"1036":1,"1176":6,"1220":1,"1223":1,"1227":1,"1265":1,"1329":3,"1334":1,"1373":1,"1389":1,"1427":1,"1445":2,"1446":1}}],["x",{"0":{"535":1,"547":1,"548":1,"549":1,"554":1,"555":1,"576":1,"586":1,"604":1,"685":1,"761":1},"1":{"536":1,"537":1,"538":1,"539":1,"548":1,"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":1,"559":1,"560":1,"561":1,"562":1,"563":1,"564":1,"565":1,"566":1,"567":1,"568":1,"569":1,"570":1,"571":1,"572":1,"573":1,"577":1,"578":1,"579":1,"580":1,"581":1,"582":1,"583":1,"584":1,"585":1,"587":1,"588":1,"589":1,"590":1,"591":1,"592":1,"593":1,"594":1,"595":1,"596":1,"597":1,"598":1,"599":1,"600":1,"601":1,"602":1,"603":1,"605":1,"606":1,"607":1,"608":1,"609":1,"610":1,"611":1,"612":1,"613":1,"614":1,"615":1,"616":1,"617":1,"618":1,"619":1,"620":1,"621":1,"622":1,"623":1,"624":1,"625":1,"626":1,"627":1,"628":1,"629":1,"630":1,"631":1,"632":1,"633":1,"634":1,"635":1,"636":1,"637":1,"638":1,"639":1,"640":1,"641":1,"642":1,"643":1,"644":1,"645":1,"646":1,"647":1,"648":1,"649":1,"650":1,"651":1,"652":1,"653":1,"654":1,"655":1,"656":1,"657":1,"658":1,"659":1,"660":1,"661":1,"662":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"670":1,"671":1,"672":1,"673":1,"674":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"686":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"693":1,"694":1,"695":1,"696":1,"697":1,"698":1,"699":1,"700":1,"701":1,"702":1,"703":1,"704":1,"705":1,"706":1,"707":1,"708":1,"709":1,"710":1,"711":1,"712":1,"713":1,"714":1,"715":1,"716":1,"717":1,"718":1,"719":1,"720":1,"721":1,"722":1,"723":1,"724":1,"725":1,"726":1,"727":1,"728":1,"729":1,"730":1,"731":1,"732":1,"733":1,"734":1,"735":1,"736":1,"737":1,"738":1,"739":1,"740":1,"741":1,"742":1,"743":1,"744":1,"745":1,"746":1,"747":1,"748":1,"749":1,"750":1,"751":1,"752":1,"753":1,"754":1,"755":1,"756":1,"757":1,"758":1,"759":1,"760":1,"762":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"770":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"779":1,"780":1,"781":1,"782":1,"783":1,"784":1,"785":1,"786":1,"787":1,"788":1,"789":1,"790":1,"791":1,"792":1,"793":1,"794":1,"795":1,"796":1,"797":1,"798":1,"799":1,"800":1,"801":1,"802":1,"803":1,"804":1,"805":1,"806":1,"807":1,"808":1,"809":1,"810":1,"811":1,"812":1,"813":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"820":1,"821":1,"822":1,"823":1,"824":1,"825":1,"826":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"834":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"3":1,"19":1,"138":1,"270":1,"367":1,"469":2,"535":2,"537":1,"545":1,"547":1,"549":2,"551":1,"554":1,"556":2,"563":2,"564":2,"573":3,"574":5,"759":1,"763":2,"765":1,"766":2,"767":1,"786":1,"836":1,"941":3,"948":1,"966":1,"1090":2,"1125":1,"1188":1,"1193":1}}],["0x07",{"2":{"1368":1}}],["0x06",{"2":{"1368":1}}],["0x05",{"2":{"1368":1}}],["0x04",{"2":{"1368":1}}],["0x03",{"2":{"1368":1}}],["0x02",{"2":{"1368":1}}],["0x01",{"2":{"1368":1}}],["0x00",{"2":{"1368":1}}],["0=1",{"2":{"1272":1}}],["0=off",{"2":{"117":1}}],["0h",{"2":{"1209":1}}],["0°",{"2":{"1046":1,"1062":2,"1063":1,"1071":2,"1076":1,"1344":1,"1358":2}}],["0650",{"2":{"1338":1}}],["06",{"0":{"624":1,"725":1,"727":1,"730":1,"733":1,"736":1,"740":1,"742":1,"745":1,"749":1,"753":1,"756":1},"1":{"625":1,"626":1,"627":1,"726":1,"728":1,"729":1,"731":1,"732":1,"734":1,"735":1,"737":1,"738":1,"739":1,"741":1,"743":1,"744":1,"746":1,"747":1,"748":1,"750":1,"751":1,"752":1,"754":1,"755":1,"757":1,"758":1,"759":1,"760":1},"2":{"334":1,"520":2,"543":1,"1048":1,"1055":1,"1056":1,"1060":2,"1061":1,"1067":1,"1068":2,"1069":1,"1070":1,"1072":1,"1158":1,"1171":1,"1180":1,"1195":1,"1197":1,"1222":1,"1232":2,"1316":1,"1317":1,"1326":1,"1329":5,"1348":2,"1360":2,"1361":2,"1363":2,"1366":1,"1415":1}}],["0ns",{"2":{"325":1}}],["0kb",{"2":{"283":1}}],["0347°",{"2":{"1070":1}}],["03t21",{"2":{"1078":1}}],["03t15",{"2":{"1078":1}}],["03t12",{"2":{"1059":1,"1076":1,"1078":2}}],["03t09",{"2":{"905":1}}],["03",{"0":{"587":1,"591":1,"595":1,"599":1},"1":{"588":1,"589":1,"590":1,"592":1,"593":1,"594":1,"596":1,"597":1,"598":1,"600":1,"601":1,"602":1,"603":1},"2":{"138":2,"139":4,"140":1,"144":1,"370":1,"849":1,"1047":1,"1059":1,"1076":1,"1078":4,"1141":1,"1147":1,"1190":2,"1195":1,"1214":1,"1273":1,"1280":2,"1307":1,"1313":2}}],["03pm",{"2":{"137":1}}],["09",{"0":{"713":1,"789":1,"794":1,"799":1,"803":1,"809":1,"813":1,"820":2,"826":1},"1":{"714":1,"790":1,"791":1,"792":1,"793":1,"795":1,"796":1,"797":1,"798":1,"800":1,"801":1,"802":1,"804":1,"805":1,"806":1,"807":1,"808":1,"810":1,"811":1,"812":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"821":2,"822":2,"823":2,"824":2,"825":2,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1},"2":{"95":1,"102":1,"105":1,"177":1,"178":1,"179":1,"180":2,"186":4,"325":1,"333":2,"367":1,"368":4,"520":2,"908":1,"982":1,"988":2,"1015":1,"1049":1,"1062":1,"1063":1,"1083":2,"1090":1,"1203":1,"1217":1,"1220":1}}],["02t12",{"2":{"1062":1}}],["02t17",{"2":{"898":1}}],["026",{"2":{"138":3}}],["02",{"0":{"783":1},"1":{"784":1,"785":1,"786":1,"787":1,"788":1},"2":{"78":1,"317":1,"372":1,"964":2,"1091":1,"1103":1,"1104":1,"1197":2,"1199":2,"1201":1,"1220":1,"1221":1,"1232":2,"1271":1,"1280":1}}],["050",{"2":{"1273":1,"1278":1,"1281":2,"1313":1}}],["05t14",{"2":{"1016":1}}],["05t18",{"2":{"905":1}}],["05t15",{"2":{"140":1,"903":1}}],["05",{"0":{"605":1,"608":1,"611":1,"615":1,"619":1,"624":1,"718":1,"779":1},"1":{"606":1,"607":1,"609":1,"610":1,"612":1,"613":1,"614":1,"616":1,"617":1,"618":1,"620":1,"621":1,"622":1,"623":1,"625":1,"626":1,"627":1,"719":1,"720":1,"780":1,"781":1,"782":1},"2":{"62":1,"64":1,"68":1,"76":1,"78":1,"123":1,"138":2,"147":1,"158":1,"159":2,"191":1,"197":1,"201":1,"207":1,"224":2,"231":1,"243":1,"247":1,"296":1,"335":1,"362":1,"376":4,"446":1,"448":2,"520":1,"731":1,"734":1,"878":2,"887":2,"962":1,"1065":1,"1090":1,"1096":1,"1103":1,"1104":1,"1190":2,"1205":2}}],["01t14",{"2":{"1316":1,"1317":1,"1326":1,"1329":5}}],["01t09",{"2":{"880":1}}],["01t00",{"2":{"95":1,"695":1,"908":1,"974":1,"1419":2}}],["0100",{"2":{"1281":1}}],["01",{"2":{"58":1,"65":2,"73":2,"78":1,"138":3,"162":2,"164":2,"202":2,"205":1,"216":3,"217":2,"223":1,"240":4,"268":1,"283":2,"304":2,"370":1,"517":2,"518":2,"519":1,"766":2,"768":2,"806":1,"885":3,"887":1,"964":2,"1048":1,"1088":3,"1103":1,"1104":1,"1111":1,"1113":1,"1125":4,"1136":2,"1153":1,"1154":1,"1203":2,"1209":4,"1216":2,"1222":2,"1223":3,"1281":2,"1307":1,"1363":2,"1419":2}}],["00+",{"2":{"1119":1}}],["00+10",{"2":{"197":1,"903":1}}],["00`",{"2":{"1082":1,"1085":1}}],["0060",{"2":{"1065":1,"1337":1,"1348":1,"1361":1}}],["006",{"2":{"1055":1,"1056":1,"1064":1,"1067":1,"1068":1,"1069":2,"1363":1}}],["001°",{"2":{"227":1}}],["001",{"2":{"138":1,"1125":1}}],["000062",{"2":{"1313":1}}],["000026",{"2":{"1307":1}}],["000043",{"2":{"1273":1,"1280":2,"1307":1,"1313":1}}],["000005",{"2":{"138":1}}],["000z",{"2":{"1078":2}}],["000",{"2":{"138":2,"442":1,"895":1,"904":1,"955":1,"972":3,"979":1,"1028":1,"1032":2,"1042":3,"1043":1,"1064":2,"1069":1,"1072":1,"1082":1,"1120":1,"1192":1,"1218":1,"1223":1,"1355":1,"1389":1}}],["00z",{"2":{"95":2,"154":1,"169":2,"170":2,"171":1,"176":2,"201":1,"695":2,"880":2,"889":1,"905":2,"908":1,"962":1,"974":2,"1016":1,"1047":1,"1055":1,"1056":1,"1059":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":2,"1076":1,"1078":2,"1141":2,"1158":1,"1171":1,"1180":1,"1316":1,"1317":1,"1348":2,"1360":2,"1361":2,"1419":2,"1421":1,"1439":2}}],["00am",{"2":{"54":1,"398":1}}],["00",{"0":{"1136":1},"2":{"52":1,"68":3,"78":2,"95":2,"97":1,"102":1,"123":2,"133":1,"138":11,"140":1,"144":2,"146":1,"149":2,"158":2,"167":2,"169":2,"170":2,"171":1,"176":1,"177":2,"178":4,"179":6,"180":6,"186":15,"190":6,"197":2,"201":1,"214":1,"224":3,"240":2,"296":3,"306":8,"333":1,"368":6,"369":6,"370":3,"398":1,"399":3,"418":1,"518":2,"519":2,"520":2,"637":1,"690":1,"695":2,"880":2,"889":3,"898":6,"903":2,"905":2,"908":1,"910":2,"912":2,"962":1,"965":2,"974":2,"982":1,"988":6,"993":1,"1015":2,"1047":1,"1055":1,"1056":1,"1059":1,"1061":1,"1062":1,"1063":1,"1067":1,"1068":1,"1069":5,"1070":1,"1071":1,"1072":2,"1076":1,"1078":2,"1081":1,"1082":1,"1083":2,"1085":1,"1088":3,"1094":3,"1111":1,"1113":1,"1119":1,"1125":5,"1131":2,"1136":10,"1158":1,"1171":1,"1180":1,"1203":12,"1204":2,"1209":4,"1220":1,"1232":2,"1260":3,"1316":1,"1325":3,"1326":2,"1348":2,"1360":2,"1361":1,"1363":3,"1366":2,"1415":2,"1419":2,"1420":2,"1421":1,"1439":4,"1447":1}}],["0700",{"2":{"1096":1}}],["07t17",{"2":{"898":1}}],["07",{"0":{"577":1,"693":1,"698":1,"700":1,"703":1,"706":1,"710":1,"713":1,"715":1,"718":1,"721":1},"1":{"578":1,"579":1,"580":1,"581":1,"582":1,"694":1,"695":1,"696":1,"697":1,"699":1,"701":1,"702":1,"704":1,"705":1,"707":1,"708":1,"709":1,"711":1,"712":1,"714":1,"716":1,"717":1,"719":1,"720":1,"722":1,"723":1,"724":1},"2":{"52":1,"63":1,"73":2,"95":1,"169":2,"170":2,"171":1,"176":2,"268":1,"520":4,"695":1,"974":1,"1046":3,"1153":1,"1154":1,"1195":2,"1197":3,"1199":3,"1201":2,"1217":1,"1222":2}}],["0444",{"2":{"1158":1,"1171":1}}],["04µs",{"2":{"442":1}}],["04ms",{"2":{"442":1}}],["045",{"2":{"138":1}}],["04012026",{"2":{"58":2,"215":3}}],["04",{"0":{"628":1,"632":1,"636":1,"638":1,"641":1,"646":1,"650":1,"652":1,"656":1,"658":1,"662":1,"670":1,"674":1,"721":1,"826":1},"1":{"629":1,"630":1,"631":1,"633":1,"634":1,"635":1,"637":1,"639":1,"640":1,"642":1,"643":1,"644":1,"645":1,"647":1,"648":1,"649":1,"651":1,"653":1,"654":1,"655":1,"657":1,"659":1,"660":1,"661":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"671":1,"672":1,"673":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"722":1,"723":1,"724":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1},"2":{"32":1,"78":1,"216":3,"217":2,"296":1,"306":1,"362":1,"878":2,"885":1,"1048":1,"1065":1,"1096":1,"1103":1,"1104":1,"1221":2,"1222":1,"1223":1}}],["08t18",{"2":{"1065":1}}],["08",{"0":{"619":1,"686":1,"715":1,"756":1,"834":1},"1":{"620":1,"621":1,"622":1,"623":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"716":1,"717":1,"757":1,"758":1,"759":1,"760":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"32":1,"62":1,"306":1,"689":2,"690":2,"695":1,"880":2,"887":4,"889":1,"898":2,"903":1,"905":2,"988":5,"1199":1,"1201":1,"1220":1,"1221":1,"1316":1,"1317":1,"1324":1,"1325":1,"1326":2,"1328":1,"1329":5,"1352":1,"1360":1}}],["08042026",{"2":{"31":1}}],["0",{"0":{"540":1,"557":1,"561":1,"562":1,"570":2,"576":1,"577":1,"583":1,"599":1,"605":1,"611":1,"624":1,"628":1,"632":1,"636":1,"638":1,"641":1,"646":1,"693":1,"703":1,"706":1,"710":1,"715":1,"718":1,"727":1,"730":1,"736":1,"749":1,"753":1,"756":2,"762":1,"770":1,"783":1,"809":1,"813":1,"820":1,"826":1,"834":2,"1094":1},"1":{"541":1,"542":1,"543":1,"544":1,"545":1,"546":1,"558":1,"559":1,"563":1,"564":1,"565":1,"571":2,"572":2,"577":1,"578":2,"579":2,"580":2,"581":2,"582":2,"583":1,"584":2,"585":2,"600":1,"601":1,"602":1,"603":1,"606":1,"607":1,"612":1,"613":1,"614":1,"625":1,"626":1,"627":1,"629":1,"630":1,"631":1,"633":1,"634":1,"635":1,"637":1,"639":1,"640":1,"642":1,"643":1,"644":1,"645":1,"647":1,"648":1,"649":1,"694":1,"695":1,"696":1,"697":1,"704":1,"705":1,"707":1,"708":1,"709":1,"711":1,"712":1,"716":1,"717":1,"719":1,"720":1,"728":1,"729":1,"731":1,"732":1,"737":1,"738":1,"739":1,"750":1,"751":1,"752":1,"754":1,"755":1,"757":2,"758":2,"759":2,"760":2,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"784":1,"785":1,"786":1,"787":1,"788":1,"810":1,"811":1,"812":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"821":1,"822":1,"823":1,"824":1,"825":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"835":2,"836":2,"837":2,"838":2,"839":2,"840":2,"841":2,"842":2,"843":2},"2":{"3":1,"9":1,"10":4,"19":1,"22":1,"42":1,"43":1,"44":3,"45":1,"116":1,"117":1,"121":1,"138":35,"148":1,"151":7,"152":2,"163":1,"202":1,"203":1,"225":2,"228":1,"229":1,"233":2,"235":2,"240":7,"264":1,"285":1,"288":2,"289":1,"290":1,"291":1,"297":1,"300":1,"320":1,"322":1,"324":11,"326":1,"328":1,"370":9,"373":1,"403":1,"412":1,"442":2,"450":2,"451":1,"454":1,"458":1,"461":1,"468":2,"497":2,"512":1,"536":4,"537":4,"538":2,"539":2,"540":1,"541":1,"542":1,"543":1,"545":2,"557":1,"572":2,"574":1,"584":2,"588":2,"603":1,"637":1,"728":1,"737":1,"763":1,"768":2,"771":1,"776":1,"784":1,"808":2,"810":1,"814":1,"821":1,"827":1,"829":2,"835":2,"850":1,"854":1,"860":1,"865":3,"870":1,"871":3,"872":3,"875":3,"880":1,"881":3,"882":3,"890":3,"891":6,"894":1,"898":1,"899":3,"900":3,"912":2,"927":1,"934":1,"937":5,"938":3,"942":2,"945":1,"947":2,"950":1,"961":1,"962":2,"965":1,"973":1,"978":3,"986":3,"989":3,"997":1,"998":1,"1010":1,"1030":2,"1036":1,"1053":6,"1055":2,"1059":4,"1062":1,"1065":6,"1067":2,"1070":1,"1072":1,"1076":1,"1077":4,"1081":1,"1082":1,"1084":1,"1088":1,"1094":4,"1125":1,"1132":1,"1136":2,"1178":7,"1191":1,"1203":7,"1209":1,"1223":1,"1234":2,"1240":4,"1261":1,"1263":1,"1313":1,"1329":1,"1337":1,"1347":2,"1348":1,"1358":1,"1360":2,"1363":1,"1365":1,"1368":1,"1369":2,"1370":1,"1389":1,"1401":1,"1404":1,"1409":1,"1417":1,"1420":1,"1436":1,"1438":1}}],["2ms",{"2":{"1387":1}}],["2°",{"2":{"1347":1}}],["2fa",{"0":{"1266":1},"2":{"1266":1}}],["2h",{"2":{"1209":2}}],["2pm",{"2":{"946":1}}],["2s",{"2":{"935":1}}],["2q1",{"2":{"734":1}}],["2945",{"2":{"1366":1}}],["29",{"0":{"698":1,"794":1},"1":{"699":1,"795":1,"796":1,"797":1,"798":1},"2":{"739":1,"1059":2,"1271":1}}],["297",{"2":{"137":1,"138":1,"152":1}}],["2kb",{"2":{"514":1,"515":1}}],["2779",{"2":{"1280":1,"1304":3}}],["270°",{"2":{"1046":1,"1062":1,"1071":1,"1076":1,"1358":1}}],["27",{"0":{"632":1,"799":1,"834":1},"1":{"633":1,"634":1,"635":1,"800":1,"801":1,"802":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"450":1,"451":1,"1203":3,"1209":2,"1224":2,"1307":1,"1329":1}}],["2+",{"2":{"335":1,"831":1,"1373":1,"1432":1}}],["217",{"2":{"1365":1}}],["21t08",{"2":{"1360":1}}],["21t02",{"2":{"1071":1}}],["21t11",{"2":{"1348":1}}],["21t10",{"2":{"1348":1,"1360":1}}],["21t16",{"2":{"1068":1}}],["21t12",{"2":{"1055":1,"1056":1,"1061":1,"1067":1,"1068":1,"1069":1,"1070":1,"1072":2,"1158":1,"1171":1,"1180":1,"1361":2}}],["219",{"2":{"520":1}}],["21",{"0":{"736":1},"1":{"737":1,"738":1,"739":1},"2":{"334":1,"448":1,"543":1,"1046":2,"1068":1,"1158":1,"1329":5,"1366":1}}],["2nd",{"2":{"203":2,"381":1,"758":1,"771":1,"775":1,"976":1,"981":1,"1213":2}}],["28",{"0":{"725":1,"727":1},"1":{"726":1,"728":1,"729":1},"2":{"137":1,"138":1,"150":2,"1220":1,"1223":1}}],["2357",{"2":{"1158":1,"1171":1}}],["234",{"2":{"787":1}}],["23",{"0":{"591":1,"608":1},"1":{"592":1,"593":1,"594":1,"609":1,"610":1},"2":{"63":1,"151":1,"186":2,"190":1,"192":1,"320":1,"368":1,"369":1,"370":1,"1046":1,"1049":1,"1063":1,"1088":1,"1125":2,"1136":1,"1203":3,"1209":1,"1271":1,"1352":1}}],["23rd",{"2":{"9":1}}],["26t00",{"2":{"910":1}}],["26+",{"2":{"34":1,"37":1}}],["26",{"0":{"730":1},"1":{"731":1,"732":1},"2":{"10":1,"137":1,"138":4,"190":1,"450":1,"885":1,"1064":1,"1083":1,"1088":1,"1090":1,"1125":1,"1203":2,"1209":2,"1224":1}}],["240",{"2":{"1351":1}}],["2461331",{"2":{"138":1,"150":2}}],["2461338",{"2":{"137":1}}],["241026",{"2":{"138":1}}],["24102026",{"2":{"137":1,"758":1}}],["24h",{"0":{"1192":1},"2":{"137":4,"890":1,"899":1,"1089":1,"1125":2,"1166":1,"1168":2,"1171":1}}],["24t00",{"2":{"974":1,"1119":1}}],["24t04",{"2":{"154":1}}],["24t12",{"2":{"518":1,"519":1}}],["24t15",{"2":{"78":1,"133":1,"144":2,"149":1,"1101":1,"1102":1,"1118":1,"1130":1,"1141":3,"1143":1,"1144":3,"1147":1}}],["24th",{"2":{"64":1,"131":1,"134":1,"138":1,"191":1,"758":1,"1090":1,"1101":1,"1125":1}}],["24",{"0":{"641":1,"1094":1,"1136":1,"1184":1},"1":{"642":1,"643":1,"644":1,"645":1},"2":{"10":1,"78":3,"94":2,"133":1,"134":1,"137":4,"139":2,"145":1,"149":1,"150":1,"205":3,"226":1,"240":2,"370":2,"517":2,"518":3,"635":1,"669":1,"734":1,"806":3,"885":1,"895":1,"1008":1,"1072":1,"1078":1,"1088":1,"1090":1,"1091":1,"1094":4,"1101":2,"1102":1,"1118":1,"1119":3,"1125":2,"1127":1,"1128":1,"1129":2,"1131":1,"1132":1,"1136":8,"1141":3,"1143":1,"1144":2,"1147":2,"1182":2,"1183":1,"1184":1,"1192":2,"1203":1,"1207":1,"1215":1,"1218":1,"1223":2,"1224":2,"1271":2,"1280":2,"1310":2}}],["25fps",{"0":{"1330":1},"1":{"1331":1,"1332":1},"2":{"1320":1,"1331":1}}],["256",{"2":{"954":1,"997":1,"1008":2,"1011":1}}],["25t12",{"2":{"1439":1}}],["25t10",{"2":{"1439":1}}],["25t14",{"2":{"146":1}}],["25t09",{"2":{"1421":1}}],["25t00",{"2":{"912":1}}],["2500",{"2":{"1408":1}}],["250+",{"2":{"365":1}}],["250",{"2":{"209":1}}],["25",{"0":{"605":1,"636":1,"638":1,"700":1},"1":{"606":1,"607":1,"637":1,"639":1,"640":1,"701":1,"702":1},"2":{"9":1,"54":2,"146":2,"158":2,"188":2,"209":1,"300":1,"520":3,"885":1,"1048":1,"1059":2,"1079":1,"1136":2,"1203":1,"1223":1,"1271":1,"1332":1,"1360":1,"1370":1}}],["2",{"0":{"27":1,"43":1,"88":1,"111":1,"121":1,"124":1,"170":1,"189":1,"195":1,"233":1,"259":1,"267":1,"279":1,"290":1,"310":1,"334":1,"363":1,"383":1,"393":1,"413":1,"434":1,"445":1,"457":1,"459":1,"472":1,"482":1,"490":1,"503":1,"510":1,"518":1,"525":1,"560":1,"561":1,"562":1,"566":1,"583":1,"591":1,"604":1,"619":1,"650":1,"652":1,"656":1,"658":1,"662":2,"674":1,"700":1,"721":1,"740":1,"742":2,"745":1,"749":1,"766":1,"774":1,"787":1,"793":1,"798":1,"799":1,"807":1,"817":1,"820":1,"824":1,"830":1,"839":1,"846":1,"860":1,"863":1,"875":1,"885":1,"894":1,"903":1,"946":1,"955":1,"969":1,"998":1,"1014":1,"1031":1,"1046":1,"1060":1,"1068":1,"1076":1,"1082":1,"1089":1,"1094":1,"1111":1,"1119":1,"1125":1,"1142":1,"1158":1,"1172":1,"1177":1,"1185":1,"1191":1,"1221":1,"1232":1,"1255":1,"1262":1,"1305":1,"1327":1,"1336":1,"1348":1,"1352":1,"1358":1,"1364":1,"1370":1,"1373":1,"1390":1,"1409":1,"1414":1,"1426":1,"1435":1,"1442":1,"1445":1},"1":{"112":1,"113":1,"114":1,"115":1,"414":1,"458":1,"459":1,"460":1,"461":1,"491":1,"563":1,"564":1,"565":1,"567":1,"568":1,"569":1,"584":1,"585":1,"592":1,"593":1,"594":1,"605":1,"606":1,"607":1,"608":1,"609":1,"610":1,"611":1,"612":1,"613":1,"614":1,"615":1,"616":1,"617":1,"618":1,"619":1,"620":2,"621":2,"622":2,"623":2,"624":1,"625":1,"626":1,"627":1,"628":1,"629":1,"630":1,"631":1,"632":1,"633":1,"634":1,"635":1,"636":1,"637":1,"638":1,"639":1,"640":1,"641":1,"642":1,"643":1,"644":1,"645":1,"646":1,"647":1,"648":1,"649":1,"650":1,"651":2,"652":1,"653":2,"654":2,"655":2,"656":1,"657":2,"658":1,"659":2,"660":2,"661":2,"662":1,"663":3,"664":3,"665":3,"666":3,"667":3,"668":3,"669":3,"670":1,"671":1,"672":1,"673":1,"674":1,"675":2,"676":2,"677":2,"678":2,"679":2,"680":2,"681":2,"682":2,"683":2,"684":2,"701":1,"702":1,"722":1,"723":1,"724":1,"741":1,"743":2,"744":2,"746":1,"747":1,"748":1,"750":1,"751":1,"752":1,"800":1,"801":1,"802":1,"821":1,"822":1,"823":1,"824":1,"825":1,"1032":1,"1033":1,"1143":1,"1144":1,"1159":1,"1178":1,"1179":1,"1180":1,"1186":1,"1187":1,"1263":1,"1264":1,"1306":1,"1307":1,"1328":1,"1329":1,"1337":1,"1338":1,"1391":1,"1392":1,"1415":1,"1427":1},"2":{"9":1,"32":1,"34":1,"39":1,"43":2,"44":1,"45":2,"59":1,"62":1,"87":1,"91":1,"102":1,"137":2,"138":7,"146":1,"158":2,"159":1,"160":1,"164":1,"167":1,"191":2,"201":1,"225":2,"228":1,"231":1,"236":1,"240":3,"243":2,"265":1,"266":1,"270":1,"274":1,"276":2,"285":1,"288":1,"289":1,"290":2,"305":1,"313":1,"317":1,"323":1,"324":1,"332":1,"370":1,"372":3,"381":1,"397":2,"412":1,"429":1,"440":1,"444":1,"448":1,"454":1,"458":1,"461":2,"463":2,"469":1,"481":1,"497":1,"505":1,"509":1,"519":2,"520":2,"545":2,"556":1,"574":1,"584":1,"618":1,"639":1,"674":1,"712":1,"732":1,"771":1,"773":1,"775":2,"787":2,"800":1,"821":1,"824":1,"850":1,"854":2,"860":1,"862":1,"878":2,"916":1,"917":1,"918":1,"929":1,"934":1,"947":3,"950":1,"953":1,"954":2,"955":1,"973":1,"978":1,"982":3,"983":3,"988":1,"993":1,"998":1,"1000":1,"1007":1,"1008":3,"1013":1,"1016":1,"1029":1,"1046":1,"1079":2,"1088":1,"1089":2,"1090":2,"1091":1,"1096":2,"1120":1,"1122":1,"1125":2,"1140":1,"1141":1,"1147":2,"1150":1,"1158":1,"1160":1,"1178":1,"1181":2,"1190":1,"1192":1,"1197":1,"1199":1,"1203":2,"1219":1,"1220":4,"1221":3,"1222":1,"1224":1,"1229":1,"1233":1,"1243":1,"1254":1,"1263":1,"1264":1,"1280":1,"1304":1,"1310":1,"1313":1,"1319":1,"1326":1,"1329":2,"1332":1,"1348":1,"1358":1,"1360":2,"1363":1,"1366":1,"1381":1,"1388":1,"1394":1,"1413":3,"1415":1,"1429":1,"1435":1,"1436":1,"1440":1,"1445":1,"1448":1}}],["20z",{"2":{"1329":1}}],["2065",{"2":{"1304":1}}],["20t08",{"2":{"520":1}}],["20t01",{"2":{"224":1}}],["20t12",{"2":{"1047":1}}],["20t10",{"2":{"201":1}}],["20t15",{"2":{"197":1}}],["20th",{"2":{"64":1,"191":1}}],["2030",{"2":{"189":1}}],["209",{"2":{"144":1,"226":1}}],["2093°",{"2":{"1352":2}}],["2093",{"2":{"121":1,"142":1,"154":1,"226":1,"1046":1,"1061":1,"1071":1,"1076":1,"1078":2,"1160":1,"1172":2,"1347":1,"1352":4,"1357":1,"1364":1}}],["200524",{"2":{"732":1}}],["2000",{"2":{"207":1,"935":1,"1335":2}}],["200",{"2":{"137":1,"202":4,"242":2,"1232":1}}],["200626",{"2":{"743":1}}],["2006",{"2":{"78":1,"1091":1,"1096":1,"1103":1,"1104":1}}],["2022",{"2":{"1065":2}}],["2027",{"2":{"885":2,"1223":3}}],["2023",{"2":{"217":2}}],["2021",{"2":{"189":1}}],["2020",{"2":{"189":1}}],["2029",{"2":{"189":1}}],["2028",{"2":{"189":2,"985":1}}],["2025",{"0":{"577":1},"1":{"578":1,"579":1,"580":1,"581":1,"582":1},"2":{"65":1,"303":3,"304":2,"305":1,"317":2,"1088":1,"1110":1,"1222":1}}],["20240520",{"2":{"244":1}}],["2024",{"0":{"583":1},"1":{"584":1,"585":1},"2":{"54":2,"62":2,"63":1,"64":1,"68":1,"73":2,"76":1,"146":3,"147":1,"164":2,"191":1,"201":1,"207":1,"243":1,"247":1,"268":1,"283":1,"300":1,"362":1,"363":3,"376":4,"446":1,"731":1,"734":1,"1064":1,"1065":2,"1153":2,"1154":1,"1271":1,"1280":1,"1310":1}}],["20261024",{"2":{"137":1}}],["2026",{"0":{"587":1,"591":1,"595":1,"599":1,"605":1,"608":1,"611":1,"615":1,"619":1,"624":1,"628":1,"632":1,"636":1,"638":1,"641":1,"646":1,"650":1,"652":1,"656":1,"658":1,"662":1,"670":1,"674":1,"686":1,"693":1,"698":1,"700":1,"703":1,"706":1,"710":1,"713":1,"715":1,"718":1,"721":1,"725":1,"727":1,"730":1,"733":1,"736":1,"740":1,"742":1,"745":1,"749":1,"753":1,"756":1,"762":1,"770":1,"779":1,"783":1,"789":1,"794":1,"799":1,"803":1,"809":1,"813":1,"820":1,"826":1,"834":1},"1":{"588":1,"589":1,"590":1,"592":1,"593":1,"594":1,"596":1,"597":1,"598":1,"600":1,"601":1,"602":1,"603":1,"606":1,"607":1,"609":1,"610":1,"612":1,"613":1,"614":1,"616":1,"617":1,"618":1,"620":1,"621":1,"622":1,"623":1,"625":1,"626":1,"627":1,"629":1,"630":1,"631":1,"633":1,"634":1,"635":1,"637":1,"639":1,"640":1,"642":1,"643":1,"644":1,"645":1,"647":1,"648":1,"649":1,"651":1,"653":1,"654":1,"655":1,"657":1,"659":1,"660":1,"661":1,"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"671":1,"672":1,"673":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"694":1,"695":1,"696":1,"697":1,"699":1,"701":1,"702":1,"704":1,"705":1,"707":1,"708":1,"709":1,"711":1,"712":1,"714":1,"716":1,"717":1,"719":1,"720":1,"722":1,"723":1,"724":1,"726":1,"728":1,"729":1,"731":1,"732":1,"734":1,"735":1,"737":1,"738":1,"739":1,"741":1,"743":1,"744":1,"746":1,"747":1,"748":1,"750":1,"751":1,"752":1,"754":1,"755":1,"757":1,"758":1,"759":1,"760":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"780":1,"781":1,"782":1,"784":1,"785":1,"786":1,"787":1,"788":1,"790":1,"791":1,"792":1,"793":1,"795":1,"796":1,"797":1,"798":1,"800":1,"801":1,"802":1,"804":1,"805":1,"806":1,"807":1,"808":1,"810":1,"811":1,"812":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1,"821":1,"822":1,"823":1,"824":1,"825":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"835":1,"836":1,"837":1,"838":1,"839":1,"840":1,"841":1,"842":1,"843":1},"2":{"9":3,"32":1,"52":1,"78":4,"95":3,"97":4,"98":2,"123":1,"131":1,"133":2,"134":2,"137":5,"138":2,"140":2,"144":2,"145":1,"149":1,"150":3,"152":1,"154":1,"158":3,"159":1,"162":1,"169":2,"170":2,"171":1,"176":2,"184":2,"186":4,"197":2,"200":1,"203":4,"205":4,"216":3,"219":4,"223":1,"224":2,"226":1,"231":1,"325":1,"334":1,"335":1,"367":1,"368":4,"372":1,"448":2,"450":1,"451":1,"517":2,"518":4,"519":1,"520":8,"543":1,"689":3,"690":1,"695":2,"763":1,"765":2,"766":5,"767":1,"768":3,"806":3,"849":1,"878":1,"880":2,"885":4,"887":4,"889":1,"898":2,"903":1,"905":2,"908":1,"909":2,"910":1,"912":4,"918":2,"945":1,"961":2,"962":1,"964":4,"965":1,"973":1,"974":2,"988":5,"1016":1,"1046":3,"1047":2,"1048":2,"1049":1,"1055":1,"1056":1,"1059":1,"1060":2,"1061":1,"1062":1,"1063":1,"1067":1,"1068":2,"1069":1,"1070":1,"1071":1,"1072":2,"1076":1,"1078":4,"1083":2,"1088":4,"1090":1,"1091":1,"1101":4,"1102":2,"1110":3,"1118":2,"1119":3,"1125":1,"1127":2,"1128":1,"1129":2,"1130":1,"1131":1,"1132":1,"1136":2,"1141":6,"1143":1,"1144":3,"1147":3,"1158":2,"1171":1,"1180":1,"1190":2,"1195":3,"1197":4,"1199":3,"1201":2,"1203":4,"1205":2,"1209":4,"1214":1,"1216":3,"1217":1,"1220":3,"1221":3,"1222":5,"1223":4,"1224":5,"1232":2,"1272":1,"1280":1,"1304":2,"1310":1,"1316":1,"1317":1,"1326":1,"1329":5,"1348":2,"1360":2,"1361":2,"1363":2,"1366":1,"1419":2,"1421":1,"1439":2}}],["20",{"0":{"611":1,"650":1,"652":1,"740":1,"803":1},"1":{"612":1,"613":1,"614":1,"651":1,"653":1,"654":1,"655":1,"741":1,"804":1,"805":1,"806":1,"807":1,"808":1},"2":{"10":1,"64":1,"68":1,"123":1,"137":1,"138":1,"147":1,"191":1,"195":2,"197":1,"200":1,"201":2,"224":1,"243":1,"247":1,"306":1,"376":4,"381":3,"446":1,"448":1,"731":1,"734":2,"849":1,"896":1,"953":1,"954":1,"1046":2,"1047":1,"1338":2}}],["20+",{"2":{"3":1,"365":1}}],["22z",{"2":{"1326":1}}],["224",{"2":{"880":2}}],["22µs",{"2":{"442":1}}],["22ms",{"2":{"442":1}}],["229",{"2":{"158":6}}],["22",{"0":{"595":1,"646":1,"733":1},"1":{"596":1,"597":1,"598":1,"647":1,"648":1,"649":1,"734":1,"735":1},"2":{"3":1,"224":1,"225":1,"231":1,"1046":3,"1059":2,"1085":1,"1324":1,"1325":1,"1326":1,"1328":1,"1329":3}}],["rhythm",{"2":{"1343":1}}],["rrc",{"2":{"1307":1}}],["rrules",{"2":{"1014":1}}],["rrule",{"0":{"984":1,"1014":1,"1418":1},"2":{"919":2,"950":1,"981":1,"982":2,"984":3,"986":3,"1014":4,"1401":1,"1403":1,"1404":1,"1418":1,"1427":1}}],["rpm",{"2":{"947":1}}],["ryy",{"2":{"766":1}}],["ry",{"2":{"766":1}}],["rm",{"2":{"766":1}}],["rtt=t1−t0",{"2":{"1228":1}}],["rtt",{"0":{"1228":1},"2":{"1233":3,"1242":1,"1246":1}}],["rtfstyle",{"2":{"564":2,"565":1,"633":1}}],["rtfformat",{"2":{"564":1,"565":1,"633":1}}],["rtf",{"2":{"520":2,"787":1}}],["rtl",{"2":{"370":1}}],["r",{"2":{"332":4,"1041":1,"1135":2,"1178":2,"1264":2,"1355":1}}],["r>",{"2":{"332":2}}],["rsn",{"2":{"313":1,"321":1,"326":1}}],["ric",{"2":{"1307":1}}],["richdata",{"2":{"500":2,"502":1}}],["rich",{"2":{"418":1,"451":1,"468":1,"472":3,"500":1,"502":1,"503":1,"522":1,"625":1,"692":1,"1042":1,"1103":1}}],["river",{"2":{"1083":1}}],["rise",{"2":{"1061":1,"1072":1,"1271":1}}],["risky",{"2":{"1146":1}}],["risking",{"2":{"797":1}}],["riskier",{"2":{"431":1}}],["risks",{"0":{"1011":1},"2":{"453":1}}],["risk",{"0":{"1386":1},"1":{"1387":1,"1388":1,"1389":1},"2":{"263":1,"280":1,"431":1,"644":1,"752":1,"972":1,"995":1,"1011":2,"1367":1,"1387":2,"1388":2,"1389":1}}],["rigor",{"2":{"366":1,"522":1}}],["rigorously",{"2":{"403":1,"422":1}}],["rigorous",{"2":{"137":1}}],["rigid",{"2":{"146":1,"522":1,"750":1,"865":1,"910":1,"1010":1,"1098":1}}],["right",{"2":{"96":1,"138":2,"170":1,"291":1,"365":1,"423":1,"510":1,"522":1,"765":1,"983":1,"1167":1}}],["rfc",{"0":{"1014":1,"1418":1},"2":{"154":1,"981":1,"984":1,"986":1,"1014":1,"1135":1,"1143":2,"1144":2,"1266":1,"1401":1,"1404":1,"1411":1,"1418":1,"1427":1}}],["rapier",{"2":{"1391":1}}],["rapidly",{"2":{"445":1}}],["rapid",{"2":{"45":1,"270":1,"445":1,"953":1,"1008":1}}],["radial",{"2":{"1344":1}}],["radiation",{"2":{"1082":1}}],["radius",{"2":{"1333":1,"1334":1,"1345":1,"1355":1,"1364":1}}],["rarely",{"2":{"1312":1}}],["rarr",{"2":{"1112":2}}],["raises",{"2":{"954":1}}],["ratio",{"2":{"1052":1,"1058":1}}],["rationale",{"2":{"900":1}}],["rationalization",{"0":{"633":1}}],["rationalized",{"2":{"562":1}}],["rating",{"2":{"872":1,"882":1}}],["rates",{"2":{"954":1,"1008":1}}],["ratelimit",{"2":{"941":3,"948":1,"966":1}}],["rate",{"0":{"948":1,"966":1},"1":{"967":1,"968":1,"969":1,"970":1,"971":1,"972":1,"973":1,"974":1,"975":1,"976":1,"977":1,"978":1,"979":1,"980":1},"2":{"450":1,"451":1,"573":1,"669":1,"867":1,"921":2,"934":1,"936":1,"940":1,"941":1,"942":2,"953":1,"954":3,"955":1,"966":1,"967":1,"968":2,"1178":2,"1182":1,"1192":1,"1225":1}}],["rather",{"2":{"76":1,"102":1,"125":1,"138":1,"144":1,"181":1,"208":1,"247":1,"262":1,"276":1,"280":1,"452":1,"469":1,"559":1,"644":1,"744":1,"865":1,"875":1,"878":1,"942":1,"1010":1,"1011":1,"1081":1,"1084":1,"1097":1,"1234":1,"1268":1,"1271":1}}],["ranging",{"2":{"1368":1}}],["rangeerror",{"2":{"517":2}}],["range",{"0":{"314":1,"865":1,"1073":1},"2":{"155":1,"196":1,"301":4,"306":1,"313":3,"314":2,"315":3,"319":1,"323":1,"325":1,"326":3,"380":1,"388":4,"529":1,"617":1,"649":1,"771":3,"775":1,"865":2,"1076":2,"1136":1,"1358":1}}],["ranges",{"2":{"155":2,"175":1,"273":1,"313":3,"314":1,"315":3,"319":2,"326":4,"531":1,"682":1,"1054":1,"1067":1}}],["ranked",{"2":{"940":1,"948":1}}],["random",{"2":{"377":1}}],["race",{"0":{"949":1},"2":{"109":1,"696":1,"867":2,"871":1,"881":1,"890":1,"899":1,"921":1,"934":4,"937":1,"938":2,"940":1,"942":2,"949":1,"959":1,"963":1,"989":1,"1017":1}}],["rawcue",{"2":{"1332":3}}],["rawclick",{"2":{"1326":2}}],["rawdroptime",{"2":{"1326":2}}],["rawduration",{"2":{"162":2}}],["rawaddress",{"2":{"1192":2}}],["rawtime",{"2":{"1329":2}}],["rawtimestampms",{"2":{"1332":2}}],["rawtimestamp",{"2":{"1141":3}}],["rawtext",{"2":{"889":1,"891":1,"998":1}}],["rawepochs",{"2":{"1030":3}}],["rawreasoning",{"2":{"998":1}}],["rawprompt",{"2":{"912":1,"936":1,"997":1,"998":1}}],["rawpayload",{"2":{"793":1}}],["rawiso",{"2":{"912":1,"965":1}}],["raw",{"0":{"1042":1},"1":{"1043":1},"2":{"44":1,"76":1,"138":5,"139":4,"140":1,"145":1,"148":1,"161":2,"174":2,"233":1,"245":1,"247":1,"282":1,"357":1,"370":4,"373":1,"412":1,"418":1,"427":1,"429":1,"442":1,"450":1,"451":1,"469":1,"505":2,"507":1,"513":1,"520":1,"567":1,"626":1,"701":1,"723":1,"763":1,"768":1,"857":1,"891":1,"913":1,"984":1,"991":1,"995":1,"998":1,"1008":1,"1011":5,"1016":1,"1017":1,"1022":1,"1029":1,"1042":1,"1090":3,"1103":1,"1125":8,"1326":1,"1328":1,"1329":2,"1381":1,"1396":1,"1412":1}}],["rag",{"2":{"29":1}}],["rotates",{"2":{"1351":1}}],["rotation",{"0":{"1004":1},"2":{"867":1,"933":2,"940":2,"1004":1}}],["royal",{"2":{"1309":1}}],["room",{"2":{"889":1}}],["rooted",{"2":{"1269":1}}],["root",{"2":{"27":1,"263":1,"280":1,"298":1,"402":1,"440":1,"453":1,"559":1,"627":1,"757":1,"836":1,"955":1}}],["rogue",{"2":{"709":1}}],["rock",{"2":{"516":1,"522":1,"524":1,"674":1}}],["roles",{"2":{"464":1}}],["role",{"2":{"464":10,"465":2,"644":1,"714":1}}],["rollconvention",{"2":{"1222":2}}],["rolling",{"0":{"1031":1},"1":{"1032":1,"1033":1},"2":{"1032":1,"1035":1,"1210":1,"1222":1}}],["roll",{"2":{"164":1,"606":1}}],["rollup",{"2":{"161":1,"285":1,"618":1,"651":1,"665":1,"816":1}}],["roi",{"2":{"447":1}}],["roadmap",{"2":{"138":1,"954":1,"1008":1}}],["romancoin",{"2":{"1307":2}}],["romancalculationoptions",{"0":{"1284":1}}],["romanparseoptions",{"0":{"1289":1,"1290":1}}],["romanplugin",{"2":{"1278":2,"1281":1,"1282":2,"1304":2,"1313":1}}],["romans",{"2":{"1270":1,"1271":1}}],["romanmonth",{"2":{"766":2}}],["romandate",{"2":{"765":2}}],["roman",{"0":{"765":1,"1275":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1},"1":{"1276":1,"1277":1,"1278":1,"1279":1,"1280":1,"1281":1,"1282":1,"1283":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1299":1,"1300":1},"2":{"138":4,"763":9,"765":9,"766":2,"767":3,"1090":6,"1098":1,"1268":2,"1269":2,"1271":1,"1272":1,"1273":3,"1275":1,"1276":3,"1277":1,"1278":5,"1280":3,"1281":2,"1282":1,"1284":1,"1288":1,"1291":1,"1301":1,"1304":5,"1306":2,"1307":5,"1309":1,"1310":1,"1312":2,"1313":6}}],["routines",{"2":{"679":1,"1122":1}}],["routinely",{"2":{"498":1,"1012":1}}],["routing",{"2":{"43":2,"666":1,"871":1,"881":1,"890":1,"899":1,"955":1,"958":1,"989":1,"1121":1,"1225":1}}],["route",{"0":{"1365":1},"2":{"854":1,"858":2,"860":1,"913":1,"931":1,"955":2,"1005":2,"1008":1,"1017":1,"1178":1,"1191":1,"1362":2}}],["routes",{"2":{"427":1,"932":1,"1011":1,"1365":1}}],["routed",{"2":{"408":1}}],["routers",{"2":{"333":1}}],["rounding",{"2":{"1315":1}}],["roundrobin",{"0":{"947":1},"2":{"696":1,"867":2,"871":1,"881":1,"890":1,"899":1,"921":1,"934":2,"937":1,"938":2,"940":1,"942":2,"947":1,"959":1,"963":1,"989":1}}],["round",{"0":{"765":1,"1228":1},"2":{"121":1,"296":1,"763":2,"1081":3,"1084":1,"1085":1,"1135":1,"1223":1,"1225":1,"1240":1,"1242":1,"1246":1,"1276":1,"1351":1,"1363":1,"1365":2}}],["rounded",{"2":{"121":1,"226":1,"227":1,"1318":1}}],["robustness",{"2":{"621":1,"644":1,"647":1}}],["robust",{"2":{"3":1,"165":1,"206":1,"215":1,"221":1,"273":1,"281":1,"451":1,"452":1,"466":1,"470":1,"499":1,"504":1,"527":1,"529":1,"606":1,"667":1,"696":1,"712":1,"751":1,"939":1,"1194":1,"1276":1,"1315":1}}],["rubber",{"2":{"1391":1}}],["ruby",{"2":{"1123":1}}],["russia",{"2":{"1338":1}}],["russian",{"2":{"1095":1}}],["rule",{"0":{"440":1},"2":{"250":1,"351":1,"388":1,"440":1,"1114":1,"1147":1,"1213":1,"1404":1,"1418":1,"1427":1}}],["rules",{"0":{"122":1,"981":1,"1126":1,"1418":1},"1":{"123":1,"124":1,"125":1,"126":1,"127":1,"128":1,"982":1,"983":1,"984":1,"985":1,"986":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1},"2":{"24":1,"26":1,"27":1,"31":1,"43":1,"48":1,"97":1,"122":1,"138":1,"202":1,"216":1,"218":1,"219":1,"220":1,"247":2,"328":1,"348":1,"370":2,"372":1,"388":1,"910":1,"911":1,"1036":1,"1067":1,"1088":1,"1158":1,"1210":1,"1213":3,"1298":1,"1383":1,"1396":1,"1411":1}}],["rulebook",{"2":{"24":1}}],["runaway",{"2":{"1437":1}}],["runtradingdashboard",{"2":{"1430":1}}],["runtimes",{"2":{"335":1,"365":1,"367":1,"402":1,"1161":1,"1188":1,"1442":1}}],["runtime",{"0":{"113":1,"716":1},"2":{"10":1,"12":1,"24":1,"34":2,"43":1,"102":1,"107":1,"116":1,"250":1,"276":1,"363":2,"365":2,"402":5,"406":1,"430":1,"439":1,"453":2,"466":1,"467":1,"468":3,"469":2,"471":1,"479":1,"497":1,"541":3,"542":1,"653":1,"716":1,"717":1,"719":1,"738":1,"793":1,"807":1,"830":1,"832":1,"841":1,"845":1,"849":1,"856":1,"864":2,"874":1,"876":2,"910":1,"926":1,"958":1,"994":1,"996":1,"998":1,"1000":1,"1001":1,"1038":1,"1093":1,"1095":1,"1106":1,"1147":1,"1161":1,"1178":1,"1207":1,"1215":1,"1224":1,"1257":1,"1276":1,"1353":1,"1376":1}}],["runners",{"2":{"1054":1,"1067":1}}],["runner",{"2":{"451":2}}],["running",{"0":{"1455":1},"1":{"1456":1,"1457":1,"1458":1},"2":{"83":1,"89":1,"276":1,"365":1,"367":1,"716":1,"856":1,"861":1,"1039":1,"1040":1,"1234":1,"1262":1,"1371":1,"1406":1,"1426":5,"1442":1,"1443":2}}],["runscheduledsync",{"2":{"1448":1}}],["runs",{"2":{"6":1,"84":1,"111":1,"266":2,"330":1,"419":2,"425":1,"741":1,"855":1,"993":1,"1032":1,"1103":1,"1188":1,"1331":1,"1388":1,"1394":1,"1417":1}}],["run",{"2":{"5":1,"6":6,"102":1,"112":1,"119":1,"138":1,"161":1,"266":1,"327":1,"448":2,"451":1,"543":1,"845":1,"1106":1,"1122":1,"1218":1,"1222":1,"1258":1,"1376":1,"1378":1,"1391":1,"1392":1,"1441":1,"1457":1,"1458":1}}],["rewrite",{"2":{"1114":1,"1147":1}}],["reinforce",{"2":{"1076":1}}],["reiwa",{"2":{"146":1,"750":1}}],["rehydrating",{"2":{"1035":1}}],["rehydrates",{"2":{"1022":1}}],["rehydrate",{"2":{"1011":1,"1022":1,"1030":1,"1033":1,"1036":3,"1042":2,"1043":1}}],["rehydrated",{"2":{"895":1}}],["reorganized",{"0":{"559":1},"2":{"559":1,"560":1,"661":1,"712":1,"747":1}}],["renewal",{"2":{"950":1}}],["rename",{"2":{"743":1}}],["renamed",{"2":{"546":1,"590":1,"758":1}}],["renderdashboard",{"2":{"1430":1}}],["renders",{"2":{"1267":1,"1292":1}}],["rendering",{"2":{"723":1,"1058":1,"1063":1,"1394":1,"1395":1}}],["render",{"2":{"165":2,"1235":1,"1331":1,"1332":1}}],["revamped",{"2":{"651":1}}],["reverted",{"2":{"629":1}}],["reversegeocode",{"2":{"1176":1,"1178":1,"1181":1,"1191":1}}],["reversed",{"2":{"1060":1}}],["reverse",{"0":{"886":1,"1172":1,"1181":1},"2":{"461":1,"468":1,"752":1,"862":1,"1162":1,"1166":1,"1167":1,"1168":2,"1169":2,"1172":4,"1176":2,"1178":2,"1181":4,"1188":1,"1191":1,"1420":1}}],["revocation",{"2":{"612":1,"1363":1}}],["review",{"2":{"95":1,"229":1,"560":1,"889":1,"948":1,"1013":1}}],["rebuilding",{"2":{"416":1,"536":1}}],["rebuild",{"2":{"416":1,"421":1,"502":1}}],["rebuilds",{"2":{"407":1,"501":1}}],["rebuilt",{"2":{"228":1,"414":1,"416":1,"421":1}}],["reject",{"2":{"407":1,"475":1,"481":3,"483":1,"484":1,"486":1,"942":1,"973":1}}],["rejection",{"0":{"1233":1},"2":{"407":1,"419":2,"446":1,"1226":1,"1236":1}}],["rejecting",{"2":{"359":1,"871":1,"881":1,"890":1,"899":1,"1136":1}}],["rejects",{"2":{"359":1,"453":1,"970":1}}],["rejected",{"2":{"109":1,"121":1,"157":1,"227":1,"359":1,"442":1,"445":1,"483":1,"484":1,"486":2,"487":2,"767":1,"856":1,"1000":1,"1001":1,"1233":1,"1266":1}}],["redshift",{"2":{"1099":1,"1103":2}}],["redisadapter",{"2":{"978":2}}],["rediscacheadapter",{"2":{"895":1,"904":1}}],["redis",{"2":{"866":1,"871":1,"881":1,"890":1,"895":1,"899":1,"904":1,"921":1,"937":1,"938":1,"978":11,"980":1,"1009":1,"1011":2}}],["redacted",{"2":{"864":1,"997":1,"1003":1}}],["redaction",{"0":{"864":1,"997":1,"1003":1},"2":{"861":1,"864":1,"1017":1}}],["redesigned",{"2":{"666":1}}],["redefinition",{"2":{"657":1}}],["redefine",{"2":{"338":1}}],["redundant",{"2":{"93":1,"416":1,"726":1,"748":1,"1184":1}}],["reduction",{"2":{"444":1}}],["reduced",{"2":{"402":1,"450":1,"665":1,"760":1}}],["reduces",{"2":{"249":1,"503":1,"516":1,"675":1,"1043":1}}],["reduce",{"2":{"48":1,"98":1,"649":1,"672":1,"1329":1}}],["reducing",{"2":{"43":1,"198":1,"644":1,"668":1,"714":1,"722":1,"757":1,"798":1,"971":1}}],["reusing",{"2":{"326":1}}],["reusable",{"2":{"76":1,"116":1,"297":1,"526":1}}],["retryat",{"2":{"970":2}}],["retry",{"2":{"941":1,"942":1,"970":1}}],["retrieve",{"2":{"1426":1}}],["retrieves",{"2":{"1168":1,"1291":1}}],["retrieval",{"2":{"933":1}}],["retries",{"2":{"146":1,"1233":1}}],["retained",{"2":{"816":1,"953":1}}],["retain",{"2":{"812":1,"863":1}}],["retaining",{"2":{"516":1}}],["retains",{"2":{"502":1,"972":1,"998":1}}],["retail",{"2":{"313":1,"321":1,"531":1}}],["retailseason",{"2":{"313":1,"326":1}}],["retention",{"0":{"863":1},"2":{"476":1,"863":1,"954":1,"1008":6}}],["rethrow",{"2":{"146":1}}],["returned",{"2":{"266":1,"315":1,"326":1,"359":1,"856":1,"876":1,"912":2,"936":1,"949":1,"950":2,"965":1,"966":1,"968":2}}],["returning",{"2":{"109":1,"150":1,"157":3,"279":1,"319":1,"358":1,"389":1,"477":1,"593":1,"875":1,"876":1,"912":1,"934":2,"1140":1,"1168":1,"1240":1,"1247":1,"1248":1,"1285":1,"1286":1}}],["returns",{"2":{"62":1,"124":1,"145":1,"155":4,"158":2,"159":3,"160":1,"161":2,"179":2,"180":2,"182":1,"183":1,"197":2,"301":1,"307":1,"314":1,"321":1,"326":1,"330":1,"344":1,"345":1,"346":1,"347":1,"348":1,"350":1,"352":1,"353":1,"354":1,"360":1,"367":2,"383":2,"385":1,"394":2,"402":1,"418":1,"433":1,"444":1,"453":1,"473":1,"487":2,"491":1,"520":5,"539":1,"750":1,"831":1,"856":1,"864":1,"865":1,"871":1,"876":1,"881":1,"890":1,"899":1,"919":1,"920":3,"932":1,"969":1,"973":1,"976":1,"983":2,"986":1,"993":1,"1003":1,"1014":1,"1019":1,"1021":1,"1022":1,"1036":1,"1042":1,"1053":1,"1068":1,"1104":2,"1169":1,"1245":1,"1251":1,"1284":1,"1293":1,"1296":1,"1297":1,"1318":2,"1382":4,"1406":1}}],["return",{"0":{"920":1},"2":{"7":1,"27":1,"117":1,"123":1,"147":1,"161":1,"173":2,"174":2,"181":1,"192":1,"199":1,"224":2,"225":2,"233":3,"235":2,"261":1,"265":5,"266":2,"270":1,"281":2,"300":1,"313":4,"317":1,"319":1,"321":1,"324":13,"327":1,"334":3,"404":1,"409":1,"426":1,"437":3,"438":1,"520":2,"543":1,"625":1,"682":1,"836":2,"856":1,"860":8,"871":1,"910":1,"912":1,"919":1,"920":2,"955":4,"972":1,"973":4,"989":1,"998":1,"1004":1,"1013":1,"1014":1,"1015":1,"1016":1,"1030":1,"1033":1,"1036":1,"1081":3,"1082":1,"1083":1,"1084":1,"1085":1,"1114":1,"1141":1,"1144":2,"1147":1,"1173":1,"1178":4,"1184":1,"1190":1,"1191":3,"1192":2,"1193":1,"1220":1,"1221":1,"1222":2,"1223":1,"1261":2,"1266":1,"1304":1,"1307":1,"1310":1,"1326":1,"1329":1,"1332":1,"1363":1,"1364":1,"1365":1,"1389":1,"1392":1,"1395":1,"1405":1,"1406":1,"1444":1,"1452":1}}],["req",{"2":{"119":1,"860":3,"953":1,"955":3,"1178":1,"1193":3}}],["requiring",{"2":{"333":1,"513":1,"522":1,"647":1,"688":1,"716":1,"838":1,"863":1,"1008":1,"1009":1,"1042":1,"1045":1,"1147":1,"1215":1,"1369":1}}],["requirement",{"2":{"108":1,"124":1,"138":1,"271":1,"293":1,"405":1,"1000":1,"1054":1}}],["requirements",{"2":{"77":1,"122":1,"170":1,"281":1,"293":1,"418":1,"1376":1}}],["required",{"0":{"565":1,"569":1},"2":{"12":1,"38":1,"76":1,"281":1,"329":1,"373":1,"423":2,"539":1,"548":1,"551":1,"559":1,"560":1,"561":1,"862":1,"871":1,"875":1,"881":1,"890":1,"899":1,"925":1,"949":1,"958":1,"989":1,"1011":1,"1025":1,"1089":1,"1094":1,"1107":1,"1211":1,"1252":1,"1321":1,"1349":1,"1360":1,"1384":1,"1410":1,"1442":1}}],["require",{"2":{"10":1,"34":1,"287":1,"328":1,"513":1,"699":1,"954":1,"962":1,"1014":1,"1041":1,"1084":1,"1121":1,"1143":1,"1149":1,"1222":1,"1324":1,"1375":1,"1376":1,"1378":2,"1392":1,"1425":1}}],["requires",{"2":{"3":1,"10":1,"43":1,"170":1,"250":1,"285":1,"296":1,"469":1,"510":1,"513":1,"524":1,"597":1,"856":1,"950":1,"1008":1,"1032":1,"1091":3,"1093":1,"1098":1,"1121":1,"1125":1,"1149":1,"1189":1,"1328":1,"1361":1,"1363":1}}],["requesttime",{"2":{"1193":2}}],["requests",{"0":{"975":1},"2":{"93":1,"829":1,"854":1,"855":1,"858":1,"860":1,"863":1,"889":1,"913":1,"931":1,"934":2,"935":1,"940":2,"941":2,"942":1,"945":1,"946":1,"948":2,"949":2,"950":1,"954":1,"955":2,"968":2,"969":1,"970":1,"972":1,"974":1,"996":1,"1005":1,"1008":1,"1178":1,"1184":1,"1185":1,"1193":1,"1213":1,"1223":1,"1240":1}}],["requesteddurationminutes",{"2":{"1015":2}}],["requested",{"2":{"76":1,"144":1,"370":1,"406":1,"434":1,"1326":1}}],["requestcontext",{"2":{"69":3}}],["request",{"0":{"8":1,"855":1,"968":1,"1193":1},"2":{"8":1,"69":1,"119":2,"120":1,"247":1,"334":1,"357":1,"427":1,"536":3,"838":2,"856":2,"860":2,"871":3,"881":1,"891":1,"900":1,"908":1,"933":2,"936":1,"939":2,"940":3,"942":4,"946":2,"948":1,"962":2,"963":1,"968":1,"969":2,"970":1,"972":2,"975":2,"980":1,"987":1,"1001":1,"1004":4,"1007":1,"1008":1,"1009":1,"1178":1,"1188":1,"1192":1,"1193":3,"1227":3,"1246":1,"1443":1,"1450":1}}],["re",{"2":{"91":1,"147":1,"191":1,"262":1,"276":1,"327":1,"371":1,"424":1,"536":1,"560":1,"684":1,"722":1,"838":1,"841":1,"932":1,"993":1,"1004":1,"1239":1,"1240":1,"1421":1}}],["reform",{"2":{"1271":1}}],["reformationstag",{"2":{"1213":1}}],["reformatted",{"2":{"582":1}}],["ref1",{"2":{"1096":1}}],["refraction",{"2":{"1062":1}}],["refreshers",{"2":{"1004":1}}],["refreshed",{"2":{"671":1}}],["refreshing",{"2":{"933":1}}],["refresh",{"0":{"977":1},"2":{"618":1,"1004":1,"1167":2,"1168":1,"1184":1,"1331":1}}],["refinements",{"0":{"654":1},"2":{"684":1}}],["refinement",{"0":{"626":1},"2":{"648":1}}],["refined",{"0":{"629":1},"2":{"100":1,"617":1,"622":1,"634":1,"664":1,"738":1}}],["refdate",{"2":{"520":2}}],["refactoring",{"0":{"644":1,"712":1,"717":1,"724":1,"726":1,"738":1,"744":1,"748":1,"752":1,"755":1,"760":1},"2":{"705":1}}],["refactored",{"2":{"635":1,"651":1}}],["refactor",{"0":{"556":1,"580":1,"649":1},"2":{"442":1,"672":1}}],["reflecting",{"2":{"598":1,"644":1}}],["reflection",{"0":{"461":1,"664":1},"2":{"461":1,"463":1,"471":1,"664":1}}],["reflect",{"2":{"409":1,"437":2,"1125":1}}],["reflects",{"2":{"71":1}}],["referencing",{"2":{"247":1,"457":1}}],["references",{"2":{"362":1,"472":1,"476":1,"505":1,"651":1,"671":1,"708":1,"1039":1,"1445":1}}],["reference",{"0":{"479":1,"937":1,"959":1,"1096":1,"1244":1,"1283":1,"1425":1},"1":{"938":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1},"2":{"13":1,"28":2,"29":1,"78":1,"195":1,"276":1,"317":1,"351":1,"352":1,"406":2,"414":1,"423":1,"475":1,"479":2,"504":1,"559":1,"601":1,"661":2,"888":1,"890":1,"893":1,"899":1,"907":2,"989":1,"1012":2,"1013":1,"1091":1,"1096":3,"1104":2,"1120":1,"1123":2,"1351":1,"1352":1,"1353":1,"1370":1,"1422":1,"1427":1}}],["referential",{"2":{"224":1}}],["refer",{"2":{"27":1,"565":1,"871":1,"881":1,"890":1,"899":1,"934":1,"936":1,"963":1,"989":1}}],["remembrance",{"2":{"1213":1}}],["remember",{"2":{"1088":1}}],["remix",{"2":{"1193":1}}],["reminders",{"2":{"897":1}}],["remindertime",{"2":{"894":2}}],["reminder",{"2":{"9":1,"889":1,"898":1,"1421":1}}],["remap",{"2":{"326":1}}],["remainingms",{"2":{"1261":2}}],["remainingworkinghours",{"2":{"1220":4}}],["remainingtokens",{"2":{"942":1,"968":1,"969":1}}],["remainingrequests",{"2":{"942":1,"968":1,"969":1}}],["remaining",{"2":{"158":1,"233":3,"235":3,"402":1,"430":1,"941":2,"947":1,"948":1,"949":1,"970":1,"1220":1,"1269":1}}],["remaining`",{"2":{"65":1}}],["remains",{"2":{"139":1,"278":1,"281":1,"291":2,"333":1,"367":1,"414":1,"415":1,"421":1,"434":1,"440":1,"444":1,"446":1,"465":1,"842":1,"1005":1,"1072":2,"1103":1,"1120":1,"1264":1,"1339":1,"1421":1,"1452":1}}],["remain",{"2":{"99":1,"147":1,"295":1,"402":1,"409":1,"413":1,"419":1,"426":1,"427":1,"440":1,"453":1,"514":1,"629":1,"630":1,"695":1,"732":1,"737":1,"768":1,"771":1,"776":1,"786":1,"931":1,"1072":1,"1128":1,"1157":1,"1443":1}}],["removing",{"2":{"751":1}}],["removals",{"0":{"843":1}}],["removal",{"2":{"574":1,"757":1}}],["removelistener",{"2":{"955":1}}],["remove",{"2":{"561":1,"708":1,"747":1,"760":1,"1147":1}}],["removed",{"0":{"570":1},"1":{"571":1,"572":1},"2":{"152":1,"537":1,"546":1,"571":1,"572":1,"637":1,"729":1,"757":4,"836":3,"843":4,"942":1}}],["remoteconfigurl",{"2":{"856":3,"937":1,"938":1}}],["remote",{"0":{"829":1,"856":1},"2":{"109":4,"477":1,"827":1,"829":2,"855":1,"856":8,"932":2,"937":1,"938":1,"958":1,"1000":1,"1001":2,"1254":1,"1422":1}}],["regulations",{"2":{"1222":1}}],["regulated",{"2":{"1017":1}}],["regular",{"0":{"798":1},"2":{"237":1,"239":1,"243":1,"247":2,"363":1,"416":1,"795":1,"806":1,"951":1,"1195":1,"1263":1}}],["regressions",{"2":{"1109":1}}],["regression",{"2":{"573":1,"679":1,"1454":1}}],["regardless",{"2":{"118":1,"163":1,"186":1,"216":1,"416":1,"483":1,"567":1,"817":1,"848":1,"941":1,"949":1,"1325":1,"1444":1}}],["regarding",{"2":{"48":1,"954":1,"1008":1}}],["regexp",{"0":{"246":1},"2":{"243":2,"246":3,"620":1,"1240":2}}],["regexes",{"2":{"205":1,"776":1,"1011":1}}],["regex",{"2":{"93":1,"96":1,"97":1,"123":1,"238":1,"240":1,"243":3,"245":1,"246":3,"297":2,"322":1,"348":1,"351":1,"357":2,"359":1,"377":1,"466":1,"510":1,"647":1,"735":1,"737":1,"738":1,"752":1,"798":1,"865":1,"997":1,"1010":1,"1113":1,"1121":2,"1240":1,"1263":1}}],["regime",{"2":{"1078":2}}],["regions",{"0":{"1072":1},"2":{"218":1,"370":4,"884":1,"1072":1,"1366":1}}],["region",{"2":{"137":1,"216":1,"274":1,"285":5,"289":1,"291":1,"362":2,"364":1,"367":1,"370":3,"786":1,"872":1,"881":1,"885":1,"890":1,"899":1,"904":1,"1078":1,"1190":1,"1195":1,"1207":1,"1214":6,"1220":5}}],["regional",{"0":{"154":1,"365":1,"366":1,"368":1,"563":1,"869":1,"907":1,"909":1,"1212":1},"1":{"367":1,"368":1,"369":1,"370":1,"870":1,"871":1,"872":1,"873":1,"874":1,"875":1,"876":1,"877":1,"878":1,"908":1,"909":1,"1213":1,"1214":1,"1215":1,"1216":1,"1217":1},"2":{"71":2,"117":1,"137":2,"186":1,"294":1,"296":3,"365":3,"366":1,"370":1,"371":1,"522":1,"633":2,"634":1,"786":2,"814":1,"817":2,"866":1,"869":1,"881":1,"884":1,"885":1,"890":1,"893":1,"899":1,"906":1,"907":2,"919":1,"1009":1,"1103":1,"1156":1,"1158":3,"1190":3,"1194":1,"1203":1,"1206":1,"1207":1,"1210":1,"1212":1,"1213":1,"1224":1,"1364":2}}],["registering",{"0":{"214":1,"316":1,"1177":1},"1":{"1178":1,"1179":1,"1180":1},"2":{"261":1,"782":1,"832":1}}],["registered",{"0":{"307":1},"2":{"155":2,"203":1,"214":1,"262":2,"276":1,"291":1,"300":1,"307":1,"315":2,"326":1,"336":1,"338":1,"346":1,"353":1,"354":1,"363":1,"387":1,"409":1,"416":2,"429":1,"738":1,"757":1,"771":1,"833":1,"868":1,"1215":1,"1257":1,"1414":1}}],["registers",{"2":{"102":2,"250":1,"262":1,"276":2,"409":1,"541":1,"1374":1,"1405":1}}],["register",{"2":{"31":1,"32":1,"87":1,"115":1,"117":1,"136":1,"214":1,"221":1,"236":1,"247":1,"262":1,"268":1,"271":1,"274":1,"276":2,"285":2,"292":1,"316":1,"476":1,"478":1,"483":1,"490":3,"541":1,"548":1,"552":1,"704":1,"737":1,"759":2,"780":1,"844":1,"849":1,"850":1,"851":1,"1049":1,"1153":1,"1176":1,"1178":1,"1191":1,"1424":1}}],["registrations",{"2":{"726":1,"782":1,"812":1}}],["registration",{"0":{"113":1,"262":1,"289":1,"292":1,"421":1,"553":1,"678":1,"847":1,"1101":1,"1178":1,"1238":1,"1282":1,"1398":1},"1":{"554":1,"555":1,"848":1,"849":1,"1102":1,"1239":1,"1240":1,"1241":1,"1399":1,"1400":1},"2":{"101":1,"102":2,"113":1,"232":1,"274":3,"276":3,"285":1,"288":2,"312":1,"418":1,"421":1,"431":1,"434":1,"503":1,"541":3,"542":2,"612":1,"625":1,"626":1,"678":1,"726":1,"812":1,"830":1,"832":1,"847":1,"1154":1}}],["registryupdate",{"2":{"298":1,"414":1}}],["registry",{"0":{"218":1,"272":1,"296":1,"298":1,"401":1,"544":1,"626":1,"663":1,"716":1,"737":1,"782":1,"1374":1,"1426":1},"1":{"402":1,"545":1,"1427":1},"2":{"6":1,"30":1,"31":1,"32":1,"35":1,"39":1,"76":3,"96":3,"97":2,"102":1,"105":1,"112":1,"113":1,"115":1,"116":1,"117":1,"123":1,"124":1,"125":4,"134":1,"145":2,"147":2,"198":1,"203":2,"214":1,"218":1,"221":1,"222":2,"223":1,"225":1,"228":2,"229":1,"243":4,"244":1,"247":1,"251":1,"276":1,"291":1,"294":1,"295":4,"296":2,"297":2,"298":1,"330":1,"333":1,"362":1,"363":2,"402":2,"407":2,"410":3,"414":1,"416":3,"418":2,"440":1,"503":1,"535":1,"544":4,"545":1,"609":1,"625":1,"626":1,"634":1,"643":1,"647":1,"667":1,"702":1,"712":1,"716":1,"731":1,"737":2,"738":4,"746":1,"754":2,"755":1,"757":1,"776":2,"782":1,"831":1,"836":2,"843":1,"846":1,"1374":1,"1401":1,"1426":1,"1440":1,"1442":2}}],["registries",{"0":{"294":1,"295":1,"297":1},"1":{"295":1,"296":1,"297":1,"298":2},"2":{"1":1,"115":1,"117":2,"124":1,"294":1,"295":2,"298":3,"336":1,"348":1,"406":3,"413":1,"421":1,"422":1,"423":1,"430":1,"438":2,"439":1,"444":1,"663":2,"717":1,"1303":1,"1454":1}}],["reload",{"2":{"747":1}}],["reloads",{"2":{"653":1,"663":2,"1371":1}}],["relocated",{"2":{"539":1,"644":1,"836":1}}],["rely",{"2":{"276":1,"279":1,"479":1,"560":1,"723":1,"909":1,"1011":1,"1054":1,"1259":1}}],["relying",{"2":{"44":1,"139":1,"403":1,"452":1,"465":1,"471":1,"573":1,"1081":1}}],["relevant",{"2":{"250":1,"394":1}}],["released",{"2":{"648":1}}],["release",{"0":{"575":1},"2":{"34":1,"47":2,"559":1,"565":1,"574":2,"590":1,"642":1,"659":1,"695":1,"729":1,"808":1,"1442":1}}],["releases",{"0":{"574":1},"1":{"575":1},"2":{"23":1}}],["related",{"2":{"230":1,"263":2,"280":1,"286":1,"562":1,"747":1}}],["relation",{"0":{"1288":1},"2":{"409":1,"1270":3,"1272":1,"1304":3}}],["relational",{"0":{"193":1,"195":1,"381":1,"681":1},"1":{"194":1,"195":1},"2":{"195":1,"381":2}}],["relativetime",{"2":{"372":2,"572":3,"633":1,"757":2,"787":2}}],["relativetimeformat",{"2":{"115":1,"117":1,"157":1,"159":3,"371":1,"520":2,"564":2,"572":3,"744":1}}],["relativeto",{"2":{"162":2,"164":1,"165":1}}],["relative",{"0":{"59":1,"66":1,"397":1,"564":1,"911":1,"1415":1},"2":{"59":1,"64":1,"66":1,"83":1,"92":1,"97":1,"99":2,"107":1,"129":1,"157":2,"159":1,"191":1,"195":1,"201":1,"219":1,"220":1,"222":1,"223":1,"237":1,"240":1,"242":1,"245":1,"352":1,"363":2,"370":2,"372":1,"373":1,"381":1,"383":2,"387":2,"388":1,"389":1,"390":1,"393":1,"510":1,"517":1,"520":3,"526":1,"532":1,"610":1,"633":1,"654":2,"679":1,"681":1,"684":1,"699":1,"734":1,"737":1,"754":1,"787":1,"802":1,"878":1,"879":1,"886":1,"888":1,"890":1,"897":1,"898":1,"899":1,"902":1,"903":1,"906":1,"908":1,"951":1,"962":1,"989":1,"1012":1,"1063":3,"1067":1,"1075":1,"1157":1,"1415":1,"1459":1}}],["rel",{"2":{"127":1,"128":1}}],["religious",{"2":{"1271":1}}],["relied",{"2":{"561":1,"569":1}}],["relies",{"2":{"102":1,"170":1,"194":1,"466":1,"469":1,"470":1,"513":1,"518":1,"759":1,"909":1,"1075":1}}],["reliably",{"2":{"410":1,"456":1,"503":1,"504":1,"906":1}}],["reliable",{"2":{"44":1,"617":1,"653":1,"668":1,"1422":1}}],["reliability",{"0":{"109":1,"679":1,"683":1},"2":{"451":1,"516":1,"524":1,"1012":1}}],["republic",{"2":{"1269":1,"1273":1,"1312":1}}],["represented",{"2":{"355":1,"992":1}}],["represent",{"2":{"240":1,"446":1}}],["represents",{"2":{"167":1,"326":1,"522":1,"909":1,"1088":2,"1110":3,"1134":1,"1136":1,"1368":1}}],["representing",{"2":{"160":1,"179":1,"221":1,"477":1,"968":1,"1019":1,"1068":1,"1094":1,"1382":1}}],["representations",{"0":{"153":1},"2":{"272":1,"500":1,"973":1,"1307":1}}],["representation",{"2":{"138":2,"151":1,"191":1,"501":1,"758":1,"1090":1,"1116":1,"1150":1}}],["reproducible",{"2":{"85":1,"1054":1}}],["reproduces",{"2":{"1271":1,"1276":1}}],["reproduce",{"2":{"22":1}}],["repeating",{"2":{"981":1}}],["repeat",{"2":{"380":1,"388":1}}],["repeated",{"2":{"266":1,"373":1,"798":1,"1189":1,"1408":1}}],["repeatedly",{"2":{"76":1,"321":1,"983":1,"1088":1}}],["repetitive",{"2":{"119":1,"971":1}}],["repls",{"2":{"274":1,"780":1,"810":1,"915":1}}],["replaced",{"2":{"653":1,"864":1,"1003":1}}],["replace",{"2":{"402":1,"502":1,"528":1,"560":1,"1147":1}}],["replaces",{"2":{"184":1,"793":1}}],["replacement",{"2":{"96":1,"516":1}}],["replacing",{"2":{"125":1,"356":1,"708":1,"712":1,"782":1,"840":1,"1118":1}}],["repl",{"0":{"83":1,"85":1,"1243":1},"1":{"84":1,"85":1,"86":1,"87":1,"88":1,"89":1,"90":1,"91":1},"2":{"83":1,"85":1,"88":1,"90":1,"747":2,"953":1,"1314":1}}],["repo",{"2":{"614":1}}],["repository",{"2":{"21":1,"229":1}}],["reported",{"2":{"272":2}}],["reporter",{"2":{"23":1}}],["report",{"0":{"21":1},"2":{"21":2,"23":1,"119":1,"922":1,"1113":2,"1127":2,"1128":1}}],["reporting",{"0":{"20":1},"1":{"21":1,"22":1,"23":1},"2":{"77":2,"1088":1,"1097":1}}],["reports",{"2":{"15":1,"1079":1,"1454":1}}],["reclaims",{"2":{"1442":1}}],["reclaim",{"2":{"1440":1}}],["reclaimed",{"2":{"473":1,"1374":1}}],["rectangular",{"0":{"1336":1},"1":{"1337":1,"1338":1},"2":{"1333":1,"1343":1,"1345":1,"1364":1}}],["reckoning",{"2":{"1276":1}}],["reckoned",{"2":{"1272":1,"1285":1}}],["recalibrates",{"2":{"1264":1}}],["recalculates",{"2":{"1262":1}}],["recharge",{"2":{"1224":1}}],["recreating",{"2":{"536":1}}],["recreates",{"2":{"425":1}}],["recurs",{"2":{"982":1}}],["recursively",{"2":{"121":1,"227":1,"1106":1,"1173":1}}],["recursive",{"2":{"107":1,"276":1,"404":1,"664":1,"744":2,"829":1,"830":1}}],["recurrenceprompt",{"2":{"1014":2}}],["recurrenceaitempo",{"2":{"919":1}}],["recurrenceai",{"0":{"981":1},"1":{"982":1,"983":1,"984":1,"985":1,"986":1},"2":{"910":1,"912":1,"946":1,"950":1,"981":1,"982":2,"983":2,"984":2,"985":1}}],["recurrence",{"0":{"981":1,"1014":1,"1418":1},"1":{"982":1,"983":1,"984":1,"985":1,"986":1},"2":{"89":1,"479":1,"891":1,"919":1,"986":1,"1014":3,"1396":1,"1404":1,"1411":1,"1418":3,"1427":1,"1451":3}}],["recurring",{"2":{"77":1,"1014":1,"1191":1,"1421":1,"1425":1}}],["reconciledatabasechanges",{"2":{"1448":1}}],["reconciling",{"2":{"1362":1}}],["reconciliation",{"2":{"1213":1}}],["reconstructs",{"2":{"472":1}}],["recovery",{"0":{"1448":1},"2":{"617":1,"1401":1,"1425":1,"1443":1}}],["recovering",{"2":{"404":1}}],["recovered",{"2":{"281":1,"1424":1}}],["recognized",{"2":{"766":1,"1094":1,"1195":1}}],["recognize",{"2":{"689":1,"1216":1}}],["recognizes",{"2":{"261":1}}],["recognizing",{"2":{"227":1,"1276":1}}],["recording",{"2":{"1304":1}}],["records",{"2":{"337":1,"888":1,"1008":2,"1035":1,"1227":3,"1265":1}}],["recorded",{"2":{"205":1,"1008":2,"1091":5,"1101":2,"1112":4,"1272":1,"1273":1,"1332":1}}],["record",{"2":{"102":1,"115":2,"117":1,"120":1,"323":1,"830":1,"1033":1,"1047":1,"1176":3,"1265":1,"1303":1,"1304":6,"1306":1,"1329":2,"1427":1}}],["recommendation",{"2":{"921":1,"1011":1}}],["recommend",{"2":{"34":1,"47":1,"857":1,"913":1,"921":1,"1005":1,"1098":1}}],["recommended",{"0":{"309":1,"848":1,"955":1,"1122":1,"1187":1},"2":{"3":1,"10":1,"44":1,"89":1,"102":1,"113":1,"114":1,"204":1,"234":1,"259":1,"262":1,"274":2,"276":1,"377":1,"456":1,"571":1,"572":1,"1011":2,"1441":1}}],["reception",{"0":{"1229":1}}],["recent",{"2":{"385":1,"911":1,"969":2}}],["recently",{"2":{"94":1}}],["receiving",{"2":{"1227":1}}],["received",{"2":{"490":1,"856":2,"1001":1,"1082":1}}],["receives",{"2":{"265":1,"860":1,"998":1,"1035":1,"1039":1}}],["receive",{"2":{"19":1,"47":1,"147":1,"341":1,"1036":1,"1188":1,"1370":1}}],["receipt",{"2":{"23":1}}],["recipes",{"2":{"49":1,"1105":1}}],["reassembles",{"2":{"1040":1}}],["reassignment",{"2":{"782":1,"1173":1}}],["reasons",{"2":{"972":1}}],["reasoning",{"2":{"872":2,"882":2,"891":2,"900":1,"912":1,"919":2,"936":1,"951":1,"953":1,"986":2,"992":1,"997":1,"998":3,"1011":1,"1016":1}}],["reasoningextracts",{"2":{"204":1}}],["reason",{"2":{"157":1,"158":1}}],["reasonable",{"2":{"129":1,"281":1}}],["realistically",{"2":{"1090":1}}],["reality",{"2":{"526":1,"1171":1}}],["realm",{"2":{"167":1,"773":1}}],["real",{"0":{"967":1,"1062":1,"1071":1,"1393":1},"1":{"968":1,"969":1,"1394":1,"1395":1},"2":{"83":2,"140":1,"230":1,"407":1,"451":1,"525":1,"526":1,"531":1,"648":1,"867":1,"949":1,"1026":1,"1050":1,"1052":1,"1058":1,"1062":1,"1065":1,"1066":1,"1097":1,"1137":1,"1218":1,"1242":1,"1362":1,"1364":1,"1367":1,"1377":1,"1383":1,"1391":1,"1419":2}}],["reader",{"0":{"1370":1},"2":{"1370":2,"1381":5,"1382":4,"1388":4,"1389":5,"1392":5,"1395":3}}],["readmes",{"2":{"655":1}}],["readme",{"2":{"648":1,"666":1,"671":1}}],["readability",{"2":{"402":1,"707":1}}],["readable",{"0":{"520":1},"2":{"59":1,"66":1,"125":1,"131":1,"140":1,"157":2,"159":1,"192":1,"213":1,"364":1,"517":1,"520":4,"525":1,"688":1}}],["readonly",{"0":{"1291":1},"2":{"336":1,"461":4,"546":1,"1176":1,"1248":4,"1427":9}}],["readiness",{"2":{"326":1}}],["reading",{"0":{"1381":1},"2":{"59":1,"108":1,"109":1,"871":1,"881":1,"890":1,"899":1,"921":1,"966":1,"975":2}}],["readstore",{"2":{"117":1}}],["reads",{"2":{"111":1,"114":1,"288":1,"300":1,"327":1,"948":1,"1168":1}}],["read",{"2":{"43":1,"48":1,"64":1,"76":1,"110":1,"121":1,"148":1,"155":1,"170":1,"172":1,"230":1,"233":1,"275":1,"280":1,"291":1,"295":1,"307":1,"414":1,"416":1,"430":1,"432":1,"437":1,"453":1,"471":1,"472":1,"473":1,"475":1,"517":1,"518":1,"519":1,"520":1,"747":1,"818":1,"864":1,"1003":1,"1089":1,"1168":1,"1184":1,"1186":1,"1370":1,"1377":1,"1381":1,"1388":2,"1389":1,"1395":1}}],["readyforcore",{"2":{"1147":1}}],["ready",{"0":{"44":1},"2":{"12":1,"84":1,"90":1,"515":1,"534":1,"539":1,"836":2,"894":1,"1036":1}}],["react",{"2":{"857":1,"1005":1,"1149":1}}],["reactive",{"0":{"420":1,"421":1,"473":1,"488":1,"792":2,"1423":1,"1429":1},"1":{"421":1,"422":1,"489":1,"490":1,"491":1,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1,"1424":1,"1425":1,"1426":1,"1427":1,"1428":1,"1429":1,"1430":1},"2":{"273":1,"473":3,"488":2,"489":4,"491":1,"492":2,"493":3,"494":2,"495":1,"496":4,"600":1,"674":1,"683":1,"790":2,"792":3,"1401":1,"1423":1}}],["reactions",{"0":{"16":1}}],["reaching",{"2":{"1439":1}}],["reaches",{"2":{"94":1,"1045":1,"1366":1,"1439":1}}],["reached",{"2":{"34":1,"314":1,"1421":2,"1425":1}}],["reach",{"2":{"8":1,"15":1}}],["resurrected",{"2":{"503":1}}],["resurrects",{"2":{"503":1}}],["resulted",{"2":{"451":1}}],["resulting",{"2":{"364":1,"505":1,"520":1,"760":1}}],["results",{"0":{"450":1},"1":{"451":1},"2":{"138":1,"353":1,"384":1,"393":1,"407":1,"426":1,"441":1,"446":1,"447":1,"448":2,"451":1,"502":1,"625":1,"660":1,"667":1,"797":1,"831":1,"863":1,"871":2,"881":2,"890":2,"896":1,"899":2,"905":1,"937":1,"938":1,"968":1,"971":1,"1010":1,"1040":1,"1091":1,"1093":1,"1276":1}}],["result",{"0":{"351":1,"872":1,"882":1,"891":1,"900":1,"986":1,"992":1},"2":{"98":1,"161":1,"285":1,"300":1,"301":1,"319":1,"334":1,"337":1,"339":2,"351":2,"359":1,"412":1,"414":1,"429":1,"454":1,"477":1,"481":1,"667":1,"864":1,"865":1,"885":3,"889":2,"894":2,"895":1,"898":4,"903":1,"904":1,"909":1,"910":1,"912":1,"936":2,"950":1,"957":1,"977":1,"982":5,"983":2,"998":5,"1011":1,"1014":2,"1036":1,"1040":1,"1114":2,"1184":1,"1276":1,"1329":3}}],["residual",{"0":{"1011":1},"2":{"1011":1}}],["resides",{"2":{"437":1}}],["resistant",{"0":{"998":1},"2":{"861":1}}],["resilience",{"0":{"631":1,"634":1,"782":1,"866":1,"980":1},"2":{"400":1,"627":1,"634":1,"649":1,"653":1,"696":1,"726":1,"780":1,"905":1,"940":1,"942":1}}],["resilient",{"0":{"1191":1},"2":{"358":1}}],["reservation",{"2":{"1131":1}}],["reserved",{"2":{"274":1,"388":1,"541":1,"830":1,"832":1,"1088":1}}],["reserve",{"2":{"204":1,"388":1}}],["research",{"2":{"1085":1}}],["resetat",{"2":{"942":1,"968":1,"969":1}}],["resets",{"2":{"422":1,"970":1,"1250":1}}],["resetting",{"2":{"95":1}}],["reset",{"0":{"1250":1},"2":{"6":1,"224":1,"331":1,"485":1,"941":1,"942":2,"969":1}}],["res",{"2":{"119":2,"936":3,"955":10,"998":1,"1011":4,"1178":4,"1191":6,"1271":4}}],["restarting",{"2":{"933":1}}],["restored",{"2":{"501":2,"669":1,"765":2}}],["restricted",{"2":{"202":1,"829":1,"856":1,"1040":1}}],["restricts",{"2":{"161":1}}],["rest",{"2":{"118":1,"292":1}}],["resource",{"0":{"335":1,"494":1,"831":1,"1256":1,"1373":1,"1431":1,"1432":1,"1445":1},"1":{"495":1,"1432":1,"1433":2,"1434":2,"1435":1,"1436":1,"1437":1,"1438":1,"1439":1,"1440":1,"1441":1,"1442":1},"2":{"331":1,"422":1,"473":1,"475":1,"483":1,"491":1,"531":1,"535":1,"540":1,"543":3,"792":1,"827":1,"831":1,"1256":1,"1373":1,"1396":1,"1401":2,"1431":1,"1432":1,"1440":1,"1442":1,"1443":1,"1445":1}}],["resources",{"2":{"89":1}}],["resolving",{"2":{"357":1,"402":1,"477":1,"516":1,"607":1,"702":1,"775":1,"776":1,"856":1,"1013":1,"1105":1,"1168":1,"1287":1}}],["resolveinscriptiondate",{"2":{"1304":2}}],["resolvepaymentrundate",{"2":{"1222":3}}],["resolvetenantlocation",{"2":{"1192":1}}],["resolvecalendarslot",{"2":{"1326":2}}],["resolveculturallocale",{"0":{"1160":1},"2":{"1160":8,"1161":1,"1168":1,"1190":4}}],["resolveconfig",{"0":{"829":1},"2":{"538":1,"687":1,"829":1,"839":1}}],["resolveconfigsync",{"0":{"839":1},"2":{"538":1,"839":1}}],["resolvecyclewindow",{"2":{"313":3,"654":1}}],["resolvedcoordinates",{"2":{"1176":1}}],["resolvedlocaleinfo",{"2":{"367":1}}],["resolved",{"2":{"76":2,"97":1,"120":2,"125":1,"131":1,"142":2,"154":3,"155":1,"285":1,"337":1,"339":1,"351":2,"370":1,"449":1,"463":3,"483":1,"486":1,"487":2,"585":1,"617":1,"645":1,"653":1,"667":1,"683":1,"695":1,"702":1,"709":1,"829":1,"855":1,"856":1,"863":1,"888":1,"912":1,"919":1,"926":1,"933":1,"968":2,"971":1,"992":2,"1181":1,"1192":3,"1203":3,"1204":1,"1219":1,"1304":4,"1435":1}}],["resolverangeordinal",{"2":{"775":1}}],["resolverangeformat",{"2":{"775":2}}],["resolverangediff",{"2":{"775":2}}],["resolvers",{"2":{"264":1,"265":2,"266":1,"270":1,"271":1,"838":1}}],["resolver",{"2":{"71":1,"265":1,"266":1,"631":1,"642":2,"688":1,"807":1,"933":1,"959":1}}],["resolves",{"2":{"43":1,"58":1,"69":1,"98":1,"119":1,"138":1,"141":1,"144":1,"145":1,"148":1,"158":1,"202":1,"209":2,"224":1,"294":1,"338":1,"362":1,"381":1,"383":1,"477":3,"707":1,"738":1,"855":1,"869":1,"907":1,"951":1,"958":1,"974":1,"1001":1,"1048":2,"1061":1,"1063":1,"1083":1,"1168":1,"1169":2,"1188":1,"1207":1,"1214":1,"1220":1,"1276":1,"1288":1,"1326":1}}],["resolve",{"0":{"321":1},"2":{"22":1,"39":1,"43":1,"44":1,"47":1,"117":2,"198":1,"219":1,"224":1,"225":2,"313":5,"321":2,"324":1,"362":1,"377":1,"381":1,"388":1,"481":3,"482":1,"483":1,"561":1,"607":1,"633":1,"651":2,"657":1,"669":1,"729":1,"752":1,"860":1,"887":1,"938":1,"972":1,"975":1,"1004":1,"1012":1,"1054":1,"1167":1,"1168":1,"1188":1,"1304":2,"1313":1,"1408":2}}],["resolutions",{"2":{"1182":1}}],["resolutiontime",{"2":{"878":1}}],["resolution",{"0":{"99":1,"217":1,"338":1,"362":1,"385":1,"386":1,"404":1,"567":1,"654":1,"807":1,"825":1,"829":1,"855":1,"926":1,"979":1,"987":1,"1214":1,"1219":1,"1225":1},"1":{"568":1,"569":1,"988":1,"989":1,"990":1,"991":1,"992":1,"993":1,"1220":1},"2":{"10":1,"41":1,"43":1,"44":1,"58":1,"92":1,"93":2,"97":1,"99":1,"129":1,"131":1,"198":1,"227":1,"254":1,"326":1,"357":1,"361":1,"362":1,"375":1,"385":1,"389":1,"404":1,"409":1,"418":3,"446":1,"449":1,"481":1,"536":2,"613":1,"616":3,"617":2,"621":1,"625":3,"627":1,"631":1,"634":1,"637":1,"644":1,"647":1,"649":3,"651":2,"657":1,"660":1,"666":1,"671":1,"694":1,"755":1,"827":1,"829":1,"855":1,"856":2,"866":1,"872":1,"878":1,"882":1,"933":2,"936":1,"950":1,"979":1,"980":1,"984":1,"992":1,"1041":1,"1054":2,"1075":1,"1121":1,"1134":1,"1144":1,"1166":1,"1176":2,"1206":1,"1207":1,"1226":1,"1232":1,"1343":1,"1396":1,"1425":1,"1454":1}}],["responding",{"2":{"950":1}}],["responsibility",{"2":{"1454":1}}],["responsible",{"2":{"20":1,"281":1,"361":1,"922":1,"986":1}}],["responses",{"2":{"701":1,"865":1,"941":1,"978":1,"1008":1,"1264":1}}],["response",{"0":{"23":1},"2":{"860":7,"867":1,"912":1,"934":2,"942":1,"946":2,"948":1,"949":2,"975":1,"1218":1,"1227":2,"1262":1,"1264":1,"1378":1}}],["respective",{"2":{"936":1}}],["respecting",{"2":{"519":1}}],["respects",{"2":{"356":1,"884":1,"1205":1,"1207":1,"1219":1,"1447":1}}],["respect",{"0":{"280":1},"2":{"24":1,"281":1,"282":1,"567":1,"616":1,"637":1,"1213":1}}],["jfkairport",{"2":{"1365":3}}],["jet",{"2":{"1361":1}}],["jean",{"2":{"1045":1}}],["jittery",{"2":{"1240":1,"1329":1}}],["jitter",{"0":{"1233":1},"2":{"1226":1,"1232":1,"1236":1,"1242":1,"1328":1,"1332":1,"1387":1,"1391":1}}],["jira",{"2":{"1219":1}}],["jws",{"2":{"836":1}}],["jwt",{"2":{"479":1,"539":1,"588":1,"612":1,"836":1,"859":1,"955":1}}],["jose",{"2":{"1335":2}}],["jour",{"2":{"1213":1}}],["jours",{"2":{"372":1}}],["john",{"2":{"997":2}}],["jobid",{"2":{"1445":3}}],["jobs",{"2":{"1225":1,"1443":1,"1447":1}}],["job",{"2":{"423":1}}],["jp",{"2":{"146":1,"908":1,"1157":1,"1158":1,"1160":1,"1190":4,"1213":1,"1214":2}}],["jazzy",{"2":{"651":1}}],["japan",{"2":{"366":1,"1158":1,"1190":1,"1207":1,"1213":1}}],["japaneseconfig",{"2":{"146":2}}],["japanese",{"2":{"146":3,"750":1,"752":1,"802":1,"908":1}}],["januariis",{"2":{"1270":1}}],["january",{"2":{"138":1,"150":1,"184":1,"192":1,"202":1,"215":1,"370":1,"1093":2,"1110":1,"1224":1,"1270":1,"1273":1,"1307":1}}],["janvier",{"2":{"363":2}}],["jan",{"2":{"150":1,"215":1,"240":1,"363":1,"518":2,"1091":1,"1096":1,"1097":1,"1203":8,"1209":1,"1213":2,"1222":2,"1223":1,"1269":1,"1270":1}}],["ja",{"2":{"146":1,"908":1,"1157":1,"1158":1,"1160":1,"1190":2,"1214":1}}],["javascriptnew",{"2":{"569":1}}],["javascriptcore",{"2":{"446":1}}],["javascriptconst",{"2":{"87":1,"88":1,"159":1,"160":1,"163":1,"164":1,"518":2,"519":2,"520":1}}],["javascriptt",{"2":{"380":1,"382":1,"682":1}}],["javascripttempo",{"2":{"123":1,"127":1,"128":1,"166":1,"295":1}}],["javascriptimport",{"2":{"9":1,"36":1,"38":1,"40":1,"46":1,"113":1,"116":1,"158":1,"295":1,"548":1,"552":1,"555":1,"558":1,"759":1,"848":1,"849":1}}],["javascript",{"2":{"1":1,"27":1,"34":1,"83":1,"95":1,"109":1,"110":1,"112":1,"118":1,"124":1,"125":1,"138":2,"161":1,"162":1,"165":1,"224":1,"283":1,"335":1,"381":1,"411":1,"424":1,"426":1,"427":1,"431":1,"439":1,"453":1,"464":1,"467":2,"468":2,"472":1,"498":1,"501":1,"504":1,"514":1,"516":1,"517":2,"520":1,"522":1,"528":1,"542":1,"545":1,"556":1,"568":1,"876":1,"903":1,"910":1,"955":1,"998":1,"1032":1,"1040":1,"1161":1,"1178":1,"1287":1,"1367":1,"1442":1,"1443":1,"1445":1}}],["j",{"2":{"138":1,"150":1,"997":3,"1090":1,"1125":1,"1269":3,"1296":1,"1297":1}}],["jj",{"2":{"137":1,"138":2,"150":4}}],["jurisdiction",{"2":{"1219":1}}],["jurisdictions",{"2":{"1189":1,"1205":1}}],["jun",{"2":{"1097":1,"1269":1}}],["juneteenth",{"2":{"1213":1}}],["june",{"2":{"739":2,"1046":1,"1048":2,"1158":1}}],["julius",{"2":{"1307":1}}],["julio",{"2":{"1273":1,"1280":1,"1281":2,"1312":1,"1313":2}}],["julian",{"2":{"137":2,"138":5,"150":4,"1271":1,"1298":1,"1303":1}}],["jul",{"2":{"304":2}}],["july",{"2":{"64":1,"191":1,"266":2,"317":2,"333":1,"734":1,"739":3,"1097":1,"1195":1,"1197":4,"1199":3,"1222":3,"1269":3,"1296":1,"1297":1}}],["jumps",{"2":{"194":1,"380":1,"734":1}}],["jump",{"2":{"63":1,"188":1,"191":3,"194":1,"233":1,"396":1,"680":1,"734":2,"735":1}}],["jumping",{"0":{"63":1},"2":{"380":1,"389":1,"681":1,"734":1,"1234":1}}],["justification",{"2":{"872":1,"882":1}}],["just",{"2":{"45":1,"171":1,"225":1,"267":1,"273":1,"387":1,"427":1,"503":1,"505":1,"513":1,"644":1,"705":1,"855":1,"933":1,"993":1,"1004":2}}],["jsbi",{"2":{"651":2}}],["jst",{"2":{"213":1,"296":1,"689":1,"1447":1}}],["json",{"0":{"505":1,"839":1,"927":1},"2":{"102":2,"103":1,"107":1,"109":1,"119":1,"300":1,"403":1,"429":1,"465":1,"468":1,"472":4,"479":1,"498":2,"500":1,"503":3,"505":4,"538":2,"541":4,"542":1,"559":4,"688":2,"691":1,"701":1,"829":2,"832":1,"836":1,"839":1,"856":1,"860":10,"865":1,"870":1,"893":1,"910":1,"925":1,"926":1,"927":2,"937":1,"955":8,"958":1,"1011":1,"1178":2,"1191":3,"1232":1,"1264":1,"1265":1,"1394":1,"1444":2}}],["jsonc",{"0":{"538":1,"688":1,"839":1},"2":{"102":1,"103":2,"105":3,"109":1,"538":2,"688":1,"829":2,"835":1,"836":1,"839":1,"926":1}}],["jsif",{"2":{"34":1}}],["jsdelivr",{"2":{"10":2,"42":2,"44":7,"45":3,"47":4,"850":3}}],["js",{"0":{"35":1,"37":1,"38":1,"103":1,"860":1,"1128":2},"1":{"36":1,"37":1,"38":1},"2":{"3":2,"10":6,"34":3,"37":2,"38":2,"42":5,"43":3,"44":7,"45":4,"78":1,"102":5,"103":3,"106":1,"107":2,"116":1,"119":1,"137":2,"157":2,"158":1,"170":1,"215":1,"268":1,"271":1,"274":2,"286":2,"300":1,"316":1,"335":1,"365":1,"419":2,"427":3,"442":1,"446":2,"447":1,"449":1,"450":1,"468":2,"479":1,"505":1,"506":1,"507":1,"510":1,"511":1,"514":3,"515":1,"524":1,"532":1,"538":1,"594":1,"610":1,"620":1,"635":1,"648":1,"651":2,"669":1,"722":1,"729":1,"741":2,"778":1,"808":1,"829":1,"836":1,"839":1,"850":4,"853":1,"858":1,"860":2,"861":1,"915":1,"925":1,"926":1,"955":1,"957":1,"978":1,"998":1,"1005":1,"1028":1,"1039":1,"1041":1,"1086":2,"1089":1,"1091":1,"1099":2,"1103":2,"1108":2,"1110":2,"1112":2,"1113":1,"1116":1,"1120":1,"1123":3,"1125":3,"1146":1,"1161":1,"1188":1,"1193":1,"1368":1,"1370":1,"1371":1,"1372":1,"1376":2,"1378":1,"1451":1,"1452":1}}],["ntpsyncoptions",{"0":{"1240":1}}],["ntpplugin",{"2":{"1239":2,"1243":2,"1254":2,"1257":1,"1261":2,"1263":4,"1422":2}}],["ntp",{"0":{"1236":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1254":2,"1422":1},"1":{"1237":1,"1238":1,"1239":1,"1240":1,"1241":1,"1242":1,"1243":1,"1244":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1252":1},"2":{"1226":1,"1232":1,"1235":2,"1237":1,"1239":3,"1241":3,"1242":1,"1243":5,"1251":1,"1253":1,"1254":9,"1255":2,"1256":2,"1257":2,"1258":1,"1261":4,"1262":1,"1263":1,"1264":3,"1265":4,"1266":1,"1267":1,"1422":10}}],["nt",{"2":{"1213":1}}],["nth",{"0":{"203":1},"1":{"204":1}}],["nlp",{"2":{"913":1}}],["nfc",{"2":{"802":1}}],["nf",{"2":{"787":1}}],["n=10k",{"2":{"419":2}}],["nir",{"2":{"1213":1}}],["nine",{"2":{"1123":1,"1269":1}}],["nightmares",{"0":{"1091":1}}],["nightmodeat",{"2":{"1082":1}}],["night",{"0":{"1072":1},"2":{"306":1,"1053":1,"1054":1,"1066":1,"1067":3,"1072":1,"1081":1,"1415":1}}],["niche",{"2":{"138":1}}],["nz",{"2":{"1213":1}}],["nzdt",{"2":{"296":1}}],["nzst",{"2":{"296":1}}],["nzt",{"2":{"296":1}}],["nbr",{"2":{"240":1,"242":1}}],["nbsp",{"2":{"16":6}}],["nysebell",{"2":{"1447":2}}],["nyse",{"2":{"1430":1,"1447":2}}],["nytime",{"2":{"1429":1}}],["ny",{"2":{"274":1,"285":1,"289":1,"291":1,"890":1,"1065":1,"1337":2,"1361":1}}],["nye",{"2":{"240":1}}],["nyc",{"2":{"68":3,"1363":1}}],["nuances",{"0":{"1133":1},"1":{"1134":1,"1135":1,"1136":1}}],["null>",{"2":{"938":1,"1176":3}}],["nullish",{"2":{"367":1}}],["null",{"0":{"1054":1},"2":{"171":3,"173":1,"174":1,"179":1,"180":1,"453":3,"468":2,"938":1,"1054":3,"1055":1,"1065":1,"1071":7,"1072":3,"1078":4,"1132":1,"1147":1,"1178":2}}],["numismatics",{"0":{"1305":1},"1":{"1306":1,"1307":1},"2":{"1299":1,"1301":1}}],["numismatic",{"2":{"1274":1,"1306":1,"1307":1}}],["numerous",{"2":{"424":1}}],["numerals",{"2":{"146":1,"370":1,"750":1,"763":1,"765":2,"767":1}}],["numeral",{"0":{"765":1},"2":{"138":1,"763":3,"817":1,"1090":2}}],["numeric",{"0":{"188":1,"189":1,"206":1},"1":{"207":1,"208":1,"209":1},"2":{"117":2,"127":1,"138":6,"146":4,"157":1,"159":1,"203":2,"208":1,"209":1,"215":1,"216":1,"240":1,"359":1,"370":1,"468":1,"469":1,"518":2,"520":1,"567":1,"571":1,"616":2,"639":1,"734":1,"735":1,"738":1,"776":1,"879":1,"1022":1,"1042":1,"1125":3,"1319":1}}],["numbered",{"2":{"712":1}}],["number>",{"2":{"492":1,"494":1,"1329":2}}],["numbering",{"0":{"768":1,"1093":1},"2":{"152":1,"189":1,"364":1,"370":3,"763":3,"768":2,"1088":4,"1093":3,"1110":2,"1125":3,"1157":1,"1268":2,"1272":1}}],["numberingsystem",{"2":{"138":1,"146":1,"367":1,"786":1,"817":1}}],["numberformat",{"2":{"115":1,"117":1,"606":2}}],["numbers",{"2":{"97":1,"115":1,"117":1,"201":1,"207":1,"294":1,"297":1,"370":1,"388":1,"505":1,"544":4,"545":2,"699":1,"766":1,"836":2,"869":1,"994":1,"995":1,"997":1,"1022":1,"1029":1,"1030":1,"1042":1,"1096":1,"1312":1}}],["number",{"0":{"1247":1,"1285":1,"1286":1,"1291":1,"1292":1,"1294":2,"1295":1,"1296":2,"1297":2,"1298":1},"2":{"60":1,"94":1,"117":3,"137":1,"138":10,"150":10,"151":7,"152":6,"154":2,"157":2,"158":3,"161":3,"188":1,"206":1,"231":1,"233":1,"234":1,"235":1,"265":4,"266":1,"267":3,"270":2,"297":1,"315":6,"317":1,"323":2,"355":1,"387":1,"396":1,"399":1,"406":1,"413":1,"415":1,"430":1,"431":2,"440":1,"449":1,"520":3,"544":2,"616":1,"750":1,"769":1,"771":1,"776":1,"787":3,"871":4,"872":1,"881":2,"882":4,"890":2,"891":2,"899":2,"900":1,"937":4,"938":4,"959":1,"986":4,"989":1,"992":2,"1013":1,"1015":1,"1021":2,"1022":3,"1030":2,"1033":2,"1036":1,"1042":1,"1071":4,"1078":1,"1081":3,"1082":2,"1083":3,"1084":3,"1085":2,"1089":1,"1090":1,"1095":1,"1125":1,"1189":1,"1199":1,"1201":1,"1203":1,"1220":2,"1221":1,"1223":2,"1240":3,"1248":4,"1266":1,"1304":3,"1310":3,"1318":1,"1329":3,"1332":1,"1336":4,"1363":3,"1364":2,"1365":2,"1382":2,"1389":1,"1392":1,"1395":1,"1403":1,"1404":7,"1427":3,"1446":2}}],["n",{"0":{"983":1,"1235":1},"2":{"138":3,"323":2,"416":2,"425":1,"446":1,"683":2,"919":1,"920":2,"940":2,"983":2,"986":1,"1072":1,"1089":1,"1125":15,"1438":1}}],["nsw",{"2":{"285":2,"881":1,"890":1,"899":1,"1213":1,"1220":1}}],["ns",{"2":{"117":1,"137":1,"138":4,"151":1,"154":1,"170":1,"418":1,"569":2,"1319":2,"1381":1}}],["naive",{"2":{"1218":1,"1219":1,"1223":1}}],["nautical",{"2":{"1052":1,"1053":1,"1067":2,"1073":2,"1084":1,"1362":1}}],["narrative",{"0":{"897":1,"1016":1},"1":{"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1},"2":{"879":1,"881":1,"882":1,"897":1,"899":1,"900":1,"919":2,"1016":3}}],["narrows",{"2":{"769":1}}],["narrowing",{"2":{"617":1,"769":1}}],["narrow",{"2":{"159":1}}],["navigator",{"0":{"1124":1},"2":{"1265":1}}],["navigation",{"0":{"193":1,"194":1,"380":1,"383":1,"1354":1},"1":{"194":1,"195":1,"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1},"2":{"222":2,"661":1,"751":1,"1067":1,"1080":1,"1162":1,"1339":1,"1343":1,"1344":3,"1365":1}}],["navigating",{"0":{"185":1,"1196":1},"1":{"186":1,"187":1,"188":1,"189":1,"190":1,"1197":1},"2":{"378":1}}],["navigate",{"2":{"26":1,"64":1,"185":1,"191":1}}],["naming",{"0":{"274":1,"572":1},"2":{"138":1,"263":1,"271":1,"280":1,"341":1,"546":1,"612":1,"773":1,"1272":1,"1273":1}}],["namespacing",{"0":{"1164":1,"1341":1},"1":{"1165":1,"1342":1},"2":{"978":1}}],["namespaced",{"2":{"788":1,"866":1,"1009":1}}],["namespaces",{"0":{"271":1},"1":{"272":1},"2":{"102":2,"144":1,"264":1,"272":1,"280":1,"535":1,"541":1,"711":1,"823":1,"1103":1}}],["namespace",{"0":{"141":2,"143":1,"145":1,"263":1,"268":1,"280":1,"459":1,"776":1,"786":1,"823":1,"850":1,"915":1,"916":1,"1406":1},"1":{"142":2,"143":2,"144":2,"145":2,"264":1,"265":1,"266":1,"267":1,"268":1,"269":1,"270":1,"271":1,"272":1,"916":1,"917":2,"918":1},"2":{"45":2,"141":2,"143":2,"145":1,"154":1,"168":1,"230":1,"261":1,"264":2,"265":2,"267":1,"269":3,"270":1,"271":3,"274":1,"276":3,"280":2,"294":1,"297":2,"328":1,"367":1,"371":1,"378":1,"380":1,"381":1,"382":1,"402":1,"468":2,"505":1,"537":1,"544":1,"711":1,"712":1,"722":1,"784":1,"821":1,"830":1,"836":1,"866":1,"915":1,"916":1,"919":1,"1106":2,"1151":1,"1153":1,"1164":1,"1173":2,"1178":1,"1194":1,"1215":1,"1341":1,"1357":1}}],["names",{"0":{"392":1},"2":{"213":1,"240":1,"326":2,"364":1,"375":1,"399":1,"416":1,"723":1,"1011":2,"1095":1,"1157":3,"1293":1}}],["named",{"0":{"134":1,"153":1,"460":1},"2":{"133":1,"138":1,"168":1,"237":1,"250":1,"297":1,"306":1,"315":1,"457":1,"651":1,"711":1,"1088":1}}],["name",{"2":{"22":1,"26":1,"115":1,"117":1,"137":4,"142":2,"153":4,"232":1,"233":1,"235":1,"240":2,"265":2,"270":1,"271":1,"274":3,"285":1,"290":1,"391":1,"392":1,"426":3,"461":1,"860":1,"893":1,"902":1,"1059":1,"1083":3,"1090":4,"1104":4,"1111":2,"1113":1,"1125":3,"1167":1,"1168":1,"1176":1,"1178":1,"1191":1,"1209":1,"1214":1,"1216":1,"1220":2,"1223":1,"1313":1}}],["nano",{"2":{"137":1,"154":1,"355":1,"750":1}}],["nanosecond",{"0":{"511":1},"2":{"63":1,"137":1,"209":1,"382":1,"511":1,"522":1,"613":1,"673":1,"738":1,"1319":2,"1367":1,"1377":1}}],["nanoseconds",{"2":{"60":2,"137":1,"138":1,"151":1,"154":1,"174":2,"201":1,"207":1,"355":1,"507":2,"567":1,"568":1,"569":1,"750":2,"1315":1,"1319":1,"1368":1,"1369":1,"1370":1,"1381":1,"1382":1}}],["nationale",{"2":{"1213":1}}],["national",{"2":{"1207":1,"1213":2,"1214":1,"1224":2}}],["nativetempopattern",{"2":{"1147":3}}],["nativestr",{"2":{"146":1}}],["natively",{"2":{"10":2,"12":2,"34":2,"42":1,"43":1,"59":1,"165":1,"170":1,"181":1,"202":1,"203":1,"213":1,"219":1,"222":2,"260":1,"311":1,"363":1,"414":1,"492":1,"503":1,"514":1,"515":1,"688":1,"689":1,"722":1,"723":1,"735":1,"746":1,"763":1,"771":1,"776":1,"884":1,"909":1,"1378":1,"1416":1,"1418":1}}],["native",{"0":{"37":1,"41":1,"80":1,"146":1,"149":1,"204":1,"516":1,"774":1,"818":1,"884":1,"894":1,"902":1,"984":1,"1120":1,"1121":1,"1132":1,"1372":1},"1":{"42":1,"43":1,"44":1,"517":1,"518":1,"519":1,"520":1,"1121":1,"1122":1},"2":{"0":1,"3":2,"7":1,"10":2,"11":3,"14":1,"24":1,"26":1,"27":1,"34":2,"37":1,"39":1,"41":2,"63":2,"76":4,"83":1,"95":1,"109":1,"130":1,"131":2,"137":1,"138":1,"146":2,"147":4,"149":2,"150":2,"154":1,"167":1,"170":1,"185":1,"196":1,"197":2,"198":2,"199":2,"204":2,"220":1,"233":1,"251":1,"361":2,"363":1,"364":1,"365":2,"367":4,"370":1,"371":1,"372":1,"373":1,"411":1,"427":1,"448":1,"450":1,"451":2,"452":1,"456":1,"461":1,"467":1,"468":4,"469":2,"471":2,"472":2,"489":1,"498":2,"501":1,"505":1,"507":4,"511":1,"513":3,"514":2,"516":2,"517":1,"518":1,"519":2,"520":2,"522":1,"524":1,"594":1,"673":1,"691":1,"701":1,"702":2,"704":1,"719":1,"723":1,"729":1,"731":1,"747":1,"750":1,"754":1,"768":1,"776":1,"778":1,"786":1,"814":1,"817":1,"818":1,"829":1,"831":1,"865":1,"876":1,"888":1,"903":1,"910":1,"962":1,"968":2,"975":1,"984":6,"991":1,"993":1,"1086":1,"1089":2,"1092":1,"1098":3,"1103":3,"1104":6,"1105":1,"1113":1,"1114":1,"1120":2,"1121":2,"1122":2,"1123":1,"1124":1,"1125":2,"1132":1,"1147":4,"1158":5,"1166":1,"1171":2,"1190":3,"1218":1,"1287":1,"1319":1,"1376":3}}],["naturalaction",{"2":{"482":1}}],["naturally",{"2":{"269":1,"792":1}}],["natural",{"0":{"89":1,"906":1,"960":1,"1013":1,"1014":1,"1350":1,"1351":1},"1":{"907":1,"908":1,"909":1,"910":1,"911":1,"912":1,"961":1,"962":1,"963":1,"964":1,"965":1,"1351":1,"1352":1,"1353":1},"2":{"9":1,"11":1,"12":2,"14":1,"96":1,"122":1,"125":1,"158":5,"159":1,"196":1,"198":1,"204":1,"210":1,"221":1,"315":1,"323":1,"384":1,"395":1,"516":1,"517":2,"520":1,"526":1,"647":2,"684":1,"689":1,"701":1,"711":1,"738":1,"767":1,"771":2,"775":2,"776":1,"787":1,"800":1,"802":1,"906":1,"913":2,"919":2,"921":1,"960":1,"961":1,"981":1,"982":1,"987":1,"1008":1,"1013":1,"1014":1,"1067":1,"1082":1,"1289":1,"1339":1,"1343":1,"1344":1,"1345":1,"1350":1,"1351":1,"1353":1,"1362":1,"1446":1}}],["noël",{"2":{"1213":1}}],["nocturnal",{"0":{"1085":1},"2":{"1085":1}}],["nominatim",{"2":{"1175":1,"1178":6,"1189":1,"1191":1}}],["nominative",{"0":{"1292":1},"2":{"1095":1}}],["nominate",{"2":{"363":1}}],["nominal",{"0":{"163":1},"2":{"161":2,"163":2,"165":2,"469":2,"606":2}}],["novembres",{"2":{"1270":2,"1276":1,"1280":1}}],["november",{"2":{"203":3,"909":2,"925":1,"951":1,"954":1,"1270":1}}],["nov",{"2":{"203":1,"976":1,"1213":1,"1224":1,"1269":1,"1270":1,"1276":1,"1280":1,"1303":1,"1304":3}}],["noise",{"0":{"125":1},"2":{"125":2,"227":1,"300":1,"363":1,"429":1,"647":2,"648":1}}],["noon",{"0":{"1068":2,"1366":1},"2":{"123":3,"150":1,"240":1,"338":1,"398":1,"949":1,"1052":2,"1053":1,"1054":1,"1055":3,"1066":1,"1068":2,"1069":3,"1080":1,"1081":1,"1082":2,"1094":2,"1343":1,"1353":2,"1366":3}}],["norway",{"2":{"1072":2}}],["nor",{"2":{"402":1}}],["nord",{"2":{"145":1}}],["normalizing",{"2":{"1168":1,"1328":1}}],["normalizeexternaltimestamp",{"2":{"1141":4}}],["normalize",{"2":{"1136":1,"1167":1}}],["normalizeutcoffset",{"2":{"637":1}}],["normalizer",{"2":{"616":2,"622":1,"752":1}}],["normalizers",{"2":{"522":1}}],["normalizedepochs",{"2":{"1030":2}}],["normalizedevicebatch",{"2":{"1030":2}}],["normalizedprompt",{"2":{"912":1,"936":1}}],["normalized",{"2":{"227":1,"399":1,"654":1,"868":1,"904":1,"950":1,"1030":3,"1077":1,"1136":1,"1140":1,"1141":1,"1358":1}}],["normalizes",{"2":{"220":1,"690":1,"1030":1,"1110":1,"1136":1}}],["normalization",{"0":{"220":1,"227":1,"1027":1,"1136":1},"1":{"1028":1,"1029":1,"1030":1},"2":{"357":1,"399":1,"637":1,"802":1,"1161":1}}],["normal",{"2":{"113":1,"1053":1,"1055":1,"1076":2,"1083":1,"1224":1,"1262":1}}],["northernmost",{"2":{"1045":1}}],["northern",{"2":{"302":1,"304":2,"519":1,"907":1,"1046":2,"1060":1,"1213":1,"1336":1}}],["north",{"2":{"73":1,"117":1,"121":1,"142":1,"145":1,"154":1,"227":1,"302":1,"303":1,"304":1,"313":4,"366":1,"389":1,"458":2,"459":1,"519":1,"824":1,"849":1,"872":1,"878":1,"1030":1,"1046":1,"1047":1,"1048":2,"1049":1,"1054":1,"1059":1,"1060":4,"1062":1,"1071":1,"1178":1,"1358":1,"1359":1,"1365":1}}],["nownano",{"2":{"1368":1,"1369":1,"1370":1,"1381":1,"1382":1,"1388":1,"1389":1,"1395":1}}],["now",{"0":{"53":1,"1245":1},"2":{"52":2,"69":1,"97":1,"118":1,"121":1,"124":2,"131":1,"132":1,"158":12,"166":1,"171":1,"177":1,"191":1,"228":1,"234":1,"235":1,"236":1,"240":1,"268":1,"276":1,"337":1,"352":1,"386":1,"396":1,"397":2,"399":1,"437":1,"440":1,"446":1,"449":1,"518":1,"519":1,"520":3,"522":1,"550":1,"552":2,"553":1,"558":1,"567":1,"569":1,"597":2,"612":1,"617":2,"631":1,"639":2,"649":1,"675":1,"676":1,"678":1,"680":1,"682":1,"687":1,"688":1,"689":1,"691":1,"695":1,"699":1,"704":1,"707":2,"712":1,"716":1,"720":1,"722":2,"723":1,"731":1,"732":2,"734":1,"735":1,"737":1,"738":2,"743":1,"744":1,"747":1,"750":2,"752":1,"754":1,"757":2,"758":1,"765":1,"768":1,"774":1,"786":2,"802":1,"807":1,"812":1,"816":1,"823":1,"833":1,"859":1,"942":1,"1013":1,"1014":1,"1015":1,"1147":3,"1167":1,"1178":4,"1181":1,"1191":1,"1193":1,"1216":1,"1220":3,"1235":3,"1239":2,"1241":2,"1243":1,"1254":1,"1256":2,"1259":1,"1260":1,"1261":2,"1265":1,"1266":1,"1267":2,"1370":1,"1381":1,"1382":1,"1388":3,"1389":1,"1391":2,"1392":3,"1422":1}}],["nonis",{"2":{"1269":3}}],["nonae",{"2":{"1269":1}}],["nones",{"2":{"1269":3,"1270":1,"1275":1,"1276":1,"1299":1,"1304":1}}],["none",{"2":{"539":1,"769":1,"836":1,"1085":1,"1090":1,"1158":1,"1167":1,"1376":1,"1382":5}}],["non",{"0":{"1093":1},"2":{"30":1,"41":1,"95":1,"165":1,"205":1,"208":1,"215":1,"220":1,"243":1,"296":1,"317":1,"363":1,"367":1,"377":1,"464":1,"627":1,"665":1,"691":1,"701":1,"709":1,"739":1,"782":1,"802":1,"912":1,"996":1,"1008":1,"1010":1,"1011":1,"1015":1,"1093":1,"1137":1,"1203":2,"1205":1,"1221":1,"1224":2,"1376":1,"1406":1,"1426":1,"1442":1}}],["no",{"2":{"12":1,"39":1,"41":1,"46":1,"124":1,"132":1,"138":1,"139":1,"145":1,"159":1,"165":1,"191":1,"199":1,"202":1,"262":1,"300":1,"377":1,"388":2,"393":1,"399":1,"429":2,"538":1,"539":1,"551":1,"571":1,"572":1,"629":1,"854":1,"855":1,"859":1,"946":1,"993":1,"1004":1,"1005":1,"1011":1,"1025":1,"1038":1,"1041":1,"1067":1,"1091":2,"1107":1,"1121":1,"1211":1,"1225":2,"1252":1,"1321":1,"1349":1,"1384":1,"1410":1}}],["notorious",{"2":{"1443":1}}],["notoriously",{"2":{"909":1,"1091":1,"1265":1}}],["notation",{"2":{"1412":1}}],["notated",{"2":{"141":1}}],["notifies",{"2":{"1405":1}}],["notifications",{"0":{"1016":1},"2":{"1016":1}}],["notification",{"2":{"905":1}}],["notify",{"2":{"998":1}}],["notices",{"2":{"771":1,"776":1,"786":1}}],["noticeably",{"2":{"450":1}}],["notice",{"0":{"922":1},"2":{"233":1,"265":1,"291":1,"913":1,"922":1,"1008":1}}],["nothing",{"2":{"41":1,"359":1,"427":1}}],["notes",{"0":{"114":1,"410":1,"637":1},"2":{"442":1,"450":1,"888":1,"994":1,"1395":1}}],["note",{"0":{"34":1},"2":{"34":2,"47":1,"76":1,"89":1,"120":1,"125":1,"137":1,"139":1,"147":1,"150":2,"152":1,"159":1,"170":1,"260":1,"262":2,"274":1,"297":1,"311":1,"357":1,"361":1,"365":1,"367":1,"402":1,"407":1,"416":1,"426":1,"451":1,"456":1,"479":1,"481":1,"502":1,"559":1,"637":1,"763":1,"768":1,"771":1,"854":1,"870":1,"922":1,"948":1,"954":1,"968":1,"972":1,"1008":1,"1089":1,"1125":1,"1178":1,"1319":1,"1376":1,"1378":1,"1417":1,"1421":1,"1442":1}}],["not",{"0":{"113":1,"221":1},"2":{"7":1,"21":1,"34":2,"38":1,"76":1,"102":1,"124":1,"131":1,"158":2,"179":1,"191":1,"198":1,"215":1,"229":1,"234":1,"250":1,"269":1,"274":1,"279":1,"281":2,"291":1,"292":1,"296":1,"298":1,"300":1,"320":1,"325":1,"326":1,"331":1,"357":1,"359":2,"360":1,"365":1,"388":4,"407":1,"409":1,"434":1,"438":1,"453":1,"456":1,"464":1,"479":1,"486":2,"503":2,"516":1,"528":1,"541":1,"560":1,"565":1,"627":1,"751":1,"769":1,"863":1,"909":1,"954":2,"955":1,"972":3,"989":1,"1008":2,"1011":2,"1054":3,"1067":1,"1072":1,"1086":1,"1092":1,"1125":2,"1129":1,"1178":1,"1188":1,"1195":3,"1218":1,"1257":1,"1270":1,"1372":1,"1376":1,"1422":1,"1442":1,"1450":1}}],["nodeintegration",{"2":{"1376":1}}],["nodes",{"2":{"978":1,"1255":2,"1422":1}}],["nodejs",{"2":{"468":1,"504":1,"998":1}}],["node",{"0":{"35":1,"37":1,"38":1,"103":1},"1":{"36":1,"37":1,"38":1},"2":{"3":2,"10":3,"34":2,"37":1,"43":2,"69":1,"102":2,"103":1,"106":1,"107":1,"119":1,"215":1,"300":1,"365":4,"419":2,"446":1,"447":1,"449":1,"450":1,"479":1,"559":2,"594":1,"610":1,"620":1,"635":1,"648":1,"651":1,"669":1,"726":1,"729":1,"829":1,"853":1,"860":1,"861":1,"869":1,"913":1,"915":1,"925":1,"936":1,"957":1,"996":2,"998":1,"1011":3,"1028":1,"1039":1,"1041":1,"1188":1,"1368":1,"1370":1,"1371":1,"1372":1,"1376":2,"1378":1,"1381":1,"1389":2}}],["nerva",{"2":{"1281":2}}],["neujahr",{"2":{"1213":1}}],["neighbors",{"2":{"1134":1}}],["neither",{"2":{"402":1}}],["nesting",{"2":{"1085":1}}],["nested",{"2":{"43":2,"374":1,"562":1,"565":1,"616":1,"633":1,"744":1,"747":1,"757":1,"775":1,"788":1,"1091":1,"1139":1}}],["negligible",{"2":{"972":1}}],["negotiated",{"2":{"862":1}}],["negation",{"2":{"734":1}}],["negative",{"2":{"138":3,"157":1,"183":2,"451":1,"771":2,"886":1,"1046":1,"1060":1,"1404":1,"1420":1}}],["neap",{"2":{"1052":1,"1053":1,"1055":1,"1076":2,"1080":1,"1083":1}}],["neatly",{"2":{"711":1}}],["nearest",{"2":{"1035":1,"1197":1,"1316":1,"1318":1,"1319":1,"1329":1,"1332":2,"1351":1}}],["nearly",{"2":{"407":1,"665":1,"1366":1}}],["near",{"2":{"228":1,"415":1,"429":1,"444":1,"1064":2,"1077":1,"1083":1}}],["nexus",{"2":{"402":1}}],["nextoccurrence",{"2":{"1451":1}}],["nextosmslot",{"2":{"1178":3}}],["nextactiveworkday",{"2":{"1224":2}}],["nextworkday",{"2":{"1209":2}}],["nextbusinessday",{"0":{"1197":1},"2":{"1197":1,"1209":1,"1210":1,"1222":1}}],["nextbiz",{"2":{"236":1}}],["nextlowtide",{"2":{"1078":2}}],["nexthightide",{"2":{"1078":2,"1083":3}}],["nextsunrise",{"2":{"1055":1}}],["nextcursor",{"2":{"978":2}}],["nexttaxyear",{"2":{"270":3}}],["next",{"0":{"860":1},"2":{"6":1,"9":1,"10":1,"11":1,"12":1,"36":1,"38":1,"45":1,"59":2,"99":1,"116":1,"119":1,"125":1,"158":1,"188":1,"191":2,"194":2,"201":1,"204":1,"211":1,"222":2,"223":1,"233":6,"235":6,"240":1,"326":1,"352":1,"357":1,"363":1,"380":3,"383":2,"386":1,"387":1,"390":1,"393":2,"395":3,"489":2,"510":1,"517":2,"522":1,"525":1,"684":1,"734":2,"735":1,"737":5,"739":4,"776":1,"802":1,"850":1,"856":1,"858":1,"859":1,"860":2,"880":1,"888":1,"889":1,"896":1,"906":1,"911":3,"916":1,"917":1,"935":1,"939":1,"945":1,"946":1,"948":1,"951":1,"955":1,"968":1,"970":2,"978":2,"983":1,"986":1,"987":1,"988":1,"997":3,"1005":1,"1012":1,"1013":2,"1193":1,"1197":3,"1209":1,"1222":2,"1270":1,"1405":1,"1415":2,"1426":3,"1427":2,"1436":1,"1445":1}}],["neptune",{"2":{"305":1}}],["necessary",{"2":{"146":1}}],["never",{"2":{"27":1,"89":1,"120":1,"181":1,"233":1,"276":1,"327":1,"403":1,"465":1,"504":1,"522":1,"617":1,"631":1,"737":1,"857":1,"913":1,"955":1,"1004":1,"1005":1,"1088":1,"1187":1,"1263":1,"1428":1,"1442":1}}],["needing",{"2":{"265":1,"1085":1}}],["needed",{"2":{"165":1,"427":1,"854":1,"929":1,"1091":1}}],["needlessly",{"2":{"34":1}}],["needs",{"2":{"16":1,"248":1,"270":1,"321":2,"480":1,"1035":1}}],["need",{"0":{"293":1},"2":{"10":1,"39":1,"44":1,"45":1,"46":1,"88":1,"97":1,"112":1,"138":1,"147":2,"150":1,"161":1,"164":1,"173":1,"197":1,"198":1,"199":1,"210":1,"233":1,"236":2,"249":1,"250":1,"260":1,"269":1,"276":1,"282":1,"293":1,"355":1,"455":1,"474":1,"482":1,"515":2,"519":2,"531":1,"552":1,"561":1,"675":2,"723":1,"759":1,"1049":1,"1088":1,"1255":1,"1303":1,"1309":1,"1312":1}}],["networks",{"2":{"1218":1}}],["network",{"0":{"975":1,"984":1,"999":1,"1422":1},"1":{"1000":1,"1001":1},"2":{"42":1,"43":1,"93":2,"109":1,"203":1,"227":1,"472":1,"610":1,"856":1,"862":1,"866":1,"920":1,"941":1,"942":1,"951":1,"968":1,"971":1,"972":1,"974":2,"975":1,"980":1,"984":1,"1000":1,"1011":1,"1028":1,"1080":1,"1182":1,"1184":3,"1213":1,"1225":1,"1229":1,"1233":3,"1236":1,"1253":1,"1263":1,"1267":1,"1339":2,"1394":1,"1444":1}}],["net",{"0":{"1130":1,"1135":1,"1374":1,"1440":1},"1":{"1441":1,"1442":1},"2":{"10":2,"42":2,"44":5,"45":3,"47":2,"850":3,"885":1,"1011":1,"1103":2,"1104":3,"1123":2,"1125":2,"1135":1,"1440":1,"1442":2}}],["new",{"0":{"578":1,"584":1,"588":1,"592":1,"596":1,"600":1,"606":1,"609":1,"612":1,"620":1,"639":1,"659":1,"704":1,"707":1,"711":1,"716":1,"719":1,"720":1,"722":1,"723":1,"728":1,"731":1,"734":1,"737":1,"741":1,"743":1,"746":1,"750":1,"754":1,"758":1,"764":1,"772":1,"785":1,"791":1,"796":1,"805":1,"811":1,"815":1,"822":1,"828":1,"837":1},"1":{"765":1,"766":1,"767":1,"768":1,"769":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"786":1,"787":1,"788":1,"792":1,"793":1,"797":1,"798":1,"806":1,"807":1,"808":1,"812":1,"816":1,"817":1,"818":1,"819":1,"823":1,"824":1,"825":1,"829":1,"830":1,"831":1,"832":1,"838":1,"839":1,"840":1,"841":1,"842":1},"2":{"6":2,"7":1,"8":1,"9":2,"10":1,"26":1,"27":1,"31":1,"32":1,"36":1,"38":1,"40":1,"42":1,"45":1,"46":1,"52":1,"53":1,"54":1,"55":1,"58":2,"59":3,"60":1,"62":4,"63":3,"64":1,"65":1,"66":1,"68":2,"69":2,"71":3,"72":1,"73":5,"75":1,"76":1,"77":1,"78":1,"80":3,"81":3,"82":3,"87":1,"95":1,"98":1,"101":1,"110":2,"118":1,"119":2,"120":1,"121":1,"123":1,"124":1,"125":3,"133":1,"134":1,"137":1,"140":1,"142":1,"144":2,"145":1,"146":2,"147":2,"149":1,"158":2,"159":3,"169":1,"170":1,"171":2,"176":4,"177":3,"178":6,"179":7,"180":7,"181":1,"182":1,"183":1,"186":1,"191":1,"192":1,"199":1,"200":1,"203":9,"205":3,"207":3,"214":1,"215":3,"217":2,"219":3,"222":3,"223":3,"226":1,"230":1,"231":1,"233":1,"236":1,"237":1,"243":1,"244":1,"261":1,"267":1,"268":1,"271":1,"276":1,"279":1,"281":1,"283":1,"291":1,"296":2,"298":1,"300":1,"303":2,"304":2,"305":1,"306":1,"315":2,"317":1,"323":1,"325":1,"331":2,"333":2,"338":1,"339":1,"341":1,"344":1,"351":1,"357":1,"358":1,"360":1,"363":3,"367":2,"368":1,"372":1,"377":1,"387":1,"394":1,"406":3,"407":1,"411":1,"415":1,"421":2,"425":2,"431":1,"437":1,"439":2,"440":1,"446":2,"448":1,"465":2,"481":2,"482":1,"483":1,"484":1,"486":1,"489":1,"493":2,"494":1,"500":2,"514":1,"517":2,"518":1,"519":1,"520":3,"556":1,"563":3,"564":2,"565":1,"568":2,"571":4,"572":2,"575":1,"590":1,"596":1,"598":1,"637":1,"639":1,"640":1,"689":2,"690":1,"695":1,"702":1,"704":1,"705":1,"707":2,"708":1,"728":3,"731":1,"734":1,"737":3,"741":1,"743":1,"747":1,"751":1,"754":1,"758":1,"765":2,"766":3,"768":1,"773":1,"776":1,"786":1,"792":2,"797":1,"806":3,"807":1,"824":1,"848":1,"849":1,"850":1,"860":8,"872":1,"880":2,"885":1,"889":2,"898":4,"907":1,"908":1,"910":1,"955":1,"964":1,"974":1,"977":1,"978":1,"988":2,"993":1,"1004":1,"1013":1,"1014":1,"1015":1,"1016":1,"1039":2,"1041":3,"1046":3,"1047":1,"1048":2,"1049":1,"1054":1,"1055":4,"1056":1,"1059":3,"1060":2,"1061":1,"1062":1,"1063":1,"1064":3,"1065":3,"1067":3,"1068":1,"1069":2,"1070":1,"1071":1,"1072":2,"1076":3,"1077":1,"1078":2,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1088":1,"1098":1,"1101":1,"1102":1,"1118":1,"1141":1,"1144":1,"1147":1,"1153":1,"1154":1,"1158":1,"1167":1,"1169":1,"1171":1,"1172":1,"1173":1,"1178":1,"1180":1,"1181":1,"1187":1,"1188":1,"1190":1,"1193":1,"1195":2,"1197":1,"1199":1,"1201":2,"1203":2,"1205":2,"1207":1,"1209":3,"1213":8,"1214":1,"1216":1,"1217":1,"1220":2,"1221":2,"1222":3,"1223":3,"1224":2,"1234":1,"1245":1,"1251":1,"1254":1,"1259":1,"1265":1,"1269":1,"1271":1,"1273":1,"1280":3,"1281":1,"1304":1,"1307":2,"1310":1,"1313":1,"1316":1,"1317":1,"1318":1,"1326":1,"1329":3,"1332":1,"1335":1,"1337":1,"1348":3,"1352":1,"1357":1,"1358":1,"1360":2,"1361":3,"1363":3,"1366":1,"1369":1,"1381":2,"1382":2,"1389":2,"1392":1,"1395":1,"1408":1,"1429":3,"1430":1,"1445":1,"1447":2,"1452":1}}],["npt",{"2":{"296":1}}],["npx",{"2":{"6":1,"741":1}}],["npmjs",{"2":{"846":1}}],["npm",{"2":{"3":1,"4":1,"6":3,"10":4,"35":2,"39":2,"42":2,"44":5,"45":3,"47":2,"116":1,"229":1,"284":1,"648":1,"665":1,"759":1,"846":2,"850":3,"857":1}}],["e=±rtt2",{"2":{"1231":1}}],["eight",{"2":{"1269":1}}],["einheit",{"2":{"1213":1}}],["either",{"2":{"34":1,"131":1,"168":1,"219":1,"281":1,"919":1,"1023":1,"1084":1,"1150":1}}],["ebb",{"2":{"1083":1}}],["eurostar",{"2":{"1360":1}}],["european",{"2":{"375":1,"766":1,"1139":1,"1141":1,"1309":1,"1366":1}}],["europe",{"2":{"68":1,"112":1,"113":1,"296":2,"878":2,"1366":1,"1429":1,"1430":1}}],["eu",{"2":{"909":1}}],["etl",{"2":{"1018":1,"1042":1,"1225":1}}],["et",{"2":{"372":1,"1273":1}}],["etc",{"2":{"64":1,"72":1,"117":1,"123":1,"127":1,"146":1,"170":1,"181":1,"191":1,"199":2,"240":7,"246":1,"251":1,"265":1,"296":1,"301":1,"338":1,"351":1,"367":1,"375":1,"402":1,"446":1,"448":1,"504":1,"556":1,"684":1,"712":1,"870":1,"874":1,"1097":1,"1104":6,"1168":2}}],["eee",{"2":{"1125":1}}],["eeee",{"0":{"1095":1},"2":{"1095":1,"1098":1,"1125":1}}],["eest",{"2":{"296":1}}],["eet",{"2":{"296":1}}],["ey",{"2":{"242":1}}],["equinox",{"0":{"1048":1},"2":{"1045":1,"1046":2,"1047":2,"1048":1,"1052":1,"1055":2,"1213":2}}],["equinoxes",{"0":{"1044":1},"1":{"1045":1,"1046":1,"1047":1,"1048":1,"1049":1},"2":{"849":1,"1044":1,"1045":1,"1048":2,"1052":2}}],["equivalents",{"2":{"1122":1,"1124":1}}],["equivalent",{"2":{"165":1,"186":1,"188":1,"223":1,"369":1,"734":1,"1104":1,"1113":1}}],["equation",{"2":{"1069":1,"1353":1}}],["equatorial",{"2":{"227":1,"1063":2}}],["equator",{"2":{"117":1,"121":1,"142":1,"145":1,"227":2,"824":1,"1045":1,"1054":1}}],["equality",{"2":{"735":1}}],["equal",{"2":{"393":2}}],["edge",{"0":{"1193":1},"2":{"726":1,"857":1,"861":1,"913":1,"922":1,"954":1,"1008":1,"1094":1,"1166":1,"1188":1,"1193":2,"1366":1,"1422":1,"1444":1,"1454":1}}],["educational",{"2":{"708":1}}],["editing",{"2":{"1331":1}}],["edition",{"2":{"539":1}}],["editor",{"2":{"83":1,"89":1,"91":1,"464":2}}],["edt",{"2":{"296":2,"898":2}}],["edo",{"0":{"160":1},"2":{"158":1,"160":1,"520":2}}],["eponymous",{"2":{"1291":1,"1292":1,"1312":1}}],["epochms",{"2":{"1240":1,"1266":1,"1444":1}}],["epochmilliseconds",{"2":{"146":1,"1257":1}}],["epoch=",{"2":{"1232":1}}],["epochs",{"0":{"1042":1},"1":{"1043":1},"2":{"206":2,"1019":2,"1020":2,"1021":1,"1029":2,"1033":1,"1038":1,"1039":3}}],["epochnanoseconds",{"2":{"170":2}}],["epoch",{"0":{"206":1,"208":1},"1":{"207":1,"208":1,"209":1},"2":{"154":1,"170":1,"174":1,"208":1,"355":2,"613":1,"616":2,"738":1,"750":2,"1009":1,"1018":1,"1029":2,"1030":2,"1037":1,"1069":1,"1125":3,"1223":4,"1232":1,"1255":1,"1261":4,"1265":1,"1266":2,"1368":1,"1381":1,"1382":2,"1421":1,"1444":2}}],["epigraphic",{"2":{"763":1,"1303":1}}],["epigraphy",{"0":{"1302":1},"1":{"1303":1,"1304":1},"2":{"763":1,"1299":1,"1301":1}}],["ephemerally",{"2":{"855":1,"863":1,"1007":1}}],["ephemeral",{"0":{"863":1,"1006":1},"1":{"1007":1,"1008":1,"1009":1},"2":{"89":1,"331":1,"332":1,"335":1,"543":1,"831":1}}],["ephemeris",{"0":{"1047":1,"1058":1,"1066":1},"1":{"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1,"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1},"2":{"83":1,"1045":1,"1049":1,"1052":4,"1053":2,"1055":2,"1080":1,"1353":2}}],["egyptian",{"2":{"1158":1,"1171":1}}],["egypt",{"2":{"1158":3,"1171":1,"1190":1}}],["egress",{"2":{"953":1}}],["eg",{"2":{"138":1,"146":2,"186":1,"370":3,"1157":1,"1158":7,"1159":2,"1171":2,"1190":2}}],["eot",{"2":{"1069":1,"1353":1}}],["eod",{"2":{"888":1}}],["eon",{"2":{"137":1,"150":1,"152":1,"707":1}}],["eoy",{"2":{"97":1}}],["efficiency",{"2":{"406":1,"418":1,"419":1,"423":1,"445":1,"972":1}}],["efficiently",{"2":{"466":1}}],["efficient",{"2":{"125":1,"232":1,"560":1,"945":1}}],["effortless",{"2":{"516":1,"522":1}}],["effortlessly",{"2":{"191":1,"525":1,"1315":1}}],["effort",{"0":{"1442":1},"2":{"365":1,"1396":1,"1442":1}}],["effective",{"2":{"1214":1,"1363":1}}],["effect",{"0":{"258":1,"678":1,"812":1,"917":1,"1020":1,"1056":1,"1102":1,"1154":1,"1165":1,"1241":1,"1317":1,"1342":1,"1380":1,"1400":1},"2":{"250":1,"274":2,"309":1,"421":1,"810":1,"1450":1}}],["effects",{"0":{"327":1},"2":{"42":1,"276":1,"327":1,"527":1,"552":1,"613":1,"812":1,"1450":1,"1459":1}}],["elbe",{"2":{"1083":1}}],["elliptical",{"2":{"1064":1,"1075":1}}],["eligible",{"2":{"1008":1,"1203":1}}],["eliminated",{"2":{"403":1,"653":1}}],["eliminates",{"2":{"371":1,"516":1,"910":1,"1377":1}}],["eliminate",{"2":{"93":1,"119":1,"137":1,"139":1,"617":1,"651":1,"743":1,"902":1,"911":1,"1011":1,"1096":1,"1113":1}}],["eliminating",{"0":{"1088":1},"2":{"42":1,"227":1,"282":1,"416":1,"453":1,"489":1,"709":1,"722":1,"723":1,"752":1,"825":1,"1388":1,"1444":1}}],["el",{"2":{"363":3}}],["elapsed",{"2":{"150":1,"156":1,"157":1,"159":1,"449":1,"520":1,"774":1,"775":1,"882":1,"884":1,"902":1,"1363":1,"1448":1}}],["else",{"2":{"138":1,"519":3,"978":1,"1134":1,"1223":1}}],["electron",{"2":{"1376":1}}],["element",{"2":{"305":2,"637":1,"776":1}}],["elements",{"2":{"138":1}}],["elegantly",{"2":{"236":1,"519":1,"722":1}}],["elev",{"2":{"1055":1}}],["elevated",{"2":{"950":1}}],["elevations",{"2":{"1070":1}}],["elevation",{"0":{"1070":2},"2":{"117":1,"142":2,"154":1,"1052":1,"1053":1,"1055":1,"1066":1,"1067":1,"1070":5,"1071":1,"1080":1,"1081":1}}],["eleventh",{"2":{"203":2}}],["erroneous",{"2":{"1088":1}}],["errored",{"2":{"377":1}}],["errorcondition",{"2":{"281":1}}],["errors",{"0":{"973":1},"2":{"261":1,"282":1,"358":1,"627":2,"651":2,"657":1,"709":2,"866":1,"921":1,"942":1,"1110":1,"1161":1,"1257":1,"1422":1}}],["error",{"0":{"281":1},"2":{"76":1,"117":1,"139":1,"161":1,"176":1,"281":4,"282":2,"295":1,"333":1,"358":2,"360":1,"481":1,"482":1,"483":1,"484":1,"487":1,"490":4,"503":1,"593":1,"622":1,"649":1,"661":1,"696":1,"702":1,"860":2,"920":1,"954":1,"955":5,"970":5,"972":1,"973":1,"980":1,"1003":1,"1004":1,"1008":1,"1014":1,"1088":1,"1136":1,"1141":1,"1143":1,"1182":1,"1221":1,"1231":1,"1376":1,"1444":1,"1445":1}}],["err",{"2":{"282":2,"482":2,"483":2,"490":2,"860":2,"955":2,"1444":2}}],["eras",{"2":{"202":1,"750":1}}],["erayear",{"2":{"152":1}}],["era",{"0":{"202":1,"1294":1},"2":{"137":3,"146":2,"150":3,"152":1,"202":6,"240":2,"242":4,"506":1,"514":1,"707":3,"1272":3,"1294":1,"1295":1}}],["ergonomically",{"2":{"711":1}}],["ergonomics",{"0":{"114":1},"2":{"522":1,"747":1,"827":1}}],["ergonomic",{"0":{"169":1,"793":1},"2":{"113":1,"527":1,"790":1}}],["eagerly",{"2":{"1450":1}}],["eager",{"2":{"300":1,"442":1,"446":1}}],["earth",{"2":{"227":1,"937":1,"1064":1,"1069":1,"1075":1,"1077":1,"1080":1,"1351":1,"1355":1}}],["early",{"2":{"109":1,"306":1,"490":1,"1110":1,"1213":1,"1269":1,"1312":1}}],["earlier",{"2":{"101":1,"112":1,"886":1}}],["each",{"2":{"157":1,"301":2,"326":1,"329":1,"330":1,"371":1,"402":1,"405":1,"409":1,"453":1,"465":1,"469":1,"484":1,"559":1,"643":1,"867":1,"947":1,"972":1,"1004":1,"1039":2,"1073":1,"1082":1,"1126":1,"1139":1,"1147":1,"1185":1,"1331":1,"1392":1,"1413":1,"1415":3,"1444":1}}],["ease",{"2":{"524":1}}],["easter",{"2":{"951":1,"1213":3,"1221":2,"1225":1}}],["eastern",{"2":{"71":1,"138":1,"296":1,"365":1,"1205":1,"1207":1,"1336":1,"1338":1}}],["east",{"2":{"366":1,"1062":1,"1071":1,"1093":1,"1188":1,"1338":1,"1352":2,"1358":1}}],["easy",{"2":{"129":1,"273":1,"471":1}}],["easier",{"2":{"114":1,"456":1,"562":1,"661":1,"747":1}}],["easiest",{"2":{"41":1,"42":1,"43":1,"169":1}}],["easily",{"2":{"43":1,"229":1,"233":1,"473":1,"493":1,"691":1,"701":1,"732":1}}],["ema",{"0":{"1234":1},"2":{"1226":1,"1236":1,"1240":1,"1242":1,"1246":1,"1267":1}}],["emailtext",{"2":{"889":2}}],["emails",{"2":{"869":1,"888":1,"936":1,"994":1,"995":1,"1011":1}}],["email",{"2":{"204":1,"534":1,"869":1,"997":1}}],["emailing",{"2":{"21":1}}],["emergence",{"2":{"1085":1}}],["emergency",{"0":{"651":1}}],["emoji",{"0":{"1060":2},"2":{"775":1,"1055":1,"1058":1,"1060":3}}],["emojis",{"2":{"446":1,"1052":1,"1053":1}}],["emission",{"2":{"645":1,"653":1}}],["emit",{"2":{"1108":1,"1115":1,"1127":1,"1129":1,"1132":1,"1139":1,"1144":1,"1324":1,"1328":1,"1376":1,"1378":1,"1419":1}}],["emitter",{"2":{"1424":1,"1444":1}}],["emitted",{"2":{"497":1,"631":1,"1425":3,"1427":1}}],["emitting",{"2":{"1099":1,"1438":1}}],["emits",{"2":{"138":2,"1276":1}}],["empire",{"2":{"1312":1}}],["emperor",{"2":{"1213":1,"1307":5}}],["employees",{"2":{"1222":1,"1223":2}}],["employee",{"2":{"1035":1,"1222":1,"1223":1}}],["employs",{"2":{"405":1,"408":1}}],["empty",{"2":{"144":1,"360":1,"503":1,"593":1,"983":1,"1125":1}}],["embedder",{"2":{"1375":1,"1378":1}}],["embedded",{"2":{"888":1,"1091":1}}],["embedding",{"2":{"1126":1}}],["embeds",{"2":{"370":1}}],["embed",{"2":{"75":1,"680":1}}],["ecclesiastical",{"2":{"1309":1}}],["eccentricity",{"2":{"1069":1}}],["ecliptic",{"2":{"1075":1}}],["eclipse",{"0":{"1065":2},"2":{"1052":2,"1053":1,"1054":1,"1065":8}}],["eclipses",{"2":{"1052":1,"1053":1,"1065":1}}],["economies",{"2":{"1212":1,"1215":1}}],["economics",{"0":{"972":1},"2":{"972":1}}],["ecological",{"0":{"1085":1},"2":{"1085":1}}],["ecosystems",{"2":{"1099":1,"1103":1,"1109":1,"1112":1,"1116":1,"1150":1}}],["ecosystem",{"0":{"14":1,"229":1,"671":1,"729":1,"747":1,"751":1,"1123":1,"1133":1,"1148":1},"1":{"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":2,"1135":2,"1136":2,"1149":1,"1150":1},"2":{"11":1,"12":1,"14":1,"23":1,"78":1,"102":1,"137":1,"236":1,"273":1,"283":1,"420":1,"421":1,"514":1,"547":1,"648":1,"708":1,"851":1,"1105":1,"1112":1,"1115":1,"1123":1,"1162":1,"1236":1,"1275":1,"1339":1,"1396":1,"1414":1}}],["ecmascript",{"2":{"12":1,"83":1,"157":1,"167":1,"361":2,"363":1,"365":1,"366":1,"367":1,"371":1,"461":1,"522":1,"572":1,"717":1,"1094":1,"1095":1,"1256":1,"1432":1,"1442":1}}],["es2018",{"2":{"489":1}}],["es2015",{"2":{"468":1}}],["es2022",{"2":{"5":1}}],["esbuild",{"2":{"468":1}}],["es6",{"2":{"404":1}}],["essential",{"2":{"278":1,"665":1,"948":1,"1431":1}}],["escapes",{"2":{"1091":1}}],["escaped",{"2":{"243":2,"771":1,"778":2,"1091":1}}],["escape",{"0":{"369":1},"2":{"243":2,"522":1,"1091":1,"1096":1,"1098":1,"1130":1,"1131":1}}],["escaping",{"0":{"1091":1,"1112":1,"1126":1},"1":{"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1},"2":{"243":1,"778":1,"1091":1,"1105":1,"1112":2,"1126":1}}],["estuary",{"2":{"1083":1}}],["estuaries",{"2":{"1083":1}}],["estimatedarrival",{"2":{"1083":2}}],["estimated",{"0":{"1229":1},"2":{"1078":2}}],["est",{"2":{"213":1,"214":1,"294":1,"296":2,"689":1,"1447":1}}],["established",{"2":{"659":1,"1099":1,"1261":1}}],["establishes",{"2":{"262":2,"276":1}}],["establishing",{"2":{"409":1}}],["establish",{"2":{"116":2,"152":1,"907":1,"1234":1,"1325":1}}],["eslint",{"2":{"191":2,"541":1,"832":1}}],["es",{"2":{"106":1,"219":2,"363":4,"468":1,"702":1,"836":1,"919":1}}],["esm",{"2":{"10":4,"33":1,"39":1,"41":2,"42":3,"43":7,"44":1,"45":1,"83":1,"112":1,"468":1,"648":1,"651":1,"657":2,"671":1,"726":1,"729":1,"839":1}}],["evolution",{"2":{"574":1}}],["evolve",{"2":{"514":2}}],["evolves",{"2":{"34":1}}],["evidenced",{"2":{"514":1}}],["evict",{"2":{"976":1}}],["evicting",{"0":{"976":1},"2":{"798":1}}],["eviction",{"2":{"92":1,"94":2,"694":1,"695":1,"1009":1}}],["evicted",{"2":{"94":1}}],["evt",{"2":{"240":1,"241":1,"245":1}}],["evaluable",{"0":{"807":1},"2":{"117":4,"119":1,"477":2,"536":1,"804":1,"838":1,"841":1,"933":1,"938":5,"1004":1}}],["evaluating",{"2":{"175":1,"424":1,"469":1,"631":1,"1054":1,"1106":1,"1110":1,"1214":1,"1387":1}}],["evaluations",{"2":{"177":1,"711":1}}],["evaluation",{"0":{"119":1,"264":1,"411":1,"424":1,"477":1,"838":1,"954":1,"1106":1},"1":{"120":1,"412":1,"425":1,"426":1,"427":1,"428":1,"429":1},"2":{"1":1,"12":1,"83":1,"96":1,"112":1,"148":2,"280":1,"300":1,"377":1,"406":1,"407":1,"412":1,"424":1,"425":1,"426":1,"429":3,"477":3,"479":1,"537":1,"592":1,"708":1,"840":1,"841":1,"855":1,"929":1,"953":1,"954":2,"1008":1,"1046":2,"1387":1}}],["evaluator",{"2":{"147":1,"427":1}}],["evaluators",{"2":{"76":1,"147":1,"704":1,"731":1,"1388":1}}],["evaluatetraderisk",{"2":{"1389":1}}],["evaluateloginrisk",{"2":{"1363":2}}],["evaluateinvertermode",{"2":{"1081":1}}],["evaluateconfigasync",{"2":{"477":1,"841":1}}],["evaluateconfig",{"2":{"477":1,"841":1}}],["evaluateasync",{"2":{"477":3,"841":1,"855":1}}],["evaluates",{"2":{"357":1,"370":1,"412":1,"746":1,"812":1,"987":1,"1011":1,"1054":1,"1077":1,"1119":1,"1144":1,"1214":1,"1261":1,"1298":1,"1344":1,"1392":1}}],["evaluatedatms",{"2":{"1389":1}}],["evaluatedatnano",{"2":{"1389":1}}],["evaluated",{"2":{"112":1,"120":1,"124":1,"264":1,"266":1,"268":1,"273":1,"300":1,"353":1,"357":1,"375":1,"377":1,"412":2,"425":1,"427":1,"429":1,"450":1,"536":1,"629":1,"639":1,"807":1,"838":1,"911":3,"933":1,"1004":1,"1106":1,"1213":1}}],["evaluate",{"0":{"477":1},"2":{"69":1,"91":1,"120":1,"181":1,"262":1,"370":1,"394":1,"424":1,"426":1,"477":4,"519":1,"726":1,"807":1,"841":1,"855":1,"908":1,"989":1,"1054":1,"1072":2,"1153":2,"1363":1,"1387":1}}],["eval",{"2":{"109":1,"1041":1}}],["eve",{"2":{"1224":2}}],["evergreen",{"2":{"729":1}}],["ever",{"2":{"99":1,"233":1,"265":1}}],["everything",{"2":{"551":1,"1132":1}}],["everyday",{"2":{"522":1,"763":1,"778":1,"1273":1}}],["everywhere",{"2":{"43":1,"466":1,"509":1,"1134":1}}],["every",{"2":{"13":1,"93":1,"133":1,"138":1,"148":1,"155":1,"172":1,"265":1,"266":1,"300":1,"316":1,"336":1,"337":1,"351":1,"367":1,"406":1,"418":1,"424":1,"425":1,"429":1,"524":1,"617":1,"738":1,"910":1,"912":1,"933":1,"948":1,"968":1,"981":1,"982":1,"985":1,"1004":1,"1014":2,"1095":1,"1146":1,"1192":1,"1234":1,"1255":1,"1269":2,"1271":1,"1276":1,"1329":1,"1388":1,"1412":2,"1413":3,"1417":1,"1424":1,"1425":1,"1435":1,"1444":2}}],["eveninglightson",{"2":{"1082":1}}],["evening",{"2":{"306":1,"1415":1}}],["evenly",{"2":{"158":1,"1033":1}}],["even",{"2":{"73":1,"222":1,"291":1,"343":1,"387":1,"388":1,"402":1,"415":1,"423":1,"427":1,"431":2,"444":1,"445":1,"453":1,"465":1,"469":1,"519":1,"668":1,"684":1,"1417":1,"1445":1}}],["eventtype",{"2":{"1265":2}}],["eventtime",{"2":{"1144":3}}],["eventually",{"2":{"514":1}}],["eventemitter",{"2":{"489":1}}],["events",{"0":{"123":1,"223":1,"1015":1,"1046":1,"1048":1,"1061":1},"2":{"96":2,"97":1,"115":1,"117":1,"123":2,"219":1,"223":2,"225":1,"228":1,"229":1,"297":1,"300":1,"363":1,"416":1,"429":1,"492":1,"516":1,"544":1,"625":1,"792":1,"888":1,"889":1,"891":2,"894":1,"919":2,"988":1,"989":2,"991":1,"993":2,"998":1,"1014":1,"1050":1,"1052":1,"1053":1,"1054":1,"1058":1,"1061":1,"1080":1,"1265":1,"1324":1,"1328":1,"1361":1,"1362":1,"1364":1,"1424":1,"1446":1}}],["event",{"0":{"490":1,"888":1,"991":1,"1423":1,"1424":1,"1425":1},"1":{"491":1,"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1,"1424":1,"1425":2,"1426":1,"1427":1,"1428":1,"1429":1,"1430":1},"2":{"9":5,"89":1,"127":1,"240":1,"241":1,"242":1,"245":1,"315":3,"329":1,"348":1,"417":1,"473":2,"488":1,"489":5,"490":1,"493":1,"634":2,"639":1,"653":1,"792":1,"889":8,"891":1,"916":1,"917":1,"950":1,"951":1,"991":1,"993":1,"1015":1,"1028":1,"1046":4,"1047":1,"1264":1,"1265":1,"1328":1,"1329":1,"1332":1,"1367":1,"1368":2,"1395":1,"1401":2,"1405":1,"1423":2,"1424":1,"1425":1,"1428":1,"1436":1,"1442":1,"1443":1,"1445":1,"1446":1,"1448":1}}],["exfiltration",{"2":{"1005":1}}],["exhausts",{"2":{"1192":1}}],["exhaust",{"2":{"970":1}}],["exhausted",{"2":{"942":2,"970":1,"983":1}}],["exhaustion",{"0":{"970":1},"2":{"867":1,"983":1}}],["exhaustive",{"0":{"479":1},"2":{"1105":1}}],["exits",{"2":{"1433":1,"1445":1}}],["exiting",{"2":{"792":1,"1256":1,"1372":1,"1434":1}}],["exit",{"2":{"486":1,"494":1,"709":1,"1435":1}}],["exist",{"2":{"329":1,"427":1,"453":1,"769":2,"870":1}}],["exists",{"2":{"145":1,"769":1,"1086":1}}],["existing",{"2":{"78":1,"95":1,"120":1,"125":1,"137":1,"205":1,"296":1,"298":2,"325":1,"326":1,"331":1,"465":1,"496":1,"514":1,"515":1,"532":1,"642":1,"755":1,"776":1,"778":1,"977":1,"987":1,"989":1,"1015":2,"1118":1,"1122":1,"1147":1,"1167":1,"1172":1}}],["exotic",{"2":{"446":1}}],["excavation",{"2":{"1303":1}}],["exchanges",{"2":{"1447":1}}],["exchange",{"2":{"1221":3,"1447":1}}],["excised",{"2":{"546":1,"836":1}}],["excising",{"2":{"535":1}}],["exceeding",{"2":{"1043":1,"1233":1,"1363":2,"1421":1}}],["exceeded",{"2":{"954":1,"962":1}}],["exceeds",{"2":{"860":1,"1344":1,"1361":1}}],["excel",{"0":{"1131":1},"2":{"909":1,"1103":2,"1104":1,"1123":1,"1134":1}}],["excellent",{"2":{"230":1,"506":1,"516":1,"606":1}}],["except",{"2":{"551":1}}],["exception",{"2":{"144":1,"146":1,"559":1,"1000":1}}],["exceptionally",{"2":{"124":1,"997":1,"1077":1}}],["excluding",{"2":{"665":1,"882":1,"950":1}}],["excluded",{"2":{"885":1}}],["exclude",{"2":{"617":1,"881":1}}],["excludes",{"2":{"129":1}}],["exclusions",{"0":{"885":1}}],["exclusion",{"2":{"627":1,"769":1,"1203":2}}],["exclusively",{"2":{"273":1,"386":1,"1000":1,"1264":1}}],["exclusive",{"2":{"102":1,"177":1,"383":2}}],["execargv",{"2":{"1041":2}}],["executing",{"2":{"262":1,"266":1,"327":1,"856":1,"1037":1}}],["executions",{"2":{"1106":1}}],["execution",{"0":{"334":1,"867":1,"934":1,"939":1,"949":1,"963":1,"1038":1},"1":{"868":1,"940":1,"941":1,"942":1,"943":1,"944":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"1039":1,"1040":1},"2":{"107":1,"109":2,"112":1,"331":1,"332":1,"334":1,"335":1,"357":1,"404":3,"407":1,"419":1,"427":1,"491":1,"505":1,"606":1,"702":1,"755":1,"778":1,"825":1,"831":1,"848":1,"853":1,"855":1,"867":1,"871":1,"881":1,"890":1,"899":1,"912":1,"921":1,"924":1,"930":1,"934":3,"936":2,"937":1,"938":1,"939":1,"941":1,"959":1,"963":3,"972":2,"989":1,"1007":1,"1030":1,"1032":1,"1041":1,"1121":1,"1144":1,"1147":1,"1213":1,"1242":1,"1253":1,"1329":1,"1396":1,"1431":1,"1433":1,"1436":1,"1438":1,"1443":1,"1448":1,"1450":1}}],["executed",{"2":{"262":1,"264":1,"300":1,"833":1,"839":1,"1221":2,"1389":1,"1459":1}}],["execute",{"2":{"191":2,"266":1,"409":1,"414":1,"536":1,"731":1,"856":1,"858":1,"859":1,"1215":1,"1225":1,"1387":1}}],["executes",{"2":{"93":1,"102":1,"114":1,"409":1,"412":1,"416":1,"1008":1,"1140":1,"1370":2,"1395":1}}],["executable",{"2":{"102":2,"541":1,"830":1,"832":1}}],["exempt",{"2":{"94":1,"695":1}}],["externally",{"2":{"474":1,"480":1,"481":1}}],["external",{"2":{"89":1,"109":1,"120":1,"137":1,"205":2,"227":1,"274":1,"327":1,"340":1,"402":1,"439":1,"440":1,"479":1,"510":1,"522":1,"778":1,"792":1,"863":1,"929":1,"954":1,"980":1,"1008":1,"1011":1,"1017":1,"1084":1,"1099":2,"1101":1,"1103":1,"1104":4,"1115":1,"1116":1,"1121":1,"1141":1,"1192":2,"1263":2,"1353":1,"1451":1}}],["extendable",{"2":{"464":1}}],["extending",{"0":{"233":1,"273":1,"464":1,"516":1},"1":{"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1,"284":1,"285":1,"286":1,"287":1,"288":1,"289":1,"290":1,"291":1,"292":1,"293":1,"465":1,"517":1,"518":1,"519":1,"520":1},"2":{"237":1,"269":1,"596":1}}],["extended",{"0":{"735":1},"2":{"109":1,"122":1,"138":1,"160":1,"229":1,"465":2,"468":1,"520":1,"578":1,"1072":1}}],["extend",{"0":{"464":1,"849":1,"1449":1},"1":{"465":1,"1450":1,"1451":1,"1452":1},"2":{"45":1,"123":1,"125":1,"203":1,"211":1,"233":1,"261":1,"268":1,"271":1,"275":1,"276":1,"296":1,"431":1,"439":1,"453":1,"464":2,"465":1,"468":1,"541":1,"726":1,"832":2,"849":2,"850":1,"1451":3}}],["extends",{"0":{"105":1,"541":1,"832":1},"1":{"542":1},"2":{"14":1,"102":2,"105":2,"109":2,"115":1,"117":1,"264":1,"291":1,"437":1,"540":1,"541":3,"542":1,"734":1,"825":1,"827":1,"829":2,"830":1,"832":1,"1194":1,"1318":1}}],["extensibility",{"0":{"519":1,"672":1},"2":{"406":1,"414":1,"423":2,"430":1,"439":1,"453":1,"464":1,"468":1,"516":1,"672":1,"776":1}}],["extensible",{"0":{"776":1,"978":1},"2":{"1":1,"9":1,"12":1,"203":1,"300":1,"438":2,"440":1,"453":1,"510":1,"526":1,"642":1,"782":2,"845":1,"1098":1,"1189":1}}],["extensively",{"2":{"504":1,"747":1}}],["extensive",{"2":{"148":1,"516":1,"1098":1}}],["extension",{"0":{"849":1,"1449":1},"1":{"1450":1,"1451":1,"1452":1},"2":{"101":1,"229":1,"251":2,"274":1,"275":1,"276":1,"283":1,"596":1,"653":1,"857":1,"1449":1,"1454":1}}],["extensions",{"0":{"30":1,"287":1,"533":1},"1":{"31":1,"32":1},"2":{"229":1,"247":1,"287":1,"488":1,"529":1,"531":1,"551":1,"631":1,"702":1,"836":1,"841":1,"1125":3,"1450":1}}],["extreme",{"2":{"364":1,"423":1,"649":1,"1018":1,"1377":1}}],["extremely",{"2":{"46":1,"147":1,"407":1,"513":1}}],["extraneous",{"2":{"690":1}}],["extra",{"2":{"315":1,"1262":1,"1271":1}}],["extractaitempo",{"2":{"919":1}}],["extractai",{"0":{"888":1},"1":{"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1},"2":{"888":1,"889":2,"893":1,"894":1,"895":2,"896":1,"910":1,"912":2,"936":1,"946":1,"950":1,"973":1}}],["extracting",{"2":{"547":1}}],["extraction",{"0":{"548":1,"888":1,"896":1},"1":{"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1},"2":{"256":1,"757":1,"891":2,"1143":1}}],["extracted",{"2":{"351":1,"357":1,"548":1,"642":1,"644":1,"647":1,"757":1,"759":1,"891":3,"894":1,"919":1}}],["extract",{"2":{"45":1,"173":1,"239":1,"617":1,"750":1,"857":1,"888":1,"919":1,"1009":1,"1167":1,"1188":1,"1193":2}}],["example",{"0":{"225":1,"324":1,"542":1,"545":1,"568":1,"859":1,"860":1,"927":1},"2":{"137":1,"138":1,"142":1,"146":1,"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"224":1,"230":1,"247":1,"281":1,"296":1,"315":1,"326":1,"393":1,"394":1,"395":1,"556":1,"559":1,"560":1,"711":1,"747":1,"860":1,"909":1,"955":1,"1014":1,"1030":1,"1083":1,"1103":1,"1112":1,"1115":1,"1144":1,"1149":1,"1178":3,"1190":2,"1205":1,"1220":1,"1270":2,"1304":1,"1319":1,"1363":1,"1413":1}}],["examples",{"0":{"140":1,"944":1,"1170":1,"1181":1,"1335":1,"1346":1,"1357":1,"1407":1},"1":{"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"1171":1,"1172":1,"1347":1,"1348":1,"1408":1,"1409":1},"2":{"34":1,"140":1,"302":1,"518":1,"520":1,"581":1,"601":1,"610":1,"637":1,"640":1,"651":1,"655":1,"708":1,"747":1,"1124":1}}],["exactdays",{"2":{"164":2}}],["exactly",{"2":{"129":1,"158":1,"164":1,"178":1,"192":1,"195":1,"229":1,"262":1,"264":1,"266":1,"269":1,"339":1,"374":1,"408":1,"412":1,"510":1,"551":1,"716":1,"1319":1,"1412":1,"1415":2,"1438":1}}],["exact",{"2":{"26":1,"63":1,"76":1,"96":1,"160":1,"164":1,"173":1,"191":1,"219":1,"382":1,"394":1,"447":1,"504":1,"525":1,"739":1,"856":1,"884":1,"902":1,"907":2,"1039":1,"1047":2,"1052":1,"1054":1,"1066":1,"1068":1,"1069":2,"1082":1,"1144":1,"1201":1,"1203":1,"1265":1,"1270":1,"1272":1,"1276":1,"1303":1,"1312":1,"1344":1,"1351":1,"1353":1,"1359":1,"1381":1,"1388":1,"1415":1,"1429":1,"1444":1,"1445":1}}],["expanses",{"2":{"1366":1}}],["expand",{"2":{"1135":1}}],["expanding",{"2":{"747":1}}],["expanded",{"0":{"841":1},"2":{"589":1,"594":1,"610":1,"620":1,"623":1,"661":1,"673":1,"707":1,"720":1,"1070":1}}],["expands",{"2":{"246":1,"827":1}}],["expired",{"2":{"691":1}}],["expiration",{"2":{"92":1,"94":2,"694":1,"695":1,"974":1,"1008":1,"1009":1}}],["exponential",{"0":{"1234":1},"2":{"1226":1,"1234":1,"1236":1,"1240":1,"1246":1,"1267":1}}],["exposure",{"2":{"864":1}}],["exposing",{"2":{"424":1,"427":1,"818":1}}],["exposed",{"2":{"402":1,"410":1,"457":1,"499":1,"913":1}}],["exposes",{"2":{"336":1,"367":1,"707":1,"824":1,"840":1,"910":1,"969":1,"1012":1,"1071":1,"1382":1}}],["expose",{"2":{"170":1,"301":1,"831":1,"857":1,"955":1}}],["exportresult",{"2":{"1104":2}}],["exporting",{"0":{"1115":1},"2":{"469":2,"724":1}}],["export",{"0":{"170":1,"1115":1,"1148":1},"1":{"1149":1,"1150":1},"2":{"102":1,"119":1,"168":1,"232":1,"235":1,"261":2,"265":1,"270":3,"271":2,"285":4,"286":1,"313":1,"319":1,"324":1,"326":1,"341":1,"456":1,"457":1,"459":1,"463":1,"464":2,"651":2,"687":1,"711":1,"722":1,"728":1,"841":1,"843":1,"860":1,"891":1,"955":1,"1011":1,"1013":1,"1014":1,"1015":1,"1016":1,"1021":1,"1030":2,"1033":1,"1036":1,"1081":4,"1082":1,"1083":1,"1084":1,"1085":1,"1099":1,"1104":2,"1115":5,"1141":1,"1144":1,"1147":1,"1150":5,"1190":1,"1192":1,"1193":1,"1220":1,"1221":1,"1222":1,"1223":1,"1265":1,"1326":2,"1329":1,"1332":1,"1363":1,"1364":1,"1365":1,"1389":2,"1392":1,"1395":1,"1444":1,"1446":1}}],["exports",{"0":{"841":1},"2":{"43":1,"234":1,"457":2,"476":1,"477":1,"596":1,"651":1,"672":1,"687":1,"1021":1,"1104":2,"1452":1}}],["exported",{"2":{"7":1,"274":1,"282":1,"322":1,"453":1,"470":1,"775":1,"776":1,"792":1,"841":1}}],["expressed",{"2":{"777":1,"1270":1}}],["expresses",{"2":{"138":2,"879":1}}],["expressive",{"0":{"518":1},"2":{"522":1,"1103":1}}],["expressions",{"0":{"1416":1},"1":{"1417":1},"2":{"196":1,"203":1,"204":1,"243":1,"247":1,"323":1,"324":1,"363":1,"416":1,"766":1,"771":1,"773":2,"775":1,"776":1,"778":1,"806":1,"888":1,"890":1,"913":1,"951":1,"960":1,"1008":1,"1012":1,"1276":1,"1401":1,"1416":1}}],["expression",{"0":{"798":1},"2":{"158":4,"237":1,"239":1,"247":1,"795":1,"1090":1,"1263":1,"1403":1,"1404":1,"1427":1}}],["express",{"0":{"860":1},"2":{"119":1,"858":1,"860":1,"955":2,"978":1}}],["explained",{"2":{"1147":3}}],["explainresult",{"2":{"1104":2}}],["explain",{"0":{"1113":1},"1":{"1114":1},"2":{"880":1,"887":1,"1099":1,"1104":2,"1105":1,"1113":2,"1114":2,"1122":1,"1147":3}}],["explains",{"2":{"452":1,"498":1,"844":1,"1086":1,"1175":1,"1350":1}}],["explanation",{"2":{"986":1}}],["explanations",{"2":{"879":1}}],["explanatory",{"2":{"157":1}}],["explosion",{"0":{"1090":1}}],["explosions",{"2":{"1086":1}}],["exploits",{"2":{"411":1}}],["explores",{"2":{"1026":1,"1044":1,"1074":1,"1156":1,"1385":1}}],["explore",{"2":{"84":1,"89":1,"574":1,"954":1,"1052":1,"1105":1,"1166":1,"1242":1,"1343":1,"1401":1}}],["explicit",{"0":{"113":1,"116":1,"259":1,"310":1,"335":1,"849":1,"928":1,"958":1,"1256":1,"1282":1,"1373":1,"1432":1,"1445":1},"1":{"117":1,"929":1,"930":1,"931":1,"932":1,"933":1,"1433":1,"1434":1},"2":{"44":1,"101":1,"102":1,"103":1,"113":1,"114":1,"137":1,"139":1,"158":1,"213":1,"242":2,"247":1,"250":2,"261":1,"262":2,"274":2,"296":1,"310":1,"323":1,"389":1,"408":1,"410":1,"422":1,"469":1,"473":1,"491":1,"516":1,"522":1,"524":1,"543":2,"597":1,"689":1,"699":1,"729":1,"773":1,"790":1,"792":1,"831":1,"855":1,"881":1,"888":1,"918":1,"926":2,"932":1,"955":1,"958":1,"986":1,"1012":1,"1054":1,"1067":2,"1093":1,"1098":1,"1104":3,"1125":1,"1158":1,"1159":2,"1169":1,"1188":2,"1207":1,"1214":1,"1256":1,"1263":1,"1278":1,"1294":1,"1373":1,"1396":1,"1401":1,"1421":1,"1432":1,"1440":1,"1441":2,"1442":1,"1443":1,"1445":1,"1447":1,"1451":1}}],["explicitly",{"2":{"44":1,"46":1,"102":1,"104":1,"136":1,"138":1,"139":1,"146":1,"202":1,"210":1,"217":1,"256":1,"281":1,"298":1,"302":1,"336":1,"370":1,"375":1,"406":1,"434":1,"486":1,"514":1,"569":1,"617":1,"630":1,"651":1,"699":1,"724":1,"747":1,"853":1,"854":1,"863":1,"884":1,"908":3,"972":1,"976":1,"977":1,"1011":1,"1088":1,"1106":1,"1188":1,"1239":1,"1316":1,"1451":1}}],["expertise",{"2":{"534":1}}],["experience",{"0":{"763":1,"771":1,"780":1},"2":{"269":1,"274":1,"286":1,"326":2,"439":1,"522":1,"702":1,"705":1,"719":1,"722":1,"867":1,"1070":1,"1258":1}}],["experiences",{"2":{"43":1}}],["experimental",{"0":{"701":1},"2":{"85":1,"402":1,"701":1,"1041":4}}],["expensive",{"2":{"266":1,"359":1,"406":1,"407":1,"424":1,"752":1,"1139":1,"1189":1}}],["expecting",{"2":{"469":1}}],["expected",{"2":{"359":1}}],["expect",{"2":{"213":1,"375":1,"524":1,"1077":1}}],["expectation",{"2":{"139":1}}],["expectations",{"2":{"24":1,"326":1,"366":1}}],["expects",{"2":{"27":1,"34":1,"158":1,"221":1}}],["e",{"0":{"1131":1},"2":{"6":1,"12":1,"22":1,"31":1,"43":1,"52":1,"59":1,"71":1,"76":1,"96":2,"97":3,"99":1,"102":2,"107":1,"116":1,"117":2,"125":1,"128":1,"129":1,"131":1,"137":1,"138":13,"143":2,"145":1,"146":1,"150":1,"155":1,"157":3,"158":2,"159":1,"161":2,"164":1,"166":1,"167":2,"173":1,"186":1,"189":2,"202":1,"204":2,"213":2,"214":1,"216":1,"219":1,"221":1,"224":1,"235":1,"240":1,"241":2,"242":2,"243":1,"245":1,"263":1,"266":1,"270":1,"271":2,"272":2,"273":2,"274":3,"276":1,"280":1,"281":2,"291":1,"295":1,"296":1,"297":2,"300":1,"301":3,"315":2,"317":1,"318":1,"321":2,"323":2,"324":1,"325":2,"326":5,"338":1,"351":2,"357":2,"362":1,"363":1,"364":1,"365":1,"366":1,"370":5,"375":1,"376":4,"380":1,"387":1,"388":1,"399":1,"403":2,"406":1,"412":1,"416":1,"418":1,"426":1,"427":1,"429":1,"431":1,"434":1,"446":1,"447":1,"448":1,"450":1,"466":1,"468":1,"469":1,"477":1,"479":2,"500":1,"505":1,"531":1,"536":1,"571":1,"606":1,"631":1,"642":1,"644":1,"678":1,"680":3,"689":1,"719":1,"722":1,"724":1,"726":1,"732":1,"743":1,"746":1,"750":1,"752":1,"758":2,"763":1,"773":3,"788":1,"806":1,"817":1,"833":1,"838":1,"842":2,"854":1,"855":1,"863":1,"866":1,"868":1,"869":1,"871":1,"872":3,"875":1,"879":1,"881":2,"884":1,"885":1,"886":2,"890":5,"897":1,"899":4,"902":1,"906":2,"907":1,"910":1,"912":1,"934":1,"937":2,"938":3,"939":1,"950":1,"951":2,"970":1,"974":1,"978":1,"983":1,"986":1,"987":1,"995":1,"997":3,"1004":2,"1009":2,"1010":1,"1012":1,"1014":1,"1016":1,"1017":1,"1028":1,"1030":1,"1032":1,"1042":1,"1054":1,"1055":1,"1062":2,"1065":2,"1067":1,"1068":1,"1071":1,"1078":3,"1081":1,"1085":2,"1088":2,"1089":1,"1090":1,"1091":1,"1093":1,"1094":1,"1096":1,"1097":1,"1110":1,"1111":1,"1113":1,"1124":1,"1125":5,"1139":1,"1144":4,"1157":1,"1158":3,"1168":1,"1178":1,"1188":1,"1190":3,"1193":1,"1207":1,"1213":1,"1214":1,"1220":2,"1222":2,"1224":1,"1233":1,"1240":1,"1259":1,"1263":1,"1273":1,"1276":1,"1289":1,"1292":1,"1303":1,"1312":1,"1319":2,"1324":2,"1328":2,"1338":1,"1351":1,"1361":2,"1364":1,"1370":1,"1376":1,"1404":1,"1414":1,"1415":2,"1421":1,"1436":1,"1444":1,"1447":1,"1450":1,"1454":1,"1457":1}}],["enrichment",{"0":{"1172":1}}],["enrich",{"2":{"1171":1,"1172":1,"1307":1}}],["enrichedcatalog",{"2":{"1307":2}}],["enriched",{"2":{"1167":1,"1169":1,"1172":3,"1173":1}}],["energy",{"2":{"1081":1,"1366":1}}],["enforcing",{"2":{"667":1,"1012":1}}],["enforced",{"0":{"1000":1},"2":{"654":1,"856":2,"862":1}}],["enforcement",{"0":{"1010":1},"2":{"616":1,"836":2,"856":1,"860":1,"922":1}}],["enforce",{"2":{"423":1,"478":1,"955":1,"1218":1,"1263":1}}],["enforces",{"2":{"271":1,"612":1,"712":1,"757":1,"830":1,"860":1,"861":1,"910":1,"911":1,"954":1,"1001":1,"1010":1,"1178":1,"1364":1}}],["enough",{"2":{"470":1,"511":1}}],["enclosed",{"2":{"1132":1}}],["enclose",{"2":{"1127":1,"1128":1,"1130":1,"1131":1}}],["encapsulation",{"2":{"667":1}}],["encapsulated",{"2":{"626":1}}],["encapsulates",{"2":{"342":1,"1097":1}}],["encryption",{"2":{"504":1}}],["encoding",{"2":{"503":1}}],["encodeuricomponent",{"2":{"1178":1,"1191":1}}],["encode",{"2":{"90":1,"509":1,"588":1}}],["encoded",{"2":{"89":1,"503":1}}],["encountered",{"2":{"882":1}}],["encounters",{"2":{"281":1,"358":1,"503":2,"866":1,"980":1,"1182":1}}],["encourages",{"2":{"367":1}}],["enjoy",{"2":{"268":1,"365":1}}],["enhances",{"2":{"800":1}}],["enhanced",{"2":{"581":1,"592":1,"609":1,"612":1,"620":1,"621":1,"623":1,"625":1,"634":1,"637":1,"640":1,"648":1,"672":1,"767":1,"788":1,"829":1}}],["enhancements",{"0":{"697":1,"705":1,"708":1,"784":1,"790":1,"804":1,"810":1,"814":1,"821":1,"827":1},"2":{"575":1,"584":1,"642":1,"1226":1}}],["enhance",{"2":{"230":1}}],["enumify",{"0":{"452":1,"467":1,"468":1,"469":1,"471":1},"1":{"453":1,"454":1,"455":1,"456":1,"457":1,"458":1,"459":1,"460":1,"461":1,"462":1,"463":1,"464":1,"465":1,"466":1,"467":1,"468":2,"469":2},"2":{"438":2,"452":1,"453":2,"454":2,"455":1,"456":4,"462":1,"463":2,"464":4,"467":1,"468":6,"469":3,"471":1,"702":1,"841":1}}],["enumerator",{"2":{"776":1}}],["enumerators",{"0":{"452":1,"471":1},"1":{"453":1,"454":1,"455":1,"456":1,"457":1,"458":1,"459":1,"460":1,"461":1,"462":1,"463":1,"464":1,"465":1,"466":1,"467":1,"468":1,"469":1},"2":{"453":1,"460":1,"466":1,"471":1,"771":1}}],["enumerate",{"0":{"438":1}}],["enumerates",{"2":{"409":1}}],["enumerations",{"2":{"452":1,"457":1}}],["enumeration",{"2":{"409":3}}],["enumerability",{"0":{"408":1},"1":{"409":1,"410":1}}],["enumerable",{"2":{"300":1,"402":1,"409":2,"410":1,"426":2,"429":1,"579":1,"1011":2}}],["enum",{"0":{"461":1,"463":1,"464":1,"467":1,"471":1},"1":{"465":1,"468":1,"469":1},"2":{"203":2,"298":1,"453":1,"456":1,"460":2,"461":13,"463":4,"464":8,"465":3,"467":1,"469":4,"471":3,"571":1,"581":1,"661":1,"776":1,"836":1,"867":1}}],["enums",{"0":{"453":1,"457":1,"462":1,"464":1,"776":1},"1":{"454":1,"455":1,"456":1,"458":1,"459":1,"460":1,"461":1,"463":1,"464":1,"465":2},"2":{"138":1,"203":4,"313":9,"324":1,"452":1,"453":1,"456":1,"457":2,"458":8,"459":4,"460":1,"461":1,"464":1,"465":2,"468":8,"469":2,"471":3,"580":2,"596":1,"771":2,"776":4}}],["ensuring",{"2":{"181":1,"198":1,"228":1,"315":1,"402":1,"421":1,"444":1,"475":1,"503":1,"504":1,"522":1,"584":1,"616":1,"617":1,"625":1,"642":1,"649":1,"653":1,"679":1,"709":1,"717":1,"755":1,"778":2,"780":1,"893":1,"1003":1,"1186":1,"1440":1}}],["ensured",{"2":{"660":1}}],["ensures",{"2":{"45":1,"102":1,"103":1,"208":1,"281":1,"312":1,"326":2,"387":1,"402":1,"403":1,"414":1,"415":1,"423":1,"430":1,"440":1,"466":1,"993":1,"1157":1,"1223":1,"1372":1}}],["ensure",{"2":{"6":1,"8":1,"24":1,"47":1,"109":1,"139":1,"261":2,"276":1,"326":2,"364":1,"365":1,"384":1,"388":1,"407":1,"441":1,"446":1,"472":1,"473":1,"559":1,"565":1,"579":1,"616":1,"617":1,"634":1,"644":1,"651":1,"653":1,"663":1,"668":1,"669":1,"760":1,"904":1,"910":1,"1011":1,"1054":1,"1067":1,"1083":1,"1221":1,"1261":1,"1442":1,"1459":1}}],["enabling",{"0":{"136":1,"211":1},"2":{"149":1,"255":1,"625":1,"642":1,"643":1,"647":1,"667":1,"771":1,"775":1,"808":1,"869":1,"995":1,"1004":1,"1063":1}}],["enables",{"2":{"107":2,"117":1,"219":1,"326":1,"536":1,"563":1,"750":1,"773":1,"933":2,"1099":1,"1253":1}}],["enable",{"2":{"93":1,"126":1,"135":1,"210":2,"211":1,"257":1,"258":1,"309":1,"321":1,"368":2,"484":1,"701":1,"930":1,"937":1,"938":1,"962":1,"1263":1,"1376":1,"1378":1}}],["enabled",{"2":{"37":1,"39":1,"89":1,"127":1,"186":1,"308":1,"357":1,"702":1,"912":3,"972":1,"996":1,"1008":1,"1039":1,"1054":1,"1088":1,"1240":1,"1243":1,"1256":1,"1262":1,"1376":1,"1422":3}}],["engaged",{"2":{"407":1}}],["english",{"2":{"76":1,"138":1,"153":4,"219":1,"220":1,"221":2,"222":1,"223":1,"363":2,"737":2,"738":1,"763":1,"767":1,"1158":1}}],["engineering",{"0":{"1226":1},"1":{"1227":1,"1228":1,"1229":1,"1230":1,"1231":1,"1232":1,"1233":1,"1234":1,"1235":1},"2":{"533":1,"534":2,"922":1,"1008":1,"1086":1,"1146":1}}],["engineered",{"2":{"411":1,"684":1,"994":1,"1105":1,"1108":1,"1367":1}}],["engines",{"0":{"1411":1},"1":{"1412":1,"1413":1,"1414":1,"1415":1,"1416":1,"1417":1,"1418":1,"1419":1,"1420":1,"1421":1,"1422":1},"2":{"236":1,"361":1,"365":1,"418":1,"466":1,"558":1,"1015":1,"1082":1,"1097":1,"1136":1,"1210":1,"1225":1,"1331":1,"1367":1,"1387":1,"1401":1}}],["engine",{"0":{"281":1,"315":1,"378":1,"422":1,"509":1,"616":1,"617":1,"667":1,"668":1,"684":1,"694":1,"778":1,"792":1,"993":1,"1038":1,"1113":1,"1219":1},"1":{"379":1,"380":1,"381":1,"382":1,"383":1,"384":1,"385":1,"386":1,"387":1,"388":1,"389":1,"1039":1,"1040":1,"1114":1,"1220":1},"2":{"1":1,"6":1,"10":1,"14":1,"42":1,"45":1,"46":1,"77":1,"96":2,"120":1,"122":1,"130":1,"132":1,"135":2,"136":1,"137":1,"141":1,"147":1,"195":1,"196":1,"201":1,"205":1,"208":2,"210":1,"222":1,"228":2,"237":1,"243":1,"245":1,"246":1,"251":1,"261":1,"268":1,"276":4,"281":1,"297":1,"315":2,"321":2,"323":1,"356":1,"357":3,"361":1,"362":1,"365":1,"366":1,"367":1,"374":1,"377":2,"378":2,"384":1,"403":1,"404":1,"412":1,"415":1,"427":2,"440":2,"446":1,"451":1,"462":1,"469":1,"470":1,"505":1,"510":1,"513":1,"522":1,"525":1,"548":1,"549":1,"550":1,"552":1,"555":1,"565":1,"574":2,"622":1,"625":2,"642":3,"647":1,"649":1,"659":1,"667":1,"672":1,"675":1,"676":1,"679":1,"684":1,"691":1,"704":1,"719":1,"723":1,"731":1,"732":1,"737":1,"738":1,"748":1,"750":1,"751":1,"754":2,"790":1,"800":1,"845":1,"871":1,"872":1,"881":1,"882":1,"890":1,"899":1,"941":1,"951":1,"993":2,"1012":1,"1019":1,"1021":1,"1086":1,"1092":1,"1094":1,"1095":1,"1099":1,"1156":1,"1215":1,"1219":1,"1388":1,"1442":1,"1454":2,"1457":2}}],["en",{"2":{"56":1,"69":1,"71":2,"116":1,"119":2,"138":1,"147":1,"154":2,"159":2,"186":2,"215":1,"218":2,"362":2,"365":2,"367":4,"368":1,"370":5,"518":1,"520":1,"563":2,"687":1,"731":1,"786":1,"870":1,"872":1,"878":1,"890":1,"899":1,"907":1,"927":1,"962":1,"1157":1,"1158":3,"1160":1,"1190":6,"1214":1}}],["env=production",{"2":{"1011":1}}],["env",{"2":{"43":2,"107":2,"477":1,"504":1,"853":6,"854":2,"856":2,"860":5,"869":1,"880":1,"889":1,"898":1,"929":1,"930":2,"932":1,"934":2,"935":1,"936":1,"939":2,"947":3,"955":1,"957":1,"958":1,"961":1,"974":1,"978":3,"982":1,"988":1,"996":2,"997":1,"1011":2,"1017":1}}],["environmental",{"2":{"1082":1}}],["environments",{"0":{"41":1},"1":{"42":1,"43":1,"44":1},"2":{"10":1,"34":3,"38":1,"41":1,"43":1,"44":1,"47":1,"83":1,"87":1,"102":2,"116":1,"215":2,"281":1,"300":1,"336":1,"358":1,"365":1,"367":2,"400":1,"422":1,"440":1,"479":1,"503":2,"515":1,"607":1,"610":1,"651":1,"657":1,"669":1,"696":1,"702":1,"726":1,"729":1,"747":1,"782":1,"829":2,"862":1,"869":1,"925":1,"936":1,"957":1,"978":1,"996":2,"997":1,"1011":1,"1017":1,"1026":1,"1040":1,"1054":1,"1067":1,"1093":1,"1137":1,"1176":1,"1185":1,"1258":1,"1387":1}}],["environment",{"0":{"365":1,"617":1,"956":1,"957":1,"996":1,"1376":1},"1":{"957":1,"958":1},"2":{"3":1,"6":1,"33":1,"34":2,"43":3,"102":4,"114":1,"258":1,"361":1,"363":1,"365":2,"367":1,"446":2,"447":1,"606":1,"617":1,"634":1,"702":1,"716":1,"853":1,"855":1,"856":1,"862":1,"870":1,"921":1,"925":2,"926":1,"952":1,"957":1,"996":1,"1011":1,"1182":1,"1188":1,"1376":2,"1378":1,"1458":1}}],["ending",{"2":{"1459":1}}],["endidx",{"2":{"1039":1}}],["endhour",{"2":{"1204":1,"1220":1}}],["enddateiso",{"2":{"1223":2}}],["enddate",{"2":{"950":1,"1223":1}}],["endofq1",{"2":{"192":1}}],["ends",{"2":{"178":1,"204":1,"771":1}}],["endns",{"0":{"174":1},"2":{"174":1}}],["ended",{"0":{"171":1},"2":{"171":1,"173":1,"174":1,"985":2}}],["end",{"0":{"63":1,"173":1,"190":1},"2":{"43":1,"63":3,"117":1,"167":1,"171":1,"177":1,"185":2,"186":3,"190":3,"192":1,"205":1,"318":1,"319":1,"320":2,"323":1,"324":3,"368":1,"369":1,"382":2,"451":1,"486":2,"490":1,"682":1,"728":1,"771":1,"773":1,"777":3,"842":1,"879":1,"880":2,"882":2,"886":1,"887":2,"889":3,"891":2,"894":1,"919":2,"986":1,"988":3,"990":1,"991":2,"992":2,"1014":1,"1015":3,"1047":2,"1201":3,"1223":3,"1224":1,"1271":2,"1325":1,"1326":5}}],["endpointurl",{"2":{"1444":2}}],["endpoints",{"0":{"932":1},"2":{"855":1,"856":3,"862":2,"868":1,"1000":1,"1001":1,"1003":1,"1239":1}}],["endpoint",{"0":{"856":1,"931":1,"1246":1},"2":{"28":1,"89":1,"728":1,"856":1,"859":1,"860":1,"931":3,"932":2,"933":1,"937":2,"938":2,"953":2,"955":4,"958":3,"959":3,"1001":1,"1008":1,"1017":1,"1227":1,"1239":1,"1240":1,"1243":1}}],["entity",{"2":{"891":1,"950":1}}],["entities",{"2":{"888":1,"890":1,"919":1}}],["entirely",{"2":{"230":1,"237":1,"325":1,"410":1,"421":1,"427":1,"451":1,"479":1,"513":1,"699":1,"836":2,"856":1,"906":1,"984":1,"1368":1}}],["entire",{"2":{"10":1,"42":1,"43":1,"170":1,"180":1,"198":1,"223":1,"263":1,"269":1,"278":1,"298":1,"871":1,"973":1,"1011":1,"1088":1,"1173":1}}],["entra",{"2":{"854":4,"1004":1}}],["entries",{"2":{"94":3,"95":1,"99":1,"298":1,"461":2,"465":1,"560":2,"691":1,"695":1,"972":1,"974":1,"976":1,"1009":2,"1329":1}}],["entry",{"0":{"103":1,"104":1},"2":{"46":1,"94":1,"102":2,"116":1,"250":1,"341":1,"351":1,"415":1,"423":1,"427":1,"444":1,"524":1,"557":1,"559":2,"648":1,"651":1,"671":1,"672":1,"687":1,"724":1,"741":1,"806":1,"960":1,"977":1,"979":1}}],["enters",{"2":{"1443":1,"1448":1}}],["entered",{"2":{"1273":1,"1415":1}}],["entering",{"2":{"1083":1}}],["enterprises",{"2":{"1224":1}}],["enterprisegeogateway",{"2":{"1191":2}}],["enterprise",{"0":{"287":1,"533":1,"1017":1,"1142":1},"1":{"1143":1,"1144":1},"2":{"101":1,"287":1,"291":1,"533":1,"534":1,"539":1,"827":1,"836":1,"854":3,"997":2,"1004":1,"1017":1,"1097":1,"1105":1,"1143":1,"1146":1,"1189":1,"1191":3,"1220":1,"1224":2}}],["enter",{"2":{"26":1,"91":2,"1362":1,"1364":1}}],["lse",{"2":{"1430":1}}],["lhrairport",{"2":{"1365":3}}],["l",{"2":{"1090":1,"1213":1}}],["lying",{"2":{"1063":1}}],["lf",{"2":{"787":1}}],["lllll",{"2":{"1090":1}}],["llll",{"0":{"1095":1},"2":{"1090":1,"1095":1,"1098":1,"1125":1}}],["lll",{"2":{"1090":1,"1102":1,"1118":1,"1125":1,"1146":1,"1147":1}}],["llama3",{"2":{"1017":1}}],["llama",{"2":{"859":1,"932":1}}],["ll",{"2":{"229":1,"269":1,"1090":1}}],["llms",{"0":{"24":1,"48":1,"692":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1},"2":{"24":1,"26":1,"27":2,"28":1,"29":1,"31":1,"48":1,"89":1,"247":4,"692":2,"701":1,"909":1,"951":1,"972":1,"1012":2,"1017":1}}],["llm",{"0":{"247":1,"854":1,"950":1},"2":{"12":1,"29":1,"93":2,"98":2,"99":1,"204":1,"247":1,"701":1,"854":1,"857":1,"859":1,"860":1,"862":1,"865":2,"866":1,"867":1,"871":1,"872":1,"874":1,"876":1,"881":2,"882":1,"884":2,"886":1,"890":2,"891":1,"893":1,"899":2,"900":1,"902":1,"906":2,"909":1,"910":2,"912":1,"913":2,"921":2,"922":1,"932":1,"937":1,"938":1,"939":1,"950":1,"955":1,"959":1,"969":2,"971":1,"972":1,"974":1,"975":2,"976":1,"977":1,"980":1,"984":1,"993":2,"995":1,"1000":1,"1005":1,"1007":1,"1010":1,"1011":1,"1012":1}}],["lru",{"2":{"92":1,"94":3,"694":1,"695":1,"1009":1}}],["lunitidalintervalmin",{"2":{"1078":3,"1083":2}}],["lunitidal",{"2":{"1074":1,"1078":1,"1083":1}}],["lunation",{"2":{"1055":1}}],["lunareclipse",{"2":{"1065":3}}],["lunarterm",{"2":{"1059":1,"1061":1,"1062":1,"1065":1}}],["lunartideminute",{"0":{"1079":1},"2":{"1054":1,"1079":1}}],["lunar",{"0":{"1058":1,"1059":2,"1060":1,"1063":1,"1065":3,"1079":1,"1268":1,"1269":1},"1":{"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1,"1269":1,"1270":1,"1271":1,"1272":1,"1273":1,"1274":1},"2":{"87":1,"1050":2,"1052":5,"1053":7,"1054":12,"1055":7,"1058":2,"1059":5,"1060":2,"1061":6,"1062":3,"1063":1,"1064":5,"1065":10,"1075":1,"1078":1,"1079":2,"1080":1,"1085":10,"1268":1,"1269":1,"1299":1,"1314":1}}],["lunes",{"2":{"363":1}}],["lundi",{"2":{"147":1,"372":2,"731":1,"1213":2}}],["luxon",{"0":{"78":1,"1118":1,"1127":1},"2":{"78":3,"137":1,"205":2,"506":1,"507":1,"510":1,"511":1,"514":3,"515":1,"532":1,"778":1,"808":1,"1086":1,"1088":1,"1099":1,"1103":2,"1104":3,"1108":1,"1110":1,"1114":1,"1118":2,"1123":1,"1146":1,"1147":1,"1149":1}}],["lng=$",{"2":{"1191":1}}],["lng",{"2":{"87":1,"121":2,"142":1,"144":1,"226":1,"227":1,"824":1,"1046":1,"1054":3,"1055":1,"1056":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1067":2,"1068":1,"1069":2,"1070":1,"1071":1,"1072":2,"1076":1,"1078":2,"1085":2,"1158":1,"1160":4,"1167":1,"1168":1,"1171":2,"1172":2,"1178":6,"1181":1,"1191":5,"1335":3,"1337":2,"1338":1,"1347":2,"1348":2,"1351":2,"1352":4,"1357":2,"1358":2,"1359":2,"1360":2,"1361":2,"1364":2,"1365":2}}],["ldml",{"0":{"1094":1,"1095":1,"1127":2},"2":{"78":2,"137":2,"138":2,"778":1,"808":1,"1088":3,"1090":1,"1091":1,"1094":1,"1098":1,"1099":1,"1101":1,"1103":2,"1104":5,"1105":1,"1110":2,"1112":1,"1114":1,"1116":1,"1120":1,"1123":2,"1125":5,"1127":1,"1136":1,"1141":1}}],["led",{"2":{"1082":1}}],["ledger",{"2":{"1018":1}}],["legally",{"2":{"1223":1}}],["legal",{"0":{"1308":1},"1":{"1309":1,"1310":1},"2":{"867":1,"922":1,"950":1,"1273":1,"1301":1}}],["legacymask",{"2":{"1114":2,"1147":3}}],["legacy",{"0":{"291":1,"1108":1},"1":{"1109":1,"1110":1,"1111":1,"1112":1,"1113":1,"1114":1,"1115":1,"1116":1,"1117":1,"1118":1,"1119":1,"1120":1,"1121":1,"1122":1},"2":{"12":1,"27":1,"152":2,"157":1,"214":1,"248":1,"356":1,"365":1,"367":1,"418":1,"506":2,"507":3,"512":1,"513":1,"514":3,"515":1,"532":1,"535":1,"537":1,"546":1,"565":2,"574":2,"626":1,"630":1,"732":1,"757":1,"760":1,"768":1,"776":1,"836":1,"840":1,"842":1,"1089":2,"1092":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1098":2,"1103":1,"1104":1,"1105":2,"1108":1,"1110":1,"1111":1,"1113":2,"1114":1,"1120":1,"1139":1,"1143":1,"1144":1,"1146":1,"1147":1,"1150":1}}],["lexing",{"0":{"766":1}}],["lexed",{"2":{"361":1}}],["lexer",{"2":{"219":1,"363":1,"388":2,"738":1,"766":1,"1454":1}}],["left",{"2":{"365":1,"983":1}}],["leveraging",{"2":{"402":1}}],["leveraged",{"2":{"776":1}}],["leverage",{"2":{"364":1,"515":1}}],["leverages",{"2":{"297":1,"520":1,"951":1,"1161":1,"1378":1}}],["levels",{"2":{"117":1,"282":1,"571":1,"639":1,"1076":1,"1085":1}}],["level",{"0":{"118":1,"1187":1},"2":{"43":1,"100":1,"101":1,"117":1,"142":1,"199":1,"357":1,"378":1,"458":1,"465":1,"477":1,"522":3,"528":1,"544":3,"546":1,"565":1,"613":1,"644":1,"728":1,"757":1,"775":1,"786":1,"836":3,"854":1,"979":1,"1008":1,"1011":1,"1021":1,"1041":1,"1070":1,"1111":1,"1125":1,"1168":4,"1185":1,"1187":1,"1194":1,"1219":1,"1367":1,"1378":1,"1383":1,"1450":1,"1452":1}}],["less",{"2":{"269":1}}],["lendemain",{"2":{"223":2}}],["lengths",{"2":{"156":1,"1412":1}}],["length",{"2":{"138":3,"146":1,"216":1,"407":1,"416":1,"445":1,"860":1,"978":1,"983":2,"997":1,"1022":1,"1039":4,"1071":1,"1147":1,"1178":1,"1329":1,"1396":1,"1412":1,"1426":1}}],["le",{"2":{"223":2,"982":1}}],["let",{"2":{"233":3,"235":2,"265":1,"266":1,"361":1,"519":1,"889":1,"978":1,"1178":1,"1223":2,"1389":1,"1409":1,"1441":1}}],["lets",{"2":{"222":1,"1191":1}}],["letter",{"2":{"213":1,"399":1,"689":1,"1135":1}}],["letters",{"2":{"127":1,"767":1}}],["leaving",{"2":{"1373":1,"1408":1}}],["leave",{"0":{"1223":1},"2":{"1011":1,"1210":1,"1223":6}}],["leaves",{"2":{"335":1,"491":1,"1445":1}}],["leads",{"2":{"375":1,"1149":1}}],["lead",{"2":{"281":1}}],["leadingtz",{"2":{"214":1}}],["leading",{"0":{"214":1},"2":{"109":1,"138":2,"139":1,"202":1,"213":1,"242":1,"388":1,"400":1,"857":1,"1090":1}}],["leaning",{"2":{"385":1}}],["lean",{"0":{"527":1,"552":1,"1280":1},"2":{"273":1,"300":1,"1313":1}}],["leaked",{"2":{"1003":1}}],["leaky",{"0":{"512":1}}],["leak",{"2":{"473":1,"616":1,"1401":1,"1442":1}}],["leaks",{"0":{"1445":1},"2":{"336":1,"422":1,"475":1,"495":1,"616":1,"664":1,"797":1,"1011":1,"1371":1,"1431":1,"1443":1,"1445":1}}],["leaking",{"2":{"188":1,"543":1,"1189":1,"1443":1}}],["leakage",{"0":{"1408":1},"2":{"116":1,"613":1,"709":1,"833":1,"1012":1}}],["leapcharter",{"2":{"1310":2}}],["leapday",{"2":{"1271":2,"1280":3}}],["leap",{"0":{"1271":1},"2":{"156":1,"162":1,"163":1,"164":1,"522":1,"754":1,"1275":1,"1276":1,"1280":2,"1298":1,"1310":1,"1412":1}}],["leaf",{"2":{"145":1}}],["least",{"2":{"94":1,"769":1,"962":1,"1249":1}}],["learned",{"2":{"1089":1}}],["learns",{"2":{"363":1}}],["learning",{"2":{"363":1}}],["learn",{"2":{"56":1,"58":1,"59":1,"64":1,"69":1,"76":3,"77":1,"78":1,"195":1,"275":1,"280":1,"293":1,"851":1,"954":1,"1089":1,"1090":1}}],["ltd",{"2":{"1220":1}}],["ltr",{"2":{"137":1,"365":1,"367":1,"786":1}}],["lt",{"0":{"792":1,"793":1,"807":1,"1246":1},"2":{"19":1,"45":1,"102":2,"115":2,"117":5,"119":1,"137":1,"138":1,"142":2,"250":2,"301":6,"323":1,"370":1,"383":3,"388":2,"393":4,"394":2,"398":1,"473":1,"476":1,"477":3,"488":1,"489":2,"492":2,"494":1,"514":1,"515":1,"536":1,"546":4,"709":3,"722":2,"735":2,"738":1,"790":2,"792":1,"804":1,"830":1,"838":1,"850":1,"856":1,"866":1,"910":1,"919":1,"920":1,"932":1,"933":2,"937":1,"959":1,"989":1,"991":1,"1004":3,"1011":1,"1021":1,"1063":1,"1067":4,"1090":1,"1186":1,"1240":1,"1318":1,"1358":2,"1405":2,"1415":1}}],["lts",{"2":{"10":1}}],["laptop",{"0":{"1448":1},"2":{"1258":1,"1401":1,"1448":2}}],["labour",{"2":{"1213":2}}],["labor",{"2":{"1213":2}}],["labels",{"2":{"117":2,"571":1,"680":1,"1046":1,"1052":1}}],["label",{"2":{"75":1,"326":1,"755":1,"775":2,"889":1,"891":2,"991":1,"1326":3,"1404":2,"1417":1,"1418":1,"1427":2,"1444":1,"1447":1,"1448":1}}],["laravel",{"2":{"1103":2,"1123":1}}],["largest",{"2":{"1088":1}}],["largestunit",{"2":{"161":1,"164":2,"520":1,"720":1}}],["large",{"0":{"1034":1},"1":{"1035":1,"1036":1},"2":{"329":1,"513":1,"532":1,"616":1,"913":1,"922":1,"947":1,"1010":1,"1012":1,"1024":1,"1042":1,"1117":1,"1146":1,"1366":1}}],["larger",{"2":{"161":1}}],["lag",{"2":{"1078":3,"1443":1}}],["lack",{"2":{"367":1,"1093":1}}],["lacking",{"2":{"365":1}}],["lacks",{"2":{"139":1,"167":1,"1096":1}}],["las",{"2":{"363":1}}],["lasttickms",{"2":{"1392":4}}],["lastlogin",{"2":{"1363":4}}],["lasts",{"2":{"1331":1}}],["lastsyncedat",{"2":{"1248":1}}],["lastupdated",{"2":{"797":1}}],["last",{"2":{"138":1,"139":1,"201":1,"203":6,"219":2,"222":1,"292":1,"297":1,"324":1,"393":1,"394":1,"395":3,"461":1,"737":3,"739":1,"775":1,"776":2,"911":2,"955":1,"975":1,"997":1,"1090":1,"1213":1}}],["la",{"2":{"363":1}}],["laziness",{"2":{"300":1}}],["lazily",{"2":{"124":1,"250":1,"273":1,"477":2,"668":1,"853":1,"855":1,"856":1,"925":1}}],["lazy",{"0":{"264":1,"411":1,"415":1,"424":1,"699":1,"855":1,"985":1,"1106":1},"1":{"412":1,"416":1,"425":1,"426":1,"427":1,"428":1,"429":1},"2":{"1":1,"12":1,"124":1,"148":2,"230":1,"264":1,"265":1,"280":1,"291":1,"300":1,"406":1,"407":1,"408":3,"409":1,"412":2,"415":1,"416":1,"424":2,"425":1,"426":1,"427":1,"428":1,"429":1,"441":1,"442":1,"446":1,"477":4,"516":1,"519":1,"536":1,"588":1,"699":1,"708":1,"985":1,"986":1,"1106":1,"1459":1}}],["launches",{"2":{"946":1}}],["launched",{"2":{"671":1}}],["launch",{"2":{"123":1,"223":1,"804":1,"946":1}}],["lat=$",{"2":{"1178":1,"1191":1}}],["latindate",{"2":{"1304":2,"1307":1}}],["latinarum",{"2":{"1303":1}}],["latin",{"2":{"359":1,"802":1,"1269":3,"1271":1,"1276":4,"1278":1,"1280":5,"1289":1,"1290":1,"1292":1,"1303":1,"1307":1,"1310":1,"1314":1}}],["latitude",{"2":{"154":2,"226":1,"227":1,"1046":1,"1060":1,"1063":2,"1072":1,"1081":1,"1082":1,"1083":2,"1084":2,"1085":1,"1167":3,"1168":1,"1171":1,"1178":2,"1181":1,"1336":3,"1347":1,"1359":1,"1363":2,"1365":3,"1366":1}}],["latitudes",{"2":{"121":1,"1063":2}}],["latn",{"2":{"137":1,"367":3,"786":1}}],["late",{"2":{"782":1,"1110":1}}],["later",{"2":{"101":1,"110":1,"120":1,"250":1,"276":1,"317":1,"1030":1,"1348":1,"1361":1,"1363":2,"1448":1}}],["latency",{"0":{"946":1,"1225":1},"2":{"93":1,"99":1,"204":1,"419":1,"867":4,"934":1,"939":1,"940":1,"946":1,"951":1,"954":1,"971":1,"1008":1,"1192":1,"1207":1,"1215":1,"1225":1,"1229":1,"1233":1,"1367":1,"1377":1,"1385":1,"1441":1,"1444":1}}],["latestprice",{"2":{"1446":2}}],["latest",{"2":{"47":3,"582":1,"584":1,"618":1,"958":2,"1448":1}}],["lat",{"2":{"87":1,"121":2,"142":1,"144":1,"226":1,"227":1,"824":1,"1046":1,"1054":3,"1055":1,"1056":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1067":2,"1068":1,"1069":2,"1070":1,"1071":1,"1072":2,"1076":1,"1078":2,"1085":2,"1158":1,"1160":4,"1167":1,"1168":1,"1171":2,"1172":2,"1178":8,"1181":1,"1191":5,"1335":3,"1337":2,"1338":1,"1347":2,"1348":2,"1352":4,"1357":2,"1358":2,"1359":2,"1360":2,"1361":2,"1364":2,"1365":2}}],["lang",{"2":{"145":3}}],["languages",{"2":{"109":1,"212":1,"219":2,"221":1,"363":2,"750":1,"1095":1,"1189":1}}],["language",{"0":{"89":1,"906":1,"960":1,"1013":1,"1014":1},"1":{"907":1,"908":1,"909":1,"910":1,"911":1,"912":1,"961":1,"962":1,"963":1,"964":1,"965":1},"2":{"9":1,"11":1,"12":3,"14":1,"96":1,"117":1,"122":1,"125":1,"158":5,"159":1,"165":1,"196":1,"198":1,"204":1,"210":1,"219":4,"221":1,"315":1,"362":1,"367":1,"395":1,"516":1,"517":2,"520":1,"647":2,"684":1,"689":1,"701":1,"711":1,"738":1,"752":2,"767":1,"771":1,"800":2,"802":1,"872":1,"881":1,"890":1,"899":1,"906":1,"909":1,"913":3,"919":2,"921":1,"922":1,"960":1,"961":1,"972":1,"981":1,"982":1,"987":1,"1008":1,"1010":1,"1012":1,"1013":1,"1014":1,"1156":1,"1157":1,"1158":4,"1166":1,"1190":3}}],["landmark",{"2":{"1273":1,"1276":1,"1278":1}}],["landing",{"2":{"273":1,"627":1,"666":1}}],["lands",{"2":{"63":2,"993":1,"1222":1}}],["land",{"2":{"63":1}}],["layoutorder",{"0":{"128":1,"375":1},"1":{"376":1},"2":{"117":1,"128":1,"375":2,"376":1,"630":1,"637":1}}],["layouts",{"0":{"242":1,"243":1,"376":1},"1":{"244":1},"2":{"30":1,"31":1,"32":1,"78":1,"96":2,"97":1,"115":1,"117":2,"127":4,"128":3,"213":1,"214":1,"216":1,"237":1,"243":4,"244":1,"247":1,"248":1,"294":1,"297":1,"344":1,"374":1,"375":1,"376":2,"518":1,"544":1,"560":1,"580":1,"630":1,"633":2,"1123":1}}],["layout",{"0":{"30":1,"96":1,"214":1,"237":1,"239":1,"244":1,"247":1,"362":1,"1368":1},"1":{"31":1,"32":1,"97":1,"238":1,"239":1,"240":1,"241":1,"242":1,"243":1,"244":1,"245":1,"246":1,"247":1,"248":1,"1369":1,"1370":1},"2":{"24":1,"27":2,"30":2,"31":1,"32":3,"76":1,"78":2,"97":1,"208":1,"213":1,"214":1,"238":1,"239":2,"240":1,"242":1,"243":4,"246":1,"247":2,"254":1,"357":1,"362":2,"375":2,"421":1,"510":1,"525":1,"616":1,"621":1,"637":1,"642":6,"644":2,"645":2,"659":2,"684":1,"689":1,"694":1,"709":1,"798":1,"1104":1,"1140":1,"1383":1,"1454":1}}],["layered",{"2":{"994":1}}],["layers",{"2":{"338":1,"701":1,"760":1,"830":1,"951":1}}],["layer",{"0":{"12":1,"1371":1,"1440":1,"1441":1,"1442":1},"1":{"1372":1,"1373":1,"1374":1,"1441":1,"1442":1},"2":{"92":1,"110":1,"118":1,"198":1,"270":2,"339":2,"408":1,"413":1,"527":1,"855":1,"1011":2,"1147":2,"1182":1,"1371":1,"1383":1,"1440":3}}],["liftoff",{"2":{"1420":1}}],["life",{"2":{"922":1,"1273":1}}],["lifecycles",{"2":{"332":1,"1445":1}}],["lifecycle",{"0":{"322":1,"323":1,"331":1,"420":1,"481":1,"773":1,"775":1,"1256":1,"1371":1,"1431":1,"1436":1,"1440":1},"1":{"323":1,"324":1,"325":1,"421":1,"422":1,"1372":1,"1373":1,"1374":1,"1432":1,"1433":1,"1434":1,"1435":1,"1436":1,"1437":1,"1438":1,"1439":1,"1440":1,"1441":2,"1442":2},"2":{"120":1,"262":1,"325":2,"336":1,"474":1,"475":2,"483":1,"621":1,"625":1,"771":2,"775":1,"786":1,"856":2,"969":1,"1009":1,"1055":1,"1371":1,"1383":1,"1401":1,"1440":2}}],["liturgical",{"2":{"1268":1}}],["litellm",{"2":{"858":1}}],["literals",{"0":{"1112":1},"2":{"469":1,"684":1,"778":1,"867":1,"1113":1}}],["literal",{"0":{"1091":1,"1126":1},"1":{"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1},"2":{"76":1,"148":1,"424":1,"425":1,"455":1,"469":1,"771":1,"778":1,"1091":6,"1096":1,"1098":2,"1112":4,"1127":1,"1128":1,"1129":2,"1132":2}}],["lite",{"0":{"46":1,"311":1},"2":{"33":1,"46":1,"276":2,"648":1}}],["limb",{"0":{"1063":1},"2":{"1053":1}}],["limitprice",{"2":{"1389":2}}],["limit=1",{"2":{"1178":1}}],["limiting",{"2":{"941":1,"1178":1}}],["limit",{"0":{"948":1,"1438":2},"2":{"683":1,"776":1,"856":1,"860":2,"867":1,"934":1,"936":1,"940":1,"942":1,"954":1,"967":1,"968":2,"970":1,"985":1,"986":1,"1041":1,"1178":2,"1182":1,"1256":1,"1404":2,"1405":1,"1417":1,"1419":1,"1421":1,"1422":1,"1425":1,"1426":1,"1427":2,"1436":1,"1438":3}}],["limited",{"2":{"511":1,"942":1}}],["limits",{"0":{"966":1,"968":1},"1":{"967":1,"968":1,"969":1,"970":1,"971":1,"972":1,"973":1,"974":1,"975":1,"976":1,"977":1,"978":1,"979":1,"980":1},"2":{"174":1,"221":1,"227":1,"750":1,"921":2,"953":1,"954":2,"955":1,"966":2,"968":7,"1011":1,"1192":1,"1225":1,"1387":1,"1401":1,"1417":1,"1421":1}}],["limitations",{"0":{"221":1},"2":{"64":1}}],["living",{"2":{"877":1}}],["lived",{"2":{"331":1,"332":1,"333":1,"334":1,"859":1,"1004":3,"1436":1}}],["live",{"0":{"1259":1},"1":{"1260":1,"1261":1},"2":{"28":1,"84":1,"89":1,"94":1,"229":2,"265":1,"413":1,"648":1,"666":1,"694":1,"771":1,"776":1,"871":1,"881":1,"890":1,"894":1,"895":1,"899":1,"937":1,"938":1,"949":1,"958":1,"1011":2,"1124":1,"1242":1,"1259":1,"1314":1,"1378":2,"1426":1,"1436":1}}],["licensing",{"0":{"923":1,"1025":1,"1057":1,"1107":1,"1155":1,"1174":1,"1252":1,"1321":1,"1384":1},"2":{"607":1,"612":1,"614":2,"751":2,"836":2}}],["licensed",{"2":{"547":1,"1364":1}}],["licensekey",{"2":{"539":1}}],["license",{"0":{"17":1,"1211":1,"1300":1,"1349":1,"1410":1},"2":{"17":2,"163":1,"534":1,"537":1,"539":3,"609":2,"610":1,"612":3,"659":1,"714":4,"836":4,"843":1,"845":2,"923":1,"1025":2,"1057":1,"1107":2,"1155":1,"1174":1,"1211":2,"1252":1,"1300":1,"1321":2,"1349":2,"1384":2,"1410":2}}],["libreoffice",{"2":{"1103":1}}],["libraries",{"0":{"1007":1},"2":{"116":1,"139":1,"157":1,"329":1,"424":1,"506":1,"509":1,"513":1,"532":1,"1089":1,"1091":1,"1109":1,"1111":1}}],["library",{"0":{"437":1,"438":1,"470":1,"841":1,"1161":1},"1":{"471":1,"472":1,"473":1,"474":1,"475":1,"476":1,"477":1,"478":1,"479":1},"2":{"0":1,"14":2,"101":2,"249":1,"273":1,"276":1,"278":1,"283":1,"312":1,"316":1,"319":1,"329":1,"341":1,"411":1,"414":1,"430":2,"431":2,"434":1,"435":1,"438":1,"439":3,"440":2,"446":1,"452":2,"457":1,"461":1,"462":1,"463":1,"464":1,"466":1,"467":1,"469":1,"470":1,"477":1,"479":2,"481":1,"485":1,"488":1,"489":1,"498":1,"500":1,"501":1,"502":1,"504":1,"506":1,"510":1,"512":1,"515":1,"528":1,"529":1,"534":1,"617":1,"618":1,"644":1,"661":1,"663":1,"672":1,"702":1,"720":1,"722":1,"790":1,"792":2,"793":1,"833":1,"841":1,"903":1,"1007":1,"1018":1,"1120":1,"1161":2,"1184":1,"1315":1,"1377":1}}],["lib",{"2":{"507":1}}],["lights",{"2":{"1082":1}}],["lighting",{"0":{"1082":1},"2":{"1052":1,"1066":1,"1071":1,"1080":1,"1082":1}}],["lighten",{"2":{"757":1}}],["light",{"2":{"447":1,"1067":1,"1082":1,"1353":1}}],["lightning",{"2":{"138":1,"175":1}}],["lightweight",{"2":{"12":1,"197":1,"199":1,"233":1,"478":1,"479":1,"488":1,"527":1,"558":1,"625":1,"792":1,"909":1,"1039":1,"1103":1,"1236":1,"1246":1,"1275":1,"1339":1}}],["lint",{"2":{"1114":1,"1147":1}}],["linter",{"2":{"191":1}}],["linters",{"2":{"191":1}}],["linguistic",{"2":{"1095":1}}],["lingual",{"0":{"363":1},"2":{"219":1,"361":1,"750":1}}],["lingering",{"2":{"714":1}}],["linked",{"2":{"1454":1}}],["linking",{"2":{"1156":1}}],["link",{"2":{"229":1,"627":1}}],["links",{"2":{"85":1,"89":1,"409":1}}],["linear",{"2":{"1272":1}}],["lineage",{"2":{"351":1,"936":1}}],["lines",{"2":{"469":1,"766":1}}],["liners",{"2":{"373":1}}],["line",{"2":{"192":1,"258":1,"262":1,"309":1,"373":1,"688":2,"856":1}}],["linux",{"2":{"91":1,"365":1,"419":2,"1099":1,"1103":1,"1123":1,"1149":1}}],["listener",{"2":{"489":1,"490":1,"955":1,"1446":1}}],["listeners",{"0":{"1424":1},"1":{"1425":1},"2":{"473":1,"488":1,"489":3,"490":2,"1401":1,"1405":2,"1423":1,"1424":1,"1442":1,"1445":1}}],["listens",{"2":{"421":1}}],["listed",{"2":{"229":1}}],["listformat",{"2":{"371":1}}],["list",{"2":{"76":1,"125":2,"215":1,"218":1,"228":1,"296":1,"301":1,"307":1,"313":3,"372":2,"373":1,"375":1,"438":1,"634":1,"787":3,"882":1,"890":1,"938":1,"987":1,"989":1,"993":1,"1140":1,"1178":4,"1329":3}}],["lists",{"2":{"19":1,"220":1,"262":1,"444":1}}],["likelihood",{"2":{"757":1}}],["likely",{"2":{"359":1,"506":1}}],["like",{"2":{"3":1,"10":1,"43":4,"44":3,"46":1,"58":1,"63":1,"71":1,"75":1,"76":1,"77":1,"88":1,"93":1,"102":2,"110":1,"114":1,"123":1,"127":1,"129":2,"135":1,"137":1,"138":3,"139":1,"144":1,"146":1,"148":1,"155":1,"161":2,"173":1,"191":2,"193":1,"202":1,"208":2,"215":3,"222":1,"230":2,"233":3,"247":1,"257":1,"265":1,"267":1,"273":1,"274":1,"278":1,"279":1,"283":1,"293":1,"294":1,"296":1,"298":1,"300":2,"315":1,"326":3,"338":1,"344":1,"352":1,"362":1,"363":3,"365":1,"370":2,"375":1,"378":1,"385":1,"386":1,"390":1,"395":1,"407":1,"414":2,"424":1,"430":2,"433":1,"439":1,"440":1,"451":1,"453":2,"465":1,"468":2,"471":2,"472":1,"483":1,"498":1,"504":1,"505":1,"510":2,"512":1,"513":1,"514":1,"519":1,"520":1,"532":1,"551":2,"553":1,"606":1,"617":1,"625":1,"630":1,"680":1,"704":1,"707":2,"711":1,"724":1,"726":1,"729":1,"735":2,"744":1,"747":1,"754":1,"771":1,"775":1,"776":1,"786":1,"788":2,"802":1,"817":1,"854":1,"857":1,"872":1,"874":1,"882":1,"909":1,"911":1,"912":1,"913":1,"966":1,"993":1,"1033":1,"1088":2,"1091":1,"1131":1,"1136":1,"1173":1,"1207":1,"1315":1,"1412":1}}],["lossless",{"2":{"1276":1}}],["loss",{"2":{"1028":1}}],["losses",{"0":{"469":1}}],["lose",{"2":{"737":1}}],["losing",{"2":{"514":1,"1448":1}}],["lost",{"2":{"489":1}}],["los",{"2":{"214":1,"296":1,"363":1}}],["lowest",{"2":{"290":1,"338":1,"1076":1}}],["lower",{"2":{"137":1,"138":5,"140":1,"205":1,"326":1,"451":1,"754":1,"871":1,"881":1,"890":1,"899":1,"1075":1,"1088":1,"1090":4,"1098":1}}],["lowercase",{"0":{"1088":1},"2":{"117":1,"138":1,"139":1,"140":1,"456":1,"571":1,"723":1,"763":1,"767":1,"1088":2,"1090":2,"1098":1,"1105":1,"1111":1}}],["low",{"2":{"129":1,"419":1,"451":1,"522":2,"867":1,"875":1,"912":1,"920":2,"945":1,"993":1,"1011":3,"1021":1,"1076":2,"1078":2,"1080":1,"1081":1,"1083":1,"1168":4,"1443":1}}],["loops",{"0":{"1444":1},"2":{"371":1,"466":1,"649":1,"699":1,"735":1,"792":1,"798":1,"1235":1,"1242":1,"1253":1,"1262":1,"1267":1,"1371":1,"1383":1,"1396":1,"1405":1,"1411":1,"1431":1,"1434":1,"1442":1}}],["loop",{"2":{"126":1,"233":1,"276":1,"416":1,"649":1,"829":1,"985":1,"1028":1,"1367":1,"1368":2,"1372":1,"1379":1,"1382":2,"1388":1,"1392":1,"1395":1,"1422":1,"1428":1,"1434":1,"1435":2,"1443":1}}],["look",{"2":{"357":1,"433":1}}],["looks",{"2":{"115":1,"386":1}}],["looking",{"2":{"109":1,"157":2,"451":1,"506":1}}],["lookups",{"2":{"266":1,"325":1,"327":1,"412":2,"427":1,"461":1,"974":1,"1090":1,"1189":1}}],["lookup",{"2":{"94":1,"96":1,"98":2,"293":1,"300":1,"326":1,"416":3,"429":1,"452":1,"466":1,"752":1,"868":1,"962":1,"1105":1,"1162":1,"1167":1,"1168":4,"1169":1,"1171":6,"1172":1,"1176":1,"1178":2,"1182":2,"1184":6,"1188":4,"1191":2,"1192":1,"1339":1}}],["lon=$",{"2":{"1178":1}}],["lon",{"2":{"1178":1}}],["londontime",{"2":{"1429":1}}],["london",{"2":{"68":3,"73":2,"121":1,"787":2,"878":3,"1062":1,"1157":1,"1221":1,"1347":4,"1348":1,"1358":4,"1360":1,"1363":2,"1429":2,"1430":1}}],["longitudinal",{"2":{"1069":1,"1350":1,"1351":1,"1353":2}}],["longitude",{"2":{"154":2,"226":1,"305":1,"1046":4,"1075":2,"1081":1,"1082":1,"1083":2,"1084":2,"1085":1,"1167":3,"1168":1,"1171":1,"1178":2,"1181":1,"1336":3,"1343":1,"1347":1,"1351":2,"1352":1,"1359":1,"1363":2,"1365":3,"1366":1}}],["longitudes",{"2":{"121":1}}],["longest",{"2":{"416":2}}],["longer",{"2":{"39":1,"326":1,"538":1,"539":1,"571":1,"572":1,"1067":1,"1070":1}}],["long",{"0":{"65":1,"1215":1},"1":{"1216":1,"1217":1},"2":{"76":5,"138":5,"146":4,"147":1,"157":2,"166":1,"331":1,"332":1,"333":1,"513":1,"564":2,"572":2,"731":1,"997":1,"1004":1,"1114":1,"1135":2,"1207":1,"1218":1,"1269":1,"1319":1,"1371":1,"1436":1,"1442":1,"1443":1,"1444":1}}],["loc",{"2":{"907":1}}],["locking",{"2":{"539":1,"836":1,"855":1,"1258":1,"1369":1}}],["lock=false",{"2":{"437":1}}],["lock=true",{"2":{"437":1}}],["lock",{"0":{"1039":1,"1367":1,"1370":1,"1381":1},"1":{"1368":1,"1369":1,"1370":1,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1},"2":{"437":3,"1018":1,"1191":1,"1377":1,"1383":1,"1385":1,"1388":2,"1389":1,"1395":1}}],["locked",{"0":{"968":1},"2":{"102":1,"120":1,"438":1,"453":1,"559":1,"751":2,"1164":1,"1173":1,"1341":1}}],["locks",{"2":{"47":1,"1005":1,"1083":1,"1260":1}}],["located",{"2":{"1180":1}}],["locate",{"2":{"1124":1}}],["locationiq",{"2":{"1178":2}}],["locations",{"2":{"559":1,"869":1,"1361":1}}],["location",{"0":{"121":1,"1061":1,"1188":1},"2":{"96":1,"121":1,"142":1,"522":1,"526":1,"728":1,"878":1,"1050":1,"1054":3,"1169":1,"1176":2,"1188":3,"1189":1,"1190":1,"1191":4}}],["localtimeutc",{"2":{"1265":1}}],["localtime",{"2":{"1171":5,"1247":1}}],["localhost",{"2":{"829":1,"854":1,"856":1,"862":1,"1000":1,"1017":1}}],["locality",{"2":{"142":1,"1168":1,"1181":1}}],["localize",{"2":{"59":1,"222":1,"754":2,"1167":1}}],["localizedregional",{"2":{"1158":3}}],["localizednative",{"2":{"1158":4}}],["localized",{"0":{"222":1,"737":1},"2":{"28":1,"76":1,"137":1,"138":2,"147":1,"150":1,"157":1,"159":2,"165":2,"221":1,"222":3,"357":1,"361":1,"363":1,"364":1,"370":4,"372":1,"450":3,"451":2,"518":1,"606":1,"701":1,"705":1,"707":1,"723":1,"731":1,"739":1,"746":1,"754":2,"802":1,"817":2,"893":1,"897":1,"982":1,"986":1,"1090":2,"1094":1,"1095":1,"1103":1,"1125":1,"1143":1,"1156":1}}],["localizations",{"2":{"536":1}}],["localization",{"0":{"74":1,"76":1,"145":1,"1193":1},"1":{"75":1,"76":1,"77":1,"78":1},"2":{"12":1,"50":1,"109":1,"117":1,"138":1,"221":1,"361":1,"518":1,"520":1,"746":1,"754":2,"755":2,"1166":1,"1189":1}}],["localstorage",{"2":{"110":2,"472":1,"479":1,"504":1,"857":1,"913":1,"1005":1}}],["locally",{"2":{"89":1,"243":1,"1213":1}}],["localeinfo",{"0":{"368":1},"2":{"117":1,"137":1,"186":3,"368":2,"369":1,"814":1,"817":2,"884":1}}],["locales",{"0":{"67":1,"219":1},"1":{"68":1,"69":1,"220":1,"221":1},"2":{"50":1,"71":1,"115":1,"117":2,"145":5,"146":1,"218":1,"219":1,"220":1,"297":2,"298":1,"363":1,"365":2,"370":2,"563":2,"633":1,"644":1,"738":1,"746":1,"750":1,"754":2,"817":1,"1207":1}}],["locale",{"0":{"145":1,"212":1,"361":1,"366":1,"786":1,"817":1,"1093":1,"1156":1,"1160":1,"1190":1,"1205":1},"1":{"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1,"362":1,"363":1,"364":1,"365":1,"366":1,"367":2,"368":2,"369":2,"370":2,"371":1,"372":1,"373":1,"1157":1,"1158":1,"1159":1,"1160":1,"1161":1},"2":{"12":1,"56":1,"69":4,"71":4,"76":4,"109":1,"110":1,"116":1,"117":6,"119":6,"120":1,"137":1,"138":20,"145":8,"146":3,"147":2,"154":5,"159":1,"186":3,"201":1,"215":2,"219":5,"222":1,"223":1,"224":1,"269":1,"297":1,"344":1,"361":4,"362":4,"363":2,"364":7,"365":3,"366":2,"367":12,"368":1,"370":24,"371":1,"372":3,"373":1,"522":1,"536":2,"544":1,"634":2,"642":1,"687":1,"731":1,"737":2,"750":1,"751":2,"752":2,"754":4,"784":1,"786":5,"788":1,"817":8,"838":1,"855":1,"866":1,"869":1,"870":1,"872":1,"874":1,"878":1,"881":2,"890":2,"899":2,"904":1,"907":2,"908":2,"909":1,"919":1,"921":1,"927":1,"933":4,"937":2,"938":2,"962":2,"982":1,"1009":1,"1090":5,"1093":6,"1094":3,"1095":2,"1098":6,"1103":2,"1125":4,"1157":1,"1158":4,"1159":1,"1160":1,"1161":2,"1162":1,"1166":1,"1168":3,"1169":1,"1171":2,"1189":1,"1190":3,"1195":1,"1205":3,"1207":1,"1214":1}}],["local",{"0":{"2":1,"1007":1,"1065":1,"1069":1,"1078":1},"1":{"3":1,"4":1,"5":1},"2":{"89":3,"98":1,"102":2,"103":2,"105":3,"109":3,"114":1,"115":1,"117":1,"155":1,"191":1,"272":1,"338":1,"364":1,"418":2,"522":1,"541":1,"631":1,"663":1,"669":1,"684":1,"760":1,"829":1,"833":1,"854":3,"856":2,"862":1,"863":1,"910":1,"932":1,"939":1,"996":1,"1000":1,"1008":1,"1009":1,"1017":2,"1052":2,"1053":4,"1054":1,"1055":4,"1062":2,"1063":2,"1065":1,"1066":1,"1067":1,"1068":1,"1069":2,"1074":1,"1078":4,"1125":1,"1187":1,"1190":1,"1219":1,"1227":2,"1257":1,"1378":1,"1422":2}}],["loadremotemanifest",{"2":{"1001":1}}],["loader",{"2":{"726":1,"812":1,"1041":2}}],["loaded",{"2":{"101":1,"113":1,"250":1,"272":1,"276":1,"300":1,"331":1,"346":1,"402":1,"516":1,"519":1,"538":1,"668":1,"702":1,"716":1,"741":1,"782":1,"926":1,"1054":1,"1121":1,"1422":1,"1450":1,"1459":1}}],["loads",{"2":{"103":2,"230":1,"741":1}}],["loading",{"0":{"88":1},"2":{"108":1,"661":1,"671":1,"780":1,"782":1,"858":1,"941":1,"943":1,"952":1,"994":1,"1179":1,"1364":2}}],["load",{"0":{"947":1},"2":{"34":1,"43":1,"44":1,"45":3,"112":2,"250":1,"276":1,"311":1,"428":1,"592":1,"780":1,"839":1,"934":1,"939":1,"942":1,"1262":1,"1328":1,"1368":1,"1370":1,"1450":1}}],["loving",{"2":{"16":1}}],["logistics",{"2":{"1362":1}}],["logins",{"2":{"1361":1}}],["login2",{"2":{"1348":3}}],["login1",{"2":{"1348":3}}],["logify",{"2":{"356":1}}],["logically",{"2":{"191":1,"560":1,"747":1}}],["logic",{"0":{"70":1,"156":1,"519":1,"520":1,"556":1,"680":1},"1":{"71":1,"72":1,"73":1,"157":1,"158":1,"159":1,"160":1,"161":1,"162":1,"163":1,"164":1,"165":1,"166":1},"2":{"9":1,"11":2,"50":1,"76":1,"77":1,"96":1,"102":1,"103":1,"107":2,"117":1,"123":1,"124":1,"131":1,"147":1,"173":1,"174":1,"192":1,"217":1,"219":1,"233":1,"235":1,"246":1,"266":1,"270":1,"273":1,"281":1,"283":1,"293":1,"297":1,"300":1,"327":1,"342":1,"349":1,"357":1,"368":1,"403":1,"407":1,"415":1,"417":1,"437":1,"440":1,"462":1,"466":2,"470":1,"482":1,"507":1,"509":1,"515":1,"519":2,"520":1,"527":1,"532":1,"556":1,"616":1,"617":1,"625":1,"634":2,"635":1,"642":1,"644":1,"647":1,"664":1,"668":1,"676":1,"704":1,"711":1,"735":1,"741":1,"760":1,"845":1,"909":1,"1012":1,"1035":1,"1089":1}}],["logged",{"2":{"998":1,"1054":1}}],["logger",{"2":{"282":1,"1011":1}}],["logging",{"0":{"282":1,"356":1,"403":1,"676":1,"936":1},"1":{"357":1,"358":1,"359":1,"360":1},"2":{"1":1,"282":2,"403":1,"483":1,"484":1,"580":1,"634":1,"676":2,"701":1,"702":1,"738":1,"868":1,"930":1,"936":2,"937":1,"938":1,"962":1,"1008":1,"1011":3,"1122":1,"1143":1,"1242":1,"1265":1,"1389":1}}],["logdebug",{"0":{"282":1},"2":{"282":1}}],["logerror",{"0":{"282":1},"2":{"282":3,"403":1}}],["logwarn",{"0":{"282":1},"2":{"282":2,"403":1}}],["logstash",{"2":{"1143":1}}],["logstamp",{"2":{"610":1}}],["logs",{"2":{"129":1,"357":2,"359":1,"403":1,"484":1,"869":1,"871":1,"888":1,"936":1,"980":1,"995":1,"996":1,"1007":1,"1011":2,"1157":1,"1219":1,"1265":2}}],["log",{"0":{"1265":1},"2":{"9":3,"42":1,"45":1,"52":1,"58":1,"65":1,"66":1,"68":2,"72":1,"73":4,"75":1,"87":2,"88":1,"117":2,"124":1,"125":1,"131":1,"133":1,"134":1,"146":2,"149":5,"160":3,"163":2,"164":1,"165":1,"177":1,"197":1,"214":2,"226":3,"231":1,"246":1,"248":1,"268":2,"271":1,"281":1,"282":2,"295":1,"300":1,"317":1,"335":1,"336":2,"339":1,"367":10,"429":1,"460":1,"461":1,"464":5,"481":1,"482":1,"483":2,"490":2,"491":1,"492":2,"497":1,"571":2,"639":1,"765":1,"768":2,"786":5,"792":1,"806":2,"848":1,"849":1,"850":1,"864":1,"870":5,"880":5,"885":2,"889":4,"894":1,"898":3,"912":1,"918":1,"936":2,"954":1,"961":2,"964":2,"965":1,"968":3,"969":3,"973":2,"982":4,"983":2,"984":3,"985":1,"988":4,"994":1,"995":1,"996":1,"997":2,"998":4,"1011":6,"1019":1,"1030":2,"1036":1,"1046":9,"1047":10,"1048":2,"1049":1,"1055":15,"1056":1,"1059":6,"1060":2,"1061":3,"1062":3,"1063":1,"1064":4,"1065":4,"1067":4,"1068":1,"1069":2,"1070":2,"1071":5,"1072":5,"1073":2,"1076":4,"1077":1,"1078":4,"1083":1,"1101":3,"1102":1,"1113":3,"1114":1,"1115":2,"1116":3,"1118":2,"1119":3,"1136":2,"1141":3,"1144":2,"1147":3,"1150":3,"1153":3,"1154":1,"1158":5,"1159":1,"1160":6,"1171":4,"1172":2,"1181":4,"1184":1,"1190":2,"1191":1,"1195":2,"1197":2,"1199":2,"1201":2,"1203":1,"1205":2,"1209":5,"1214":4,"1216":3,"1217":1,"1220":1,"1221":1,"1222":2,"1223":3,"1224":2,"1243":3,"1254":2,"1255":1,"1264":1,"1265":1,"1271":3,"1273":1,"1280":10,"1281":2,"1304":2,"1310":2,"1313":4,"1316":1,"1317":1,"1326":3,"1329":1,"1332":2,"1335":3,"1337":3,"1338":1,"1347":3,"1348":2,"1352":4,"1357":1,"1358":1,"1359":1,"1360":1,"1361":2,"1363":2,"1365":3,"1366":1,"1381":1,"1408":1,"1409":1,"1412":3,"1415":2,"1417":2,"1418":1,"1419":1,"1420":2,"1421":2,"1422":1,"1424":3,"1426":2,"1434":1,"1435":1,"1436":2,"1438":2,"1439":1,"1445":1,"1447":1,"1459":1}}],["1s",{"2":{"1420":1}}],["1st",{"2":{"138":1,"192":2,"202":1,"203":6,"204":1,"215":1,"266":1,"370":1,"737":1,"758":1,"768":1,"908":1,"1055":1,"1076":1,"1093":1,"1097":3,"1113":1,"1213":1,"1222":1,"1269":1,"1413":1}}],["1ms",{"2":{"1388":2,"1389":1}}],["1°",{"2":{"1351":1}}],["1h",{"2":{"1240":1,"1412":1}}],["1−α",{"2":{"1234":1}}],["1er",{"2":{"746":1}}],["1khz",{"2":{"1394":1}}],["1k",{"2":{"419":2}}],["1q",{"2":{"388":1}}],["1pm",{"2":{"306":1}}],["18°",{"2":{"1067":2}}],["18",{"0":{"662":1,"670":1,"742":1,"809":1},"1":{"663":1,"664":1,"665":1,"666":1,"667":1,"668":1,"669":1,"671":1,"672":1,"673":1,"743":1,"744":1,"810":1,"811":1,"812":1},"2":{"306":1,"365":1,"450":1,"451":1,"1059":2,"1060":2,"1072":2}}],["180°",{"2":{"227":2,"1046":1,"1062":1,"1071":1,"1076":1,"1338":2,"1358":1}}],["180",{"2":{"121":1,"1336":4}}],["1>",{"2":{"246":1}}],["1918",{"2":{"1213":1}}],["1945",{"2":{"1213":1}}],["19+",{"2":{"365":1}}],["1994",{"2":{"766":1}}],["1995",{"2":{"512":1}}],["199",{"2":{"202":2}}],["1990",{"2":{"159":1}}],["19",{"0":{"599":1,"656":1,"658":1,"703":1},"1":{"600":1,"601":1,"602":1,"603":1,"657":1,"659":1,"660":1,"661":1,"704":1,"705":1},"2":{"147":1,"186":1,"305":1,"368":1}}],["130",{"2":{"1361":2}}],["13th",{"2":{"1269":1}}],["134z",{"2":{"1068":1}}],["139",{"2":{"1160":1,"1359":1}}],["1394",{"2":{"442":2}}],["139+",{"2":{"34":1}}],["13",{"0":{"753":1},"1":{"754":1,"755":1},"2":{"159":1,"178":2,"180":2,"186":1,"368":1,"1160":1,"1269":1,"1297":1}}],["135",{"2":{"138":1}}],["114",{"2":{"1337":1}}],["11434",{"2":{"854":1,"1017":1}}],["11am",{"2":{"1209":1}}],["1123",{"2":{"1135":1}}],["110",{"2":{"1078":3,"1366":1}}],["11th",{"2":{"909":1}}],["11140",{"2":{"1363":1}}],["111",{"2":{"227":1}}],["11mo",{"2":{"162":1}}],["11",{"0":{"605":1,"686":1,"693":1,"710":1,"770":1,"1094":1},"1":{"606":1,"607":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"694":1,"695":1,"696":1,"697":1,"711":1,"712":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1},"2":{"138":3,"163":1,"179":2,"203":2,"370":1,"450":1,"889":1,"906":1,"909":1,"910":1,"918":1,"961":1,"965":1,"1059":2,"1094":1,"1203":3,"1209":1,"1214":1,"1224":3,"1304":1}}],["11+10",{"2":{"52":1}}],["178",{"2":{"1338":1}}],["170°",{"2":{"1338":2}}],["170",{"2":{"1338":2,"1359":1}}],["1700000005000",{"2":{"1036":1}}],["1700000002000",{"2":{"1030":1}}],["1700000001000",{"2":{"1019":1,"1020":1,"1030":1}}],["1700000000000",{"2":{"1019":1,"1020":1,"1030":1,"1036":1}}],["17ms",{"2":{"1331":1}}],["17t11",{"2":{"1064":1}}],["17t00",{"2":{"965":1}}],["172",{"2":{"1062":1}}],["1715900000000000n",{"2":{"207":1}}],["1715900000000",{"2":{"207":1}}],["1716163200000000000n",{"2":{"60":1}}],["1716163200000",{"2":{"60":1}}],["17",{"0":{"745":1},"1":{"746":1,"747":1,"748":1},"2":{"138":1,"150":1,"177":1,"178":1,"180":2,"324":1,"918":1,"961":1,"988":1,"1015":1,"1083":1,"1203":1,"1205":1,"1220":1,"1304":1,"1332":3,"1338":1}}],["1792843200000000000n",{"2":{"154":1}}],["1792843200000000000",{"2":{"137":1}}],["1792843200000",{"2":{"137":1,"154":1}}],["1=mon",{"2":{"137":1,"1125":1}}],["1600",{"2":{"1070":2}}],["16t04",{"2":{"1065":1}}],["167",{"2":{"138":2}}],["16",{"0":{"674":1,"749":1,"762":1,"813":1},"1":{"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"750":1,"751":1,"752":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"814":1,"815":1,"816":1,"817":1,"818":1,"819":1},"2":{"97":1,"102":1,"123":1,"186":2,"207":1,"213":4,"333":1,"367":1,"368":2,"689":4,"765":2,"1065":1,"1204":1,"1213":1,"1220":1,"1270":1,"1280":1,"1304":2,"1307":2,"1331":1,"1387":1}}],["1d",{"2":{"66":1}}],["144",{"2":{"1357":1}}],["144+",{"2":{"34":1}}],["14th",{"2":{"1012":1}}],["14µs",{"2":{"442":1}}],["14ms",{"2":{"442":1}}],["149d",{"2":{"159":1}}],["1439",{"2":{"138":2}}],["14",{"0":{"706":1},"1":{"707":1,"708":1,"709":1},"2":{"62":1,"146":2,"179":1,"305":1,"324":8,"419":2,"763":1,"766":3,"767":1,"988":1,"1047":1,"1059":2,"1069":1,"1083":1,"1270":1,"1310":2,"1316":3,"1317":1,"1324":1,"1325":3,"1326":5,"1328":1}}],["128",{"2":{"1394":1}}],["128kb",{"2":{"829":1}}],["124",{"2":{"1337":1}}],["121",{"2":{"1335":1}}],["122",{"2":{"1335":2,"1337":1,"1359":1,"1361":1}}],["125",{"2":{"1091":2,"1098":2,"1112":2,"1132":2}}],["1255u",{"2":{"419":2}}],["12°",{"2":{"1067":2}}],["120b",{"2":{"860":1}}],["120x",{"2":{"798":1}}],["127",{"2":{"829":1}}],["1278",{"2":{"121":1,"1062":1,"1347":1,"1348":1,"1358":1,"1360":1,"1363":1}}],["12th",{"2":{"419":2,"909":1}}],["12h",{"2":{"137":1,"1125":2}}],["123456z",{"2":{"1143":1,"1144":3}}],["123456",{"2":{"1125":1}}],["1234567",{"2":{"787":1}}],["123456789",{"2":{"137":1,"151":1}}],["1234",{"2":{"997":2}}],["123",{"2":{"119":1,"137":1,"151":1,"483":1,"500":1,"997":1,"1091":2,"1098":2,"1112":2,"1125":1,"1130":1,"1132":2,"1363":2}}],["12",{"2":{"9":1,"54":2,"97":1,"138":1,"139":3,"146":3,"150":1,"158":2,"179":2,"223":1,"240":2,"306":2,"313":2,"370":2,"519":1,"520":3,"885":3,"906":1,"909":1,"912":1,"974":1,"984":1,"988":4,"1065":1,"1069":2,"1071":1,"1072":1,"1079":1,"1081":1,"1082":1,"1088":4,"1089":1,"1094":2,"1110":1,"1111":1,"1113":2,"1125":6,"1139":1,"1141":1,"1222":1,"1223":4,"1224":2,"1270":1,"1280":2,"1366":1,"1415":1,"1421":1,"1439":3}}],["15ns",{"2":{"1389":1}}],["150°",{"2":{"1352":2}}],["15000ms",{"2":{"938":1}}],["15000",{"2":{"937":1,"959":1}}],["1500ms",{"2":{"209":1,"856":1}}],["15−12+1=4⟹ante",{"2":{"1270":1}}],["15ms",{"2":{"1368":1}}],["15m",{"2":{"1239":1,"1240":1,"1320":1}}],["15°",{"2":{"1062":1,"1080":1,"1351":3}}],["15s",{"2":{"935":1,"955":1}}],["15x",{"2":{"867":1}}],["15e",{"2":{"746":1}}],["15th",{"2":{"203":2,"1012":1,"1222":1,"1269":1}}],["15t12",{"2":{"1063":1}}],["15t16",{"2":{"176":1}}],["15t15",{"2":{"169":1,"170":1}}],["15t14",{"2":{"169":1,"170":1,"171":1,"176":1}}],["15t09",{"2":{"95":1}}],["153045",{"2":{"137":1}}],["151",{"2":{"87":1,"121":1,"142":1,"144":1,"154":1,"226":2,"824":1,"1046":1,"1061":1,"1071":1,"1076":1,"1078":2,"1160":1,"1172":2,"1347":1,"1352":6,"1357":1,"1364":3}}],["15",{"2":{"9":1,"62":1,"63":1,"68":1,"76":3,"78":2,"105":1,"123":1,"137":3,"144":1,"151":1,"160":1,"205":1,"219":4,"226":1,"303":2,"306":1,"317":1,"363":3,"370":1,"398":1,"806":2,"887":1,"894":1,"940":1,"955":1,"978":1,"988":3,"1023":1,"1046":3,"1083":2,"1090":1,"1091":1,"1096":1,"1101":2,"1103":1,"1104":1,"1118":1,"1119":1,"1127":1,"1128":1,"1129":1,"1141":2,"1143":1,"1144":2,"1203":2,"1205":1,"1209":1,"1232":2,"1269":1,"1270":2,"1273":1,"1280":1,"1297":1,"1307":2,"1313":3,"1316":5,"1317":1,"1319":2,"1324":1,"1325":1,"1326":2,"1351":1,"1360":2,"1404":1,"1413":2,"1415":2,"1417":3,"1444":3}}],["10°",{"2":{"1081":1}}],["104",{"2":{"1070":1,"1304":1}}],["103",{"2":{"1063":1}}],["10m",{"2":{"1033":1}}],["10am",{"2":{"888":1,"1013":1,"1421":1}}],["10s",{"2":{"860":1,"1319":1}}],["10t09",{"2":{"889":1}}],["10t08",{"2":{"158":1}}],["10t17",{"2":{"880":1}}],["10t12",{"2":{"695":1,"962":1}}],["108",{"2":{"450":1}}],["10pm",{"2":{"225":1}}],["10242026",{"2":{"137":1}}],["10",{"0":{"583":1,"608":1,"611":1,"615":1,"686":1,"698":1,"700":1,"703":1,"762":1,"770":1,"779":1,"783":1},"1":{"584":1,"585":1,"609":1,"610":1,"612":1,"613":1,"614":1,"616":1,"617":1,"618":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"699":1,"701":1,"702":1,"704":1,"705":1,"763":1,"764":1,"765":1,"766":1,"767":1,"768":1,"769":1,"771":1,"772":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"780":1,"781":1,"782":1,"784":1,"785":1,"786":1,"787":1,"788":1},"2":{"9":1,"10":1,"68":2,"78":4,"133":1,"134":1,"137":4,"138":1,"140":1,"144":2,"145":1,"149":1,"150":2,"154":1,"159":2,"188":1,"191":2,"203":1,"205":3,"208":1,"214":2,"226":1,"306":1,"324":1,"325":1,"335":1,"372":1,"398":1,"450":2,"451":1,"613":1,"689":1,"690":1,"707":2,"765":2,"766":1,"776":1,"806":3,"889":1,"972":1,"988":1,"1014":1,"1016":1,"1032":1,"1064":1,"1078":1,"1081":1,"1090":1,"1091":1,"1101":3,"1102":1,"1118":1,"1119":4,"1127":1,"1128":1,"1129":2,"1130":1,"1132":1,"1136":2,"1141":6,"1143":1,"1144":3,"1147":2,"1256":1,"1260":1,"1280":1,"1304":2,"1310":1,"1328":1,"1329":5,"1335":2,"1360":1,"1363":2,"1364":1,"1379":1,"1380":1,"1389":1,"1417":1,"1420":2,"1422":1,"1439":1}}],["100z",{"2":{"1329":1}}],["100+",{"2":{"1207":1,"1210":1,"1212":1,"1215":1}}],["100n",{"2":{"500":1}}],["1000ms",{"2":{"1233":1}}],["1000n",{"2":{"568":2,"569":1}}],["1000th",{"2":{"511":1}}],["10000",{"2":{"102":1,"291":1,"860":1}}],["1000",{"2":{"94":3,"102":1,"121":2,"174":1,"288":2,"289":1,"290":1,"568":2,"694":2,"816":1,"1178":1,"1240":1,"1319":1,"1392":1}}],["100",{"0":{"539":1,"679":1},"2":{"8":1,"83":1,"84":1,"89":1,"204":1,"209":2,"269":1,"448":1,"451":1,"468":1,"507":2,"534":1,"539":1,"573":1,"574":1,"642":1,"665":1,"669":1,"683":1,"776":1,"812":1,"835":1,"836":1,"845":1,"936":1,"978":1,"998":1,"1011":1,"1042":1,"1059":1,"1080":1,"1085":1,"1120":1,"1191":1,"1225":1,"1243":1,"1316":1}}],["1",{"0":{"26":1,"42":1,"87":1,"110":1,"119":1,"123":1,"169":1,"188":1,"194":1,"232":1,"258":1,"265":1,"275":1,"278":1,"289":1,"309":1,"333":1,"362":1,"379":1,"392":1,"411":1,"433":1,"444":2,"453":1,"458":1,"471":1,"481":1,"489":1,"499":1,"509":1,"517":1,"524":1,"540":1,"586":1,"587":1,"591":1,"595":2,"599":1,"608":1,"670":1,"674":1,"686":1,"713":1,"725":1,"733":1,"745":1,"753":1,"765":1,"773":1,"779":1,"782":1,"786":1,"792":1,"797":1,"802":1,"803":1,"806":1,"812":1,"816":1,"823":1,"826":1,"829":1,"838":1,"845":1,"859":1,"862":1,"874":1,"884":1,"893":1,"902":1,"945":1,"954":1,"968":1,"995":1,"1013":1,"1027":1,"1045":1,"1059":1,"1067":1,"1075":1,"1081":1,"1088":1,"1093":1,"1094":1,"1110":1,"1118":1,"1124":1,"1138":1,"1157":1,"1171":1,"1176":1,"1184":1,"1190":1,"1219":1,"1227":1,"1254":1,"1259":1,"1302":1,"1323":1,"1334":1,"1347":1,"1351":1,"1355":1,"1363":1,"1369":1,"1372":1,"1386":1,"1408":1,"1412":1,"1415":1,"1424":1,"1432":1,"1441":1,"1444":1},"1":{"120":1,"266":1,"380":1,"381":1,"382":1,"412":1,"454":1,"455":1,"456":1,"500":1,"501":1,"502":1,"541":1,"542":1,"543":1,"544":1,"545":1,"546":1,"587":1,"588":2,"589":2,"590":2,"591":1,"592":2,"593":2,"594":2,"595":1,"596":3,"597":3,"598":3,"599":1,"600":2,"601":2,"602":2,"603":2,"609":1,"610":1,"671":1,"672":1,"673":1,"675":1,"676":1,"677":1,"678":1,"679":1,"680":1,"681":1,"682":1,"683":1,"684":1,"687":1,"688":1,"689":1,"690":1,"691":1,"692":1,"714":1,"726":1,"734":1,"735":1,"746":1,"747":1,"748":1,"754":1,"755":1,"780":1,"781":1,"782":1,"804":1,"805":1,"806":1,"807":1,"808":1,"827":1,"828":1,"829":1,"830":1,"831":1,"832":1,"833":1,"996":1,"997":1,"1028":1,"1029":1,"1030":1,"1139":1,"1140":1,"1141":1,"1220":1,"1228":1,"1229":1,"1230":1,"1231":1,"1260":1,"1261":1,"1303":1,"1304":1,"1324":1,"1325":1,"1326":1,"1335":1,"1356":1,"1357":1,"1387":1,"1388":1,"1389":1,"1413":1,"1425":1,"1433":1,"1434":1},"2":{"1":1,"10":1,"22":1,"32":1,"42":1,"43":2,"44":2,"45":4,"46":1,"62":2,"77":1,"96":1,"97":1,"98":1,"102":1,"124":1,"137":3,"138":15,"146":1,"147":1,"148":1,"150":4,"152":3,"158":1,"159":2,"160":1,"161":1,"162":1,"163":4,"164":1,"165":2,"166":4,"184":1,"188":1,"189":4,"190":1,"192":1,"195":2,"202":1,"203":3,"204":1,"209":2,"215":1,"224":1,"231":1,"233":4,"235":3,"240":2,"265":5,"266":4,"270":3,"274":1,"276":3,"285":1,"288":1,"289":1,"290":2,"297":3,"300":1,"303":2,"304":1,"313":1,"317":2,"318":1,"324":6,"325":1,"332":1,"365":1,"370":6,"371":1,"372":3,"373":1,"381":2,"387":1,"407":1,"409":1,"412":1,"416":2,"419":3,"424":1,"426":1,"429":2,"440":1,"442":2,"444":2,"446":1,"448":1,"450":1,"454":1,"458":1,"461":1,"463":1,"473":1,"481":1,"505":1,"511":1,"519":1,"520":2,"540":1,"541":1,"542":1,"543":1,"545":2,"574":1,"603":2,"606":1,"625":1,"674":1,"681":1,"684":1,"694":1,"712":3,"734":1,"737":1,"739":5,"752":2,"766":1,"768":3,"773":2,"776":2,"780":1,"786":1,"787":1,"792":1,"804":1,"819":1,"827":1,"829":1,"842":1,"850":3,"854":1,"860":2,"862":2,"865":1,"870":1,"871":1,"872":1,"878":2,"880":1,"881":1,"882":1,"888":1,"889":1,"890":1,"891":2,"898":1,"899":1,"900":1,"904":1,"918":1,"921":1,"929":1,"934":1,"937":1,"938":1,"940":3,"947":3,"950":2,"953":1,"955":2,"972":4,"973":4,"978":1,"979":1,"982":1,"983":2,"986":1,"988":1,"989":1,"998":1,"1000":2,"1029":1,"1046":1,"1053":2,"1054":1,"1055":2,"1059":8,"1063":1,"1064":1,"1065":3,"1070":1,"1077":1,"1082":1,"1088":3,"1089":1,"1091":1,"1093":2,"1094":1,"1096":1,"1113":1,"1120":1,"1122":1,"1125":4,"1140":1,"1141":1,"1147":2,"1150":1,"1158":1,"1178":5,"1181":1,"1188":1,"1190":1,"1191":1,"1192":1,"1199":1,"1219":1,"1220":1,"1222":3,"1223":3,"1224":2,"1232":3,"1234":1,"1235":1,"1240":1,"1243":1,"1254":3,"1264":1,"1268":1,"1269":2,"1270":2,"1272":1,"1273":1,"1278":1,"1280":1,"1281":2,"1304":1,"1307":1,"1313":2,"1316":1,"1319":3,"1326":1,"1328":1,"1329":5,"1337":1,"1347":2,"1348":2,"1353":1,"1363":1,"1370":1,"1377":1,"1381":2,"1382":1,"1388":2,"1389":2,"1395":1,"1400":1,"1401":2,"1404":1,"1408":1,"1409":1,"1412":3,"1413":3,"1415":1,"1417":1,"1419":2,"1420":1,"1421":1,"1424":1,"1428":1,"1429":2,"1430":1,"1433":1,"1434":1,"1436":3,"1438":1,"1440":1,"1441":2,"1447":1}}],["dsp",{"0":{"1393":1},"1":{"1394":1,"1395":1},"2":{"1367":1,"1383":1,"1394":1}}],["dst",{"2":{"158":1,"296":1,"1447":2}}],["dli",{"2":{"1052":1,"1082":1}}],["dbformat",{"2":{"1150":2}}],["db",{"2":{"1011":1}}],["dfc",{"0":{"536":1,"838":1},"2":{"574":1,"835":1}}],["dx",{"2":{"269":1}}],["dmy6",{"2":{"732":1,"743":1}}],["dmy↔mdy",{"2":{"642":1}}],["dmy",{"2":{"137":1,"138":1,"217":1,"242":1,"362":1,"375":2,"376":1,"732":2,"758":1}}],["dt2",{"2":{"964":2}}],["dt1",{"2":{"964":2}}],["dtf",{"2":{"372":2,"787":1}}],["dtoptions",{"2":{"147":2,"731":2}}],["dt",{"0":{"968":1},"2":{"128":1,"214":2,"241":1,"242":1,"908":1,"912":2,"918":2,"925":1,"935":1,"939":1,"945":1,"946":1,"948":1,"949":1,"950":2,"954":2,"961":3,"962":1,"965":1,"968":5,"970":1,"975":1,"977":1,"978":1,"1144":1}}],["dtm",{"2":{"127":1,"242":1}}],["du",{"2":{"1213":1}}],["dusk",{"2":{"1073":1}}],["duplication",{"2":{"634":1}}],["duplicate",{"0":{"1095":1},"2":{"326":1,"702":1,"802":1,"972":1,"1098":1}}],["dumps",{"2":{"517":1,"864":1,"995":1}}],["dumb",{"2":{"503":1}}],["duck",{"2":{"170":2}}],["dubai",{"2":{"112":1,"113":1}}],["dur",{"2":{"160":4}}],["durationlike",{"2":{"1412":1}}],["durationminutes",{"2":{"988":1,"992":1,"1013":2,"1015":1,"1326":2}}],["durationmodule",{"2":{"156":1,"251":3,"720":1,"724":1}}],["duration",{"0":{"156":1,"160":1,"253":2,"520":1,"720":1,"1412":1},"1":{"157":1,"158":1,"159":1,"160":1,"161":1,"162":1,"163":1,"164":1,"165":1,"166":1,"1413":1},"2":{"138":1,"157":1,"158":2,"159":1,"160":3,"161":4,"162":2,"163":1,"164":2,"165":2,"166":1,"167":1,"180":1,"221":2,"224":2,"242":1,"251":2,"253":1,"421":1,"430":1,"458":1,"520":8,"553":1,"555":1,"560":1,"606":6,"610":1,"639":1,"644":1,"677":2,"681":1,"699":1,"720":2,"891":1,"950":1,"992":1,"993":1,"1010":1,"1021":1,"1023":1,"1070":1,"1255":1,"1325":2,"1326":1,"1412":1,"1413":1,"1420":1,"1421":1,"1427":1,"1454":2}}],["durationformat",{"2":{"115":1,"117":1,"165":1,"166":2,"747":1}}],["durations",{"0":{"157":1,"165":1},"1":{"158":1,"159":1,"166":1},"2":{"9":1,"83":1,"156":1,"157":1,"161":1,"387":1,"458":1,"527":1,"1401":1,"1411":1}}],["during",{"2":{"111":1,"115":1,"116":1,"117":1,"125":1,"134":1,"163":1,"262":3,"276":1,"281":1,"296":1,"300":1,"312":1,"315":1,"350":1,"351":1,"357":1,"358":1,"367":1,"416":1,"418":1,"429":1,"431":1,"434":1,"440":1,"483":1,"502":1,"538":1,"616":1,"617":1,"625":1,"647":1,"649":1,"660":1,"667":1,"690":1,"695":1,"709":2,"751":1,"759":1,"767":1,"836":1,"848":1,"862":1,"868":1,"939":1,"1000":1,"1007":1,"1055":1,"1076":2,"1082":1,"1084":2,"1110":1,"1134":1,"1223":1,"1258":1,"1371":1}}],["due",{"2":{"106":1,"451":1,"888":1,"889":1,"921":1,"1028":1,"1070":1,"1109":1,"1128":2,"1375":1,"1428":1,"1443":1}}],["duality",{"0":{"489":1},"2":{"473":1}}],["dual",{"0":{"269":1,"1038":1,"1353":1,"1371":1,"1440":1},"1":{"270":1,"1039":1,"1040":1,"1372":1,"1373":1,"1374":1,"1441":1,"1442":1},"2":{"92":1,"137":1,"261":1,"514":1,"773":1,"1213":1,"1371":1,"1383":1,"1440":1}}],["d",{"0":{"1130":1},"2":{"78":1,"240":1,"243":3,"261":2,"425":1,"724":1,"1088":5,"1089":11,"1090":4,"1091":1,"1101":1,"1103":3,"1104":3,"1112":1,"1115":1,"1116":3,"1120":1,"1125":5,"1129":2,"1131":1,"1135":2,"1146":2,"1149":1,"1150":1,"1271":1,"1276":3,"1280":3,"1289":1,"1303":2,"1304":3}}],["drone",{"0":{"1084":1},"2":{"1052":1,"1084":1}}],["drops",{"2":{"1259":1}}],["dropped",{"2":{"495":1,"752":1,"836":1,"1442":1,"1446":1}}],["dropdown",{"2":{"88":1,"89":1}}],["drop",{"0":{"1117":1,"1118":1,"1323":1},"1":{"1118":1,"1119":1,"1324":1,"1325":1,"1326":1},"2":{"78":1,"137":1,"138":1,"205":1,"233":1,"1099":1,"1104":2,"1117":1,"1118":1,"1320":1,"1326":1}}],["dry",{"2":{"766":1}}],["drags",{"2":{"1326":1}}],["drag",{"0":{"1323":1},"1":{"1324":1,"1325":1,"1326":1},"2":{"1324":1}}],["draw",{"2":{"1222":1}}],["drawn",{"2":{"1222":1}}],["drawbacks",{"0":{"106":1,"108":1,"505":1},"1":{"107":1,"108":1,"109":1}}],["draft",{"2":{"1083":1}}],["drain",{"2":{"1443":1,"1448":1}}],["drainage",{"2":{"857":1}}],["drained",{"2":{"812":1}}],["dramatically",{"2":{"722":1}}],["drastically",{"2":{"516":1,"971":1}}],["driftcompensated",{"2":{"1422":1}}],["drifts",{"2":{"1266":1}}],["drift",{"0":{"1230":1,"1248":1,"1267":1,"1422":1,"1428":1,"1444":1},"1":{"1429":1,"1430":1},"2":{"120":2,"418":1,"660":2,"667":1,"1011":1,"1028":1,"1093":1,"1149":1,"1233":1,"1236":1,"1242":1,"1243":2,"1246":1,"1247":1,"1251":1,"1253":1,"1254":2,"1262":1,"1264":2,"1265":1,"1267":1,"1343":1,"1353":1,"1392":2,"1396":1,"1401":2,"1412":1,"1422":1,"1423":1,"1428":1,"1429":1,"1443":2,"1444":1}}],["drives",{"2":{"1392":1}}],["driver",{"2":{"1011":1}}],["driven",{"0":{"1414":1},"1":{"1415":1},"2":{"77":1,"237":1,"407":1,"489":1,"625":1,"666":1,"867":1,"1414":1,"1423":1,"1431":1,"1433":1,"1440":1}}],["drive",{"2":{"77":1,"1428":1,"1429":1}}],["driving",{"2":{"77":1,"361":1,"505":1,"1411":1}}],["dynamicsettings",{"2":{"477":1}}],["dynamicproxy",{"0":{"477":1},"2":{"477":3,"841":1}}],["dynamically",{"2":{"76":1,"141":1,"215":1,"250":1,"262":1,"276":1,"291":1,"316":1,"362":1,"363":2,"416":1,"421":1,"502":1,"536":1,"538":1,"754":1,"776":1,"780":1,"798":1,"823":1,"838":1,"849":1,"856":1,"869":1,"876":1,"933":1,"948":1,"1004":1,"1038":1,"1081":1,"1150":1,"1190":1,"1254":1}}],["dynamic",{"0":{"69":1,"88":1,"119":1,"141":1,"536":1,"731":1,"782":1,"807":1,"823":1,"838":1,"856":1,"933":1,"1001":1,"1004":1,"1212":1,"1215":1},"1":{"120":1,"142":1,"143":1,"144":1,"145":1,"1213":1,"1214":1,"1215":1,"1216":2,"1217":2},"2":{"69":1,"83":1,"88":1,"92":1,"94":2,"96":3,"97":1,"101":1,"103":1,"107":1,"108":1,"109":2,"112":1,"117":4,"119":1,"147":1,"224":2,"276":1,"365":1,"445":1,"477":3,"516":1,"536":2,"574":1,"754":1,"776":1,"780":1,"782":1,"804":1,"807":1,"821":1,"825":1,"835":1,"838":1,"851":1,"855":2,"856":2,"933":5,"937":5,"938":6,"953":1,"958":2,"959":1,"974":1,"1001":1,"1004":1,"1055":1,"1103":1,"1125":1,"1207":1,"1210":1,"1212":1}}],["dashboard",{"2":{"1328":1}}],["dashboards",{"2":{"165":1,"407":1,"1401":1,"1423":1,"1428":1}}],["da",{"2":{"1217":1}}],["daemons",{"2":{"1143":1}}],["dangling",{"2":{"1435":1}}],["dangerous",{"2":{"1110":1}}],["dans",{"2":{"372":1}}],["dawn",{"2":{"1073":1}}],["darkness",{"2":{"1067":1}}],["dark",{"2":{"1067":1}}],["dallas",{"2":{"1065":1}}],["dailysync",{"2":{"1418":1}}],["daily",{"0":{"306":1},"2":{"307":1,"378":1,"989":1,"1076":1,"1082":1,"1413":1,"1415":1,"1418":1}}],["dayjs",{"2":{"1103":1}}],["dayoffset",{"2":{"324":4}}],["dayofyear",{"2":{"233":1,"1098":1}}],["dayofweek",{"2":{"233":1}}],["daylightdurationms",{"2":{"1053":1,"1070":1,"1072":2,"1082":1}}],["daylight",{"2":{"156":1,"296":2,"522":1,"1053":1,"1055":2,"1067":5,"1070":1,"1072":1,"1081":1,"1082":1,"1396":1,"1447":1}}],["day",{"0":{"152":1,"218":1,"563":1,"819":1,"1066":1,"1128":1,"1223":1,"1271":1,"1288":1},"1":{"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1},"2":{"99":1,"134":2,"137":6,"138":22,"146":2,"147":1,"150":7,"151":1,"152":3,"157":1,"158":2,"163":1,"186":1,"188":1,"189":1,"192":1,"202":1,"203":6,"204":1,"215":1,"216":2,"217":1,"218":1,"225":1,"233":1,"240":2,"242":3,"245":1,"301":1,"303":1,"304":1,"305":1,"306":1,"315":1,"323":1,"324":3,"357":1,"362":3,"365":1,"370":2,"372":1,"390":1,"506":1,"507":1,"510":1,"511":1,"514":3,"515":1,"518":1,"520":1,"524":1,"556":1,"739":3,"758":1,"766":2,"771":1,"773":1,"775":3,"776":3,"778":1,"817":1,"879":1,"884":1,"885":3,"886":1,"893":1,"902":3,"909":1,"912":1,"951":1,"955":1,"964":2,"965":1,"1010":1,"1047":1,"1052":1,"1053":1,"1054":1,"1055":2,"1059":1,"1066":1,"1067":2,"1068":1,"1082":1,"1086":1,"1088":8,"1089":1,"1090":1,"1091":1,"1093":1,"1095":1,"1099":1,"1103":1,"1108":1,"1110":1,"1112":1,"1113":1,"1121":1,"1123":2,"1125":11,"1136":1,"1157":2,"1189":1,"1194":1,"1195":3,"1197":2,"1199":3,"1203":3,"1204":1,"1205":2,"1206":1,"1209":3,"1210":1,"1213":42,"1214":2,"1218":1,"1220":1,"1221":4,"1222":9,"1223":5,"1224":4,"1269":11,"1270":3,"1271":5,"1276":3,"1280":1,"1287":1,"1290":1,"1304":2,"1310":2,"1416":2,"1419":2}}],["daysinmonth",{"2":{"138":1,"149":2,"150":3,"233":1,"818":1}}],["daysleft",{"2":{"65":2}}],["days",{"0":{"1194":1,"1195":1,"1196":1,"1198":1,"1200":1},"1":{"1195":1,"1196":1,"1197":2,"1198":1,"1199":2,"1200":1,"1201":2,"1202":1,"1203":1,"1204":1,"1205":1},"2":{"12":1,"23":1,"46":1,"62":1,"65":2,"71":1,"96":1,"97":1,"123":2,"137":1,"138":2,"150":3,"157":1,"158":7,"159":3,"160":1,"161":4,"162":2,"163":6,"164":5,"165":1,"182":2,"183":6,"192":1,"195":2,"201":1,"202":1,"221":1,"230":1,"231":1,"233":4,"234":1,"235":4,"236":1,"245":1,"293":1,"324":5,"365":2,"368":1,"381":3,"461":1,"509":1,"519":1,"520":7,"522":1,"606":1,"684":1,"776":1,"787":2,"879":1,"880":3,"881":1,"882":3,"884":2,"885":1,"886":2,"898":2,"902":1,"919":2,"950":1,"951":1,"953":1,"954":1,"1008":1,"1010":1,"1012":1,"1016":1,"1023":2,"1053":1,"1055":1,"1059":2,"1093":1,"1105":1,"1199":3,"1201":1,"1203":2,"1210":1,"1218":1,"1219":1,"1220":2,"1221":1,"1223":2,"1224":1,"1268":1,"1269":1,"1270":3,"1319":2,"1404":2,"1413":2,"1419":1,"1421":1}}],["dating",{"0":{"1308":1,"1311":1},"1":{"1309":1,"1310":1,"1312":1,"1313":1},"2":{"1273":1,"1292":1,"1299":1,"1312":1,"1313":1}}],["datacenter",{"2":{"1188":1}}],["datadog",{"2":{"995":1,"1011":1,"1143":1}}],["datafetch",{"2":{"481":1}}],["dataset",{"2":{"450":1}}],["datasets",{"2":{"448":2,"451":1}}],["databasequery",{"2":{"484":1}}],["databases",{"2":{"371":1,"1303":1,"1306":1,"1328":1}}],["database",{"2":{"110":1,"365":1,"517":1,"1011":1,"1028":1,"1030":1,"1042":1,"1149":1,"1150":1,"1225":1,"1329":1,"1443":1,"1444":1}}],["data",{"0":{"260":1,"544":1,"1006":1,"1008":1,"1031":1},"1":{"545":1,"1007":1,"1008":1,"1009":1,"1032":1,"1033":1},"2":{"87":1,"102":1,"109":2,"117":1,"128":1,"160":1,"214":1,"230":1,"233":1,"265":1,"294":1,"297":2,"298":1,"334":2,"365":1,"406":1,"439":1,"440":1,"448":1,"462":1,"470":1,"472":3,"473":1,"489":3,"490":2,"491":4,"499":1,"511":1,"520":1,"525":1,"532":1,"699":1,"798":1,"825":1,"829":1,"860":2,"863":1,"865":2,"912":1,"920":1,"936":1,"948":1,"953":2,"954":1,"955":2,"994":1,"996":1,"997":1,"998":1,"1007":1,"1008":4,"1010":1,"1017":1,"1018":1,"1053":1,"1090":1,"1098":1,"1178":6,"1262":1,"1265":1,"1446":1}}],["dated",{"2":{"1306":1,"1309":1,"1312":2}}],["datefromconsuls",{"2":{"1313":2}}],["datefns",{"2":{"1103":1}}],["dateformat",{"2":{"458":1}}],["dateiso",{"2":{"1085":3,"1190":2}}],["datetimekind",{"2":{"1125":3}}],["datetime",{"2":{"513":1,"647":1,"787":1,"1103":2,"1104":1,"1123":1,"1125":1,"1146":1}}],["datetimeformatoptions",{"2":{"146":1,"750":2}}],["datetimeformat",{"2":{"115":1,"146":2,"147":1,"371":1,"372":2,"518":1,"731":1,"744":1,"755":1,"1095":1}}],["datestyle",{"2":{"372":1,"1158":2,"1171":1}}],["dates",{"0":{"215":1,"1200":1,"1221":1},"1":{"216":1,"217":1,"218":1,"1201":1},"2":{"31":1,"58":1,"82":2,"92":1,"96":2,"97":1,"128":1,"138":1,"146":1,"156":1,"201":1,"202":2,"203":1,"204":1,"212":1,"219":2,"296":1,"297":2,"300":1,"304":1,"321":1,"324":1,"361":2,"364":1,"390":1,"451":1,"510":1,"513":1,"516":1,"517":1,"520":1,"522":1,"528":1,"681":1,"707":1,"750":1,"765":1,"766":1,"774":1,"863":1,"867":1,"881":1,"882":1,"893":2,"905":1,"906":1,"919":2,"947":1,"950":1,"951":2,"970":1,"972":1,"973":3,"989":1,"1010":1,"1012":2,"1014":1,"1019":1,"1035":1,"1072":2,"1096":1,"1099":1,"1189":1,"1190":1,"1201":1,"1207":1,"1209":1,"1213":1,"1218":1,"1224":1,"1268":1,"1269":1,"1270":2,"1303":1,"1306":2,"1309":2,"1315":1,"1459":1}}],["date",{"0":{"52":1,"54":1,"55":1,"80":1,"150":1,"362":1,"766":1,"798":1,"879":1,"897":1,"911":1,"1034":1,"1096":1,"1287":1},"1":{"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1,"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1,"1035":1,"1036":1},"2":{"0":1,"12":1,"30":1,"31":1,"32":3,"49":1,"52":1,"55":1,"64":1,"76":3,"77":1,"78":2,"80":2,"89":1,"93":2,"96":2,"97":1,"99":2,"117":1,"123":3,"129":1,"137":3,"138":2,"139":1,"146":1,"154":1,"155":1,"158":5,"159":1,"169":1,"173":1,"184":1,"191":1,"196":1,"203":2,"204":1,"206":1,"213":1,"216":2,"224":3,"233":1,"239":1,"240":1,"241":1,"264":1,"265":1,"266":1,"273":2,"279":1,"300":1,"301":1,"304":1,"305":1,"313":1,"314":1,"325":1,"328":1,"342":1,"357":1,"358":1,"359":1,"361":1,"374":2,"375":1,"377":2,"378":1,"382":1,"390":1,"398":1,"399":3,"424":1,"448":1,"449":1,"450":1,"451":1,"458":1,"470":1,"472":1,"498":1,"500":2,"501":1,"503":1,"504":1,"506":3,"507":4,"511":2,"512":1,"513":1,"514":4,"515":3,"518":3,"519":4,"520":1,"529":1,"531":1,"532":1,"578":1,"580":1,"630":1,"639":1,"649":1,"677":1,"679":1,"684":1,"694":1,"699":1,"701":1,"707":1,"711":1,"732":1,"734":1,"737":1,"743":1,"758":3,"763":5,"765":1,"767":2,"771":2,"778":1,"800":1,"802":1,"806":1,"808":1,"845":1,"859":1,"865":1,"866":1,"878":1,"879":1,"881":1,"885":1,"886":2,"890":1,"891":2,"894":2,"897":1,"899":1,"902":1,"903":1,"905":2,"913":2,"919":2,"920":1,"936":1,"945":1,"950":2,"954":1,"960":1,"962":1,"965":1,"972":4,"976":1,"983":1,"986":1,"993":1,"994":1,"997":2,"998":1,"1008":1,"1012":2,"1018":1,"1037":1,"1046":1,"1082":1,"1085":1,"1086":1,"1088":2,"1091":1,"1095":1,"1097":1,"1099":1,"1103":2,"1104":8,"1108":1,"1109":1,"1110":1,"1123":6,"1125":3,"1127":1,"1131":1,"1135":2,"1139":1,"1149":1,"1151":1,"1156":1,"1157":1,"1178":1,"1187":1,"1188":1,"1195":2,"1218":1,"1221":2,"1222":3,"1232":3,"1240":1,"1259":2,"1260":1,"1262":1,"1267":1,"1270":2,"1276":2,"1280":3,"1284":1,"1287":1,"1289":1,"1290":1,"1304":1,"1313":1,"1319":2,"1391":1,"1404":2}}],["dormant",{"2":{"1421":1}}],["doubling",{"2":{"1095":1,"1276":1}}],["doubled",{"2":{"1091":1,"1098":1,"1271":2}}],["double",{"2":{"183":1,"734":1,"793":1,"1039":1,"1091":1,"1130":1,"1131":1}}],["doppler",{"2":{"1004":1}}],["doe",{"2":{"997":1}}],["does",{"0":{"301":1},"2":{"34":1,"158":1,"191":1,"198":1,"216":1,"298":1,"301":1,"388":1,"863":1,"972":1,"1067":1,"1072":1,"1125":1,"1178":1,"1195":3}}],["doesn",{"2":{"11":1,"270":1,"387":1,"427":1,"909":1,"993":1}}],["dos",{"2":{"829":1}}],["domelement",{"2":{"797":1}}],["domini",{"2":{"763":1,"766":2}}],["dom",{"2":{"447":1,"617":1}}],["domains",{"2":{"897":1}}],["domain",{"0":{"12":1,"519":1,"1457":1},"2":{"9":1,"11":1,"102":1,"103":1,"273":1,"278":1,"287":1,"293":1,"325":1,"333":1,"458":1,"479":1,"509":1,"516":1,"519":2,"526":1,"531":1,"534":1,"539":1,"695":1,"741":1,"751":2,"771":2,"778":1,"836":1,"845":1,"879":1,"897":1,"997":1,"998":3,"1009":1,"1042":1,"1097":1,"1098":1,"1453":1}}],["doing",{"2":{"276":1}}],["dozens",{"2":{"181":1,"228":1,"1090":1,"1443":1}}],["dotnet",{"0":{"1130":1},"2":{"1103":2,"1104":1,"1123":1,"1130":1}}],["dot",{"2":{"141":1,"1103":1}}],["dots",{"2":{"138":3,"139":3,"707":1}}],["doy",{"0":{"819":2},"2":{"137":1,"138":8,"150":3,"152":1,"324":1,"819":3,"1125":1}}],["dow",{"2":{"71":3,"117":1,"137":1,"138":9,"152":1,"187":1,"188":1,"189":2,"233":2,"235":1,"370":4,"817":1,"1089":2,"1093":1,"1103":1,"1125":1}}],["downtown",{"2":{"1335":1}}],["downtime",{"0":{"1145":1},"1":{"1146":1,"1147":1},"2":{"867":1,"1004":1,"1086":1,"1105":1,"1108":1,"1224":1}}],["downsample",{"2":{"1329":1}}],["downsampling",{"0":{"1327":1},"1":{"1328":1,"1329":1},"2":{"1315":1,"1320":1,"1322":1}}],["downstream",{"2":{"617":1,"709":1,"841":1,"998":1,"1193":1,"1446":1}}],["downwards",{"0":{"164":1},"2":{"164":1}}],["download",{"2":{"43":1}}],["down",{"2":{"43":1,"164":1,"402":1,"453":1,"495":1,"505":1,"606":1,"942":1,"1096":1,"1164":1,"1173":1,"1233":1,"1316":1,"1318":1,"1325":2,"1326":1,"1329":2,"1341":1,"1420":1,"1436":1,"1446":1}}],["done",{"2":{"489":1,"1039":1}}],["don",{"2":{"43":1,"138":1,"163":1,"427":1,"482":1,"515":1}}],["do",{"0":{"52":1,"54":1,"55":1},"2":{"21":1,"34":1,"41":1,"179":1,"229":1,"235":1,"250":1,"279":1,"281":1,"325":1,"357":1,"409":1,"453":1,"469":1,"479":1,"498":1,"552":1,"560":1,"954":2,"978":1,"1008":1,"1054":1,"1090":2,"1101":1,"1113":2,"1125":1,"1218":1,"1256":1}}],["dock",{"2":{"1364":1}}],["docker",{"2":{"365":2}}],["documents",{"2":{"896":3,"1011":1}}],["documenttext",{"2":{"895":1}}],["document",{"2":{"204":1,"342":1,"441":1,"470":1,"708":1,"747":1,"891":1,"1086":1,"1123":1,"1309":1}}],["documented",{"2":{"48":1,"407":1,"479":1}}],["documentation",{"0":{"13":1,"581":1,"589":1,"594":1,"598":1,"601":1,"610":1,"614":1,"623":1,"627":1,"640":1,"648":1,"655":1,"661":1,"666":1,"671":1,"697":1,"705":1,"708":1,"729":1,"747":1,"751":1,"1052":1,"1166":1,"1242":1,"1343":1,"1401":1},"2":{"7":1,"13":2,"26":1,"29":2,"77":1,"78":1,"137":1,"205":1,"293":1,"581":1,"594":1,"598":1,"610":2,"614":1,"617":2,"620":1,"623":1,"637":2,"640":1,"648":1,"651":2,"661":1,"665":1,"666":2,"669":1,"671":1,"692":1,"709":2,"712":2,"729":1,"732":1,"747":1,"751":1,"889":1,"1090":1,"1314":1,"1378":1}}],["docs",{"2":{"14":1,"26":1,"589":1,"601":1,"655":1}}],["doc",{"2":{"7":1,"26":1,"919":1}}],["ddthh",{"2":{"1135":2,"1140":1,"1141":1}}],["dddo",{"2":{"1090":1}}],["dddd",{"2":{"1090":2,"1125":3}}],["ddd",{"2":{"1090":2,"1125":3,"1135":1}}],["dd>",{"2":{"243":1,"246":1}}],["ddmmyy",{"2":{"216":1}}],["ddmmyyyy",{"2":{"137":1}}],["dd",{"0":{"215":1},"1":{"216":1,"217":1,"218":1},"2":{"9":1,"30":1,"32":1,"42":1,"54":1,"58":1,"64":1,"76":2,"78":4,"96":1,"112":1,"113":1,"119":1,"131":1,"134":1,"137":4,"138":10,"140":2,"146":1,"150":2,"152":1,"190":1,"191":1,"205":5,"207":1,"224":1,"233":1,"240":1,"241":1,"242":3,"243":3,"244":1,"245":1,"246":2,"247":1,"265":1,"266":1,"270":1,"271":1,"295":2,"325":1,"351":1,"370":2,"513":1,"518":1,"545":2,"680":1,"682":1,"734":1,"763":1,"765":2,"806":6,"881":1,"882":1,"889":2,"897":1,"918":1,"961":1,"964":2,"972":1,"985":1,"988":2,"1036":1,"1083":2,"1088":2,"1089":4,"1090":4,"1091":3,"1098":1,"1101":1,"1102":1,"1103":5,"1104":2,"1112":3,"1113":2,"1114":2,"1115":3,"1116":3,"1118":1,"1119":5,"1120":2,"1125":6,"1127":2,"1128":2,"1130":1,"1131":1,"1132":1,"1134":2,"1135":2,"1136":2,"1139":2,"1140":4,"1141":4,"1144":1,"1146":2,"1147":3,"1149":1,"1150":4,"1190":2,"1197":2,"1199":2,"1209":1,"1220":1,"1221":3,"1222":2,"1223":1,"1224":1,"1243":1,"1254":1,"1255":1,"1265":2,"1280":1,"1304":2,"1307":1,"1310":1,"1313":1,"1329":1,"1404":1,"1412":1,"1413":2,"1417":1,"1418":1,"1419":1,"1422":1,"1444":1,"1446":1,"1447":1}}],["diurnal",{"2":{"1078":3,"1079":1,"1080":1}}],["dips",{"2":{"1082":1}}],["dip",{"0":{"1070":1},"2":{"1052":1,"1053":1,"1066":1,"1067":2,"1070":2}}],["dilemma",{"2":{"995":1}}],["dinner",{"2":{"957":1}}],["did",{"2":{"763":1,"767":1,"1270":1,"1450":1}}],["dictates",{"2":{"361":1}}],["dictionary",{"2":{"102":1,"115":1,"145":2,"155":2,"323":1,"469":1,"477":1,"746":1,"752":1,"755":1,"773":1,"777":1,"830":1}}],["dictionaries",{"0":{"294":1},"1":{"295":1,"296":1,"297":1,"298":1},"2":{"12":1,"115":1,"117":1,"291":2,"294":1,"297":6,"466":1,"746":1,"752":1,"776":1,"830":1}}],["diem",{"0":{"1270":1},"2":{"164":1,"1270":3,"1271":4,"1275":1,"1276":2,"1280":2,"1304":2,"1310":1}}],["divides",{"2":{"303":1,"1033":1}}],["divided",{"2":{"283":1}}],["divide",{"2":{"158":1}}],["divergent",{"2":{"1098":1}}],["divergence",{"2":{"1093":1}}],["diverge",{"2":{"1088":1}}],["diverse",{"2":{"939":1}}],["dives",{"0":{"944":1},"1":{"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"2":{"1105":1}}],["dive",{"2":{"13":1,"64":1,"76":1,"357":1,"705":1,"1314":1}}],["dimension",{"2":{"1353":1}}],["dimensional",{"2":{"138":1}}],["dim",{"2":{"137":1,"138":1,"150":4,"767":1}}],["digital",{"0":{"1302":1},"1":{"1303":1,"1304":1},"2":{"1301":1,"1367":1,"1394":1}}],["digit",{"2":{"117":1,"137":7,"138":6,"139":1,"150":1,"152":1,"216":2,"370":1,"388":1,"613":1,"639":1,"640":1,"743":1,"758":1,"768":1,"1088":3,"1089":3,"1110":1,"1113":1,"1125":7}}],["digits",{"0":{"58":1,"216":1},"2":{"127":1,"138":1,"208":1,"240":1,"245":2,"359":1,"362":1,"370":2,"642":1,"732":1,"997":1,"1090":1,"1125":2}}],["dia",{"2":{"1217":1}}],["diameter",{"2":{"1064":1}}],["diagnose",{"2":{"954":1,"1008":2}}],["diagnostics",{"0":{"645":1,"1008":1},"2":{"357":1,"661":1,"676":1,"691":1,"953":1,"954":1,"1008":1,"1401":1,"1423":1}}],["diagnostic",{"0":{"281":1,"965":1},"2":{"1":2,"356":1,"357":2,"403":2,"404":1,"429":1,"440":1,"634":1,"864":1,"912":1,"936":1,"937":1,"938":1,"965":1,"996":1,"1003":1,"1008":2,"1011":1}}],["dialectoroptions",{"2":{"1104":4}}],["dialect",{"0":{"778":1,"807":1,"1115":1,"1116":1,"1124":1},"2":{"78":2,"137":1,"205":1,"771":2,"778":3,"804":1,"806":1,"807":1,"1086":1,"1092":1,"1099":1,"1101":8,"1103":10,"1104":24,"1113":4,"1114":2,"1115":1,"1116":1,"1121":1,"1122":1,"1124":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1134":1,"1141":3,"1144":7,"1147":6,"1150":5}}],["dialectsplugin",{"2":{"137":2,"1101":2,"1113":2,"1117":1,"1141":2,"1144":2,"1147":2,"1150":2}}],["dialects",{"0":{"78":1,"808":2,"1099":1,"1103":1,"1113":1,"1115":1,"1116":1,"1120":1},"1":{"1100":1,"1101":1,"1102":1,"1103":1,"1104":1,"1105":1,"1106":1,"1107":1,"1114":1,"1121":1,"1122":1},"2":{"78":7,"137":4,"205":4,"804":1,"806":2,"808":1,"1086":2,"1088":1,"1090":1,"1092":1,"1097":1,"1098":3,"1099":1,"1100":1,"1101":1,"1102":1,"1103":1,"1104":23,"1105":1,"1106":2,"1108":1,"1110":1,"1113":4,"1114":1,"1115":3,"1116":3,"1120":3,"1122":2,"1123":1,"1136":1,"1137":1,"1140":1,"1141":2,"1144":1,"1147":3,"1150":4}}],["directing",{"2":{"806":1,"1376":1}}],["directions",{"2":{"393":1,"489":1}}],["direction",{"2":{"137":1,"233":2,"235":2,"365":2,"367":1,"370":1,"383":1,"397":1,"458":2,"459":1,"786":1,"817":1,"886":1,"1233":1,"1316":2,"1318":1,"1325":2,"1326":1,"1329":2}}],["directionality",{"2":{"902":1}}],["directional",{"0":{"886":1},"2":{"64":1,"157":2,"191":2,"195":1,"734":1,"737":1,"981":1,"1316":1}}],["directories",{"2":{"627":1,"712":1}}],["directory",{"0":{"1454":1},"2":{"7":1,"451":1,"627":1,"644":1,"1449":1,"1450":2,"1452":1,"1453":1,"1454":1}}],["directly",{"2":{"28":1,"43":1,"64":1,"90":1,"102":1,"107":1,"138":1,"140":1,"142":1,"143":1,"146":1,"150":1,"161":1,"167":1,"169":2,"170":1,"190":1,"191":1,"223":1,"226":1,"243":1,"263":1,"265":1,"274":1,"276":2,"282":1,"285":1,"289":1,"290":1,"291":1,"295":1,"300":1,"322":1,"327":1,"361":1,"365":2,"366":1,"367":2,"370":2,"403":1,"409":1,"418":1,"455":1,"458":1,"460":1,"477":1,"482":1,"489":2,"509":1,"515":1,"516":1,"537":1,"560":1,"680":1,"709":1,"711":1,"720":1,"723":1,"731":1,"734":1,"771":1,"776":2,"777":1,"786":1,"787":1,"816":1,"824":1,"830":1,"848":1,"850":1,"861":1,"870":1,"878":1,"907":1,"912":1,"918":2,"920":1,"927":1,"936":2,"971":1,"973":1,"984":1,"996":1,"1007":1,"1011":1,"1014":1,"1029":1,"1036":1,"1039":1,"1048":1,"1049":1,"1069":1,"1080":1,"1093":1,"1095":1,"1104":3,"1106":1,"1109":1,"1115":1,"1116":3,"1117":1,"1121":1,"1135":1,"1144":1,"1150":2,"1160":1,"1187":1,"1263":1,"1289":1,"1304":1,"1313":1,"1362":1,"1370":1,"1381":1,"1389":1,"1414":1,"1415":1,"1446":1}}],["direct",{"0":{"460":1,"818":1,"956":1},"1":{"957":1,"958":1},"2":{"15":1,"78":1,"117":1,"149":2,"367":1,"414":1,"429":1,"439":1,"461":1,"464":1,"481":1,"777":1,"786":1,"814":1,"817":1,"818":1,"819":1,"852":1,"864":1,"866":1,"929":1,"953":3,"954":1,"980":1,"1007":1,"1008":2,"1011":1,"1098":1,"1099":1,"1112":1,"1147":1,"1222":2}}],["diffused",{"2":{"1071":1,"1084":1}}],["diff2",{"2":{"887":1}}],["diff1",{"2":{"887":1}}],["diffaitempo",{"2":{"919":1}}],["diffai",{"0":{"879":1},"1":{"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1},"2":{"863":1,"879":2,"880":2,"884":1,"885":1,"886":1,"887":1,"910":1,"912":2,"936":1,"950":2,"973":1}}],["diffs",{"2":{"771":1}}],["difficult",{"2":{"402":1,"516":1,"1265":1}}],["diffdays",{"2":{"324":2}}],["differing",{"2":{"1136":1,"1412":1}}],["differ",{"2":{"304":1}}],["differs",{"2":{"158":1}}],["difference",{"2":{"322":1,"323":1,"394":1,"520":1,"771":1,"882":1,"1088":1,"1351":1}}],["differences",{"2":{"157":1,"773":1,"774":1,"775":1,"1428":1}}],["differentiating",{"2":{"763":1}}],["differently",{"2":{"298":1}}],["different",{"2":{"113":1,"157":1,"161":1,"219":1,"221":1,"304":1,"321":1,"328":2,"332":1,"355":1,"384":1,"387":1,"442":1,"514":1,"1054":1,"1098":1,"1112":1,"1149":2,"1161":1,"1185":1,"1205":2,"1447":1}}],["diff",{"2":{"9":2,"157":4,"323":1,"324":2,"520":2,"773":1,"775":1,"880":6,"887":1,"919":1,"950":1,"1009":1}}],["disbursement",{"2":{"1222":1}}],["disburse",{"2":{"1218":1}}],["disk",{"2":{"1053":1,"1064":1,"1065":4}}],["disjunction",{"2":{"769":1}}],["disjoint",{"2":{"522":1}}],["disagreed",{"2":{"950":1}}],["disagree",{"2":{"950":1}}],["disabled",{"2":{"1011":1,"1378":1}}],["disables",{"2":{"871":1,"881":1,"890":1,"899":1,"975":1}}],["disable",{"2":{"856":2,"937":2,"938":2,"1011":1,"1259":1,"1375":1}}],["disabling",{"2":{"856":1,"975":1}}],["disambiguation",{"0":{"769":1}}],["disallowed",{"2":{"856":1,"862":1,"1000":1,"1001":1,"1319":1}}],["disallow",{"2":{"109":1}}],["disruption",{"2":{"370":1,"866":1,"1004":1}}],["disputes",{"2":{"1218":1}}],["disparate",{"2":{"402":1}}],["dispatchers",{"2":{"1364":1}}],["dispatches",{"2":{"489":1,"773":1,"945":1,"949":1,"950":1}}],["dispatching",{"2":{"325":1,"668":1,"855":1,"884":1,"893":1,"906":1,"942":1,"972":1}}],["dispatch",{"0":{"943":1},"2":{"198":1,"473":1,"778":1,"855":2,"867":1,"933":1,"939":1,"940":1,"941":1,"942":1,"1004":1,"1362":1,"1444":1}}],["disposing",{"2":{"831":2}}],["disposable",{"0":{"422":1},"2":{"335":1,"473":2,"486":1,"491":1,"494":1,"831":2,"1445":1}}],["disposal",{"0":{"336":1,"491":1,"543":1,"831":1},"2":{"331":1,"336":1,"486":1,"535":1,"827":1,"1441":1}}],["disposer",{"0":{"1408":1,"1433":1,"1434":1},"2":{"1405":2}}],["disposers",{"2":{"1396":1}}],["disposes",{"2":{"334":1,"1434":1}}],["disposed",{"2":{"332":2,"334":2,"335":1,"486":1,"543":1,"1445":1}}],["dispose",{"0":{"422":1,"486":1},"2":{"6":1,"335":1,"336":2,"422":1,"475":1,"486":1,"491":2,"543":1,"831":1,"833":4,"1256":1,"1373":1,"1374":1,"1405":1,"1432":1}}],["displacement",{"2":{"191":1,"1069":1}}],["displayname",{"2":{"1168":1}}],["displaynames",{"2":{"361":1}}],["displaying",{"2":{"164":1}}],["displays",{"2":{"163":1}}],["display",{"2":{"133":1,"163":1,"166":1,"300":1,"612":1,"1042":1,"1094":1,"1149":1,"1259":1,"1331":1}}],["disconnected",{"2":{"955":1}}],["disconnect",{"2":{"955":1,"1089":1}}],["disconnects",{"2":{"955":1}}],["discoverability",{"2":{"562":1,"633":1}}],["discoverable",{"2":{"269":1,"276":1,"741":1}}],["discover",{"2":{"111":1,"229":1,"321":2,"596":1,"853":1}}],["discovers",{"2":{"103":1,"741":1,"849":1,"870":1,"957":1}}],["discovery",{"0":{"103":1,"111":1,"112":1,"113":1,"115":1,"272":1,"321":1,"538":1,"839":1,"853":1,"925":1,"957":1},"1":{"112":1,"113":1,"114":1,"115":1,"854":1,"855":1,"856":1,"857":1,"926":1,"927":1},"2":{"101":1,"102":2,"111":4,"112":2,"113":1,"114":3,"116":2,"117":3,"124":2,"129":3,"250":1,"262":1,"271":1,"300":1,"312":1,"313":1,"326":1,"335":1,"336":1,"345":1,"402":2,"403":2,"409":4,"410":1,"429":1,"439":2,"440":3,"446":1,"538":2,"543":1,"544":4,"592":1,"596":1,"609":1,"631":2,"653":1,"687":1,"757":2,"830":1,"831":1,"833":1,"835":1,"836":3,"839":1,"853":1,"870":1,"925":1,"1454":1}}],["discovered",{"2":{"20":1,"101":1,"444":1,"538":1,"855":1,"925":1,"926":1}}],["disclaimer",{"2":{"922":1}}],["disclosure",{"2":{"20":1,"23":1}}],["discarded",{"2":{"856":1,"1233":1,"1240":1}}],["discrimination",{"2":{"712":2}}],["discrepancy",{"2":{"1088":1}}],["discrepancies",{"2":{"585":1}}],["discrete",{"2":{"422":1,"1053":1,"1059":1}}],["discernible",{"2":{"377":1}}],["discuss",{"2":{"293":1,"534":1}}],["discussions",{"2":{"15":1}}],["distm",{"2":{"1357":1}}],["distmiles",{"2":{"1357":1}}],["distkm",{"2":{"1347":2,"1357":1}}],["disturbed",{"2":{"1271":1}}],["distortion",{"2":{"1233":1,"1443":1}}],["distinguishable",{"2":{"1067":1}}],["distinction",{"2":{"262":1,"729":1,"1054":1}}],["distinct",{"0":{"920":1},"2":{"157":1,"181":1,"193":1,"332":1,"361":1,"405":1,"734":1,"752":1,"915":1,"920":1,"1090":1,"1126":1,"1268":1}}],["distances",{"2":{"1362":1}}],["distancekm",{"2":{"1053":1,"1054":1,"1064":2,"1365":4}}],["distance",{"0":{"1064":1,"1347":1,"1355":2,"1356":1,"1365":1},"1":{"1356":2,"1357":2},"2":{"1052":1,"1053":1,"1058":1,"1064":5,"1071":1,"1075":1,"1080":1,"1334":1,"1343":1,"1344":3,"1345":1,"1347":2,"1355":1,"1357":2,"1360":1,"1363":1,"1365":2}}],["distant",{"2":{"514":1,"1361":1}}],["distributing",{"0":{"284":1},"1":{"285":1,"286":1,"287":1}}],["distributions",{"2":{"663":1}}],["distribution",{"2":{"6":1,"41":1,"665":1,"669":1}}],["distribute",{"2":{"236":1}}],["distributed",{"0":{"895":1,"904":1,"1255":1,"1265":1},"2":{"17":1,"511":1,"866":1,"937":1,"938":1,"978":1,"1011":1,"1149":1,"1242":1,"1255":2,"1265":1,"1328":1,"1377":1,"1422":1}}],["dist",{"2":{"6":2,"10":2,"42":2,"44":5,"45":3,"559":1,"560":1,"665":1,"850":3}}],["debitrun",{"2":{"1222":2}}],["debit",{"2":{"1222":1}}],["debits",{"2":{"1222":1}}],["debugger",{"2":{"439":1}}],["debugging",{"0":{"342":1,"356":1,"359":1,"484":1,"936":1},"1":{"343":1,"344":1,"345":1,"346":1,"347":1,"348":1,"349":1,"350":1,"351":1,"352":1,"353":1,"354":1,"355":1,"356":1,"357":2,"358":2,"359":2,"360":2},"2":{"342":1,"351":1,"404":1,"475":1,"634":1,"995":1,"996":1,"1265":1}}],["debug",{"0":{"357":1,"571":1,"645":1,"995":1},"1":{"996":1,"997":1},"2":{"107":1,"116":1,"117":3,"128":2,"129":2,"282":1,"292":1,"341":3,"357":7,"359":1,"403":1,"484":3,"485":1,"571":7,"639":1,"645":2,"701":1,"861":1,"869":2,"871":1,"912":3,"921":1,"930":1,"936":4,"937":2,"938":2,"962":1,"980":2,"995":2,"996":3,"997":2,"1011":6,"1054":1,"1459":1}}],["deutschen",{"2":{"1213":1}}],["deux",{"2":{"545":2}}],["deg",{"2":{"1069":1,"1344":1,"1352":1,"1353":1}}],["degrades",{"2":{"1192":1}}],["degradation",{"0":{"1040":1}}],["degrees",{"2":{"1062":2,"1071":4}}],["de",{"2":{"954":1,"1157":2,"1160":2,"1213":4,"1220":1}}],["dead",{"2":{"627":1}}],["deadlocks",{"2":{"404":1,"475":1}}],["deadlines",{"2":{"321":1,"1259":1}}],["deadline",{"0":{"65":1,"1203":1},"2":{"62":1,"96":1,"97":1,"123":2,"890":1,"891":1,"896":1,"948":1,"1207":1,"1209":2,"1220":5}}],["deals",{"2":{"519":1}}],["deregistered",{"2":{"1445":1}}],["der",{"2":{"1213":2}}],["derivative",{"2":{"1428":1}}],["derivation",{"2":{"1046":1,"1054":1}}],["derive",{"2":{"1054":1,"1266":1,"1391":1}}],["derived",{"0":{"333":1},"2":{"305":1,"330":1,"331":1,"332":1,"863":1,"942":1,"1008":1,"1046":1,"1344":1,"1429":1}}],["dernier",{"2":{"222":2,"737":2}}],["denial",{"2":{"997":1}}],["dense",{"2":{"411":1}}],["denver",{"2":{"296":1,"1070":4}}],["deno",{"0":{"39":1},"1":{"40":1},"2":{"10":2,"34":1,"39":3,"648":1,"853":1,"861":1,"925":1,"957":1,"1188":1}}],["deducted",{"2":{"1223":1}}],["deductions",{"2":{"1223":1}}],["deduces",{"2":{"878":1}}],["deduced",{"2":{"227":1}}],["deduplication",{"2":{"726":1}}],["dedicated",{"0":{"186":1,"369":1,"687":1,"830":1},"2":{"43":1,"48":1,"83":1,"102":1,"186":2,"260":1,"275":1,"287":1,"311":1,"333":1,"369":2,"514":1,"517":1,"518":1,"519":1,"520":1,"540":1,"561":1,"598":1,"601":1,"622":1,"635":1,"637":1,"642":1,"647":1,"659":1,"687":1,"692":1,"705":1,"766":1,"768":1,"769":1,"817":1,"827":1,"830":1,"832":1,"861":1,"867":1,"921":1,"1033":1,"1105":1,"1162":1,"1178":1,"1240":1,"1262":1,"1339":1,"1368":1,"1391":2}}],["demain",{"2":{"754":1}}],["demand",{"2":{"148":1,"409":1,"412":1,"699":1,"981":1}}],["demo",{"2":{"648":1}}],["demonstrates",{"2":{"419":1,"451":1,"1322":1}}],["demonstrate",{"2":{"407":1,"648":1}}],["demonstrating",{"2":{"140":1,"516":1}}],["demonstration",{"2":{"34":1,"655":1}}],["demos",{"2":{"13":1,"671":1}}],["defense",{"0":{"1010":1},"2":{"1442":1}}],["defensive",{"2":{"404":2,"665":1,"1161":1}}],["deferred",{"0":{"474":1},"1":{"475":1},"2":{"124":1,"451":1,"699":2}}],["deferring",{"0":{"124":1},"2":{"407":2,"416":1}}],["defer",{"0":{"124":1},"2":{"117":2,"124":4,"416":1,"448":1,"450":1,"451":2}}],["definitive",{"2":{"708":1}}],["definition",{"0":{"313":1},"2":{"327":1,"339":1,"409":1,"469":1,"471":1,"1195":1,"1205":1,"1278":1}}],["definitions",{"0":{"454":1,"455":1},"2":{"139":1,"224":1,"298":1,"348":1,"544":2,"649":1,"719":1,"851":1,"884":1}}],["defining",{"2":{"222":1,"273":1,"426":1,"456":1,"469":1,"1437":1}}],["definefunction",{"2":{"426":2}}],["defineproperty",{"2":{"425":1,"426":2,"429":1,"433":1}}],["defineplugin",{"0":{"232":1},"2":{"229":1,"232":3,"233":1,"234":1,"235":2,"273":1,"274":1,"275":1,"276":1,"285":3,"286":2,"537":3,"728":1,"816":1,"840":1}}],["definerange",{"2":{"313":2,"537":1,"840":1}}],["definemodule",{"2":{"261":2,"274":1,"537":1,"728":3,"840":1}}],["defineterm",{"2":{"229":1,"273":1,"274":1,"312":1,"313":2,"322":1,"324":2,"326":1,"537":1,"728":1,"840":1}}],["defines",{"2":{"218":1,"315":1,"1094":1}}],["defined",{"0":{"453":1},"1":{"454":1,"455":1,"456":1},"2":{"191":1,"238":1,"239":1,"266":1,"301":2,"306":1,"315":2,"367":1,"452":1,"477":1,"503":1,"634":1,"639":1,"751":1,"910":1,"1093":1,"1336":1,"1445":1}}],["definenamespace",{"0":{"265":1},"1":{"266":1},"2":{"143":1,"230":1,"263":1,"265":2,"266":1,"267":1,"270":2,"271":2,"273":1,"274":1,"280":1,"537":1,"711":1,"840":1}}],["define",{"0":{"312":1},"1":{"313":1,"314":1,"315":1,"316":1,"317":1},"2":{"128":1,"134":1,"147":1,"166":1,"221":1,"265":2,"276":1,"301":1,"313":1,"315":1,"317":2,"319":1,"321":1,"324":1,"326":2,"327":1,"426":1,"452":1,"463":1,"504":1,"731":1,"1141":1,"1149":1,"1150":1}}],["defineconfig",{"0":{"290":1},"2":{"102":2,"107":1,"687":3}}],["defaulting",{"2":{"231":1,"438":1,"1195":1}}],["default",{"0":{"345":1,"945":1},"2":{"34":1,"37":1,"39":1,"76":1,"87":1,"94":2,"102":1,"109":1,"110":1,"111":1,"116":1,"117":4,"124":1,"125":3,"129":1,"138":1,"139":1,"159":2,"161":1,"162":2,"166":1,"186":1,"198":1,"207":2,"208":1,"211":1,"213":2,"218":1,"281":3,"282":1,"288":1,"308":1,"325":1,"344":2,"358":1,"363":1,"365":3,"368":1,"375":1,"429":1,"438":1,"442":1,"457":1,"459":1,"563":1,"567":1,"578":1,"585":1,"642":1,"644":2,"651":1,"678":1,"687":1,"737":1,"738":2,"757":1,"854":2,"855":1,"856":3,"867":2,"868":1,"871":1,"930":1,"934":2,"935":2,"937":6,"938":9,"940":1,"946":1,"958":3,"959":2,"971":1,"972":1,"973":1,"978":2,"979":1,"982":1,"985":1,"994":1,"1011":1,"1017":1,"1022":1,"1042":1,"1088":1,"1090":1,"1091":1,"1093":1,"1098":2,"1132":1,"1158":2,"1168":2,"1176":1,"1178":1,"1182":1,"1214":1,"1233":1,"1234":1,"1239":1,"1240":1,"1271":1,"1273":1,"1315":1,"1316":1,"1319":1,"1344":1,"1352":1,"1356":1,"1360":1,"1361":1,"1363":1,"1375":1,"1376":1,"1379":1,"1404":1,"1419":1,"1459":1}}],["defaults",{"0":{"855":1},"2":{"9":1,"56":1,"100":1,"101":2,"102":2,"110":1,"115":1,"116":1,"117":1,"129":1,"132":2,"137":1,"138":1,"198":1,"202":1,"266":1,"331":1,"338":1,"345":1,"393":1,"399":1,"422":1,"485":2,"516":1,"541":1,"606":1,"830":1,"833":1,"853":1,"856":5,"874":1,"890":2,"899":2,"932":2,"938":1,"958":2,"989":1,"1011":1,"1203":1,"1422":1}}],["deepfreeze",{"2":{"744":1,"1106":1,"1173":1}}],["deepmerge",{"2":{"744":3}}],["deeply",{"2":{"147":1,"294":1,"298":1,"414":1,"417":1,"420":1,"453":1,"502":1,"731":1,"771":1,"864":2,"1173":1}}],["deep",{"0":{"944":1},"1":{"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"2":{"64":1,"76":1,"109":1,"145":1,"300":1,"328":1,"357":1,"470":1,"472":1,"502":1,"503":1,"504":1,"534":1,"578":1,"705":1,"738":1,"754":1,"814":1,"830":1,"998":1,"1071":1,"1083":1,"1084":1,"1105":1,"1314":1}}],["deeper",{"2":{"13":1,"195":1,"362":1,"412":1,"414":1}}],["decree",{"2":{"1310":1}}],["decrees",{"2":{"1309":1,"1312":1}}],["decrypting",{"2":{"504":1}}],["decades",{"2":{"1086":1}}],["declensions",{"2":{"1276":1,"1314":1}}],["declinations",{"2":{"1045":1}}],["declaration",{"2":{"1449":1}}],["declarations",{"2":{"760":1}}],["declarative",{"0":{"290":1}}],["declaratively",{"2":{"288":1}}],["declaring",{"2":{"466":1,"486":1}}],["declare",{"2":{"234":2,"261":2,"267":1,"326":1,"479":1,"927":1}}],["decouples",{"2":{"676":1,"1090":1}}],["decoupled",{"0":{"403":1,"910":1},"1":{"911":1,"912":1},"2":{"1":1,"168":1,"415":1,"418":1,"447":1,"626":1,"668":1,"825":1,"910":1,"993":1}}],["decoupling",{"2":{"626":1,"659":1,"836":1,"1189":1,"1339":1}}],["decoder",{"2":{"588":1}}],["decode",{"2":{"588":1}}],["decoding",{"2":{"479":1}}],["decorator",{"2":{"546":1,"578":1,"579":1}}],["decorators",{"0":{"478":1},"2":{"340":1,"478":1,"1131":1}}],["decorated",{"2":{"503":1,"597":1,"664":1}}],["dec",{"2":{"150":1,"240":1,"300":1,"1222":1,"1223":1,"1269":1}}],["decided",{"2":{"216":1}}],["decide",{"2":{"215":1,"362":1}}],["decimals",{"2":{"226":1}}],["decimal",{"2":{"121":1,"227":2,"520":1}}],["decisions",{"2":{"645":1,"936":1}}],["decision",{"0":{"97":1,"943":1},"2":{"642":1,"697":1,"867":1,"934":1,"963":1}}],["december",{"2":{"54":1,"909":1,"934":1,"1046":1,"1088":1,"1110":2,"1224":1}}],["device",{"2":{"1030":1,"1266":1}}],["deviceid",{"2":{"1030":2}}],["devices",{"2":{"1028":1,"1258":1,"1422":1}}],["developed",{"2":{"479":1}}],["developers",{"2":{"229":1,"267":1,"268":1,"269":2,"270":2,"275":1,"288":1,"447":1,"464":1,"468":1,"522":1,"524":1,"525":1,"528":1,"560":1,"606":1,"645":1,"704":1,"716":1,"722":1,"728":1,"747":1,"845":1,"875":1,"922":1,"1008":1,"1011":1,"1090":2,"1095":1,"1097":1,"1176":1,"1376":1}}],["developer",{"0":{"326":1,"763":1,"764":1,"771":1,"780":1},"1":{"765":1,"766":1,"767":1,"768":1,"769":1},"2":{"116":1,"168":1,"269":1,"272":1,"274":1,"326":2,"370":1,"512":1,"513":1,"516":1,"522":2,"527":1,"671":1,"719":1,"722":1,"728":1,"763":1,"827":1,"936":1,"1011":1,"1054":1,"1374":1}}],["developing",{"2":{"341":1,"728":1}}],["development",{"0":{"2":1,"388":1,"531":1},"1":{"3":1,"4":1,"5":1},"2":{"43":1,"236":1,"261":1,"281":1,"324":1,"358":1,"402":1,"537":1,"582":1,"701":1,"840":1,"862":1,"996":2,"1000":1,"1098":1,"1378":1}}],["dev",{"2":{"43":1,"829":1,"1011":1}}],["depart",{"2":{"1360":1}}],["departure",{"2":{"905":1}}],["departuretime",{"2":{"334":1}}],["dep",{"2":{"1360":4}}],["depot",{"0":{"1364":1},"2":{"1343":1,"1362":1,"1364":4}}],["depth",{"2":{"416":1,"861":1,"1442":1}}],["deprecating",{"2":{"418":1}}],["deprecation",{"0":{"557":1},"1":{"558":1,"559":1},"2":{"152":1,"291":1,"669":1,"771":1,"786":1,"832":1}}],["deprecated",{"0":{"546":1,"571":1},"2":{"138":1,"152":3,"291":1,"367":1,"535":1,"537":2,"538":1,"541":1,"545":1,"565":1,"574":1,"708":1,"732":1,"757":1,"768":1,"776":1,"830":1,"832":1,"836":1,"843":1}}],["depend",{"2":{"327":1,"407":1,"862":1}}],["dependent",{"2":{"315":1,"326":1,"1054":3,"1093":1,"1125":3}}],["dependency",{"0":{"618":1},"2":{"43":4,"404":1,"561":1,"614":1,"617":1,"651":1,"857":1,"1147":1,"1275":1}}],["dependencies",{"2":{"43":3,"109":1,"227":1,"276":1,"281":1,"310":1,"479":1,"582":1,"729":1,"792":1,"998":1,"1103":1,"1276":1,"1353":1}}],["depending",{"2":{"164":1,"210":1,"298":1,"379":1,"520":1,"847":1,"1093":1,"1095":1}}],["depends",{"2":{"96":1,"281":1,"1063":1}}],["deploying",{"2":{"921":1}}],["deploy",{"2":{"418":1,"1147":1}}],["deployments",{"2":{"365":1,"666":1}}],["deployment",{"2":{"43":1,"859":1,"862":1,"1011":1}}],["deployed",{"2":{"23":1}}],["desktop",{"2":{"1443":1}}],["desyncs",{"2":{"1391":1}}],["despite",{"2":{"1366":1}}],["destination",{"2":{"1344":1,"1358":1,"1363":3,"1365":4}}],["destroys",{"2":{"425":1}}],["destructively",{"2":{"472":1}}],["destructive",{"2":{"95":1,"464":1}}],["deserialize",{"2":{"504":1}}],["desc",{"2":{"1113":6}}],["descending",{"2":{"314":1,"948":1,"1141":1}}],["describing",{"2":{"594":1}}],["describe",{"2":{"8":1,"1013":1}}],["descriptors",{"2":{"425":1,"438":1}}],["descriptor",{"2":{"402":1,"912":1,"1284":1}}],["descriptive",{"2":{"146":1,"189":1,"281":1,"326":1,"775":1,"891":1,"954":1,"1376":1,"1404":1}}],["descriptions",{"2":{"886":1,"897":1,"981":1}}],["description",{"2":{"8":1,"14":1,"22":1,"115":1,"117":1,"137":1,"138":1,"142":1,"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"155":1,"240":1,"242":1,"271":1,"288":1,"307":4,"313":1,"317":1,"324":1,"326":1,"871":1,"881":1,"890":1,"899":1,"919":1,"937":1,"959":1,"989":1,"1021":1,"1022":1,"1067":1,"1071":1,"1078":1,"1090":1,"1104":1,"1125":1,"1168":1,"1169":1,"1240":1,"1318":1,"1319":1,"1344":1,"1345":1,"1382":1,"1403":1,"1404":1,"1405":1,"1406":1}}],["design",{"0":{"1086":1,"1087":1},"1":{"1087":1,"1088":2,"1089":2,"1090":2,"1091":2,"1092":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1098":1},"2":{"213":1,"248":1,"293":1,"361":1,"430":1,"452":1,"466":1,"467":1,"531":1,"623":1,"626":1,"972":1,"1105":1}}],["designated",{"2":{"1273":1}}],["designates",{"2":{"1111":2}}],["designations",{"2":{"202":1,"707":1}}],["designators",{"2":{"213":1,"214":2}}],["designator",{"2":{"137":1,"240":1}}],["designed",{"2":{"33":1,"116":2,"138":1,"147":1,"249":1,"273":1,"276":1,"300":1,"358":1,"371":1,"400":1,"474":1,"480":1,"498":1,"510":1,"512":1,"515":1,"527":1,"534":1,"852":1,"869":1,"1011":1,"1459":1}}],["del",{"2":{"978":2}}],["delays",{"2":{"1254":1,"1257":1,"1368":1,"1388":1,"1421":1,"1422":1}}],["delayed",{"2":{"1240":1}}],["delay",{"2":{"871":1,"934":1,"937":1,"938":1,"1229":2,"1233":1,"1422":1,"1444":1}}],["deltatime",{"2":{"1391":1,"1392":2}}],["deltaminutes",{"2":{"1366":2}}],["deltas",{"0":{"879":1},"1":{"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1},"2":{"887":1}}],["delta",{"2":{"451":1,"879":1,"899":1,"902":1,"919":1,"1075":1,"1343":1,"1350":1,"1352":2,"1353":2,"1366":2}}],["deletion",{"2":{"978":1,"1008":2}}],["deletions",{"2":{"453":1}}],["deleteproperty",{"2":{"433":1,"437":2}}],["delete",{"2":{"402":1,"978":1}}],["deletes",{"2":{"336":1}}],["delegation",{"0":{"444":1},"2":{"408":2,"441":1,"464":1,"465":1,"668":1}}],["delegator",{"0":{"408":1,"424":1,"426":1,"444":1},"1":{"409":1,"410":1,"425":1,"426":1,"427":2,"428":2,"429":1},"2":{"408":3,"409":1,"410":1,"412":1,"424":1,"426":1,"429":1,"444":1,"699":1}}],["delegators",{"2":{"1":1,"699":1}}],["delegated",{"2":{"361":1}}],["delegates",{"2":{"146":1,"282":1,"361":1,"364":1,"365":1,"366":1,"1095":1}}],["delegate",{"2":{"76":1,"427":1,"731":1}}],["delivered",{"2":{"1232":1}}],["deliverables",{"2":{"888":1}}],["delivers",{"2":{"795":1}}],["deliver",{"2":{"699":1}}],["delivering",{"2":{"513":1,"674":1}}],["deliverydate",{"2":{"1199":3}}],["deliverydateiso",{"2":{"1016":2}}],["delivery",{"2":{"123":1,"879":1,"1016":3,"1364":3}}],["deliberate",{"0":{"1086":1,"1092":1},"1":{"1087":1,"1088":1,"1089":1,"1090":1,"1091":1,"1092":1,"1093":2,"1094":2,"1095":2,"1096":2,"1097":2,"1098":1},"2":{"219":1,"467":1,"1105":1}}],["deliberately",{"2":{"157":1,"365":1,"1086":2,"1092":1}}],["delimiters",{"2":{"243":3}}],["delimiter",{"2":{"138":1}}],["delimited",{"0":{"690":1},"2":{"31":1,"690":1}}],["detachedcopy",{"2":{"502":1}}],["detached",{"2":{"453":1,"502":1,"504":1}}],["detailing",{"2":{"351":1,"697":1}}],["details",{"0":{"436":1,"1047":1},"1":{"437":1,"438":1},"2":{"69":1,"109":1,"137":1,"195":1,"281":1,"362":1,"363":1,"424":1,"471":1,"565":1,"594":1,"629":1,"640":1,"705":1,"934":1,"963":1,"1012":1,"1172":1,"1178":1,"1181":3,"1333":1}}],["detailed",{"2":{"10":1,"13":1,"22":1,"77":1,"128":1,"165":1,"357":1,"419":1,"472":1,"473":1,"581":1,"867":1,"936":1,"1008":1,"1052":1,"1166":1,"1242":1,"1343":1,"1401":1}}],["detect",{"2":{"625":1,"1008":1,"1116":1}}],["detects",{"2":{"208":1,"500":1,"690":1,"1053":1,"1065":1,"1113":1,"1364":1,"1448":1}}],["detected",{"2":{"127":1,"829":1,"957":1,"1104":1}}],["detecting",{"2":{"127":1,"1361":1,"1362":1,"1363":1}}],["detection",{"0":{"208":1,"996":1,"1348":1,"1361":1,"1363":1},"2":{"107":1,"217":1,"218":1,"612":1,"625":1,"631":2,"633":1,"649":1,"748":1,"942":1,"987":1,"1052":1,"1104":2,"1162":1,"1339":1,"1343":2,"1354":1}}],["determining",{"0":{"1195":1}}],["determinism",{"0":{"120":1},"2":{"644":1}}],["deterministically",{"2":{"227":1,"335":1,"1054":1,"1067":1,"1419":1}}],["deterministic",{"0":{"227":1,"336":1,"491":1,"527":1,"831":1,"865":1,"1075":1,"1373":1,"1441":1},"2":{"9":2,"121":1,"159":2,"203":1,"204":1,"250":2,"326":1,"331":1,"375":1,"416":1,"440":1,"522":1,"535":1,"540":1,"543":1,"573":1,"739":1,"827":1,"902":1,"906":1,"909":1,"910":1,"913":1,"922":1,"937":1,"938":1,"951":1,"959":1,"960":1,"972":1,"993":1,"1010":4,"1012":1,"1014":1,"1054":1,"1067":1,"1075":1,"1093":1,"1098":1,"1125":1,"1301":1,"1322":1,"1325":1,"1339":1,"1373":1,"1440":2,"1441":1,"1442":3,"1459":1}}],["determines",{"2":{"216":1,"305":1,"387":1,"1067":1,"1334":1}}],["determine",{"2":{"124":1,"301":1,"313":1,"362":1,"399":1}}],["fx",{"2":{"1221":1}}],["fête",{"2":{"1213":2}}],["fz",{"2":{"1144":1}}],["f",{"0":{"1132":1},"2":{"1089":1,"1125":3,"1144":1}}],["fn",{"0":{"334":1},"2":{"331":2,"332":2,"831":2}}],["fns",{"0":{"283":1},"2":{"14":1,"78":1,"283":3,"506":1,"507":1,"511":1,"514":2,"515":3,"808":1,"885":2,"1045":1,"1086":1,"1088":1,"1099":1,"1103":1,"1104":1,"1108":1,"1110":1,"1123":1,"1125":1,"1207":1,"1215":1,"1416":1}}],["fy2024",{"2":{"317":1,"326":1}}],["fps",{"2":{"1332":2,"1391":1}}],["fp",{"0":{"269":1},"1":{"270":1},"2":{"269":2,"270":1}}],["février",{"2":{"220":1}}],["fffffffk",{"2":{"1135":1}}],["ffffff",{"2":{"1125":1}}],["fff",{"2":{"1103":1,"1104":1,"1125":1,"1130":1,"1422":1}}],["ff",{"2":{"137":1,"138":9,"151":1,"240":1,"245":1,"1125":1}}],["fmt",{"0":{"354":1},"2":{"124":1,"406":1,"408":2,"409":2,"411":1,"427":1,"444":1,"513":3,"518":2,"699":2}}],["feasibility",{"2":{"1344":1,"1361":1,"1363":1}}],["featured",{"2":{"915":1,"1036":1}}],["feature",{"0":{"83":1,"84":1,"553":1},"1":{"84":1,"85":1,"86":1,"87":1,"88":1,"89":1,"90":1,"91":1,"554":1,"555":1},"2":{"8":1,"11":1,"34":1,"83":1,"101":1,"102":1,"196":1,"199":1,"273":1,"373":1,"406":1,"507":1,"533":1,"542":1,"555":1,"681":1,"1098":1}}],["features",{"0":{"475":1,"570":1,"578":1,"584":1,"588":1,"592":1,"596":1,"600":1,"606":1,"609":1,"612":1,"620":1,"639":1,"659":1,"764":1,"772":1,"785":1,"791":1,"796":1,"805":1,"811":1,"815":1,"822":1,"828":1,"837":1,"1053":1,"1207":1,"1276":1},"1":{"571":1,"572":1,"765":1,"766":1,"767":1,"768":1,"769":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"786":1,"787":1,"788":1,"792":1,"793":1,"797":1,"798":1,"806":1,"807":1,"808":1,"812":1,"816":1,"817":1,"818":1,"819":1,"823":1,"824":1,"825":1,"829":1,"830":1,"831":1,"832":1,"838":1,"839":1,"840":1,"841":1,"842":1},"2":{"6":1,"13":1,"15":1,"26":1,"249":1,"262":1,"263":1,"266":1,"273":1,"287":1,"310":1,"387":1,"430":1,"467":1,"470":1,"547":1,"552":2,"553":1,"554":1,"575":1,"637":1,"644":1,"678":1,"716":1,"845":1,"870":1,"925":1,"1086":1,"1105":1,"1212":1,"1440":1}}],["festivals",{"2":{"1271":1}}],["feminine",{"2":{"1269":1}}],["fedwire",{"2":{"1221":1}}],["fedex",{"2":{"1139":1}}],["federal",{"2":{"1097":1,"1224":1}}],["feeds",{"0":{"1446":1}}],["feed",{"2":{"878":1}}],["feedback",{"0":{"16":1,"922":1},"2":{"922":2}}],["feels",{"2":{"387":1}}],["feel",{"2":{"384":1,"433":1,"522":1,"1016":1}}],["feb",{"2":{"303":2,"363":1,"458":1,"459":1,"461":1,"1213":1,"1269":1}}],["febrero",{"2":{"219":1,"363":1}}],["february",{"2":{"219":2,"1271":6,"1280":1,"1310":1}}],["fevrier",{"2":{"219":1,"220":1}}],["few",{"2":{"140":1,"467":1}}],["fetchlatestquote",{"2":{"1446":1}}],["fetched",{"2":{"856":1,"932":1,"1004":1,"1215":1}}],["fetches",{"2":{"856":1,"937":1,"938":1,"959":1}}],["fetchdefaults",{"2":{"856":3,"938":1,"1001":1}}],["fetchdataasync",{"2":{"496":1}}],["fetchflightdeparture",{"2":{"334":1}}],["fetching",{"2":{"44":1,"829":1,"856":2,"1262":1}}],["fetch",{"2":{"43":2,"829":1,"860":2,"955":1,"983":2,"1011":1,"1178":2,"1191":3,"1215":1,"1240":1,"1262":2,"1264":2,"1444":1}}],["fuel",{"2":{"1365":1}}],["furikae",{"2":{"1213":1}}],["further",{"2":{"14":1,"300":1,"444":1,"634":1,"699":1}}],["fulfill",{"2":{"1147":1}}],["fulfilled",{"2":{"891":1,"900":1}}],["fullday",{"2":{"180":1}}],["fully",{"2":{"39":1,"43":1,"139":1,"140":1,"171":1,"269":1,"291":1,"326":1,"365":1,"367":1,"410":1,"450":1,"630":1,"680":1,"682":1,"683":1,"716":1,"732":1,"734":1,"735":1,"737":1,"739":1,"744":1,"760":1,"786":1,"816":1,"836":1,"932":1,"1036":2,"1173":1,"1190":1,"1459":1}}],["full",{"0":{"135":1,"210":1,"251":1,"551":1,"1281":1},"1":{"136":1,"211":1},"2":{"10":1,"12":1,"13":1,"27":1,"29":3,"72":1,"78":1,"84":1,"85":1,"131":1,"135":1,"137":2,"138":1,"146":2,"147":1,"153":2,"187":1,"197":1,"198":1,"199":1,"205":1,"210":1,"215":1,"223":1,"256":1,"262":1,"265":1,"267":1,"275":1,"276":3,"301":2,"305":1,"308":1,"334":1,"365":3,"372":1,"392":1,"429":1,"445":1,"459":1,"471":1,"472":1,"473":1,"475":1,"479":1,"487":1,"597":1,"617":1,"647":1,"668":1,"669":1,"677":1,"678":1,"687":1,"692":1,"709":1,"723":1,"763":1,"774":1,"831":1,"915":1,"940":2,"953":1,"996":1,"998":2,"1011":1,"1012":1,"1035":1,"1042":1,"1055":1,"1059":4,"1064":2,"1067":1,"1076":2,"1077":1,"1089":1,"1090":1,"1111":1,"1113":1,"1125":4,"1158":2,"1171":1,"1201":1,"1248":1,"1269":1,"1276":2,"1278":2,"1313":2,"1389":1,"1413":1}}],["fundamental",{"2":{"440":1}}],["fundamentally",{"2":{"230":1}}],["functioning",{"2":{"984":1}}],["function",{"0":{"919":1},"1":{"920":1},"2":{"96":1,"123":1,"131":1,"197":1,"198":1,"199":1,"224":3,"225":2,"233":1,"235":2,"261":2,"266":1,"270":2,"276":2,"300":1,"301":1,"312":1,"313":1,"317":1,"319":1,"326":2,"327":2,"334":1,"427":1,"437":1,"438":1,"453":1,"456":1,"469":2,"477":1,"492":1,"502":1,"505":1,"647":1,"664":1,"778":1,"816":1,"853":1,"855":1,"860":1,"918":1,"919":1,"955":1,"1013":1,"1014":1,"1015":1,"1016":1,"1030":1,"1036":1,"1081":2,"1082":1,"1083":1,"1084":1,"1085":1,"1141":1,"1147":1,"1168":2,"1178":1,"1190":1,"1192":1,"1193":1,"1220":1,"1221":1,"1222":1,"1223":1,"1240":2,"1261":1,"1263":1,"1265":1,"1266":1,"1287":1,"1304":1,"1310":1,"1326":1,"1332":1,"1335":1,"1357":1,"1363":1,"1364":1,"1365":1,"1372":1,"1389":1,"1409":1,"1430":1,"1435":1,"1444":1,"1445":1,"1446":1,"1452":1}}],["functions",{"0":{"283":1,"499":1,"915":1,"918":1},"1":{"500":1,"501":1,"502":1,"916":1,"917":1,"918":1},"2":{"69":1,"93":1,"98":1,"119":1,"265":1,"269":1,"270":4,"273":1,"283":1,"294":1,"477":2,"479":3,"503":1,"509":1,"519":1,"525":1,"536":1,"649":1,"651":1,"673":1,"769":1,"807":1,"858":1,"859":1,"863":1,"910":1,"912":2,"915":2,"918":1,"919":2,"920":1,"933":2,"936":1,"946":1,"955":1,"971":1,"972":2,"973":2,"1004":1}}],["functionality",{"0":{"470":1},"1":{"471":1,"472":1,"473":1,"474":1,"475":1,"476":1,"477":1,"478":1,"479":1},"2":{"46":1,"229":1,"249":1,"273":1,"596":1,"597":1,"747":1,"1315":1}}],["functional",{"0":{"69":1,"119":1,"224":1,"225":1,"404":1,"477":1,"536":1,"838":1},"1":{"120":1,"225":1},"2":{"12":1,"14":1,"69":1,"120":1,"224":1,"269":2,"283":1,"403":1,"404":1,"477":1,"515":1,"520":1,"574":1,"617":2,"625":1,"626":1,"655":1,"682":1,"835":1,"855":1,"1153":1,"1453":1}}],["fuzzy",{"2":{"220":1}}],["future",{"2":{"12":1,"56":1,"158":1,"202":1,"321":1,"331":1,"383":1,"386":1,"485":1,"489":1,"507":1,"528":1,"565":1,"642":2,"729":1,"902":1,"1045":1,"1421":2}}],["family",{"2":{"1213":1}}],["families",{"2":{"1098":1}}],["familiar",{"2":{"1":1,"137":1,"205":1,"490":1,"524":1}}],["faithfully",{"2":{"1271":1}}],["fair",{"2":{"1223":1}}],["fainter",{"2":{"1067":1}}],["faintly",{"2":{"1067":1}}],["failure",{"2":{"445":1,"860":1,"920":1,"973":2}}],["failures",{"2":{"146":2,"281":1,"404":1,"607":1,"657":1,"702":1,"709":1,"747":1,"876":1,"1008":1,"1443":1}}],["failing",{"2":{"419":1,"451":1,"631":1,"942":1,"1443":1}}],["failed",{"2":{"360":1,"481":1,"651":1,"738":1,"973":3,"993":1,"1444":1}}],["fail",{"0":{"359":1,"445":1,"866":1,"980":1},"2":{"221":1,"281":1,"389":2,"404":1,"407":2,"419":1,"442":1,"472":1,"498":1,"510":1,"856":1,"866":1,"942":1,"970":1}}],["fails",{"2":{"216":1,"359":1,"360":1,"446":1,"450":1,"856":1,"866":1,"947":1,"980":1,"1425":1}}],["failovers",{"2":{"939":1}}],["failover",{"0":{"1182":1},"2":{"117":1,"404":1,"970":1,"1182":1}}],["farthest",{"2":{"1077":1}}],["far",{"2":{"972":1,"1427":1}}],["farmlng",{"2":{"1082":2}}],["farmlat",{"2":{"1082":2}}],["farm",{"0":{"696":1,"924":1},"1":{"925":1,"926":1,"927":1,"928":1,"929":1,"930":1,"931":1,"932":1,"933":1,"934":1,"935":1,"936":1,"937":1,"938":1},"2":{"919":1,"942":1}}],["faults",{"2":{"1041":1}}],["fault",{"2":{"896":1,"939":1}}],["fa",{"2":{"884":1}}],["fake",{"2":{"876":1}}],["favor",{"2":{"157":1,"291":1,"546":1,"768":1,"830":1,"836":1}}],["fan",{"2":{"489":1,"792":1}}],["fancy",{"2":{"134":2}}],["fantastic",{"2":{"43":1}}],["fall",{"2":{"771":1,"778":1,"1178":1,"1195":2,"1331":1,"1344":1}}],["falling",{"2":{"359":1,"702":1,"755":1,"1010":1,"1017":1}}],["falls",{"2":{"177":1,"301":1,"321":1,"365":1,"782":1,"856":1,"947":1,"1182":1,"1257":1,"1336":1,"1344":1,"1345":1,"1422":1}}],["fallbacks",{"0":{"365":1},"2":{"78":1,"205":1,"365":1,"367":1,"565":1,"699":1,"823":1,"855":1,"1010":1}}],["fallback",{"0":{"144":1,"291":1,"855":1,"945":1,"1017":1,"1257":1},"2":{"11":1,"71":1,"99":1,"102":1,"144":1,"145":2,"215":1,"219":1,"281":3,"285":1,"288":1,"290":1,"291":1,"358":2,"359":1,"367":1,"450":1,"477":1,"503":1,"607":2,"634":2,"644":1,"696":1,"746":1,"752":1,"760":1,"856":1,"865":1,"867":2,"871":1,"874":1,"881":1,"890":1,"899":1,"921":1,"927":1,"934":5,"936":1,"937":3,"938":3,"940":1,"942":2,"945":1,"958":1,"959":1,"963":1,"989":1,"1010":1,"1017":3,"1024":1,"1099":1,"1104":2,"1119":1,"1140":1,"1182":1,"1191":1,"1214":1,"1374":1,"1422":1}}],["false",{"2":{"117":3,"149":1,"217":1,"282":1,"336":1,"358":2,"360":1,"402":3,"426":1,"433":1,"437":2,"438":1,"464":1,"497":1,"702":2,"757":1,"763":1,"767":1,"802":1,"856":2,"863":1,"871":1,"881":1,"890":1,"899":1,"912":3,"920":1,"937":4,"938":2,"959":1,"965":2,"973":2,"975":3,"982":1,"985":1,"986":1,"1008":1,"1009":1,"1011":2,"1022":2,"1030":1,"1033":1,"1042":1,"1043":1,"1059":1,"1064":1,"1071":2,"1084":2,"1085":1,"1136":1,"1153":1,"1158":1,"1182":1,"1195":1,"1205":1,"1209":1,"1216":1,"1224":1,"1240":1,"1259":1,"1261":1,"1304":1,"1335":1,"1337":1,"1436":1}}],["facade",{"0":{"840":1},"2":{"795":1,"835":1,"840":1}}],["facilitycoordinates",{"2":{"1081":2}}],["facilitating",{"2":{"414":1}}],["facilitate",{"2":{"111":1}}],["facing",{"2":{"402":2,"946":1,"1016":1}}],["factors",{"2":{"1074":1}}],["factor",{"0":{"1077":1},"2":{"1009":1,"1077":1,"1234":1,"1240":1}}],["factories",{"0":{"285":1,"816":1},"2":{"712":1,"787":1,"814":1,"816":1}}],["factory",{"0":{"232":1,"265":1,"328":1,"333":1,"496":1},"1":{"266":1,"329":1,"330":1,"331":1,"332":1,"333":1,"334":1,"335":1,"336":1,"337":1,"338":1,"339":1,"340":1,"341":1},"2":{"102":2,"146":1,"230":1,"232":1,"235":1,"253":1,"263":1,"271":1,"273":4,"274":2,"275":1,"276":1,"280":1,"285":1,"288":1,"289":1,"290":1,"312":1,"328":1,"331":2,"332":1,"338":1,"339":1,"402":1,"422":1,"631":1,"639":1,"640":1,"643":2,"711":1,"787":1,"816":1}}],["face",{"2":{"269":1}}],["fasti",{"0":{"1268":1,"1273":1,"1281":1,"1311":1},"1":{"1269":1,"1270":1,"1271":1,"1272":1,"1273":1,"1274":1,"1312":1,"1313":1},"2":{"1268":1,"1276":1,"1278":1,"1281":1,"1291":1,"1293":1,"1299":1,"1313":3,"1314":1}}],["fastify",{"2":{"116":1,"119":1,"1193":1}}],["fastest",{"2":{"258":1,"309":1,"427":1,"450":1,"934":3,"949":2}}],["faster",{"0":{"1121":1},"2":{"44":1,"127":1,"174":1,"445":1,"450":1,"505":1,"588":1,"798":1,"1120":1}}],["fast",{"0":{"359":1,"445":1},"2":{"89":1,"127":1,"138":1,"147":1,"175":1,"278":1,"281":1,"407":3,"419":1,"442":1,"445":1,"451":1,"705":1,"787":1,"867":1,"935":1,"940":2,"1042":1,"1104":8,"1389":1}}],["fleet",{"0":{"1364":1},"2":{"1362":1}}],["fleets",{"2":{"1255":1}}],["flexibility",{"2":{"516":1,"520":1}}],["flexible",{"2":{"100":1,"196":1,"273":1,"390":1,"672":1,"750":1,"847":1,"852":1}}],["fluctuations",{"2":{"1076":1}}],["fluctuate",{"2":{"1064":1}}],["flush",{"2":{"1009":1}}],["fluentd",{"2":{"1143":1}}],["fluent",{"0":{"682":1,"1169":1,"1171":1,"1345":1},"2":{"9":1,"199":1,"283":1,"515":1,"771":1,"1318":1,"1335":1,"1337":1,"1341":1,"1357":1,"1358":1,"1360":1}}],["flightplan",{"2":{"1365":4}}],["flighttime",{"2":{"1084":2}}],["flights",{"2":{"1084":1}}],["flight",{"0":{"1365":1},"2":{"905":1,"946":1,"1052":1,"1343":1,"1363":2}}],["flash",{"0":{"1259":1},"1":{"1260":1,"1261":1},"2":{"1259":1}}],["flaviu",{"2":{"1226":1}}],["flattening",{"2":{"644":1}}],["flat",{"2":{"145":1}}],["flagging",{"2":{"1363":1}}],["flagged",{"2":{"950":1}}],["flags",{"2":{"356":1,"475":1,"484":1,"701":1,"1041":4}}],["flag",{"0":{"357":1,"358":1,"571":1,"1041":1},"2":{"34":2,"39":1,"357":1,"377":1,"702":1,"937":2,"938":2,"977":1,"996":1,"1024":1,"1062":1,"1219":1}}],["flood",{"2":{"1083":1}}],["floor",{"2":{"265":1,"1266":1,"1316":1,"1325":1,"1326":1,"1329":1}}],["float64array",{"2":{"1029":1,"1039":1}}],["floating",{"0":{"1224":1},"2":{"43":1,"109":1,"520":1,"1225":1,"1232":1}}],["flowcharts",{"2":{"934":1,"963":1}}],["flows",{"2":{"709":1}}],["flow",{"0":{"878":1,"1264":1},"2":{"111":1,"631":1,"1446":1}}],["fly",{"2":{"10":1,"43":1,"44":1,"147":1,"780":1}}],["francisco",{"2":{"1335":1,"1361":1}}],["france",{"2":{"365":1,"1207":1,"1213":1,"1366":1}}],["framenumber",{"2":{"1395":2}}],["frame",{"0":{"1330":1},"1":{"1331":1,"1332":1},"2":{"993":1,"1315":1,"1320":1,"1331":3,"1332":6}}],["frames",{"2":{"897":1,"1267":1,"1331":1,"1394":1}}],["framework",{"0":{"1430":1},"2":{"642":1}}],["fragile",{"2":{"503":1,"1091":1,"1139":1}}],["fragmentation",{"2":{"227":1}}],["fractions",{"2":{"1080":1,"1085":1}}],["fraction",{"2":{"240":1,"1033":1,"1053":2,"1065":2}}],["fractional",{"0":{"209":1},"2":{"137":1,"138":4,"151":1,"158":2,"209":1,"245":1,"416":1,"613":1,"689":1,"1124":1,"1125":3}}],["frictionless",{"2":{"1108":1}}],["friction",{"2":{"467":1,"468":1,"780":1}}],["friendlier",{"2":{"198":1}}],["friendly",{"2":{"196":1,"512":1,"516":1,"763":1,"798":1,"840":1,"882":1,"897":1,"898":1,"986":1,"1016":1}}],["fri",{"2":{"191":1,"203":1,"233":1,"235":1,"395":1,"454":1,"1209":1,"1224":1,"1232":2}}],["friday",{"2":{"9":1,"10":1,"11":1,"12":1,"36":1,"38":1,"45":1,"59":1,"71":2,"125":3,"158":1,"191":2,"201":1,"203":1,"219":1,"222":1,"223":1,"231":1,"233":1,"357":1,"365":1,"366":1,"393":1,"398":1,"510":1,"517":2,"525":1,"684":1,"734":2,"737":1,"739":5,"776":1,"802":1,"850":1,"884":2,"888":1,"889":1,"898":2,"902":1,"911":1,"934":1,"939":1,"951":1,"955":1,"962":1,"968":1,"970":1,"975":1,"982":1,"985":1,"997":3,"1012":1,"1013":1,"1195":1,"1197":1,"1203":2,"1205":4,"1207":1,"1209":1,"1213":4,"1219":1,"1220":2,"1221":4,"1222":1,"1224":1,"1417":1,"1421":1,"1447":1}}],["frustrating",{"2":{"163":1}}],["freq=daily",{"2":{"1418":1}}],["freq=monthly",{"2":{"983":1,"984":1,"1014":1}}],["freq=weekly",{"2":{"982":1,"986":1,"1014":2,"1418":1}}],["frequency",{"0":{"1267":1,"1327":1,"1386":1},"1":{"1328":1,"1329":1,"1387":1,"1388":1,"1389":1},"2":{"407":1,"511":1,"616":1,"699":1,"1235":1,"1267":1,"1322":1,"1328":1,"1367":1,"1377":1,"1383":1}}],["frequently",{"2":{"119":1,"157":1,"377":1,"994":1,"1086":1,"1097":1,"1224":1,"1258":1,"1303":1,"1309":1,"1362":1}}],["freshly",{"2":{"334":1}}],["fresh",{"2":{"233":2,"279":1,"402":1,"871":1,"881":1,"890":1,"899":1,"937":1,"938":1,"959":1,"1167":1,"1184":2}}],["french",{"2":{"76":2,"219":3,"222":1,"363":2,"737":2,"746":1,"1090":1}}],["freezing",{"2":{"114":1,"425":1,"464":1,"469":1}}],["freezes",{"2":{"468":1,"1448":1}}],["freeze",{"0":{"413":1,"430":1,"432":1},"1":{"414":1,"431":1,"432":1,"433":2,"434":2,"435":2,"436":1,"437":1,"438":1,"439":1,"440":1},"2":{"1":1,"112":1,"114":1,"120":1,"406":1,"413":1,"414":1,"424":1,"425":2,"430":1,"431":2,"432":1,"434":1,"437":4,"438":2,"440":1,"453":1,"464":1,"466":1,"468":1,"578":1,"597":1,"629":2,"738":1,"864":1,"998":1,"1218":1,"1443":1}}],["freeform",{"0":{"85":1},"2":{"83":2}}],["free",{"0":{"1015":1,"1039":1,"1367":1,"1370":1,"1381":1},"1":{"1368":1,"1369":1,"1370":1,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1},"2":{"45":1,"89":4,"138":1,"152":1,"204":1,"326":1,"479":1,"609":1,"722":1,"923":1,"929":1,"948":1,"953":1,"954":4,"993":2,"1008":2,"1018":1,"1025":1,"1029":1,"1057":1,"1107":1,"1155":1,"1174":1,"1211":1,"1252":1,"1300":1,"1321":1,"1349":1,"1377":1,"1383":1,"1384":1,"1385":1,"1388":2,"1389":1,"1392":1,"1395":1,"1410":1}}],["fr",{"2":{"76":4,"145":3,"147":4,"154":2,"219":2,"222":2,"223":2,"363":4,"370":2,"372":2,"731":4,"737":2,"754":2,"890":2,"899":2,"982":2,"1157":2,"1158":1,"1159":2,"1160":2,"1181":1,"1213":1,"1214":1,"1418":1}}],["fronleichnam",{"2":{"1213":1}}],["frontino",{"2":{"1281":2}}],["frontier",{"2":{"909":1,"972":1}}],["frontends",{"2":{"114":1,"129":1,"780":1,"931":1}}],["frontend",{"0":{"104":1,"857":1,"1005":1},"2":{"102":1,"104":1,"111":1,"610":1,"852":1,"913":1,"1005":1,"1146":1,"1149":1,"1150":1,"1188":1,"1265":1}}],["frozen=false",{"2":{"438":1}}],["frozen=true",{"2":{"437":2}}],["frozen",{"0":{"425":1},"2":{"27":1,"69":1,"120":1,"121":1,"227":1,"295":1,"340":1,"367":1,"414":1,"427":1,"431":1,"433":1,"437":4,"438":3,"453":2,"464":1,"465":1,"475":1,"657":1,"682":1,"738":2,"782":1,"786":1,"817":1,"824":1,"864":2,"912":1,"916":1,"965":1,"968":1,"998":1,"1106":1,"1173":2,"1276":1,"1284":1,"1287":1}}],["fromclassical",{"0":{"1288":1},"2":{"1276":1,"1304":1}}],["fromiso",{"2":{"1146":1}}],["fromepochnanoseconds",{"2":{"699":1}}],["fromnowon",{"2":{"171":1}}],["fromformats",{"0":{"1119":1},"2":{"1104":2,"1119":1,"1140":1,"1141":1}}],["fromformat",{"0":{"1119":1},"2":{"78":1,"205":1,"1104":1,"1119":1,"1122":1,"1136":2,"1147":1}}],["from",{"0":{"80":1,"560":1,"561":1,"562":1},"1":{"563":1,"564":1,"565":1},"2":{"7":1,"9":2,"10":1,"27":1,"31":1,"32":1,"36":1,"38":1,"39":1,"40":1,"42":1,"43":3,"45":1,"46":2,"69":1,"76":1,"78":1,"88":1,"89":1,"94":2,"97":1,"98":3,"102":4,"103":2,"104":2,"105":1,"109":1,"111":1,"113":2,"114":2,"115":1,"116":1,"117":1,"119":2,"131":1,"133":1,"136":2,"137":3,"138":2,"142":1,"145":1,"146":2,"148":1,"157":1,"158":4,"169":2,"170":4,"171":1,"189":1,"197":1,"200":1,"205":1,"211":2,"213":1,"220":1,"227":1,"232":1,"234":1,"236":2,"240":1,"249":1,"250":1,"251":6,"259":2,"260":2,"261":1,"265":2,"267":1,"268":2,"271":5,"274":3,"275":1,"276":5,"278":1,"282":1,"283":2,"285":2,"286":3,"288":1,"289":5,"290":4,"291":1,"295":1,"297":1,"305":1,"310":2,"311":2,"313":2,"316":2,"319":1,"322":1,"323":1,"324":1,"330":1,"333":2,"334":2,"335":2,"336":2,"338":1,"339":1,"351":1,"363":2,"365":1,"375":1,"396":1,"397":2,"399":1,"402":2,"404":1,"425":1,"439":2,"440":2,"447":1,"448":2,"453":1,"457":2,"458":1,"459":1,"460":1,"461":3,"462":1,"463":1,"464":2,"468":2,"477":1,"481":1,"489":1,"496":5,"500":1,"501":2,"502":1,"511":1,"512":1,"514":1,"517":2,"520":3,"528":1,"532":1,"536":2,"537":3,"548":3,"549":1,"551":1,"552":1,"558":2,"572":1,"597":1,"626":1,"643":1,"644":2,"651":1,"664":1,"665":1,"676":1,"687":1,"695":1,"699":1,"705":1,"708":1,"711":1,"714":1,"717":1,"723":1,"728":3,"732":1,"734":1,"738":1,"739":5,"744":1,"750":2,"757":1,"759":3,"763":1,"765":1,"771":1,"773":1,"775":3,"792":1,"793":1,"806":1,"812":1,"831":1,"836":2,"848":2,"849":2,"853":1,"856":2,"859":1,"862":2,"870":2,"871":1,"872":1,"877":1,"878":2,"880":2,"881":2,"882":1,"885":2,"888":1,"889":3,"890":1,"891":2,"896":1,"898":2,"899":1,"900":1,"903":2,"908":1,"915":2,"916":2,"917":1,"918":1,"925":1,"929":1,"930":1,"931":1,"933":1,"939":1,"942":2,"948":1,"954":1,"955":1,"957":1,"958":3,"961":1,"969":3,"970":1,"972":1,"973":1,"974":1,"976":2,"978":2,"982":1,"988":1,"989":1,"997":1,"1004":2,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1019":2,"1020":1,"1028":1,"1030":2,"1033":2,"1036":3,"1046":3,"1049":2,"1055":4,"1056":1,"1059":2,"1064":2,"1067":2,"1069":1,"1071":1,"1075":1,"1076":2,"1077":1,"1081":2,"1082":2,"1083":3,"1084":2,"1085":2,"1090":1,"1099":1,"1101":2,"1102":1,"1104":5,"1108":1,"1113":2,"1115":2,"1136":1,"1141":2,"1144":2,"1147":2,"1150":2,"1153":2,"1154":1,"1157":2,"1158":2,"1160":3,"1161":1,"1164":2,"1165":1,"1167":1,"1168":3,"1171":2,"1172":2,"1176":2,"1178":2,"1184":3,"1188":2,"1189":1,"1190":2,"1191":2,"1192":1,"1193":1,"1195":1,"1197":1,"1209":1,"1214":1,"1216":1,"1220":1,"1221":2,"1222":1,"1223":1,"1224":2,"1239":2,"1240":1,"1241":1,"1243":2,"1254":4,"1255":1,"1257":1,"1258":1,"1261":2,"1263":2,"1265":1,"1266":2,"1268":3,"1270":2,"1272":1,"1273":1,"1278":1,"1280":1,"1281":2,"1282":2,"1291":1,"1304":2,"1307":1,"1310":1,"1312":1,"1313":1,"1316":2,"1317":1,"1326":2,"1329":2,"1332":2,"1334":1,"1335":2,"1337":2,"1338":1,"1339":1,"1341":2,"1342":1,"1344":8,"1345":2,"1347":2,"1352":2,"1353":1,"1357":2,"1358":4,"1359":2,"1360":2,"1361":3,"1363":4,"1364":1,"1365":1,"1366":1,"1368":2,"1372":1,"1379":2,"1380":1,"1381":3,"1389":6,"1391":1,"1392":2,"1395":1,"1399":2,"1400":1,"1408":1,"1412":1,"1420":1,"1422":3,"1424":1,"1426":1,"1429":3,"1430":1,"1433":1,"1435":1,"1436":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":2,"1450":1}}],["fiji",{"2":{"1338":2}}],["fit",{"2":{"989":1}}],["fits",{"2":{"952":1,"1015":1}}],["fidelity",{"2":{"532":1,"996":1,"998":2,"1098":1}}],["fighting",{"2":{"512":1}}],["field",{"0":{"1416":1},"1":{"1417":1},"2":{"426":1,"1028":1,"1085":1,"1401":1,"1404":1,"1411":1,"1417":1,"1427":1,"1447":1}}],["fields",{"0":{"314":1},"2":{"7":2,"142":1,"301":1,"314":1,"326":4,"408":1,"424":1,"427":3,"428":1,"464":1,"717":1,"855":1,"1004":1}}],["fish",{"2":{"305":1}}],["fiscalyear",{"2":{"1097":1}}],["fiscalyearstart",{"2":{"317":2,"333":1}}],["fiscalterm",{"2":{"274":1}}],["fiscalquarter",{"2":{"143":1,"230":1,"265":2,"267":1,"268":1,"519":1,"1153":1,"1154":1}}],["fiscal",{"0":{"72":1,"303":1,"1097":1},"2":{"76":1,"95":1,"143":1,"193":1,"230":1,"266":1,"268":1,"302":1,"303":2,"307":1,"315":1,"317":2,"323":1,"333":1,"509":1,"519":3,"522":1,"526":1,"695":1,"704":1,"771":1,"773":1,"774":1,"776":1,"823":1,"974":2,"1097":2,"1151":1,"1415":1}}],["filters",{"2":{"374":1}}],["filter",{"2":{"326":1,"468":1,"738":1,"763":1,"767":1,"890":1,"940":5,"1048":1,"1124":1}}],["filtering",{"0":{"125":1,"126":1,"941":1,"1233":1},"1":{"127":1,"128":1,"942":1},"2":{"630":1,"647":1,"648":1,"763":1,"942":1,"1233":1,"1242":1,"1263":1}}],["fill",{"2":{"138":2,"1131":1}}],["filler",{"2":{"125":1}}],["fileurltopath",{"2":{"829":1}}],["filesystem",{"2":{"688":1,"926":1}}],["files",{"0":{"1450":1},"2":{"44":1,"102":1,"105":1,"107":1,"109":1,"214":1,"457":1,"538":4,"655":1,"688":1,"829":1,"839":1,"864":1,"926":1,"1035":1,"1224":1,"1450":1,"1454":1,"1459":1}}],["file",{"2":{"7":1,"10":1,"27":1,"29":1,"42":1,"44":1,"102":2,"103":1,"105":2,"107":1,"108":1,"109":2,"110":1,"115":2,"117":2,"234":1,"261":1,"479":1,"541":2,"588":1,"741":2,"829":2,"832":1,"913":1,"925":1,"1450":1,"1459":1}}],["finnish",{"2":{"1095":1}}],["finish",{"2":{"1443":1}}],["finished",{"2":{"336":1,"812":1}}],["finishes",{"2":{"109":1,"1036":1}}],["finiteresult",{"2":{"983":3}}],["finite",{"2":{"983":1,"986":1}}],["fintempo",{"2":{"333":2,"339":2}}],["finally",{"2":{"483":1,"616":1,"831":1,"860":1,"955":1,"1441":2}}],["finalized",{"2":{"625":1,"704":1,"1434":1}}],["finalizes",{"2":{"547":1,"1405":1}}],["finalizer",{"0":{"476":1},"2":{"473":1,"476":1,"495":1,"1374":1,"1442":1}}],["finalizationregistry",{"0":{"1442":1},"2":{"476":1}}],["finalization",{"0":{"495":1,"1374":1,"1442":1},"2":{"473":1}}],["final",{"2":{"118":1,"246":1,"357":1,"382":1,"645":1,"863":1,"888":1,"1043":1,"1273":1}}],["financeplugin",{"2":{"333":2}}],["financenamespace",{"2":{"265":1,"267":1,"268":2,"270":1,"274":1,"708":1,"1153":2}}],["finance",{"0":{"1151":1},"1":{"1152":1,"1153":1,"1154":1,"1155":1},"2":{"12":1,"14":1,"141":1,"143":3,"230":2,"263":1,"265":4,"266":1,"267":2,"268":3,"269":1,"270":2,"273":1,"333":2,"711":2,"823":1,"1017":1,"1152":1,"1153":4,"1154":2}}],["financial",{"0":{"1031":1,"1221":1,"1446":1},"1":{"1032":1,"1033":1},"2":{"12":1,"248":1,"333":1,"531":1,"711":1,"845":1,"867":1,"922":1,"950":1,"1018":1,"1024":1,"1110":1,"1151":1,"1218":1,"1221":1,"1242":1,"1428":1,"1447":1}}],["findconsuls",{"0":{"1293":1},"2":{"1313":1}}],["findnextavailableslot",{"2":{"1015":1}}],["finds",{"2":{"319":1,"383":2,"385":1,"387":1,"1015":1}}],["finding",{"2":{"176":1,"179":1,"993":1}}],["find",{"2":{"76":1,"127":1,"157":1,"191":1,"359":1,"399":1,"573":1,"987":1,"1197":1}}],["firmware",{"2":{"1028":1}}],["firmly",{"2":{"167":1}}],["firing",{"2":{"942":1}}],["firebase",{"2":{"955":1}}],["fire",{"2":{"856":1}}],["firestore",{"2":{"1008":2}}],["fires",{"2":{"493":1,"1421":1,"1448":2}}],["firefox",{"2":{"34":1}}],["firstday",{"2":{"137":1,"154":1,"365":1,"367":2,"370":5,"786":2,"817":1}}],["first",{"0":{"461":1},"2":{"45":1,"75":1,"87":1,"98":1,"99":1,"110":1,"111":1,"112":2,"114":1,"124":1,"128":1,"148":1,"186":1,"203":3,"216":2,"265":1,"266":1,"269":1,"270":1,"297":1,"300":2,"314":1,"326":1,"365":1,"366":1,"375":1,"378":1,"398":1,"399":1,"407":2,"424":1,"427":1,"429":1,"444":1,"458":2,"477":1,"482":1,"489":3,"506":1,"507":2,"514":1,"515":1,"517":1,"677":1,"681":1,"707":1,"711":1,"739":1,"763":1,"771":1,"776":2,"806":1,"817":2,"853":1,"856":1,"925":1,"934":1,"945":1,"946":1,"948":1,"951":1,"1014":1,"1015":1,"1030":2,"1059":2,"1067":1,"1076":1,"1085":1,"1093":2,"1104":1,"1106":1,"1110":1,"1140":1,"1178":8,"1184":1,"1189":1,"1192":1,"1234":1,"1264":2,"1269":1,"1435":1}}],["fixing",{"2":{"709":1}}],["fix",{"0":{"714":1},"2":{"8":1,"23":2,"616":1,"617":1,"627":1}}],["fixer",{"2":{"191":1}}],["fixed",{"0":{"607":1},"2":{"6":1,"97":1,"167":1,"296":3,"387":1,"504":1,"520":1,"593":1,"613":1,"631":1,"634":1,"637":1,"651":1,"664":1,"666":1,"709":1,"738":1,"751":1,"833":1,"856":1,"972":1,"1081":1,"1125":2,"1222":1,"1268":1,"1272":1,"1328":1,"1329":1,"1412":1,"1459":1}}],["fixes",{"0":{"579":1,"585":1,"593":1,"613":1,"621":1,"627":1,"631":1,"634":1,"660":1,"702":1,"709":1,"781":1,"800":1,"801":1,"833":1},"1":{"782":1,"802":1},"2":{"6":1,"22":1,"575":1,"621":1,"637":1,"751":1}}],["folder",{"2":{"559":1,"560":1,"627":1}}],["followed",{"2":{"1134":1,"1270":1}}],["follows",{"2":{"157":1,"423":1,"575":1,"1272":1}}],["following",{"0":{"1222":1},"2":{"19":1,"101":1,"115":1,"202":1,"245":1,"285":1,"326":1,"393":1,"450":1,"739":1,"926":1,"1011":1,"1213":1,"1214":1,"1221":1,"1222":3,"1270":1}}],["follow",{"2":{"0":1,"20":1,"186":1,"213":1,"279":1,"281":1,"326":1,"388":1,"842":1,"920":1,"1417":1}}],["focuses",{"2":{"361":1,"780":1}}],["focused",{"2":{"273":1,"661":1}}],["footprint",{"2":{"300":1,"373":1,"402":1,"403":1}}],["fourth",{"2":{"909":1}}],["four",{"2":{"172":1,"303":1,"997":1,"1087":1,"1269":1,"1271":1}}],["founding",{"2":{"1272":1,"1273":2}}],["founded",{"2":{"1087":1}}],["found",{"2":{"16":1,"76":1,"129":1,"627":1,"993":1,"1004":1}}],["foundational",{"2":{"361":1,"1111":1}}],["foundation",{"2":{"12":1,"221":1,"507":1,"516":1,"522":1,"1213":1,"1306":1}}],["forbidden",{"2":{"955":1}}],["fortnightly",{"2":{"1413":1}}],["fortnight",{"2":{"639":1}}],["forgotten",{"2":{"1445":1}}],["forgery",{"2":{"1001":1}}],["forgets",{"2":{"1374":1}}],["forgetting",{"2":{"1091":1}}],["forget",{"2":{"109":1,"856":1}}],["forgiving",{"2":{"510":1}}],["formulas",{"2":{"1312":1,"1314":1}}],["formula",{"2":{"1270":1,"1292":1,"1313":1,"1355":1}}],["forms",{"2":{"946":1,"1276":1}}],["former",{"2":{"743":1}}],["formallatin",{"2":{"1310":3}}],["formally",{"2":{"728":1}}],["formal",{"2":{"899":1}}],["formatconsuls",{"0":{"1292":1}}],["formatinvoicedateforvisitor",{"2":{"1190":2}}],["format=json`",{"2":{"1178":1}}],["format=json",{"2":{"1178":1}}],["formatrfc5424",{"2":{"1144":2}}],["formatrfc3164",{"2":{"1144":2}}],["formatmodule",{"2":{"135":1,"136":2,"251":2,"271":2,"724":1}}],["formataiextractaidiffaicontextai",{"2":{"920":1}}],["formataitempo",{"2":{"919":1}}],["formatai",{"0":{"897":1},"1":{"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1},"2":{"93":1,"863":1,"897":2,"898":2,"902":1,"903":2,"904":2,"905":1,"910":1,"912":1,"936":1,"950":1,"973":3,"998":1}}],["formatter",{"0":{"787":1},"2":{"159":1,"784":1,"1104":10}}],["formatters",{"2":{"78":1,"371":1,"513":1,"778":1,"787":1,"1106":1}}],["formatted",{"2":{"119":1,"143":1,"165":2,"335":2,"355":1,"364":1,"609":1,"651":1,"880":1,"882":1,"898":1,"900":2,"919":2,"950":1,"973":3,"998":2,"1016":1,"1313":1}}],["formatting",{"0":{"74":1,"75":1,"130":1,"131":1,"133":1,"136":1,"140":1,"146":1,"165":1,"364":1,"370":1,"372":1,"513":1,"518":1,"723":1,"897":1,"905":1,"1096":1,"1157":1},"1":{"75":1,"76":1,"77":1,"78":1,"131":1,"132":2,"133":1,"134":2,"135":1,"136":1,"137":1,"138":1,"139":1,"140":1,"141":1,"142":1,"143":1,"144":1,"145":1,"146":1,"147":1,"166":1,"365":1,"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1},"2":{"9":1,"12":1,"14":1,"50":1,"76":2,"84":1,"109":1,"117":1,"130":1,"131":2,"135":2,"136":1,"137":1,"138":2,"144":1,"146":4,"147":2,"156":1,"157":1,"166":1,"199":1,"205":2,"322":1,"323":1,"325":1,"344":1,"354":1,"361":2,"370":2,"372":2,"373":1,"444":1,"451":1,"466":1,"507":1,"513":1,"516":1,"518":2,"520":1,"558":1,"606":2,"659":1,"671":1,"679":1,"704":1,"707":1,"731":2,"750":2,"752":2,"754":1,"755":2,"758":1,"763":2,"765":1,"768":1,"771":3,"775":2,"778":1,"787":4,"788":2,"808":1,"817":1,"819":1,"823":1,"881":1,"897":1,"899":1,"919":1,"1042":1,"1055":1,"1086":2,"1088":1,"1090":1,"1097":1,"1099":1,"1105":1,"1106":1,"1110":2,"1118":1,"1120":1,"1121":1,"1123":1,"1125":1,"1131":2,"1149":1,"1156":1,"1157":1,"1190":2,"1276":1}}],["formats",{"0":{"134":1,"201":1,"391":1},"1":{"392":1,"393":1,"394":1,"395":1,"396":1,"397":1},"2":{"30":1,"41":1,"76":3,"96":1,"112":1,"113":1,"115":1,"117":1,"124":1,"134":1,"140":1,"146":1,"202":1,"221":1,"237":1,"248":1,"294":2,"295":3,"297":2,"298":1,"331":2,"355":1,"370":5,"375":1,"410":1,"431":1,"451":1,"518":1,"524":1,"525":1,"544":5,"545":2,"631":1,"723":1,"738":1,"836":2,"843":2,"897":1,"989":1,"1010":1,"1088":1,"1089":2,"1096":1,"1104":1,"1125":2,"1139":2,"1140":1,"1141":1,"1144":2,"1168":1,"1189":2}}],["format",{"0":{"54":1,"76":1,"78":1,"147":1,"205":1,"254":2,"731":1,"765":1,"788":1,"806":1,"807":1,"823":1,"1095":1,"1096":1,"1148":1,"1295":1},"1":{"1149":1,"1150":1},"2":{"9":1,"42":1,"46":1,"54":3,"58":1,"68":2,"75":2,"76":7,"83":1,"109":1,"117":1,"119":1,"124":1,"125":1,"128":1,"131":9,"133":3,"134":2,"135":1,"136":1,"137":4,"138":1,"139":7,"140":3,"141":1,"142":1,"143":2,"144":2,"145":4,"146":3,"147":4,"150":2,"152":1,"159":1,"161":1,"165":3,"166":2,"173":1,"199":1,"205":5,"207":1,"216":1,"231":1,"251":2,"254":1,"271":3,"278":1,"297":4,"323":3,"324":3,"325":1,"334":1,"335":1,"364":1,"370":3,"406":1,"413":1,"430":1,"440":1,"458":1,"466":1,"510":1,"513":1,"518":2,"520":3,"544":1,"553":1,"557":1,"558":2,"559":4,"560":1,"588":1,"597":1,"606":2,"610":1,"633":1,"637":1,"680":2,"682":1,"704":3,"705":1,"709":1,"719":1,"723":1,"731":2,"732":1,"743":2,"750":1,"754":3,"763":4,"765":4,"766":2,"768":3,"773":4,"775":1,"776":1,"798":1,"804":3,"806":7,"807":2,"817":1,"821":1,"823":2,"878":1,"886":1,"889":2,"894":1,"897":1,"903":1,"905":1,"909":2,"913":1,"918":1,"919":1,"954":1,"961":1,"964":2,"968":1,"969":1,"985":1,"988":2,"1009":1,"1014":1,"1016":2,"1036":1,"1055":2,"1061":3,"1069":2,"1073":2,"1082":4,"1083":2,"1085":1,"1087":1,"1088":3,"1089":5,"1091":3,"1095":1,"1096":1,"1099":1,"1101":4,"1103":4,"1104":14,"1109":1,"1112":1,"1113":1,"1114":1,"1115":1,"1116":1,"1118":1,"1119":1,"1122":4,"1123":2,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1135":1,"1141":2,"1144":4,"1146":1,"1147":4,"1149":2,"1150":1,"1158":2,"1171":1,"1190":1,"1197":2,"1199":2,"1209":1,"1220":1,"1221":3,"1222":2,"1223":1,"1224":1,"1243":1,"1254":1,"1255":1,"1265":2,"1280":1,"1281":1,"1304":2,"1307":1,"1310":1,"1313":4,"1316":1,"1317":1,"1326":4,"1329":1,"1408":1,"1412":3,"1415":1,"1417":2,"1418":1,"1419":1,"1420":1,"1421":1,"1422":1,"1424":2,"1434":1,"1439":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1,"1454":2}}],["form",{"2":{"166":1,"204":2,"240":1,"326":1,"878":1,"1095":1}}],["forwarded",{"2":{"1188":1}}],["forwarder",{"2":{"1149":1}}],["forwardgeocode",{"2":{"1176":1,"1178":1,"1181":1,"1191":1}}],["forwards",{"2":{"860":1,"955":1,"1259":1}}],["forwarding",{"2":{"408":1}}],["forward",{"0":{"1181":1,"1365":1},"2":{"157":1,"189":1,"191":2,"192":1,"195":1,"321":2,"383":2,"408":1,"522":1,"734":1,"754":1,"955":1,"993":1,"1028":1,"1032":1,"1035":1,"1055":2,"1162":1,"1166":1,"1167":1,"1168":2,"1176":2,"1178":1,"1181":3,"1191":2,"1192":1,"1260":1,"1270":1,"1344":1,"1345":1,"1354":1,"1358":1,"1362":1,"1419":1}}],["forcing",{"0":{"975":1,"977":1},"2":{"140":1,"375":1,"469":1}}],["forced",{"2":{"563":1,"1090":2}}],["forcefully",{"2":{"298":1}}],["forces",{"2":{"161":1,"191":1,"724":1,"937":1,"938":1,"975":1,"1076":2}}],["force",{"2":{"124":1,"161":1,"163":1,"164":1,"217":3,"270":1,"701":1,"871":1,"881":1,"890":2,"899":1,"937":1,"938":1,"959":2,"962":1,"975":2,"977":2,"1008":1,"1009":1,"1184":1}}],["foreign",{"2":{"109":1,"212":1,"223":2,"361":1,"363":1}}],["for",{"0":{"30":1,"54":1,"468":1,"469":1,"521":1,"555":1,"759":1,"842":1,"955":1,"985":1,"1016":1,"1435":1,"1446":1},"1":{"31":1,"32":1,"522":1,"523":1,"524":1,"525":1,"526":1,"527":1,"528":1},"2":{"0":1,"1":3,"3":1,"6":2,"7":2,"8":2,"10":2,"12":1,"13":2,"17":1,"23":1,"27":1,"28":1,"29":1,"30":1,"31":1,"33":1,"34":4,"35":1,"38":1,"43":6,"44":2,"45":1,"48":2,"49":1,"69":1,"71":5,"72":1,"76":2,"77":3,"78":1,"85":1,"89":4,"90":1,"92":1,"96":2,"97":1,"99":1,"101":2,"102":1,"107":1,"109":3,"110":1,"111":1,"112":1,"113":1,"114":1,"115":2,"116":3,"117":6,"118":1,"123":1,"124":4,"125":1,"126":1,"128":1,"129":4,"137":2,"138":12,"144":2,"146":4,"150":2,"152":3,"154":4,"155":1,"156":1,"157":7,"159":1,"164":1,"165":1,"168":2,"171":1,"175":1,"176":1,"177":1,"179":1,"181":2,"187":1,"190":1,"193":1,"195":1,"198":3,"199":3,"203":1,"204":2,"205":1,"206":1,"213":1,"215":1,"218":1,"219":1,"221":1,"224":1,"228":1,"229":3,"230":1,"233":1,"236":2,"240":1,"246":1,"247":1,"248":1,"250":5,"253":1,"254":1,"255":1,"257":1,"259":1,"260":1,"262":1,"266":1,"270":1,"271":2,"272":1,"273":4,"274":3,"275":1,"276":3,"281":2,"282":1,"283":1,"286":1,"288":1,"289":1,"291":2,"292":1,"293":1,"296":1,"297":2,"298":2,"300":2,"302":1,"305":1,"310":1,"311":1,"313":4,"315":2,"321":1,"322":1,"326":3,"328":1,"332":1,"333":1,"334":1,"341":1,"344":1,"351":2,"352":1,"353":1,"354":1,"357":1,"359":1,"360":1,"361":1,"362":1,"363":1,"364":2,"365":7,"370":5,"377":2,"378":1,"380":1,"381":1,"382":1,"383":2,"386":1,"388":1,"389":2,"390":1,"394":1,"395":1,"400":1,"402":4,"404":2,"405":1,"409":1,"410":1,"411":2,"412":1,"413":1,"414":1,"415":1,"419":1,"421":1,"422":1,"423":3,"424":1,"425":1,"427":1,"430":2,"431":1,"438":1,"439":1,"440":1,"441":1,"442":1,"445":1,"456":4,"457":1,"458":1,"461":1,"462":2,"466":1,"467":1,"469":1,"470":1,"471":3,"472":1,"473":3,"475":2,"476":2,"477":1,"479":1,"480":1,"483":1,"484":1,"485":1,"489":3,"492":2,"499":1,"500":1,"503":2,"506":2,"511":1,"513":1,"514":4,"515":4,"516":5,"517":1,"518":4,"519":1,"520":1,"522":1,"524":2,"527":1,"528":1,"531":1,"532":2,"533":1,"538":1,"539":1,"541":2,"544":1,"549":1,"557":1,"559":3,"560":2,"561":1,"562":1,"565":2,"571":1,"578":3,"580":1,"581":1,"582":1,"592":1,"596":2,"597":1,"600":1,"606":1,"609":1,"610":1,"612":1,"613":1,"614":1,"616":3,"620":2,"621":1,"625":2,"629":4,"633":1,"634":1,"635":1,"637":4,"639":5,"642":1,"644":1,"649":2,"653":1,"654":1,"659":1,"661":2,"663":2,"664":1,"666":1,"671":1,"672":1,"673":1,"675":1,"676":1,"677":1,"682":2,"683":1,"684":3,"687":2,"688":1,"691":1,"692":1,"696":1,"699":1,"701":1,"704":2,"705":1,"707":1,"709":1,"711":3,"716":1,"719":1,"720":1,"722":2,"723":1,"728":1,"729":3,"732":1,"735":3,"737":1,"739":1,"746":2,"747":1,"750":2,"754":2,"757":1,"758":2,"763":1,"768":1,"771":3,"773":2,"775":1,"776":2,"778":2,"787":1,"788":1,"792":1,"804":1,"807":1,"810":1,"817":1,"818":1,"829":2,"830":2,"831":1,"832":2,"836":1,"838":1,"839":1,"841":1,"842":1,"852":2,"853":1,"854":1,"857":1,"859":1,"861":1,"867":2,"868":1,"869":2,"871":2,"881":4,"887":1,"889":1,"890":4,"891":1,"894":2,"899":4,"909":3,"910":4,"912":1,"913":3,"915":1,"918":1,"920":3,"922":1,"923":1,"924":1,"929":1,"931":1,"934":2,"935":2,"936":3,"937":7,"938":7,"942":1,"945":1,"946":2,"947":1,"948":1,"949":1,"950":5,"951":1,"953":3,"954":1,"955":1,"958":1,"959":1,"960":1,"962":1,"963":2,"968":3,"969":1,"972":1,"973":2,"978":1,"985":2,"986":1,"993":1,"996":1,"997":1,"998":3,"1000":1,"1004":1,"1005":1,"1008":4,"1011":1,"1013":1,"1014":1,"1018":3,"1022":2,"1025":1,"1030":1,"1035":1,"1036":1,"1042":1,"1043":1,"1047":3,"1048":1,"1050":1,"1053":1,"1054":1,"1055":4,"1057":1,"1062":1,"1065":1,"1069":1,"1072":2,"1073":1,"1078":3,"1084":1,"1086":1,"1088":2,"1089":1,"1090":2,"1094":1,"1095":1,"1097":1,"1098":5,"1099":2,"1104":10,"1105":1,"1107":1,"1108":1,"1110":2,"1113":2,"1115":1,"1117":1,"1122":1,"1125":5,"1136":1,"1139":1,"1143":1,"1147":1,"1149":1,"1151":1,"1154":1,"1155":1,"1162":2,"1168":2,"1169":1,"1171":1,"1174":1,"1178":1,"1184":1,"1185":1,"1186":3,"1188":2,"1190":2,"1192":1,"1205":1,"1206":1,"1207":1,"1210":1,"1211":1,"1212":2,"1213":4,"1215":2,"1216":1,"1217":2,"1222":1,"1223":1,"1225":1,"1236":1,"1242":2,"1252":1,"1253":1,"1254":1,"1270":1,"1275":1,"1276":1,"1278":1,"1284":1,"1291":1,"1296":2,"1297":2,"1300":1,"1301":1,"1303":1,"1313":1,"1315":1,"1319":1,"1321":1,"1329":1,"1339":1,"1345":1,"1349":1,"1361":1,"1366":1,"1367":1,"1373":1,"1377":2,"1378":1,"1382":3,"1384":1,"1389":3,"1396":1,"1401":1,"1404":1,"1405":5,"1406":1,"1409":1,"1410":1,"1412":2,"1415":2,"1421":1,"1426":2,"1430":1,"1431":1,"1433":1,"1434":3,"1435":2,"1441":1,"1442":2,"1443":1,"1445":1,"1446":1,"1448":1,"1450":1,"1453":1,"1454":1}}],["bbox",{"2":{"1344":1,"1345":1}}],["bsd",{"2":{"1125":1,"1143":1,"1144":1}}],["bst",{"2":{"878":1}}],["b2b",{"2":{"1219":1}}],["b2",{"2":{"983":1}}],["b1",{"2":{"983":1}}],["blending",{"2":{"1224":1}}],["blindly",{"2":{"993":1}}],["blue",{"2":{"666":1,"1071":1,"1084":2}}],["blueprint",{"2":{"240":1}}],["blazing",{"2":{"451":1}}],["blanket",{"2":{"298":1}}],["bloat",{"2":{"519":1,"705":1,"997":1}}],["bloating",{"2":{"181":1}}],["blocking",{"2":{"856":1}}],["blocked",{"2":{"414":1,"1376":1}}],["blocks",{"2":{"324":1,"335":1,"404":1,"437":1,"440":1,"616":1,"651":1,"1028":1,"1139":1,"1405":2}}],["block",{"2":{"266":2,"335":1,"486":2,"494":1,"647":1,"709":1,"792":1,"831":2,"839":1,"1324":1,"1373":1,"1433":2}}],["b",{"0":{"381":1,"849":1,"918":1,"958":1,"1040":1,"1092":1,"1128":1,"1135":1,"1179":1,"1187":1,"1281":1,"1430":1,"1439":1},"1":{"1093":1,"1094":1,"1095":1,"1096":1,"1097":1},"2":{"157":2,"286":1,"292":1,"363":1,"469":1,"642":1,"1038":1,"1090":2,"1125":2,"1144":2,"1263":1,"1360":1,"1417":1,"1421":1,"1424":1}}],["bce⟹754−753=1",{"2":{"1272":1}}],["bce⟹754−44=710",{"2":{"1272":1}}],["bce",{"0":{"1294":1},"2":{"137":1,"150":1,"202":1,"707":1,"1271":1,"1272":3,"1273":5,"1276":2,"1278":1,"1280":2,"1281":1,"1291":1,"1294":1,"1295":1,"1306":1,"1307":2,"1313":2}}],["bc",{"2":{"137":1,"138":1,"150":3,"202":6,"240":1,"242":2,"707":1}}],["bcp",{"2":{"117":1,"154":1,"872":1,"890":1,"899":1,"1158":2,"1159":1,"1160":1,"1168":1,"1207":1,"1214":1}}],["bissextilis",{"2":{"1271":1}}],["bissextile",{"0":{"1271":1},"2":{"1271":2,"1275":1,"1276":1,"1280":1,"1299":1,"1314":1}}],["bis",{"2":{"1271":3,"1276":1,"1280":2,"1310":1}}],["bidding",{"2":{"1259":1}}],["bidirectional",{"2":{"370":1,"473":1,"1099":1,"1276":1}}],["bidi",{"2":{"370":2}}],["bills",{"2":{"1191":1}}],["billing",{"2":{"77":1,"93":1,"164":1,"531":1,"857":1,"887":1,"1088":2,"1110":1,"1222":1}}],["biologists",{"2":{"1085":1}}],["biographies",{"2":{"869":1}}],["bit",{"2":{"1039":1,"1368":1,"1421":1}}],["binds",{"2":{"1370":1}}],["binding",{"2":{"265":1,"860":1}}],["bind",{"2":{"159":1}}],["birthday",{"2":{"157":2,"159":4,"1213":5}}],["bigint64array",{"2":{"1368":1,"1369":1}}],["bigint",{"0":{"567":1},"1":{"568":1,"569":1},"2":{"60":1,"154":3,"174":2,"201":1,"206":1,"355":1,"472":1,"498":1,"500":1,"501":1,"503":1,"567":3,"569":1,"616":1,"750":2,"1381":1,"1382":2}}],["boyne",{"2":{"1213":1}}],["bots",{"2":{"1013":1}}],["both",{"0":{"43":1,"270":1},"2":{"60":1,"87":1,"94":1,"109":1,"171":1,"202":1,"203":1,"206":1,"214":1,"270":1,"271":2,"283":1,"296":1,"331":1,"363":1,"437":1,"456":1,"469":1,"489":1,"494":1,"502":1,"606":1,"616":1,"651":1,"719":1,"722":2,"735":1,"831":1,"852":1,"862":1,"1221":1,"1254":1,"1270":1,"1306":1,"1362":1,"1440":1}}],["bodies",{"2":{"869":1,"1008":1}}],["body",{"2":{"112":1,"860":5,"955":2,"1011":1,"1444":1}}],["bowing",{"2":{"514":1}}],["bones",{"2":{"251":1,"276":1}}],["bobfreetime",{"2":{"179":2}}],["boost",{"2":{"934":1}}],["boosts",{"0":{"795":1},"2":{"699":1,"934":1}}],["books",{"2":{"1223":1,"1387":1}}],["booked",{"2":{"989":1}}],["bookedslot",{"2":{"176":2}}],["booking",{"0":{"987":1,"1013":1},"1":{"988":1,"989":1,"990":1,"991":1,"992":1,"993":1},"2":{"919":1,"987":2,"988":5,"989":1,"1013":1,"1015":1,"1190":2,"1324":1}}],["book",{"2":{"766":1,"1388":1}}],["bookkeeping",{"2":{"402":2}}],["boolean",{"0":{"127":1,"571":1,"1249":1,"1298":2},"2":{"117":4,"154":1,"235":1,"265":1,"266":1,"267":1,"270":1,"285":1,"313":1,"317":1,"319":1,"336":1,"487":4,"571":1,"631":1,"871":4,"881":3,"890":3,"899":3,"937":5,"938":4,"959":3,"986":1,"992":1,"1022":1,"1062":1,"1071":2,"1084":2,"1220":1,"1240":1,"1363":1,"1427":1}}],["boots",{"2":{"114":1,"812":1}}],["bootstraps",{"2":{"111":1,"114":1,"741":1}}],["bootstrap",{"0":{"112":1},"2":{"102":1,"103":3,"104":1,"106":1,"108":1,"109":1,"113":1,"741":1,"760":1,"829":1,"926":1}}],["booting",{"2":{"109":1}}],["board",{"2":{"95":1}}],["boundingbox",{"2":{"1336":1}}],["bounding",{"0":{"1333":1,"1336":1,"1337":1},"1":{"1334":1,"1335":1,"1336":1,"1337":2,"1338":2},"2":{"445":1,"1160":1,"1333":1,"1336":1,"1338":2,"1343":1,"1344":1,"1345":1,"1362":1,"1364":1}}],["bound",{"0":{"372":1},"2":{"323":1,"324":2,"371":2,"372":2,"373":1,"473":1,"493":1,"514":1,"773":1,"787":1,"888":1,"955":1,"1382":1}}],["boundedticker",{"2":{"1439":1}}],["boundedstream",{"2":{"493":1}}],["bounded",{"0":{"1184":1,"1437":1},"1":{"1438":1,"1439":1},"2":{"167":1,"416":1,"696":1,"829":1,"860":1,"1162":1,"1182":1}}],["boundedcache",{"2":{"92":1,"691":1,"694":1,"938":1,"971":1,"974":1,"978":1,"1009":1,"1166":1,"1184":1}}],["boundary",{"0":{"382":1,"777":1,"842":1,"1330":1,"1415":1,"1439":1},"1":{"1331":1,"1332":1},"2":{"109":1,"117":1,"173":1,"174":1,"186":2,"190":1,"194":1,"227":1,"301":1,"304":1,"314":1,"321":1,"322":1,"323":2,"324":3,"369":1,"383":2,"699":1,"711":1,"747":1,"771":4,"775":2,"777":1,"865":1,"910":1,"1039":1,"1047":2,"1067":1,"1255":1,"1263":1,"1320":1,"1322":1,"1325":1,"1332":3,"1333":1,"1336":4,"1364":1,"1404":1,"1415":2,"1417":1,"1425":1,"1439":1}}],["boundaries",{"0":{"63":1,"171":1,"185":1,"186":1,"190":1,"320":1,"394":1,"682":1,"1073":1,"1092":1,"1263":1,"1364":1},"1":{"186":1,"187":1,"188":1,"189":1,"190":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1},"2":{"63":1,"77":1,"106":1,"156":1,"172":1,"174":1,"177":1,"185":1,"186":2,"191":1,"301":1,"303":1,"304":1,"313":2,"315":1,"318":1,"319":1,"321":4,"326":2,"369":1,"380":1,"382":1,"387":1,"389":1,"402":1,"472":1,"504":1,"519":1,"653":1,"680":1,"696":1,"734":1,"771":1,"773":1,"825":1,"829":1,"881":1,"910":1,"972":1,"989":1,"1010":1,"1035":1,"1052":1,"1054":1,"1080":1,"1082":1,"1097":1,"1149":1,"1255":2,"1315":1,"1324":1,"1329":1,"1331":1,"1332":1,"1364":1}}],["bounds",{"0":{"109":1},"2":{"137":1,"997":1,"1015":2,"1231":1,"1336":1}}],["boilerplate",{"0":{"812":1,"1020":1,"1102":1,"1280":1,"1317":1,"1380":1},"2":{"84":1,"87":1,"119":1,"274":2,"373":1,"469":1,"489":1,"510":1,"513":2,"516":2,"810":1,"925":1,"1154":1}}],["boxes",{"0":{"1333":1},"1":{"1334":1,"1335":1,"1336":1,"1337":1,"1338":1},"2":{"1338":1,"1343":1,"1362":1}}],["boxing",{"2":{"885":1,"1213":5,"1223":1}}],["box",{"0":{"1336":1,"1337":1},"1":{"1337":1,"1338":1},"2":{"24":1,"101":1,"109":1,"129":1,"135":1,"161":1,"170":1,"210":1,"219":1,"273":1,"331":1,"345":1,"452":1,"510":1,"516":1,"517":1,"724":1,"754":1,"763":1,"1333":1,"1336":1,"1338":1,"1344":1,"1345":1,"1364":1}}],["bay",{"2":{"1364":1}}],["baking",{"2":{"1097":1}}],["baked",{"2":{"427":1,"429":1}}],["bad",{"0":{"976":1}}],["badge",{"2":{"709":1}}],["badges",{"2":{"709":1}}],["banking",{"2":{"1218":1,"1221":1,"1222":4,"1363":1}}],["bank",{"2":{"950":1,"1206":1,"1213":4,"1219":1,"1220":2,"1221":1,"1222":1,"1223":1}}],["bans",{"2":{"857":1}}],["banding",{"2":{"1391":1}}],["bands",{"2":{"1052":1,"1080":1,"1351":1}}],["bandwidth",{"2":{"942":1}}],["band",{"2":{"227":1,"1073":1}}],["bar",{"2":{"1124":1}}],["bars",{"2":{"946":1}}],["barrel",{"0":{"1450":1},"2":{"728":1,"1450":2,"1452":1}}],["bare",{"2":{"43":1,"251":1,"276":1,"285":1,"288":1,"289":1,"290":1,"291":2,"651":1,"1128":1}}],["battle",{"2":{"1213":1}}],["battery",{"0":{"1081":1},"2":{"1081":2,"1262":1}}],["batteries",{"2":{"46":1,"251":1,"276":1,"724":1,"1258":1,"1278":1}}],["bat",{"2":{"1085":1}}],["batchoptions",{"0":{"1022":1},"2":{"1021":1}}],["batchorchestrator",{"2":{"1021":3,"1041":1}}],["batchresult",{"2":{"1019":2,"1020":1}}],["batch2",{"2":{"983":2}}],["batch1",{"2":{"983":2}}],["batches",{"0":{"973":1},"2":{"981":1,"982":1,"983":1}}],["batchplugin",{"2":{"702":1,"1019":2,"1030":2,"1033":2,"1036":2}}],["batching",{"0":{"696":1,"983":1},"2":{"972":1}}],["batch",{"0":{"877":1,"887":1,"896":1,"905":1,"964":1,"1018":1},"1":{"1019":1,"1020":1,"1021":1,"1022":1,"1023":1,"1024":1,"1025":1},"2":{"292":1,"335":1,"696":1,"867":1,"871":1,"881":1,"890":1,"899":1,"912":1,"919":1,"920":1,"947":1,"970":1,"972":1,"973":2,"982":1,"983":3,"985":1,"986":1,"1019":3,"1020":2,"1021":3,"1026":1,"1029":3,"1030":5,"1033":5,"1036":2,"1037":1,"1038":1,"1225":1,"1447":1}}],["backslash",{"2":{"1091":1,"1130":1,"1131":1}}],["backtestengine",{"2":{"1033":1}}],["backtesting",{"0":{"1031":1},"1":{"1032":1,"1033":1},"2":{"1018":1,"1024":1,"1032":1}}],["backtrack",{"2":{"647":1}}],["backtracking",{"2":{"416":1,"647":2}}],["backpressure",{"2":{"473":1,"489":1,"1446":1}}],["backends",{"2":{"853":1,"915":1,"1188":1}}],["backend",{"0":{"860":1,"931":1,"955":1},"2":{"368":1,"852":1,"854":1,"857":1,"858":1,"859":1,"860":1,"861":1,"913":2,"931":2,"937":1,"953":2,"954":2,"955":3,"959":1,"1005":1,"1007":1,"1008":3,"1108":1,"1146":1,"1150":1,"1178":1,"1185":1,"1265":2,"1444":1}}],["backed",{"2":{"71":1,"203":1,"298":1,"473":1,"495":1,"879":1,"897":1,"968":1}}],["background",{"2":{"199":1,"856":1,"867":1,"945":1,"1008":1,"1019":1,"1030":1,"1037":1,"1262":1,"1372":1,"1391":1,"1431":1,"1440":2,"1442":1,"1443":1,"1448":1}}],["back",{"2":{"192":1,"359":1,"365":1,"422":1,"426":1,"501":1,"502":1,"702":1,"755":1,"763":1,"765":1,"771":1,"778":1,"782":1,"856":1,"1017":1,"1040":1,"1063":1,"1178":1,"1182":1,"1199":1,"1250":1,"1257":1,"1276":1,"1288":1,"1420":1,"1422":1}}],["backward",{"0":{"1270":1},"2":{"189":1,"367":1,"383":2,"549":1,"565":1,"630":1,"668":1,"771":2,"776":1,"778":1,"786":1,"886":1,"1299":1}}],["backwards",{"0":{"1420":1},"2":{"183":1,"291":1,"381":1,"732":1,"832":1,"842":1,"1197":1,"1259":1,"1268":1,"1270":2,"1404":1,"1420":1}}],["balancers",{"2":{"1328":1}}],["balanced",{"2":{"161":1,"162":1,"165":1,"1039":1}}],["balance",{"0":{"1223":1},"2":{"161":7,"162":3,"163":1,"164":2,"165":1,"430":1,"522":1,"606":1,"720":1,"1132":2,"1223":1}}],["balancing",{"0":{"161":1,"164":2,"947":1},"1":{"162":1,"163":1,"164":1},"2":{"156":1,"520":1,"720":1,"934":1,"939":1,"942":1}}],["baggage",{"2":{"12":1}}],["bastille",{"2":{"1213":1}}],["basilius",{"2":{"1273":1,"1278":1}}],["basic",{"0":{"463":1,"481":1,"870":1,"880":1,"889":1,"898":1,"928":1,"961":1,"982":1,"988":1},"1":{"929":1,"930":1,"931":1,"932":1,"933":1},"2":{"122":1,"211":1,"251":1,"675":1}}],["basics",{"0":{"51":1},"1":{"52":1,"53":1,"54":1,"55":1,"56":1},"2":{"50":1}}],["basis",{"2":{"119":1,"838":1,"908":1}}],["baseoptions",{"2":{"830":1,"838":1}}],["base64",{"2":{"588":1}}],["basename",{"2":{"367":2}}],["base",{"2":{"102":2,"105":1,"107":1,"115":1,"117":1,"290":1,"291":1,"340":1,"341":1,"370":1,"390":1,"399":1,"406":1,"412":1,"424":1,"453":1,"464":4,"465":3,"468":1,"504":1,"541":1,"542":1,"666":1,"937":1,"938":1,"1090":1}}],["baselines",{"2":{"1226":1}}],["baseline",{"0":{"874":1},"2":{"101":2,"102":1,"105":2,"116":2,"119":1,"121":1,"129":3,"250":1,"262":2,"276":1,"352":1,"365":3,"442":1,"448":1,"522":1,"867":1,"874":2,"945":1,"1120":1,"1234":1,"1422":1}}],["based",{"0":{"133":1,"199":1,"200":1,"454":1,"455":1,"490":1,"492":1,"1266":1},"1":{"134":1,"201":1,"202":1,"203":1,"204":1,"205":1,"491":1},"2":{"1":1,"29":1,"43":1,"58":1,"125":1,"127":1,"130":1,"131":1,"138":4,"147":1,"148":1,"159":1,"185":1,"208":1,"219":2,"270":1,"306":1,"315":1,"319":1,"325":1,"370":2,"378":1,"418":1,"420":1,"424":1,"446":1,"453":1,"473":2,"488":2,"507":4,"515":1,"531":1,"580":1,"596":1,"609":1,"621":1,"626":1,"642":1,"644":1,"648":1,"659":1,"672":1,"757":1,"870":1,"897":1,"909":1,"1059":1,"1065":1,"1067":1,"1078":1,"1080":1,"1085":1,"1093":2,"1095":1,"1098":1,"1125":2,"1189":1,"1219":1,"1427":1}}],["bash",{"2":{"957":1}}],["bashdeno",{"2":{"39":1}}],["bashnpx",{"2":{"1457":1}}],["bashnpm",{"2":{"5":1,"10":1,"35":1,"38":1,"846":1,"914":1,"1019":1,"1051":1,"1100":1,"1152":1,"1163":1,"1208":1,"1237":1,"1277":1,"1316":1,"1340":1,"1378":1,"1397":1,"1456":1,"1458":1}}],["bashnode",{"2":{"37":1}}],["bashgit",{"2":{"4":1}}],["byte",{"2":{"1368":1,"1382":1}}],["bytes",{"2":{"229":1,"373":1,"1368":1}}],["byday=mo",{"2":{"1418":1}}],["byday=tu",{"2":{"986":1,"1014":2}}],["byday=1mo",{"2":{"983":1,"984":1,"1014":1}}],["byday=fr",{"2":{"982":1}}],["byhour=9",{"2":{"982":1}}],["bycode",{"2":{"461":1}}],["byok",{"0":{"853":1,"1002":1},"1":{"854":1,"855":1,"856":1,"857":1,"1003":1,"1004":1,"1005":1},"2":{"89":1,"852":1,"854":1,"857":1,"913":1,"921":1,"954":1,"1004":1,"1007":1,"1008":2}}],["bypassing",{"0":{"975":1},"2":{"750":1,"1184":1}}],["bypassed",{"2":{"505":1,"738":1,"752":1}}],["bypasses",{"2":{"199":1,"439":1,"450":1,"871":1,"881":1,"890":1,"899":1,"937":1,"938":1,"984":1,"1011":1,"1368":1}}],["bypass",{"2":{"46":1,"217":1,"325":1,"406":1,"414":1,"427":1,"440":1,"701":1,"738":1,"752":1,"778":1,"959":1,"974":1,"1008":1,"1009":1,"1106":1}}],["by",{"0":{"25":1},"1":{"26":1,"27":1,"28":1,"29":1},"2":{"8":1,"11":1,"12":1,"21":1,"22":1,"24":1,"27":1,"34":1,"37":1,"39":1,"48":1,"59":1,"62":1,"64":1,"71":1,"89":1,"93":2,"111":1,"115":1,"117":2,"123":1,"124":1,"125":1,"138":2,"146":1,"147":1,"157":1,"159":3,"161":1,"162":2,"164":1,"166":1,"167":2,"182":1,"183":1,"186":1,"191":1,"195":1,"198":1,"200":1,"203":2,"207":1,"211":1,"213":1,"215":1,"216":1,"222":1,"230":1,"237":2,"240":3,"243":1,"245":1,"246":1,"247":1,"260":1,"274":1,"275":1,"276":2,"278":1,"281":1,"282":1,"294":1,"297":2,"301":1,"303":1,"308":1,"312":1,"313":1,"321":1,"338":1,"340":1,"345":1,"358":1,"363":2,"365":3,"368":1,"375":1,"377":1,"381":1,"387":2,"396":1,"402":1,"406":1,"407":1,"409":1,"410":1,"413":2,"416":2,"418":1,"426":2,"428":1,"429":1,"438":2,"442":1,"444":2,"462":1,"468":1,"472":1,"473":2,"479":1,"486":3,"493":1,"495":1,"502":1,"504":1,"513":1,"514":1,"516":1,"522":1,"529":1,"547":1,"561":1,"562":1,"617":1,"631":1,"664":1,"665":2,"667":1,"678":2,"681":1,"709":2,"724":1,"728":1,"737":1,"746":1,"751":1,"757":2,"763":2,"766":1,"767":1,"776":1,"798":1,"829":1,"854":1,"856":1,"862":1,"872":2,"879":1,"882":2,"889":1,"897":1,"900":1,"906":1,"908":1,"912":1,"948":1,"953":1,"966":2,"968":2,"971":1,"972":3,"973":1,"978":1,"985":1,"994":1,"998":1,"1028":1,"1033":1,"1035":1,"1037":1,"1040":1,"1043":1,"1055":2,"1069":1,"1080":1,"1082":1,"1088":1,"1090":1,"1091":1,"1093":1,"1098":2,"1113":1,"1118":1,"1124":1,"1128":2,"1129":1,"1132":1,"1134":2,"1141":1,"1176":1,"1184":1,"1218":1,"1251":1,"1255":1,"1258":1,"1264":1,"1266":2,"1268":1,"1270":1,"1271":1,"1272":2,"1273":2,"1306":1,"1312":2,"1313":1,"1315":1,"1316":1,"1336":1,"1339":1,"1368":1,"1374":1,"1375":1,"1376":2,"1395":1,"1414":1,"1416":1,"1419":1,"1431":1,"1437":1,"1442":2,"1443":1,"1453":1,"1459":1}}],["brutus",{"2":{"1278":1}}],["br",{"2":{"1160":2,"1217":1}}],["breach",{"2":{"1218":1,"1219":1}}],["breaches",{"2":{"1017":1}}],["breadcrumb",{"2":{"351":1}}],["breaks",{"2":{"1233":1}}],["breakers",{"0":{"911":1}}],["breaking",{"0":{"757":1,"836":1},"2":{"43":1,"567":1,"575":1,"637":1,"816":1,"942":1,"972":1,"1097":1}}],["break",{"2":{"43":1,"276":1,"431":1,"498":1,"985":2,"1096":1,"1223":1,"1409":1,"1412":1,"1434":1,"1435":1}}],["breakdowns",{"2":{"867":1}}],["breakdown",{"2":{"41":1,"861":1,"1113":1,"1203":1}}],["brk",{"2":{"240":1,"242":4,"1041":1}}],["brazil",{"2":{"1217":4}}],["brain",{"2":{"402":2}}],["bracket",{"2":{"1091":1}}],["brackets",{"0":{"1112":1},"2":{"240":1,"1091":3,"1098":1,"1112":2,"1128":1}}],["bracketed",{"2":{"141":1,"1105":1,"1113":1}}],["brace",{"2":{"778":1}}],["braced",{"0":{"806":1,"1091":1},"2":{"205":2,"798":1,"804":1,"806":1,"1096":1,"1103":1,"1112":1}}],["braces",{"2":{"137":1,"771":1,"778":1,"1091":2,"1098":1,"1132":2}}],["branding",{"0":{"590":1},"2":{"666":1}}],["brand",{"2":{"27":1,"331":1,"653":1,"708":1,"728":1,"1381":1}}],["branches",{"2":{"116":1}}],["branch",{"2":{"8":1,"331":1,"623":1}}],["broken",{"2":{"1088":1}}],["browse",{"2":{"229":1,"479":1}}],["browsers",{"2":{"365":1,"1039":1,"1375":1,"1378":1}}],["browser",{"0":{"41":1,"45":1,"850":1,"858":1,"859":1,"1375":1},"1":{"42":1,"43":1,"44":1,"859":1,"860":1,"1376":1},"2":{"10":3,"33":1,"34":1,"41":1,"42":1,"43":3,"44":1,"83":1,"84":1,"89":1,"102":1,"104":1,"138":1,"447":1,"479":3,"559":1,"560":1,"578":1,"588":1,"609":1,"610":1,"648":2,"651":4,"657":1,"671":1,"722":1,"780":1,"782":1,"810":1,"812":1,"857":5,"858":1,"859":2,"861":1,"913":3,"921":1,"931":1,"953":1,"955":1,"989":1,"1005":4,"1024":1,"1040":1,"1093":1,"1168":3,"1176":2,"1178":1,"1188":1,"1190":1,"1368":1,"1370":1,"1376":3,"1378":1,"1383":1}}],["broadcasting",{"2":{"792":1}}],["broadcast",{"2":{"489":2,"1368":1}}],["broad",{"2":{"100":1}}],["bright",{"0":{"1063":1},"2":{"1053":1,"1067":1}}],["bring",{"0":{"853":1},"1":{"854":1,"855":1,"856":1,"857":1},"2":{"852":1,"913":1}}],["brings",{"2":{"763":1,"814":1}}],["bringing",{"2":{"720":1,"810":1}}],["brittle",{"2":{"712":1}}],["bridging",{"2":{"366":1,"514":1}}],["bridge",{"0":{"402":1,"910":1},"1":{"911":1,"912":1},"2":{"76":1,"138":2,"221":1,"223":1,"515":2,"910":1}}],["bridges",{"2":{"11":1,"76":1,"167":1,"488":1,"526":1,"704":1,"879":1,"897":1,"913":1,"1012":1}}],["brief",{"2":{"8":1}}],["bucketkey",{"2":{"1329":3}}],["buckets",{"2":{"1320":1,"1328":1,"1329":4}}],["bucket",{"2":{"1266":1,"1329":5}}],["bumps",{"2":{"993":1}}],["bumping",{"0":{"993":1},"2":{"987":1}}],["bumped",{"2":{"603":1,"992":1}}],["burdens",{"2":{"1095":1}}],["burden",{"2":{"716":1}}],["buffer",{"0":{"1393":1},"1":{"1394":1,"1395":1},"2":{"1039":2,"1368":1,"1370":1,"1373":1,"1379":1,"1381":1,"1382":4,"1388":1,"1389":3,"1394":1,"1395":1}}],["buffered",{"2":{"497":1,"812":1}}],["buffers",{"2":{"489":1,"495":1,"1039":3,"1394":1}}],["buffering",{"2":{"473":1,"489":1}}],["bulls",{"2":{"1309":1}}],["bulletproof",{"2":{"439":1}}],["bulk",{"0":{"292":1},"2":{"251":1,"1018":1,"1030":1,"1037":1,"1042":1,"1083":1,"1225":1}}],["busycalendar",{"2":{"1015":2}}],["busyblock",{"2":{"1015":2}}],["busyevent",{"2":{"992":1}}],["busy",{"0":{"1015":1},"2":{"919":1,"987":1,"989":1,"993":2,"1015":3,"1394":1}}],["busting",{"2":{"44":1}}],["businessdaysuntil",{"0":{"1201":1},"2":{"1201":2,"1221":1,"1223":1}}],["businessdays",{"2":{"880":1,"882":1,"885":1,"919":1}}],["businessdaysplugin",{"2":{"232":2,"233":2,"235":2,"236":2,"275":1}}],["businessdayoptions",{"2":{"235":2}}],["businesshours",{"2":{"177":2}}],["businessglossary",{"2":{"95":2}}],["business",{"0":{"70":1,"509":1,"526":1,"879":1,"1097":1,"1194":1,"1195":1,"1196":1,"1198":1,"1200":1},"1":{"71":1,"72":1,"73":1,"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1,"1195":1,"1196":1,"1197":2,"1198":1,"1199":2,"1200":1,"1201":2,"1202":1,"1203":1,"1204":1,"1205":1},"2":{"11":1,"23":1,"50":1,"77":1,"92":1,"95":1,"96":2,"99":1,"177":1,"230":1,"236":1,"248":1,"273":1,"293":3,"300":1,"317":1,"507":1,"515":1,"522":2,"526":1,"711":1,"771":1,"845":1,"879":1,"880":2,"881":1,"882":1,"884":2,"885":2,"886":3,"897":1,"919":1,"950":1,"951":1,"974":1,"988":1,"1010":1,"1035":1,"1036":1,"1089":1,"1194":1,"1195":1,"1197":1,"1199":3,"1201":1,"1205":1,"1206":1,"1207":1,"1209":1,"1210":1,"1214":1,"1218":3,"1219":3,"1220":3,"1221":1,"1222":4,"1224":1}}],["bundesländer",{"2":{"1213":1}}],["bundling",{"2":{"10":1,"43":1,"170":1}}],["bundled",{"0":{"104":1},"2":{"43":1,"102":1,"104":1,"260":1,"311":1,"657":1,"663":1,"755":1,"780":1,"850":1,"859":1,"1005":1}}],["bundler",{"2":{"41":3,"43":1,"198":1,"702":1,"812":1,"847":1}}],["bundlers",{"0":{"35":1},"1":{"36":1,"37":1,"38":1}}],["bundle",{"0":{"42":1,"552":1},"2":{"10":2,"12":1,"29":1,"33":1,"34":1,"41":1,"42":2,"45":2,"46":1,"114":1,"198":1,"199":1,"229":1,"249":1,"260":1,"270":1,"283":1,"291":1,"311":1,"402":2,"447":1,"651":1,"653":2,"672":1,"675":1,"724":1,"757":1,"760":1,"850":1,"857":1,"918":1,"1121":1,"1273":1}}],["bundles",{"0":{"722":1},"2":{"6":1,"45":1,"669":1,"692":1,"722":1,"913":1,"915":1}}],["bun",{"0":{"35":1},"1":{"36":1,"37":1,"38":1},"2":{"10":2,"35":2,"846":2,"853":1,"861":1,"925":1,"957":1,"1188":1}}],["bugs",{"2":{"137":1,"573":1,"631":1,"972":1,"1086":1,"1088":1,"1094":1,"1110":1,"1149":1,"1218":1,"1447":1}}],["bug",{"0":{"579":1,"585":1,"593":1,"613":1,"621":1,"631":1,"634":1,"660":1,"702":1,"709":1,"714":1,"833":1},"2":{"6":1,"15":1,"16":1,"575":1,"637":1,"702":1,"752":1,"833":1,"1454":1}}],["builds",{"0":{"46":1},"2":{"276":1,"402":1,"428":1,"657":1,"751":1}}],["build",{"0":{"1114":1},"2":{"5":1,"11":1,"46":1,"76":1,"140":1,"191":1,"229":1,"236":1,"265":1,"266":1,"275":1,"529":1,"590":1,"607":3,"617":1,"627":2,"648":1,"665":2,"669":1,"688":1,"709":1,"716":1,"722":1,"760":2,"985":1,"1242":1}}],["building",{"0":{"5":1},"2":{"33":1,"140":1,"163":1,"230":2,"263":1,"269":1,"271":1,"280":1,"281":1,"283":1,"333":1,"388":1,"424":1,"440":1,"528":1,"838":1,"1015":1,"1092":1,"1315":1,"1428":1}}],["built",{"0":{"242":1,"1182":1,"1213":1},"2":{"0":1,"12":1,"14":1,"117":1,"124":1,"135":1,"157":2,"203":1,"210":1,"213":1,"229":1,"233":1,"262":1,"274":3,"293":1,"296":1,"298":1,"309":1,"338":1,"407":1,"447":1,"453":1,"488":1,"506":2,"507":1,"512":1,"513":1,"514":1,"516":1,"518":1,"519":1,"552":1,"634":1,"639":1,"737":2,"855":1,"958":1,"1017":1,"1113":1,"1172":1,"1192":1,"1207":1,"1210":1,"1215":1,"1437":1}}],["buttons",{"2":{"1259":1}}],["button",{"2":{"90":1}}],["but",{"2":{"1":1,"14":1,"102":1,"106":1,"113":1,"124":1,"139":2,"146":1,"197":1,"198":2,"219":1,"256":1,"262":1,"291":1,"298":1,"321":1,"330":1,"331":2,"359":1,"367":1,"371":1,"424":1,"437":2,"439":1,"446":1,"447":1,"450":1,"451":1,"456":1,"469":1,"481":1,"499":1,"515":1,"520":1,"528":1,"629":1,"642":1,"752":1,"972":2,"975":1,"1011":2,"1054":2,"1157":1,"1190":1,"1224":1}}],["beginning",{"2":{"1270":1,"1392":1}}],["begins",{"2":{"77":1,"178":1,"1415":1}}],["berlin",{"2":{"1160":1}}],["bearings",{"2":{"1354":1,"1362":1}}],["bearing",{"0":{"1347":1,"1358":2},"2":{"1062":1,"1071":2,"1343":1,"1344":2,"1345":1,"1347":2,"1358":3,"1365":2}}],["bearer",{"2":{"854":5,"859":1,"936":1,"955":2,"997":3}}],["beautiful",{"2":{"9":1}}],["bess",{"2":{"1081":1}}],["bespoke",{"2":{"533":1}}],["best",{"0":{"43":1,"102":1,"270":1,"277":1,"326":1,"327":1,"341":1,"389":1,"429":1,"1442":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"278":1,"279":1,"280":1,"281":1,"282":1},"2":{"41":1,"43":1,"96":1,"102":1,"129":1,"260":1,"310":1,"311":1,"365":1,"380":1,"381":1,"382":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"953":1,"987":1,"1092":1,"1188":1,"1396":1,"1442":1}}],["betting",{"2":{"1259":1}}],["better",{"2":{"572":1,"609":1,"621":1,"625":1,"635":1,"672":1}}],["beta",{"2":{"496":1}}],["between",{"0":{"1200":1},"1":{"1201":1},"2":{"137":1,"156":1,"161":1,"179":1,"180":1,"205":1,"262":1,"269":1,"274":1,"283":1,"324":1,"329":1,"394":1,"422":1,"473":1,"488":1,"520":1,"617":1,"729":1,"774":1,"879":1,"882":2,"891":1,"900":1,"910":1,"913":1,"981":1,"1007":1,"1015":1,"1038":1,"1060":1,"1064":1,"1071":2,"1072":1,"1075":1,"1076":1,"1079":1,"1081":1,"1084":1,"1089":2,"1099":1,"1104":1,"1109":1,"1116":1,"1150":1,"1201":1,"1203":1,"1207":1,"1209":1,"1240":1,"1272":1,"1331":1,"1334":1,"1344":4,"1345":1,"1351":1,"1355":1,"1360":1,"1363":1,"1395":1,"1447":1}}],["bench",{"2":{"451":1,"635":1}}],["benchmarkmodule",{"2":{"447":1,"448":2,"449":1,"450":1}}],["benchmark",{"0":{"446":1,"447":1,"450":1,"1043":1},"1":{"448":1,"449":1,"450":1,"451":2},"2":{"441":1,"446":1,"448":2}}],["benchmarking",{"2":{"419":1,"635":1}}],["benchmarks",{"0":{"441":1},"1":{"442":1,"443":1,"444":1,"445":1,"446":1,"447":1,"448":1,"449":1,"450":1,"451":1},"2":{"407":1,"419":1,"446":1,"589":1,"1105":1}}],["benefits",{"0":{"106":1,"107":1,"373":1,"439":1,"503":1},"1":{"107":1,"108":1,"109":1},"2":{"402":1,"472":1,"498":1,"1105":1}}],["bedtime",{"2":{"224":1,"225":2,"315":2}}],["being",{"2":{"208":1,"249":1,"359":1,"426":1,"440":1,"512":1,"569":1,"1028":1,"1415":1}}],["beyond",{"2":{"122":1,"130":1,"155":1,"1215":1,"1276":1}}],["becoming",{"2":{"514":1}}],["becomes",{"2":{"125":1,"202":2}}],["become",{"2":{"120":1,"454":1,"560":1,"1008":1,"1067":1}}],["because",{"2":{"44":1,"108":1,"114":1,"120":1,"146":1,"156":1,"161":1,"170":1,"191":3,"192":1,"229":1,"266":1,"270":1,"295":1,"300":1,"317":1,"327":1,"342":1,"351":1,"361":1,"370":1,"371":1,"429":1,"505":1,"514":1,"867":1,"906":1,"909":1,"994":1,"1060":1,"1088":1,"1096":1,"1110":1,"1178":1,"1265":1,"1267":1,"1369":1,"1378":1,"1431":1}}],["been",{"2":{"102":1,"228":1,"336":1,"346":1,"537":1,"539":1,"541":2,"544":2,"546":3,"548":1,"556":1,"561":1,"563":1,"564":1,"571":1,"573":1,"699":1,"705":1,"712":1,"717":1,"722":1,"732":1,"735":1,"738":1,"757":4,"758":1,"836":2,"1249":1,"1257":1}}],["behave",{"2":{"739":1}}],["behaves",{"2":{"414":1,"439":1}}],["behaviour",{"2":{"737":1}}],["behavioral",{"2":{"361":1}}],["behaviors",{"0":{"873":1,"883":1,"892":1,"901":1},"1":{"874":1,"875":1,"876":1,"877":1,"878":1,"884":1,"885":1,"886":1,"887":1,"893":1,"894":1,"895":1,"896":1,"902":1,"903":1,"904":1,"905":1},"2":{"122":1,"230":1,"278":1,"298":1,"328":1,"1092":1}}],["behavior",{"0":{"409":1,"1257":1},"2":{"93":1,"117":1,"124":1,"147":1,"297":1,"326":2,"342":1,"379":1,"383":1,"610":1,"617":1,"642":1,"644":1,"910":1,"1011":1,"1085":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1125":1,"1325":1,"1459":1}}],["behind",{"2":{"34":1,"43":1,"325":1,"1086":1}}],["before",{"2":{"43":1,"89":1,"93":1,"94":1,"98":2,"102":2,"109":1,"112":2,"114":2,"138":1,"146":1,"204":1,"246":1,"317":1,"319":1,"343":1,"357":2,"362":1,"383":1,"393":1,"394":1,"407":1,"409":1,"568":1,"631":1,"637":1,"639":1,"669":1,"707":1,"741":1,"778":1,"812":1,"856":4,"865":1,"871":1,"876":1,"884":1,"893":1,"902":1,"906":1,"908":1,"918":1,"921":1,"922":1,"932":1,"934":1,"942":1,"951":1,"955":1,"961":1,"975":1,"996":1,"1001":1,"1028":1,"1041":1,"1121":1,"1218":1,"1219":1,"1220":1,"1221":2,"1222":1,"1227":1,"1239":1,"1257":1,"1269":1,"1270":2,"1271":1,"1272":1,"1276":1,"1328":1,"1366":1,"1404":1,"1417":1,"1441":1,"1459":1}}],["bell",{"2":{"1447":1}}],["belongs",{"2":{"283":1,"1088":1,"1110":1}}],["below",{"2":{"34":1,"161":1,"221":1,"229":1,"302":1,"314":1,"359":1,"479":1,"875":1,"912":1,"921":1,"972":1,"1010":1,"1062":1,"1071":2,"1072":1,"1082":1,"1105":1,"1124":1,"1125":1}}],["believe",{"2":{"20":1,"522":1}}],["be",{"2":{"1":1,"6":1,"7":1,"23":1,"33":1,"100":1,"115":1,"122":1,"124":2,"125":1,"138":3,"140":1,"143":1,"147":1,"152":1,"157":1,"158":1,"163":1,"170":1,"191":1,"202":1,"203":1,"219":2,"229":1,"238":1,"246":1,"256":1,"274":1,"276":1,"281":1,"288":1,"298":1,"300":1,"326":2,"327":1,"335":1,"341":1,"342":1,"358":1,"359":1,"363":1,"367":1,"371":1,"375":1,"393":1,"395":1,"407":1,"414":1,"438":2,"465":1,"468":2,"469":1,"475":1,"476":1,"477":1,"479":1,"480":1,"484":2,"503":1,"504":1,"505":2,"510":1,"512":1,"527":1,"565":2,"637":1,"665":1,"687":1,"757":1,"768":1,"771":1,"777":1,"812":1,"852":1,"856":1,"913":1,"939":1,"946":1,"967":1,"974":1,"993":1,"1003":1,"1005":1,"1008":1,"1028":1,"1090":1,"1091":1,"1115":1,"1118":1,"1180":1,"1190":1,"1222":1,"1240":1,"1266":1,"1306":1,"1367":1,"1414":1,"1446":1}}],["s`",{"2":{"1420":1}}],["square",{"2":{"1091":1,"1112":1,"1128":1}}],["sqlmodel",{"2":{"1150":2}}],["sqlmask",{"2":{"1116":2}}],["sql",{"0":{"78":1,"690":1},"2":{"78":2,"690":1,"1086":1,"1088":1,"1097":1,"1099":1,"1103":1,"1104":4,"1115":2,"1116":1,"1150":1}}],["svg",{"2":{"1063":1}}],["svelte",{"2":{"857":1,"1005":1}}],["smoothed",{"2":{"1234":1,"1267":1}}],["smoothing",{"0":{"1234":1},"2":{"1226":1,"1234":1,"1236":1,"1240":1,"1242":1}}],["smith",{"2":{"997":1}}],["small",{"2":{"278":1,"1090":1}}],["smaller",{"2":{"164":1,"909":1,"972":1}}],["smart",{"0":{"43":1,"130":1,"196":1,"208":1,"211":1,"767":1,"995":1,"1082":1},"1":{"131":1,"132":1,"133":1,"134":1,"135":1,"136":1,"137":1,"138":1,"139":1,"140":1,"141":1,"142":1,"143":1,"144":1,"145":1,"146":1,"147":1,"197":1,"198":1,"199":1,"200":1,"201":1,"202":1,"203":1,"204":1,"205":1,"206":1,"207":1,"208":1,"209":1,"210":1,"211":1,"212":1,"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"996":1,"997":1},"2":{"12":1,"41":1,"43":2,"44":1,"76":3,"197":1,"210":1,"507":1,"513":1,"729":2,"861":1,"869":1,"921":1,"936":1,"995":1,"1011":1}}],["sf",{"2":{"1335":2,"1337":3,"1361":1}}],["sfc",{"2":{"709":1}}],["sfx",{"2":{"240":1,"242":4}}],["sky",{"0":{"1062":1},"2":{"1052":1,"1058":1,"1062":2,"1067":1,"1071":1}}],["skews",{"2":{"1387":1}}],["skewed",{"2":{"1233":1}}],["skewoffset",{"2":{"1030":3}}],["skew",{"0":{"1027":1},"1":{"1028":1,"1029":1,"1030":1},"2":{"1024":1,"1028":1,"1233":1,"1258":1}}],["skeletons",{"2":{"655":1}}],["sk",{"2":{"957":1,"997":2}}],["skipholidays",{"2":{"235":2,"236":1}}],["skipping",{"2":{"231":1,"1220":1,"1443":1}}],["skipped",{"2":{"109":1,"128":1}}],["skips",{"2":{"127":3,"699":1,"942":1,"1197":1,"1220":1,"1221":1}}],["skip",{"2":{"102":1,"198":1,"235":1,"377":1,"806":1,"962":1,"1234":1}}],["switches",{"2":{"1190":1}}],["switching",{"0":{"1089":1},"2":{"1368":1}}],["switch",{"2":{"473":1,"1081":1}}],["swap",{"2":{"644":1}}],["swaplayout",{"2":{"644":1}}],["swapped",{"2":{"475":1}}],["swaps",{"2":{"362":1,"642":1}}],["swallowing",{"2":{"358":1}}],["swallows",{"2":{"282":1}}],["sb",{"2":{"334":5,"335":4,"336":6,"543":6,"831":1}}],["src",{"0":{"1449":1},"1":{"1450":1,"1451":1,"1452":1},"2":{"232":1,"234":1,"642":1,"644":2}}],["src=",{"2":{"45":3,"850":3}}],["szn",{"0":{"304":1},"2":{"73":4,"87":1,"301":1,"304":2,"307":1,"309":1,"406":1,"519":1,"771":1,"775":3,"1181":1}}],["spy",{"2":{"1459":1}}],["spherical",{"2":{"1355":2,"1359":1,"1362":1}}],["spheres",{"2":{"389":1}}],["sphere",{"2":{"69":1,"73":2,"117":1,"119":1,"120":1,"121":2,"142":1,"144":1,"145":8,"154":2,"224":1,"226":1,"227":1,"281":1,"301":1,"302":1,"303":2,"304":2,"313":14,"315":1,"326":2,"364":1,"389":1,"519":1,"536":1,"649":1,"788":1,"824":1,"838":1,"849":1,"855":1,"870":1,"872":1,"878":1,"907":1,"919":1,"933":1,"937":2,"938":2,"1046":4,"1047":1,"1048":2,"1049":1,"1054":2,"1059":1,"1060":3,"1067":1,"1178":1,"1359":1,"1365":1}}],["sports",{"2":{"1213":1,"1259":1,"1391":1}}],["spot",{"2":{"993":2}}],["spikes",{"2":{"857":1,"867":1,"1233":2}}],["splits",{"2":{"1019":1,"1021":1}}],["split",{"2":{"402":2,"479":1,"550":1,"675":1,"752":1,"955":1}}],["spreadsheets",{"0":{"1134":1},"2":{"1123":1}}],["spreadsheet",{"2":{"1103":1,"1104":1,"1134":1}}],["spreading",{"2":{"1011":2}}],["spread",{"2":{"402":1,"410":1,"744":1,"1011":1}}],["sprints",{"2":{"324":1}}],["sprintterm",{"2":{"324":1}}],["sprint",{"2":{"323":1,"324":12,"773":1,"776":1,"879":1,"887":1,"889":1}}],["spring",{"2":{"87":1,"313":2,"326":3,"455":2,"456":2,"461":6,"469":2,"519":1,"1046":3,"1047":1,"1048":2,"1052":1,"1053":1,"1055":2,"1076":2,"1077":2,"1080":1,"1083":1,"1213":1}}],["spawnworkers",{"2":{"1389":1}}],["spawning",{"2":{"1041":1,"1085":1}}],["spain",{"2":{"1366":1}}],["spanning",{"2":{"1273":1,"1281":1,"1338":1}}],["spanish",{"2":{"219":2,"363":2}}],["spans",{"2":{"171":1,"180":1,"771":1,"774":1}}],["spas",{"2":{"116":1,"953":1}}],["space",{"0":{"690":1},"2":{"91":1,"138":7,"139":3,"359":1,"690":1,"707":3,"1041":1,"1090":4,"1131":1,"1141":1,"1362":1}}],["spatialsolaroffset",{"0":{"1352":1},"2":{"1345":1,"1352":1}}],["spatialvelocity",{"2":{"1345":1,"1360":1}}],["spatialbearing",{"2":{"1345":1,"1358":1}}],["spatialdistance",{"2":{"1345":1,"1357":1}}],["spatialplugin",{"2":{"88":2,"1335":2,"1337":2,"1341":3,"1347":2,"1352":2,"1357":2,"1358":2,"1359":2,"1360":2,"1361":2}}],["spatial",{"0":{"141":1,"823":1,"1333":1,"1334":1,"1336":1,"1339":1,"1344":1,"1352":1,"1353":1,"1355":1,"1358":1,"1359":1,"1360":1,"1361":1},"1":{"142":1,"143":1,"144":1,"145":1,"1334":1,"1335":2,"1336":1,"1337":2,"1338":2,"1340":1,"1341":1,"1342":1,"1343":1,"1344":1,"1345":2,"1346":1,"1347":1,"1348":1,"1349":1,"1356":1,"1357":1},"2":{"88":3,"364":1,"821":1,"823":1,"1162":1,"1333":2,"1335":3,"1337":3,"1338":1,"1339":2,"1340":1,"1341":2,"1342":1,"1343":1,"1344":8,"1347":4,"1348":2,"1350":1,"1352":4,"1353":3,"1354":2,"1357":3,"1358":2,"1359":2,"1360":3,"1361":3,"1362":2,"1363":4,"1364":3,"1365":5,"1366":3,"1391":1}}],["spectre",{"2":{"1375":1}}],["specs",{"2":{"1144":1,"1242":1}}],["speculative",{"0":{"946":1,"949":1},"2":{"871":1,"934":1,"937":1,"938":1,"946":1}}],["specialized",{"0":{"1024":1,"1105":1,"1320":1,"1383":1},"2":{"122":1,"138":2,"248":1,"271":1,"273":2,"319":1,"333":1,"474":1,"480":1,"501":1,"505":1,"531":1,"648":1,"1097":1,"1151":1}}],["specifying",{"2":{"164":1,"958":1,"1033":1,"1421":1}}],["specify",{"2":{"63":1,"125":1,"390":1,"396":1,"397":1,"932":1,"958":1,"1125":1,"1219":1}}],["specifier",{"2":{"651":1,"1041":1,"1125":1}}],["specifiers",{"0":{"1135":1},"2":{"43":1,"1104":4,"1108":1,"1124":1,"1135":1,"1144":1}}],["specifies",{"2":{"617":1,"955":1}}],["specified",{"2":{"109":1,"138":3,"262":1,"363":1,"750":1,"1125":1,"1168":1,"1182":1,"1318":1,"1345":1}}],["specificity",{"2":{"1141":1}}],["specifically",{"2":{"407":1,"506":1,"514":1,"565":1,"572":1,"1367":1}}],["specification",{"0":{"1123":1},"1":{"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":1,"1135":1,"1136":1},"2":{"137":1,"522":1,"1105":1,"1125":1}}],["specifications",{"2":{"78":1,"205":1,"1088":1}}],["specific",{"0":{"244":1,"519":1,"1048":1,"1133":1,"1457":1},"1":{"1134":1,"1135":1,"1136":1},"2":{"33":1,"46":1,"75":1,"77":1,"97":1,"100":1,"101":1,"106":1,"118":1,"125":1,"128":1,"129":1,"146":1,"158":1,"161":1,"164":1,"177":1,"182":1,"183":1,"194":1,"195":1,"219":1,"224":1,"231":1,"240":1,"260":1,"264":1,"266":1,"273":1,"278":1,"281":1,"287":1,"293":1,"297":2,"311":2,"313":1,"341":1,"350":1,"351":2,"353":1,"357":1,"376":1,"380":1,"390":1,"393":1,"398":1,"405":1,"406":1,"447":1,"455":1,"479":3,"509":1,"516":1,"518":1,"519":2,"526":1,"531":1,"561":1,"637":1,"695":1,"737":1,"754":1,"778":1,"845":1,"879":1,"891":1,"897":1,"915":1,"935":1,"955":1,"968":1,"978":1,"1004":1,"1052":1,"1061":1,"1078":1,"1082":1,"1086":1,"1105":1,"1166":1,"1189":1,"1199":1,"1343":1,"1364":1,"1401":1,"1454":1,"1457":1,"1458":1}}],["spell",{"2":{"363":1}}],["speedmph",{"2":{"1360":1}}],["speedkmh",{"2":{"1360":1}}],["speedups",{"2":{"795":1}}],["speed",{"0":{"1360":1},"2":{"407":2,"414":1,"416":1,"429":1,"446":1,"450":1,"451":1,"505":1,"649":1,"1042":1,"1106":1,"1140":1,"1344":1,"1348":2,"1360":4,"1361":1,"1363":3,"1382":1}}],["speedzero",{"2":{"204":1}}],["speeds",{"2":{"44":1,"93":1,"451":1,"1363":1}}],["sleep",{"0":{"1448":1},"2":{"1258":1,"1401":1,"1443":3,"1448":1}}],["slabusinessdays",{"2":{"1220":3}}],["slahours",{"2":{"1203":2}}],["slas",{"0":{"935":1},"2":{"879":1,"924":1,"925":1,"1218":1,"1219":1}}],["sla",{"0":{"1194":1,"1202":1,"1219":1},"1":{"1195":1,"1196":1,"1197":1,"1198":1,"1199":1,"1200":1,"1201":1,"1202":1,"1203":2,"1204":2,"1205":1,"1220":1},"2":{"533":1,"534":1,"930":1,"935":1,"937":1,"938":1,"959":1,"1194":1,"1203":1,"1206":1,"1207":1,"1209":1,"1210":2,"1218":1,"1219":2}}],["slate",{"2":{"422":1}}],["slight",{"2":{"469":1}}],["slightly",{"2":{"469":1,"505":1}}],["sliced",{"2":{"1090":1}}],["slice",{"2":{"138":1,"1039":1}}],["slices",{"2":{"138":4,"1029":1,"1039":2,"1040":2,"1266":1}}],["slicing",{"2":{"138":1}}],["slick",{"0":{"64":1,"191":1,"734":1,"739":1},"2":{"64":2,"185":2,"191":4,"378":1,"384":1,"705":1,"734":2,"735":1,"737":2,"738":1,"739":1}}],["sloppy",{"2":{"468":1}}],["slotend",{"2":{"1015":2}}],["slotstart",{"2":{"1015":2}}],["slots",{"2":{"402":3,"833":1,"987":1,"989":1,"1015":1,"1320":1}}],["slot",{"0":{"830":1,"1015":1},"2":{"111":1,"117":1,"176":1,"336":1,"402":2,"540":1,"541":1,"827":1,"831":1,"871":1,"919":2,"987":2,"989":2,"992":6,"993":5,"1015":1,"1325":4,"1326":6}}],["slows",{"2":{"1446":1}}],["slowly",{"2":{"1443":1}}],["slower",{"2":{"442":1,"505":1}}],["slow",{"2":{"43":1,"371":1,"934":1,"1444":1}}],["sdks",{"2":{"1191":1}}],["sdk",{"0":{"537":2,"840":2},"2":{"44":3,"232":1,"234":1,"265":1,"267":1,"271":1,"282":2,"285":2,"286":1,"312":1,"313":1,"319":1,"537":4,"775":2,"792":1,"835":1,"840":1}}],["snowflake",{"2":{"1099":1,"1103":2,"1104":1,"1123":1}}],["sniff",{"2":{"1240":2}}],["sniffing",{"2":{"712":1}}],["snippet",{"0":{"96":1,"238":1},"1":{"97":1},"2":{"64":1,"83":1,"85":1,"96":1,"97":1,"190":1,"191":1,"238":1,"240":1,"247":2,"466":1,"510":1,"525":1,"647":1,"891":1}}],["snippets",{"0":{"90":1,"240":1,"241":1},"1":{"241":1},"2":{"34":1,"89":1,"96":1,"97":1,"115":1,"117":1,"238":1,"239":1,"240":1,"247":1,"297":1,"348":1,"544":1,"659":1,"863":1}}],["snake",{"2":{"305":1}}],["snapkey",{"0":{"1319":1},"2":{"1318":1}}],["snapoptions",{"2":{"1318":1}}],["snapdown",{"2":{"1316":1}}],["snapup",{"2":{"1316":1}}],["snapms",{"2":{"1316":1}}],["snaphour",{"2":{"1316":1}}],["snapplugin",{"2":{"1316":2,"1326":2,"1329":2,"1332":2}}],["snapped",{"2":{"418":1,"1316":2}}],["snapping",{"0":{"1323":1,"1415":1},"1":{"1324":1,"1325":1,"1326":1},"2":{"190":1,"322":1,"323":1,"382":1,"418":2,"625":1,"771":3,"775":1,"817":1,"1055":1,"1315":1,"1316":1,"1320":1,"1332":1,"1415":1}}],["snapsecond",{"2":{"1316":1}}],["snaps",{"2":{"186":7,"190":2,"194":1,"368":4,"369":3,"380":1,"382":3,"773":1,"1315":1,"1316":1,"1319":6,"1415":1}}],["snapshots",{"2":{"936":1,"948":1,"1406":1,"1426":1}}],["snapshot",{"0":{"1427":2},"2":{"120":1,"429":1,"487":1,"864":1,"968":1,"1003":1,"1168":1,"1184":2,"1248":1,"1405":1,"1406":1,"1427":1}}],["snap",{"0":{"1315":1},"1":{"1316":1,"1317":1,"1318":1,"1319":1,"1320":1,"1321":1},"2":{"14":1,"185":1,"190":1,"192":2,"324":1,"556":1,"777":1,"1055":3,"1316":8,"1317":2,"1318":3,"1319":7,"1322":1,"1324":1,"1325":1,"1326":2,"1329":3,"1332":6,"1415":1}}],["sab",{"2":{"1376":1}}],["saint",{"2":{"1213":2}}],["saleend",{"2":{"1260":1}}],["sales",{"0":{"1259":1},"1":{"1260":1,"1261":1},"2":{"1259":1}}],["salesforce",{"2":{"1139":1}}],["salary",{"2":{"1222":1}}],["salt",{"2":{"1008":1}}],["salted",{"2":{"99":2,"954":1,"972":1,"1008":1}}],["sanfrancisco",{"2":{"1359":2}}],["sanjosepos",{"2":{"1335":2}}],["san",{"2":{"1335":3,"1361":1}}],["sanitization",{"0":{"1041":1},"2":{"996":1,"1001":1,"1011":1,"1041":1}}],["sanitizeexecargv",{"2":{"1021":1}}],["sanitizers",{"2":{"997":1}}],["sanitize",{"2":{"996":1}}],["sanitizes",{"2":{"936":1}}],["sanitized",{"2":{"864":1,"869":1,"871":1,"930":1,"953":1,"955":1,"998":1,"1003":1}}],["sanctioned",{"2":{"559":1}}],["sandboxtempo",{"2":{"831":1}}],["sandboxing",{"0":{"643":1}}],["sandboxes",{"2":{"335":1,"337":1,"341":1,"631":1,"782":1,"831":1}}],["sandboxed",{"2":{"116":2,"330":1,"335":1,"340":1,"588":1,"748":1,"833":1}}],["sandbox",{"0":{"328":1,"954":1,"1008":1},"1":{"329":1,"330":1,"331":1,"332":1,"333":1,"334":1,"335":1,"336":1,"337":1,"338":1,"339":1,"340":1,"341":1},"2":{"83":1,"89":1,"328":1,"330":1,"331":2,"332":5,"333":1,"334":1,"336":3,"338":1,"339":2,"340":2,"341":1,"402":1,"543":2,"631":2,"639":1,"640":1,"643":2,"741":1,"748":1,"780":1,"831":2,"833":3,"918":1,"929":1,"953":2,"954":7,"1008":2,"1378":2}}],["sacrifices",{"2":{"451":1}}],["saudi",{"2":{"365":1,"817":1,"1205":2}}],["sayhello",{"2":{"261":2}}],["saas",{"0":{"1190":1,"1219":1},"1":{"1220":1},"2":{"163":1,"165":1,"1004":1,"1035":1,"1139":1,"1166":1,"1210":1,"1218":1,"1219":1}}],["savings",{"2":{"972":1}}],["saving",{"2":{"156":1,"296":1,"377":1,"972":1,"1396":1,"1447":1}}],["saves",{"2":{"942":1}}],["save",{"2":{"76":1}}],["satisfies",{"2":{"945":1}}],["satisfy",{"2":{"124":1,"992":1}}],["sat",{"2":{"133":1,"137":1,"153":1,"393":1,"454":1,"1125":1,"1209":1,"1220":1}}],["saturday",{"2":{"71":5,"137":1,"153":1,"186":2,"365":3,"366":1,"367":1,"368":1,"370":2,"393":1,"786":1,"817":1,"880":1,"884":2,"1093":1,"1125":1,"1195":1,"1203":1,"1205":1,"1207":1,"1222":1}}],["safe",{"0":{"440":1},"2":{"291":1,"389":1,"404":1,"439":1,"440":1,"461":1,"465":1,"471":1,"472":1,"476":1,"481":1,"500":1,"503":2,"592":1,"614":1,"667":1,"687":1,"741":1,"857":1,"859":1,"910":1,"980":1,"997":1,"1083":1}}],["safestring",{"2":{"500":1,"501":1}}],["safest",{"2":{"232":1}}],["safely",{"2":{"146":2,"162":1,"189":1,"192":1,"202":1,"219":1,"275":1,"298":1,"367":1,"404":1,"406":1,"418":1,"427":1,"438":1,"466":1,"468":1,"470":1,"472":2,"473":1,"500":1,"504":2,"505":2,"690":1,"726":1,"782":1,"812":1,"856":1,"858":1,"913":1,"970":1,"997":1,"1041":1,"1136":1,"1167":1,"1264":1,"1374":1,"1422":1}}],["safer",{"2":{"114":1}}],["safety",{"0":{"276":1,"476":1,"494":1,"617":1,"644":1,"649":1,"657":1,"996":1,"1374":1,"1440":1},"1":{"495":1,"1441":1,"1442":1},"2":{"89":1,"107":1,"109":1,"181":1,"326":1,"367":1,"370":1,"402":1,"449":1,"456":1,"466":1,"471":1,"522":1,"644":1,"647":1,"649":2,"738":1,"752":1,"774":1,"972":1,"998":1,"1011":1,"1440":1,"1442":2}}],["safari",{"2":{"34":1}}],["same",{"2":{"76":1,"139":1,"158":1,"188":1,"191":1,"219":1,"225":1,"234":1,"250":1,"261":2,"300":1,"340":1,"387":1,"394":1,"406":2,"462":1,"856":1,"972":1,"1005":1,"1243":1,"1375":1,"1376":1,"1378":1,"1422":1,"1429":1}}],["samplerateseconds",{"2":{"1446":2}}],["sampledat",{"2":{"1446":2}}],["sampletimestampns",{"2":{"1395":2}}],["samplecount",{"2":{"1248":1,"1264":1}}],["samples",{"2":{"1233":1,"1234":1}}],["sampleepochs",{"2":{"1030":3}}],["sample",{"0":{"31":1},"2":{"1234":2,"1240":1,"1249":1,"1250":1,"1264":1,"1329":2,"1394":1}}],["sa",{"2":{"71":6,"884":1,"1205":8,"1207":1,"1213":1}}],["sibling",{"2":{"972":1}}],["siguiente",{"2":{"363":1}}],["sigil",{"2":{"325":1,"778":1}}],["signed",{"2":{"1310":2}}],["significant",{"2":{"575":1,"684":1}}],["significantly",{"2":{"44":1,"198":1,"647":1,"712":1,"722":1,"728":1,"995":1,"1088":1,"1120":1}}],["signals",{"0":{"1429":1},"2":{"1401":1,"1423":1,"1429":1}}],["signal",{"2":{"473":1,"493":1,"860":3,"955":4,"983":1,"1039":1,"1367":1,"1394":1,"1429":2}}],["signatures",{"0":{"332":1},"1":{"333":1,"334":1,"335":1},"2":{"456":1,"501":1,"505":1,"842":1}}],["signature",{"2":{"323":1,"836":1,"1021":1,"1140":1,"1141":1,"1425":1}}],["signs",{"2":{"230":1,"509":1,"1363":1}}],["sign",{"2":{"138":3,"157":1,"305":1,"307":1,"771":1,"775":1,"1091":1}}],["sixth",{"2":{"1271":3,"1276":1}}],["six",{"2":{"303":1,"867":1,"934":1,"963":1}}],["sit",{"2":{"301":1}}],["sites",{"2":{"666":1,"776":1,"1117":1,"1146":1,"1147":1}}],["site",{"0":{"1159":1,"1180":1},"2":{"288":1,"289":1,"290":1,"807":1,"816":1,"857":1,"926":1,"935":2,"978":1,"979":1,"1146":1,"1166":1}}],["simd",{"2":{"1033":1}}],["similar",{"2":{"524":1}}],["simulated",{"2":{"1419":1,"1439":1}}],["simulate",{"2":{"446":1,"1032":1,"1458":1}}],["simulating",{"2":{"442":1}}],["simulations",{"2":{"1391":1}}],["simulation",{"0":{"1390":1,"1458":1},"1":{"1391":1,"1392":1},"2":{"442":1,"446":1,"1032":1,"1033":1,"1391":2,"1392":3,"1419":1}}],["simultaneously",{"2":{"219":1,"489":1,"750":1,"769":1,"1117":1,"1429":1}}],["simplifies",{"2":{"644":1}}],["simplified",{"2":{"561":1,"648":1,"751":1,"836":1}}],["simplification",{"2":{"637":1}}],["simplify",{"2":{"474":1}}],["simply",{"2":{"44":1,"76":1,"138":1,"147":1,"229":1,"270":1,"355":1,"425":1,"451":1,"506":1,"555":1,"678":1,"728":1,"1091":1,"1093":1}}],["simple",{"0":{"392":1},"2":{"34":1,"45":1,"71":1,"147":1,"170":1,"385":1,"427":1,"445":1,"456":1,"513":1,"515":1,"518":1,"588":1,"765":1,"1178":1,"1218":1}}],["singapore",{"2":{"1063":2}}],["singletons",{"2":{"653":1}}],["singleton",{"2":{"92":1,"102":1,"653":1,"694":1}}],["single",{"0":{"402":1,"929":1,"1135":1,"1281":1},"2":{"10":1,"42":1,"45":1,"101":1,"102":1,"116":2,"191":1,"192":1,"219":1,"228":1,"263":1,"280":1,"289":1,"292":1,"301":1,"321":1,"402":2,"406":1,"416":1,"425":1,"427":1,"439":1,"489":1,"500":1,"563":1,"564":1,"642":1,"643":1,"653":1,"688":1,"722":1,"728":1,"750":1,"769":1,"812":1,"840":1,"919":1,"920":3,"929":1,"931":1,"937":2,"938":2,"947":1,"955":1,"972":3,"976":1,"1005":1,"1040":1,"1081":1,"1086":1,"1088":2,"1090":1,"1091":2,"1098":1,"1112":2,"1116":1,"1119":1,"1127":3,"1130":1,"1135":1,"1178":1,"1262":1,"1272":1,"1370":1,"1392":1,"1421":1,"1428":1,"1429":1}}],["since",{"0":{"66":1,"159":1,"774":1},"2":{"66":1,"138":1,"150":2,"154":1,"157":5,"159":5,"253":1,"317":1,"323":1,"380":1,"458":1,"520":3,"560":1,"709":1,"724":1,"771":1,"773":1,"774":1,"775":2,"1125":2,"1454":1}}],["silently",{"2":{"389":1,"503":1,"631":1,"709":1,"738":2,"856":1,"865":1,"875":1,"1088":1,"1098":1}}],["silent",{"2":{"56":1,"117":2,"281":1,"282":1,"300":1,"404":1,"429":1,"440":1,"649":1,"702":3,"709":1,"747":1,"1443":1}}],["sized",{"2":{"1039":1}}],["size",{"0":{"1064":1},"2":{"46":1,"198":1,"199":1,"229":1,"249":1,"260":1,"311":1,"505":1,"514":1,"665":1,"675":1,"722":1,"760":1,"829":1,"860":1,"982":2,"984":1,"986":1,"1033":1,"1041":1,"1064":1,"1121":1,"1278":1}}],["sizes",{"2":{"34":1,"672":1}}],["sidebar",{"2":{"479":1,"712":1}}],["side",{"0":{"258":1,"327":1,"678":1,"812":1,"858":1,"917":1,"956":1,"1020":1,"1056":1,"1102":1,"1154":1,"1165":1,"1193":1,"1241":1,"1317":1,"1342":1,"1380":1,"1400":1},"1":{"859":1,"860":1,"957":1,"958":1},"2":{"33":1,"83":1,"116":1,"146":2,"199":1,"250":1,"274":2,"276":1,"309":1,"327":1,"421":1,"479":1,"516":2,"527":1,"552":1,"559":1,"613":1,"649":1,"810":1,"812":1,"857":2,"858":1,"861":1,"913":2,"915":1,"931":2,"953":1,"955":2,"1001":1,"1005":4,"1008":2,"1168":1,"1375":1,"1450":2,"1459":1}}],["ssz",{"2":{"1135":1,"1140":1,"1141":1}}],["sss",{"2":{"1089":1,"1103":1,"1114":1,"1125":3}}],["ssssss",{"2":{"1125":3}}],["sssss",{"2":{"138":1}}],["ssrf",{"2":{"1001":1}}],["ssr",{"2":{"116":1,"751":2}}],["ss",{"2":{"30":1,"78":2,"117":1,"137":1,"138":9,"151":1,"154":1,"207":1,"208":1,"224":1,"240":1,"245":1,"247":1,"295":1,"719":1,"734":1,"806":1,"968":1,"969":1,"1069":2,"1088":2,"1089":3,"1101":1,"1103":5,"1104":2,"1111":1,"1114":2,"1115":3,"1116":2,"1118":1,"1125":4,"1130":1,"1134":2,"1135":3,"1140":1,"1141":1,"1144":1,"1147":2,"1149":1,"1150":4,"1243":1,"1254":1,"1255":1,"1265":2,"1316":1,"1319":2,"1329":3,"1344":1,"1352":1,"1404":1,"1408":1,"1413":2,"1417":1,"1420":2,"1422":1,"1424":2,"1434":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1}}],["s",{"0":{"704":1,"707":1,"711":1,"716":1,"719":1,"720":1,"722":1,"723":1,"728":1,"731":1,"734":1,"737":1,"741":1,"743":1,"746":1,"750":1,"754":1,"758":1,"1226":1,"1227":1},"1":{"1227":1,"1228":2,"1229":2,"1230":2,"1231":2,"1232":1,"1233":1,"1234":1,"1235":1},"2":{"24":1,"26":1,"30":1,"48":1,"75":1,"78":1,"102":1,"109":1,"110":1,"115":2,"117":3,"120":1,"122":1,"123":1,"131":2,"137":1,"138":4,"141":1,"146":2,"147":1,"158":1,"165":1,"181":1,"186":1,"191":1,"196":1,"197":1,"205":1,"213":1,"228":1,"229":2,"233":2,"237":1,"240":2,"247":1,"261":1,"265":2,"266":2,"268":1,"271":1,"274":1,"276":3,"281":3,"282":1,"300":1,"317":1,"318":1,"322":1,"329":1,"337":1,"342":1,"357":2,"359":1,"362":2,"365":1,"367":1,"370":6,"371":1,"374":1,"387":1,"388":1,"399":1,"418":1,"419":1,"446":1,"453":1,"461":1,"467":1,"469":1,"474":1,"503":2,"510":1,"516":1,"522":1,"525":1,"637":1,"708":1,"717":1,"719":1,"731":1,"737":1,"752":1,"755":1,"771":1,"806":1,"812":1,"817":1,"839":1,"860":1,"868":1,"874":1,"876":1,"885":1,"889":1,"907":1,"919":3,"927":1,"954":1,"993":2,"1012":1,"1047":2,"1054":1,"1060":1,"1062":1,"1063":1,"1064":1,"1065":1,"1067":1,"1068":2,"1069":1,"1075":1,"1081":1,"1086":2,"1087":1,"1089":3,"1091":1,"1093":2,"1094":1,"1101":1,"1103":3,"1104":2,"1106":1,"1115":1,"1116":2,"1125":5,"1129":1,"1134":2,"1135":1,"1144":3,"1147":1,"1149":1,"1150":1,"1157":1,"1158":2,"1173":1,"1188":3,"1190":2,"1192":1,"1205":1,"1213":15,"1217":1,"1219":2,"1220":2,"1222":2,"1223":1,"1224":1,"1226":2,"1236":1,"1262":1,"1263":1,"1265":1,"1266":1,"1278":1,"1319":1,"1345":2,"1351":1,"1371":1,"1374":1,"1436":1,"1445":1,"1449":1}}],["scholar",{"2":{"1272":1}}],["schema",{"0":{"865":1,"872":1,"882":1,"891":1,"900":1,"992":1,"1010":1},"2":{"865":1,"893":1,"922":1,"1010":1,"1012":1}}],["schemas",{"2":{"701":1,"865":1,"910":1,"954":1,"1008":1,"1010":1}}],["schematics",{"2":{"412":1,"414":1}}],["scheduleddateiso",{"2":{"1222":2}}],["scheduled",{"2":{"1222":2,"1242":1,"1253":1,"1417":1,"1421":1,"1427":1,"1442":1,"1443":1,"1445":1}}],["scheduledtime",{"2":{"1178":3}}],["scheduledstart",{"2":{"1013":2}}],["scheduleresult",{"2":{"1015":3}}],["schedulers",{"2":{"12":1}}],["scheduleeventinput",{"0":{"991":1},"2":{"989":1,"991":1}}],["scheduleairecurrenceai",{"2":{"920":1}}],["scheduleaitempo",{"2":{"919":1}}],["scheduleai",{"0":{"987":1},"1":{"988":1,"989":1,"990":1,"991":1,"992":1,"993":1},"2":{"910":1,"912":1,"936":1,"946":1,"987":1,"988":2,"993":1}}],["schedules",{"0":{"1255":1,"1447":1},"2":{"273":1,"763":1,"768":1,"985":2,"1255":1,"1396":1,"1401":1}}],["schedule",{"0":{"981":1},"1":{"982":1,"983":1,"984":1,"985":1,"986":1},"2":{"89":1,"204":1,"889":1,"913":1,"919":1,"946":1,"981":1,"983":1,"985":2,"986":2,"988":1,"1013":1,"1015":2,"1082":1,"1085":1,"1417":1,"1424":1,"1425":1}}],["scheduling",{"0":{"89":1,"1015":1,"1084":1,"1411":1},"1":{"1412":1,"1413":1,"1414":1,"1415":1,"1416":1,"1417":1,"1418":1,"1419":1,"1420":1,"1421":1,"1422":1},"2":{"89":2,"176":1,"229":1,"236":1,"531":1,"921":1,"950":1,"994":1,"1013":1,"1015":1,"1052":1,"1320":1,"1324":1,"1366":1,"1391":1,"1396":1,"1401":1,"1411":1,"1428":1,"1443":2,"1447":1}}],["sct",{"2":{"1213":1,"1214":1}}],["scotland",{"2":{"1213":1}}],["scores",{"2":{"936":1}}],["score",{"2":{"871":1,"881":1,"890":1,"891":2,"899":1,"900":1,"912":1,"945":1,"962":1,"986":1,"989":1}}],["scoping",{"0":{"1187":1},"2":{"831":1}}],["scopedoperation",{"2":{"486":1}}],["scoped",{"0":{"334":1,"543":1,"1047":1},"2":{"145":1,"331":1,"332":2,"334":1,"335":1,"402":1,"491":1,"536":1,"543":1,"831":2,"833":1,"846":1,"1193":1}}],["scopes",{"2":{"138":3,"315":2,"775":1}}],["scope",{"2":{"138":6,"301":3,"305":1,"307":4,"313":1,"315":2,"317":1,"320":1,"324":1,"326":5,"335":1,"361":1,"405":1,"406":1,"475":1,"486":1,"491":1,"539":1,"543":1,"561":2,"590":1,"637":2,"711":1,"1256":1,"1373":1,"1408":2,"1429":1,"1441":1,"1445":1}}],["scientific",{"2":{"511":1,"1377":1}}],["scenario",{"2":{"204":1}}],["scenarios",{"2":{"124":1,"161":1,"441":1,"594":1}}],["scenes",{"2":{"43":1}}],["scaffolding",{"0":{"741":1}}],["scaffolded",{"2":{"697":1}}],["scaffold",{"2":{"451":1,"741":2}}],["scale",{"0":{"1034":1},"1":{"1035":1,"1036":1},"2":{"411":1,"532":1,"1024":1}}],["scalars",{"2":{"536":1}}],["scalar",{"2":{"120":1}}],["scatter",{"2":{"402":1}}],["scattering",{"2":{"102":1}}],["scans",{"2":{"888":1}}],["scanned",{"2":{"538":1}}],["scanning",{"2":{"300":1,"407":1,"752":1}}],["scan",{"2":{"228":1,"377":1,"416":2,"444":1,"445":2,"978":1}}],["scrubbed",{"2":{"954":1,"997":1}}],["scratch",{"2":{"275":1,"528":1}}],["scratchpad",{"2":{"85":1}}],["screen",{"2":{"84":1,"85":1,"1331":1}}],["scripting",{"2":{"857":1}}],["scripts",{"2":{"114":1,"274":1,"590":1,"802":1,"810":1,"850":1,"1005":1,"1041":1}}],["script>",{"2":{"10":2,"42":2,"43":2,"44":1,"45":5,"850":5}}],["script",{"0":{"802":1},"2":{"10":2,"42":2,"43":2,"44":1,"45":4,"102":1,"111":1,"112":1,"137":1,"367":1,"370":1,"446":1,"451":1,"607":1,"651":1,"722":2,"800":1,"802":1,"850":5,"1147":1}}],["syslogformat",{"2":{"1150":2}}],["syslog",{"0":{"1142":1},"1":{"1143":1,"1144":1},"2":{"1103":1,"1105":1,"1143":2,"1144":1,"1149":1,"1150":1}}],["systematically",{"2":{"416":1}}],["systemnamespace",{"2":{"272":1}}],["systems",{"0":{"1094":1},"2":{"202":1,"361":1,"511":1,"852":1,"1026":1,"1037":1,"1080":1,"1081":2,"1082":1,"1088":1,"1103":1,"1108":1,"1218":1,"1303":1,"1324":1,"1363":1,"1385":1,"1443":1}}],["system",{"0":{"154":1,"629":1,"699":1},"2":{"100":1,"102":1,"117":3,"137":1,"202":1,"224":1,"272":1,"273":1,"278":2,"298":1,"300":1,"364":1,"370":1,"420":1,"423":1,"479":1,"507":1,"509":1,"519":1,"592":1,"612":1,"625":1,"671":1,"672":1,"699":3,"701":1,"716":1,"856":1,"869":1,"872":1,"884":1,"888":1,"890":1,"893":1,"902":1,"907":2,"911":1,"913":1,"922":1,"972":3,"1009":1,"1035":1,"1086":1,"1135":1,"1257":1,"1258":1,"1259":1,"1268":1,"1332":1,"1422":2,"1443":1,"1444":1}}],["syzygy",{"2":{"1052":1,"1055":1,"1074":1,"1076":2,"1083":1}}],["symfony",{"2":{"1103":1,"1123":1}}],["symmetry",{"0":{"765":1,"1089":1},"2":{"765":1,"1105":1}}],["symmetrical",{"2":{"1229":1,"1233":1}}],["symmetric",{"2":{"763":1}}],["sym",{"2":{"403":1,"421":1,"667":1}}],["symbolic",{"0":{"393":1},"2":{"738":1,"739":1}}],["symbols",{"2":{"7":2,"272":2,"322":2,"359":1,"393":1,"402":1,"404":1,"446":1,"631":1,"676":1,"773":2,"782":1,"1011":1}}],["symbol",{"0":{"271":1,"272":1,"422":1,"435":1,"486":1,"773":1},"1":{"272":1},"2":{"1":1,"6":1,"7":1,"101":1,"111":2,"112":1,"117":2,"129":1,"271":7,"272":3,"274":1,"304":1,"305":1,"322":1,"323":1,"326":2,"335":1,"336":3,"351":1,"355":1,"402":4,"403":2,"406":1,"410":1,"414":1,"420":1,"422":1,"435":2,"438":1,"439":1,"440":1,"468":1,"472":1,"475":1,"486":1,"491":2,"498":1,"500":2,"501":1,"543":1,"544":1,"621":1,"631":1,"644":2,"663":1,"667":1,"773":1,"775":1,"831":1,"833":4,"919":1,"985":1,"986":1,"998":1,"1129":1,"1256":2,"1373":1,"1405":3,"1432":2,"1435":1,"1446":4}}],["sydneyoffsethours",{"2":{"1352":2}}],["sydneyoffsetsec",{"2":{"1352":2}}],["sydneyoffsetmin",{"2":{"1352":2}}],["sydneybooking",{"2":{"1190":2}}],["sydneytime",{"2":{"1181":2,"1429":1}}],["sydney",{"2":{"52":1,"73":3,"102":1,"105":1,"110":1,"116":1,"121":1,"137":1,"138":1,"142":3,"144":3,"145":4,"149":1,"154":1,"197":2,"215":1,"226":1,"296":1,"687":1,"787":2,"870":2,"903":1,"927":1,"962":1,"1046":3,"1061":1,"1071":6,"1078":4,"1160":1,"1172":2,"1181":2,"1190":1,"1347":4,"1352":1,"1357":5,"1364":1,"1429":2,"1430":1}}],["synergy",{"0":{"1161":1},"2":{"1166":1}}],["synodic",{"2":{"775":1,"1052":1,"1054":1,"1055":1,"1058":1,"1059":1}}],["synonyms",{"2":{"138":1,"737":3}}],["synonym",{"2":{"137":1}}],["syntactic",{"2":{"147":1}}],["syntax",{"0":{"32":1,"1121":1,"1416":1},"1":{"1417":1},"2":{"24":1,"26":1,"30":1,"48":1,"54":1,"77":1,"288":1,"323":1,"378":1,"556":1,"731":1,"816":1,"842":1,"915":1,"1086":1,"1087":1,"1096":1,"1098":1,"1103":3,"1104":1,"1111":1,"1112":1,"1120":1,"1132":1,"1147":2,"1150":1,"1269":3,"1411":1,"1447":1}}],["syncloop",{"2":{"1448":3}}],["syncplugin",{"2":{"1379":2,"1389":2,"1392":2}}],["syncinterval",{"2":{"1239":1,"1240":1}}],["syncing",{"2":{"11":1,"318":1}}],["syncs",{"2":{"869":1}}],["synchronization",{"0":{"1156":1,"1190":1,"1393":1,"1428":1},"1":{"1157":1,"1158":1,"1159":1,"1160":1,"1161":1,"1394":1,"1395":1,"1429":1,"1430":1},"2":{"315":1,"420":1,"610":1,"1156":1,"1158":1,"1162":1,"1166":1,"1169":1,"1189":1,"1226":1,"1232":1,"1236":1,"1239":1,"1242":1,"1249":1,"1322":1,"1331":1,"1367":1,"1372":1,"1377":1,"1378":1,"1382":1,"1383":1,"1385":1,"1394":1,"1396":1}}],["synchronize",{"2":{"1014":1,"1190":1,"1241":1,"1448":1}}],["synchronizes",{"2":{"315":1,"649":1,"958":1}}],["synchronizedjob",{"2":{"1255":1}}],["synchronized",{"2":{"295":1,"402":1,"421":1,"617":1,"618":1,"683":1,"760":1,"1149":1,"1158":1,"1168":1,"1255":2,"1382":3,"1392":1,"1422":1}}],["synchronously",{"2":{"120":1,"414":1,"421":1,"477":1,"538":1,"856":1,"932":1,"1184":1,"1215":1,"1225":1,"1245":1,"1267":1,"1306":1,"1370":1,"1377":1,"1395":1}}],["synchronous",{"0":{"538":1,"839":1,"1225":1,"1433":1},"2":{"108":1,"334":1,"477":1,"538":1,"831":1,"835":1,"856":1,"933":2,"938":1,"974":1,"978":1,"1004":2,"1207":1,"1216":1,"1235":1,"1243":1,"1261":1,"1405":1}}],["sync",{"0":{"259":1,"310":1,"315":1,"420":1,"1158":1,"1246":1,"1377":1},"1":{"421":1,"422":1,"1159":1,"1378":1,"1379":1,"1380":1,"1381":1,"1382":1,"1383":1,"1384":1},"2":{"11":1,"14":1,"120":1,"421":1,"442":1,"477":1,"649":1,"946":1,"987":1,"988":1,"1158":1,"1168":1,"1234":1,"1239":2,"1240":1,"1241":1,"1243":2,"1254":2,"1257":1,"1261":1,"1262":1,"1367":1,"1368":1,"1371":1,"1372":1,"1373":1,"1378":2,"1379":2,"1380":2,"1381":1,"1382":4,"1385":1,"1389":3,"1392":1,"1395":1,"1418":1,"1422":1,"1428":1,"1448":2}}],["shōwa",{"2":{"1213":1}}],["sheets",{"0":{"1131":1},"2":{"1103":2,"1104":1,"1123":1,"1134":1}}],["sheet",{"0":{"1131":1},"2":{"1103":2,"1104":2,"1123":1,"1131":1,"1134":1}}],["shell",{"2":{"475":1,"957":1}}],["shutdowns",{"0":{"1224":1},"2":{"1224":1}}],["shutdown",{"2":{"974":1,"1389":1,"1404":1}}],["shields",{"2":{"709":1}}],["shield",{"0":{"433":1}}],["shiftticker",{"2":{"1415":1}}],["shifter",{"2":{"386":1}}],["shifters",{"0":{"386":1}}],["shiftedepochs",{"2":{"1033":2}}],["shifted",{"2":{"182":1,"183":1,"1028":1,"1032":1}}],["shifting",{"0":{"189":1,"193":1,"1415":1},"1":{"194":1,"195":1},"2":{"189":1,"195":1,"296":1,"313":1,"321":1,"381":1,"387":3,"389":1,"729":1,"894":1,"1415":1}}],["shift2",{"2":{"178":2,"180":2}}],["shift1",{"2":{"178":2,"180":2}}],["shift",{"2":{"146":1,"189":3,"192":1,"195":2,"205":1,"303":1,"351":1,"416":1,"531":1,"681":1,"1033":2,"1036":1,"1088":1,"1213":2}}],["shiftsimulationwindow",{"2":{"1033":1}}],["shifts",{"0":{"835":1},"2":{"138":2,"146":1,"184":1,"191":1,"575":1,"993":1,"1033":1,"1085":1,"1157":1,"1206":1,"1210":1,"1218":1,"1396":1,"1422":1}}],["shim",{"2":{"78":2,"205":1,"1147":1}}],["shims",{"0":{"1117":1},"1":{"1118":1,"1119":1},"2":{"78":1,"1099":1,"1104":1,"1147":2}}],["shipped",{"2":{"559":1}}],["shipping",{"0":{"1083":1},"2":{"34":1}}],["ships",{"2":{"345":1,"642":1,"1083":1}}],["ship",{"2":{"34":1}}],["shape",{"0":{"991":1},"2":{"954":1,"1008":1}}],["shapes",{"2":{"920":1}}],["sha",{"2":{"954":1,"1008":2}}],["shallow",{"2":{"738":1,"744":1,"1011":1,"1083":1}}],["shanghai",{"2":{"637":1}}],["shadows",{"2":{"1084":1}}],["shadowratio",{"2":{"1071":2}}],["shadow",{"2":{"298":1,"326":1,"418":1,"465":1,"1071":2}}],["shadowed",{"2":{"155":1}}],["shadowing",{"0":{"411":1},"1":{"412":1},"2":{"125":1,"406":2,"408":2,"411":1,"423":1,"441":1,"465":1,"621":1,"653":2}}],["sharing",{"2":{"83":1,"85":1,"418":1,"1395":1}}],["shareable",{"0":{"90":1},"2":{"90":1}}],["sharedbuffer",{"2":{"1392":2,"1395":2}}],["sharedarraybuffer",{"0":{"1037":1,"1039":1},"1":{"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1},"2":{"1018":1,"1024":2,"1029":2,"1038":2,"1039":2,"1040":1,"1367":1,"1368":1,"1369":1,"1370":1,"1375":1,"1376":2,"1377":1,"1378":2,"1379":1,"1382":2,"1383":1,"1388":1,"1392":1,"1395":1}}],["sharedopts",{"2":{"290":1}}],["shared",{"0":{"291":1,"401":1,"1368":1},"1":{"402":1,"1369":1,"1370":1},"2":{"89":1,"107":1,"114":1,"179":1,"290":2,"291":1,"292":1,"402":1,"406":2,"430":1,"440":1,"479":1,"606":1,"775":1,"855":1,"1003":1,"1018":1,"1029":1,"1038":1,"1039":4,"1115":1,"1178":1,"1185":2,"1187":1,"1263":1,"1368":1,"1373":1,"1381":1,"1382":3,"1388":1,"1389":1}}],["share",{"2":{"45":1,"89":2,"90":2,"176":1,"219":1,"402":2,"406":1,"1265":1}}],["shakable",{"2":{"147":1,"558":1}}],["shakeability",{"2":{"812":1}}],["shakeable",{"0":{"170":1,"915":1,"918":1},"1":{"916":1,"917":1,"918":1},"2":{"14":1,"269":2,"283":1,"515":1,"711":1,"915":1,"919":1,"1357":1}}],["shake",{"2":{"43":1}}],["shaking",{"2":{"12":1,"43":1,"168":1,"198":1,"274":1,"283":1,"672":1,"711":1,"812":1,"1450":1}}],["shot",{"0":{"1421":1},"2":{"1401":1,"1421":2}}],["shopify",{"2":{"1139":1}}],["show",{"2":{"645":1}}],["showing",{"2":{"128":1}}],["showcases",{"2":{"1137":1}}],["showcase",{"0":{"83":1,"84":1},"1":{"84":1,"85":1,"86":1,"87":1,"88":1,"89":1,"90":1,"91":1},"2":{"83":1,"84":1,"90":1,"609":1}}],["shown",{"2":{"38":1,"112":1}}],["shortest",{"2":{"1355":1,"1365":1}}],["shorter",{"2":{"208":1}}],["shortlatin",{"2":{"1271":1,"1280":2,"1307":1,"1310":1}}],["shortdate",{"2":{"1190":1,"1307":1}}],["shortdur",{"2":{"166":1}}],["shortcut",{"2":{"76":1,"563":1}}],["shortcuts",{"0":{"91":1},"2":{"43":1,"631":1,"771":1}}],["short",{"2":{"76":1,"137":2,"138":11,"153":2,"166":2,"201":1,"240":1,"301":2,"334":1,"370":2,"392":1,"477":3,"518":1,"606":1,"788":1,"859":1,"891":1,"1004":2,"1090":2,"1111":1,"1125":3,"1135":2}}],["shorthands",{"0":{"513":1},"2":{"138":2,"574":1,"771":1,"777":1}}],["shorthand",{"0":{"378":1,"379":1,"380":1,"381":1,"382":1,"719":1,"720":1,"735":1,"777":1,"929":1,"1413":1},"1":{"379":1,"380":2,"381":2,"382":2,"383":1,"384":1,"385":1,"386":1,"387":1,"388":1,"389":1},"2":{"64":2,"138":1,"181":1,"190":1,"191":2,"193":1,"195":1,"222":2,"378":1,"379":1,"388":1,"389":3,"556":1,"574":1,"639":1,"719":1,"720":2,"734":1,"737":2,"738":1,"757":4,"768":1,"777":1,"937":2,"938":2,"1023":1,"1412":2,"1413":1}}],["shouldstop",{"2":{"1434":1}}],["should",{"0":{"515":1,"1167":1},"2":{"1":1,"7":1,"44":1,"110":1,"116":1,"125":1,"230":1,"274":2,"281":2,"282":1,"321":1,"327":1,"367":1,"375":1,"522":1,"1082":1,"1088":1,"1178":1,"1263":1}}],["sh",{"2":{"10":1,"43":7,"83":1,"729":1}}],["st",{"2":{"1191":1,"1213":2}}],["stuffing",{"2":{"1363":1}}],["stutter",{"2":{"1234":1}}],["studying",{"2":{"1085":1}}],["studio",{"2":{"89":1}}],["stubs",{"2":{"614":1}}],["stolen",{"2":{"1363":1}}],["stock",{"2":{"1221":1,"1447":1}}],["stopping",{"2":{"1437":1}}],["stopped",{"2":{"1256":1,"1405":1,"1406":1,"1424":1,"1426":1,"1427":2,"1433":1,"1436":2,"1445":1}}],["stopper",{"2":{"493":3}}],["stops",{"2":{"1404":1,"1405":1,"1425":1,"1438":2,"1439":1}}],["stopclock",{"2":{"1382":1}}],["stop",{"0":{"1439":1,"1441":1},"2":{"485":1,"490":3,"509":1,"600":1,"1256":1,"1373":1,"1374":1,"1389":1,"1401":2,"1403":1,"1405":2,"1420":2,"1424":3,"1425":4,"1435":1,"1436":2,"1440":1,"1441":1,"1442":2}}],["storing",{"2":{"1185":1,"1328":1}}],["storage",{"0":{"866":1,"978":1,"1005":1,"1081":1,"1183":1,"1192":1,"1215":1},"1":{"1184":1,"1185":1,"1186":1,"1187":1,"1188":1,"1216":1,"1217":1},"2":{"101":1,"110":1,"117":1,"227":1,"504":2,"588":1,"653":1,"857":3,"913":2,"937":1,"938":1,"953":1,"978":2,"980":1,"1005":3,"1008":1,"1009":1,"1081":1,"1166":2,"1168":7,"1185":1,"1186":1,"1192":1,"1207":1,"1215":1}}],["storepos",{"2":{"1335":4}}],["stored",{"2":{"340":1,"402":1,"426":1,"913":1,"954":1,"1004":1,"1005":1,"1008":1,"1215":1}}],["stores",{"2":{"98":1,"294":1,"948":1,"1008":1,"1039":1}}],["store",{"2":{"28":1,"110":1,"117":1,"427":1,"857":1,"863":1,"971":1,"1011":1,"1335":2,"1368":1,"1369":3}}],["stealth",{"2":{"465":1}}],["steady",{"2":{"407":1,"419":2}}],["stepms",{"2":{"1332":2}}],["step3",{"2":{"1096":1}}],["stepsimulation",{"2":{"1392":1}}],["steps",{"2":{"357":1,"381":1,"514":1,"681":1,"688":1,"1255":1,"1419":1}}],["stepping",{"2":{"323":1,"773":1,"775":1,"1055":1,"1197":1,"1420":1}}],["step",{"2":{"22":2,"48":2,"62":1,"192":1,"195":1,"275":2,"321":1,"323":1,"324":2,"329":1,"351":2,"771":1,"773":1,"872":2,"882":2,"900":2,"1055":2,"1319":1,"1363":1,"1392":1,"1404":6}}],["styles",{"2":{"138":1,"193":1,"788":1,"922":1}}],["style",{"0":{"215":1,"1292":1},"1":{"216":1,"217":1,"218":1},"2":{"138":2,"159":1,"166":1,"211":1,"224":1,"507":1,"564":1,"572":2,"616":1,"633":1,"766":1,"816":1,"899":2,"904":1,"919":1,"1016":1}}],["styling",{"2":{"76":2,"138":2,"622":1,"666":1,"709":1,"1098":1}}],["stitch",{"2":{"522":1}}],["stick",{"2":{"191":1}}],["sticky",{"2":{"101":1,"110":1,"129":1}}],["still",{"2":{"102":1,"129":1,"146":1,"161":1,"220":1,"451":1,"565":1,"637":1,"782":1,"946":1,"975":1,"1157":1}}],["strange",{"2":{"468":1}}],["strategies",{"0":{"867":1},"1":{"868":1},"2":{"384":1,"405":1,"442":1,"754":1,"867":1,"924":1,"934":1,"963":1,"1032":1}}],["strategy",{"0":{"413":1,"415":1,"430":1,"514":1,"575":1,"940":1,"1086":1,"1087":1,"1122":1},"1":{"414":1,"416":1,"431":1,"432":1,"433":1,"434":1,"435":1,"436":1,"437":1,"438":1,"439":1,"440":1,"1087":1,"1088":2,"1089":2,"1090":2,"1091":2,"1092":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1098":1},"2":{"117":1,"298":1,"356":1,"414":1,"415":1,"450":1,"614":1,"722":1,"867":1,"871":1,"881":1,"890":1,"899":1,"937":1,"959":1,"989":1,"1011":1,"1032":1,"1105":1}}],["street",{"2":{"1167":1}}],["strengthened",{"2":{"621":1}}],["stress",{"2":{"448":1}}],["streammarketticks",{"2":{"1446":1}}],["streamclock",{"2":{"1409":1}}],["streamline",{"2":{"920":1}}],["streamlined",{"2":{"648":1,"672":1}}],["streamlining",{"2":{"719":1}}],["streamfrompromise",{"2":{"496":1}}],["streamfromarray",{"2":{"496":1}}],["stream",{"0":{"493":1,"497":1,"792":1,"1409":1,"1430":1},"2":{"473":7,"488":1,"489":11,"490":6,"491":2,"492":2,"493":5,"494":1,"495":1,"497":3,"790":1,"792":1,"1409":1,"1434":2,"1435":1}}],["streams",{"0":{"473":1,"488":1,"1423":1},"1":{"489":1,"490":1,"491":1,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1,"1424":1,"1425":1,"1426":1,"1427":1,"1428":1,"1429":1,"1430":1},"2":{"214":1,"473":3,"476":1,"496":1,"600":1,"683":1,"1315":1,"1396":1,"1401":1,"1446":1}}],["streaming",{"0":{"1435":1,"1446":1},"2":{"83":1,"792":2,"1042":1,"1401":1,"1405":1,"1434":1}}],["strongest",{"2":{"196":1}}],["strongly",{"2":{"34":1,"113":1,"416":1,"466":1,"857":1,"921":1,"1013":1}}],["str",{"0":{"501":1},"2":{"131":2,"1123":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1}}],["structural",{"0":{"382":1,"1040":1},"2":{"96":2,"185":1,"363":1,"379":1,"418":1,"423":1,"467":1,"469":1,"471":1,"726":1,"743":1,"1024":1,"1038":2,"1368":1}}],["structuredclone",{"2":{"472":1,"503":3}}],["structured",{"0":{"205":1,"786":1},"2":{"140":1,"146":1,"154":1,"203":1,"204":1,"205":2,"356":1,"367":1,"625":1,"784":1,"806":1,"864":1,"865":1,"888":1,"910":1,"912":1,"920":1,"936":1,"950":2,"973":2,"1011":1,"1047":1,"1143":1,"1276":1}}],["structures",{"2":{"97":1,"221":1,"298":1,"469":1,"470":1,"500":1,"766":1}}],["structure",{"0":{"1427":1,"1454":1},"2":{"76":1,"115":1,"125":1,"221":1,"559":1,"565":1,"642":1,"653":1,"751":1,"847":1}}],["strftime",{"0":{"1129":2,"1142":1},"1":{"1143":1,"1144":1},"2":{"78":1,"137":1,"205":1,"808":1,"1086":1,"1090":1,"1091":1,"1098":1,"1099":1,"1101":1,"1103":2,"1104":3,"1105":1,"1108":1,"1112":1,"1115":3,"1116":4,"1120":1,"1123":2,"1125":3,"1129":1,"1144":3,"1149":1,"1150":1}}],["strive",{"2":{"549":1}}],["strike",{"0":{"260":1}}],["stripe",{"2":{"1139":1}}],["strip",{"2":{"647":1,"778":1}}],["stripping",{"2":{"546":1}}],["stripped",{"2":{"125":1,"365":1,"367":1,"505":1,"738":1,"856":1,"1001":1,"1041":1}}],["strips",{"2":{"220":1,"503":1}}],["strictness",{"2":{"516":1}}],["stricter",{"2":{"170":1,"757":1}}],["strict",{"0":{"162":1,"394":1,"517":1,"520":1,"875":1},"2":{"24":1,"107":1,"117":1,"146":1,"161":1,"163":1,"168":1,"186":1,"198":2,"227":1,"270":1,"271":1,"281":2,"283":1,"296":1,"326":1,"358":1,"367":1,"368":1,"369":1,"370":1,"393":2,"394":1,"402":1,"407":1,"418":2,"421":1,"423":1,"450":2,"453":1,"507":4,"510":1,"517":1,"524":1,"535":1,"573":1,"606":1,"616":1,"649":1,"709":1,"711":1,"712":2,"720":1,"744":1,"747":1,"755":1,"757":1,"763":1,"775":1,"861":1,"865":1,"866":1,"910":3,"954":1,"966":1,"972":1,"979":1,"993":1,"1000":1,"1008":3,"1010":1,"1012":1,"1041":1,"1173":1,"1178":1,"1186":1,"1218":1,"1263":1,"1375":1,"1394":1,"1450":1,"1458":1}}],["strictly",{"2":{"7":1,"102":1,"109":1,"120":1,"137":1,"146":1,"170":1,"181":1,"191":1,"196":1,"202":1,"205":1,"220":1,"227":1,"233":1,"274":1,"325":1,"361":1,"370":1,"383":2,"393":2,"394":1,"409":1,"412":2,"414":1,"416":2,"419":1,"423":1,"424":1,"469":1,"519":1,"520":1,"541":1,"571":1,"616":1,"702":1,"717":1,"778":1,"825":1,"830":1,"832":1,"833":1,"856":2,"862":1,"1009":1,"1080":1,"1088":2,"1093":2,"1097":1,"1098":1,"1136":1,"1143":1,"1319":1,"1392":1,"1438":1,"1452":1}}],["stringification",{"2":{"503":1}}],["stringified",{"2":{"501":1,"504":1}}],["stringifying",{"2":{"468":1}}],["stringify",{"0":{"472":1,"498":1,"500":1},"1":{"499":1,"500":1,"501":1,"502":1,"503":1,"504":1,"505":1},"2":{"300":1,"403":1,"429":1,"465":1,"472":3,"498":1,"500":2,"501":1,"502":1,"503":3,"505":2,"691":1,"860":4,"955":1,"1265":1,"1444":1}}],["string>",{"2":{"481":1,"483":1,"489":1,"792":1,"938":6,"978":1,"1014":1,"1016":1}}],["strings",{"0":{"59":1,"1417":1},"2":{"66":1,"76":1,"96":1,"125":2,"130":1,"131":1,"132":2,"140":2,"157":1,"169":1,"181":1,"201":2,"208":1,"211":1,"216":1,"221":1,"239":1,"240":1,"243":3,"247":1,"359":1,"361":1,"363":1,"445":1,"449":1,"450":3,"454":1,"503":1,"505":1,"513":1,"517":2,"520":2,"525":1,"606":1,"637":1,"649":1,"679":1,"680":1,"690":1,"699":1,"707":1,"716":2,"734":1,"738":1,"750":1,"754":1,"757":1,"758":1,"763":1,"766":1,"788":1,"806":1,"823":1,"877":1,"879":1,"903":1,"950":2,"951":1,"972":3,"981":1,"996":1,"997":1,"1014":2,"1016":1,"1023":1,"1089":1,"1091":1,"1104":2,"1109":1,"1112":1,"1114":1,"1122":2,"1131":1,"1135":1,"1139":1,"1149":1,"1418":1}}],["string",{"0":{"153":1,"194":1,"380":1,"1245":1,"1246":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1},"2":{"11":1,"31":1,"32":1,"47":1,"64":1,"69":3,"75":1,"76":2,"96":2,"102":1,"115":5,"117":13,"119":3,"124":1,"125":1,"127":1,"138":11,"139":1,"144":1,"147":1,"150":2,"153":4,"154":6,"157":1,"158":7,"159":3,"165":1,"191":1,"194":1,"202":2,"215":1,"216":2,"219":1,"222":2,"223":1,"228":1,"239":1,"245":2,"246":1,"251":1,"256":1,"261":2,"285":1,"294":1,"297":1,"301":1,"313":1,"315":2,"323":8,"326":2,"351":1,"354":1,"355":2,"357":2,"358":1,"359":5,"361":1,"362":1,"370":1,"375":1,"379":1,"389":1,"394":1,"398":1,"407":1,"415":1,"416":1,"445":2,"446":1,"448":1,"455":2,"469":1,"484":1,"500":1,"503":1,"505":1,"510":1,"517":2,"518":1,"520":2,"571":1,"593":1,"610":1,"640":1,"647":1,"734":1,"750":3,"758":1,"769":1,"774":1,"807":1,"829":1,"830":1,"832":2,"860":2,"867":1,"872":5,"876":1,"881":5,"882":4,"890":6,"891":4,"899":5,"900":4,"910":1,"919":5,"933":1,"937":18,"938":16,"959":9,"972":1,"973":1,"976":2,"984":1,"986":5,"989":1,"991":2,"992":2,"1004":3,"1011":1,"1013":2,"1014":1,"1015":2,"1016":1,"1021":1,"1030":2,"1081":1,"1082":1,"1083":2,"1084":1,"1085":1,"1088":1,"1104":17,"1114":3,"1125":1,"1141":1,"1143":1,"1144":2,"1147":3,"1158":1,"1167":1,"1168":1,"1176":6,"1178":1,"1190":4,"1192":2,"1220":5,"1221":4,"1222":2,"1223":5,"1240":6,"1265":2,"1289":1,"1290":1,"1304":3,"1307":2,"1326":1,"1329":6,"1363":2,"1389":2,"1403":1,"1404":6,"1417":1,"1421":1,"1427":4,"1444":1,"1445":1,"1446":3,"1452":2}}],["stamp",{"2":{"1395":1}}],["stalling",{"2":{"942":1}}],["stale",{"2":{"634":1}}],["staggered",{"2":{"934":2,"940":1,"1387":1}}],["stages",{"2":{"101":1}}],["stage",{"2":{"12":1,"34":1,"412":3,"506":1,"1147":7}}],["stakes",{"2":{"867":1,"950":1}}],["stay",{"2":{"735":1}}],["stays",{"2":{"437":2,"466":1}}],["stable",{"2":{"407":1,"409":1,"515":1}}],["stabilization",{"0":{"616":1,"625":1,"663":1},"2":{"634":1}}],["stabilize",{"2":{"617":1}}],["stabilizes",{"2":{"444":1}}],["stabilized",{"2":{"39":1,"667":1,"683":1,"751":1}}],["stability",{"0":{"573":1,"702":1,"709":1},"2":{"34":1,"47":1,"406":1,"423":1,"574":1,"629":1,"631":1,"654":1,"674":1,"679":1,"1041":1}}],["stashed",{"2":{"1168":2,"1182":1}}],["stashes",{"2":{"1168":1}}],["stashing",{"0":{"1184":1},"2":{"503":1}}],["stash",{"2":{"266":2,"1168":1,"1186":2,"1192":3}}],["standby",{"2":{"1081":3}}],["standout",{"2":{"464":1}}],["standalone",{"0":{"131":1,"197":1,"198":1,"199":1,"283":1,"557":1,"558":1,"918":1,"1049":1,"1095":1},"1":{"132":1,"198":1,"199":1,"558":1,"559":1},"2":{"131":2,"147":1,"197":1,"198":3,"199":2,"283":2,"289":1,"479":1,"547":1,"548":1,"557":1,"559":1,"647":1,"659":1,"757":1,"918":1,"919":2,"1041":1,"1168":1}}],["standardizing",{"2":{"278":1,"294":1,"1098":1}}],["standardization",{"0":{"842":1},"2":{"227":1,"625":1}}],["standardizes",{"2":{"139":1}}],["standardized",{"0":{"840":1},"2":{"24":1,"522":1,"535":1,"537":1,"667":1,"669":1,"671":1,"692":1,"709":1,"832":1,"835":1,"840":1,"842":1,"1080":1}}],["standard",{"0":{"42":1,"258":1,"274":1,"309":1,"775":1,"1135":1,"1337":1,"1416":1},"1":{"1417":1},"2":{"10":1,"30":1,"41":1,"43":1,"71":1,"88":1,"89":1,"93":1,"106":1,"116":1,"124":1,"129":1,"130":1,"138":1,"139":1,"140":1,"144":1,"150":1,"154":1,"157":1,"169":1,"198":1,"206":1,"221":1,"223":1,"235":1,"243":1,"247":1,"251":2,"258":1,"260":1,"267":1,"272":1,"273":1,"276":2,"282":1,"284":1,"298":1,"306":1,"308":1,"311":1,"317":1,"325":2,"333":1,"357":1,"359":1,"361":1,"365":2,"367":1,"370":1,"403":2,"407":1,"408":1,"424":1,"427":1,"431":1,"453":1,"461":1,"468":3,"471":1,"489":1,"491":1,"498":2,"500":1,"504":1,"505":2,"516":1,"519":2,"541":1,"546":1,"637":1,"648":1,"657":1,"690":1,"711":1,"723":1,"737":1,"750":1,"758":1,"767":1,"771":3,"775":3,"778":1,"787":1,"792":1,"806":1,"812":1,"846":1,"853":1,"854":1,"869":1,"884":1,"908":1,"909":1,"919":1,"925":1,"945":1,"951":1,"957":1,"958":1,"966":1,"975":1,"986":1,"1014":2,"1023":1,"1040":2,"1076":1,"1088":1,"1093":2,"1094":2,"1097":1,"1098":3,"1108":1,"1110":1,"1125":4,"1131":1,"1135":1,"1139":1,"1141":1,"1160":1,"1205":1,"1219":1,"1220":1,"1222":1,"1225":1,"1232":2,"1259":1,"1262":1,"1313":1,"1315":1,"1351":3,"1366":1,"1367":1,"1404":2,"1411":1,"1416":1,"1422":1,"1432":1,"1443":2,"1447":1,"1448":1}}],["standards",{"0":{"7":1,"1125":1},"2":{"34":1,"102":1,"137":1,"205":1,"293":1,"326":1,"572":1,"655":1,"861":1,"1099":1,"1136":1,"1143":1}}],["standups",{"2":{"988":1}}],["standup",{"2":{"105":1,"859":1,"988":2,"1418":1}}],["stack",{"0":{"841":1},"2":{"76":1}}],["starvation",{"2":{"1443":1}}],["stars",{"2":{"1067":2}}],["stardate",{"2":{"243":3}}],["star",{"2":{"31":1,"32":1}}],["starttelemetryemitter",{"2":{"1444":1}}],["startclock",{"2":{"1373":1,"1379":1,"1380":1,"1382":1,"1389":1}}],["starthour",{"2":{"1204":1,"1220":1}}],["startidx",{"2":{"1039":1}}],["starting",{"2":{"131":1,"138":1,"322":1,"947":1,"983":1,"1270":1,"1404":1}}],["startdateiso",{"2":{"1223":2}}],["startdate",{"2":{"950":1,"1223":1}}],["startswith",{"2":{"955":1,"1263":1}}],["starts",{"2":{"306":1,"1372":1,"1382":1,"1419":1}}],["startmonth",{"2":{"265":3,"266":2,"267":1,"270":4,"317":3}}],["startof",{"2":{"181":1,"1319":2}}],["startns",{"0":{"174":1},"2":{"174":1}}],["start=0",{"2":{"138":1}}],["startup",{"2":{"116":1,"250":1,"262":5,"276":2,"588":1,"741":1,"839":1,"955":1,"1388":1}}],["started",{"2":{"13":1,"385":1,"712":1,"1415":1}}],["start",{"0":{"9":1,"63":1,"173":1,"190":1},"2":{"15":1,"63":2,"89":1,"95":1,"117":1,"137":1,"138":1,"167":1,"171":1,"177":1,"185":2,"186":5,"190":3,"192":1,"194":2,"214":1,"266":1,"268":1,"301":1,"318":1,"319":1,"320":2,"323":2,"324":3,"365":2,"368":3,"369":3,"380":3,"381":1,"382":3,"385":1,"388":1,"515":2,"556":2,"648":1,"680":1,"682":2,"739":4,"771":1,"773":2,"777":4,"817":3,"842":2,"879":1,"880":2,"882":2,"886":1,"887":2,"889":2,"891":2,"894":2,"919":2,"974":3,"977":1,"988":3,"990":1,"991":2,"992":2,"1015":3,"1047":2,"1055":3,"1082":1,"1097":1,"1197":2,"1201":3,"1209":2,"1223":3,"1254":1,"1325":2,"1326":6,"1379":1,"1415":1,"1422":1}}],["statute",{"2":{"1356":1}}],["statutory",{"2":{"1213":2,"1215":1,"1218":1,"1219":1,"1223":1,"1224":1}}],["status",{"2":{"135":1,"210":1,"407":1,"463":4,"487":2,"497":1,"836":1,"860":8,"955":6,"969":1,"1039":1,"1298":1,"1427":1,"1436":1,"1445":1}}],["stats",{"2":{"969":7}}],["statistical",{"0":{"1233":1},"2":{"1226":1,"1242":1}}],["statistics",{"2":{"497":1}}],["statically",{"2":{"168":1}}],["static",{"0":{"44":1,"343":1,"458":1,"461":1,"478":1,"496":1,"677":1,"825":1,"974":1,"1119":1,"1178":1,"1216":1,"1406":1},"1":{"344":1,"345":1,"346":1,"347":1,"348":1},"2":{"12":1,"41":1,"44":3,"92":1,"93":1,"94":2,"95":2,"96":2,"99":1,"109":1,"111":1,"112":1,"148":1,"223":1,"230":1,"246":1,"253":1,"261":1,"262":1,"265":1,"268":1,"273":1,"276":2,"295":1,"301":1,"307":1,"316":1,"326":1,"332":3,"340":1,"343":1,"347":1,"410":1,"426":1,"457":1,"461":1,"463":1,"471":1,"477":2,"478":2,"536":1,"541":1,"596":1,"625":1,"643":1,"664":1,"668":1,"677":1,"729":2,"771":1,"776":1,"787":1,"825":1,"829":1,"836":1,"839":2,"843":1,"869":1,"911":1,"916":1,"937":4,"938":5,"974":3,"1004":1,"1021":2,"1033":1,"1081":1,"1098":1,"1104":8,"1106":1,"1113":1,"1144":2,"1153":1,"1164":1,"1287":1,"1341":1,"1357":1,"1376":1,"1378":1,"1426":1}}],["stateful",{"0":{"983":1}}],["statement",{"0":{"1028":1,"1032":1,"1035":1,"1139":1,"1143":1,"1146":1,"1149":1,"1324":1,"1328":1,"1331":1,"1387":1,"1391":1,"1394":1},"2":{"812":1}}],["stated",{"2":{"514":1}}],["states",{"0":{"1067":1,"1076":1},"2":{"362":1,"402":1,"440":1,"1053":1,"1067":1,"1072":1,"1083":1,"1213":1}}],["stateless",{"2":{"199":1}}],["state",{"0":{"425":1,"487":1,"497":1,"667":1,"969":1,"1076":1},"2":{"6":1,"7":2,"115":1,"116":2,"120":3,"155":2,"199":1,"251":1,"266":1,"302":1,"327":2,"329":1,"330":2,"331":1,"336":1,"340":1,"343":1,"349":1,"377":1,"402":1,"403":1,"405":1,"406":1,"407":1,"408":1,"410":1,"412":1,"413":1,"414":1,"419":2,"422":1,"423":1,"425":1,"427":1,"429":1,"431":1,"439":2,"440":1,"473":1,"475":1,"481":2,"487":2,"497":2,"504":1,"543":1,"580":1,"612":1,"613":1,"643":2,"649":3,"663":1,"667":3,"717":2,"760":1,"776":1,"782":1,"831":1,"833":2,"838":1,"855":1,"856":1,"968":1,"1004":2,"1054":1,"1055":1,"1066":1,"1067":1,"1074":1,"1075":1,"1076":1,"1083":1,"1210":1,"1213":3,"1214":2,"1248":1,"1250":1,"1405":1,"1446":1,"1448":1,"1454":1}}],["sum",{"2":{"1329":2}}],["summarize",{"2":{"887":1}}],["summarizing",{"2":{"470":1,"882":1}}],["summaries",{"0":{"1016":1},"2":{"879":1,"897":1,"1016":1}}],["summary",{"0":{"129":1,"423":1,"428":1,"442":1,"920":1,"1098":1},"2":{"128":1,"763":1,"771":1,"891":1,"982":2,"986":2}}],["summernorth",{"2":{"1046":5}}],["summer",{"2":{"73":2,"155":1,"296":1,"304":2,"313":2,"326":2,"455":2,"456":2,"461":2,"519":1,"775":1,"1046":8,"1048":1,"1072":1,"1213":2,"1220":1,"1366":1}}],["suffers",{"2":{"1368":1}}],["suffer",{"2":{"1258":1}}],["suffixes",{"0":{"397":1,"398":1},"2":{"754":1}}],["suffix",{"2":{"138":1,"240":1,"274":2,"397":1,"737":1,"746":1,"910":1,"997":1,"1090":1,"1113":1,"1125":1}}],["surrounding",{"2":{"1095":1}}],["surveytime",{"2":{"1085":2}}],["surveying",{"0":{"1084":1}}],["surfacing",{"2":{"404":1}}],["surface",{"0":{"1021":1,"1104":1,"1168":1,"1318":1,"1344":1,"1382":1,"1402":1},"1":{"1022":1,"1023":1,"1169":1,"1319":1,"1345":1,"1403":1,"1404":1,"1405":1,"1406":1},"2":{"152":1,"527":1,"562":1,"841":1,"936":1,"942":1,"1042":1,"1095":1,"1314":1,"1355":1}}],["surgical",{"0":{"260":1,"311":1}}],["suitable",{"2":{"1225":1}}],["suites",{"2":{"116":1}}],["suite",{"0":{"461":1,"1453":1},"1":{"1454":1,"1455":1,"1456":1,"1457":1,"1458":1,"1459":1},"2":{"6":1,"8":1,"263":1,"422":1,"461":1,"472":1,"498":1,"573":1,"635":1,"669":1,"723":1,"1431":1,"1453":1,"1459":1}}],["suivant",{"2":{"222":1,"737":1}}],["sunaltitude",{"2":{"1084":2}}],["sunlight",{"2":{"1071":1}}],["sundial",{"2":{"1069":1}}],["sunday=0",{"2":{"138":1}}],["sunday",{"2":{"71":3,"138":1,"186":5,"190":1,"233":1,"365":3,"366":1,"367":2,"368":1,"369":1,"370":2,"392":1,"395":1,"786":1,"817":1,"884":1,"908":1,"1093":1,"1158":1,"1195":1,"1203":1,"1205":4,"1219":1}}],["sunrise",{"2":{"1053":1,"1054":1,"1055":4,"1070":1,"1072":3,"1073":2,"1082":1}}],["sunset",{"2":{"507":1,"514":1,"515":1,"1053":1,"1054":1,"1070":1,"1072":2,"1073":2,"1082":2}}],["sun",{"0":{"1067":1,"1072":1},"2":{"152":1,"240":1,"304":1,"392":1,"454":1,"1045":1,"1050":1,"1054":1,"1055":2,"1056":1,"1067":4,"1068":1,"1069":1,"1071":1,"1072":3,"1075":1,"1076":1,"1081":2,"1209":1,"1220":1,"1366":1}}],["suggestions",{"2":{"922":1}}],["suggested",{"2":{"22":1}}],["sugar",{"2":{"147":1}}],["sud",{"2":{"145":7}}],["supermoons",{"0":{"1064":1},"2":{"1080":1}}],["supermoon",{"2":{"1058":1,"1064":1}}],["superadmin",{"2":{"464":2}}],["supersedes",{"2":{"152":3,"732":1}}],["superseded",{"2":{"138":1,"757":1}}],["suppressed",{"2":{"1459":1}}],["suppresses",{"2":{"117":1,"702":1}}],["suppression",{"0":{"893":1},"2":{"531":1,"1459":2}}],["supplemental",{"0":{"1082":1},"2":{"1052":1,"1082":1}}],["supply",{"2":{"226":1,"243":1,"806":1,"825":1,"853":1,"854":1,"885":1,"931":1,"1009":1,"1054":1}}],["supplying",{"2":{"123":1,"291":1,"746":1,"830":1,"1420":1}}],["supplies",{"2":{"1004":1}}],["suppliers",{"0":{"933":1},"2":{"69":2,"119":1,"120":2,"477":3,"838":1,"855":1,"1004":2}}],["supplier",{"0":{"536":1},"2":{"69":1,"117":4,"119":1,"477":3,"536":1,"855":1,"933":2,"953":1,"958":1,"1004":1}}],["supplied",{"2":{"34":1,"477":1,"884":1,"912":1,"1054":1,"1061":1,"1078":1,"1079":1,"1263":1}}],["supporting",{"2":{"335":1,"668":1,"688":1,"831":1,"852":1,"863":1,"1424":1}}],["supports",{"2":{"109":1,"119":1,"138":2,"170":1,"198":1,"202":1,"203":1,"209":1,"211":1,"213":1,"288":1,"292":1,"331":1,"332":1,"418":1,"437":1,"694":1,"723":1,"731":1,"750":1,"823":1,"853":1,"933":1,"934":1,"963":1,"1093":1,"1168":1,"1224":1,"1254":1,"1263":1,"1411":1,"1418":1,"1447":1}}],["supported",{"0":{"19":1,"132":1,"137":1,"201":1,"376":1,"391":1,"1023":1,"1103":1,"1213":1,"1319":1,"1356":1,"1413":1},"1":{"138":1,"139":1,"140":1,"392":1,"393":1,"394":1,"395":1,"396":1,"397":1},"2":{"19":1,"89":1,"138":2,"190":1,"290":1,"291":2,"367":1,"559":1,"572":1,"637":1,"689":1,"732":1,"734":1,"735":1,"786":1,"816":1,"842":1,"1116":1,"1124":1,"1376":1,"1378":1}}],["support",{"0":{"15":1,"533":1,"645":1,"688":1,"1338":1},"2":{"3":2,"8":1,"10":2,"11":1,"12":1,"34":3,"37":1,"76":1,"125":1,"137":1,"171":1,"181":1,"187":1,"199":1,"205":1,"206":1,"210":1,"218":1,"253":1,"254":1,"255":1,"257":1,"283":1,"287":1,"365":1,"461":1,"475":1,"479":1,"514":2,"515":1,"519":1,"533":1,"534":1,"559":1,"578":1,"592":1,"606":1,"609":1,"612":1,"617":1,"620":2,"633":1,"639":1,"642":2,"659":1,"673":1,"678":1,"684":1,"691":1,"696":1,"707":2,"719":1,"720":1,"729":1,"732":1,"735":1,"746":1,"755":1,"757":1,"763":1,"775":2,"782":1,"784":1,"788":1,"800":1,"802":1,"819":1,"829":2,"831":1,"836":1,"838":1,"953":1,"978":1,"1004":1,"1013":1,"1136":1,"1192":1,"1218":1,"1219":1,"1344":1,"1376":1,"1405":1,"1454":1,"1459":1}}],["succeeds",{"2":{"934":2,"945":1,"1104":1,"1119":1}}],["succeed",{"2":{"498":1}}],["successive",{"2":{"1079":1}}],["successrate",{"2":{"449":1}}],["success",{"2":{"199":1,"333":1,"419":1,"450":1,"451":1,"481":1}}],["successfully",{"2":{"220":1,"351":1,"407":1,"416":1,"449":1,"626":1,"668":1,"993":1,"1249":1}}],["successful",{"2":{"93":1,"949":1,"1182":1}}],["such",{"2":{"24":1,"116":1,"119":1,"137":1,"138":1,"141":1,"202":1,"205":2,"213":1,"214":1,"243":1,"261":1,"361":1,"365":1,"366":1,"404":1,"457":1,"479":1,"522":1,"526":1,"531":1,"690":1,"702":1,"746":1,"763":1,"771":1,"776":1,"802":1,"823":1,"845":1,"858":1,"862":1,"888":1,"895":1,"904":1,"936":1,"972":1,"994":1,"1010":1,"1013":1,"1015":1,"1041":1,"1072":1,"1080":1,"1085":1,"1095":1,"1134":2,"1143":1,"1175":1,"1218":1,"1219":1,"1271":1,"1303":1,"1366":1,"1367":1}}],["suburb",{"2":{"1178":2}}],["subject",{"2":{"966":1}}],["subclasses",{"2":{"831":1}}],["subclass",{"2":{"643":1}}],["subsidized",{"2":{"1008":1}}],["substring",{"2":{"1293":1}}],["substrings",{"2":{"806":1}}],["substitute",{"2":{"1213":1}}],["substitution",{"2":{"592":1}}],["substantially",{"2":{"699":1}}],["subscribe",{"2":{"792":1}}],["subscribes",{"2":{"489":1}}],["subscribers",{"2":{"473":1,"497":1,"792":1}}],["subscription",{"2":{"473":1,"491":1,"600":1,"792":1}}],["subscriptions",{"0":{"490":1},"1":{"491":1},"2":{"473":1}}],["subseconds",{"2":{"1125":1}}],["subset",{"2":{"314":1}}],["subsequent",{"2":{"120":1,"148":1,"262":1,"300":1,"327":1,"393":2,"427":1,"894":1,"934":1,"948":1,"955":1,"1106":1,"1184":1,"1215":1,"1216":1,"1417":1,"1441":1,"1444":1}}],["subsystems",{"2":{"1149":1}}],["subsystem",{"2":{"282":1,"361":1,"683":1}}],["subtitles",{"2":{"1331":1}}],["subtitle",{"2":{"1331":1,"1332":2}}],["subtle",{"2":{"205":1,"262":1,"1088":1,"1109":1,"1149":1}}],["subtraction",{"2":{"1223":1}}],["subtracts",{"2":{"183":2,"231":1,"1199":1}}],["subtract",{"0":{"62":1,"183":1},"2":{"27":1,"181":1,"183":3,"189":1,"192":1,"255":1,"380":1,"381":3,"399":1,"894":1,"1199":1}}],["submission",{"2":{"896":1}}],["submit",{"2":{"21":2,"229":1,"954":1,"1008":1,"1223":1}}],["submonths",{"2":{"181":1}}],["subpath",{"0":{"537":1,"687":1},"2":{"44":1,"462":1,"537":1,"559":2,"560":1,"594":1,"596":1,"812":1,"1154":1,"1273":1,"1451":1,"1452":1}}],["subpaths",{"2":{"43":1,"843":1}}],["suboptimal",{"2":{"43":1}}],["sub",{"0":{"786":1,"1232":1},"2":{"43":3,"44":1,"93":1,"138":2,"260":1,"311":1,"323":1,"324":1,"418":1,"451":2,"473":1,"491":4,"625":1,"712":1,"738":1,"752":1,"771":1,"773":1,"775":1,"792":1,"1045":1,"1052":1,"1073":1,"1105":1,"1213":1,"1226":1,"1232":2,"1242":1,"1318":1,"1332":1,"1388":1}}],["sockets",{"2":{"1028":1}}],["soon",{"2":{"276":1,"812":1,"1096":1}}],["somewhere",{"2":{"875":1}}],["some",{"2":{"377":1,"479":1,"549":1,"556":1,"1139":2}}],["somemodule",{"2":{"250":2}}],["something",{"2":{"229":1,"236":1}}],["sometimes",{"2":{"161":1,"235":1}}],["sophisticated",{"2":{"148":1}}],["solely",{"2":{"1442":1}}],["solstice",{"0":{"1048":1},"2":{"1045":1,"1046":5,"1048":1,"1052":1,"1072":2,"1366":1}}],["solstices",{"0":{"1044":1},"1":{"1045":1,"1046":1,"1047":1,"1048":1,"1049":1},"2":{"1044":1,"1045":1,"1048":2,"1052":2}}],["solid",{"0":{"1429":1},"2":{"516":1,"522":1,"524":1,"674":1}}],["solution",{"0":{"330":1,"426":1,"432":1,"1029":1,"1033":1,"1036":1,"1140":1,"1144":1,"1147":1,"1150":1,"1186":1,"1187":1,"1261":1,"1325":1,"1329":1,"1332":1,"1388":1,"1392":1,"1395":1},"1":{"331":1,"332":1,"333":1,"334":1,"335":1,"336":1,"427":1,"428":1,"433":1,"434":1,"435":1},"2":{"424":1,"1088":1,"1090":1,"1091":1,"1110":1}}],["solutions",{"0":{"529":1},"1":{"530":1,"531":1,"532":1,"533":1,"534":1},"2":{"236":1,"248":2,"293":1,"529":1,"922":1}}],["solves",{"2":{"513":1,"519":1,"906":1,"1111":1,"1137":1,"1262":1,"1443":1}}],["solve",{"2":{"263":1,"402":1,"1090":1}}],["solving",{"2":{"8":1,"49":1,"1189":1}}],["solaroffset",{"0":{"1352":2},"2":{"1343":1,"1344":1,"1352":5,"1353":2,"1366":2}}],["solarelevationdeg",{"2":{"1081":4}}],["solareclipse",{"2":{"1065":3}}],["solarnoon",{"2":{"1068":2}}],["solarterm",{"2":{"1067":1,"1071":1,"1353":1}}],["solartime",{"0":{"1069":1},"2":{"1052":1,"1053":1,"1054":1,"1055":1,"1069":3,"1353":1}}],["solar",{"0":{"1065":1,"1066":2,"1067":2,"1068":2,"1069":2,"1071":1,"1081":1,"1350":1,"1351":1,"1366":1},"1":{"1067":2,"1068":2,"1069":2,"1070":2,"1071":2,"1072":2,"1073":2,"1351":1,"1352":1,"1353":1},"2":{"143":1,"771":1,"775":2,"1044":1,"1045":1,"1046":4,"1050":2,"1052":8,"1053":8,"1054":4,"1055":14,"1065":7,"1066":3,"1067":6,"1068":3,"1069":9,"1070":2,"1071":9,"1072":5,"1073":4,"1080":4,"1081":8,"1082":8,"1084":6,"1339":1,"1343":2,"1344":2,"1345":1,"1350":1,"1351":1,"1353":6,"1362":2,"1366":2}}],["sortable",{"2":{"1135":2}}],["sorted",{"2":{"940":1}}],["sorts",{"2":{"82":1,"314":1}}],["sort",{"2":{"82":1,"191":2}}],["sorting",{"0":{"82":1},"2":{"174":1,"384":1,"654":1,"948":1}}],["sound",{"2":{"512":1,"516":1,"520":1}}],["southeast",{"2":{"1062":1,"1358":1}}],["southernmost",{"2":{"1045":1}}],["southern",{"2":{"303":2,"304":2,"519":1,"1046":2,"1060":1,"1336":1}}],["south",{"2":{"73":1,"117":1,"121":1,"142":2,"144":1,"145":6,"154":2,"226":1,"227":1,"303":1,"304":1,"313":4,"389":1,"824":1,"870":1,"872":1,"1046":2,"1054":1,"1060":5,"1062":2,"1071":1,"1178":1,"1358":2}}],["sources",{"2":{"1312":1}}],["sourcemask",{"2":{"1147":1}}],["source",{"0":{"434":1,"539":1},"2":{"23":1,"246":1,"313":2,"316":1,"337":1,"339":1,"406":1,"439":1,"457":1,"534":2,"539":1,"548":1,"574":1,"712":1,"835":1,"836":1,"845":1,"854":1,"872":1,"882":1,"889":1,"891":1,"923":1,"1011":1,"1025":1,"1057":1,"1088":1,"1094":1,"1104":2,"1107":1,"1113":6,"1116":1,"1155":1,"1158":1,"1174":1,"1211":1,"1224":1,"1252":1,"1300":1,"1321":1,"1349":1,"1384":1,"1410":1,"1429":1}}],["so",{"2":{"3":1,"34":1,"44":1,"99":1,"102":1,"114":1,"165":1,"267":1,"271":1,"276":1,"285":1,"364":1,"365":1,"426":1,"456":1,"541":1,"631":1,"714":1,"932":1,"946":1,"972":1,"1427":1,"1452":1}}],["software",{"2":{"1085":1,"1088":1,"1134":1}}],["softerrors",{"2":{"696":1,"871":1,"881":1,"890":1,"896":2,"899":1,"905":2,"912":2,"920":1,"972":1,"973":4}}],["soft",{"0":{"413":1,"430":1,"432":1,"973":1},"1":{"414":1,"431":1,"432":1,"433":2,"434":2,"435":2,"436":1,"437":1,"438":1,"439":1,"440":1},"2":{"1":1,"406":1,"413":1,"414":1,"430":1,"432":1,"437":2,"438":2,"440":1,"1084":1}}],["sex",{"2":{"1281":2}}],["sextum",{"2":{"1271":4,"1280":1,"1310":1}}],["severe",{"2":{"1012":1}}],["several",{"2":{"1":1,"134":1,"297":1,"400":1,"470":1,"1092":1}}],["sequential",{"0":{"945":1},"2":{"867":1,"910":1,"940":1,"1268":1,"1369":1,"1383":1}}],["sequentially",{"2":{"43":1,"934":2,"945":1,"1032":1,"1268":1}}],["sequence",{"0":{"767":1},"2":{"276":1,"637":1,"767":1,"1448":1}}],["sequences",{"2":{"221":1}}],["segmentation",{"2":{"1041":1}}],["segmenter",{"2":{"361":1}}],["segment",{"2":{"167":1,"176":1}}],["selling",{"0":{"503":1}}],["self",{"0":{"447":1},"1":{"448":1,"449":1,"450":1,"451":1},"2":{"157":1,"224":1,"552":1,"858":1,"1005":1,"1081":1,"1178":1,"1189":1,"1443":1}}],["selects",{"2":{"1038":1}}],["selected",{"2":{"947":1,"968":1,"992":2}}],["selector",{"2":{"648":1}}],["selective",{"0":{"278":1},"2":{"597":1}}],["selection",{"0":{"207":1},"2":{"777":1}}],["select",{"2":{"88":1,"89":1,"1095":1,"1124":1}}],["session",{"2":{"120":2,"500":1,"536":2,"838":1,"860":5,"948":1,"955":1,"1004":1,"1013":1,"1363":1}}],["sessioncontext",{"2":{"119":4}}],["sessionstorage",{"2":{"504":1,"857":1,"913":1,"1005":1}}],["sessions",{"2":{"110":1,"1014":1,"1362":1}}],["sector",{"2":{"1343":1}}],["section",{"2":{"407":2,"409":1,"479":1,"594":1,"666":1,"708":1}}],["secrets",{"2":{"955":1,"1003":2,"1004":1,"1005":1}}],["secretvault",{"2":{"933":1,"1004":1}}],["secretplugin",{"2":{"271":3}}],["secret",{"0":{"1004":1},"2":{"271":2,"477":1,"857":1,"933":3,"953":1,"1004":1}}],["sec",{"2":{"138":2,"1178":1}}],["secondary",{"2":{"946":1}}],["seconds",{"2":{"137":2,"138":3,"151":2,"207":1,"209":2,"741":1,"1028":1,"1032":1,"1105":1,"1125":4,"1139":1,"1141":1,"1254":1,"1256":1,"1266":1,"1315":1,"1319":1,"1344":1,"1351":1,"1352":3,"1392":1,"1400":1,"1403":1,"1404":2,"1408":1,"1409":1,"1412":1,"1413":3,"1420":2,"1422":1,"1424":1,"1430":1,"1434":1,"1435":1,"1436":2,"1438":1,"1439":1,"1444":3,"1445":1,"1446":1}}],["second",{"2":{"98":1,"138":3,"151":1,"203":2,"208":1,"225":1,"240":1,"245":1,"315":1,"324":3,"418":1,"489":1,"511":1,"625":1,"680":1,"775":1,"776":1,"829":1,"908":2,"930":1,"935":1,"948":1,"962":1,"1013":1,"1088":1,"1089":1,"1125":2,"1134":1,"1178":1,"1221":1,"1232":1,"1235":1,"1254":1,"1266":1,"1267":1,"1271":1,"1319":2,"1328":1,"1329":3,"1331":1,"1332":1,"1428":1}}],["securities",{"2":{"1221":1}}],["securityauditlogger",{"2":{"1144":3}}],["security",{"0":{"18":1,"109":1,"114":1,"340":1,"852":1,"857":1,"861":1,"862":1,"994":1,"999":1,"1173":1,"1363":1,"1375":1},"1":{"19":1,"20":1,"21":1,"22":1,"23":1,"853":1,"854":1,"855":1,"856":1,"857":1,"858":1,"859":1,"860":1,"861":1,"862":2,"863":2,"864":2,"865":2,"866":2,"867":1,"868":1,"995":1,"996":1,"997":1,"998":1,"999":1,"1000":2,"1001":2,"1002":1,"1003":1,"1004":1,"1005":1,"1006":1,"1007":1,"1008":1,"1009":1,"1010":1,"1011":1,"1376":1},"2":{"19":1,"20":2,"21":7,"271":1,"425":1,"429":1,"533":1,"647":1,"717":1,"829":1,"861":3,"869":1,"913":1,"921":3,"936":1,"954":1,"994":2,"995":1,"1040":1,"1143":1,"1263":1,"1344":2,"1361":1,"1362":1}}],["secured",{"2":{"580":1}}],["securely",{"2":{"402":2,"424":1,"428":1,"859":1}}],["secure",{"2":{"1":1,"23":1,"413":1,"426":1,"427":1,"437":1,"440":1,"578":1,"626":1,"663":1,"738":1,"858":1,"859":1,"913":2,"954":1,"1005":1,"1008":1}}],["sendbeacon",{"2":{"1265":1}}],["sendtelemetrylog",{"2":{"1265":1}}],["sends",{"2":{"934":1,"946":1,"1246":1}}],["send",{"2":{"854":1,"863":1,"934":1,"1139":1,"1444":1}}],["sending",{"2":{"93":1,"1012":1,"1017":1,"1227":1}}],["sentry",{"2":{"995":1,"1011":1}}],["sent",{"2":{"954":1,"1008":1}}],["sentinel",{"0":{"501":1,"502":1},"2":{"502":1}}],["sentence",{"2":{"146":1,"878":1}}],["sentences",{"2":{"140":2}}],["sensorid",{"2":{"1329":4}}],["sensors",{"2":{"1328":1}}],["sensor",{"2":{"227":1,"1028":1}}],["sensitivity",{"2":{"1098":1}}],["sensitive",{"0":{"1134":1},"2":{"89":1,"402":1,"476":1,"529":1,"701":1,"867":1,"918":1,"946":1,"954":1,"994":1,"995":1,"996":1,"997":1,"1008":3,"1011":1,"1012":1,"1017":1,"1225":1,"1441":1}}],["sensitively",{"2":{"76":1}}],["sensible",{"2":{"101":1,"281":1}}],["september",{"2":{"908":1,"1046":1}}],["sep>",{"2":{"246":1}}],["separating",{"2":{"728":1}}],["separation",{"0":{"832":1},"2":{"102":1,"542":1,"626":1,"644":1,"830":1,"1075":1,"1076":1}}],["separately",{"2":{"714":1}}],["separated",{"2":{"541":1}}],["separate",{"2":{"297":1,"406":1,"507":1,"513":1,"669":1}}],["separates",{"2":{"102":1}}],["separator",{"2":{"240":1,"767":1}}],["separators",{"2":{"216":1,"243":1}}],["sep",{"2":{"63":1,"205":1,"214":2,"240":1,"241":1,"242":9,"243":2,"246":4,"1213":1,"1220":1,"1269":1}}],["semi",{"2":{"1078":2,"1079":1,"1080":1}}],["semaphores",{"2":{"1369":1}}],["semaines",{"2":{"982":1}}],["semantics",{"0":{"739":1},"2":{"410":1,"642":1,"1086":1,"1109":1,"1110":1}}],["semantic",{"0":{"75":1,"89":1,"1412":1},"1":{"1413":1},"2":{"62":1,"63":2,"89":1,"138":2,"139":1,"195":1,"257":1,"318":1,"326":2,"381":1,"516":1,"519":1,"575":1,"680":1,"681":1,"734":1,"735":1,"747":1,"951":1,"954":1,"1011":1,"1055":1,"1088":1,"1090":1,"1401":1,"1411":1,"1412":1}}],["semver",{"2":{"43":1}}],["seamless",{"2":{"682":1,"771":1,"780":1,"878":1,"996":1,"1103":1}}],["seamlessly",{"2":{"59":1,"138":1,"144":1,"145":1,"148":1,"156":1,"222":1,"321":1,"465":1,"473":1,"489":1,"606":1,"654":1,"704":1,"720":1,"723":1,"755":1,"760":1,"807":1,"816":1,"855":1,"903":1,"1094":1,"1099":1,"1224":1}}],["seals",{"2":{"468":1}}],["sealed",{"2":{"465":1}}],["searching",{"2":{"1276":1}}],["searches",{"2":{"375":1}}],["search",{"2":{"204":1,"383":1,"867":1,"946":1,"949":1,"1178":1,"1181":1,"1293":1,"1313":1}}],["sea",{"2":{"142":1,"1067":1,"1070":1,"1085":1}}],["season>",{"2":{"456":2}}],["seasonal",{"2":{"117":1,"313":1,"389":1,"1046":1,"1052":1}}],["seasons",{"0":{"73":1,"304":1,"1044":1},"1":{"1045":1,"1046":1,"1047":1,"1048":1,"1049":1},"2":{"84":1,"87":1,"193":1,"302":1,"321":1,"378":1,"453":1,"471":1,"509":1,"526":1,"531":1,"556":1,"609":1,"680":1,"771":1,"849":1,"1049":1,"1052":1}}],["season",{"0":{"304":1},"2":{"9":1,"75":1,"143":3,"155":1,"257":1,"281":1,"300":1,"301":1,"304":2,"307":2,"326":1,"334":2,"455":1,"456":4,"458":1,"461":4,"469":1,"504":2,"519":8,"543":2,"561":3,"637":4,"711":1,"1044":1,"1046":6,"1047":1,"1181":1,"1414":1}}],["serving",{"2":{"708":1,"1116":1}}],["servicenow",{"2":{"1219":1}}],["services",{"0":{"248":1,"529":1,"530":1},"1":{"530":1,"531":2,"532":2,"533":2,"534":1},"2":{"248":1,"287":1,"333":1,"529":1,"534":1,"1444":1}}],["service",{"0":{"447":1,"1364":1},"1":{"448":1,"449":1,"450":1,"451":1},"2":{"119":1,"913":1,"997":1,"1004":1,"1178":1,"1194":1,"1219":1,"1362":1,"1364":1}}],["serves",{"2":{"470":1,"1375":1}}],["serve",{"2":{"44":1,"89":1,"157":1,"504":1,"1189":1}}],["servertimeutc",{"2":{"1265":1}}],["servertime",{"2":{"1247":1}}],["serverless",{"2":{"119":1,"953":1,"978":1}}],["servers",{"2":{"116":1,"829":1,"857":1,"861":1,"863":1,"913":1,"953":1,"1000":2,"1007":1,"1067":1,"1176":1,"1263":1,"1377":1,"1391":1}}],["server",{"0":{"35":1,"103":1,"956":1,"1188":1,"1193":1,"1229":1,"1232":1},"1":{"36":1,"37":1,"38":1,"957":1,"958":1},"2":{"33":1,"102":1,"103":1,"199":1,"205":1,"336":1,"365":1,"479":3,"588":1,"806":1,"858":1,"862":2,"925":1,"953":1,"955":3,"1001":1,"1005":1,"1008":1,"1013":1,"1026":1,"1166":2,"1168":3,"1188":6,"1226":1,"1227":3,"1232":4,"1235":1,"1236":2,"1239":2,"1240":2,"1241":1,"1242":1,"1243":1,"1245":1,"1253":1,"1254":1,"1258":1,"1261":2,"1262":2,"1265":1,"1266":1,"1267":1,"1376":2,"1378":1,"1392":2,"1422":1}}],["series",{"2":{"919":1,"1028":1,"1328":2}}],["serialisation",{"2":{"596":1}}],["serialized",{"2":{"472":1,"500":1,"998":1}}],["serializes",{"2":{"472":1,"500":1}}],["serialize",{"2":{"468":1,"503":1,"504":1,"505":1,"691":1}}],["serializers",{"0":{"498":1},"1":{"499":1,"500":1,"501":1,"502":1,"503":1,"504":1,"505":1},"2":{"472":1,"499":1}}],["serializer",{"2":{"300":1}}],["serialization",{"0":{"472":1,"691":1},"2":{"403":1,"468":1,"470":1,"472":1,"478":1,"498":2,"663":1,"691":1,"1039":1,"1094":1,"1368":1}}],["serializable",{"0":{"478":1},"2":{"102":1,"340":1,"478":1,"830":1}}],["serializing",{"2":{"357":1}}],["seriously",{"2":{"20":1}}],["seeds",{"2":{"1254":1,"1421":1}}],["seeded",{"2":{"99":1,"695":1,"974":1}}],["seeding",{"0":{"95":1,"695":1,"974":1,"1419":1}}],["seed",{"2":{"93":1,"95":1,"695":1,"854":1,"1273":1,"1404":1,"1419":2,"1420":1,"1421":4,"1439":1}}],["see",{"0":{"1274":1,"1314":1},"2":{"10":1,"17":1,"64":1,"69":1,"76":1,"77":1,"78":1,"109":1,"128":1,"137":1,"161":1,"195":1,"205":1,"221":1,"229":1,"287":1,"339":1,"355":1,"359":3,"362":1,"363":1,"412":1,"414":1,"419":1,"465":1,"515":1,"629":1,"861":1,"867":1,"869":1,"972":1,"998":1,"1162":1}}],["setimmediate",{"2":{"1431":1}}],["setinterval",{"2":{"1396":1,"1442":1,"1443":1,"1444":1,"1448":1}}],["setprovider",{"0":{"1178":1},"2":{"1168":1,"1178":1,"1191":2}}],["setproperty",{"2":{"738":1}}],["setlocale",{"0":{"1158":1},"1":{"1159":1},"2":{"1158":3,"1159":1,"1166":1,"1169":1,"1171":1}}],["setlazy",{"2":{"426":1}}],["settimeout",{"2":{"860":1,"955":1,"1178":1,"1408":1,"1431":1,"1442":1,"1443":1}}],["setting",{"2":{"73":1,"116":1,"118":1,"129":1,"357":1,"361":1,"363":1,"936":1,"954":1,"1054":1,"1157":1}}],["settings",{"2":{"26":1,"95":1,"100":1,"101":1,"102":1,"105":1,"109":1,"110":1,"122":1,"129":1,"186":1,"331":2,"344":1,"350":1,"365":2,"504":1,"541":1,"616":1,"817":1,"869":2,"870":1,"933":1,"1125":1}}],["settlementdate",{"2":{"1221":3}}],["settlement",{"0":{"1221":1},"2":{"1210":1,"1218":1,"1221":5}}],["settle",{"2":{"495":1,"1221":1}}],["settled",{"2":{"481":1,"483":1,"487":1}}],["settles",{"2":{"334":1}}],["sets",{"2":{"121":1,"184":1,"326":1,"924":1,"1098":1,"1168":1,"1260":1}}],["set",{"0":{"175":1,"184":1},"1":{"176":1,"177":1,"178":1,"179":1,"180":1,"185":1,"186":1,"187":1,"188":1,"189":1,"190":1,"191":1},"2":{"9":1,"27":1,"46":1,"63":4,"64":3,"68":1,"100":1,"102":1,"124":1,"128":1,"129":1,"181":1,"184":2,"185":2,"186":8,"188":3,"189":3,"190":5,"191":8,"192":3,"194":1,"199":1,"224":3,"225":1,"233":1,"255":1,"278":1,"320":2,"323":2,"324":4,"326":1,"329":1,"341":1,"351":1,"360":1,"368":4,"369":4,"377":1,"380":2,"381":3,"382":4,"389":1,"399":1,"416":1,"433":1,"437":2,"452":1,"472":1,"484":1,"485":1,"498":1,"503":1,"505":1,"556":2,"569":1,"597":1,"606":1,"617":1,"645":1,"667":1,"680":2,"711":1,"719":1,"734":5,"735":1,"747":1,"773":3,"777":5,"797":1,"817":2,"842":5,"938":1,"946":1,"959":2,"972":1,"978":3,"980":1,"1011":1,"1041":2,"1055":3,"1061":1,"1090":1,"1329":1,"1376":1,"1429":4,"1430":4,"1454":1}}],["setup",{"0":{"4":1,"25":1,"844":1},"1":{"26":1,"27":1,"28":1,"29":1,"845":1,"846":1,"847":1,"848":1,"849":1,"850":1,"851":1},"2":{"41":1,"43":1,"48":1,"90":1,"101":1,"102":1,"266":2,"407":1,"469":1,"847":1,"925":1,"952":1,"1454":1,"1459":2}}],["ux",{"0":{"648":1,"655":1,"666":1}}],["urbe",{"0":{"1272":1},"2":{"1272":1,"1275":1,"1276":1,"1285":1}}],["uri",{"2":{"503":1}}],["urls",{"2":{"105":1,"107":1,"109":2,"541":1,"829":3,"832":1,"854":1,"856":1,"1263":1}}],["url",{"2":{"26":1,"43":1,"83":1,"89":1,"90":1,"115":1,"117":1,"829":3,"854":2,"855":1,"856":2,"859":2,"933":2,"937":2,"938":2,"959":2,"978":2,"1001":1,"1004":1,"1178":4,"1240":1,"1263":4}}],["u",{"2":{"146":1,"240":1,"1089":1,"1125":2,"1135":1}}],["ukc",{"2":{"1083":1}}],["uk",{"0":{"58":1},"2":{"215":1,"817":1,"878":1,"909":1,"950":1,"1097":1,"1219":1,"1220":3,"1221":1}}],["ui",{"0":{"54":1,"1429":1},"2":{"76":2,"140":1,"164":1,"199":1,"204":1,"513":1,"622":1,"651":2,"723":1,"897":1,"1042":1,"1063":1,"1315":1,"1320":1,"1394":1,"1401":1,"1436":1,"1443":1}}],["uts",{"2":{"1099":1,"1103":1,"1123":1,"1125":1}}],["util",{"2":{"998":2}}],["utilized",{"2":{"499":1}}],["utilize",{"2":{"462":1,"839":1,"998":1,"1045":1}}],["utilizes",{"2":{"356":1,"402":1,"403":1,"412":1,"414":1,"922":1,"1106":1}}],["utilizing",{"2":{"114":1,"422":1,"716":1,"839":1,"913":1,"1018":1,"1033":1}}],["utilities",{"0":{"557":1,"673":1},"1":{"558":1,"559":1},"2":{"14":1,"181":1,"403":1,"424":1,"470":2,"477":1,"479":3,"515":1,"519":1,"537":1,"581":1,"588":2,"728":1,"744":1,"775":1,"840":1,"1104":1,"1151":1,"1173":1,"1454":1}}],["utility",{"0":{"371":1,"841":1,"969":1},"1":{"372":1,"373":1},"2":{"0":1,"131":1,"147":1,"283":1,"298":1,"300":1,"371":1,"373":1,"402":1,"438":1,"449":1,"452":1,"471":1,"477":1,"479":1,"480":1,"488":1,"509":1,"514":1,"519":1,"525":1,"528":1,"546":1,"557":1,"578":1,"596":1,"598":1,"637":1,"661":1,"668":1,"673":1,"769":1,"790":1,"1168":1}}],["ut",{"2":{"150":1}}],["utc+0",{"2":{"1366":1}}],["utc+2",{"2":{"1366":2}}],["utc+10",{"2":{"1352":1}}],["utc+1",{"2":{"1351":1,"1366":1}}],["utcnow",{"2":{"53":1}}],["utc",{"0":{"53":1},"2":{"53":1,"56":1,"69":1,"118":2,"119":1,"138":6,"146":1,"154":1,"213":2,"240":1,"296":6,"477":1,"637":2,"689":1,"1047":2,"1054":2,"1067":1,"1125":2,"1140":1,"1141":2,"1144":1,"1193":1,"1243":1,"1265":2,"1351":1,"1360":2}}],["umd",{"2":{"41":1,"45":1,"850":1}}],["updating",{"2":{"1117":1,"1157":2,"1233":1,"1388":1}}],["updateui",{"2":{"1433":1}}],["updatedashboard",{"2":{"1256":1}}],["updated",{"2":{"438":1,"580":1,"582":1,"584":1,"590":1,"601":1,"607":1,"618":2,"622":1,"637":1,"649":1,"655":1,"708":1,"747":1}}],["updates",{"0":{"540":1,"618":1},"1":{"541":1,"542":1,"543":1,"544":1,"545":1,"546":1},"2":{"19":1,"414":1,"421":1,"430":1,"440":2,"617":1,"648":1,"714":1,"716":1,"782":1,"856":1,"937":1,"938":1,"1016":1,"1246":1,"1368":1}}],["update",{"2":{"7":1,"8":1,"440":1,"444":1,"559":1,"565":1,"728":1,"759":1,"1429":1}}],["upright",{"2":{"1063":1}}],["upstash",{"2":{"978":3}}],["upstreamres",{"2":{"955":3}}],["upstreamresponse",{"2":{"860":3}}],["upstream",{"2":{"860":5,"862":1,"955":3,"1000":1}}],["upcoming",{"2":{"729":1,"1078":1,"1270":1}}],["upgrading",{"2":{"549":1,"759":1}}],["upgrades",{"0":{"1114":1}}],["upgraded",{"2":{"669":1,"696":1,"735":1,"752":1,"755":2,"838":1}}],["upgrade",{"2":{"34":1}}],["upfront",{"2":{"124":1,"127":1,"424":1}}],["up",{"2":{"114":1,"336":2,"363":1,"407":1,"419":2,"468":2,"512":1,"606":1,"634":1,"728":1,"737":1,"760":1,"798":1,"831":1,"833":1,"853":1,"924":1,"953":1,"954":2,"985":1,"1043":1,"1125":2,"1232":1,"1316":1,"1318":1,"1363":1,"1408":1,"1444":1,"1445":1}}],["upon",{"2":{"94":1,"276":1,"340":1,"421":1,"494":1,"543":1,"831":1,"895":1,"1039":1,"1227":1,"1234":1,"1256":1,"1370":1,"1373":1,"1408":1}}],["uppercase",{"2":{"76":1,"138":1,"139":1,"758":1,"767":1,"1088":1,"1090":1,"1111":1,"1113":1,"1125":1}}],["upper",{"2":{"76":3,"138":2,"139":1,"144":2,"145":1,"323":1,"754":2,"773":1,"775":1,"823":1,"1061":1,"1075":1,"1088":1,"1090":3,"1098":1,"1113":2,"1125":2,"1147":1,"1439":1}}],["uptime",{"2":{"43":1,"44":1,"866":1}}],["unhandled",{"2":{"1431":1}}],["unrounded",{"2":{"1324":1}}],["unrestricted",{"2":{"1376":1}}],["unref",{"0":{"1372":1},"2":{"1372":3,"1383":1}}],["unreferencing",{"0":{"1372":1}}],["unreferenced",{"2":{"476":1,"1434":1,"1442":2}}],["unrecognized",{"2":{"1141":1}}],["unverified",{"2":{"1010":1,"1041":1}}],["unescapable",{"2":{"1098":1}}],["unencrypted",{"2":{"1000":1}}],["unexpected",{"2":{"857":1}}],["unmount",{"2":{"1443":1}}],["unmounted",{"2":{"1256":1}}],["unmodified",{"2":{"998":1}}],["unmet",{"2":{"920":1}}],["uncalibrated",{"0":{"1260":1},"2":{"1422":1}}],["uncalled",{"2":{"816":2}}],["uncertaintyms",{"2":{"1243":1,"1248":1,"1265":2}}],["uncertainty",{"0":{"1231":1}}],["unchanged",{"2":{"1147":1}}],["unconfigured",{"2":{"959":1}}],["unconditionally",{"2":{"738":1}}],["unclosed",{"2":{"473":1,"495":1,"709":1}}],["undocumented",{"2":{"573":1}}],["undescribed",{"2":{"271":1}}],["undefined",{"0":{"1291":1,"1292":1},"2":{"34":1,"109":1,"117":5,"144":1,"154":2,"285":1,"323":6,"324":5,"367":1,"489":1,"502":1,"503":1,"855":1,"860":2,"872":3,"882":5,"891":3,"900":1,"937":4,"968":1,"978":2,"1054":1,"1178":2,"1186":1,"1240":3,"1436":1}}],["undergo",{"2":{"865":1}}],["understanding",{"2":{"237":1,"276":1,"342":1}}],["understand",{"2":{"199":1,"219":1,"237":1,"331":1,"342":1,"343":1,"349":1,"363":1,"375":1,"645":1}}],["understands",{"2":{"59":1,"294":1,"520":1,"522":1}}],["underlying",{"2":{"148":1,"149":2,"150":1,"154":1,"233":2,"265":1,"416":1,"418":1,"434":1,"435":1,"520":1,"691":1,"707":1,"719":1,"769":1,"818":1,"1021":1,"1094":1,"1144":1,"1372":1,"1382":1}}],["under",{"2":{"17":1,"110":2,"111":1,"263":1,"280":1,"294":1,"297":1,"322":1,"374":1,"402":1,"407":1,"415":1,"423":1,"446":1,"453":1,"470":1,"499":1,"513":1,"516":1,"524":1,"534":1,"544":1,"556":1,"771":1,"776":1,"786":1,"829":1,"830":1,"845":1,"916":1,"923":1,"1025":1,"1057":1,"1083":1,"1088":1,"1107":1,"1110":1,"1155":1,"1174":1,"1185":1,"1186":2,"1194":1,"1211":1,"1215":1,"1271":1,"1298":1,"1300":1,"1321":1,"1349":1,"1384":1,"1394":1,"1410":1,"1459":1}}],["unwanted",{"2":{"465":1,"767":1}}],["unwrapping",{"2":{"489":1}}],["unwrap",{"2":{"435":1,"437":1}}],["unfrozen",{"2":{"426":1,"427":1,"431":1}}],["unflagged",{"2":{"34":1,"37":1}}],["unknown>",{"2":{"986":1,"1265":1}}],["unknown",{"2":{"333":1,"793":1}}],["unbraced",{"2":{"806":1}}],["unbounded",{"2":{"278":1}}],["unbalanced",{"2":{"161":1,"162":1}}],["untrustworthy",{"2":{"1265":1}}],["untrusted",{"2":{"856":1,"1264":2}}],["untouched",{"2":{"333":1,"465":1,"1122":1}}],["unt",{"2":{"240":1,"242":2,"245":1}}],["untilthen",{"2":{"171":1}}],["until",{"0":{"65":2,"158":1,"493":1,"774":1,"1439":1},"2":{"9":1,"34":1,"46":1,"65":1,"124":1,"157":5,"158":12,"160":1,"161":3,"234":1,"253":1,"300":1,"323":1,"324":1,"380":1,"406":1,"407":1,"416":1,"427":1,"473":1,"493":2,"520":6,"522":1,"699":1,"709":1,"720":2,"724":1,"771":1,"773":1,"774":2,"775":2,"879":1,"934":2,"945":1,"970":1,"1009":1,"1043":1,"1106":1,"1119":1,"1221":1,"1404":1,"1421":2,"1439":1}}],["unlocking",{"2":{"516":1}}],["unlock",{"2":{"318":1}}],["unlike",{"2":{"206":1,"408":1,"489":1,"500":1,"1125":1,"1396":1}}],["unless",{"2":{"198":1,"302":1,"862":1,"955":1,"1088":1,"1182":1,"1375":1}}],["unseeded",{"2":{"1422":1}}],["unset",{"2":{"1011":1}}],["unspecified",{"2":{"1125":1}}],["unsubscribes",{"2":{"792":1}}],["unsubscribe",{"2":{"491":2}}],["unsupported",{"2":{"191":1,"326":1,"505":2,"876":1,"1115":1}}],["unstructured",{"0":{"888":1},"1":{"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1},"2":{"204":1,"869":1,"870":1,"888":1,"913":1,"919":1,"960":1,"1011":2}}],["unstable",{"2":{"39":1}}],["unpredictable",{"2":{"1258":1}}],["unpredictably",{"2":{"1091":1}}],["unpartitioned",{"2":{"1185":1}}],["unparseable",{"2":{"865":1,"872":1,"882":1,"973":1}}],["unpadded",{"2":{"138":2,"370":2,"1090":1,"1125":4}}],["unpolluted",{"2":{"468":1}}],["unpopulated",{"2":{"144":1}}],["unanchored",{"2":{"1254":1}}],["unanimous",{"2":{"950":2}}],["unauthenticated",{"2":{"856":2}}],["unauthorized",{"2":{"114":1,"860":1,"955":1}}],["unavailable",{"2":{"607":1,"1103":1}}],["unacceptable",{"2":{"411":1}}],["unaffected",{"2":{"345":1}}],["unambiguous",{"2":{"139":1,"1093":1}}],["unification",{"2":{"574":1}}],["unifies",{"2":{"473":1}}],["unified",{"0":{"282":1,"680":1,"728":1,"776":1},"2":{"44":1,"45":1,"181":1,"402":1,"416":1,"458":2,"465":1,"556":1,"588":1,"592":1,"625":1,"653":1,"771":1,"776":1,"835":1,"842":1,"858":1,"996":1,"1366":1,"1411":1}}],["uniform",{"0":{"259":1,"310":1},"2":{"286":1,"310":1,"1191":1,"1351":1}}],["union",{"0":{"180":1},"2":{"180":1,"469":1,"617":1,"699":1,"711":1}}],["universally",{"2":{"407":1,"503":1}}],["universal",{"0":{"824":1,"903":1,"996":1,"1116":1},"2":{"138":3,"273":1,"298":1,"617":1,"821":1,"1135":1,"1162":1,"1168":1,"1171":1}}],["unicode",{"0":{"802":1,"1127":1},"2":{"137":2,"138":1,"365":1,"370":1,"371":1,"507":2,"802":1,"808":1,"872":1,"1088":1,"1091":1,"1099":1,"1103":1,"1104":2,"1110":1,"1112":1,"1123":1,"1125":1,"1136":1}}],["uniquely",{"2":{"1088":1}}],["unique",{"2":{"116":1,"229":1,"326":3,"406":1,"451":1,"506":1,"514":1,"972":1,"1176":1,"1185":1}}],["unitdisplay",{"2":{"606":1}}],["united",{"2":{"121":1,"362":1,"1207":1,"1213":2}}],["unit",{"0":{"207":1},"2":{"116":1,"138":5,"158":1,"159":3,"161":2,"165":1,"208":1,"221":1,"245":1,"323":3,"324":3,"325":1,"334":1,"567":1,"569":1,"602":1,"616":2,"644":1,"774":1,"775":1,"778":1,"911":3,"1000":1,"1318":1,"1319":1,"1344":3,"1345":2,"1352":2,"1360":1,"1363":1,"1366":1,"1412":1,"1413":1,"1441":1,"1445":1}}],["units",{"0":{"774":1,"1319":1,"1356":1,"1413":1},"2":{"63":2,"138":3,"161":1,"164":1,"165":1,"206":1,"209":1,"221":2,"237":1,"240":2,"378":1,"519":1,"606":1,"773":1,"774":1,"1316":1,"1318":1,"1319":1,"1412":2}}],["unintended",{"2":{"109":1}}],["unix",{"0":{"60":1},"2":{"137":1,"154":2,"201":1,"206":1,"355":2,"1125":3}}],["unused",{"2":{"43":1,"249":1,"427":1}}],["un",{"0":{"164":1},"2":{"29":1,"164":1,"247":1,"412":1,"545":2}}],["ultra",{"2":{"12":1,"89":1,"867":1,"940":2,"1042":1,"1389":1,"1412":1}}],["usr",{"2":{"1363":2}}],["usually",{"2":{"114":1,"161":1,"250":2}}],["us",{"0":{"58":1,"215":1,"534":1},"1":{"216":1,"217":1,"218":1},"2":{"15":1,"22":1,"58":2,"69":1,"71":5,"117":1,"119":2,"137":2,"138":1,"151":1,"154":2,"159":2,"186":7,"207":1,"215":3,"248":1,"274":1,"285":1,"289":1,"291":1,"362":1,"365":2,"367":4,"368":1,"370":4,"418":1,"450":2,"563":2,"817":1,"872":1,"881":1,"890":2,"899":2,"907":1,"909":1,"1093":2,"1097":1,"1141":1,"1157":1,"1158":1,"1188":1,"1190":5,"1193":1,"1195":3,"1197":2,"1199":1,"1201":2,"1207":1,"1213":1,"1214":1,"1220":1,"1222":4,"1224":2,"1319":2,"1447":1}}],["usage",{"0":{"36":1,"40":1,"42":1,"332":1,"448":1,"850":1,"870":1,"880":1,"889":1,"898":1,"915":1,"928":1,"961":1,"982":1,"988":1,"1049":1,"1153":1,"1352":1},"1":{"333":1,"334":1,"335":1,"916":1,"917":1,"918":1,"929":1,"930":1,"931":1,"932":1,"933":1,"1154":1},"2":{"10":2,"41":1,"289":1,"439":1,"472":1,"473":1,"475":1,"581":1,"651":1,"659":1,"937":1,"938":1,"954":1,"959":1,"1008":1,"1178":1,"1335":1}}],["using`",{"2":{"1440":1}}],["using",{"0":{"317":1,"335":1,"457":1,"491":1,"543":1,"1216":1,"1217":1,"1373":1,"1432":2,"1433":1,"1434":1,"1441":1,"1445":1},"1":{"458":1,"459":1,"460":1,"461":1,"1433":2,"1434":2},"2":{"6":1,"27":1,"31":3,"32":1,"34":1,"35":1,"43":2,"45":1,"46":1,"48":1,"49":1,"62":1,"63":1,"64":1,"72":1,"77":2,"93":1,"94":1,"95":1,"102":1,"105":1,"106":1,"107":1,"113":1,"116":1,"123":1,"124":2,"131":2,"133":2,"136":1,"138":4,"142":1,"145":2,"146":2,"147":1,"158":2,"162":1,"165":1,"170":1,"185":1,"191":1,"193":1,"199":1,"200":1,"203":1,"205":1,"210":1,"211":1,"214":1,"219":1,"229":1,"232":1,"233":1,"234":1,"243":2,"247":2,"250":1,"256":1,"261":1,"276":1,"281":2,"285":2,"288":1,"289":1,"295":1,"296":1,"312":1,"315":1,"322":1,"326":1,"329":1,"335":2,"337":1,"360":1,"369":1,"370":1,"374":1,"389":1,"397":1,"422":1,"424":1,"426":1,"429":1,"440":1,"441":1,"444":1,"449":2,"453":1,"457":1,"461":1,"467":1,"473":2,"485":1,"486":3,"490":1,"491":1,"493":1,"494":1,"496":1,"513":1,"515":1,"519":1,"538":1,"540":1,"543":2,"555":1,"563":1,"629":1,"663":1,"666":1,"667":2,"722":1,"729":1,"734":1,"737":1,"754":1,"763":1,"765":1,"769":1,"773":1,"792":2,"806":1,"827":1,"831":3,"833":1,"846":1,"849":1,"850":1,"855":1,"875":1,"884":1,"912":1,"927":1,"935":1,"966":1,"978":1,"979":1,"993":1,"996":1,"998":1,"1007":1,"1008":1,"1009":1,"1010":1,"1019":1,"1082":1,"1085":1,"1088":1,"1090":1,"1095":1,"1096":1,"1099":1,"1101":1,"1104":2,"1105":1,"1122":1,"1130":1,"1131":1,"1146":1,"1168":2,"1172":1,"1183":1,"1184":1,"1190":1,"1214":1,"1223":1,"1233":1,"1234":1,"1236":1,"1256":1,"1265":1,"1266":1,"1304":1,"1309":1,"1329":1,"1355":1,"1367":1,"1369":1,"1373":1,"1377":1,"1383":1,"1392":1,"1396":2,"1401":3,"1405":2,"1408":1,"1409":1,"1412":4,"1415":2,"1417":2,"1418":2,"1419":1,"1420":1,"1422":1,"1423":1,"1430":1,"1433":1,"1434":1,"1438":2,"1441":1,"1442":3,"1443":2,"1445":3}}],["useadditionalweekyeartokens",{"2":{"1088":1}}],["useful",{"2":{"125":1,"128":1,"138":1,"164":1,"177":1,"179":1,"246":1,"328":1,"346":1,"358":1,"390":1,"462":1,"483":1,"869":1}}],["used",{"0":{"466":1,"504":1},"2":{"94":1,"96":1,"117":2,"129":1,"173":1,"233":1,"239":1,"245":1,"274":2,"297":2,"298":1,"313":1,"341":1,"351":1,"352":1,"380":1,"381":1,"382":1,"393":1,"395":1,"406":1,"411":1,"413":1,"415":1,"430":1,"446":1,"451":1,"456":1,"471":1,"479":1,"498":1,"504":2,"629":1,"937":1,"938":1,"993":1,"1008":1}}],["userloginevent",{"2":{"1363":3}}],["userauth2",{"2":{"1361":3}}],["userauth1",{"2":{"1361":3}}],["useracceptlanguage",{"2":{"1190":3}}],["userpos",{"2":{"1335":5}}],["usertime",{"2":{"1188":1}}],["usertimezone",{"2":{"1013":3}}],["usercoords",{"2":{"1188":2}}],["userinput",{"2":{"1013":2}}],["userid",{"2":{"860":1,"1363":3}}],["usersessiontoken",{"2":{"859":1}}],["usersession>",{"2":{"119":1}}],["usersession",{"2":{"119":1}}],["users",{"0":{"759":1},"2":{"43":1,"198":1,"236":1,"270":1,"326":2,"357":1,"430":1,"439":1,"479":1,"584":1,"594":1,"675":1,"678":1,"705":1,"806":1,"1013":1,"1178":1,"1189":1,"1258":1}}],["user",{"2":{"34":1,"101":1,"110":1,"119":1,"129":1,"165":1,"220":1,"264":2,"281":2,"286":1,"319":1,"321":1,"375":1,"402":3,"414":1,"431":1,"465":1,"503":1,"504":1,"517":1,"634":1,"639":1,"728":1,"854":1,"859":1,"860":3,"863":1,"869":2,"878":1,"946":1,"955":2,"972":1,"994":1,"995":1,"1012":2,"1013":2,"1016":1,"1157":1,"1167":1,"1178":4,"1186":1,"1188":3,"1190":1,"1259":1,"1260":1,"1263":1,"1264":2,"1322":1,"1324":1,"1326":1,"1335":2,"1362":1,"1363":2,"1436":1,"1448":1}}],["use",{"0":{"96":1,"198":1,"204":1,"289":1,"551":1,"1012":1,"1026":1,"1080":1,"1137":1,"1189":1,"1218":1,"1258":1,"1301":1,"1322":1,"1362":1,"1385":1,"1443":1},"1":{"97":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":1,"1033":1,"1034":1,"1035":1,"1036":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":1,"1144":1,"1145":1,"1146":1,"1147":1,"1148":1,"1149":1,"1150":1,"1190":1,"1191":1,"1192":1,"1193":1,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1259":1,"1260":1,"1261":1,"1262":1,"1263":1,"1264":1,"1265":1,"1266":1,"1267":1,"1302":1,"1303":1,"1304":1,"1305":1,"1306":1,"1307":1,"1308":1,"1309":1,"1310":1,"1311":1,"1312":1,"1313":1,"1314":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1363":1,"1364":1,"1365":1,"1366":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"6":3,"7":2,"10":3,"27":1,"30":1,"39":1,"41":4,"42":1,"43":3,"44":3,"45":2,"46":2,"54":1,"64":1,"71":1,"75":1,"78":1,"84":1,"88":2,"89":1,"97":3,"101":1,"102":1,"108":1,"109":1,"112":1,"113":2,"114":2,"117":1,"125":1,"131":4,"135":1,"136":1,"137":1,"139":1,"150":1,"157":2,"161":1,"166":1,"169":1,"173":1,"174":1,"183":1,"185":1,"186":1,"191":3,"194":1,"195":1,"197":1,"198":2,"199":2,"210":1,"211":1,"217":1,"222":1,"229":1,"230":1,"233":1,"235":1,"236":1,"246":1,"247":1,"250":6,"251":2,"259":1,"260":1,"261":1,"262":3,"266":1,"268":1,"270":1,"271":2,"274":4,"275":1,"276":6,"278":1,"282":1,"285":1,"286":1,"288":1,"289":5,"290":1,"292":2,"295":3,"296":2,"298":2,"310":1,"311":2,"315":2,"316":3,"317":2,"320":1,"325":1,"326":3,"331":2,"333":1,"334":1,"335":1,"338":1,"341":1,"346":1,"359":1,"367":1,"385":1,"386":1,"388":1,"389":2,"402":2,"431":1,"451":1,"452":1,"456":4,"458":1,"463":1,"469":2,"470":1,"479":1,"503":1,"512":1,"513":1,"518":2,"541":5,"542":1,"543":2,"544":1,"546":3,"548":1,"559":4,"580":1,"680":2,"709":1,"717":1,"720":1,"734":1,"757":2,"817":1,"832":4,"836":2,"843":1,"856":1,"867":1,"909":1,"916":1,"921":1,"923":1,"929":1,"977":1,"1000":1,"1008":1,"1019":1,"1024":1,"1025":1,"1029":1,"1030":1,"1033":1,"1036":2,"1046":1,"1049":1,"1052":1,"1055":1,"1057":1,"1059":1,"1067":1,"1076":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1098":2,"1101":1,"1105":1,"1107":1,"1113":1,"1114":1,"1115":1,"1124":1,"1127":1,"1129":1,"1132":1,"1139":1,"1140":1,"1141":1,"1144":2,"1147":2,"1150":2,"1153":1,"1155":1,"1158":1,"1164":1,"1166":1,"1167":1,"1171":1,"1172":1,"1174":1,"1178":2,"1179":1,"1184":1,"1185":1,"1210":1,"1211":1,"1239":1,"1242":2,"1243":1,"1252":1,"1254":2,"1261":1,"1263":3,"1269":1,"1274":1,"1278":1,"1282":1,"1299":1,"1300":1,"1304":1,"1313":1,"1316":1,"1319":1,"1320":1,"1321":1,"1325":1,"1326":1,"1329":1,"1332":2,"1335":1,"1337":1,"1341":1,"1343":1,"1347":1,"1349":1,"1352":1,"1353":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1,"1379":1,"1383":1,"1384":1,"1389":1,"1392":1,"1399":1,"1401":1,"1410":1,"1422":2,"1428":1,"1436":1,"1459":1}}],["uses",{"2":{"1":1,"118":1,"124":1,"128":1,"137":1,"148":1,"159":1,"162":1,"165":2,"170":1,"205":1,"212":1,"215":2,"220":1,"228":1,"243":1,"285":1,"294":1,"317":1,"326":1,"359":1,"362":1,"364":1,"384":1,"385":1,"386":1,"388":1,"399":1,"427":1,"429":1,"432":1,"435":1,"438":1,"452":1,"468":1,"471":1,"478":1,"546":2,"606":1,"676":1,"744":1,"802":1,"948":1,"972":2,"1088":1,"1110":1,"1149":1,"1176":1,"1270":1,"1365":1}}],["gnu",{"2":{"1125":1}}],["gg",{"0":{"1093":1},"2":{"1093":1}}],["gggg",{"0":{"1093":1},"2":{"137":1,"1089":1,"1093":1,"1125":2}}],["gdpr",{"2":{"1017":1}}],["gsk",{"2":{"957":1}}],["gps",{"2":{"526":1,"1084":1,"1167":1,"1168":1,"1178":1,"1188":1,"1190":1}}],["gpt",{"2":{"89":2,"860":1,"927":1,"930":1,"958":1}}],["glance",{"0":{"507":1}}],["globe",{"2":{"1084":1}}],["globalized",{"2":{"663":1}}],["globalspinner",{"2":{"485":1}}],["globally",{"2":{"116":1,"121":1,"125":1,"134":1,"166":1,"203":1,"243":1,"326":1,"331":1,"357":1,"368":1,"373":1,"431":1,"754":1,"771":1,"776":1,"937":1,"938":1,"939":1,"946":1,"959":1,"963":1,"996":1,"1178":1,"1191":1}}],["globalthis",{"0":{"112":1},"2":{"34":1,"111":2,"112":2,"336":1,"402":5,"663":1,"831":1}}],["global",{"0":{"42":1,"45":1,"56":1,"111":1,"113":1,"166":1,"401":1,"485":1,"722":1,"850":1,"931":1,"941":1,"969":1,"1178":1},"1":{"112":1,"113":1,"114":1,"115":1,"402":1,"942":1},"2":{"1":1,"6":1,"10":1,"41":1,"45":3,"56":1,"76":2,"94":1,"101":1,"111":1,"113":1,"114":3,"115":1,"116":1,"117":1,"118":2,"119":2,"121":1,"123":1,"129":2,"145":1,"147":1,"198":1,"199":1,"218":1,"229":1,"262":1,"272":1,"276":1,"326":1,"328":1,"329":1,"331":3,"338":1,"343":1,"344":1,"345":1,"348":1,"350":1,"389":1,"402":6,"403":1,"405":1,"406":2,"413":1,"414":1,"418":2,"422":1,"423":1,"439":1,"440":1,"485":1,"543":1,"544":1,"578":1,"606":1,"609":1,"631":1,"643":1,"711":1,"722":2,"746":1,"754":2,"755":1,"776":1,"800":1,"802":1,"810":1,"833":3,"850":2,"855":1,"871":1,"924":2,"930":1,"931":1,"933":1,"935":2,"937":4,"938":4,"939":1,"959":1,"969":2,"978":1,"979":1,"1004":2,"1054":1,"1154":1,"1168":1,"1178":1,"1185":1,"1187":1,"1189":1,"1207":1,"1215":1,"1224":1,"1426":1,"1447":1}}],["glossary",{"0":{"96":1,"695":1,"974":1},"1":{"97":1},"2":{"93":1,"94":2,"96":1,"97":1,"99":2,"695":4,"697":1,"938":1,"974":2}}],["glossaries",{"0":{"95":1},"2":{"92":1,"974":1}}],["gc",{"0":{"476":1,"494":1,"1374":1,"1440":1,"1442":1},"1":{"495":1,"1441":1,"1442":1},"2":{"373":1,"451":1,"476":1,"1440":1,"1442":1}}],["gmt+5",{"2":{"296":1}}],["gmt+10",{"2":{"213":1,"214":1,"240":1,"689":1}}],["gmt",{"2":{"213":1,"296":2,"689":1,"788":1,"878":1,"1135":1,"1232":2}}],["gave",{"2":{"1271":1}}],["game",{"0":{"1390":1},"1":{"1391":1,"1392":1},"2":{"1377":1,"1383":1,"1391":1}}],["games",{"2":{"1255":1}}],["gamma",{"2":{"496":1}}],["gating",{"2":{"836":1,"1010":1}}],["gate",{"2":{"473":1,"493":1}}],["gatekeeper",{"2":{"407":1,"416":2,"445":1}}],["gated",{"2":{"403":1,"493":2}}],["gateways",{"2":{"921":1,"932":1,"933":1,"948":1,"958":1,"1088":1,"1166":1,"1263":1,"1444":1}}],["gateway",{"0":{"149":1,"818":1,"932":1,"1006":1,"1008":1,"1175":1,"1191":1},"1":{"1007":1,"1008":1,"1009":1,"1176":1,"1177":1,"1178":1,"1179":1,"1180":1,"1181":1,"1182":1},"2":{"814":1,"854":1,"858":1,"859":2,"860":1,"932":1,"954":2,"955":1,"958":3,"1005":1,"1008":7,"1028":1,"1162":1,"1166":1,"1168":3,"1176":1,"1178":1,"1189":1,"1191":2}}],["garbage",{"2":{"449":1,"450":2,"473":1,"476":1,"486":1,"495":1,"798":1,"1043":1,"1370":1,"1374":1,"1395":1,"1442":1}}],["gain",{"2":{"444":1}}],["gains",{"2":{"375":1}}],["gapped",{"0":{"1017":1},"2":{"856":2}}],["gaps",{"2":{"221":1,"223":1,"681":1,"1324":1}}],["gap",{"0":{"524":1},"2":{"11":1,"167":1,"180":1,"488":1,"879":1,"897":1,"913":1,"1448":1}}],["grid",{"0":{"1323":1},"1":{"1324":1,"1325":1,"1326":1},"2":{"1081":1,"1325":1,"1326":1}}],["grids",{"2":{"1042":1,"1315":1,"1320":1}}],["gregory",{"2":{"870":1,"872":1,"890":1}}],["gregorian",{"2":{"202":1,"1097":2,"1298":1,"1303":1,"1307":1}}],["great",{"0":{"1347":1,"1355":1,"1365":1},"1":{"1356":1,"1357":1},"2":{"503":1,"1162":1,"1334":1,"1339":1,"1343":1,"1344":2,"1345":1,"1354":1,"1355":1,"1358":1,"1359":1,"1362":1,"1363":1,"1365":1}}],["greenery",{"2":{"1213":1}}],["greenfield",{"2":{"1098":1}}],["greenhouse",{"0":{"1082":1},"2":{"1052":1,"1082":1}}],["greedy",{"2":{"416":1,"445":1}}],["greetings",{"2":{"261":1}}],["greet",{"2":{"261":2}}],["grow",{"2":{"1082":1}}],["grows",{"2":{"514":1,"560":1}}],["groundhog",{"2":{"964":1}}],["grounds",{"2":{"909":1,"1013":1}}],["grounded",{"2":{"888":1}}],["grounding",{"0":{"884":1,"893":1,"902":1,"906":1,"907":1,"908":1,"909":1},"1":{"907":1,"908":2,"909":2,"910":1,"911":1,"912":1},"2":{"879":1,"881":1,"884":2,"890":2,"893":1,"897":1,"899":1,"902":1,"906":1,"907":2,"908":1,"911":3,"921":1,"922":1,"1010":2,"1012":1}}],["ground",{"2":{"512":1,"874":1,"1013":1,"1361":1}}],["groups",{"0":{"245":1},"2":{"237":1,"245":1,"323":1,"324":3,"351":1,"357":1,"359":1,"757":1,"1329":1}}],["group",{"2":{"230":1,"306":1,"315":1,"326":2,"560":1,"1351":1,"1366":1}}],["grouped",{"0":{"562":1},"1":{"563":1,"564":1,"565":1},"2":{"117":2,"313":1,"633":1,"711":1,"747":1,"786":1}}],["grouping",{"2":{"115":1,"117":1,"280":1,"562":1,"1329":1}}],["groq",{"2":{"89":1,"853":4,"856":4,"860":4,"870":1,"872":1,"880":2,"882":1,"889":2,"898":3,"913":1,"925":2,"926":1,"927":2,"929":2,"930":2,"934":2,"935":2,"937":1,"938":1,"939":3,"947":6,"953":1,"955":2,"957":2,"958":3,"961":2,"965":1,"966":1,"978":2,"979":1,"982":2,"988":2,"997":3,"1008":1,"1017":2}}],["gradual",{"0":{"1145":1},"1":{"1146":1,"1147":1},"2":{"1105":1}}],["grade",{"2":{"0":1,"287":1,"1258":1}}],["grammatical",{"2":{"1098":1}}],["grammatically",{"2":{"1095":1}}],["grammar",{"2":{"27":1,"48":1,"221":1}}],["gravitational",{"2":{"1076":2,"1080":1}}],["gracefully",{"2":{"145":1,"188":1,"282":1,"358":1,"607":1,"707":1,"980":1,"1257":1,"1372":1}}],["graceful",{"0":{"144":1,"1040":1},"2":{"144":1,"823":1,"1182":1,"1422":1}}],["grab",{"2":{"90":1}}],["graphing",{"2":{"1328":1}}],["graph",{"2":{"43":1}}],["granularity",{"2":{"912":1,"965":1}}],["granular",{"0":{"46":1},"2":{"10":1,"138":2,"625":1,"639":1,"657":1,"659":1,"671":1,"972":2,"1009":1}}],["golang",{"2":{"1103":1,"1123":1}}],["goldenhour",{"2":{"1082":1}}],["golden",{"0":{"1084":1},"2":{"388":1,"1052":1,"1082":1,"1084":1,"1353":1}}],["governed",{"2":{"1080":1}}],["government",{"2":{"1017":1,"1097":1,"1225":1}}],["governance",{"2":{"659":1,"827":1,"829":1}}],["gotchas",{"0":{"1109":1},"1":{"1110":1,"1111":1,"1112":1},"2":{"921":1}}],["gotcha",{"0":{"262":1},"2":{"972":1}}],["goal",{"0":{"231":1},"2":{"406":1,"1167":1}}],["good",{"2":{"157":1,"1213":4,"1221":4}}],["google",{"0":{"1131":1},"2":{"89":1,"939":1,"1004":1,"1014":1,"1103":1,"1104":1,"1123":1,"1134":1,"1175":1,"1189":1,"1324":1}}],["goes",{"2":{"130":1,"232":1}}],["go",{"0":{"1096":1},"2":{"78":2,"475":1,"1091":2,"1096":2,"1098":1,"1103":3,"1104":4,"1123":2}}],["gb",{"2":{"56":1,"362":1,"365":1,"370":2,"518":1,"878":1,"1213":1,"1214":1,"1220":2,"1221":1}}],["guesswork",{"2":{"1113":1}}],["guessed",{"2":{"875":1}}],["guess",{"2":{"198":1}}],["guaranteed",{"2":{"327":1,"367":2,"431":1,"465":1,"466":1,"503":1,"522":1,"856":2,"942":1,"968":1,"972":1,"1442":1}}],["guaranteeing",{"2":{"116":1,"357":1,"504":1,"683":1,"724":1,"752":1,"948":1,"1093":1,"1388":1}}],["guarantee",{"0":{"325":1,"387":1},"2":{"102":1,"121":1,"186":1,"271":1,"279":1,"369":1,"817":1,"875":1,"884":1,"972":1,"975":1,"1041":1,"1134":1}}],["guarantees",{"0":{"120":1,"861":1},"1":{"862":1,"863":1,"864":1,"865":1,"866":1},"2":{"69":1,"233":1,"295":1,"402":1,"504":1,"533":1,"651":1,"848":1,"921":1,"932":1,"1265":1,"1325":1,"1369":1,"1441":1}}],["guardrails",{"0":{"865":1}}],["guarding",{"2":{"775":1}}],["guarded",{"0":{"415":1},"1":{"416":1},"2":{"415":1,"864":1}}],["guards",{"2":{"295":1,"657":1,"744":2,"769":1,"778":1}}],["guard",{"0":{"228":1,"359":1,"415":1,"445":1,"767":1},"1":{"416":1},"2":{"34":1,"124":2,"228":3,"359":6,"407":1,"414":1,"415":1,"416":4,"419":4,"421":2,"423":1,"442":1,"444":1,"445":2,"446":1,"617":2,"622":1,"647":1,"738":3,"757":1,"763":2,"767":1}}],["guiding",{"2":{"954":1}}],["guidance",{"0":{"1043":1},"2":{"38":1,"589":1,"610":1,"614":1,"620":1,"623":1,"637":1,"640":1,"655":1,"661":1,"806":2}}],["guides",{"0":{"921":1,"1024":1,"1105":1,"1210":1,"1299":1,"1320":1,"1383":1},"2":{"13":1,"109":1,"671":1,"705":1,"708":1,"729":1,"751":2,"867":1,"921":1,"1052":1,"1105":1,"1166":1,"1242":1,"1343":1,"1401":1}}],["guide",{"0":{"33":1,"92":1,"100":1,"130":1,"196":1,"237":1,"250":1,"326":1,"764":1,"844":1,"943":1,"951":1,"1052":1,"1166":1,"1242":1,"1343":1,"1401":1},"1":{"34":1,"35":1,"36":1,"37":1,"38":1,"39":1,"40":1,"41":1,"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"93":1,"94":1,"95":1,"96":1,"97":1,"98":1,"99":1,"101":1,"102":1,"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"110":1,"111":1,"112":1,"113":1,"114":1,"115":1,"116":1,"117":1,"118":1,"119":1,"120":1,"121":1,"122":1,"123":1,"124":1,"125":1,"126":1,"127":1,"128":1,"129":1,"131":1,"132":1,"133":1,"134":1,"135":1,"136":1,"137":1,"138":1,"139":1,"140":1,"141":1,"142":1,"143":1,"144":1,"145":1,"146":1,"147":1,"197":1,"198":1,"199":1,"200":1,"201":1,"202":1,"203":1,"204":1,"205":1,"206":1,"207":1,"208":1,"209":1,"210":1,"211":1,"212":1,"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"238":1,"239":1,"240":1,"241":1,"242":1,"243":1,"244":1,"245":1,"246":1,"247":1,"248":1,"765":1,"766":1,"767":1,"768":1,"769":1,"845":1,"846":1,"847":1,"848":1,"849":1,"850":1,"851":1,"952":1,"953":1,"954":1,"955":1,"956":1,"957":1,"958":1,"959":1},"2":{"10":1,"13":1,"48":1,"56":1,"58":1,"59":1,"69":1,"76":3,"109":1,"230":2,"275":2,"280":1,"287":1,"293":2,"362":1,"452":1,"471":1,"472":1,"473":1,"475":1,"498":1,"515":1,"517":1,"518":1,"519":1,"520":1,"601":1,"637":1,"640":1,"648":1,"692":1,"697":1,"708":1,"844":1,"851":1,"861":1,"867":1,"869":1,"871":1,"881":1,"890":1,"899":1,"934":2,"936":1,"954":1,"963":2,"989":1,"1008":1,"1026":1,"1044":1,"1058":1,"1066":1,"1074":1,"1137":1,"1156":1,"1175":1,"1183":1,"1322":1,"1333":1,"1350":1,"1354":1,"1385":1,"1423":1}}],["guidelines",{"2":{"0":1,"20":1,"326":1}}],["germany",{"2":{"1207":1,"1213":1}}],["gestures",{"2":{"1324":1}}],["gesture",{"2":{"588":1}}],["genitive",{"2":{"1095":1}}],["gentle",{"2":{"786":1}}],["gen",{"2":{"419":2}}],["generic",{"2":{"408":1,"412":1,"1104":1,"1190":1}}],["generally",{"2":{"456":1}}],["generalized",{"2":{"138":1}}],["general",{"2":{"109":1,"230":1,"273":1,"275":1,"293":1,"298":1,"361":1,"945":1,"1454":1}}],["generator",{"0":{"1409":1,"1430":1,"1435":1},"2":{"600":1,"634":1,"683":1,"910":1,"986":2,"1396":1,"1405":1,"1434":1,"1446":1}}],["generators",{"2":{"531":1,"845":1,"910":1,"920":1,"1080":1,"1401":2,"1443":1}}],["generation",{"2":{"617":1,"669":1,"684":1,"755":1,"910":1}}],["generating",{"2":{"364":1,"750":1,"758":1,"981":1,"1081":1,"1115":1}}],["generative",{"2":{"89":1}}],["generatecalendarrule",{"2":{"1014":1}}],["generates",{"2":{"84":1,"467":1,"468":1,"643":1,"1016":2}}],["generatereport",{"2":{"77":1}}],["generated",{"0":{"32":1},"2":{"83":1,"220":1,"361":1,"922":1,"1009":1,"1127":2,"1128":1,"1266":1}}],["generate",{"2":{"24":1,"30":1,"66":1,"219":1,"220":1,"233":1,"451":1,"468":1,"606":1,"1017":1,"1122":1}}],["generous",{"2":{"89":1}}],["gemini",{"2":{"89":2,"853":4,"868":2,"872":1,"882":1,"913":1,"925":1,"926":1,"939":1,"958":1,"1004":1}}],["geodesic",{"2":{"1365":1}}],["geofences",{"2":{"1362":1}}],["geofencing",{"0":{"1333":1,"1364":1},"1":{"1334":1,"1335":1,"1336":1,"1337":1,"1338":1},"2":{"1333":1,"1339":1,"1343":2,"1344":2}}],["geoprovider",{"0":{"1176":1},"2":{"1172":1,"1176":1,"1178":2,"1191":2}}],["geoplugin",{"2":{"289":2,"290":2,"812":1,"816":1,"1158":2,"1164":3,"1171":2,"1172":2,"1178":2,"1179":1,"1184":2}}],["geolookupresult",{"2":{"1176":1}}],["geolookup",{"2":{"1169":1,"1182":1}}],["geolocating",{"2":{"869":1}}],["geolocation",{"2":{"83":1,"479":1,"526":1,"588":1,"824":1,"1162":1,"1168":5,"1171":1,"1175":1,"1176":2,"1193":1,"1214":1}}],["geolocate",{"0":{"1158":1},"1":{"1159":1},"2":{"142":1,"1158":3,"1159":1,"1167":1,"1169":1,"1171":1,"1172":2,"1173":1,"1180":1}}],["geocoder",{"2":{"1191":1}}],["geocoded",{"2":{"1181":1}}],["geocode",{"2":{"1172":1}}],["geocodes",{"2":{"1168":2}}],["geocoding",{"0":{"1172":1,"1175":1,"1181":1,"1191":1},"1":{"1176":1,"1177":1,"1178":1,"1179":1,"1180":1,"1181":1,"1182":1},"2":{"1162":1,"1166":5,"1168":3,"1169":1,"1175":1,"1176":5,"1178":2,"1181":2,"1189":1,"1191":1,"1192":2}}],["geoconfig",{"2":{"121":1,"227":1,"1168":1,"1176":1}}],["geography",{"2":{"1156":1,"1158":1}}],["geographically",{"2":{"1361":1,"1366":1}}],["geographic",{"0":{"121":1,"142":1,"226":1,"824":1,"1054":1,"1157":1,"1337":1,"1359":1},"1":{"227":1},"2":{"117":1,"121":1,"142":1,"154":1,"227":1,"821":1,"869":1,"1046":1,"1054":2,"1055":1,"1061":1,"1065":1,"1067":1,"1071":1,"1079":1,"1160":2,"1189":2,"1190":1,"1193":1,"1220":1,"1336":1,"1339":1,"1343":1,"1344":2,"1354":1,"1355":1,"1360":1,"1363":1,"1366":1}}],["geometry",{"2":{"1075":1,"1168":1,"1339":1,"1353":1,"1362":1}}],["geometric",{"2":{"1067":1,"1070":1,"1162":1}}],["geooptions",{"2":{"117":1}}],["geo",{"0":{"121":1,"142":1,"226":1,"1162":1,"1168":1,"1171":1,"1178":1,"1192":1,"1214":1},"1":{"227":1,"1163":1,"1164":1,"1165":1,"1166":1,"1167":1,"1168":1,"1169":2,"1170":1,"1171":1,"1172":1,"1173":1,"1174":1},"2":{"87":2,"117":1,"121":3,"141":1,"142":10,"143":1,"144":9,"145":8,"154":1,"226":4,"227":1,"274":1,"289":1,"290":1,"364":1,"788":1,"812":2,"821":1,"823":4,"824":2,"1046":1,"1054":4,"1055":1,"1056":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1067":2,"1068":1,"1069":2,"1070":1,"1071":1,"1072":2,"1076":1,"1078":2,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1103":1,"1156":1,"1158":2,"1160":1,"1163":1,"1164":2,"1165":1,"1167":4,"1168":14,"1171":5,"1172":5,"1173":2,"1175":1,"1176":1,"1178":3,"1181":5,"1182":1,"1183":1,"1184":6,"1186":4,"1187":1,"1188":4,"1189":1,"1190":2,"1191":9,"1192":6,"1193":2,"1195":2,"1197":1,"1199":1,"1201":2,"1203":2,"1205":2,"1207":2,"1209":3,"1214":5,"1216":1,"1217":1,"1220":2,"1221":1,"1222":1,"1223":2,"1335":1,"1337":1,"1348":2,"1352":1,"1357":1,"1358":1,"1360":2,"1361":2,"1363":2,"1366":1}}],["getbuffer",{"2":{"1379":1,"1382":1,"1389":1}}],["getidesday",{"0":{"1297":1}}],["getnonesday",{"0":{"1296":1}}],["getnightsurveycontext",{"2":{"1085":1}}],["getprovider",{"2":{"1168":1}}],["getpublicholidays",{"2":{"885":3}}],["getlc",{"2":{"1161":1}}],["getlazydelegator",{"2":{"412":1}}],["getmilliseconds",{"2":{"1089":1}}],["getminutes",{"2":{"1089":1}}],["getmonth",{"2":{"138":1,"1089":1}}],["gethours",{"2":{"1089":1}}],["getdate",{"2":{"1089":1}}],["getday",{"2":{"138":1}}],["getfullyear",{"2":{"1089":1}}],["getgreenhouselightingplan",{"2":{"1082":1}}],["getstashedgeo",{"2":{"1168":1}}],["getstore",{"2":{"69":2,"119":2,"1004":1}}],["getseconds",{"2":{"1089":1}}],["getsecret",{"2":{"1004":1}}],["getvaultsecret",{"2":{"958":1}}],["getaverages",{"2":{"1329":2}}],["getauctionremainingtime",{"2":{"1261":1}}],["getairatelimits",{"0":{"969":1},"2":{"969":3}}],["getaiconfig",{"2":{"864":1,"1003":1}}],["getapikey",{"2":{"933":1}}],["getaccesstoken",{"2":{"1004":1}}],["getaccessors",{"2":{"664":1}}],["getactivegatewayurl",{"2":{"933":1}}],["getactivetenanttimezone",{"2":{"536":2}}],["getactivetoken",{"2":{"477":1}}],["getresolvedproviderdefaults",{"2":{"856":1}}],["getrotatedkey",{"2":{"855":1}}],["getuserpreferredformat",{"2":{"807":1}}],["getconsuls",{"0":{"1291":1}}],["getcontext",{"2":{"449":1}}],["getcurrentuserlocale",{"2":{"536":1}}],["getkey",{"2":{"477":1}}],["getweekinfo",{"2":{"71":1,"366":1}}],["get",{"0":{"52":1,"53":1},"2":{"76":1,"119":1,"267":1,"269":1,"285":1,"409":1,"425":1,"426":2,"461":1,"468":1,"534":1,"739":2,"860":1,"978":2,"980":1,"1168":1,"1186":1,"1192":2,"1193":2,"1329":1,"1381":2}}],["gettotptimestep",{"2":{"1266":1}}],["gettempo",{"2":{"1381":1,"1382":1,"1389":1}}],["gettextinfo",{"2":{"366":1}}],["gettermrange",{"0":{"319":1},"2":{"313":2,"314":1,"319":2,"320":1,"326":1}}],["getter",{"0":{"1089":1},"2":{"129":1,"148":2,"149":2,"150":1,"151":1,"152":2,"153":1,"154":1,"155":1,"233":1,"295":1,"300":1,"307":1,"336":1,"409":2,"424":2,"425":2,"426":1,"427":1,"458":1,"818":1,"831":1,"1089":1,"1105":1,"1168":1,"1247":1,"1248":1,"1249":1,"1286":1}}],["getters",{"0":{"148":1,"768":1},"1":{"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"155":1},"2":{"24":1,"148":1,"152":2,"155":1,"233":1,"251":1,"347":1,"409":1,"410":1,"412":1,"424":1,"425":1,"427":1,"428":1,"458":1,"477":1,"507":1,"513":1,"516":1,"518":1,"536":1,"707":1,"708":1,"763":3,"768":1,"771":1,"776":1,"787":1,"851":1,"1121":1}}],["gettime",{"2":{"1260":1}}],["gettimezones",{"2":{"215":1}}],["getting",{"2":{"13":1,"712":1}}],["gis",{"2":{"1162":1,"1303":1,"1339":1,"1362":1}}],["gibbous",{"2":{"1059":4}}],["giving",{"2":{"147":1,"506":1,"786":1}}],["given",{"2":{"99":1,"128":1,"159":1,"302":1,"321":2,"972":1,"1334":1}}],["give",{"2":{"11":1,"48":1,"447":1}}],["gives",{"2":{"11":1,"265":1,"375":1,"452":1,"466":1,"468":1,"503":1,"520":1,"1218":1}}],["git",{"2":{"4":1}}],["github",{"0":{"27":1},"2":{"4":1,"21":2,"24":1,"27":2,"48":1,"229":1,"247":1,"534":2,"607":1,"635":1,"666":1,"669":1,"922":1,"1376":1,"1378":1}}],["gt",{"0":{"792":1,"793":1,"807":1,"1246":1,"1415":1},"2":{"10":2,"45":1,"69":1,"96":2,"97":3,"102":2,"115":3,"117":6,"119":2,"137":1,"138":1,"142":2,"191":3,"250":2,"297":4,"301":6,"323":7,"326":1,"370":1,"383":3,"386":1,"388":1,"393":4,"398":1,"399":1,"465":2,"473":1,"476":1,"477":5,"488":1,"489":2,"492":2,"494":1,"505":1,"536":2,"546":4,"709":3,"722":2,"734":1,"735":2,"738":1,"739":1,"755":2,"790":2,"792":1,"804":1,"807":1,"830":1,"838":2,"850":1,"855":1,"856":1,"866":1,"910":1,"919":1,"920":1,"932":1,"933":2,"935":3,"937":7,"942":1,"959":5,"989":1,"991":1,"997":1,"1004":4,"1021":1,"1054":1,"1072":1,"1077":1,"1089":1,"1090":1,"1186":1,"1240":1,"1318":1,"1338":1,"1344":1,"1403":2,"1405":2,"1415":1,"1425":5}}],["g",{"2":{"6":1,"12":1,"22":1,"31":1,"43":1,"52":1,"59":1,"71":1,"76":1,"96":2,"97":3,"99":1,"102":2,"107":1,"116":1,"117":2,"125":1,"128":1,"129":1,"131":1,"137":1,"138":13,"143":2,"145":1,"146":1,"150":1,"155":1,"157":3,"158":2,"159":1,"161":2,"164":1,"166":1,"167":2,"173":1,"186":1,"189":2,"204":2,"213":2,"214":1,"216":1,"219":1,"221":1,"224":1,"235":1,"241":2,"242":2,"243":1,"245":1,"263":1,"266":1,"270":1,"271":2,"272":2,"273":2,"274":3,"276":1,"280":1,"281":2,"291":1,"295":1,"296":1,"297":2,"300":1,"301":3,"315":2,"317":1,"318":1,"321":2,"323":2,"324":1,"325":2,"326":5,"338":1,"351":2,"357":2,"362":1,"363":1,"364":1,"365":1,"366":1,"370":5,"375":1,"376":4,"380":1,"387":1,"388":1,"399":1,"403":2,"406":1,"412":1,"416":1,"418":1,"426":1,"427":1,"429":1,"431":1,"434":1,"446":1,"447":1,"448":1,"450":1,"466":1,"468":1,"469":1,"477":1,"479":2,"500":1,"505":1,"531":1,"536":1,"571":1,"606":1,"631":1,"642":1,"644":1,"678":1,"680":3,"689":1,"719":1,"722":1,"724":1,"726":1,"732":1,"743":1,"746":1,"750":1,"752":1,"758":2,"763":1,"773":3,"788":1,"806":1,"817":1,"833":1,"838":1,"842":2,"854":1,"855":1,"863":1,"866":1,"868":1,"869":1,"871":1,"872":3,"875":1,"879":1,"881":2,"884":1,"885":1,"886":2,"890":5,"897":1,"899":4,"902":1,"906":2,"907":1,"910":1,"912":1,"934":1,"937":2,"938":3,"939":1,"950":1,"951":2,"970":1,"974":1,"978":1,"983":1,"986":1,"987":1,"995":1,"997":3,"1004":2,"1009":2,"1010":1,"1012":1,"1014":1,"1017":1,"1028":1,"1030":1,"1032":1,"1042":1,"1054":1,"1055":1,"1062":2,"1065":2,"1067":1,"1068":1,"1071":1,"1078":3,"1081":1,"1085":2,"1088":1,"1089":1,"1093":2,"1094":1,"1096":1,"1097":1,"1110":1,"1111":1,"1113":1,"1124":1,"1125":2,"1139":1,"1144":2,"1157":1,"1158":3,"1168":1,"1178":1,"1188":1,"1190":2,"1193":1,"1207":1,"1213":1,"1214":1,"1220":2,"1222":2,"1224":1,"1233":1,"1240":1,"1263":1,"1273":1,"1276":1,"1289":1,"1292":1,"1303":1,"1312":1,"1319":2,"1324":2,"1328":2,"1338":1,"1351":1,"1361":2,"1364":1,"1370":1,"1376":1,"1404":1,"1414":1,"1415":2,"1421":1,"1436":1,"1444":1,"1447":1,"1450":1,"1454":1,"1457":1}}],["pâques",{"2":{"1213":1}}],["pfingstmontag",{"2":{"1213":1}}],["pt",{"2":{"1160":1}}],["python",{"2":{"1099":1,"1103":2,"1123":1,"1125":1}}],["pv",{"0":{"1081":1}}],["px",{"2":{"978":1}}],["pseudonymous",{"2":{"954":1,"1008":3}}],["pseudo",{"2":{"626":1}}],["pst",{"2":{"213":1,"214":3,"240":1,"296":1,"689":1}}],["p1d",{"2":{"224":1}}],["p1y1m",{"2":{"166":1}}],["p1y2m15d",{"2":{"160":1}}],["p36y",{"2":{"159":1}}],["pm",{"2":{"137":2,"138":1,"144":1,"167":1,"245":1,"370":1,"450":1,"878":1,"889":1,"898":2,"993":1,"1081":1,"1094":2,"1103":1,"1104":1,"1113":1,"1125":1,"1139":1,"1141":2,"1147":1,"1203":2,"1204":1,"1219":1}}],["p",{"2":{"117":1,"481":4,"482":3,"483":3,"484":3,"486":2,"487":6,"709":2,"997":1,"1125":1}}],["pickers",{"2":{"1315":1}}],["picking",{"2":{"260":1}}],["pitfall",{"2":{"1110":1}}],["pitfalls",{"2":{"137":1,"205":1}}],["pixel",{"2":{"1063":1}}],["pii",{"0":{"995":1,"997":1,"1017":1},"1":{"996":1,"997":1},"2":{"861":1,"869":1,"871":1,"921":1,"930":1,"936":1,"994":1,"998":2,"1011":3,"1012":2,"1017":1}}],["pinned",{"2":{"1444":1}}],["pinning",{"2":{"47":1,"476":1,"1004":1}}],["ping",{"2":{"1262":1}}],["pin",{"2":{"560":1}}],["pipeline",{"0":{"1145":1},"1":{"1146":1,"1147":1},"2":{"617":1,"626":1,"635":1,"667":1,"669":1,"709":2,"716":1,"722":1,"744":1,"751":1,"755":1,"878":1,"1147":1}}],["pipelines",{"0":{"1114":1},"2":{"322":1,"515":1,"760":2,"798":1,"1018":1,"1024":1,"1042":1,"1088":1,"1105":1,"1135":1,"1225":1,"1235":1,"1322":1,"1331":1,"1446":1}}],["piping",{"2":{"502":1}}],["pizza",{"2":{"448":1}}],["piece",{"2":{"362":1}}],["pillars",{"2":{"361":1,"407":2}}],["pisces",{"2":{"305":2}}],["pivot",{"0":{"878":1},"2":{"116":1,"117":1}}],["peak",{"2":{"1022":1,"1081":3,"1122":1,"1147":1}}],["penalty",{"2":{"1235":1}}],["pentecôte",{"2":{"1213":1}}],["penumbral",{"2":{"1053":1,"1065":1}}],["penultimate",{"2":{"98":2,"324":1,"908":1,"918":1,"934":1,"961":1}}],["pending",{"2":{"463":2,"475":1,"486":1,"487":1,"489":1,"495":1,"810":1,"946":1,"1405":1,"1435":1}}],["percent",{"2":{"1091":1,"1129":1}}],["percentage",{"2":{"387":1,"449":1}}],["perigean",{"2":{"1077":1,"1080":1,"1083":1}}],["perigeefactor",{"0":{"1077":1},"2":{"1077":3}}],["perigee",{"0":{"1077":1},"2":{"1052":1,"1053":1,"1055":1,"1064":2,"1074":1,"1075":2,"1077":3}}],["periodic",{"2":{"1239":1,"1240":1,"1372":1}}],["periods",{"0":{"123":1,"223":1,"306":1},"2":{"96":2,"97":1,"102":1,"105":1,"115":1,"117":1,"123":2,"138":1,"297":1,"333":1,"378":1,"516":1,"544":1,"625":1,"773":1,"1072":1,"1157":1}}],["period",{"2":{"63":1,"127":1,"177":1,"240":1,"241":1,"242":1,"245":1,"257":1,"306":1,"307":1,"315":3,"329":1,"339":1,"348":1,"351":1,"380":1,"387":4,"417":1,"631":1,"639":1,"1035":1,"1415":3}}],["permitted",{"2":{"862":1,"1395":1}}],["permits",{"2":{"782":1}}],["permission",{"2":{"714":1}}],["permanently",{"2":{"695":1,"1003":1}}],["permutations",{"2":{"342":1}}],["perth",{"2":{"296":1}}],["per",{"0":{"855":1},"2":{"119":1,"121":1,"164":1,"199":1,"203":1,"240":1,"241":1,"243":1,"245":1,"266":1,"326":1,"327":1,"368":1,"410":1,"423":1,"449":1,"536":2,"642":1,"738":1,"754":1,"771":1,"776":3,"838":2,"855":2,"856":1,"860":1,"871":2,"908":1,"933":2,"936":1,"939":2,"941":1,"948":1,"953":1,"955":1,"962":1,"963":1,"972":2,"973":1,"979":1,"1004":1,"1178":1,"1180":1,"1235":1,"1267":1,"1331":2,"1332":1,"1419":1,"1420":1,"1443":1}}],["perspective",{"2":{"908":1}}],["persisted",{"2":{"1429":1}}],["persistence",{"2":{"129":1,"472":1,"616":1,"663":1,"1005":1,"1008":1,"1009":1,"1183":1}}],["persistent",{"0":{"110":1},"2":{"101":1,"110":1,"117":1,"199":1,"588":1,"1004":1}}],["persisting",{"2":{"1008":1}}],["persist",{"2":{"110":1,"406":1,"1009":1}}],["personally",{"2":{"994":1}}],["personal",{"2":{"89":1,"923":1,"954":2,"1008":1,"1025":1,"1057":1,"1107":1,"1155":1,"1174":1,"1211":1,"1252":1,"1300":1,"1321":1,"1349":1,"1384":1,"1410":1}}],["performing",{"2":{"440":1}}],["performant",{"2":{"266":1,"1103":1}}],["performance",{"0":{"228":1,"371":1,"405":1,"419":1,"441":1,"473":1,"488":1,"672":1,"795":1,"796":1,"1042":1,"1106":1,"1120":1},"1":{"372":1,"373":1,"442":1,"443":1,"444":1,"445":1,"446":1,"447":1,"448":1,"449":1,"450":1,"451":1,"489":1,"490":1,"491":1,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1,"797":1,"798":1,"1043":1,"1121":1,"1122":1},"2":{"0":1,"33":1,"41":1,"92":1,"125":1,"126":1,"174":1,"293":1,"361":1,"363":1,"364":1,"375":1,"377":1,"405":1,"406":1,"407":2,"415":1,"416":2,"419":2,"423":1,"429":1,"441":1,"445":1,"446":2,"447":2,"449":1,"450":1,"476":2,"505":1,"513":1,"529":1,"531":1,"532":1,"575":1,"606":1,"622":1,"625":1,"635":2,"666":1,"672":1,"676":1,"694":1,"711":1,"737":1,"754":1,"755":1,"784":1,"792":1,"954":1,"1008":1,"1098":1,"1105":1,"1120":1,"1226":1,"1235":1,"1301":1,"1391":1,"1396":1}}],["perform",{"2":{"162":1,"192":1,"281":1,"434":1,"532":1,"787":1,"1192":1,"1243":1,"1433":1,"1450":1}}],["performed",{"2":{"157":1,"461":1}}],["performs",{"2":{"127":1,"276":1,"472":1,"1184":1,"1293":1}}],["perfectly",{"2":{"39":1,"161":1,"165":1,"517":2}}],["perfect",{"2":{"11":2,"162":1,"165":1,"176":1,"198":1,"429":1,"838":1,"1018":1,"1377":1}}],["pdt",{"2":{"81":1,"296":1}}],["physx",{"2":{"1391":1}}],["physicssimulationworker",{"2":{"1392":1}}],["physics",{"2":{"1080":1,"1353":1,"1367":1,"1383":1,"1391":2,"1392":3}}],["physical",{"0":{"1366":1},"2":{"227":1,"526":1,"1011":1,"1054":1,"1080":1,"1081":1,"1156":1,"1157":1,"1158":1,"1169":1,"1171":1,"1190":1,"1331":1,"1332":1,"1343":1,"1344":1,"1351":2,"1360":1,"1361":1,"1362":1,"1363":1}}],["phrasing",{"2":{"1276":1,"1278":1,"1280":1}}],["phrase",{"2":{"221":1,"223":1}}],["phrases",{"2":{"12":1,"59":1,"223":1,"390":1,"975":1}}],["photogrammetry",{"2":{"1084":1}}],["photography",{"2":{"1071":1,"1353":1}}],["photographer",{"2":{"870":1}}],["photosynthetically",{"2":{"1082":1}}],["photometric",{"0":{"1071":1},"2":{"1066":1}}],["photovoltaic",{"0":{"1081":1},"2":{"1052":1,"1080":1}}],["phones",{"2":{"936":1,"1011":1}}],["phone",{"2":{"869":1,"994":1,"995":1,"997":1}}],["philosophy",{"2":{"146":1,"273":1,"361":1,"994":1}}],["phases",{"0":{"1058":1},"1":{"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1},"2":{"1050":1,"1052":1,"1054":1,"1059":1,"1066":1,"1067":1,"1085":1}}],["phased",{"2":{"768":1}}],["phase",{"0":{"1059":1,"1067":1},"2":{"87":1,"312":1,"359":1,"374":1,"409":1,"416":1,"418":1,"440":1,"502":1,"1053":2,"1054":1,"1055":6,"1058":1,"1059":3,"1067":1,"1078":1,"1085":1,"1122":3,"1304":1}}],["php",{"0":{"78":1},"2":{"78":3,"138":2,"150":1,"1086":1,"1093":1,"1103":3,"1104":3,"1123":2}}],["pops",{"2":{"1394":1}}],["populates",{"2":{"958":1,"1281":1}}],["populated",{"2":{"367":1}}],["populating",{"2":{"444":1}}],["portals",{"2":{"1363":1}}],["portability",{"2":{"367":1}}],["portable",{"2":{"147":1,"479":1,"1125":2}}],["ported",{"2":{"1118":1}}],["porting",{"2":{"1109":1}}],["ports",{"2":{"1083":1}}],["portcalibrated",{"2":{"1078":2}}],["port",{"0":{"1078":1},"2":{"1074":1,"1078":4,"1083":7}}],["portfolio",{"2":{"1032":1}}],["portkey",{"2":{"858":1}}],["pools",{"2":{"867":2,"948":1}}],["pool",{"0":{"1037":1},"1":{"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1},"2":{"755":1,"934":1,"942":1,"947":1,"1019":1,"1022":1,"1024":1,"1033":1,"1036":1,"1037":1}}],["pojo",{"2":{"439":1}}],["poisoning",{"2":{"413":1,"414":1,"617":1,"866":1}}],["pointer",{"2":{"1325":1}}],["pointers",{"2":{"427":1}}],["points",{"0":{"1269":1},"2":{"116":1,"167":1,"250":1,"467":1,"471":1,"525":1,"557":1,"559":2,"648":1,"672":1,"711":1,"894":1,"1243":1,"1268":1,"1269":1,"1328":1,"1331":1,"1344":1,"1359":1}}],["pointing",{"2":{"110":1}}],["point",{"0":{"103":1,"104":1,"960":1},"1":{"961":1,"962":1,"963":1,"964":1,"965":1},"2":{"46":1,"89":1,"102":2,"170":1,"177":1,"316":1,"341":1,"351":1,"352":1,"387":1,"412":1,"415":1,"423":1,"427":1,"444":1,"520":2,"524":1,"559":1,"671":1,"687":1,"724":1,"741":1,"891":3,"910":1,"919":1,"920":1,"950":1,"960":1,"1232":1,"1270":1,"1329":3,"1336":1,"1344":1,"1358":2,"1404":1,"1448":1}}],["powershell",{"2":{"1103":1,"1123":1}}],["powers",{"2":{"773":1}}],["power",{"2":{"146":1,"734":1,"854":1,"1081":1,"1443":1}}],["powerful",{"2":{"130":1,"146":1,"156":1,"175":1,"224":1,"266":1,"351":1,"371":1,"378":1,"518":1,"754":1}}],["powered",{"2":{"11":1,"12":2,"89":1,"159":1,"203":1,"365":1,"913":1,"953":1,"1416":1}}],["possibility",{"2":{"1096":1}}],["possible",{"2":{"300":1,"359":1,"427":1,"949":1}}],["possibly",{"2":{"127":1}}],["postgres",{"2":{"1103":1}}],["postgresql",{"2":{"78":1,"1029":1,"1099":1,"1103":2,"1104":1,"1123":1,"1149":1}}],["postmessage",{"0":{"1040":1},"2":{"1024":1,"1038":1,"1040":1,"1368":2,"1370":1,"1387":1}}],["post",{"2":{"860":2,"955":1,"1039":1,"1040":1,"1264":1,"1444":1}}],["positional",{"2":{"842":1,"1417":1}}],["positions",{"2":{"454":1,"1076":1}}],["positioning",{"2":{"213":1}}],["position",{"0":{"1058":1,"1062":1},"1":{"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1},"2":{"195":1,"214":1,"381":1,"388":1,"737":2,"871":1,"920":2,"973":1,"1052":1,"1053":1,"1058":1,"1062":1,"1069":1,"1080":1,"1325":1}}],["positives",{"2":{"763":1}}],["positive",{"2":{"138":2,"150":1,"152":1,"157":1,"702":1,"757":1,"767":1,"986":1,"1294":1}}],["posixmask",{"2":{"1116":2}}],["posixexport",{"2":{"1115":2}}],["posix",{"0":{"78":1,"1129":1,"1142":1},"1":{"1143":1,"1144":1},"2":{"78":1,"137":1,"138":2,"205":1,"808":1,"1086":1,"1090":1,"1091":1,"1093":1,"1099":1,"1103":2,"1104":2,"1105":1,"1108":1,"1112":1,"1115":2,"1116":2,"1123":1,"1125":5,"1143":1,"1144":1,"1149":1,"1150":1}}],["poc",{"2":{"22":1}}],["potentially",{"2":{"647":1}}],["potential",{"2":{"22":2,"402":1,"468":1}}],["polarnight",{"2":{"1072":3}}],["polar",{"0":{"1072":2},"2":{"1063":1,"1066":1}}],["polish",{"2":{"1095":1}}],["political",{"2":{"1054":1,"1067":1}}],["policies",{"0":{"979":1},"2":{"1040":1,"1375":1}}],["policy",{"0":{"18":1,"47":1},"1":{"19":1,"20":1,"21":1,"22":1,"23":1},"2":{"271":1,"1008":1,"1178":1,"1375":2,"1378":2}}],["polynomial",{"2":{"1045":1}}],["polyfill",{"0":{"34":1,"38":1},"2":{"3":2,"10":3,"27":1,"34":6,"38":3,"42":3,"43":3,"44":2,"45":2,"165":1,"170":2,"574":1,"578":1,"640":1,"651":1,"752":2,"850":2}}],["polluting",{"2":{"328":1,"356":1,"403":1,"465":1,"711":1,"776":1}}],["pollution",{"2":{"116":1,"230":1,"269":1,"453":1,"722":1,"744":1,"998":1}}],["polluted",{"2":{"249":1}}],["pnpm",{"2":{"10":2,"35":2,"648":1,"846":2}}],["p2m2d",{"2":{"9":1}}],["pledge",{"0":{"474":1,"480":1},"1":{"475":1,"481":1,"482":1,"483":1,"484":1,"485":1,"486":1,"487":1},"2":{"474":1,"475":2,"480":1,"481":3,"482":3,"483":2,"484":2,"485":2,"486":4,"592":1,"596":1,"598":1,"841":1}}],["please",{"2":{"0":1,"7":1,"8":1,"10":1,"15":1,"20":1,"21":1,"22":1,"572":1,"922":1}}],["pluggable",{"0":{"1175":1,"1191":1},"1":{"1176":1,"1177":1,"1178":1,"1179":1,"1180":1,"1181":1,"1182":1},"2":{"1162":1,"1166":1,"1176":1}}],["plug",{"2":{"276":1,"1191":1}}],["plugincontainer",{"2":{"617":1}}],["pluginc",{"2":{"292":1}}],["pluginb",{"2":{"286":2,"290":1,"292":1}}],["plugina",{"2":{"286":2,"290":1,"292":1}}],["pluginfactory",{"2":{"285":1}}],["pluginoptions",{"0":{"291":1,"541":1,"830":1},"1":{"542":1},"2":{"102":3,"115":1,"117":1,"235":3,"285":1,"288":1,"290":1,"291":4,"333":1,"540":1,"541":3,"542":1,"827":1,"830":3}}],["pluginsdb",{"2":{"653":1,"782":2}}],["plugins",{"0":{"45":1,"87":1,"273":1,"526":1,"541":1,"832":1,"851":1},"1":{"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1,"284":1,"285":1,"286":1,"287":1,"288":1,"289":1,"290":1,"291":1,"292":1,"293":1,"542":1},"2":{"9":1,"10":2,"11":1,"14":1,"41":3,"43":2,"44":2,"45":5,"85":1,"87":1,"102":7,"107":1,"114":1,"115":2,"117":3,"193":1,"199":2,"229":2,"230":1,"262":5,"263":1,"266":1,"267":1,"272":1,"273":1,"274":1,"275":1,"276":6,"278":1,"281":1,"282":1,"283":1,"287":1,"290":2,"291":5,"292":2,"293":1,"307":1,"322":2,"331":3,"333":1,"338":1,"343":1,"346":2,"353":1,"388":1,"406":1,"415":1,"416":1,"448":1,"504":1,"513":1,"519":1,"526":1,"533":1,"541":7,"542":1,"548":1,"592":2,"644":1,"653":1,"678":1,"697":1,"716":1,"722":3,"726":1,"751":1,"757":1,"759":1,"771":3,"778":1,"780":1,"782":2,"812":1,"816":5,"830":4,"832":2,"833":1,"841":1,"844":1,"845":1,"846":2,"848":3,"849":1,"850":4,"851":1,"909":1,"926":1,"927":1,"1121":1,"1125":1,"1254":1,"1454":1}}],["plugin",{"0":{"77":1,"78":1,"88":1,"98":2,"143":1,"204":1,"229":1,"230":1,"236":1,"263":1,"275":1,"284":1,"285":1,"288":1,"293":1,"302":1,"312":1,"313":1,"316":1,"531":1,"537":2,"728":1,"782":1,"808":2,"816":1,"840":2,"844":1,"913":1,"1018":1,"1050":1,"1099":1,"1151":1,"1162":1,"1179":1,"1206":1,"1236":1,"1239":1,"1275":1,"1280":1,"1282":1,"1315":1,"1339":1,"1377":1,"1396":1,"1399":1,"1449":1},"1":{"99":2,"231":1,"232":1,"233":1,"234":1,"235":1,"236":1,"264":1,"265":1,"266":1,"267":1,"268":1,"269":1,"270":1,"271":1,"272":1,"285":1,"286":1,"287":1,"289":1,"290":1,"291":1,"303":1,"304":1,"305":1,"306":1,"313":1,"314":1,"315":1,"316":1,"317":1,"845":1,"846":1,"847":1,"848":1,"849":1,"850":1,"851":1,"914":1,"915":1,"916":1,"917":1,"918":1,"919":1,"920":1,"921":1,"922":1,"923":1,"1019":1,"1020":1,"1021":1,"1022":1,"1023":1,"1024":1,"1025":1,"1051":1,"1052":1,"1053":1,"1054":1,"1055":1,"1056":1,"1057":1,"1100":1,"1101":1,"1102":1,"1103":1,"1104":1,"1105":1,"1106":1,"1107":1,"1152":1,"1153":1,"1154":1,"1155":1,"1163":1,"1164":1,"1165":1,"1166":1,"1167":1,"1168":1,"1169":1,"1170":1,"1171":1,"1172":1,"1173":1,"1174":1,"1207":1,"1208":1,"1209":1,"1210":1,"1211":1,"1237":1,"1238":1,"1239":1,"1240":1,"1241":1,"1242":1,"1243":1,"1244":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1252":1,"1276":1,"1277":1,"1278":1,"1279":1,"1280":1,"1281":1,"1282":1,"1283":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1299":1,"1300":1,"1316":1,"1317":1,"1318":1,"1319":1,"1320":1,"1321":1,"1340":1,"1341":1,"1342":1,"1343":1,"1344":1,"1345":1,"1346":1,"1347":1,"1348":1,"1349":1,"1378":1,"1379":1,"1380":1,"1381":1,"1382":1,"1383":1,"1384":1,"1397":1,"1398":1,"1399":1,"1400":1,"1401":1,"1402":1,"1403":1,"1404":1,"1405":1,"1406":1,"1407":1,"1408":1,"1409":1,"1410":1,"1450":1,"1451":1,"1452":1},"2":{"9":2,"12":1,"14":1,"43":4,"44":8,"45":1,"72":1,"77":2,"78":4,"83":1,"85":1,"87":2,"88":5,"89":1,"93":3,"98":3,"102":9,"107":1,"115":3,"117":3,"120":1,"137":4,"141":1,"143":4,"204":2,"205":4,"229":2,"230":4,"232":3,"234":3,"235":1,"236":4,"261":1,"262":2,"264":1,"265":2,"267":1,"268":1,"269":1,"270":1,"271":3,"273":3,"274":7,"275":1,"276":9,"279":1,"280":1,"281":5,"282":2,"283":1,"284":1,"285":5,"286":4,"288":2,"289":6,"290":3,"291":1,"292":1,"293":3,"300":1,"301":4,"312":2,"313":2,"315":1,"316":1,"317":1,"318":1,"319":1,"321":1,"326":3,"330":1,"333":1,"334":1,"335":1,"402":1,"404":1,"421":1,"430":1,"431":1,"434":1,"439":1,"440":1,"444":1,"507":2,"516":1,"519":2,"526":1,"531":1,"534":1,"535":1,"537":6,"539":1,"541":6,"542":1,"547":1,"548":5,"551":1,"592":1,"596":3,"597":1,"598":1,"609":1,"637":1,"643":1,"644":1,"672":2,"696":1,"701":4,"702":1,"708":1,"709":1,"711":1,"712":4,"716":1,"728":7,"751":1,"755":1,"757":2,"759":6,"775":3,"776":1,"780":1,"782":2,"788":1,"792":1,"804":1,"806":2,"808":1,"810":1,"812":4,"814":1,"823":1,"832":1,"835":1,"836":2,"840":3,"842":1,"845":1,"846":8,"848":1,"849":1,"850":3,"851":2,"852":2,"853":3,"856":1,"859":1,"861":1,"863":1,"865":1,"866":1,"867":1,"870":2,"878":1,"880":1,"889":1,"898":1,"906":1,"907":2,"909":1,"910":3,"911":1,"913":2,"914":1,"915":3,"916":1,"917":1,"918":1,"920":1,"921":1,"922":2,"923":1,"924":1,"925":2,"929":1,"930":1,"931":1,"933":1,"934":1,"936":1,"939":3,"951":1,"954":2,"955":1,"957":1,"958":1,"961":1,"966":1,"969":1,"970":3,"972":1,"973":1,"976":1,"978":1,"979":1,"980":1,"982":1,"988":1,"994":3,"995":1,"997":1,"1007":1,"1008":1,"1010":2,"1012":2,"1013":1,"1014":1,"1015":1,"1016":1,"1017":2,"1018":1,"1019":2,"1020":1,"1021":1,"1025":1,"1026":1,"1030":1,"1033":1,"1036":1,"1037":2,"1044":1,"1046":1,"1049":1,"1050":1,"1051":1,"1054":1,"1055":1,"1056":1,"1057":1,"1058":1,"1059":1,"1066":1,"1067":1,"1074":1,"1076":1,"1080":2,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1086":2,"1092":1,"1098":1,"1099":1,"1100":1,"1101":1,"1102":1,"1103":2,"1104":1,"1107":1,"1108":2,"1110":1,"1113":2,"1120":1,"1121":1,"1122":1,"1137":1,"1141":1,"1144":1,"1147":3,"1150":1,"1151":1,"1152":1,"1153":1,"1154":1,"1155":1,"1156":1,"1158":1,"1160":1,"1162":2,"1163":1,"1164":1,"1165":1,"1171":1,"1172":1,"1174":1,"1175":1,"1176":1,"1178":1,"1179":1,"1183":1,"1184":1,"1189":2,"1190":1,"1191":2,"1192":1,"1193":1,"1194":1,"1195":1,"1206":1,"1208":1,"1209":1,"1211":1,"1212":1,"1214":1,"1215":1,"1216":1,"1218":2,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":2,"1225":1,"1226":1,"1232":2,"1233":1,"1236":1,"1237":1,"1239":1,"1241":1,"1242":1,"1243":2,"1252":1,"1253":2,"1254":3,"1257":1,"1258":2,"1261":1,"1262":2,"1263":1,"1271":1,"1272":1,"1273":2,"1275":1,"1277":1,"1278":7,"1280":1,"1281":1,"1282":1,"1300":1,"1301":1,"1304":1,"1307":1,"1310":1,"1313":2,"1314":1,"1315":2,"1316":2,"1317":1,"1318":1,"1321":1,"1322":1,"1326":1,"1329":1,"1332":1,"1333":1,"1335":1,"1337":1,"1339":2,"1340":1,"1341":1,"1342":1,"1347":1,"1349":1,"1350":1,"1352":1,"1353":2,"1354":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1,"1362":2,"1363":1,"1364":1,"1365":1,"1366":1,"1367":2,"1368":1,"1371":1,"1377":1,"1378":3,"1379":1,"1380":1,"1381":1,"1382":1,"1384":1,"1385":1,"1389":2,"1392":1,"1395":1,"1396":1,"1397":1,"1399":1,"1400":1,"1408":1,"1410":1,"1411":2,"1412":1,"1422":4,"1423":2,"1424":1,"1426":1,"1429":1,"1430":1,"1433":1,"1443":2,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1,"1451":1}}],["pluralrules",{"2":{"746":1}}],["plural",{"2":{"165":1,"372":3,"606":1,"746":1,"757":1,"1269":1}}],["plus",{"2":{"137":1,"416":1,"743":1}}],["plaintext",{"2":{"862":1,"1000":1}}],["plain",{"2":{"291":1,"292":1,"439":1,"468":2,"469":1,"830":1,"1004":1,"1011":1,"1126":1,"1287":1}}],["plaindateiso",{"2":{"518":1,"519":1,"520":1}}],["plaindatetime",{"2":{"132":1,"146":1,"201":1,"903":1}}],["plaindate",{"2":{"11":1,"81":1,"132":1,"201":1,"517":2,"520":3,"903":1}}],["playgrounds",{"2":{"780":1}}],["playground",{"2":{"648":1}}],["play",{"2":{"276":1}}],["planflightsector",{"2":{"1365":2}}],["planning",{"0":{"1365":1},"2":{"515":1,"879":1,"1084":1,"1343":1,"1362":1}}],["planned",{"2":{"507":1}}],["planneroptions",{"2":{"117":1}}],["planner",{"0":{"126":1,"127":1,"128":1,"374":1,"630":1},"1":{"127":1,"128":1,"375":1,"376":1,"377":1},"2":{"96":1,"117":1,"126":1,"127":1,"128":3,"374":2,"375":1,"377":1,"630":3,"1454":1}}],["planetary",{"2":{"1080":1}}],["planet",{"2":{"305":1}}],["plan",{"2":{"236":1,"514":1,"629":1,"1083":1}}],["places",{"2":{"227":1}}],["place",{"2":{"112":1,"741":1,"1039":1,"1167":1,"1168":1,"1172":4,"1176":2,"1178":1}}],["placeholders",{"2":{"513":1}}],["placeholder",{"2":{"54":1,"592":1}}],["platforms",{"2":{"367":1,"1015":1,"1139":1,"1219":1,"1324":1,"1364":1,"1377":1}}],["platform",{"2":{"89":1,"449":1,"1190":1}}],["pal",{"2":{"1331":1}}],["papal",{"2":{"1309":1}}],["pauses",{"2":{"1043":1}}],["payments",{"2":{"1222":1}}],["payment",{"2":{"1088":1,"1263":1}}],["pay",{"2":{"1035":1}}],["payrollrun",{"2":{"1222":2}}],["payrollinstances",{"2":{"1036":2}}],["payroll",{"0":{"1034":1,"1222":1},"1":{"1035":1,"1036":1},"2":{"1024":1,"1035":1,"1210":1,"1218":2,"1222":2}}],["payloadwithtruetimestamp",{"2":{"1265":2}}],["payloads",{"0":{"842":1},"2":{"191":1,"227":1,"504":1,"825":1,"829":1,"835":1,"842":1,"863":1,"1011":1,"1042":1,"1139":1}}],["payload",{"2":{"64":1,"191":2,"213":1,"326":1,"504":1,"505":1,"588":1,"722":1,"734":1,"829":1,"860":3,"865":1,"955":3,"1008":1,"1011":1,"1019":1,"1140":1,"1188":1,"1265":2,"1444":3}}],["paid",{"2":{"948":1,"1222":1}}],["pairing",{"2":{"1067":1}}],["paired",{"2":{"522":1,"865":1}}],["pair",{"2":{"408":1,"644":1,"1067":1,"1422":1}}],["pairs",{"2":{"95":1,"289":1,"887":1,"991":1}}],["paced",{"2":{"705":1}}],["pacificbbox",{"2":{"1338":2}}],["pacific",{"2":{"296":1,"334":1,"1338":1}}],["packet",{"2":{"1028":1,"1233":1}}],["packets",{"2":{"1028":1}}],["packaging",{"2":{"365":1}}],["packages",{"2":{"43":1,"229":1,"547":1,"559":2,"846":1}}],["package",{"0":{"551":1},"2":{"14":1,"22":1,"34":1,"35":1,"39":1,"43":2,"167":1,"229":1,"256":1,"260":1,"284":1,"311":1,"457":1,"539":1,"559":4,"560":1,"590":1,"603":1,"665":2,"678":1,"773":1,"836":2,"846":1,"1007":1,"1016":1,"1453":1}}],["packing",{"0":{"235":1}}],["padding",{"2":{"138":2,"819":1,"1125":1,"1143":1}}],["padded",{"2":{"137":11,"1088":4,"1090":2,"1111":2,"1113":1,"1125":10}}],["pads",{"2":{"138":2,"273":1,"1125":1}}],["par",{"2":{"1082":1}}],["park",{"2":{"875":1}}],["parallax",{"2":{"1062":1}}],["parallelize",{"2":{"1030":1}}],["parallelizes",{"2":{"1018":1}}],["parallel",{"0":{"877":1,"887":1,"896":1,"905":1,"949":1,"1037":1},"1":{"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1},"2":{"940":2,"964":1,"1018":1,"1024":1,"1033":2,"1036":1,"1095":1}}],["paragraph",{"2":{"888":1}}],["paradigm",{"0":{"835":1}}],["paradigms",{"2":{"283":1,"1125":1}}],["param",{"2":{"313":2}}],["parameter",{"0":{"959":1},"2":{"171":1,"361":1,"437":1,"637":1,"653":1,"856":1,"959":1,"1023":1,"1395":1,"1403":1}}],["parameters",{"0":{"266":1},"2":{"43":1,"94":1,"282":1,"292":1,"422":1,"854":1,"875":1,"926":1,"958":1,"1004":1,"1009":1,"1288":1,"1382":1}}],["partner",{"2":{"1139":1}}],["parts",{"2":{"1091":1}}],["parties",{"2":{"1263":1}}],["partial",{"2":{"938":2,"1053":2,"1065":3}}],["partitionkey",{"2":{"1192":3}}],["partition",{"2":{"980":1,"1192":3}}],["partitioning",{"0":{"1185":1,"1186":1},"1":{"1186":1,"1187":1},"2":{"866":1,"1009":1,"1037":1,"1168":1,"1182":1,"1183":1,"1189":1}}],["partitioned",{"0":{"866":1,"1006":1,"1009":1,"1192":1},"1":{"1007":1,"1008":1,"1009":1},"2":{"1039":1,"1186":1,"1189":1,"1192":2}}],["participating",{"2":{"1255":1}}],["participate",{"2":{"322":1,"954":1}}],["particularly",{"2":{"125":1,"328":1,"390":1,"462":1}}],["part",{"0":{"1087":1,"1092":1},"1":{"1088":1,"1089":1,"1090":1,"1091":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1},"2":{"198":1,"388":1,"469":1,"1416":1}}],["party",{"0":{"1138":1},"1":{"1139":1,"1140":1,"1141":1},"2":{"43":1,"88":1,"114":1,"129":1,"223":2,"288":1,"413":1,"488":1,"867":1,"966":1,"1011":1,"1012":1,"1225":1,"1263":1,"1264":3}}],["paris",{"2":{"112":1,"113":1,"296":1,"1160":1,"1167":1,"1181":1,"1358":4,"1360":1,"1366":2}}],["parity",{"2":{"43":1,"138":2,"617":1,"642":1,"665":1}}],["parent",{"2":{"105":2,"425":2,"465":3,"468":1,"643":1,"782":1,"829":1}}],["parsefloat",{"2":{"1178":2}}],["parseappointmentprompt",{"2":{"1013":1}}],["parseaitempo",{"2":{"919":1}}],["parseai",{"0":{"204":1,"878":1,"960":1},"1":{"961":1,"962":1,"963":1,"964":1,"965":1},"2":{"93":2,"98":2,"204":1,"701":1,"856":1,"859":2,"863":1,"878":3,"908":2,"910":1,"912":3,"915":1,"918":2,"920":1,"925":2,"929":1,"930":1,"932":1,"933":1,"934":3,"935":1,"936":1,"939":2,"945":1,"946":2,"948":1,"949":1,"950":3,"954":2,"955":2,"957":2,"960":1,"961":2,"962":2,"963":1,"964":1,"968":2,"970":2,"972":1,"973":3,"974":1,"975":1,"977":1,"978":2,"979":1,"997":2}}],["parseprefilter",{"2":{"630":2}}],["parselayout",{"2":{"616":1}}],["parsejsonc",{"2":{"538":1,"839":1}}],["parseint",{"2":{"324":1}}],["parsemodule",{"2":{"210":1,"211":2,"251":1,"274":1,"668":1,"750":1}}],["parses",{"0":{"976":1},"2":{"169":1,"219":3,"223":1,"294":2,"351":1,"363":1,"450":1,"517":2,"625":1,"688":1,"776":1,"878":1,"1104":1,"1232":1,"1289":1,"1290":1}}],["parsedfromtext",{"2":{"1304":2}}],["parsedromandate",{"0":{"1290":1}}],["parsedate",{"0":{"1290":1}}],["parsed",{"2":{"123":1,"202":1,"225":1,"243":1,"296":1,"359":2,"388":1,"538":1,"965":1,"978":1,"986":1,"997":1,"1141":3,"1280":2}}],["parsers",{"0":{"1119":1},"2":{"684":1,"689":1,"702":1,"771":1}}],["parser",{"0":{"626":1},"2":{"27":1,"96":1,"97":1,"217":1,"219":1,"221":1,"223":1,"240":1,"295":1,"359":1,"418":1,"466":1,"517":1,"649":1,"735":1,"752":1,"757":1,"766":1,"771":1,"984":3,"986":1,"1104":4,"1136":1,"1140":1,"1276":2,"1304":1}}],["parse",{"0":{"78":1,"126":1,"198":1,"256":2,"348":1,"351":1,"352":1,"374":1,"630":1,"668":1,"1289":1},"1":{"127":1,"128":1,"375":1,"376":1,"377":1},"2":{"12":1,"31":1,"32":1,"43":1,"78":1,"89":1,"126":1,"146":1,"155":1,"197":4,"198":1,"199":3,"205":2,"206":1,"211":1,"212":1,"215":1,"219":1,"221":1,"226":1,"251":1,"297":1,"323":1,"324":2,"337":1,"339":2,"351":2,"357":1,"371":1,"374":1,"390":1,"398":1,"446":1,"472":1,"503":1,"557":1,"558":2,"559":4,"560":1,"630":1,"633":1,"645":1,"647":1,"649":2,"659":1,"660":1,"667":2,"668":1,"705":1,"711":1,"754":2,"763":2,"765":1,"771":1,"773":1,"806":1,"888":1,"906":1,"908":1,"913":1,"916":1,"917":1,"919":1,"961":1,"1013":2,"1099":1,"1103":1,"1104":1,"1119":1,"1280":1,"1304":1,"1313":2,"1454":1}}],["parsing",{"0":{"57":1,"58":1,"60":1,"89":1,"122":1,"196":1,"197":1,"200":1,"202":1,"203":1,"204":1,"205":1,"206":1,"211":1,"213":1,"216":1,"219":1,"222":1,"363":1,"390":1,"510":1,"517":1,"525":1,"563":1,"642":1,"647":1,"684":1,"690":1,"701":1,"806":1,"906":1,"960":1,"964":1,"984":1,"1302":1},"1":{"58":1,"59":1,"60":1,"123":1,"124":1,"125":1,"126":1,"127":1,"128":1,"197":1,"198":2,"199":2,"200":1,"201":2,"202":2,"203":2,"204":3,"205":2,"206":1,"207":2,"208":2,"209":2,"210":1,"211":1,"212":1,"213":1,"214":2,"215":1,"216":1,"217":1,"218":1,"219":1,"220":2,"221":2,"222":1,"223":1,"224":1,"225":1,"226":1,"227":1,"228":1,"391":1,"392":1,"393":1,"394":1,"395":1,"396":1,"397":1,"398":1,"399":1,"907":1,"908":1,"909":1,"910":1,"911":1,"912":1,"961":1,"962":1,"963":1,"964":1,"965":1,"1303":1,"1304":1},"2":{"9":1,"11":1,"12":3,"14":1,"50":1,"59":1,"76":1,"78":4,"89":2,"93":2,"96":1,"97":1,"109":2,"117":3,"122":1,"125":1,"135":1,"146":1,"155":1,"196":1,"197":1,"198":1,"200":1,"202":4,"203":1,"204":2,"205":2,"206":1,"208":1,"210":2,"211":1,"217":2,"219":2,"222":1,"228":1,"237":1,"243":1,"251":1,"256":1,"273":1,"281":1,"297":2,"315":1,"322":1,"325":1,"328":1,"342":1,"348":1,"352":1,"357":1,"358":1,"359":1,"361":1,"362":2,"363":3,"374":2,"376":1,"377":1,"399":1,"403":1,"407":3,"416":1,"445":1,"450":1,"451":2,"466":1,"469":1,"501":1,"507":1,"515":1,"516":1,"517":1,"558":1,"563":1,"571":1,"573":1,"578":1,"580":1,"613":1,"616":1,"621":1,"626":1,"630":1,"633":1,"635":1,"637":1,"639":1,"640":1,"647":1,"659":1,"668":1,"679":1,"699":1,"701":2,"702":2,"705":1,"709":1,"737":1,"750":2,"755":1,"757":1,"763":3,"767":1,"771":1,"778":1,"795":1,"798":2,"800":1,"802":1,"804":1,"808":1,"865":1,"909":1,"910":1,"913":1,"921":1,"937":2,"938":2,"945":1,"951":1,"954":3,"959":1,"962":1,"968":1,"975":1,"993":1,"994":1,"1008":2,"1014":1,"1055":1,"1094":1,"1099":1,"1119":1,"1123":1,"1131":1,"1136":1,"1278":1,"1280":1,"1394":1,"1454":1}}],["pastdate",{"2":{"520":2}}],["pasting",{"2":{"247":1}}],["past",{"2":{"62":1,"138":1,"159":1,"321":1,"383":1,"385":1,"388":1,"520":1,"886":2,"902":1,"911":1,"988":1,"1209":1,"1224":1,"1270":1}}],["paste",{"2":{"29":1,"89":1}}],["passwords",{"0":{"1266":1}}],["passthrough",{"2":{"750":1}}],["passively",{"2":{"1239":1,"1240":1,"1264":1}}],["passive",{"0":{"1262":1},"1":{"1263":1,"1264":1},"2":{"291":1,"1242":1,"1262":2}}],["passing",{"0":{"1417":1},"2":{"95":1,"204":1,"235":1,"282":2,"373":1,"419":1,"469":1,"734":1,"750":1,"806":1,"816":1,"908":1,"909":1,"936":1,"973":1,"975":1,"984":1,"1041":1,"1060":1,"1070":1,"1255":1,"1377":1,"1387":1}}],["passé",{"2":{"222":1,"737":1}}],["passed",{"2":{"208":1,"276":1,"290":1,"314":1,"338":2,"350":1,"351":1,"402":1,"434":1,"469":1,"498":1,"881":1,"890":1,"899":1,"1388":1}}],["passes",{"2":{"8":1,"359":1,"364":1,"446":1,"679":1,"907":1,"1270":1,"1392":1}}],["pass",{"2":{"39":1,"102":1,"104":1,"131":1,"138":1,"146":1,"159":1,"163":1,"169":1,"171":1,"191":1,"228":1,"243":1,"266":1,"269":1,"271":1,"289":1,"298":1,"334":1,"357":1,"358":1,"399":1,"454":1,"455":1,"541":2,"573":1,"669":1,"816":1,"848":1,"856":1,"863":1,"877":1,"887":1,"908":1,"964":1,"972":3,"978":1,"1041":1,"1179":1,"1186":1,"1188":1,"1193":1,"1263":1,"1379":1}}],["patrick",{"2":{"1213":1}}],["paths",{"0":{"559":1,"1277":1},"1":{"1278":1},"2":{"105":1,"107":2,"260":1,"261":1,"311":1,"514":1,"541":1,"559":2,"560":2,"644":1,"655":1,"665":1,"737":1,"755":1,"778":1,"829":1,"832":1,"1086":1,"1108":1,"1122":1,"1441":1}}],["path",{"0":{"557":1,"759":1,"1278":1},"1":{"558":1,"559":1},"2":{"33":1,"103":1,"115":1,"117":1,"129":1,"145":1,"152":1,"403":1,"408":1,"642":1,"644":1,"666":1,"829":1,"839":1,"1104":8,"1240":1,"1278":1,"1344":1,"1358":1,"1359":1,"1365":1}}],["pattern",{"0":{"102":1,"266":1,"286":1,"328":1,"424":1,"916":1,"918":1,"1220":1,"1304":1,"1307":1,"1310":1,"1313":1,"1408":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"329":1,"330":1,"331":1,"332":1,"333":1,"334":1,"335":1,"336":1,"337":1,"338":1,"339":1,"340":1,"341":1,"425":1,"426":1,"427":1,"428":1,"429":1,"917":1},"2":{"32":1,"96":2,"126":1,"148":1,"198":1,"228":1,"238":1,"240":1,"262":1,"266":1,"279":1,"281":1,"285":3,"288":1,"289":4,"290":5,"291":1,"293":1,"328":1,"348":1,"351":1,"380":1,"381":1,"382":1,"404":1,"411":1,"412":1,"422":1,"424":1,"430":1,"444":1,"452":1,"637":1,"639":1,"640":1,"659":1,"668":1,"684":1,"741":1,"842":1,"919":1,"978":2,"986":1,"1078":1,"1104":7,"1106":1,"1113":2,"1114":1,"1115":3,"1116":3,"1147":1,"1150":3,"1263":1,"1417":2,"1421":2,"1446":1,"1454":1}}],["patterns",{"0":{"237":1,"480":1,"915":1,"1012":1,"1026":1,"1080":1,"1137":1,"1189":1,"1218":1,"1258":1,"1301":1,"1322":1,"1362":1,"1385":1,"1443":1},"1":{"238":1,"239":1,"240":1,"241":1,"242":1,"243":1,"244":1,"245":1,"246":1,"247":1,"248":1,"481":1,"482":1,"483":1,"484":1,"485":1,"486":1,"487":1,"916":1,"917":1,"918":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":1,"1033":1,"1034":1,"1035":1,"1036":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":1,"1144":1,"1145":1,"1146":1,"1147":1,"1148":1,"1149":1,"1150":1,"1190":1,"1191":1,"1192":1,"1193":1,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1259":1,"1260":1,"1261":1,"1262":1,"1263":1,"1264":1,"1265":1,"1266":1,"1267":1,"1302":1,"1303":1,"1304":1,"1305":1,"1306":1,"1307":1,"1308":1,"1309":1,"1310":1,"1311":1,"1312":1,"1313":1,"1314":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1363":1,"1364":1,"1365":1,"1366":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"1":1,"30":1,"198":1,"228":1,"237":1,"285":1,"288":1,"290":1,"291":1,"297":2,"332":1,"348":1,"357":1,"362":2,"363":1,"375":1,"400":1,"462":1,"473":1,"474":1,"620":1,"634":1,"647":1,"671":1,"897":1,"921":2,"1010":1,"1014":2,"1024":1,"1026":1,"1052":1,"1105":2,"1115":1,"1122":1,"1135":1,"1137":1,"1166":1,"1210":1,"1242":1,"1263":1,"1274":1,"1299":1,"1320":1,"1343":1,"1383":1,"1385":1,"1401":1}}],["patches",{"2":{"1451":1}}],["patched",{"2":{"23":1,"617":1,"631":1}}],["patching",{"2":{"322":1,"1011":1,"1173":1}}],["patch",{"2":{"23":1,"44":1,"515":1,"575":1,"627":1}}],["page2",{"2":{"1096":1}}],["paged",{"0":{"983":1},"2":{"981":1}}],["pages",{"2":{"651":1,"666":1,"1376":1,"1378":1}}],["page",{"2":{"8":1,"43":1,"451":1,"627":1,"666":1,"1005":1,"1378":1}}],["punch",{"2":{"1035":1,"1036":1}}],["punchier",{"2":{"705":1}}],["pushes",{"2":{"489":1}}],["pushed",{"2":{"376":1,"988":1,"992":1}}],["push",{"0":{"473":1,"488":1,"489":1,"490":1},"1":{"489":1,"490":1,"491":2,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1},"2":{"473":2,"488":1,"489":6,"493":1,"792":2,"1223":1,"1329":1,"1389":1}}],["pulsing",{"2":{"1438":1}}],["pulses",{"2":{"531":1,"683":1,"1427":1,"1435":1,"1438":2,"1444":1}}],["pulse",{"0":{"1438":1},"2":{"276":1,"326":1,"634":1,"683":1,"1255":1,"1401":2,"1403":1,"1404":1,"1405":3,"1412":4,"1415":4,"1417":2,"1419":1,"1421":1,"1422":1,"1424":5,"1425":1,"1426":1,"1434":1,"1436":2,"1444":3,"1447":1,"1448":2}}],["pulls",{"2":{"365":1,"489":2,"1004":1}}],["pull",{"0":{"8":1,"473":1,"488":1,"489":1,"492":1},"1":{"489":1,"490":1,"491":1,"492":1,"493":1,"494":1,"495":1,"496":1,"497":1},"2":{"8":1,"456":1,"473":4,"488":1,"489":8,"792":1,"889":1,"1445":2}}],["put",{"2":{"195":1}}],["purge",{"2":{"976":2}}],["purges",{"2":{"336":1,"1168":1}}],["purged",{"2":{"94":1,"331":1}}],["purpose",{"2":{"273":1,"275":1,"361":1,"1090":1}}],["purposes",{"2":{"34":1,"157":1}}],["purists",{"2":{"711":1}}],["purist",{"0":{"170":1}}],["purely",{"2":{"127":1,"409":1,"723":1,"738":1,"1075":1,"1235":1,"1339":1}}],["pure",{"0":{"1160":1},"2":{"14":1,"102":1,"167":1,"170":1,"171":1,"222":1,"270":3,"283":2,"326":1,"327":1,"515":1,"711":1,"752":1,"1053":1,"1054":1,"1168":1,"1173":1,"1225":1,"1335":1,"1357":1}}],["publishing",{"2":{"763":1}}],["publish",{"2":{"229":1}}],["published",{"2":{"47":1,"692":1,"846":1}}],["publishes",{"2":{"24":1,"48":1}}],["public",{"0":{"433":1,"797":1,"885":1},"2":{"7":1,"21":1,"23":2,"129":1,"235":1,"261":1,"403":1,"408":2,"427":2,"430":1,"433":1,"439":1,"457":1,"470":1,"574":1,"607":1,"612":1,"617":1,"627":1,"644":1,"655":1,"665":1,"795":1,"885":1,"913":1,"954":1,"1005":1,"1008":1,"1176":1,"1178":2,"1188":1,"1195":1,"1197":1,"1203":2,"1215":1,"1216":1,"1218":1,"1222":1,"1454":1}}],["practical",{"2":{"366":1}}],["practices",{"0":{"277":1,"326":1,"327":1,"341":1,"389":1},"1":{"278":1,"279":1,"280":1,"281":1,"282":1},"2":{"1092":1}}],["practice",{"0":{"102":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1},"2":{"43":1,"102":1,"1188":1,"1271":1}}],["próximo",{"2":{"363":4}}],["price",{"2":{"1446":2}}],["pricing",{"2":{"163":1}}],["prid",{"2":{"1270":2}}],["pridie",{"2":{"1270":4,"1271":1,"1276":1,"1304":1,"1310":1}}],["privacy",{"0":{"861":1,"994":1},"1":{"862":1,"863":1,"864":1,"865":1,"866":1,"995":1,"996":1,"997":1,"998":1,"999":1,"1000":1,"1001":1,"1002":1,"1003":1,"1004":1,"1005":1,"1006":1,"1007":1,"1008":1,"1009":1,"1010":1,"1011":1},"2":{"861":2,"869":1,"921":2,"936":1,"954":1,"994":1,"1017":1}}],["private",{"2":{"7":2,"21":1,"89":1,"402":1,"403":2,"408":2,"414":1,"418":1,"424":1,"426":1,"427":3,"428":1,"435":1,"438":1,"440":1,"529":1,"533":1,"667":1,"717":1,"859":1,"860":1,"913":1,"932":1,"955":2,"958":1,"1005":1,"1007":1,"1008":1,"1012":1,"1329":1,"1389":2,"1392":2,"1395":1}}],["pristine",{"2":{"702":1}}],["prior",{"2":{"393":2,"409":1,"504":1,"642":1,"911":1,"1004":1,"1008":1,"1010":1,"1270":1}}],["prioritization",{"0":{"948":1}}],["prioritizing",{"2":{"374":1,"375":1}}],["prioritized",{"2":{"357":1,"634":1,"948":1}}],["prioritize",{"2":{"219":1,"616":1}}],["prioritizes",{"2":{"127":1,"416":1,"527":1,"1232":1}}],["priority",{"0":{"1159":1},"2":{"199":1,"219":1,"338":2,"533":1,"630":1,"926":1,"1214":1}}],["prints",{"2":{"1111":1}}],["print",{"2":{"1091":1}}],["printing",{"2":{"144":1,"996":1}}],["principles",{"2":{"1086":1,"1087":1,"1173":1,"1268":1}}],["principle",{"0":{"1005":1,"1088":1},"2":{"281":1,"423":1}}],["prime",{"2":{"1069":1}}],["primitive",{"0":{"355":1},"2":{"157":1,"158":1,"161":1,"167":1,"355":1,"407":1,"473":1,"488":1,"711":2,"1011":1,"1030":1,"1361":1}}],["primitives",{"0":{"769":1},"2":{"11":3,"476":1,"500":1,"501":1,"769":1,"841":1,"1443":1}}],["primary",{"2":{"157":1,"219":1,"341":1,"406":2,"407":1,"522":1,"751":1,"867":1,"934":2,"940":1,"942":1,"946":2,"960":1,"1011":2,"1088":1,"1098":1,"1103":1,"1125":1,"1158":2,"1176":1,"1178":1,"1190":1,"1269":1,"1372":1,"1382":1}}],["primarily",{"2":{"128":1,"250":1,"470":1}}],["preact",{"0":{"1429":1},"2":{"1429":1}}],["premature",{"2":{"1218":1}}],["prematurely",{"2":{"942":1,"1259":1}}],["premise",{"2":{"1017":2}}],["premier",{"2":{"514":1}}],["premium",{"0":{"666":1},"2":{"16":1,"387":1,"506":1,"514":1,"515":1,"609":1,"651":1,"751":1,"760":1,"836":1}}],["predicted",{"2":{"1083":1}}],["predictions",{"0":{"1074":1,"1078":1},"1":{"1075":1,"1076":1,"1077":1,"1078":1,"1079":1},"2":{"1074":1}}],["predictors",{"2":{"909":1}}],["predictability",{"2":{"137":1}}],["predictable",{"2":{"116":1,"152":1,"181":1,"204":1,"326":1,"468":1,"644":1,"683":1}}],["predicates",{"2":{"1263":1}}],["predicate",{"2":{"769":1,"1240":1,"1263":1}}],["presiding",{"2":{"1272":1,"1313":1}}],["pressure",{"2":{"450":1,"451":1,"649":1,"798":1,"1370":1}}],["presence",{"2":{"1372":1}}],["presents",{"2":{"514":1,"995":1,"1012":1}}],["present",{"2":{"215":1,"554":1,"738":1,"853":1,"902":1,"912":2,"925":2,"1071":1}}],["presentational",{"2":{"326":1}}],["presentation",{"2":{"76":2,"1090":1}}],["preserved",{"2":{"802":1,"812":1,"996":1}}],["preserve",{"2":{"300":1,"667":1,"724":1,"1450":1}}],["preserves",{"2":{"189":1,"298":1,"317":1,"381":1,"503":1,"681":1,"1158":1,"1190":1,"1415":1}}],["preservation",{"0":{"387":1,"667":1},"2":{"195":1,"503":1,"997":1}}],["preserving",{"2":{"188":1,"189":2,"195":2,"381":1,"472":1,"500":1,"556":1,"690":1,"750":1,"832":1,"866":1,"868":1,"936":1,"964":1,"1173":1}}],["preset",{"2":{"88":2,"89":2}}],["presets",{"0":{"88":1,"90":1}}],["prevbusinessday",{"0":{"1197":1},"2":{"1197":1,"1222":1}}],["previous",{"2":{"331":1,"368":1,"381":1,"383":2,"393":1,"395":1,"737":2,"911":1}}],["previously",{"2":{"95":1,"472":1,"561":1,"569":1,"637":1,"737":1,"738":2}}],["preview",{"2":{"246":1}}],["prev",{"2":{"240":1,"395":2,"1197":2}}],["prevented",{"2":{"439":1,"714":1,"829":1}}],["preventing",{"0":{"1445":1},"2":{"298":1,"404":1,"425":1,"475":1,"495":1,"616":2,"709":1,"744":1,"767":1,"864":1,"998":1,"1431":1}}],["prevention",{"2":{"114":1,"748":1,"950":1,"993":1,"1401":2}}],["prevents",{"2":{"114":1,"213":1,"230":1,"249":1,"431":1,"464":1,"702":1,"726":1,"763":1,"975":1,"1010":1}}],["prevent",{"2":{"109":1,"119":1,"137":1,"161":1,"205":1,"278":1,"300":1,"336":1,"370":1,"413":1,"414":1,"416":1,"422":1,"429":1,"437":1,"440":1,"478":1,"546":1,"627":1,"647":1,"649":2,"657":1,"663":1,"664":1,"748":1,"829":1,"866":1,"876":1,"884":1,"893":1,"935":1,"972":1,"997":1,"1001":1,"1009":1,"1011":1,"1184":1,"1372":1,"1437":1,"1450":1}}],["prefilter",{"0":{"127":1,"377":1},"2":{"117":1,"127":1,"128":1,"377":2,"630":1}}],["prefixes",{"2":{"689":1,"806":1,"1112":1,"1240":1,"1263":2,"1270":1}}],["prefixed",{"2":{"240":3,"936":1,"1129":1}}],["prefix",{"2":{"62":1,"63":1,"399":1,"737":1,"978":4,"997":1,"1240":1}}],["prefers",{"2":{"215":1,"362":1}}],["prefer",{"2":{"183":1,"204":1,"205":1,"216":1,"250":1,"310":1,"341":1,"515":1}}],["preference",{"0":{"1159":1},"2":{"110":2,"116":1,"218":1}}],["preferences",{"2":{"101":1,"119":1,"129":1,"283":1,"616":1,"1159":1}}],["preferred",{"2":{"110":1,"270":1,"362":1,"836":1,"993":1,"1094":1}}],["preceded",{"2":{"1134":1}}],["precedes",{"2":{"617":1}}],["precedence",{"0":{"101":1},"2":{"100":1,"118":1,"129":1,"290":1,"616":1,"637":1,"639":1,"640":1,"755":1,"932":1,"1159":1}}],["preceding",{"0":{"1222":1},"2":{"393":1,"1222":4,"1270":2}}],["precision",{"0":{"209":1,"511":1,"567":1,"778":1,"1226":1,"1232":1},"1":{"568":1,"569":1,"1227":1,"1228":1,"1229":1,"1230":1,"1231":1,"1232":1,"1233":1,"1234":1,"1235":1},"2":{"117":1,"121":1,"138":3,"209":1,"227":1,"236":1,"418":1,"507":1,"511":1,"515":1,"522":2,"529":1,"613":1,"625":1,"673":2,"681":1,"750":1,"771":1,"884":1,"950":1,"1045":1,"1143":1,"1144":2,"1212":1,"1232":1,"1236":1,"1242":1,"1376":1,"1377":1,"1381":2}}],["precisely",{"2":{"77":2,"1444":1}}],["precise",{"2":{"44":1,"382":1,"503":1,"513":1,"520":3,"752":1,"879":1,"1045":1,"1082":1,"1446":1}}],["preloads",{"2":{"1217":1}}],["preload",{"0":{"1216":1,"1217":1},"2":{"1216":2,"1217":1}}],["preloaded",{"0":{"87":1}}],["preloading",{"0":{"1212":1,"1215":1},"1":{"1213":1,"1214":1,"1215":1,"1216":2,"1217":2},"2":{"83":1,"1207":1,"1210":2,"1212":1}}],["pre",{"0":{"112":1,"126":1,"372":1},"1":{"127":1,"128":1},"2":{"10":1,"42":1,"85":1,"87":1,"96":1,"97":1,"113":1,"134":1,"170":1,"220":1,"238":1,"239":1,"243":1,"301":1,"306":1,"354":1,"371":2,"372":3,"374":1,"377":1,"442":1,"518":1,"567":1,"630":1,"695":1,"738":1,"763":2,"787":1,"850":1,"937":1,"938":1,"942":1,"959":1,"962":1,"971":1,"974":1,"975":1,"1106":1,"1144":1}}],["prerequisites",{"0":{"3":1}}],["prod=true",{"2":{"1011":1}}],["prod",{"2":{"1011":1}}],["producing",{"2":{"817":1}}],["produces",{"2":{"722":1,"912":1,"1091":2,"1112":1,"1125":1}}],["producer",{"2":{"489":3,"494":1}}],["produce",{"2":{"157":1,"158":1,"351":1,"1081":1}}],["production",{"0":{"44":1,"657":1,"665":1,"922":1,"1012":1,"1026":1,"1030":1,"1080":1,"1137":1,"1141":1,"1189":1,"1218":1,"1258":1,"1264":1,"1301":1,"1322":1,"1326":1,"1362":1,"1385":1,"1389":1,"1443":1},"1":{"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":1,"1033":1,"1034":1,"1035":1,"1036":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":1,"1144":1,"1145":1,"1146":1,"1147":1,"1148":1,"1149":1,"1150":1,"1190":1,"1191":1,"1192":1,"1193":1,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1259":1,"1260":1,"1261":1,"1262":1,"1263":1,"1264":1,"1265":1,"1266":1,"1267":1,"1302":1,"1303":1,"1304":1,"1305":1,"1306":1,"1307":1,"1308":1,"1309":1,"1310":1,"1311":1,"1312":1,"1313":1,"1314":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1363":1,"1364":1,"1365":1,"1366":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"41":1,"43":3,"44":1,"47":1,"89":1,"90":1,"103":1,"107":1,"274":1,"276":1,"281":1,"448":1,"531":1,"665":1,"696":1,"729":1,"862":1,"867":1,"869":2,"871":1,"921":3,"922":1,"930":1,"936":2,"945":1,"948":1,"953":1,"996":3,"997":2,"998":1,"1011":4,"1012":1,"1024":1,"1052":1,"1084":1,"1086":1,"1105":2,"1109":1,"1137":1,"1166":1,"1189":1,"1210":1,"1218":1,"1242":2,"1265":1,"1274":1,"1299":1,"1320":1,"1343":1,"1383":1,"1401":1,"1443":1}}],["proj",{"2":{"997":1}}],["projectile",{"2":{"1391":1}}],["projected",{"2":{"132":1}}],["projects",{"0":{"29":1},"2":{"19":1,"20":1,"35":1,"198":1,"310":1,"844":1,"918":1}}],["project",{"0":{"1":1,"741":1},"2":{"0":1,"5":1,"33":1,"48":1,"197":1,"248":1,"261":1,"270":1,"462":1,"514":1,"534":1,"629":1,"659":1,"671":1,"692":1,"741":2,"887":1,"896":1,"927":1,"1054":1,"1067":1,"1459":1}}],["proactively",{"2":{"948":1}}],["proactive",{"0":{"942":1},"2":{"934":1,"940":4}}],["probabilistic",{"2":{"1226":1}}],["probabilistically",{"2":{"922":1}}],["problem",{"0":{"329":1,"425":1,"431":1,"1028":1,"1032":1,"1035":1,"1139":1,"1143":1,"1146":1,"1149":1,"1260":1,"1324":1,"1328":1,"1331":1,"1387":1,"1391":1,"1394":1},"2":{"8":1}}],["pro",{"2":{"539":1,"836":1}}],["provincial",{"2":{"1213":1}}],["provisioning",{"2":{"954":1}}],["providerid",{"2":{"938":1}}],["providers",{"2":{"89":1,"98":1,"853":1,"854":2,"855":1,"856":5,"859":1,"871":1,"880":2,"889":2,"898":2,"918":1,"925":1,"926":1,"927":1,"930":1,"932":1,"933":1,"934":8,"935":1,"937":3,"938":4,"939":2,"942":4,"945":1,"947":2,"948":2,"949":1,"950":5,"953":1,"958":5,"959":6,"961":2,"966":1,"970":1,"974":1,"978":1,"979":1,"982":1,"988":1,"997":1,"1004":3,"1017":2,"1166":1,"1175":1,"1176":1,"1180":1,"1182":1,"1363":1}}],["provider",{"0":{"696":1,"852":1,"856":1,"867":1,"868":1,"924":1,"929":1,"930":1,"933":1,"934":1,"939":1,"963":1,"1008":1,"1175":1,"1177":1,"1191":1},"1":{"853":1,"854":1,"855":1,"856":1,"857":1,"858":1,"859":1,"860":1,"861":1,"862":1,"863":1,"864":1,"865":1,"866":1,"867":1,"868":2,"925":1,"926":1,"927":1,"928":1,"929":1,"930":1,"931":1,"932":1,"933":1,"934":1,"935":1,"936":1,"937":1,"938":1,"940":1,"941":1,"942":1,"943":1,"944":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"1176":1,"1177":1,"1178":2,"1179":2,"1180":2,"1181":1,"1182":1},"2":{"89":1,"477":1,"696":1,"853":1,"854":2,"855":2,"856":8,"857":1,"860":4,"864":1,"865":1,"867":2,"868":1,"870":2,"871":3,"872":2,"881":1,"882":2,"890":1,"891":2,"898":1,"899":1,"900":2,"912":2,"916":1,"918":1,"919":3,"921":2,"924":2,"927":1,"929":5,"930":1,"932":2,"933":2,"934":5,"935":2,"936":3,"937":7,"938":5,"939":1,"941":1,"942":1,"945":2,"946":2,"947":2,"948":4,"953":4,"954":3,"955":2,"957":1,"958":1,"959":1,"963":2,"965":1,"968":5,"970":2,"973":1,"975":1,"978":1,"979":2,"982":1,"984":2,"986":2,"988":1,"989":1,"992":1,"997":1,"1001":2,"1003":1,"1004":2,"1007":2,"1008":5,"1010":1,"1017":2,"1162":1,"1166":1,"1168":7,"1176":2,"1178":2,"1179":2,"1180":1,"1181":1,"1182":1,"1189":1,"1191":1}}],["provided",{"0":{"302":1},"1":{"303":1,"304":1,"305":1,"306":1},"2":{"76":1,"125":1,"132":1,"150":1,"159":1,"202":1,"220":1,"312":1,"331":1,"339":1,"376":1,"393":1,"399":2,"477":1,"631":1,"855":1,"872":1,"874":1,"882":1,"884":1,"972":1,"1009":1}}],["provide",{"2":{"34":1,"64":1,"89":1,"107":1,"137":1,"161":1,"191":1,"219":1,"239":1,"247":1,"263":1,"271":1,"274":1,"281":1,"286":1,"298":1,"301":2,"317":1,"318":1,"321":1,"326":4,"356":1,"357":1,"379":1,"392":1,"410":1,"533":1,"692":1,"705":1,"711":1,"754":1,"769":1,"771":1,"824":1,"922":1,"1055":1,"1073":1,"1086":1,"1108":1,"1192":1,"1316":1,"1459":1}}],["provides",{"2":{"33":1,"41":1,"92":1,"96":1,"100":1,"107":1,"130":1,"137":1,"139":1,"148":1,"149":1,"150":1,"155":1,"156":1,"161":1,"172":1,"175":1,"181":1,"187":1,"193":1,"205":1,"206":1,"221":1,"224":1,"228":1,"263":1,"265":1,"270":1,"273":2,"275":1,"280":2,"283":1,"286":1,"319":1,"351":1,"367":1,"378":1,"390":1,"416":1,"423":1,"447":1,"456":1,"474":1,"481":1,"515":1,"516":1,"520":1,"524":1,"644":1,"711":1,"750":1,"847":1,"867":1,"879":1,"886":1,"897":1,"910":1,"915":1,"939":1,"951":1,"981":1,"987":1,"1008":2,"1017":1,"1047":1,"1053":1,"1065":1,"1080":1,"1094":1,"1098":1,"1099":1,"1103":2,"1123":1,"1151":1,"1189":1,"1206":1,"1236":1,"1258":1,"1272":1,"1273":1,"1275":1,"1301":1,"1315":1,"1322":1,"1362":1,"1367":1,"1377":1,"1385":1,"1442":2,"1446":1}}],["providing",{"2":{"24":1,"99":1,"167":1,"203":1,"230":1,"281":1,"367":1,"418":1,"429":1,"439":1,"456":1,"522":2,"625":1,"702":1,"707":1,"763":1,"774":1,"817":1,"1045":1,"1050":1,"1162":1,"1339":1,"1396":1,"1419":1}}],["provenance",{"0":{"1305":1},"1":{"1306":1,"1307":1}}],["prove",{"2":{"447":1}}],["profiles",{"2":{"450":1}}],["profile",{"2":{"300":1,"1264":1}}],["professional",{"0":{"248":1,"529":1},"1":{"530":1,"531":1,"532":1,"533":1,"534":1},"2":{"0":1,"236":1,"248":1,"287":1,"293":1,"529":1,"534":1,"1394":1}}],["prospective",{"2":{"1033":1}}],["prose",{"2":{"767":1,"1016":1}}],["pros",{"2":{"269":2,"431":1}}],["programmatically",{"2":{"1009":1}}],["programmatic",{"0":{"1114":1,"1436":1},"2":{"326":1,"687":1,"734":1,"1401":1}}],["programming",{"2":{"269":2,"283":1}}],["progression",{"0":{"1235":1},"2":{"942":1}}],["progress",{"2":{"195":1}}],["proleptic",{"2":{"150":1}}],["proliferating",{"2":{"138":1}}],["prone",{"2":{"139":1,"909":1,"1014":1,"1143":1,"1447":1}}],["propagating",{"2":{"865":1}}],["propagation",{"2":{"616":1,"660":1,"667":1,"1010":1}}],["propagate",{"2":{"660":1,"709":1}}],["proprietary",{"2":{"607":1,"1008":1,"1189":1,"1191":1,"1224":1}}],["proposed",{"2":{"993":2}}],["proposes",{"2":{"993":1}}],["proposition",{"0":{"523":1},"1":{"524":1,"525":1,"526":1,"527":1}}],["proposal",{"2":{"167":1,"896":1}}],["properly",{"2":{"261":1,"326":1,"360":1,"593":1,"631":2}}],["proper",{"2":{"138":1,"298":1,"399":1,"579":1,"616":1,"655":1,"1431":1}}],["propertykey",{"2":{"315":2}}],["property",{"0":{"819":1},"2":{"72":1,"115":1,"117":1,"124":1,"141":1,"142":1,"143":1,"144":2,"145":1,"148":2,"150":2,"170":1,"185":1,"199":1,"263":1,"264":1,"265":1,"266":1,"268":1,"273":1,"280":1,"300":3,"301":1,"317":1,"326":1,"351":1,"360":1,"370":1,"374":1,"402":1,"407":1,"409":1,"412":2,"416":1,"425":1,"426":1,"427":4,"428":1,"429":2,"444":1,"453":1,"464":2,"477":2,"518":1,"556":1,"571":1,"578":1,"664":1,"750":1,"757":1,"769":2,"777":1,"802":1,"836":1,"855":1,"856":1,"936":1,"970":1,"998":1,"1054":1,"1071":1,"1078":1,"1089":2,"1103":1,"1168":1,"1344":1,"1405":1,"1406":1}}],["properties",{"0":{"150":1,"151":1,"154":1,"155":1,"172":1,"347":1,"458":1},"1":{"173":1,"174":1},"2":{"1":1,"119":1,"129":3,"148":1,"149":1,"155":1,"172":1,"173":1,"174":2,"191":1,"230":2,"265":1,"300":2,"344":1,"367":1,"402":1,"409":1,"424":2,"425":1,"426":1,"427":1,"429":2,"446":2,"453":1,"457":1,"461":1,"477":2,"556":1,"699":1,"708":1,"734":1,"747":1,"757":1,"786":1,"818":1,"823":1,"869":1,"929":1,"936":1,"998":1,"1054":2,"1089":1,"1153":1}}],["prop",{"2":{"137":1}}],["prometheus",{"0":{"1327":1},"1":{"1328":1,"1329":1},"2":{"1320":1}}],["prominent",{"2":{"747":1}}],["promise",{"0":{"1246":1},"2":{"334":1,"473":1,"474":2,"475":1,"477":1,"480":2,"481":2,"482":1,"489":1,"493":1,"495":1,"496":1,"856":2,"919":2,"932":1,"937":1,"938":1,"959":1,"1004":1,"1013":1,"1014":1,"1015":1,"1016":1,"1021":1,"1030":1,"1033":1,"1036":1,"1176":3,"1178":1,"1405":1,"1408":1,"1445":2}}],["promises",{"0":{"474":1},"1":{"475":1},"2":{"109":1,"475":1,"477":1,"495":1,"496":1,"831":1,"1435":2}}],["promote",{"2":{"1092":1}}],["promotes",{"2":{"138":1}}],["promotional",{"2":{"177":1}}],["prompts",{"2":{"701":1,"863":1,"865":1,"905":1,"964":1,"972":1,"995":1,"1008":1,"1012":1,"1014":1}}],["prompting",{"0":{"30":1,"247":1},"1":{"31":1,"32":1},"2":{"27":1,"247":1}}],["prompt",{"0":{"31":1},"2":{"26":1,"28":2,"247":1,"588":1,"860":3,"863":2,"871":1,"884":1,"887":2,"902":2,"904":1,"905":2,"907":1,"911":1,"919":3,"922":3,"953":1,"954":1,"972":2,"973":1,"979":1,"996":1,"1007":2,"1008":3,"1009":1,"1013":2,"1442":1}}],["proto",{"2":{"406":1,"438":1,"744":1}}],["protocol",{"0":{"322":1,"772":1,"773":1},"1":{"323":1,"324":1,"325":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1},"2":{"322":1,"335":1,"771":1,"773":1,"831":1,"1432":1}}],["prototypal",{"0":{"464":1,"465":1},"1":{"465":1},"2":{"453":2,"468":1}}],["prototypes",{"2":{"810":1}}],["prototype",{"0":{"233":1,"1449":1,"1452":1},"1":{"1450":1,"1451":1,"1452":1},"2":{"71":1,"125":1,"138":2,"181":1,"215":1,"230":1,"233":2,"235":1,"261":1,"263":1,"269":2,"273":1,"275":1,"280":1,"293":1,"366":1,"367":1,"406":2,"409":1,"411":1,"413":1,"418":1,"429":1,"441":1,"453":6,"464":1,"465":3,"468":3,"469":1,"562":1,"621":1,"664":4,"702":2,"744":2,"833":1,"998":1,"1318":1,"1341":1,"1449":2,"1450":2,"1451":1,"1452":2}}],["prototyping",{"0":{"246":1},"2":{"43":1,"45":1,"270":1,"620":1,"729":1,"953":1,"1008":1}}],["protect",{"2":{"994":1,"1106":1}}],["protection",{"0":{"405":1},"2":{"440":1,"616":1,"623":1,"714":1,"829":1,"866":1,"1012":1}}],["protecting",{"2":{"109":1,"405":1,"472":1,"864":1}}],["protects",{"2":{"368":1,"773":1,"1233":1}}],["protected",{"2":{"278":1,"340":1,"413":1,"418":1,"439":1,"440":1,"466":1,"471":1,"597":1,"629":1,"644":1,"773":1,"782":1,"1173":1}}],["prohibited",{"2":{"109":1}}],["proceeding",{"2":{"856":1,"932":1}}],["proceeds",{"2":{"104":1}}],["processstream",{"2":{"1435":1}}],["processaudioframe",{"2":{"1395":1}}],["processor",{"2":{"1395":1}}],["processors",{"2":{"1331":1}}],["processcouriertelemetry",{"2":{"1364":1}}],["processpayrollepochs",{"2":{"1036":2}}],["processed",{"2":{"492":1,"863":1,"1129":2,"1249":1}}],["processevents",{"2":{"492":1}}],["processes",{"2":{"191":1,"214":1,"972":1,"1371":1,"1437":1,"1442":1}}],["processing",{"0":{"863":1,"877":1,"887":1,"972":1,"1006":1,"1034":1},"1":{"1007":1,"1008":1,"1009":1,"1035":1,"1036":1},"2":{"109":1,"122":1,"124":1,"199":1,"204":2,"216":1,"451":1,"492":1,"532":1,"696":1,"798":1,"863":1,"913":1,"947":1,"972":1,"973":2,"986":1,"1007":1,"1018":1,"1024":1,"1026":1,"1028":1,"1032":1,"1035":1,"1042":2,"1301":1,"1367":1,"1394":1,"1446":1}}],["process",{"0":{"8":1,"1041":1,"1379":1,"1381":1},"1":{"1380":1},"2":{"34":1,"43":1,"107":1,"477":1,"504":1,"643":1,"853":6,"854":2,"856":2,"860":3,"877":1,"880":1,"889":1,"896":1,"898":1,"913":1,"929":1,"930":2,"932":1,"934":2,"935":1,"939":2,"947":3,"955":1,"958":1,"961":1,"964":1,"974":1,"978":3,"982":1,"988":1,"992":1,"997":1,"1017":1,"1039":1,"1041":3,"1185":1,"1222":1,"1367":1,"1369":1,"1377":1,"1388":1,"1389":1,"1394":1,"1401":1}}],["prochain",{"2":{"59":1,"222":2,"737":3,"739":1}}],["proofing",{"2":{"729":1}}],["proof",{"2":{"12":1,"22":1,"461":1,"473":1,"507":1,"1173":1}}],["proxied",{"2":{"852":1,"910":1,"920":1}}],["proxies",{"0":{"408":1},"1":{"409":1,"410":1},"2":{"7":1,"264":1,"295":2,"404":1,"423":1,"428":1,"476":1,"477":1,"629":2,"851":1,"1175":1}}],["proxify",{"2":{"437":2,"438":1}}],["proximity",{"0":{"384":1,"385":1,"1334":1},"1":{"385":1,"386":1,"1335":1},"2":{"1075":1,"1077":1,"1333":1,"1343":1,"1345":1,"1364":1}}],["proximo",{"2":{"363":2}}],["proxy",{"0":{"413":1,"424":1,"426":1,"433":1,"437":1,"444":1,"858":1,"860":1,"931":1,"955":1,"998":1},"1":{"414":1,"425":1,"426":1,"427":2,"428":2,"429":1,"859":1,"860":1},"2":{"1":1,"148":1,"155":1,"298":1,"400":1,"406":2,"408":4,"409":3,"411":1,"412":2,"414":1,"424":1,"426":1,"427":4,"429":2,"432":1,"433":1,"435":1,"437":5,"438":1,"440":1,"442":1,"444":1,"453":2,"468":1,"469":1,"477":1,"479":1,"663":1,"699":1,"738":1,"854":1,"858":1,"859":3,"860":1,"861":2,"862":3,"864":1,"913":1,"921":3,"931":1,"932":1,"933":1,"936":1,"937":1,"938":1,"953":1,"954":2,"955":5,"959":1,"969":1,"998":1,"1005":2,"1007":1,"1008":3,"1106":1,"1168":1,"1188":1,"1191":1,"1376":1}}],["ok",{"2":{"1232":1}}],["omissions",{"0":{"1086":1,"1092":1},"1":{"1087":1,"1088":1,"1089":1,"1090":1,"1091":1,"1092":1,"1093":2,"1094":2,"1095":2,"1096":2,"1097":2,"1098":1},"2":{"1105":1}}],["omitting",{"2":{"1125":1}}],["omitted",{"0":{"1450":1},"2":{"855":1,"1054":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1104":2,"1105":1,"1450":1}}],["omit",{"2":{"47":1,"968":1,"1086":1,"1139":1}}],["ostermontag",{"2":{"1213":1}}],["osm",{"2":{"1178":1}}],["os",{"2":{"1022":1,"1260":1}}],["oss",{"2":{"860":1}}],["oauth",{"2":{"1004":2}}],["oop",{"0":{"269":1,"1171":1},"1":{"270":1},"2":{"269":2,"270":2}}],["occasionally",{"2":{"1010":1}}],["occasional",{"2":{"416":1}}],["occurring",{"2":{"1223":1}}],["occurrences",{"2":{"985":1,"986":1}}],["occurrence",{"2":{"386":1,"739":1,"911":3,"985":3}}],["occurred",{"2":{"351":1,"878":1,"1257":1}}],["occur",{"2":{"1007":1,"1221":1,"1389":1,"1394":1}}],["occurs",{"2":{"191":1,"228":1,"338":1,"416":1,"778":1,"1064":2,"1077":1,"1110":1,"1221":1,"1269":5,"1366":1}}],["octobres",{"2":{"1310":1}}],["octobre",{"2":{"138":2,"1090":2}}],["october",{"0":{"203":1},"1":{"204":1},"2":{"9":1,"131":1,"134":1,"137":1,"138":2,"140":1,"153":1,"203":2,"739":1,"771":1,"776":1,"934":1,"945":1,"962":1,"1090":3,"1097":1,"1101":1,"1111":1,"1113":1,"1125":1,"1131":1,"1213":1,"1269":3,"1270":2,"1296":1,"1297":1,"1310":1}}],["oct",{"2":{"133":1,"137":1,"138":2,"140":1,"153":1,"203":2,"204":1,"1090":1,"1102":1,"1111":1,"1118":1,"1125":1,"1143":1,"1144":2,"1147":1,"1213":1,"1232":2}}],["obscured",{"2":{"1065":1}}],["obscuration",{"0":{"1065":2},"2":{"1052":1,"1053":2,"1054":1,"1065":6}}],["observation",{"2":{"1085":1,"1206":1,"1210":1,"1218":1}}],["observations",{"2":{"1080":1}}],["observability",{"2":{"128":1,"129":1,"701":1,"1426":1}}],["observe",{"2":{"1224":1,"1408":1}}],["observers",{"2":{"1070":1}}],["observer",{"2":{"1053":1,"1054":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1068":1,"1069":1,"1070":1,"1075":1,"1078":2,"1083":1,"1157":1,"1351":1}}],["observed",{"2":{"451":1,"1195":1,"1197":1,"1222":1,"1223":1,"1225":1}}],["observeweekendshifts",{"2":{"285":1,"291":1}}],["obj",{"0":{"500":1,"502":1},"2":{"503":1,"769":4}}],["objectify",{"0":{"472":1,"498":1,"501":1},"1":{"499":1,"500":1,"501":1,"502":1,"503":1,"504":1,"505":1},"2":{"472":1,"501":2,"502":2}}],["objective",{"0":{"407":1},"2":{"407":2,"419":2}}],["object>",{"2":{"437":1}}],["objects",{"0":{"81":1},"2":{"131":1,"132":1,"147":1,"169":2,"170":2,"173":2,"174":1,"198":1,"201":1,"295":1,"358":1,"407":1,"411":1,"418":1,"424":1,"427":1,"439":2,"444":1,"468":3,"471":1,"472":2,"500":1,"503":1,"504":2,"513":1,"514":2,"515":1,"536":1,"544":1,"562":1,"578":1,"580":1,"593":1,"606":2,"625":1,"626":1,"629":3,"633":1,"699":2,"755":1,"782":1,"864":1,"891":1,"894":1,"895":1,"903":2,"910":1,"920":1,"950":1,"973":1,"991":1,"998":1,"1011":1,"1035":1,"1036":1,"1067":1,"1073":1,"1160":1,"1287":1,"1412":1}}],["object",{"0":{"64":1,"160":1,"191":1,"195":1,"381":1,"409":1,"455":1,"734":1,"769":1,"797":1,"1405":1},"2":{"45":1,"64":1,"76":1,"111":2,"112":2,"114":2,"120":1,"132":1,"143":1,"146":1,"147":2,"154":1,"155":4,"157":1,"158":1,"160":1,"161":2,"191":3,"195":1,"226":1,"233":1,"243":1,"251":1,"269":3,"292":1,"298":1,"300":1,"301":3,"313":1,"314":1,"317":1,"319":1,"320":1,"326":1,"357":1,"360":1,"367":1,"379":1,"389":1,"402":2,"403":2,"406":2,"409":4,"410":2,"412":1,"414":2,"424":3,"425":8,"426":4,"427":2,"429":1,"431":2,"433":2,"434":2,"435":1,"438":1,"439":2,"440":1,"442":1,"453":6,"455":1,"456":2,"459":1,"461":2,"464":2,"465":1,"466":2,"468":4,"469":1,"472":1,"476":1,"477":2,"487":1,"491":1,"501":2,"502":2,"509":1,"512":1,"514":1,"520":5,"546":1,"561":1,"563":1,"564":1,"580":1,"585":1,"597":1,"609":1,"629":2,"637":1,"664":1,"672":1,"677":1,"712":1,"734":2,"738":2,"750":1,"757":2,"795":1,"797":2,"842":1,"850":1,"864":1,"865":1,"869":1,"897":1,"908":1,"910":1,"912":1,"920":1,"936":2,"938":1,"965":1,"973":1,"992":1,"998":2,"1010":1,"1011":4,"1042":2,"1071":2,"1167":2,"1191":2,"1284":1,"1319":1,"1403":1,"1405":1,"1417":1,"1418":1,"1436":1}}],["obviously",{"2":{"359":1}}],["obvious",{"2":{"274":1}}],["owning",{"2":{"782":1}}],["ownkeys",{"2":{"409":1}}],["own",{"0":{"853":1},"1":{"854":1,"855":1,"856":1,"857":1},"2":{"110":1,"116":1,"134":1,"229":2,"243":1,"260":1,"261":1,"275":1,"285":1,"311":1,"330":1,"409":1,"418":1,"447":1,"451":1,"461":1,"462":1,"464":2,"470":1,"472":1,"517":1,"519":2,"528":1,"643":1,"731":1,"737":2,"757":1,"851":1,"852":1,"913":1,"954":1,"1004":1,"1008":2}}],["others",{"2":{"1139":2}}],["otherstream",{"2":{"473":1}}],["otherwise",{"2":{"302":1,"383":2,"399":1}}],["other",{"0":{"297":1},"1":{"298":1},"2":{"102":1,"128":1,"139":1,"157":1,"238":1,"259":1,"297":1,"323":1,"324":2,"329":1,"331":1,"372":1,"425":1,"437":1,"720":2,"746":1,"912":1,"993":1,"1014":1,"1049":1,"1185":1,"1205":1,"1269":2,"1270":1,"1296":1,"1297":1}}],["overwhelms",{"2":{"1328":1}}],["overwritten",{"2":{"440":1,"631":1}}],["overwrite",{"2":{"298":1,"424":1,"425":1,"439":1,"977":1,"1185":1}}],["overwrites",{"2":{"148":1,"597":1}}],["overwriting",{"2":{"278":1,"439":1}}],["overtime",{"2":{"1035":1}}],["overflows",{"2":{"681":1}}],["overhauled",{"2":{"617":1,"729":1}}],["overhaul",{"2":{"598":1}}],["overhead",{"0":{"131":1,"197":1,"325":1,"699":1,"984":1,"1235":1,"1262":1},"1":{"132":1,"198":1,"199":1,"1263":1,"1264":1},"2":{"76":1,"147":1,"149":2,"203":1,"264":1,"266":1,"325":1,"357":1,"371":2,"403":1,"407":2,"411":1,"419":1,"428":1,"442":2,"444":1,"449":1,"450":1,"451":1,"469":1,"471":1,"488":1,"515":1,"528":1,"642":1,"676":1,"699":1,"704":1,"771":1,"818":1,"867":1,"1042":1,"1071":1,"1106":2,"1121":1,"1147":1,"1242":1,"1261":1,"1267":1,"1329":1,"1370":1}}],["overall",{"2":{"416":1,"891":1}}],["overarching",{"2":{"273":1,"466":1}}],["overridden",{"2":{"939":1,"963":1,"1180":1}}],["overriding",{"2":{"322":1,"375":1,"958":1}}],["overrides",{"0":{"118":1,"962":1},"2":{"101":1,"129":1,"155":1,"298":1,"606":1,"617":1,"631":1,"634":1,"709":1,"829":1,"871":2,"926":1,"1041":1,"1166":1}}],["override",{"0":{"217":1,"1180":1},"2":{"101":1,"105":2,"118":1,"121":2,"295":1,"296":1,"634":1,"854":1,"871":1,"881":1,"890":1,"899":1,"908":1,"935":1,"939":1,"955":1,"958":1,"978":1,"1158":1}}],["overview",{"0":{"300":1,"845":1,"1045":1,"1053":1,"1176":1},"2":{"623":1,"1125":1}}],["overlay",{"2":{"1224":1}}],["overlays",{"0":{"1224":1},"2":{"1210":1,"1213":6}}],["overlapping",{"2":{"179":1,"180":1,"1015":1,"1324":1}}],["overlaps",{"0":{"176":1},"2":{"176":1,"699":1,"711":1,"993":2}}],["overlap",{"2":{"174":1,"179":1,"631":1,"989":1}}],["overloads",{"2":{"709":1}}],["overloaded",{"0":{"332":1,"543":1,"831":1},"1":{"333":1,"334":1,"335":1},"2":{"540":1,"827":1,"831":1}}],["overload",{"2":{"102":1,"541":1,"750":1}}],["over",{"0":{"505":1,"1227":1},"1":{"1228":1,"1229":1,"1230":1,"1231":1},"2":{"138":3,"375":1,"427":1,"442":1,"450":1,"461":1,"468":1,"476":1,"498":1,"625":1,"829":1,"862":1,"932":1,"942":1,"947":1,"985":2,"1032":1,"1039":1,"1086":1,"1105":1,"1197":1,"1212":1,"1215":1,"1226":1,"1227":1,"1363":1}}],["old",{"2":{"439":1,"565":1,"728":1,"1041":1}}],["older",{"2":{"94":1,"365":1,"503":1,"560":1}}],["ollama",{"2":{"89":5,"854":1,"939":1,"1017":2}}],["opfs",{"2":{"857":1,"913":1,"1005":1}}],["opportunity",{"2":{"514":1}}],["op",{"2":{"262":1,"442":1,"450":1}}],["opinionated",{"2":{"137":1,"273":1}}],["opera",{"2":{"142":1,"1181":1}}],["operating",{"2":{"1364":1,"1443":1}}],["operation",{"2":{"352":1,"425":1,"427":1,"449":1,"524":1,"910":1,"973":1,"1021":1,"1023":1,"1038":1}}],["operational",{"0":{"936":1,"1188":1},"2":{"282":1,"869":1,"879":1,"930":1,"936":2,"937":1,"938":1,"962":1,"1166":1,"1183":1,"1364":1}}],["operations",{"0":{"175":1,"372":1,"1023":1},"1":{"176":1,"177":1,"178":1,"179":1,"180":1},"2":{"64":1,"334":1,"408":1,"411":1,"450":1,"494":1,"504":1,"505":1,"516":1,"543":1,"621":1,"694":1,"699":1,"709":1,"711":1,"771":1,"817":1,"871":1,"894":1,"920":1,"973":1,"1009":1,"1173":1,"1194":1,"1433":1,"1445":1}}],["operated",{"2":{"1268":1}}],["operate",{"2":{"402":1,"410":1,"418":1,"456":1,"760":1,"922":1,"1454":1}}],["operates",{"2":{"374":1,"489":1,"738":1,"1178":1,"1366":1}}],["operator",{"2":{"388":1,"737":1}}],["operators",{"2":{"64":1,"191":1,"195":1,"738":1}}],["opening",{"0":{"1447":1},"2":{"1447":1}}],["opener",{"2":{"1375":1,"1378":1}}],["opened",{"2":{"1203":3,"1204":1}}],["opencage",{"2":{"1189":1}}],["opentelemetry",{"2":{"1011":1}}],["openrouter",{"2":{"858":1}}],["openstreetmap",{"2":{"1168":1,"1175":1,"1178":5,"1191":1}}],["openstreetmapprovider",{"2":{"1166":1,"1178":2,"1179":1,"1180":1}}],["opens",{"2":{"737":1,"1448":1}}],["openaiapikey",{"2":{"1004":1}}],["openai",{"2":{"89":1,"477":1,"853":4,"854":4,"860":2,"868":1,"870":1,"872":1,"882":1,"912":1,"913":1,"925":1,"926":1,"927":2,"930":2,"933":2,"934":2,"939":3,"955":1,"957":2,"958":1,"966":1,"974":2,"1004":3}}],["open",{"0":{"171":1,"539":1,"866":1,"980":1},"2":{"8":1,"15":1,"23":1,"26":1,"84":1,"85":1,"102":1,"171":1,"173":1,"174":1,"177":1,"229":1,"333":3,"339":2,"534":2,"539":1,"548":1,"574":1,"607":2,"835":1,"836":1,"845":1,"854":1,"856":1,"866":2,"923":1,"942":1,"980":1,"985":2,"1015":1,"1025":1,"1057":1,"1107":1,"1155":1,"1174":1,"1211":1,"1252":1,"1300":1,"1321":1,"1349":1,"1384":1,"1410":1,"1447":1}}],["opts",{"2":{"285":2,"1158":1,"1168":6,"1169":2,"1176":3,"1191":3,"1344":4,"1345":3,"1382":1}}],["opted",{"2":{"256":1}}],["optimal",{"2":{"854":1,"958":1,"1103":1,"1135":1}}],["optimizing",{"2":{"363":1,"374":1}}],["optimizations",{"2":{"427":1,"441":1,"575":1,"922":1}}],["optimization",{"0":{"665":1,"684":1,"778":1},"2":{"260":1,"270":1,"311":1,"377":1,"565":1,"630":1,"635":1,"672":1,"1122":1}}],["optimize",{"2":{"126":1,"532":1}}],["optimized",{"2":{"10":1,"42":1,"124":1,"167":1,"228":1,"248":1,"412":1,"417":1,"424":1,"451":1,"505":1,"513":1,"616":1,"622":1,"625":1,"649":1,"699":1,"722":1,"1120":1}}],["optionally",{"2":{"321":1}}],["optional",{"2":{"282":1,"313":1,"367":2,"391":2,"437":1,"502":1,"550":1,"597":1,"645":1,"675":1,"769":1,"853":1,"870":1,"890":1,"891":2,"895":1,"896":1,"900":1,"904":1,"905":1,"925":1,"936":1,"938":4,"958":2,"1168":1,"1169":1,"1176":2,"1403":1}}],["option",{"0":{"226":1,"848":2,"849":1,"1280":1,"1281":1,"1282":1},"1":{"227":1},"2":{"117":1,"119":1,"146":1,"207":1,"291":1,"317":1,"377":1,"513":1,"541":1,"572":1,"609":1,"631":1,"637":1,"639":1,"647":1,"707":1,"871":1,"881":1,"890":1,"899":1,"937":1,"989":1,"991":1,"1022":1,"1088":1,"1158":1,"1207":1,"1214":1,"1240":1,"1254":1,"1263":3,"1404":1}}],["options",{"0":{"69":1,"117":1,"285":1,"536":1,"562":1,"816":1,"838":1,"854":1,"871":1,"881":1,"890":1,"899":1,"908":1,"934":1,"937":1,"962":1,"989":1,"1022":1,"1179":1,"1199":1,"1201":1,"1203":1,"1240":1,"1284":1,"1287":1,"1289":1,"1290":1,"1404":1},"1":{"563":1,"564":1,"565":1,"938":1,"990":1,"991":1},"2":{"69":2,"102":1,"105":2,"107":1,"112":1,"113":1,"115":4,"116":1,"119":1,"142":1,"166":1,"226":1,"235":1,"261":1,"262":1,"285":5,"286":1,"288":2,"289":2,"290":3,"298":1,"317":1,"331":4,"332":5,"338":4,"350":1,"357":1,"358":1,"374":1,"477":1,"536":2,"541":1,"542":1,"562":1,"563":1,"564":1,"631":1,"633":2,"639":1,"744":1,"747":1,"776":1,"807":1,"814":1,"816":1,"821":1,"830":1,"831":1,"836":2,"838":2,"847":1,"853":1,"854":2,"856":1,"874":2,"878":1,"908":2,"912":1,"926":2,"930":1,"935":1,"936":1,"962":2,"972":1,"979":1,"1021":1,"1038":1,"1104":7,"1185":1,"1195":1,"1318":2,"1319":1,"1403":2,"1417":1,"1418":1,"1421":1}}],["opt",{"0":{"311":1,"368":1,"555":1},"2":{"46":2,"93":1,"135":1,"210":1,"308":1,"938":1,"954":1,"959":1,"1093":1,"1098":1,"1449":1,"1451":1,"1452":1}}],["outlook",{"2":{"1014":1}}],["outlines",{"2":{"342":1,"441":1,"1086":1}}],["outbound",{"2":{"1011":1,"1188":1,"1229":1}}],["outweighs",{"2":{"972":1}}],["outcome",{"2":{"483":1}}],["outer",{"2":{"266":1,"1112":1}}],["outside",{"0":{"457":1},"1":{"458":1,"459":1,"460":1,"461":1},"2":{"121":2,"227":1,"717":1,"1041":1,"1091":1,"1128":1,"1132":1,"1417":1}}],["outputbuffer",{"2":{"1039":1}}],["outputs",{"2":{"157":1,"354":1,"355":3,"518":1,"723":1,"922":2,"934":2,"936":1,"950":1,"996":1,"997":1,"998":1,"1088":1,"1110":1}}],["output",{"0":{"364":1,"910":1},"1":{"365":1,"911":1,"912":1},"2":{"76":2,"117":1,"138":1,"146":1,"155":1,"157":1,"159":1,"231":1,"246":1,"356":1,"357":1,"361":1,"364":1,"513":1,"518":4,"561":2,"609":1,"637":1,"754":1,"755":1,"758":1,"869":1,"878":1,"890":1,"899":1,"972":1,"982":1,"994":1,"1010":2,"1022":1,"1042":2,"1090":1,"1113":2,"1114":1,"1115":2,"1116":3,"1118":2,"1144":2,"1147":2,"1150":3,"1167":1,"1190":1,"1329":1,"1459":1}}],["outdated",{"2":{"44":1,"714":1,"747":1,"1258":1}}],["out",{"2":{"8":1,"24":1,"101":1,"109":1,"120":1,"129":1,"135":1,"158":1,"161":1,"170":1,"210":1,"219":1,"236":1,"273":1,"331":1,"345":1,"452":1,"456":1,"475":1,"489":1,"510":1,"514":1,"516":1,"517":1,"526":1,"724":1,"754":1,"763":1,"768":1,"792":1,"851":1,"856":1,"865":1,"938":1,"955":1,"959":1,"982":1,"1136":1,"1158":1,"1260":1,"1269":1,"1387":1,"1428":1,"1459":1}}],["our",{"0":{"530":1},"1":{"531":1,"532":1,"533":1},"2":{"6":1,"10":1,"21":2,"45":1,"229":1,"233":1,"235":1,"236":1,"247":1,"270":1,"287":1,"293":1,"479":2,"522":1,"532":1,"534":2,"558":1,"560":1,"573":1,"729":1,"751":1,"861":1,"878":1,"889":1,"954":1,"957":1,"1008":1,"1224":1}}],["orbit",{"2":{"1064":1,"1075":1}}],["orbital",{"2":{"1052":1,"1053":1,"1069":1,"1075":1,"1076":1,"1077":1,"1353":2}}],["org",{"2":{"997":3,"1178":2,"1220":1}}],["organization",{"2":{"644":1}}],["organized",{"2":{"297":1,"771":1,"1453":1}}],["orthodox",{"2":{"951":1}}],["orthogonally",{"2":{"1076":1}}],["orthogonal",{"2":{"138":1,"1090":1,"1098":1}}],["orchestrating",{"2":{"1422":1}}],["orchestration",{"0":{"1081":1},"2":{"696":1,"702":1,"709":1,"937":1,"1021":1}}],["orchestrator",{"2":{"939":1,"942":2,"1038":1,"1040":1}}],["orphaned",{"2":{"495":1,"651":1,"1442":1,"1443":1}}],["orientation",{"2":{"1058":1,"1063":1}}],["oriented",{"2":{"269":1}}],["origins",{"2":{"856":1,"1000":1,"1240":1,"1263":1}}],["origins=",{"2":{"89":1}}],["origin",{"0":{"1262":1,"1263":1,"1375":1},"1":{"1263":1,"1264":1,"1376":1},"2":{"418":1,"856":1,"913":1,"1001":1,"1005":1,"1024":1,"1039":1,"1240":1,"1243":1,"1263":2,"1344":1,"1358":1,"1363":3,"1365":4,"1375":4,"1376":1,"1378":4,"1422":1}}],["originating",{"2":{"1113":1}}],["originated",{"2":{"129":1}}],["originally",{"2":{"1269":3}}],["original",{"2":{"173":1,"181":1,"281":1,"351":1,"504":2,"948":1,"1030":1,"1173":1,"1199":2,"1332":1}}],["oracleexport",{"2":{"1115":2}}],["oracle",{"2":{"78":1,"138":4,"150":1,"1099":1,"1103":3,"1104":5,"1115":3,"1116":2,"1123":2,"1149":1,"1150":2}}],["ordinarii",{"2":{"1273":1}}],["ordinary",{"2":{"402":1,"486":1,"1273":1}}],["ordinal",{"0":{"204":1},"2":{"138":1,"203":8,"297":1,"323":2,"324":4,"458":1,"460":1,"746":2,"754":1,"758":2,"771":1,"773":2,"775":2,"776":5,"893":1,"902":1,"1090":1,"1113":1,"1125":2}}],["ordinals",{"0":{"203":1,"776":1},"1":{"204":1},"2":{"115":1,"117":1,"203":5,"297":1,"771":4,"775":1,"776":5,"1055":1,"1113":1}}],["orderid",{"2":{"1389":3}}],["ordering",{"2":{"215":1,"219":1,"617":1,"637":2,"642":2,"644":1,"964":1,"1388":1}}],["orderdate",{"2":{"1199":2}}],["ordered",{"2":{"361":1,"1140":1,"1141":1}}],["orders",{"2":{"191":1,"1387":1}}],["order",{"0":{"926":1},"2":{"64":1,"100":1,"101":1,"128":1,"191":3,"219":1,"250":1,"314":1,"326":1,"362":3,"477":2,"633":1,"642":2,"644":1,"645":3,"669":1,"810":1,"812":1,"848":1,"934":2,"945":1,"947":1,"948":1,"1131":1,"1225":1,"1387":3,"1388":1,"1389":1}}],["ord",{"2":{"9":1,"42":1,"76":1,"131":1,"134":1,"138":2,"140":1,"324":5,"754":1,"763":1,"768":1,"1090":3,"1098":1,"1113":2,"1124":1,"1125":1}}],["or",{"0":{"62":1},"2":{"3":1,"6":2,"8":2,"10":2,"22":2,"26":2,"27":1,"28":1,"29":1,"33":1,"34":1,"41":1,"43":1,"44":1,"45":1,"46":1,"48":2,"63":3,"73":1,"75":2,"76":3,"77":1,"78":2,"81":1,"88":2,"89":4,"91":1,"93":2,"95":4,"96":4,"97":4,"99":1,"100":1,"102":8,"103":3,"105":1,"106":1,"107":1,"109":1,"110":2,"111":1,"112":1,"115":1,"116":4,"117":7,"119":2,"120":2,"121":4,"122":1,"123":1,"124":2,"125":3,"127":1,"131":1,"137":3,"138":12,"141":2,"142":5,"143":2,"144":2,"145":1,"146":3,"147":1,"150":1,"157":3,"158":3,"160":1,"162":1,"163":1,"164":2,"165":3,"168":1,"169":1,"170":1,"171":1,"173":3,"174":3,"177":1,"180":1,"185":1,"186":1,"189":1,"191":1,"193":1,"198":1,"199":1,"201":1,"202":1,"203":2,"204":1,"205":3,"214":1,"215":2,"216":2,"219":1,"221":2,"223":2,"224":2,"226":1,"227":1,"229":1,"230":2,"231":1,"233":3,"236":2,"240":6,"241":2,"243":2,"247":1,"248":1,"251":2,"261":2,"262":1,"266":2,"273":2,"274":1,"281":4,"282":2,"283":2,"285":1,"287":1,"288":1,"290":2,"291":1,"293":1,"294":1,"295":2,"296":2,"300":1,"314":1,"315":1,"321":1,"322":1,"324":1,"326":7,"327":1,"328":1,"329":2,"333":1,"334":1,"345":1,"351":1,"352":1,"357":1,"358":2,"361":2,"362":3,"363":3,"365":3,"367":2,"368":1,"370":1,"377":1,"379":1,"382":1,"387":1,"389":1,"390":2,"392":1,"393":3,"399":2,"403":1,"404":1,"406":1,"407":2,"413":1,"421":1,"422":2,"427":1,"429":1,"430":1,"431":2,"439":1,"440":2,"444":1,"446":1,"453":2,"458":1,"461":1,"468":6,"471":1,"472":3,"473":1,"475":1,"476":2,"477":3,"481":2,"483":1,"484":1,"486":2,"487":2,"489":2,"490":1,"491":1,"493":4,"496":2,"498":1,"503":2,"504":3,"506":1,"510":2,"511":1,"513":3,"517":1,"518":1,"519":1,"520":3,"522":2,"525":1,"526":1,"531":1,"532":1,"536":1,"538":1,"539":2,"541":3,"544":1,"556":1,"571":2,"573":1,"600":1,"630":1,"634":2,"637":1,"643":1,"668":1,"691":1,"695":1,"699":3,"704":1,"707":1,"711":3,"716":1,"731":1,"734":1,"735":1,"769":2,"771":2,"776":2,"777":1,"782":1,"797":1,"802":1,"806":1,"812":1,"829":2,"832":1,"833":1,"838":2,"845":2,"854":2,"855":2,"856":7,"857":5,"858":2,"859":1,"860":2,"861":1,"862":1,"863":2,"864":1,"865":3,"866":3,"867":2,"869":2,"870":1,"872":3,"874":1,"875":1,"876":1,"879":2,"882":2,"884":1,"888":1,"890":1,"891":4,"894":1,"895":1,"897":2,"899":2,"900":1,"904":1,"909":3,"910":2,"911":1,"912":3,"913":3,"918":1,"919":3,"920":1,"922":2,"925":1,"926":1,"932":1,"933":1,"936":2,"937":7,"938":7,"939":1,"942":4,"949":1,"950":3,"953":1,"954":4,"955":2,"957":2,"958":3,"959":1,"963":1,"968":1,"969":1,"973":1,"974":1,"975":1,"976":2,"978":2,"980":1,"986":3,"989":1,"991":2,"996":2,"998":3,"1000":2,"1001":1,"1003":1,"1004":1,"1005":3,"1007":2,"1008":9,"1009":4,"1010":2,"1011":2,"1013":1,"1015":1,"1016":2,"1023":1,"1028":1,"1030":1,"1038":1,"1039":1,"1041":3,"1042":1,"1045":1,"1048":1,"1054":2,"1055":3,"1060":1,"1062":1,"1063":1,"1064":2,"1065":2,"1067":1,"1071":2,"1072":1,"1076":5,"1077":2,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1088":1,"1091":1,"1092":1,"1093":1,"1094":2,"1095":3,"1098":1,"1104":8,"1108":1,"1113":1,"1114":1,"1115":1,"1125":1,"1130":1,"1132":2,"1134":5,"1135":2,"1136":1,"1139":1,"1143":1,"1146":1,"1147":1,"1149":2,"1150":1,"1157":2,"1160":1,"1167":2,"1168":3,"1169":1,"1172":2,"1173":1,"1175":1,"1178":4,"1182":1,"1185":1,"1186":1,"1187":1,"1188":1,"1189":2,"1190":4,"1191":1,"1193":2,"1199":1,"1207":1,"1214":1,"1218":1,"1219":1,"1222":3,"1223":1,"1224":1,"1232":1,"1233":1,"1234":1,"1235":1,"1240":5,"1243":1,"1255":2,"1257":1,"1258":1,"1259":3,"1262":1,"1263":3,"1267":1,"1269":1,"1270":1,"1276":1,"1287":1,"1289":1,"1294":1,"1295":1,"1298":1,"1303":1,"1304":1,"1306":1,"1315":1,"1316":1,"1319":2,"1324":1,"1328":2,"1329":1,"1331":2,"1332":1,"1344":3,"1351":1,"1352":1,"1362":1,"1363":2,"1364":1,"1367":1,"1368":1,"1369":1,"1370":2,"1371":1,"1374":1,"1376":2,"1378":1,"1387":1,"1391":1,"1394":2,"1403":1,"1404":1,"1405":1,"1412":2,"1415":1,"1422":3,"1425":2,"1428":1,"1435":1,"1436":1,"1439":1,"1442":2,"1443":2,"1444":1,"1445":2,"1448":2,"1451":1,"1454":1,"1459":2}}],["o",{"0":{"444":1,"1235":1},"2":{"1":1,"96":1,"97":1,"98":1,"106":1,"124":1,"125":5,"148":2,"203":1,"204":1,"371":1,"372":1,"373":1,"416":4,"419":1,"424":1,"425":1,"426":1,"429":1,"442":1,"444":1,"446":2,"473":1,"625":1,"684":1,"752":2,"792":1,"1091":1,"1093":1,"1135":2,"1235":1,"1329":1,"1353":1,"1370":1,"1377":1,"1381":1,"1382":1,"1388":1,"1395":1}}],["often",{"2":{"375":1,"472":1,"510":1,"512":1,"878":1,"972":1,"995":1,"1093":1,"1109":1,"1157":1,"1255":1}}],["offload",{"2":{"1029":1}}],["offloads",{"2":{"1019":1}}],["offline",{"0":{"1213":1},"2":{"204":1,"610":1,"856":1,"1080":1,"1212":1,"1448":1}}],["office",{"2":{"878":1,"1273":1,"1312":1}}],["officially",{"2":{"701":1,"732":1,"750":2}}],["official",{"0":{"87":1},"2":{"13":1,"14":1,"24":1,"34":1,"48":1,"83":1,"85":1,"87":1,"167":1,"247":1,"365":1,"402":1,"559":1,"692":1,"804":1,"808":1,"812":1,"845":1,"1190":1,"1309":1}}],["offer",{"2":{"469":1,"529":1}}],["offering",{"2":{"278":1,"513":1}}],["offers",{"2":{"83":1,"97":1,"109":1,"157":1,"248":1,"792":1}}],["off",{"0":{"1042":1},"1":{"1043":1},"2":{"116":1,"117":1,"127":1,"138":1,"157":1,"199":1,"331":1,"490":1,"684":1,"983":1,"1223":1}}],["offsite",{"2":{"896":1}}],["offsetms",{"2":{"1248":1}}],["offsetcompact",{"2":{"1125":1}}],["offset",{"0":{"213":1,"1230":1,"1247":1,"1350":1,"1366":1},"1":{"214":1,"1351":1,"1352":1,"1353":1},"2":{"138":19,"149":1,"213":1,"214":1,"245":2,"296":2,"297":1,"381":1,"387":2,"522":1,"637":2,"689":1,"723":1,"775":1,"788":5,"798":1,"818":1,"910":1,"1054":1,"1078":1,"1125":9,"1234":2,"1235":1,"1242":1,"1243":2,"1246":1,"1247":2,"1251":1,"1254":2,"1263":1,"1264":3,"1265":1,"1267":1,"1339":1,"1343":1,"1344":2,"1345":1,"1350":1,"1351":1,"1352":2,"1353":1,"1413":1,"1415":1,"1422":2}}],["offsets",{"0":{"689":1},"2":{"59":1,"138":1,"213":1,"296":1,"324":1,"357":1,"654":1,"689":1,"735":1,"776":2,"1010":1,"1125":1,"1351":1,"1362":1,"1366":1}}],["offs",{"0":{"467":1,"469":1},"1":{"468":1,"469":1},"2":{"43":2,"199":1,"472":1,"498":1}}],["of",{"0":{"43":1,"50":1,"82":1,"129":1,"203":1,"270":1,"338":1,"379":1,"429":1,"434":1,"442":1,"457":1,"819":1,"832":1,"920":1,"985":1,"1157":1,"1435":1,"1446":1},"1":{"204":1,"380":1,"381":1,"382":1,"458":1,"459":1,"460":1,"461":1},"2":{"0":2,"1":1,"8":1,"19":1,"20":1,"21":1,"22":2,"23":1,"24":1,"27":1,"34":2,"39":1,"41":1,"43":1,"49":1,"62":2,"63":2,"64":1,"76":2,"77":1,"94":1,"100":1,"101":1,"102":2,"108":1,"109":1,"117":1,"118":3,"120":2,"124":1,"125":1,"127":1,"129":1,"130":1,"132":1,"134":2,"135":1,"137":7,"138":11,"140":2,"146":1,"147":1,"148":1,"150":3,"151":6,"152":4,"155":3,"157":2,"158":2,"161":3,"163":1,"164":1,"166":1,"167":3,"170":1,"174":3,"177":3,"180":1,"181":1,"185":2,"186":2,"188":2,"189":2,"190":5,"191":1,"194":2,"196":1,"198":1,"202":2,"203":13,"204":2,"210":2,"215":1,"216":1,"219":3,"220":1,"228":1,"229":2,"230":2,"231":1,"233":1,"235":1,"250":1,"263":2,"264":1,"266":2,"268":1,"270":1,"273":1,"274":1,"276":1,"278":1,"279":1,"280":2,"281":1,"283":1,"285":1,"288":1,"290":1,"291":1,"296":2,"298":1,"300":4,"301":5,"306":1,"307":1,"314":1,"321":1,"322":1,"323":1,"324":2,"328":1,"329":1,"331":1,"334":1,"337":1,"340":1,"343":1,"344":1,"345":2,"346":1,"347":1,"348":2,"350":2,"351":2,"353":1,"358":2,"361":1,"362":1,"363":2,"365":2,"366":2,"370":3,"375":2,"376":1,"378":1,"380":3,"381":2,"382":4,"383":1,"385":2,"387":4,"388":2,"389":1,"391":1,"392":1,"393":2,"396":1,"397":1,"399":1,"402":3,"406":2,"407":5,"410":2,"411":1,"415":2,"416":2,"418":1,"419":2,"423":1,"429":5,"439":1,"449":2,"451":2,"452":4,"456":3,"457":1,"461":1,"464":1,"467":1,"469":3,"471":2,"472":1,"475":1,"477":1,"478":1,"479":1,"483":1,"486":2,"487":1,"488":1,"489":1,"492":1,"501":1,"502":1,"503":2,"504":1,"510":1,"511":1,"512":1,"515":1,"516":3,"517":1,"518":1,"520":1,"524":2,"526":1,"527":1,"528":2,"529":1,"532":1,"541":1,"544":1,"546":1,"556":3,"558":1,"559":1,"567":1,"574":2,"580":1,"584":1,"592":1,"593":1,"597":1,"600":1,"606":2,"616":1,"617":1,"625":1,"626":2,"630":1,"634":1,"647":1,"659":1,"699":1,"701":2,"707":1,"723":1,"724":1,"726":1,"739":7,"743":2,"747":1,"750":4,"752":2,"754":1,"757":1,"758":1,"763":3,"768":2,"769":1,"771":3,"773":1,"775":3,"776":4,"792":1,"808":1,"817":1,"829":1,"830":1,"832":1,"836":1,"846":1,"848":1,"861":1,"864":1,"865":1,"871":1,"875":1,"877":1,"880":1,"881":2,"882":1,"887":1,"889":1,"890":2,"891":3,"893":1,"896":1,"899":1,"900":1,"902":2,"907":1,"908":2,"909":4,"919":1,"921":1,"922":1,"934":2,"937":1,"938":1,"941":1,"947":1,"948":1,"949":1,"954":2,"959":2,"962":1,"964":1,"968":1,"970":2,"972":6,"973":1,"975":1,"981":1,"983":3,"985":1,"986":3,"987":1,"989":1,"992":3,"997":1,"1004":1,"1008":1,"1011":1,"1013":1,"1014":1,"1015":1,"1019":3,"1022":1,"1028":1,"1032":2,"1033":1,"1035":2,"1036":1,"1037":1,"1047":1,"1054":1,"1055":2,"1062":1,"1063":1,"1064":1,"1065":1,"1068":2,"1069":3,"1076":1,"1081":1,"1082":1,"1083":1,"1086":1,"1088":10,"1090":5,"1093":1,"1094":1,"1096":1,"1098":1,"1105":1,"1110":2,"1111":1,"1113":1,"1117":1,"1125":5,"1131":2,"1132":2,"1136":2,"1140":1,"1146":1,"1158":2,"1173":1,"1178":1,"1189":1,"1199":1,"1201":1,"1203":3,"1213":2,"1218":1,"1222":1,"1232":1,"1235":1,"1240":1,"1265":1,"1267":1,"1269":2,"1270":3,"1271":2,"1272":1,"1273":3,"1276":2,"1280":1,"1307":2,"1318":1,"1325":1,"1328":1,"1329":1,"1335":2,"1344":1,"1345":1,"1351":1,"1353":1,"1360":1,"1364":2,"1366":2,"1372":1,"1387":2,"1389":1,"1392":1,"1403":1,"1405":1,"1406":1,"1409":1,"1411":1,"1412":2,"1413":1,"1415":2,"1416":2,"1422":1,"1426":3,"1427":1,"1428":1,"1429":1,"1430":1,"1434":1,"1435":1,"1442":1,"1443":1,"1444":1,"1445":1,"1446":2,"1448":1,"1457":1}}],["onclientdisconnect",{"2":{"955":3}}],["once",{"2":{"26":1,"119":1,"124":1,"165":1,"199":1,"266":1,"268":1,"300":2,"326":1,"327":1,"341":2,"349":1,"408":1,"412":1,"427":1,"429":2,"431":1,"475":1,"490":1,"741":1,"856":2,"948":1,"955":1,"1036":1,"1146":1,"1147":1,"1235":1,"1267":1,"1270":1,"1412":1,"1422":1,"1448":1}}],["onward",{"2":{"948":1}}],["online",{"2":{"875":1}}],["only",{"0":{"260":1},"2":{"34":1,"46":1,"103":1,"109":1,"114":1,"124":2,"127":1,"129":1,"155":1,"158":1,"172":1,"196":1,"197":1,"199":2,"211":1,"216":2,"221":1,"228":1,"233":1,"249":1,"250":1,"260":1,"264":1,"266":1,"269":1,"276":1,"295":1,"298":1,"307":1,"311":1,"313":1,"321":1,"326":1,"327":2,"329":1,"359":1,"394":1,"402":1,"409":1,"414":1,"416":1,"429":1,"430":1,"432":1,"435":1,"437":1,"440":1,"444":1,"449":1,"451":1,"453":1,"478":1,"489":2,"505":1,"507":2,"517":1,"526":1,"552":1,"565":1,"640":1,"642":1,"675":2,"699":1,"701":2,"737":1,"738":1,"818":1,"829":1,"857":1,"862":1,"864":1,"884":1,"913":1,"915":1,"920":1,"938":1,"958":1,"968":1,"972":2,"988":1,"1003":1,"1048":2,"1049":1,"1082":1,"1125":1,"1147":1,"1168":1,"1239":1,"1319":1,"1448":1,"1457":1}}],["onboarding",{"0":{"524":1,"951":1},"1":{"952":1,"953":1,"954":1,"955":1,"956":1,"957":1,"958":1,"959":1},"2":{"705":1,"869":1,"953":1,"1008":1}}],["onsettle",{"2":{"475":1,"483":2,"485":1}}],["onreject",{"2":{"475":1,"483":2}}],["onresolve",{"2":{"475":1,"483":2}}],["onto",{"2":{"161":1,"409":1,"426":2,"916":1,"1104":3,"1117":1,"1164":1,"1341":1}}],["onekey",{"2":{"1318":1}}],["one",{"0":{"1266":1,"1421":1},"2":{"138":1,"178":1,"192":1,"199":1,"219":1,"258":1,"266":1,"297":1,"309":1,"321":1,"329":1,"372":1,"373":1,"385":1,"387":1,"402":1,"406":2,"431":1,"440":1,"467":1,"469":1,"514":1,"684":1,"705":1,"741":2,"746":1,"752":1,"769":1,"878":1,"934":2,"973":1,"1039":1,"1104":1,"1110":1,"1233":1,"1249":1,"1278":1,"1319":1,"1392":1,"1401":1,"1421":2,"1445":1}}],["ones",{"2":{"101":1}}],["on",{"0":{"458":1,"1424":1},"1":{"1425":1},"2":{"0":1,"10":1,"12":1,"14":1,"43":2,"44":2,"45":1,"58":1,"63":3,"69":1,"77":1,"96":1,"102":1,"112":1,"119":1,"121":1,"124":1,"133":1,"137":1,"138":1,"139":2,"141":1,"143":1,"145":1,"147":1,"148":1,"150":2,"159":1,"161":2,"164":1,"170":1,"191":1,"194":1,"195":1,"204":1,"205":2,"210":1,"219":2,"225":1,"227":1,"228":1,"229":1,"264":1,"265":1,"266":2,"270":1,"273":1,"276":2,"279":1,"280":2,"281":1,"293":1,"298":1,"300":1,"306":1,"319":1,"327":2,"329":1,"334":1,"347":1,"361":1,"362":1,"363":1,"371":1,"379":1,"394":1,"399":1,"402":4,"403":1,"407":2,"409":3,"410":1,"412":1,"416":1,"419":3,"424":4,"425":2,"426":1,"427":1,"444":1,"446":2,"450":1,"451":2,"452":1,"453":2,"456":1,"457":1,"458":1,"464":1,"465":2,"466":1,"469":1,"470":1,"471":2,"473":3,"477":3,"479":1,"481":1,"482":1,"489":1,"490":4,"491":2,"512":1,"513":1,"516":1,"517":1,"518":2,"519":1,"520":1,"537":1,"552":1,"556":1,"560":1,"561":1,"565":1,"569":1,"573":2,"627":1,"635":1,"637":1,"657":1,"663":1,"699":1,"723":1,"735":1,"738":2,"739":1,"747":1,"755":1,"757":1,"759":1,"771":1,"776":2,"780":2,"782":3,"792":1,"824":1,"833":1,"838":1,"840":1,"846":1,"847":1,"853":1,"856":2,"857":1,"861":1,"862":2,"863":1,"871":1,"878":1,"881":1,"908":1,"909":4,"911":1,"913":1,"922":1,"925":1,"933":1,"936":2,"942":1,"947":1,"948":1,"950":2,"955":1,"971":1,"973":1,"981":1,"982":1,"992":1,"993":1,"996":1,"1004":1,"1009":1,"1011":3,"1013":1,"1017":2,"1028":1,"1042":1,"1052":1,"1054":2,"1063":2,"1065":1,"1067":1,"1072":4,"1075":1,"1076":1,"1078":1,"1080":2,"1081":1,"1085":1,"1087":1,"1088":2,"1091":5,"1093":2,"1095":2,"1097":1,"1098":1,"1101":2,"1106":2,"1112":4,"1125":1,"1127":2,"1128":1,"1140":1,"1166":1,"1176":1,"1178":1,"1188":1,"1189":1,"1192":1,"1195":2,"1203":2,"1218":2,"1219":3,"1220":1,"1221":6,"1222":3,"1234":1,"1239":1,"1242":1,"1255":2,"1259":1,"1268":1,"1269":6,"1270":1,"1271":1,"1273":1,"1304":1,"1310":2,"1314":1,"1343":1,"1355":1,"1362":1,"1366":3,"1370":1,"1372":1,"1378":1,"1401":4,"1405":1,"1424":4,"1425":1,"1429":1,"1444":3,"1447":2,"1448":2,"1454":2}}],["aa",{"2":{"1125":1}}],["axis",{"2":{"1081":1}}],["axial",{"2":{"1069":1}}],["azimuth",{"0":{"1365":1},"2":{"1052":1,"1053":1,"1054":1,"1058":1,"1062":3,"1071":2,"1080":1,"1344":1,"1358":1,"1362":1}}],["azure",{"2":{"854":6,"1004":2}}],["ahead",{"2":{"948":1,"1366":1}}],["aws",{"2":{"1004":1,"1103":1,"1143":1,"1188":1}}],["awst",{"2":{"296":1}}],["awkward",{"2":{"793":1,"1324":1}}],["away",{"2":{"705":1,"1335":2}}],["awaitable",{"2":{"592":1}}],["await",{"0":{"538":1,"1432":1,"1434":1,"1435":1,"1446":1},"1":{"1433":1,"1434":1},"2":{"77":3,"88":1,"98":1,"103":3,"108":1,"109":2,"112":1,"334":2,"473":3,"477":2,"481":2,"489":4,"492":2,"538":1,"600":1,"741":1,"792":1,"835":1,"839":1,"855":1,"856":4,"859":2,"860":4,"870":1,"875":1,"877":1,"878":2,"880":2,"885":2,"887":1,"889":2,"894":1,"895":1,"896":1,"898":2,"903":1,"904":1,"905":1,"908":2,"912":1,"916":2,"917":1,"918":2,"925":1,"929":2,"930":1,"931":1,"932":2,"933":1,"934":3,"935":1,"939":2,"945":1,"946":1,"948":1,"949":1,"950":2,"954":2,"955":4,"957":1,"958":1,"961":2,"962":1,"964":1,"968":1,"970":1,"973":2,"974":1,"975":1,"976":2,"977":1,"978":7,"982":2,"983":1,"984":1,"985":1,"988":2,"997":2,"998":1,"1004":2,"1009":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1019":1,"1020":1,"1030":2,"1033":1,"1036":2,"1158":2,"1159":1,"1167":5,"1171":2,"1172":2,"1178":7,"1180":1,"1181":2,"1184":3,"1188":1,"1191":4,"1192":1,"1216":1,"1217":1,"1239":1,"1241":1,"1243":1,"1254":1,"1256":1,"1261":1,"1264":2,"1396":1,"1401":2,"1405":2,"1408":2,"1409":2,"1412":4,"1417":2,"1418":2,"1419":1,"1422":2,"1430":2,"1434":3,"1435":2,"1442":1,"1443":1,"1444":1,"1445":2,"1446":2}}],["awareness",{"0":{"886":1,"1205":1},"2":{"522":1,"1207":1,"1218":1}}],["aware",{"0":{"318":1,"1060":1,"1061":1},"1":{"319":1,"320":1,"321":1},"2":{"71":1,"73":1,"84":1,"117":1,"165":1,"198":1,"201":1,"202":1,"296":1,"303":1,"304":1,"403":1,"418":2,"449":1,"531":1,"606":1,"622":1,"665":1,"676":1,"934":1,"996":1,"1044":1,"1050":1,"1052":2,"1053":1,"1058":1,"1214":1,"1443":1}}],["aerial",{"2":{"1084":1}}],["aedt",{"2":{"296":1}}],["aesthetic",{"2":{"651":1}}],["aest",{"2":{"138":1,"213":2,"214":1,"240":1,"296":1,"689":2}}],["ab",{"0":{"1272":1},"2":{"1272":1,"1275":1,"1276":1,"1285":1}}],["ablative",{"0":{"1292":1},"2":{"1269":3,"1270":1,"1276":2}}],["able",{"2":{"482":1}}],["abandoning",{"2":{"738":1}}],["abandoned",{"2":{"473":1}}],["ability",{"0":{"482":1},"2":{"387":1,"515":1}}],["absorption",{"2":{"1081":1}}],["absolutely",{"2":{"147":1,"427":1}}],["absolute",{"0":{"165":1},"1":{"166":1},"2":{"43":1,"107":1,"137":1,"174":1,"181":1,"191":2,"342":1,"357":1,"381":1,"418":1,"654":2,"734":1,"867":1,"976":1,"1013":1,"1159":1,"1276":1,"1388":1,"1444":1}}],["abstractions",{"0":{"512":1},"2":{"1382":1}}],["abstraction",{"2":{"476":1}}],["abs",{"2":{"233":1,"235":1,"520":1}}],["abutting",{"2":{"180":1}}],["abuts",{"0":{"178":1},"2":{"178":1,"711":1}}],["abbreviation",{"2":{"219":1,"240":1,"296":1,"752":1,"1125":2}}],["abbreviations",{"0":{"689":1},"2":{"138":1,"213":3,"214":1,"294":1,"296":1,"363":2,"689":1,"1143":1,"1303":1}}],["abbreviated",{"2":{"138":1,"1090":1,"1125":2,"1276":1,"1310":1}}],["aborted",{"2":{"860":1,"946":1,"955":1}}],["aborterror",{"2":{"860":1}}],["abort",{"2":{"493":1,"860":1,"955":3}}],["abortcontroller",{"2":{"493":1,"860":1,"955":2}}],["abortsignal",{"2":{"493":1,"949":1}}],["about",{"2":{"46":1,"64":1,"234":1,"265":1,"267":1,"341":1,"747":1,"1016":1}}],["above",{"2":{"43":1,"112":1,"142":1,"266":1,"456":1,"1062":2,"1067":1,"1071":1,"1072":3,"1081":1}}],["aviation",{"2":{"1344":1,"1362":1,"1363":1}}],["avg",{"2":{"940":1,"1329":2}}],["average",{"0":{"1234":1},"2":{"416":2,"419":2,"449":1,"1226":1,"1234":1,"1236":1,"1240":1,"1246":1,"1267":1,"1360":1}}],["availability",{"2":{"179":1}}],["available",{"0":{"117":1,"221":1,"240":1,"252":1},"1":{"241":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":1,"259":1,"260":1},"2":{"37":1,"76":1,"133":1,"150":1,"155":1,"215":1,"271":1,"276":1,"284":1,"315":1,"316":1,"342":1,"343":1,"347":1,"380":1,"409":1,"410":1,"416":1,"451":1,"489":1,"503":1,"597":1,"768":1,"776":1,"916":1,"942":1,"948":1,"987":1,"992":1,"1030":1,"1038":1}}],["avoiding",{"2":{"948":1,"988":1}}],["avoids",{"2":{"942":2,"1039":1}}],["avoidance",{"0":{"942":1},"2":{"867":1,"934":1}}],["avoid",{"2":{"34":1,"44":1,"93":1,"128":1,"170":1,"216":1,"261":1,"276":1,"282":1,"326":2,"341":1,"359":1,"403":1,"406":1,"416":1,"457":1,"747":1,"767":1,"947":1,"992":1,"1011":1,"1113":1,"1161":1,"1452":1,"1459":1}}],["agriculture",{"0":{"1082":1}}],["agricultural",{"2":{"1080":1}}],["agreements",{"2":{"1219":1}}],["agreement",{"2":{"950":1,"1194":1}}],["agreed",{"2":{"934":1}}],["agree",{"2":{"934":2,"950":1}}],["aged",{"2":{"1213":1}}],["agedays",{"2":{"1059":1}}],["agent",{"2":{"1178":3}}],["agents",{"2":{"1011":1,"1013":1}}],["age",{"2":{"1052":1,"1053":1,"1058":1,"1059":1,"1213":1}}],["again",{"2":{"977":1}}],["against",{"2":{"69":1,"109":1,"141":1,"220":1,"228":1,"340":1,"352":1,"357":1,"362":1,"418":1,"445":1,"447":1,"448":2,"450":1,"451":1,"466":1,"519":1,"665":1,"729":1,"744":1,"773":1,"856":1,"864":1,"876":1,"888":1,"910":1,"972":1,"993":2,"1010":1,"1012":1,"1013":2,"1106":1,"1144":1,"1173":1,"1233":1,"1239":1,"1293":1,"1422":1,"1442":1}}],["aggregations",{"2":{"1444":1}}],["aggregating",{"2":{"1328":1}}],["aggregators",{"2":{"995":1,"998":1}}],["aggregator",{"0":{"286":1},"2":{"286":1,"1329":5}}],["aggressive",{"2":{"191":1,"283":1}}],["aggressively",{"2":{"44":1,"412":1}}],["agnostic",{"0":{"1430":1},"2":{"33":1,"479":1}}],["ago",{"2":{"12":1,"59":1,"66":1,"157":2,"159":2,"201":1,"240":1,"352":1,"390":1,"396":1,"397":2,"520":3,"684":1,"737":2,"787":1,"886":1,"951":1}}],["afx",{"2":{"240":1,"242":1}}],["affix",{"2":{"221":1,"240":1}}],["affecting",{"2":{"118":1,"644":1}}],["affect",{"2":{"43":1,"331":1}}],["affected",{"2":{"22":1}}],["africa",{"2":{"146":2,"1158":1}}],["afternoon",{"2":{"59":1,"140":2,"158":2,"194":1,"306":1,"351":1,"380":1,"387":1,"987":1,"988":1,"1012":1,"1016":1,"1219":1,"1415":2}}],["after",{"2":{"23":1,"103":1,"110":1,"112":1,"113":1,"123":3,"139":1,"204":1,"225":1,"250":1,"262":1,"316":1,"368":1,"383":1,"393":1,"396":1,"407":1,"409":1,"410":1,"416":1,"419":2,"428":1,"429":1,"456":1,"503":1,"568":1,"714":1,"782":1,"911":1,"925":1,"941":1,"942":1,"946":1,"948":1,"951":2,"954":1,"957":1,"970":1,"1008":1,"1213":2,"1222":1,"1224":1,"1438":2,"1443":1}}],["asx",{"2":{"1430":1}}],["asymmetrical",{"2":{"1233":1}}],["asynciterator",{"2":{"1405":1,"1435":1}}],["asynciterable",{"2":{"492":1}}],["asyncdispose",{"2":{"1256":1,"1405":1,"1432":1}}],["asyncdisposable",{"2":{"494":1,"1445":1}}],["asyncfunction",{"2":{"505":1}}],["asyncgenerator",{"2":{"489":1,"1405":1,"1446":1}}],["asyncgenerators",{"2":{"236":1}}],["asyncevaluable",{"2":{"477":1,"841":1,"933":1,"938":1,"1004":1}}],["asynchronously",{"2":{"477":1,"504":1,"538":1,"782":1,"913":1,"1008":1,"1168":1,"1169":1,"1246":1}}],["asynchronous",{"0":{"480":1,"1434":1},"1":{"481":1,"482":1,"483":1,"484":1,"485":1,"486":1,"487":1},"2":{"106":1,"108":2,"334":1,"473":1,"474":1,"477":1,"480":1,"488":1,"839":1,"895":1,"904":1,"933":1,"978":1,"1004":1,"1212":1,"1225":1,"1233":1,"1261":1,"1267":1,"1374":1,"1387":1,"1394":1,"1405":1,"1431":1}}],["async",{"0":{"492":1,"978":1,"1216":1,"1409":1,"1430":1,"1435":1},"2":{"69":1,"119":1,"334":1,"473":2,"477":2,"488":1,"496":2,"600":1,"602":1,"634":1,"683":1,"741":1,"792":2,"831":1,"855":1,"856":1,"860":1,"933":2,"955":1,"959":1,"978":5,"1004":2,"1013":1,"1014":1,"1015":1,"1016":1,"1030":1,"1033":1,"1036":1,"1178":4,"1191":3,"1192":1,"1207":1,"1210":1,"1396":1,"1401":1,"1405":1,"1412":1,"1430":1,"1435":2,"1443":1,"1444":2,"1445":2,"1446":2}}],["asynclocalstorage",{"2":{"69":2,"119":2,"1004":1}}],["asp",{"2":{"1123":1}}],["ascension",{"2":{"1213":1}}],["ascurrency",{"2":{"593":1}}],["ascii",{"2":{"370":1}}],["asks",{"2":{"363":1}}],["ask",{"2":{"247":1}}],["asking",{"2":{"30":1,"909":1}}],["ast",{"2":{"155":1,"910":1,"1055":1,"1066":1,"1069":3,"1104":1,"1113":1,"1121":1}}],["astroterm",{"2":{"1045":1,"1049":3}}],["astrological",{"0":{"305":1},"2":{"230":1,"305":1,"307":1,"775":1}}],["astronomicalyear",{"2":{"1304":2}}],["astronomical",{"0":{"1044":1,"1046":1,"1048":1,"1074":1,"1075":1,"1295":1},"1":{"1045":1,"1046":1,"1047":1,"1048":1,"1049":1,"1075":1,"1076":1,"1077":1,"1078":1,"1079":1},"2":{"12":1,"83":1,"84":1,"137":1,"138":2,"150":3,"202":3,"229":1,"526":1,"609":1,"849":1,"1044":1,"1045":1,"1046":1,"1047":1,"1049":1,"1050":1,"1052":3,"1053":3,"1054":3,"1055":1,"1067":3,"1073":2,"1074":1,"1076":1,"1077":1,"1080":1,"1268":1,"1272":3,"1273":1,"1276":1,"1280":1,"1291":1,"1294":1,"1295":1,"1304":1,"1312":1,"1313":1}}],["astronomy",{"0":{"1047":1},"2":{"9":1,"334":1,"543":1,"845":1,"1045":1,"1046":6,"1047":2}}],["astro",{"2":{"11":1,"12":1,"14":1,"141":1,"722":1,"771":1,"775":1,"849":1,"1045":1,"1046":2,"1047":11,"1049":1,"1052":1}}],["asia",{"2":{"112":1,"113":1,"146":1,"296":3,"637":1,"908":1,"1429":1,"1430":1}}],["as",{"0":{"235":1},"2":{"24":1,"28":1,"39":1,"43":1,"76":1,"95":1,"102":2,"109":1,"112":1,"116":1,"119":1,"137":1,"138":4,"139":1,"141":1,"150":1,"158":4,"163":1,"165":1,"168":1,"202":1,"205":2,"207":1,"208":2,"213":3,"214":1,"216":2,"219":3,"233":1,"243":2,"249":1,"253":2,"261":2,"262":1,"265":1,"269":1,"270":1,"271":2,"272":2,"276":2,"279":1,"283":2,"284":1,"285":2,"288":1,"291":1,"292":1,"300":4,"301":1,"315":2,"319":1,"320":1,"326":1,"335":1,"340":1,"341":2,"344":1,"351":1,"355":1,"359":3,"361":1,"362":2,"365":1,"366":1,"367":2,"371":1,"378":1,"388":2,"399":1,"402":2,"404":1,"407":2,"424":1,"426":1,"427":4,"429":1,"437":1,"445":1,"451":1,"452":1,"456":4,"457":4,"465":1,"469":1,"470":2,"479":2,"489":1,"514":3,"515":1,"516":1,"522":2,"526":1,"531":1,"536":2,"541":2,"559":2,"560":2,"565":2,"567":1,"569":1,"597":1,"637":1,"644":1,"651":1,"689":2,"690":1,"695":1,"702":1,"708":1,"711":2,"734":1,"737":1,"746":1,"763":2,"765":2,"771":1,"776":1,"793":2,"802":1,"812":2,"816":1,"823":1,"832":2,"845":1,"846":1,"854":1,"858":1,"862":1,"874":1,"878":1,"884":3,"888":1,"891":1,"894":1,"895":1,"902":1,"904":1,"908":1,"911":3,"919":1,"922":2,"933":2,"936":1,"972":1,"984":1,"992":1,"994":1,"1008":1,"1010":1,"1011":1,"1013":1,"1015":1,"1030":1,"1035":1,"1041":1,"1072":1,"1080":1,"1081":1,"1085":1,"1091":1,"1092":1,"1093":1,"1094":3,"1095":1,"1096":2,"1108":2,"1116":1,"1129":1,"1131":2,"1132":2,"1134":2,"1143":1,"1150":1,"1175":1,"1178":4,"1218":1,"1219":1,"1224":1,"1266":1,"1271":1,"1303":1,"1366":1,"1367":1,"1374":1,"1415":1,"1424":1,"1435":1,"1442":1,"1446":1,"1459":1}}],["assomption",{"2":{"1213":1}}],["associated",{"2":{"198":1,"215":1}}],["assert",{"2":{"1459":1}}],["assertions",{"2":{"793":1,"1441":2,"1459":1}}],["assertion",{"0":{"769":1},"2":{"479":1,"617":1,"769":1}}],["asset",{"2":{"666":1}}],["assets",{"2":{"665":1}}],["assess",{"2":{"23":1}}],["assessment",{"2":{"23":1}}],["assumption",{"2":{"1233":1}}],["assumptions",{"0":{"1097":1},"2":{"202":1,"281":1,"1010":1,"1097":1}}],["assuming",{"2":{"908":1,"1229":1}}],["assume",{"2":{"302":1,"464":1,"1019":1}}],["assumes",{"2":{"202":1}}],["assist",{"2":{"634":1}}],["assistant",{"0":{"28":1},"2":{"24":1,"247":1}}],["assistants",{"2":{"24":1,"30":1,"48":1,"247":1}}],["assigning",{"2":{"1450":1}}],["assigns",{"2":{"1329":1}}],["assigned",{"2":{"188":1,"484":1,"1039":2}}],["assignments",{"2":{"191":1,"407":1,"414":1,"734":1,"744":1}}],["assignment",{"0":{"188":1,"189":1},"2":{"185":1}}],["assign",{"2":{"112":1,"188":1,"189":1,"1452":1}}],["acuity",{"2":{"1324":1}}],["achieving",{"2":{"1232":1}}],["achieve",{"2":{"516":1}}],["achieved",{"2":{"407":2,"665":1,"669":1}}],["achieves",{"2":{"215":1,"426":1,"451":1,"464":1,"522":1}}],["acme",{"2":{"1220":1}}],["acquisition",{"2":{"699":1}}],["academic",{"0":{"1308":1},"1":{"1309":1,"1310":1},"2":{"323":2,"509":1,"531":1,"771":1,"773":2,"1097":1,"1274":1,"1301":1}}],["acdt",{"2":{"296":1}}],["acst",{"2":{"296":1}}],["actionable",{"2":{"806":1}}],["actions",{"2":{"607":1,"635":1,"669":1}}],["action",{"0":{"565":1,"569":1},"2":{"548":1,"559":1,"560":1,"561":1,"916":1,"1255":1}}],["activity",{"2":{"891":1}}],["activating",{"0":{"308":1},"1":{"309":1,"310":1,"311":1}}],["activation",{"0":{"250":1,"258":1,"309":1,"847":1},"1":{"848":1,"849":1},"2":{"250":3,"258":1,"286":1,"309":1}}],["activates",{"2":{"869":1}}],["activate",{"2":{"276":1,"555":1,"678":1,"844":1}}],["activated",{"2":{"262":1}}],["activeticker",{"2":{"1256":1}}],["actively",{"2":{"515":1,"922":1,"941":1,"1373":1}}],["active",{"0":{"1426":2},"1":{"1427":2},"2":{"88":1,"117":1,"141":1,"155":3,"186":2,"216":1,"217":1,"295":1,"351":1,"362":2,"369":1,"370":4,"371":1,"463":3,"489":1,"497":1,"691":1,"737":1,"746":1,"786":1,"792":1,"823":1,"864":1,"907":1,"926":1,"936":1,"942":2,"1004":1,"1047":1,"1053":1,"1054":1,"1055":1,"1065":3,"1081":1,"1082":1,"1168":4,"1178":1,"1184":1,"1195":1,"1205":1,"1233":1,"1401":1,"1404":1,"1405":1,"1406":1,"1423":1,"1426":2,"1427":1,"1440":1,"1442":2}}],["acts",{"2":{"298":1,"445":1,"516":1,"1424":1}}],["act",{"2":{"43":1,"138":1,"344":1,"1076":1,"1213":1}}],["actually",{"2":{"109":1,"228":1,"264":1,"451":1,"738":1,"970":1,"1012":1}}],["actual",{"0":{"32":1},"2":{"409":1,"456":1,"1046":1,"1091":1}}],["across",{"2":{"34":1,"98":1,"102":1,"110":1,"116":1,"119":1,"152":1,"209":1,"291":1,"310":1,"321":2,"326":1,"365":1,"367":2,"387":1,"402":2,"409":1,"440":1,"472":1,"479":1,"562":1,"616":1,"644":1,"651":1,"653":1,"663":2,"666":1,"667":1,"669":1,"672":1,"679":1,"681":1,"697":1,"702":1,"709":1,"712":1,"719":1,"720":1,"754":1,"755":1,"760":1,"763":1,"792":1,"830":2,"842":1,"867":2,"920":1,"922":1,"934":1,"938":1,"939":1,"941":1,"947":1,"948":1,"949":1,"950":2,"969":1,"972":1,"994":1,"1018":1,"1021":1,"1026":1,"1030":1,"1032":2,"1033":1,"1037":2,"1039":1,"1042":1,"1045":1,"1054":2,"1059":1,"1067":1,"1068":1,"1069":1,"1084":1,"1088":1,"1090":1,"1093":2,"1105":1,"1109":1,"1114":1,"1122":1,"1123":1,"1125":1,"1140":1,"1146":1,"1149":1,"1161":1,"1178":1,"1189":2,"1213":1,"1258":1,"1265":1,"1315":1,"1322":1,"1338":1,"1362":1,"1369":1,"1376":1,"1385":1,"1391":1,"1392":1,"1412":1,"1422":1,"1436":1,"1447":1,"1450":1}}],["accounting",{"0":{"1223":1},"2":{"879":1,"1069":1,"1210":1}}],["account",{"2":{"857":1,"947":1,"1203":1,"1207":1}}],["according",{"2":{"370":2,"863":1,"1195":1}}],["accusative",{"2":{"1270":1,"1276":1}}],["accumulated",{"2":{"1086":1}}],["accumulates",{"2":{"948":1}}],["accumulate",{"2":{"667":1}}],["accuracy",{"2":{"365":1,"738":1,"954":1,"1045":1,"1232":1}}],["accurately",{"2":{"223":1,"402":1,"633":1,"802":1,"1220":1}}],["accurate",{"2":{"24":1,"156":1,"364":1,"446":1,"447":1,"654":1,"655":1,"708":1,"942":1,"1063":1,"1134":1,"1367":1,"1377":1}}],["accelerates",{"2":{"1026":1,"1037":1}}],["acceleration",{"2":{"699":1}}],["accents",{"2":{"220":1}}],["accent",{"0":{"220":1},"2":{"220":1,"363":1}}],["accessors",{"0":{"487":1},"2":{"843":1}}],["accessor",{"2":{"458":1,"776":1,"819":1,"843":1}}],["accessed",{"2":{"266":1,"300":1,"412":1,"425":1,"429":2,"699":1}}],["accesses",{"2":{"264":1}}],["accessing",{"0":{"295":1},"2":{"148":1,"446":1,"1047":1,"1106":1}}],["accessible",{"2":{"7":1,"92":1,"227":1,"556":1,"711":1,"716":1,"771":1,"776":1,"919":1,"1005":1}}],["access",{"0":{"435":1},"2":{"87":1,"89":1,"121":1,"124":1,"147":2,"148":3,"149":2,"168":1,"172":1,"224":4,"227":1,"233":1,"265":1,"268":2,"271":1,"276":1,"295":1,"300":1,"326":2,"327":1,"367":1,"407":1,"409":2,"412":2,"424":2,"427":2,"429":2,"435":2,"439":1,"444":1,"452":1,"458":1,"475":1,"477":2,"479":1,"481":1,"482":1,"584":1,"667":1,"707":1,"714":1,"763":1,"786":1,"787":1,"817":1,"818":1,"836":1,"998":1,"1039":2,"1042":1,"1045":1,"1054":1,"1273":1,"1281":1,"1392":1}}],["accepted",{"2":{"565":1,"767":1}}],["accepts",{"2":{"117":1,"125":1,"214":1,"447":1,"517":1,"571":1,"639":1,"750":1,"903":1,"962":1,"991":1,"1023":1,"1319":1,"1416":1}}],["accept",{"2":{"69":1,"235":1,"502":1,"536":1,"571":1,"738":1,"774":1,"807":1,"831":1,"933":1,"1004":1}}],["accidentally",{"2":{"278":1,"431":1,"439":1,"504":1}}],["accidental",{"2":{"43":1,"298":1,"418":1,"431":1,"466":1,"644":1,"763":1,"864":1,"1088":1,"1111":1,"1450":1}}],["acknowledged",{"2":{"1219":1}}],["acknowledge",{"2":{"23":1}}],["acknowledgement",{"2":{"23":1}}],["aucyear",{"2":{"1310":1}}],["auctoyear",{"0":{"1295":1},"2":{"1304":1}}],["auctionend",{"2":{"1261":3}}],["auctions",{"2":{"1242":1,"1259":1}}],["auc`",{"2":{"1280":1,"1307":1}}],["auc=754−ybce",{"2":{"1272":1}}],["auc=y+753",{"2":{"1272":2}}],["auc",{"0":{"1272":1,"1286":1,"1295":1},"2":{"1272":5,"1275":1,"1276":2,"1278":1,"1280":5,"1285":1,"1286":1,"1289":1,"1290":1,"1294":1,"1295":1,"1299":1,"1304":3,"1306":2,"1307":1,"1310":1}}],["auckland",{"2":{"296":1,"334":1}}],["audioworklettimesync",{"2":{"1395":1}}],["audio",{"0":{"1393":1},"1":{"1394":1,"1395":1},"2":{"1367":1,"1383":1,"1394":4,"1395":3}}],["audience",{"2":{"594":1}}],["audittime",{"2":{"1389":2}}],["auditandmigrateformatmask",{"2":{"1147":2}}],["auditing",{"0":{"355":1},"2":{"533":1,"950":1}}],["audit",{"0":{"1142":1},"1":{"1143":1,"1144":1},"2":{"271":3,"402":1,"532":1,"912":1,"1114":1,"1122":1,"1144":1,"1389":1}}],["augustus",{"2":{"1307":2}}],["augusto",{"2":{"1281":2}}],["august",{"2":{"213":1,"689":1,"896":1,"1213":1}}],["aug",{"2":{"213":1,"214":2,"689":1,"1220":1,"1269":1}}],["augment",{"2":{"218":1,"234":1,"326":1,"1449":1,"1452":1}}],["augmentations",{"2":{"724":1}}],["augmentation",{"0":{"234":1,"267":1,"544":1},"1":{"545":1},"2":{"117":1,"234":1,"261":2,"276":1,"326":2,"724":1}}],["augmenting",{"2":{"96":1,"754":1}}],["australie",{"2":{"145":2}}],["australian",{"2":{"138":1,"268":1,"1188":1,"1214":1}}],["australia",{"2":{"52":1,"73":1,"102":1,"105":1,"110":1,"116":1,"121":1,"137":1,"138":1,"142":2,"149":1,"154":1,"197":2,"215":1,"226":1,"296":3,"687":1,"870":2,"903":1,"927":1,"962":1,"1097":1,"1190":2,"1203":3,"1207":1,"1209":2,"1213":2,"1223":1,"1429":1,"1430":1}}],["au",{"2":{"15":1,"21":1,"26":1,"27":2,"28":1,"31":1,"116":1,"142":2,"144":3,"154":1,"215":2,"247":2,"285":2,"534":1,"687":1,"692":1,"786":1,"856":2,"870":1,"881":1,"885":2,"890":1,"899":1,"927":1,"962":1,"1160":1,"1172":2,"1190":3,"1203":2,"1209":3,"1213":1,"1214":4,"1220":1,"1223":1}}],["authclient",{"2":{"1004":1}}],["auth",{"2":{"869":1,"995":1}}],["authheader",{"2":{"860":2,"955":3}}],["authentication",{"2":{"924":1,"953":1,"955":1,"1242":1,"1266":1,"1361":1}}],["authenticates",{"2":{"1363":1}}],["authenticate",{"2":{"860":1,"955":1}}],["authentic",{"0":{"817":1},"2":{"817":1}}],["authors",{"2":{"716":1}}],["authored",{"2":{"687":1}}],["authorized",{"2":{"955":1}}],["authorization",{"2":{"854":1,"860":2,"955":3,"1003":1}}],["authoritative",{"0":{"1390":1},"1":{"1391":1,"1392":1},"2":{"365":1,"667":1,"1377":1,"1383":1}}],["authoring",{"0":{"851":1},"2":{"230":1,"233":1,"273":1,"276":2,"559":1,"687":1,"728":1}}],["author",{"0":{"1452":1},"2":{"232":1,"275":1,"301":1}}],["autocompletion",{"2":{"774":1}}],["autocomplete",{"2":{"107":1,"267":1,"269":1,"326":3,"687":1,"724":1,"867":1,"949":1}}],["automations",{"2":{"1395":1}}],["automation",{"2":{"1082":1}}],["automatic",{"0":{"139":1,"486":1,"495":1,"554":1,"997":1,"1158":1,"1182":1},"1":{"1159":1},"2":{"93":1,"102":1,"124":1,"138":1,"227":1,"276":1,"456":1,"476":1,"596":1,"649":1,"678":1,"775":1,"792":1,"812":1,"865":1,"869":1,"972":1,"1004":1,"1010":1,"1046":1,"1098":1,"1166":1,"1169":1,"1207":1,"1239":1,"1404":1,"1440":2,"1444":1}}],["automatically",{"2":{"41":1,"43":2,"75":1,"78":1,"93":1,"94":2,"103":1,"105":1,"110":1,"119":1,"121":2,"138":1,"139":1,"146":2,"166":1,"169":1,"174":1,"200":1,"208":1,"219":1,"220":2,"227":1,"230":1,"231":1,"232":1,"233":1,"256":1,"262":1,"269":1,"276":2,"279":1,"282":2,"296":1,"312":1,"315":1,"319":1,"326":1,"334":3,"335":1,"363":1,"364":1,"370":1,"373":1,"404":1,"416":1,"421":1,"475":1,"486":2,"491":1,"494":1,"495":1,"513":1,"538":1,"543":2,"649":1,"690":1,"707":1,"729":1,"746":1,"754":1,"766":1,"792":1,"812":1,"817":1,"824":1,"831":1,"839":1,"853":1,"854":1,"856":1,"866":1,"868":1,"869":1,"871":1,"884":1,"885":1,"888":1,"906":1,"907":1,"926":1,"930":1,"936":1,"942":1,"945":1,"947":1,"957":2,"958":2,"966":1,"972":1,"996":2,"1019":1,"1038":1,"1041":1,"1054":1,"1067":1,"1070":1,"1082":1,"1095":1,"1110":1,"1134":1,"1147":1,"1182":2,"1184":1,"1189":1,"1205":1,"1207":2,"1214":1,"1219":1,"1232":1,"1256":1,"1338":1,"1372":1,"1373":1,"1408":1,"1421":2,"1422":1,"1433":2,"1434":1,"1438":1,"1445":3,"1447":1}}],["automate",{"2":{"280":1}}],["automated",{"0":{"798":1,"1003":1,"1004":1,"1113":1,"1222":1},"1":{"1114":1},"2":{"191":1,"422":1,"716":1,"795":1,"861":1,"864":1,"933":2,"987":1,"997":1,"1008":1,"1011":2,"1099":1,"1105":1,"1122":1,"1147":3,"1222":1,"1362":1,"1387":1,"1453":1}}],["autoformat",{"2":{"159":3}}],["auto",{"0":{"917":1,"925":1,"957":1,"1020":1,"1056":1,"1102":1,"1154":1,"1165":1,"1241":1,"1317":1,"1342":1,"1380":1,"1400":1},"1":{"926":1,"927":1},"2":{"11":1,"83":1,"117":3,"124":1,"132":1,"139":5,"159":1,"191":1,"221":1,"250":1,"332":2,"361":1,"416":1,"421":1,"448":1,"450":1,"469":1,"520":1,"631":2,"707":2,"716":1,"741":1,"754":1,"798":1,"810":1,"836":1,"853":1,"855":1,"870":2,"915":1,"925":2,"1046":1,"1054":1,"1067":1,"1104":5,"1113":1,"1116":1,"1278":2,"1281":1,"1313":1}}],["autumnal",{"2":{"1046":2,"1049":1,"1213":1}}],["autumn",{"2":{"9":1,"313":2,"326":2,"455":2,"456":2,"519":1,"1046":2,"1310":1}}],["aiproxy",{"2":{"931":1,"955":1}}],["aiprovider>",{"2":{"938":2}}],["aiprovider",{"2":{"871":1,"937":2,"938":3,"959":1}}],["aiplugin",{"2":{"915":1,"916":3}}],["aiformatoptions",{"0":{"899":1}}],["aiextractoptions",{"0":{"890":1}}],["aidiffoptions",{"0":{"881":1}}],["aicache",{"2":{"976":3,"1009":1}}],["aicacheadapter",{"0":{"978":1},"2":{"871":1,"881":1,"890":1,"895":1,"899":1,"904":1,"937":1,"938":1,"978":3,"1008":1,"1009":1}}],["aiconfig",{"2":{"938":1}}],["aicontextoptions",{"0":{"871":1}}],["air",{"0":{"1017":1},"2":{"856":2,"1365":1}}],["aimode",{"0":{"867":1,"939":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"1":{"868":1,"940":1,"941":1,"942":1,"943":1,"944":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1},"2":{"696":6,"867":8,"871":2,"881":1,"890":1,"899":1,"937":1,"939":3,"945":1,"946":1,"947":1,"948":1,"949":1,"950":2,"958":2,"959":1,"989":1}}],["aim",{"2":{"23":1}}],["ai",{"0":{"24":1,"28":1,"30":1,"48":1,"89":1,"98":2,"204":1,"247":1,"692":1,"696":1,"701":1,"913":1,"916":1,"919":1,"951":1,"965":1,"968":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":2,"32":2,"99":2,"914":1,"915":1,"916":1,"917":2,"918":1,"919":1,"920":2,"921":1,"922":1,"923":1,"952":1,"953":1,"954":1,"955":1,"956":1,"957":1,"958":1,"959":1},"2":{"12":2,"14":1,"24":2,"27":1,"30":1,"48":2,"89":6,"93":4,"98":3,"102":1,"204":2,"247":3,"274":1,"291":2,"692":2,"694":1,"696":1,"701":2,"702":1,"812":1,"852":1,"853":2,"856":2,"858":2,"859":4,"861":1,"864":2,"866":1,"867":1,"870":2,"878":1,"880":2,"889":2,"898":2,"906":1,"909":1,"910":1,"912":3,"914":1,"915":4,"916":6,"917":2,"918":1,"919":13,"920":3,"922":3,"924":1,"925":2,"926":1,"927":2,"929":1,"930":1,"931":3,"932":2,"933":2,"934":1,"936":3,"937":2,"938":3,"939":2,"941":1,"950":3,"951":1,"953":1,"954":2,"955":4,"957":1,"958":3,"959":1,"961":3,"962":1,"965":1,"966":1,"968":7,"969":1,"970":1,"971":1,"972":2,"973":1,"976":2,"978":8,"982":1,"988":2,"992":2,"993":1,"994":1,"995":1,"997":2,"998":4,"1004":2,"1005":1,"1007":1,"1010":1,"1012":1,"1013":3,"1014":3,"1015":3,"1016":3,"1017":3}}],["alaska",{"2":{"1338":1}}],["alarm",{"2":{"894":1}}],["alsace",{"2":{"1213":1}}],["also",{"0":{"1274":1,"1314":1},"2":{"62":1,"134":1,"155":1,"164":1,"166":1,"183":1,"190":1,"191":1,"220":1,"305":1,"397":1,"491":1,"499":1,"816":1,"889":1,"946":1,"992":1,"1179":1,"1180":1,"1272":1,"1313":1}}],["alerts",{"0":{"1421":1},"2":{"1218":1,"1401":1}}],["alert",{"2":{"588":1,"1348":3,"1421":3}}],["alone",{"2":{"516":1,"897":1,"1095":1,"1157":1}}],["alongside",{"2":{"138":1,"214":1,"261":1,"513":1,"548":1,"817":1,"987":1,"1053":1,"1095":1,"1113":1,"1255":1,"1262":1,"1306":1}}],["along",{"2":{"87":1,"128":1,"907":1,"1039":1,"1075":1,"1344":1,"1358":1,"1359":1}}],["algorithm",{"0":{"1226":1,"1227":1},"1":{"1227":1,"1228":2,"1229":2,"1230":2,"1231":2,"1232":1,"1233":1,"1234":1,"1235":1},"2":{"1226":1,"1236":1,"1242":1}}],["algorithmically",{"2":{"423":1}}],["algorithmic",{"2":{"419":1,"1212":1,"1387":1}}],["algorithms",{"2":{"85":1,"174":1,"1032":1,"1045":1,"1225":1,"1242":1,"1266":1}}],["alpine",{"2":{"365":1}}],["alphacoords",{"2":{"1186":1}}],["alphabetical",{"2":{"191":1}}],["alphabetically",{"2":{"191":1}}],["alpha",{"2":{"127":1,"496":1,"1186":6,"1240":1,"1263":1}}],["already",{"2":{"176":1,"198":1,"233":1,"326":1,"385":1,"457":1,"481":1,"657":1,"739":1,"1089":1,"1222":1}}],["alter",{"2":{"1098":1,"1263":1}}],["alternatives",{"2":{"919":1,"992":1}}],["alternative",{"0":{"283":1},"2":{"992":1}}],["alternatively",{"2":{"21":1,"853":1}}],["altering",{"2":{"273":1,"403":1}}],["altitude",{"2":{"142":1,"1052":1,"1053":1,"1054":1,"1058":1,"1061":1,"1062":3,"1068":1,"1071":6,"1081":10,"1084":2,"1353":1}}],["almost",{"2":{"46":1,"524":1}}],["always",{"2":{"27":1,"47":1,"137":2,"174":1,"186":1,"204":1,"216":1,"222":1,"279":1,"326":3,"367":1,"368":1,"369":4,"370":1,"389":1,"402":1,"554":1,"567":1,"617":1,"734":1,"739":1,"932":1,"985":1,"1054":2,"1067":1,"1159":1,"1185":1,"1188":1,"1266":1,"1269":1,"1442":1,"1451":1,"1459":1}}],["alive",{"2":{"1371":1,"1408":1,"1442":1}}],["alice",{"2":{"998":2}}],["alicefreetime",{"2":{"179":2}}],["aligntovideoframe",{"2":{"1332":2}}],["aligning",{"2":{"719":1,"1315":1,"1366":1}}],["aligns",{"2":{"381":1,"1055":1,"1069":1,"1332":1}}],["alignmentdeg",{"2":{"1054":1,"1055":1,"1076":1}}],["alignment",{"0":{"1330":1},"1":{"1331":1,"1332":1},"2":{"381":1,"708":1,"709":1,"972":1,"1052":1,"1053":1,"1055":1,"1074":1,"1083":1,"1098":1,"1322":1,"1325":1,"1343":2,"1362":1}}],["alignments",{"0":{"152":1}}],["align",{"2":{"224":1,"572":1,"817":1,"1097":1,"1190":1,"1255":1,"1331":1}}],["aligned",{"0":{"1255":1},"2":{"24":1,"1271":1,"1326":1,"1332":3}}],["aliasing",{"2":{"461":1}}],["aliasresult",{"2":{"418":1,"625":1}}],["aliasengine",{"2":{"417":1,"625":1}}],["aliases",{"0":{"223":1},"2":{"12":1,"96":1,"102":1,"115":1,"117":1,"123":2,"134":1,"137":1,"138":3,"198":1,"221":1,"296":2,"297":3,"315":2,"328":1,"329":1,"338":2,"341":2,"357":1,"418":3,"439":1,"456":1,"516":1,"525":1,"565":1,"617":1,"625":1,"631":1,"634":2,"639":3,"735":1,"1103":1,"1319":1}}],["aliascontext",{"2":{"224":1}}],["alias",{"0":{"96":1,"224":1,"225":1,"315":1,"417":1,"625":1},"1":{"97":1,"225":1,"418":1,"419":1},"2":{"72":1,"97":1,"117":1,"133":1,"138":3,"150":1,"188":1,"189":2,"224":3,"228":1,"240":2,"241":2,"296":1,"315":1,"326":2,"333":1,"383":2,"388":1,"416":1,"417":1,"418":1,"469":1,"546":2,"565":1,"616":1,"617":1,"625":3,"626":2,"631":1,"697":1,"735":2,"739":1,"748":2,"802":1,"1090":1,"1104":1}}],["allerheiligen",{"2":{"1213":1}}],["allkeys",{"2":{"463":1}}],["allocating",{"2":{"1368":1,"1369":1}}],["allocations",{"2":{"1395":1}}],["allocation",{"2":{"427":1,"449":1,"531":1,"1042":1}}],["allocates",{"2":{"1039":1}}],["allocate",{"2":{"1022":1}}],["allowlisting",{"2":{"1024":1}}],["allowlists",{"2":{"1001":1}}],["allowlist",{"2":{"856":2,"1041":2}}],["allowed",{"2":{"734":1,"1000":1,"1041":2,"1240":1}}],["allow",{"2":{"148":1,"389":1,"406":1,"427":1,"447":1,"456":1,"504":1,"606":1,"654":1,"972":1,"1004":1,"1263":1}}],["allowing",{"2":{"100":1,"181":1,"249":1,"292":1,"328":1,"363":1,"390":1,"440":1,"509":1,"606":1,"675":1,"676":1,"691":1,"754":1,"886":1,"933":1,"942":1,"985":1,"1093":1,"1215":1,"1377":1,"1435":2,"1448":1}}],["allows",{"2":{"63":1,"124":1,"125":1,"131":1,"222":1,"228":1,"230":1,"263":1,"266":1,"282":1,"316":1,"326":1,"359":1,"374":1,"375":1,"378":1,"434":1,"438":1,"456":1,"468":1,"469":1,"471":1,"476":1,"502":1,"525":1,"562":1,"682":1,"716":1,"731":1,"845":1,"972":1,"973":1,"1095":1,"1097":1,"1176":1}}],["all",{"0":{"429":1,"1088":1,"1456":1},"2":{"6":2,"27":1,"38":1,"43":1,"45":1,"56":1,"76":1,"93":1,"107":1,"116":1,"119":1,"120":1,"139":1,"144":1,"155":2,"165":1,"166":1,"170":1,"181":1,"192":1,"198":1,"209":1,"227":1,"251":1,"258":1,"270":1,"276":1,"290":1,"292":1,"297":1,"300":1,"301":1,"307":1,"308":1,"309":1,"310":1,"321":1,"325":1,"326":1,"331":3,"344":1,"346":1,"351":1,"353":1,"354":1,"365":2,"367":2,"402":2,"404":1,"406":1,"412":1,"416":1,"417":1,"418":1,"422":1,"424":1,"425":1,"429":1,"431":1,"433":1,"437":1,"440":2,"454":2,"458":3,"461":1,"465":1,"472":1,"479":1,"485":1,"489":2,"492":1,"503":1,"506":1,"537":1,"544":1,"554":1,"556":1,"606":1,"625":2,"629":2,"637":1,"649":1,"651":1,"655":1,"669":1,"678":1,"679":1,"712":1,"722":2,"728":1,"737":1,"738":2,"741":1,"757":1,"769":1,"771":1,"776":1,"792":1,"836":1,"845":1,"855":1,"859":1,"862":1,"864":3,"865":1,"888":1,"889":1,"916":1,"919":1,"931":1,"934":3,"941":1,"942":2,"946":2,"949":2,"950":2,"955":1,"959":1,"963":2,"970":1,"973":1,"976":1,"992":1,"993":1,"996":1,"997":2,"998":1,"1000":1,"1003":1,"1010":1,"1054":1,"1067":1,"1088":1,"1090":1,"1091":1,"1093":1,"1098":1,"1105":1,"1112":1,"1124":1,"1147":2,"1191":1,"1213":1,"1216":1,"1225":1,"1240":1,"1255":1,"1269":3,"1270":1,"1273":1,"1281":2,"1296":1,"1297":1,"1369":1,"1372":1,"1376":1,"1392":2,"1406":1,"1426":2,"1428":1,"1448":1,"1450":1}}],["ambient",{"0":{"1184":1},"2":{"812":1,"1166":1,"1168":3,"1184":1,"1185":2,"1188":2}}],["ambiguity",{"0":{"362":1,"911":1},"2":{"58":1,"139":1,"161":1,"216":2,"361":1,"362":1,"375":1,"743":1,"910":1,"911":1,"1111":1}}],["ambiguous",{"0":{"58":1,"216":1,"1013":1},"2":{"58":1,"198":1,"212":1,"361":1,"362":2,"757":1,"869":1,"872":1,"875":1,"906":1,"909":1,"912":1,"950":2,"951":1,"965":1}}],["amazing",{"2":{"229":1}}],["amounts",{"2":{"972":1}}],["amount",{"0":{"1199":1},"2":{"167":1,"182":1,"183":1}}],["am",{"2":{"137":1,"139":1,"167":1,"191":1,"245":1,"889":2,"1094":1,"1103":1,"1104":1,"1113":1,"1125":1,"1139":1,"1141":1,"1203":2,"1204":1,"1447":3}}],["amplitude",{"2":{"1083":1}}],["ample",{"2":{"948":1}}],["amp",{"0":{"15":1,"16":1,"24":1,"27":1,"29":1,"35":1,"41":1,"48":1,"76":1,"78":1,"83":1,"88":1,"89":1,"90":1,"94":1,"95":1,"109":1,"119":1,"121":1,"126":1,"141":1,"143":1,"144":1,"152":1,"154":1,"173":1,"174":1,"181":1,"186":1,"187":1,"189":1,"203":1,"205":1,"206":1,"212":1,"213":1,"220":1,"223":1,"226":1,"227":1,"247":1,"281":1,"287":1,"321":1,"327":1,"332":1,"336":1,"337":1,"340":1,"342":1,"361":1,"365":1,"366":1,"405":1,"408":1,"419":1,"420":1,"476":1,"494":1,"513":1,"526":1,"532":1,"533":1,"536":1,"543":1,"546":1,"557":1,"616":1,"617":1,"626":1,"631":1,"634":1,"635":1,"643":1,"644":1,"645":1,"648":1,"649":1,"655":1,"661":1,"666":1,"667":1,"669":1,"671":1,"672":1,"689":1,"690":1,"691":1,"692":1,"696":1,"699":1,"702":1,"709":1,"729":1,"747":1,"751":1,"763":1,"764":1,"765":1,"766":1,"768":1,"769":1,"771":1,"772":1,"774":1,"775":1,"776":1,"778":1,"780":1,"781":1,"784":1,"785":1,"786":1,"788":1,"790":1,"791":1,"795":1,"796":1,"798":1,"800":1,"801":1,"804":1,"805":1,"806":1,"807":1,"810":1,"811":1,"814":1,"815":1,"816":1,"817":1,"819":1,"821":1,"822":1,"823":1,"824":1,"827":1,"828":1,"829":1,"831":1,"835":1,"837":1,"838":1,"839":1,"842":1,"843":1,"847":1,"850":1,"852":1,"853":1,"854":1,"855":1,"856":1,"858":1,"861":1,"863":1,"864":1,"865":1,"866":1,"869":1,"879":1,"886":1,"888":1,"893":1,"897":1,"903":1,"906":1,"907":1,"908":1,"909":1,"912":1,"914":1,"921":1,"922":1,"924":1,"933":1,"934":1,"935":1,"936":1,"941":1,"944":1,"951":1,"956":1,"962":1,"966":1,"972":1,"975":1,"978":1,"981":1,"987":1,"994":1,"995":1,"996":1,"999":1,"1002":1,"1004":1,"1006":1,"1008":1,"1010":1,"1011":1,"1012":1,"1017":1,"1019":1,"1024":1,"1026":1,"1031":1,"1037":1,"1041":1,"1044":1,"1045":1,"1046":1,"1054":1,"1058":1,"1061":1,"1063":1,"1064":1,"1065":2,"1066":1,"1071":1,"1072":1,"1074":1,"1077":1,"1078":1,"1080":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1086":1,"1092":1,"1100":1,"1105":1,"1106":1,"1108":1,"1109":1,"1119":1,"1123":1,"1127":1,"1128":1,"1129":1,"1137":1,"1142":1,"1148":1,"1164":1,"1173":1,"1176":1,"1181":1,"1182":1,"1183":1,"1184":1,"1189":1,"1192":1,"1194":1,"1212":1,"1214":1,"1215":1,"1218":1,"1221":1,"1222":1,"1223":1,"1224":1,"1226":1,"1233":1,"1238":1,"1253":1,"1256":1,"1258":1,"1259":1,"1262":1,"1263":1,"1265":1,"1267":1,"1268":1,"1277":1,"1301":1,"1302":1,"1305":1,"1308":1,"1311":1,"1316":1,"1320":1,"1322":1,"1333":1,"1341":1,"1347":1,"1354":1,"1360":1,"1362":1,"1364":1,"1365":1,"1367":1,"1378":1,"1383":1,"1385":1,"1398":1,"1411":1,"1419":1,"1421":1,"1422":1,"1423":1,"1426":1,"1431":1,"1432":1,"1440":1,"1441":1,"1443":1,"1444":1,"1447":1,"1448":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1,"36":1,"37":1,"38":1,"42":1,"43":1,"44":1,"84":1,"85":1,"86":1,"87":1,"88":1,"89":1,"90":1,"91":1,"120":1,"127":1,"128":1,"142":1,"143":1,"144":1,"145":1,"182":1,"183":1,"184":1,"185":1,"186":1,"187":1,"188":2,"189":2,"190":2,"191":1,"192":1,"193":1,"194":1,"195":1,"204":1,"207":1,"208":1,"209":1,"213":1,"214":2,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1,"227":1,"333":1,"334":1,"335":1,"338":1,"339":1,"343":1,"344":1,"345":1,"346":1,"347":1,"348":1,"349":1,"350":1,"351":1,"352":1,"353":1,"354":1,"355":1,"356":1,"357":1,"358":1,"359":1,"360":1,"362":1,"363":1,"364":1,"365":1,"366":1,"367":2,"368":2,"369":2,"370":2,"371":1,"372":1,"373":1,"409":1,"410":1,"421":1,"422":1,"495":1,"558":1,"559":1,"765":1,"766":1,"767":1,"768":1,"769":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"782":1,"786":1,"787":1,"788":1,"792":1,"793":1,"797":1,"798":1,"802":1,"806":1,"807":1,"808":1,"812":1,"816":1,"817":1,"818":1,"819":1,"823":1,"824":1,"825":1,"829":1,"830":1,"831":1,"832":1,"838":1,"839":1,"840":1,"841":1,"842":1,"848":1,"849":1,"853":1,"854":2,"855":2,"856":2,"857":2,"858":1,"859":2,"860":2,"861":1,"862":2,"863":2,"864":2,"865":2,"866":2,"867":1,"868":1,"870":1,"871":1,"872":1,"873":1,"874":1,"875":1,"876":1,"877":1,"878":1,"880":1,"881":1,"882":1,"883":1,"884":1,"885":1,"886":1,"887":1,"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1,"898":1,"899":1,"900":1,"901":1,"902":1,"903":1,"904":1,"905":1,"907":1,"908":2,"909":2,"910":1,"911":1,"912":1,"925":1,"926":1,"927":1,"928":1,"929":1,"930":1,"931":1,"932":1,"933":1,"934":1,"935":1,"936":1,"937":1,"938":1,"942":1,"945":1,"946":1,"947":1,"948":1,"949":1,"950":1,"952":1,"953":1,"954":1,"955":1,"956":1,"957":2,"958":2,"959":1,"967":1,"968":1,"969":1,"970":1,"971":1,"972":1,"973":1,"974":1,"975":1,"976":1,"977":1,"978":1,"979":1,"980":1,"982":1,"983":1,"984":1,"985":1,"986":1,"988":1,"989":1,"990":1,"991":1,"992":1,"993":1,"995":1,"996":2,"997":2,"998":1,"999":1,"1000":2,"1001":2,"1002":1,"1003":2,"1004":2,"1005":2,"1006":1,"1007":2,"1008":2,"1009":2,"1010":1,"1011":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1020":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":2,"1033":2,"1034":1,"1035":1,"1036":1,"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1,"1045":1,"1046":1,"1047":1,"1048":1,"1049":1,"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1,"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1,"1075":1,"1076":1,"1077":1,"1078":1,"1079":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1087":1,"1088":1,"1089":1,"1090":1,"1091":1,"1092":1,"1093":2,"1094":2,"1095":2,"1096":2,"1097":2,"1098":1,"1101":1,"1102":1,"1109":1,"1110":2,"1111":2,"1112":2,"1113":1,"1114":1,"1115":1,"1116":1,"1117":1,"1118":1,"1119":1,"1120":1,"1121":1,"1122":1,"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":1,"1135":1,"1136":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":2,"1144":2,"1145":1,"1146":1,"1147":1,"1148":1,"1149":2,"1150":2,"1165":1,"1184":1,"1185":1,"1186":1,"1187":1,"1188":1,"1190":1,"1191":1,"1192":1,"1193":1,"1195":1,"1196":1,"1197":1,"1198":1,"1199":1,"1200":1,"1201":1,"1202":1,"1203":1,"1204":1,"1205":1,"1213":1,"1214":1,"1215":1,"1216":2,"1217":2,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1227":1,"1228":1,"1229":1,"1230":1,"1231":1,"1232":1,"1233":1,"1234":1,"1235":1,"1239":1,"1240":1,"1241":1,"1254":1,"1255":1,"1256":1,"1257":1,"1259":1,"1260":2,"1261":2,"1262":1,"1263":2,"1264":2,"1265":1,"1266":1,"1267":1,"1269":1,"1270":1,"1271":1,"1272":1,"1273":1,"1274":1,"1278":1,"1302":1,"1303":2,"1304":2,"1305":1,"1306":2,"1307":2,"1308":1,"1309":2,"1310":2,"1311":1,"1312":2,"1313":2,"1314":1,"1317":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1334":1,"1335":1,"1336":1,"1337":1,"1338":1,"1342":1,"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1,"1363":1,"1364":1,"1365":1,"1366":1,"1368":1,"1369":1,"1370":1,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1,"1379":1,"1380":1,"1381":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1399":1,"1400":1,"1412":1,"1413":1,"1414":1,"1415":1,"1416":1,"1417":1,"1418":1,"1419":1,"1420":1,"1421":1,"1422":1,"1424":1,"1425":1,"1426":1,"1427":2,"1428":1,"1429":1,"1430":1,"1432":1,"1433":2,"1434":2,"1435":1,"1436":1,"1437":1,"1438":1,"1439":1,"1440":1,"1441":2,"1442":2,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"10":1,"11":1,"12":3,"14":2,"15":2,"23":1,"48":1,"71":1,"76":1,"83":1,"89":2,"102":1,"109":2,"137":1,"138":5,"152":1,"204":1,"205":1,"213":1,"287":1,"326":1,"361":1,"365":2,"367":1,"373":2,"388":1,"410":1,"504":1,"507":1,"510":1,"535":1,"651":1,"692":1,"701":1,"704":1,"751":1,"763":3,"771":4,"775":1,"776":1,"780":1,"784":1,"804":2,"814":1,"821":1,"827":1,"829":1,"832":1,"856":3,"861":1,"867":4,"869":1,"910":1,"919":5,"920":1,"921":7,"922":2,"936":2,"942":1,"953":1,"954":2,"958":1,"997":1,"998":1,"1004":1,"1008":3,"1024":2,"1052":4,"1053":1,"1054":1,"1098":1,"1105":4,"1110":1,"1125":1,"1166":3,"1167":1,"1210":3,"1213":1,"1222":1,"1242":3,"1274":1,"1299":2,"1314":1,"1318":1,"1320":1,"1343":2,"1353":3,"1362":2,"1383":2,"1401":4,"1443":2}}],["american",{"2":{"375":1,"1190":1}}],["america",{"2":{"6":1,"9":1,"58":1,"68":1,"73":1,"110":2,"119":2,"214":1,"215":1,"218":2,"296":5,"366":1,"448":1,"690":1,"872":1,"889":1,"898":2,"907":1,"988":1,"1054":1,"1055":1,"1067":2,"1254":1,"1429":1,"1430":1,"1447":1}}],["adjacent",{"2":{"767":1}}],["adjustment",{"2":{"1222":1}}],["adjustments",{"2":{"296":1,"1053":1,"1066":1,"1396":1}}],["adjusting",{"2":{"1190":1}}],["adjusts",{"2":{"878":1,"1060":1,"1070":1,"1254":1}}],["adjust",{"2":{"296":1,"885":1,"1258":1}}],["adopts",{"2":{"1158":1}}],["adopt",{"2":{"1086":1,"1092":1,"1094":1}}],["adopted",{"2":{"653":1}}],["adoption",{"2":{"514":1}}],["administrative",{"2":{"714":1}}],["admin",{"2":{"464":10,"714":2}}],["adelaide",{"2":{"296":1}}],["adaptation",{"2":{"1158":1}}],["adapting",{"2":{"1158":1,"1189":1}}],["adaptive",{"0":{"948":1},"2":{"696":1,"817":1,"867":2,"871":1,"881":1,"890":1,"899":1,"921":1,"934":2,"937":1,"938":2,"939":1,"940":1,"948":1,"959":1,"963":1,"989":1}}],["adapter",{"2":{"866":1,"937":1,"938":1,"978":2,"980":3,"1008":1}}],["adapters",{"0":{"978":1},"2":{"863":1,"871":1,"881":1,"890":1,"899":1,"937":1,"938":1,"1011":1}}],["adapt",{"2":{"186":1,"368":1,"451":1}}],["adapts",{"2":{"138":3,"370":1,"1158":1}}],["adhere",{"2":{"137":1,"326":1,"1143":1}}],["ad",{"2":{"129":1,"137":2,"150":1,"202":1,"556":1,"707":1}}],["adverb",{"2":{"1270":1}}],["advancing",{"2":{"1419":1}}],["advance",{"2":{"1209":1,"1436":1}}],["advances",{"2":{"986":1,"1224":1,"1405":1}}],["advanced",{"0":{"46":1,"122":1,"245":1,"271":1,"480":1,"483":1,"788":1,"854":1},"1":{"123":1,"124":1,"125":1,"126":1,"127":1,"128":1,"272":1,"481":1,"482":1,"483":1,"484":1,"485":1,"486":1,"487":1},"2":{"1":1,"10":1,"11":1,"13":1,"64":1,"199":1,"233":1,"236":1,"273":1,"318":1,"475":1,"547":1,"661":1,"1440":1}}],["advantages",{"2":{"506":1}}],["advantage",{"0":{"264":1},"2":{"204":1,"867":1}}],["advisories",{"2":{"23":1}}],["advisory",{"2":{"21":2}}],["addressdetails=1`",{"2":{"1178":1}}],["addresses",{"2":{"997":1,"1008":2,"1011":2}}],["address",{"2":{"588":1,"1167":2,"1168":1,"1176":1,"1178":11,"1188":1}}],["addbusinessdays",{"0":{"1199":1},"2":{"231":2,"233":2,"234":2,"235":1,"236":1,"1199":2,"1210":1,"1220":1,"1221":2,"1224":2}}],["adddays",{"2":{"181":1}}],["adds",{"2":{"123":1,"125":1,"182":1,"183":1,"230":1,"231":1,"253":1,"254":1,"255":1,"257":1,"264":1,"469":1,"516":1,"1199":1,"1341":1}}],["additions",{"2":{"453":1,"758":1}}],["addition",{"2":{"371":1,"513":1,"974":1,"1224":1}}],["additionally",{"2":{"282":1,"707":1,"722":1}}],["additional",{"2":{"88":1,"218":1,"262":1,"315":1,"464":1,"1125":1}}],["additively",{"2":{"737":1}}],["additive",{"2":{"298":1,"331":1,"440":1,"562":1,"633":1}}],["adding",{"0":{"1198":1},"1":{"1199":1},"2":{"27":1,"166":1,"230":1,"263":1,"273":1,"279":1,"300":1,"396":1,"425":1,"464":1,"509":1,"519":2,"737":1,"765":1,"1218":1}}],["added",{"2":{"26":1,"94":1,"139":1,"273":2,"373":1,"440":1,"578":1,"581":1,"594":1,"598":1,"601":1,"602":1,"606":1,"609":1,"610":1,"612":1,"614":2,"620":1,"630":1,"633":1,"637":3,"639":2,"640":1,"644":1,"645":1,"651":1,"657":1,"661":1,"677":1,"692":1,"701":1,"702":1,"719":1,"744":1,"746":1,"747":1,"751":1,"758":1,"778":1,"817":1,"829":1,"1271":1}}],["add",{"0":{"62":1,"182":1},"2":{"9":1,"10":4,"26":2,"27":1,"35":3,"39":3,"46":2,"62":4,"96":1,"123":1,"158":1,"159":1,"181":1,"182":2,"183":1,"184":1,"189":1,"192":2,"194":1,"195":1,"199":1,"218":1,"224":3,"225":1,"229":1,"231":1,"233":4,"235":1,"255":1,"261":2,"265":2,"276":2,"278":1,"279":1,"295":1,"316":1,"318":1,"321":1,"323":1,"324":5,"325":1,"326":2,"380":2,"381":3,"387":2,"399":1,"431":1,"439":1,"556":3,"597":1,"617":1,"667":1,"681":1,"719":1,"747":1,"773":1,"842":1,"845":1,"846":3,"1055":2,"1199":1,"1220":1,"1223":1,"1224":1,"1262":1,"1319":1,"1326":2,"1454":1}}],["apogee",{"2":{"1064":2,"1075":1,"1077":1}}],["apm",{"2":{"864":1,"1011":3}}],["apr",{"2":{"215":1,"1097":1,"1269":1}}],["april",{"2":{"58":1,"192":1,"215":1,"362":1,"739":1,"878":1,"1065":1,"1097":1,"1221":6}}],["apparent",{"0":{"1064":1,"1066":1,"1068":1,"1069":1},"1":{"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1},"2":{"1052":2,"1053":1,"1055":1,"1062":1,"1064":1,"1066":1,"1069":3,"1080":1,"1081":1,"1353":2}}],["appointmentslot",{"2":{"1326":2}}],["appointments",{"2":{"1324":1}}],["appointment",{"0":{"987":1},"1":{"988":1,"989":1,"990":1,"991":1,"992":1,"993":1},"2":{"919":1,"987":1,"1013":3,"1015":1,"1324":1}}],["appearing",{"2":{"714":1}}],["appears",{"2":{"219":1,"1060":1,"1063":2}}],["appear",{"2":{"157":1,"724":1,"1067":1,"1088":1,"1095":1,"1234":1}}],["appended",{"2":{"139":1,"707":1}}],["append",{"2":{"138":1,"139":5,"398":1,"406":1}}],["appends",{"2":{"95":2,"746":1}}],["appending",{"0":{"95":1},"2":{"95":1,"1271":1}}],["apple",{"2":{"1014":1}}],["applies",{"2":{"227":1,"262":1,"298":1,"365":1,"946":1,"1021":1}}],["applied",{"2":{"100":1,"102":1,"117":1,"292":1,"349":1,"350":1,"370":1,"403":1,"932":1,"1090":2,"1274":1}}],["applications",{"2":{"71":1,"116":1,"124":1,"126":1,"199":1,"262":1,"328":1,"329":1,"365":2,"377":1,"407":1,"479":1,"529":1,"533":1,"838":1,"858":1,"913":1,"922":1,"931":1,"1004":2,"1005":2,"1014":1,"1084":1,"1097":1,"1110":1,"1178":1,"1189":1,"1215":1,"1255":1,"1301":1,"1362":1,"1445":1,"1448":1}}],["application",{"2":{"33":1,"43":4,"100":1,"102":3,"104":1,"107":1,"109":1,"113":1,"118":1,"129":1,"214":1,"248":1,"249":1,"262":2,"276":1,"296":1,"332":1,"341":1,"403":1,"404":1,"457":1,"462":1,"470":1,"515":1,"526":1,"548":1,"610":1,"617":1,"728":1,"741":1,"759":2,"847":1,"848":1,"856":3,"860":4,"866":1,"876":1,"909":1,"936":1,"955":1,"966":1,"969":1,"980":1,"998":2,"1008":1,"1035":1,"1115":1,"1150":1,"1189":1,"1232":1,"1235":1,"1240":1,"1262":1,"1263":2,"1372":1,"1444":1}}],["applying",{"2":{"191":1,"246":1,"868":1,"1094":1,"1161":1,"1222":1}}],["apply",{"2":{"56":1,"110":1,"112":1,"144":1,"173":1,"327":1,"331":1,"364":1,"398":1,"1222":1}}],["approximation",{"2":{"1355":1}}],["approximately",{"2":{"1331":1}}],["approximate",{"2":{"1046":1}}],["approx",{"2":{"62":1,"240":1,"880":1,"1331":1,"1389":1,"1394":1}}],["appropriate",{"2":{"46":1,"304":1,"561":1}}],["approaches",{"2":{"915":1}}],["approach",{"0":{"169":1,"170":1},"2":{"8":1,"41":2,"45":1,"204":1,"269":1,"283":1,"425":1,"915":1,"1077":1,"1098":1,"1442":1}}],["app",{"2":{"37":1,"43":1,"103":2,"104":1,"114":1,"116":2,"119":1,"333":2,"341":1,"457":1,"714":1,"955":1,"1429":1,"1448":1}}],["apps",{"0":{"955":1},"2":{"34":1,"274":1,"915":1,"953":2,"1190":1}}],["apikey",{"2":{"477":1,"860":3,"929":2,"937":1,"938":1,"953":1,"1008":1}}],["apis",{"2":{"109":1,"274":1,"283":1,"361":1,"364":1,"409":2,"428":1,"479":1,"522":1,"644":1,"829":1,"845":1,"854":1,"867":1,"878":1,"921":1,"946":1,"953":1,"966":1,"1000":1,"1189":1,"1192":1,"1225":1}}],["api",{"0":{"479":1,"546":1,"677":1,"728":1,"842":1,"843":1,"1021":1,"1104":1,"1117":1,"1168":1,"1244":1,"1283":1,"1318":1,"1344":1,"1352":1,"1382":1,"1402":1},"1":{"1022":1,"1023":1,"1118":1,"1119":1,"1169":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1319":1,"1345":1,"1403":1,"1404":1,"1405":1,"1406":1},"2":{"0":1,"7":1,"11":2,"13":2,"26":1,"39":1,"76":1,"89":4,"93":1,"98":1,"119":1,"129":1,"138":1,"146":2,"152":1,"156":1,"157":1,"181":1,"199":1,"204":1,"215":2,"220":1,"224":1,"233":1,"261":1,"268":1,"310":1,"363":1,"365":2,"366":1,"402":1,"408":1,"425":1,"433":1,"439":1,"468":1,"470":1,"479":1,"506":1,"507":1,"511":1,"513":1,"514":1,"518":1,"524":1,"527":1,"537":2,"574":1,"578":1,"588":1,"589":1,"601":1,"612":1,"617":1,"644":1,"661":1,"671":1,"672":1,"720":1,"728":2,"731":1,"732":1,"750":1,"754":1,"840":1,"853":11,"854":1,"856":2,"857":2,"858":1,"859":2,"860":7,"867":1,"870":2,"876":1,"880":1,"889":1,"898":1,"913":2,"919":1,"921":1,"925":5,"926":4,"927":2,"929":2,"930":2,"931":3,"934":2,"935":1,"937":1,"938":2,"939":2,"947":1,"953":2,"954":1,"955":6,"957":4,"958":1,"959":2,"961":1,"970":1,"971":1,"972":1,"974":1,"978":1,"982":1,"988":1,"997":2,"1004":2,"1005":4,"1017":2,"1098":1,"1104":1,"1139":1,"1168":1,"1188":1,"1191":4,"1239":3,"1243":1,"1254":1,"1261":1,"1263":5,"1264":1,"1265":2,"1314":1,"1353":1,"1363":1,"1422":1}}],["atomicreader",{"0":{"1370":1},"2":{"1370":1,"1381":2,"1382":3,"1389":2,"1392":3,"1395":3}}],["atomicclock",{"0":{"1369":1},"2":{"1369":1,"1373":1,"1376":1,"1382":2,"1388":2,"1392":1,"1395":1}}],["atomics",{"0":{"1367":1},"1":{"1368":1,"1369":1,"1370":1,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1},"2":{"1367":1,"1368":2,"1369":2,"1370":1,"1377":1,"1378":1,"1383":2}}],["atomictempo",{"2":{"1254":2,"1255":2}}],["atomicnow",{"2":{"1243":2}}],["atomic",{"0":{"1253":1,"1379":1},"1":{"1254":1,"1255":1,"1256":1,"1257":1,"1380":1},"2":{"1227":1,"1242":1,"1243":1,"1245":1,"1255":3,"1258":1,"1261":1,"1266":1,"1369":1,"1381":1,"1388":1,"1389":1}}],["atnoon",{"2":{"1069":2}}],["atmospheric",{"0":{"1070":1},"2":{"1052":1,"1062":1}}],["attendancepunchepochs",{"2":{"1036":2}}],["attendance",{"2":{"1035":1}}],["attendee",{"2":{"997":1}}],["attendees",{"2":{"994":1}}],["attention",{"2":{"954":1,"1008":1}}],["attempts",{"2":{"362":1,"433":1,"450":1,"1041":1}}],["attempt",{"2":{"362":1,"970":1}}],["attempting",{"2":{"295":1,"856":1}}],["attempted",{"2":{"128":1}}],["attacks",{"2":{"829":1,"997":1}}],["attachment",{"2":{"938":1}}],["attaching",{"2":{"300":1,"918":1}}],["attach",{"2":{"274":1,"711":1,"722":1,"797":1,"850":1,"1181":1,"1187":1}}],["attached",{"0":{"169":1},"2":{"141":1,"142":2,"269":1,"403":1,"561":1,"637":1,"864":1,"912":1,"936":1,"950":1,"965":1,"998":1,"1147":1,"1173":1}}],["attaches",{"2":{"45":1,"860":1,"955":1,"1104":1,"1117":1}}],["attributes",{"2":{"775":1,"933":1}}],["attribute",{"2":{"771":1}}],["at",{"0":{"507":1,"1229":1},"2":{"8":1,"15":1,"21":1,"34":2,"69":1,"93":1,"100":1,"102":2,"120":2,"123":1,"125":5,"138":1,"190":3,"192":1,"197":1,"205":2,"214":1,"227":1,"248":1,"250":2,"262":1,"276":2,"285":1,"288":1,"289":1,"300":1,"306":1,"342":1,"363":1,"406":2,"409":1,"429":1,"439":1,"451":1,"468":3,"486":1,"491":1,"506":1,"509":1,"511":1,"522":1,"541":1,"692":1,"738":1,"741":1,"769":1,"807":1,"816":1,"839":1,"849":1,"859":1,"874":1,"878":1,"888":1,"896":1,"898":2,"907":1,"909":2,"935":1,"939":1,"946":1,"949":1,"951":2,"955":1,"958":1,"962":1,"968":1,"969":1,"978":1,"981":1,"982":1,"993":1,"1000":1,"1013":2,"1069":3,"1070":2,"1072":2,"1077":1,"1091":2,"1111":1,"1113":2,"1127":2,"1129":2,"1136":1,"1146":1,"1147":3,"1203":2,"1219":1,"1249":1,"1255":1,"1271":1,"1326":1,"1331":2,"1332":1,"1351":1,"1364":1,"1388":1,"1389":1,"1392":1,"1394":1,"1413":1,"1415":3,"1418":1,"1419":1,"1424":2,"1445":1,"1446":1,"1447":3}}],["animation",{"2":{"1267":1,"1331":1}}],["animal",{"2":{"305":2,"775":1}}],["anzac",{"2":{"1213":2}}],["angular",{"2":{"1064":1,"1071":1,"1075":1,"1076":1}}],["angulardiameterarcmin",{"2":{"1053":1,"1064":2}}],["angle",{"0":{"1063":1},"2":{"1055":1,"1063":2,"1067":2,"1071":1,"1081":2}}],["angles",{"2":{"1052":1,"1080":1}}],["angeles",{"2":{"214":1,"296":1}}],["annals",{"2":{"1309":1}}],["annus",{"2":{"1271":1}}],["annular",{"2":{"1053":1,"1065":1}}],["annually",{"2":{"1413":1}}],["annual",{"2":{"974":1,"1223":1,"1224":1}}],["announce",{"2":{"1269":1}}],["annotations",{"2":{"997":1}}],["anno",{"2":{"763":1,"766":2}}],["antonius",{"2":{"1313":1}}],["antonio",{"2":{"1273":2,"1280":1,"1292":1,"1312":1,"1313":3}}],["ante",{"0":{"1270":1},"2":{"1270":1,"1271":4,"1275":1,"1276":2,"1280":2,"1304":2,"1310":1}}],["antimeridian",{"0":{"1338":1},"2":{"1338":1,"1343":1,"1344":1}}],["anti",{"0":{"1259":1},"1":{"1260":1,"1261":1}}],["antigravity",{"0":{"28":1},"2":{"24":1,"28":1,"48":1,"692":1}}],["anthropic",{"2":{"939":1}}],["anomalies",{"2":{"1363":1}}],["anomalistic",{"2":{"1075":1}}],["anomalous",{"2":{"1233":1,"1361":1}}],["anomaly",{"0":{"1348":1,"1361":1,"1363":1},"2":{"1162":1,"1339":1,"1343":1,"1354":1}}],["anonymous",{"2":{"937":1,"938":1,"959":1}}],["another",{"0":{"68":1},"2":{"110":1,"178":1,"219":1,"326":2,"493":2,"752":1,"878":1,"1104":1,"1157":1}}],["analytical",{"2":{"1353":1}}],["analytics",{"2":{"863":1,"1007":1,"1263":1,"1264":1}}],["analysis",{"2":{"1113":4,"1362":1}}],["analyzer",{"2":{"1104":1,"1113":1}}],["analyzes",{"2":{"1104":1}}],["analyze",{"2":{"869":1,"1113":1}}],["analog",{"2":{"666":1}}],["analogous",{"2":{"483":1}}],["answering",{"2":{"522":1}}],["answers",{"2":{"301":1}}],["ancient",{"0":{"1305":1},"1":{"1306":1,"1307":1}}],["ancestor",{"2":{"465":1}}],["anchoring",{"2":{"1447":1,"1459":1}}],["anchoryear",{"0":{"1288":1}}],["anchormonth",{"0":{"1288":1},"2":{"1304":3}}],["anchortime",{"2":{"1013":2}}],["anchors",{"0":{"908":1,"1268":1},"1":{"1269":1,"1270":1,"1271":1,"1272":1,"1273":1,"1274":1},"2":{"202":1,"1012":1,"1093":1,"1276":1,"1299":1,"1314":1}}],["anchored",{"2":{"167":1,"239":1,"246":1,"247":1,"323":1,"773":1,"951":1,"1078":1,"1098":1,"1245":1,"1265":1,"1362":1}}],["anchor",{"0":{"352":1,"1269":1,"1288":1},"2":{"9":2,"99":1,"129":1,"155":1,"158":2,"159":6,"162":2,"164":1,"165":1,"203":2,"313":10,"321":2,"323":2,"324":3,"351":2,"399":3,"588":1,"654":1,"773":1,"775":3,"866":1,"888":1,"889":2,"890":2,"893":1,"898":2,"899":2,"902":1,"904":1,"907":3,"908":1,"911":3,"962":2,"972":4,"988":1,"989":2,"1009":1,"1012":2,"1013":3,"1014":1,"1015":1,"1055":2,"1268":1,"1269":1,"1270":5,"1276":1,"1280":1,"1288":1,"1304":4,"1314":1,"1459":1}}],["anew",{"2":{"120":1}}],["an",{"0":{"82":1,"168":1},"1":{"169":1,"170":1,"171":1},"2":{"15":1,"24":1,"34":1,"43":2,"48":1,"69":1,"76":1,"85":1,"88":1,"89":1,"97":1,"103":1,"112":1,"116":1,"120":2,"125":1,"137":1,"138":2,"139":1,"144":2,"145":1,"146":2,"148":1,"150":1,"158":2,"159":1,"160":1,"161":2,"162":1,"167":4,"170":1,"188":2,"195":1,"205":1,"216":1,"219":1,"223":1,"224":1,"229":1,"231":1,"233":2,"239":1,"241":1,"261":1,"262":1,"263":1,"271":1,"286":1,"295":1,"296":1,"298":2,"315":1,"326":1,"334":1,"337":1,"342":1,"343":1,"346":1,"347":1,"351":2,"358":1,"359":1,"360":1,"362":1,"363":1,"365":1,"371":1,"377":1,"379":1,"388":1,"402":1,"407":2,"408":2,"412":1,"424":1,"431":1,"437":1,"451":1,"454":1,"455":1,"464":2,"469":1,"470":1,"472":1,"481":1,"493":1,"496":2,"501":1,"502":2,"503":1,"510":1,"515":1,"516":1,"520":1,"522":2,"578":1,"702":1,"739":1,"746":1,"750":1,"812":1,"831":2,"833":1,"845":1,"854":2,"856":2,"861":1,"865":1,"874":1,"876":1,"877":1,"887":1,"888":1,"891":2,"906":1,"908":1,"910":1,"938":1,"942":1,"954":1,"955":1,"964":1,"972":3,"973":3,"975":2,"976":1,"980":1,"983":2,"984":1,"986":1,"993":1,"998":1,"1000":1,"1011":1,"1012":1,"1013":1,"1015":1,"1017":1,"1019":1,"1028":1,"1054":1,"1067":1,"1070":1,"1080":1,"1085":1,"1088":3,"1091":1,"1093":1,"1096":1,"1099":1,"1104":4,"1106":1,"1116":1,"1120":1,"1125":2,"1134":1,"1140":1,"1144":1,"1147":1,"1149":1,"1164":1,"1168":2,"1172":1,"1178":1,"1188":2,"1189":1,"1190":2,"1191":1,"1213":1,"1219":1,"1233":1,"1234":1,"1243":1,"1254":1,"1257":1,"1263":1,"1270":1,"1271":2,"1284":1,"1290":1,"1291":1,"1294":1,"1295":2,"1310":1,"1313":1,"1326":1,"1341":1,"1351":1,"1358":1,"1363":1,"1369":2,"1370":1,"1374":1,"1395":1,"1406":1,"1424":1,"1439":1,"1440":1,"1442":1,"1443":1,"1444":1,"1445":1,"1446":1}}],["any>",{"2":{"1176":3,"1427":1}}],["anything",{"2":{"918":1}}],["anywhere",{"2":{"481":1}}],["any",{"2":{"7":1,"22":1,"26":1,"43":1,"45":1,"102":3,"115":1,"117":1,"118":2,"123":1,"132":1,"138":3,"141":1,"142":1,"143":1,"146":1,"176":1,"261":1,"273":1,"285":2,"288":1,"289":2,"313":4,"314":1,"315":3,"323":1,"331":1,"345":1,"350":1,"357":1,"409":1,"421":1,"425":1,"437":1,"446":1,"491":1,"495":1,"560":1,"709":1,"737":1,"739":2,"741":1,"750":1,"752":1,"763":1,"765":1,"778":1,"830":1,"856":2,"857":2,"860":1,"865":1,"908":1,"912":1,"913":1,"922":2,"942":2,"955":1,"993":1,"1001":1,"1005":2,"1009":1,"1041":1,"1084":1,"1086":1,"1090":1,"1096":1,"1113":1,"1115":1,"1116":1,"1167":1,"1178":4,"1191":1,"1195":1,"1276":2,"1414":1,"1421":1,"1427":1,"1459":1}}],["andrew",{"2":{"1213":1}}],["and",{"0":{"52":1,"61":1,"67":1,"70":1,"74":1,"114":1,"120":1,"123":1,"294":1,"356":1,"527":1,"541":1,"573":1,"832":1,"1094":1,"1172":1,"1197":1,"1323":1},"1":{"62":1,"63":1,"64":1,"65":1,"66":1,"68":1,"69":1,"71":1,"72":1,"73":1,"75":1,"76":1,"77":1,"78":1,"295":1,"296":1,"297":1,"298":1,"357":1,"358":1,"359":1,"360":1,"542":1,"1324":1,"1325":1,"1326":1},"2":{"0":1,"8":2,"12":4,"13":3,"14":1,"20":1,"22":3,"23":3,"24":3,"26":1,"30":1,"31":1,"34":2,"37":1,"39":2,"43":3,"44":2,"46":1,"48":2,"49":1,"50":4,"52":1,"60":1,"64":2,"69":1,"71":4,"77":1,"78":1,"83":2,"84":1,"85":2,"87":1,"89":1,"92":2,"93":2,"94":1,"98":1,"102":7,"103":1,"106":1,"107":3,"108":1,"109":5,"110":1,"111":1,"113":1,"114":2,"115":2,"116":1,"117":6,"119":2,"120":1,"121":3,"122":1,"123":1,"124":1,"125":2,"127":2,"128":1,"129":3,"131":2,"137":7,"138":8,"139":5,"140":2,"146":3,"147":3,"148":2,"149":1,"150":2,"152":3,"155":4,"156":2,"157":6,"161":2,"163":2,"165":2,"167":1,"169":1,"170":3,"171":1,"174":1,"181":2,"188":2,"189":3,"191":4,"192":1,"195":1,"196":1,"198":3,"199":1,"202":5,"203":3,"204":2,"205":4,"206":2,"209":1,"212":1,"213":1,"214":2,"215":1,"219":2,"220":2,"221":1,"222":1,"227":3,"228":1,"229":3,"230":3,"232":1,"233":1,"236":1,"237":3,"239":2,"240":1,"242":3,"247":2,"248":1,"249":1,"250":1,"251":1,"253":1,"254":1,"255":1,"256":1,"257":1,"261":1,"262":3,"263":1,"264":2,"265":1,"268":2,"269":3,"270":2,"271":3,"273":3,"274":3,"276":6,"278":1,"280":1,"281":1,"282":3,"283":2,"285":1,"289":1,"292":5,"293":1,"294":2,"295":1,"296":2,"297":2,"298":1,"301":3,"302":1,"310":1,"312":1,"314":2,"315":1,"318":2,"319":1,"320":1,"322":1,"325":1,"326":12,"327":2,"328":1,"330":1,"331":5,"334":1,"335":1,"336":1,"340":1,"341":1,"342":3,"343":1,"344":1,"348":2,"349":1,"350":1,"357":1,"359":3,"360":1,"361":4,"362":1,"363":6,"364":2,"365":2,"366":3,"368":1,"370":3,"371":1,"374":1,"375":1,"377":1,"378":2,"380":1,"381":1,"383":1,"386":1,"387":1,"389":1,"391":1,"394":1,"398":1,"399":1,"400":1,"402":3,"403":1,"405":1,"407":3,"408":2,"409":5,"412":1,"416":3,"417":1,"418":2,"419":2,"421":1,"422":1,"423":2,"424":3,"425":2,"427":1,"428":1,"430":1,"433":2,"437":1,"439":1,"440":1,"441":1,"442":1,"444":2,"445":1,"446":2,"449":1,"450":2,"451":1,"452":2,"453":3,"454":1,"456":2,"458":1,"461":1,"462":1,"464":1,"465":4,"466":4,"467":1,"468":4,"469":2,"470":1,"471":3,"472":4,"473":4,"475":3,"476":1,"477":1,"478":1,"479":5,"481":1,"482":1,"484":1,"488":1,"489":3,"490":1,"494":2,"495":3,"497":1,"498":2,"500":3,"501":1,"502":2,"503":2,"504":3,"505":3,"509":1,"510":2,"511":1,"512":1,"514":3,"515":5,"516":5,"517":1,"518":1,"519":3,"520":3,"522":7,"524":1,"525":2,"526":4,"527":1,"529":1,"531":2,"533":2,"534":1,"535":1,"537":3,"538":1,"539":1,"540":1,"541":3,"544":1,"546":1,"548":1,"549":1,"550":1,"551":1,"553":1,"556":1,"557":1,"558":1,"560":1,"562":1,"563":1,"564":1,"565":4,"573":1,"574":4,"575":3,"578":2,"580":5,"581":1,"588":1,"589":1,"590":1,"592":2,"594":1,"596":1,"601":2,"602":1,"606":2,"610":3,"612":1,"613":1,"614":2,"616":1,"617":5,"618":1,"620":1,"621":2,"622":1,"625":4,"626":1,"629":2,"631":2,"633":4,"634":1,"635":2,"637":1,"639":2,"640":1,"642":2,"643":1,"644":5,"647":1,"648":4,"649":3,"651":5,"653":2,"654":1,"655":3,"659":1,"660":1,"661":2,"663":2,"664":1,"665":3,"666":3,"667":2,"669":3,"671":2,"672":1,"674":1,"675":1,"679":1,"680":1,"681":1,"682":1,"687":2,"688":2,"689":2,"690":2,"691":1,"692":1,"694":2,"695":1,"696":1,"697":2,"699":1,"701":3,"704":1,"705":1,"707":1,"708":1,"709":2,"711":1,"712":1,"716":2,"717":1,"719":2,"720":1,"722":4,"723":1,"724":1,"726":1,"728":1,"734":1,"735":3,"737":2,"738":3,"741":2,"743":1,"744":2,"746":2,"747":4,"750":1,"751":1,"752":1,"754":3,"755":2,"757":1,"759":1,"760":4,"763":8,"766":1,"767":1,"768":2,"769":3,"771":7,"773":2,"774":2,"775":4,"776":2,"778":1,"780":2,"782":2,"784":1,"786":1,"787":2,"788":1,"790":1,"792":2,"793":1,"795":1,"798":2,"802":2,"804":1,"807":2,"808":2,"810":2,"812":2,"814":1,"817":3,"819":1,"821":1,"823":2,"824":1,"825":1,"827":2,"829":8,"830":2,"831":3,"832":2,"833":3,"835":1,"836":4,"838":1,"839":2,"840":1,"841":2,"842":1,"844":1,"845":3,"847":1,"849":1,"851":2,"852":1,"853":3,"854":2,"855":2,"856":5,"857":2,"860":2,"861":2,"862":2,"863":1,"864":2,"865":1,"866":2,"867":2,"868":2,"869":5,"871":3,"878":1,"879":1,"881":2,"882":3,"884":2,"886":1,"888":4,"889":1,"890":2,"891":1,"893":3,"894":1,"895":1,"897":1,"899":1,"900":1,"902":4,"903":1,"904":1,"905":1,"906":2,"907":2,"908":1,"909":1,"910":3,"912":1,"913":4,"915":2,"919":1,"920":1,"921":3,"922":5,"923":2,"924":1,"925":1,"926":1,"929":1,"930":1,"931":1,"932":2,"933":3,"934":3,"936":5,"937":2,"938":3,"939":1,"942":3,"945":2,"948":1,"949":1,"950":3,"951":3,"953":2,"954":5,"955":3,"957":1,"958":1,"959":1,"963":1,"966":1,"967":1,"970":1,"971":1,"972":3,"973":2,"974":1,"975":2,"977":1,"980":2,"981":1,"986":1,"987":2,"989":1,"993":2,"994":4,"995":1,"996":1,"997":2,"998":3,"1000":1,"1001":1,"1003":1,"1004":3,"1005":1,"1007":3,"1008":6,"1009":1,"1010":2,"1011":4,"1012":2,"1013":2,"1015":1,"1017":2,"1018":1,"1019":1,"1021":3,"1024":2,"1025":2,"1028":1,"1035":1,"1036":1,"1037":1,"1038":1,"1039":2,"1040":1,"1044":1,"1045":1,"1049":1,"1050":1,"1052":6,"1053":7,"1054":5,"1057":2,"1058":1,"1060":1,"1061":1,"1062":1,"1063":4,"1064":1,"1065":1,"1066":1,"1067":2,"1069":1,"1070":1,"1071":3,"1072":5,"1073":2,"1074":2,"1075":2,"1076":2,"1077":1,"1078":2,"1080":4,"1081":4,"1082":1,"1083":3,"1084":2,"1085":3,"1086":4,"1088":6,"1089":3,"1090":1,"1091":3,"1093":3,"1094":4,"1095":2,"1097":2,"1098":3,"1099":3,"1103":3,"1104":4,"1105":7,"1106":3,"1107":2,"1110":3,"1113":3,"1114":1,"1121":1,"1122":2,"1123":2,"1124":1,"1125":6,"1131":1,"1136":2,"1137":1,"1139":3,"1143":3,"1146":2,"1147":2,"1149":2,"1150":2,"1151":1,"1155":2,"1156":1,"1157":2,"1158":1,"1161":1,"1162":3,"1166":4,"1168":2,"1169":2,"1171":1,"1173":1,"1174":2,"1175":1,"1176":3,"1178":2,"1181":2,"1183":1,"1187":1,"1188":2,"1189":3,"1191":1,"1192":2,"1193":1,"1194":1,"1197":1,"1203":1,"1205":3,"1206":1,"1207":2,"1210":3,"1211":2,"1212":1,"1213":3,"1214":3,"1215":1,"1218":3,"1219":1,"1220":1,"1221":3,"1223":1,"1224":1,"1225":3,"1226":1,"1236":2,"1240":1,"1241":1,"1242":4,"1246":1,"1250":1,"1252":2,"1253":1,"1254":1,"1255":1,"1256":1,"1257":1,"1258":1,"1259":1,"1260":1,"1262":2,"1267":2,"1268":1,"1269":1,"1270":2,"1272":1,"1273":1,"1274":1,"1275":1,"1276":4,"1278":1,"1280":1,"1281":1,"1293":2,"1296":1,"1297":1,"1299":2,"1300":2,"1301":1,"1303":2,"1306":1,"1307":1,"1309":2,"1312":3,"1313":1,"1314":2,"1315":3,"1316":1,"1320":1,"1321":2,"1322":1,"1324":1,"1325":1,"1328":1,"1329":1,"1331":2,"1333":1,"1336":1,"1339":3,"1341":1,"1343":4,"1345":1,"1349":2,"1350":1,"1351":1,"1353":1,"1354":1,"1362":3,"1363":2,"1364":1,"1365":2,"1366":1,"1367":2,"1368":1,"1369":1,"1370":1,"1371":1,"1375":1,"1376":1,"1377":3,"1378":2,"1382":2,"1383":2,"1384":2,"1387":2,"1388":1,"1391":1,"1392":1,"1394":2,"1395":2,"1396":2,"1401":4,"1404":1,"1405":2,"1410":2,"1411":1,"1412":2,"1415":1,"1417":1,"1421":1,"1423":1,"1424":1,"1426":1,"1429":1,"1431":1,"1432":1,"1433":1,"1434":1,"1436":2,"1440":1,"1441":1,"1442":3,"1443":3,"1444":2,"1445":3,"1446":1,"1448":1,"1449":1,"1450":2,"1454":5}}],["arg",{"2":{"1452":2}}],["arguably",{"2":{"351":1}}],["argument",{"2":{"265":1,"269":1,"276":2,"292":1,"351":1,"477":1,"908":1,"1318":1}}],["arguments",{"2":{"52":1,"169":1,"170":1,"292":1,"456":2,"520":1,"1041":1}}],["arms",{"2":{"1421":1}}],["arm",{"2":{"1370":1}}],["armistice",{"2":{"1213":1}}],["arbeit",{"2":{"1213":1}}],["arbitrary",{"2":{"775":1,"806":1,"854":1,"1012":1,"1090":1,"1091":1,"1096":1,"1097":1,"1098":1,"1112":1,"1131":1,"1276":1,"1332":1}}],["archaeological",{"2":{"1303":1}}],["archaeology",{"2":{"1301":1}}],["archival",{"0":{"766":1},"2":{"763":3,"766":2,"1299":1,"1309":1}}],["archived",{"2":{"463":2}}],["architects",{"2":{"922":1}}],["architected",{"2":{"722":1}}],["architecting",{"2":{"157":1}}],["architectures",{"2":{"111":1,"119":1,"476":1,"514":1,"755":1,"1143":1,"1149":1,"1219":1,"1242":1,"1367":1,"1368":1}}],["architecture",{"0":{"1":1,"93":1,"99":1,"269":1,"400":1,"405":1,"532":1,"550":1,"625":1,"675":1,"772":1,"852":1,"858":1,"921":1,"952":1,"994":1,"1002":1,"1007":1,"1024":1,"1037":1,"1091":1,"1105":1,"1164":1,"1220":1,"1238":1,"1320":1,"1341":1,"1353":1,"1367":1,"1383":1,"1398":1,"1428":1,"1440":1},"1":{"94":1,"270":1,"401":1,"402":1,"403":1,"404":1,"405":1,"406":1,"407":1,"408":1,"409":1,"410":1,"411":1,"412":1,"413":1,"414":1,"415":1,"416":1,"417":1,"418":1,"419":1,"420":1,"421":1,"422":1,"423":1,"551":1,"552":1,"773":1,"774":1,"775":1,"776":1,"777":1,"778":1,"853":1,"854":1,"855":1,"856":1,"857":1,"858":1,"859":2,"860":2,"861":1,"862":1,"863":1,"864":1,"865":1,"866":1,"867":1,"868":1,"953":1,"995":1,"996":1,"997":1,"998":1,"999":1,"1000":1,"1001":1,"1002":1,"1003":2,"1004":2,"1005":2,"1006":1,"1007":1,"1008":1,"1009":1,"1010":1,"1011":1,"1038":1,"1039":1,"1040":1,"1041":1,"1042":1,"1043":1,"1165":1,"1239":1,"1240":1,"1241":1,"1342":1,"1368":1,"1369":1,"1370":1,"1371":1,"1372":1,"1373":1,"1374":1,"1375":1,"1376":1,"1399":1,"1400":1,"1429":1,"1430":1,"1441":1,"1442":1},"2":{"13":1,"229":1,"266":1,"270":1,"423":1,"441":1,"515":1,"516":1,"526":1,"535":1,"574":1,"589":1,"596":1,"598":1,"614":1,"623":1,"637":1,"644":1,"651":1,"655":1,"661":1,"674":1,"704":1,"711":1,"712":1,"728":1,"752":1,"845":1,"861":1,"867":1,"869":1,"921":2,"925":1,"936":1,"993":1,"1005":1,"1018":1,"1024":1,"1162":1,"1242":1,"1383":1}}],["architecturally",{"2":{"514":2,"752":1}}],["architectural",{"0":{"373":1,"443":1,"784":1,"790":1,"804":1,"810":1,"814":1,"821":1,"827":1,"832":1,"837":1,"873":1,"883":1,"892":1,"901":1,"1012":1,"1026":1,"1029":1,"1033":1,"1036":1,"1080":1,"1084":1,"1092":1,"1137":1,"1140":1,"1144":1,"1147":1,"1150":1,"1189":1,"1218":1,"1258":1,"1322":1,"1325":1,"1329":1,"1332":1,"1362":1,"1385":1,"1388":1,"1392":1,"1395":1,"1443":1},"1":{"444":1,"445":1,"838":1,"839":1,"840":1,"841":1,"842":1,"874":1,"875":1,"876":1,"877":1,"878":1,"884":1,"885":1,"886":1,"887":1,"893":1,"894":1,"895":1,"896":1,"902":1,"903":1,"904":1,"905":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1027":1,"1028":1,"1029":1,"1030":1,"1031":1,"1032":1,"1033":1,"1034":1,"1035":1,"1036":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1138":1,"1139":1,"1140":1,"1141":1,"1142":1,"1143":1,"1144":1,"1145":1,"1146":1,"1147":1,"1148":1,"1149":1,"1150":1,"1190":1,"1191":1,"1192":1,"1193":1,"1219":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1225":1,"1259":1,"1260":1,"1261":1,"1262":1,"1263":1,"1264":1,"1265":1,"1266":1,"1267":1,"1323":1,"1324":1,"1325":1,"1326":1,"1327":1,"1328":1,"1329":1,"1330":1,"1331":1,"1332":1,"1363":1,"1364":1,"1365":1,"1366":1,"1386":1,"1387":1,"1388":1,"1389":1,"1390":1,"1391":1,"1392":1,"1393":1,"1394":1,"1395":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1},"2":{"0":1,"8":1,"43":1,"64":1,"106":1,"157":1,"202":1,"283":1,"400":1,"407":1,"549":1,"575":1,"625":1,"629":1,"705":1,"717":1,"830":1,"835":1,"921":1,"1011":1,"1024":1,"1052":1,"1084":1,"1086":1,"1105":1,"1137":1,"1166":1,"1189":1,"1210":1,"1299":1,"1320":1,"1343":1,"1383":1,"1385":1,"1401":1}}],["arcmin",{"2":{"1064":1}}],["arcminutes",{"2":{"1064":1}}],["artificial",{"2":{"1067":1,"1080":1}}],["artifacts",{"2":{"665":1,"669":1}}],["article",{"2":{"424":1}}],["articles",{"2":{"363":1}}],["aries",{"2":{"385":3,"388":1}}],["arithmetic",{"0":{"1194":1},"1":{"1195":1,"1196":1,"1197":1,"1198":1,"1199":1,"1200":1,"1201":1,"1202":1,"1203":1,"1204":1,"1205":1},"2":{"63":1,"236":1,"322":1,"323":1,"325":1,"522":1,"771":2,"773":1,"778":1,"817":1,"879":1,"884":1,"894":1,"1036":1,"1194":1,"1206":1,"1210":1,"1218":1,"1275":1,"1278":1,"1396":1}}],["around",{"0":{"1015":1},"2":{"366":1,"425":1,"432":1,"474":1,"480":1,"504":1,"514":1,"750":1,"916":1,"917":1,"1082":1,"1083":1}}],["arr",{"2":{"1360":4}}],["arriving",{"2":{"1016":1,"1083":1}}],["arrivaliso",{"2":{"1083":1}}],["arrival",{"0":{"1364":1},"2":{"1016":1,"1083":4,"1364":1}}],["arrive",{"2":{"1139":1,"1360":1,"1364":1}}],["arrives",{"2":{"946":1}}],["arrived",{"2":{"342":1}}],["arranged",{"2":{"240":1}}],["arrays",{"2":{"292":2,"504":2,"578":1,"782":1,"806":1,"896":1,"912":1,"972":1,"973":1,"1037":1,"1040":1,"1043":1,"1081":1}}],["array",{"0":{"82":1,"128":1,"454":1,"964":1,"972":1,"973":1},"2":{"71":1,"125":1,"148":1,"219":4,"235":1,"262":1,"290":1,"291":1,"319":1,"321":1,"326":1,"337":1,"346":1,"347":1,"351":2,"363":1,"375":1,"454":1,"496":1,"750":1,"757":1,"829":1,"848":1,"871":1,"877":1,"881":2,"887":1,"890":1,"891":1,"899":1,"919":1,"920":3,"934":2,"937":1,"959":1,"964":1,"970":1,"972":5,"973":4,"983":1,"989":1,"1015":1,"1019":2,"1021":1,"1029":1,"1033":1,"1036":1,"1039":1,"1040":3,"1113":1,"1140":1,"1178":1,"1240":1,"1406":1}}],["arabia",{"2":{"365":1,"817":1,"1205":2}}],["arabicconfig",{"2":{"146":3}}],["arabic",{"2":{"146":1,"370":1,"750":1,"802":1,"817":1,"1158":1,"1171":1}}],["arab",{"2":{"146":1}}],["ar",{"2":{"71":3,"138":1,"146":2,"186":1,"370":3,"884":1,"1157":1,"1158":2,"1171":1,"1190":1,"1205":4,"1207":1}}],["aren",{"2":{"45":1,"291":1}}],["are",{"0":{"72":1,"453":1,"466":1,"504":1,"1450":1},"1":{"454":1,"455":1,"456":1},"2":{"7":1,"8":1,"33":1,"43":2,"44":2,"46":1,"62":1,"73":1,"75":2,"76":1,"78":1,"94":2,"99":2,"100":1,"101":1,"102":2,"108":1,"109":3,"120":3,"121":1,"124":1,"125":1,"128":1,"129":1,"131":1,"136":1,"137":1,"138":2,"140":1,"142":1,"146":2,"156":1,"157":1,"163":1,"164":1,"170":1,"177":1,"181":1,"190":1,"191":1,"195":1,"198":1,"203":1,"205":1,"208":1,"210":1,"211":1,"220":1,"221":2,"227":2,"230":2,"234":1,"243":2,"245":1,"250":2,"257":1,"261":1,"262":3,"264":2,"266":2,"271":1,"272":2,"274":1,"276":2,"278":1,"281":1,"290":1,"295":2,"297":2,"300":3,"301":1,"308":1,"313":1,"315":3,"325":1,"326":1,"327":1,"331":1,"340":2,"351":1,"352":1,"359":1,"361":3,"364":1,"367":1,"371":1,"374":1,"376":1,"381":1,"385":1,"386":1,"387":1,"394":1,"399":3,"402":2,"404":1,"405":1,"408":1,"413":1,"414":1,"418":1,"427":2,"429":2,"430":1,"437":1,"438":1,"439":2,"440":2,"444":1,"445":1,"452":1,"453":1,"454":1,"456":1,"457":1,"464":1,"468":1,"470":2,"473":1,"479":4,"481":1,"483":1,"484":1,"498":1,"499":2,"503":2,"504":1,"505":3,"506":3,"510":1,"512":1,"515":1,"516":1,"519":1,"526":1,"534":1,"538":1,"539":1,"544":1,"549":1,"551":1,"553":1,"556":1,"560":1,"565":2,"597":1,"629":1,"631":1,"653":1,"668":1,"669":1,"680":1,"699":2,"716":2,"728":1,"735":1,"737":1,"739":1,"759":1,"766":1,"767":2,"771":1,"776":1,"782":1,"786":1,"798":2,"802":1,"812":1,"829":3,"838":1,"845":1,"846":1,"853":1,"855":1,"856":2,"857":1,"859":1,"862":1,"863":1,"864":1,"865":1,"866":1,"868":1,"884":1,"888":1,"889":1,"894":1,"895":1,"902":1,"906":1,"909":2,"916":1,"919":1,"921":1,"922":1,"925":2,"932":1,"942":3,"946":1,"948":2,"949":1,"953":1,"954":1,"957":1,"958":1,"968":1,"972":3,"978":1,"980":1,"996":1,"997":1,"998":1,"1000":1,"1001":1,"1003":1,"1004":1,"1005":1,"1008":2,"1009":1,"1010":2,"1029":1,"1040":1,"1041":1,"1054":2,"1061":1,"1067":1,"1071":1,"1078":1,"1079":1,"1080":1,"1088":1,"1090":1,"1091":1,"1094":1,"1106":1,"1115":1,"1125":2,"1129":1,"1131":1,"1132":1,"1147":1,"1173":1,"1182":1,"1186":1,"1187":1,"1213":1,"1215":1,"1221":2,"1222":1,"1225":1,"1231":1,"1233":2,"1234":1,"1240":1,"1264":1,"1265":1,"1270":2,"1318":1,"1319":1,"1338":1,"1431":1,"1435":1,"1436":1,"1442":3,"1443":1,"1450":1,"1459":4}}],["a",{"0":{"20":1,"54":1,"55":1,"65":1,"214":1,"230":1,"235":1,"238":1,"239":1,"263":1,"275":1,"288":1,"293":1,"301":1,"312":1,"380":1,"507":1,"552":1,"848":1,"916":1,"957":1,"977":1,"1039":1,"1087":1,"1127":1,"1134":1,"1177":1,"1178":1,"1186":1,"1280":1,"1429":1,"1438":1,"1452":1},"1":{"21":1,"22":1,"23":1,"231":1,"232":1,"233":1,"234":1,"235":1,"236":1,"264":1,"265":1,"266":1,"267":1,"268":1,"269":1,"270":1,"271":1,"272":1,"289":1,"290":1,"291":1,"313":1,"314":1,"315":1,"316":1,"317":1,"917":1,"1088":1,"1089":1,"1090":1,"1091":1,"1178":1,"1179":1,"1180":1},"2":{"0":1,"3":2,"5":1,"6":1,"7":2,"8":3,"10":1,"13":1,"15":1,"16":1,"20":1,"21":1,"22":1,"23":1,"27":3,"28":1,"31":1,"33":4,"34":6,"35":1,"39":1,"41":2,"42":1,"43":8,"44":2,"45":2,"47":1,"49":1,"62":1,"64":2,"72":1,"75":2,"76":2,"77":2,"83":2,"89":1,"90":1,"92":1,"93":1,"95":2,"97":2,"100":2,"101":1,"102":5,"109":2,"110":4,"111":3,"113":1,"114":1,"116":2,"117":1,"118":1,"119":1,"120":1,"124":3,"125":3,"127":2,"128":3,"129":1,"130":1,"131":2,"133":1,"138":11,"139":4,"140":1,"142":1,"147":5,"148":3,"150":1,"152":1,"155":4,"156":1,"157":4,"158":16,"159":4,"161":6,"162":3,"163":2,"164":4,"165":3,"167":5,"168":1,"174":1,"177":1,"179":1,"180":2,"181":1,"182":2,"183":2,"184":1,"189":2,"191":5,"192":2,"194":2,"195":1,"196":1,"197":2,"198":1,"202":2,"204":1,"208":1,"214":1,"215":3,"216":2,"219":3,"220":1,"221":1,"223":1,"224":4,"226":2,"228":5,"229":1,"230":5,"231":1,"232":1,"233":3,"235":2,"238":3,"239":3,"240":2,"241":3,"243":2,"246":2,"247":1,"249":1,"251":1,"258":1,"261":1,"262":1,"263":1,"264":1,"265":2,"266":2,"269":2,"270":1,"271":6,"272":1,"273":7,"274":3,"275":2,"276":5,"279":2,"280":1,"281":9,"283":3,"284":1,"285":1,"286":2,"289":1,"291":1,"292":5,"293":3,"296":3,"298":1,"300":5,"301":7,"302":1,"306":2,"307":1,"310":1,"312":1,"314":2,"315":5,"317":2,"318":1,"319":1,"321":5,"326":4,"327":1,"330":1,"331":1,"333":2,"334":1,"338":1,"340":1,"341":1,"342":1,"349":1,"350":1,"351":2,"353":1,"354":1,"355":1,"356":1,"357":2,"358":1,"359":6,"360":1,"362":1,"363":2,"365":2,"367":3,"370":4,"371":1,"372":1,"375":1,"376":1,"377":1,"378":1,"379":2,"382":1,"385":1,"386":1,"387":4,"388":2,"389":1,"390":2,"391":2,"392":1,"394":1,"396":2,"397":1,"398":1,"402":8,"403":1,"404":2,"405":1,"407":3,"408":3,"410":1,"411":1,"412":2,"413":1,"414":4,"415":1,"416":5,"417":1,"418":3,"420":1,"421":3,"422":1,"423":1,"424":2,"425":3,"426":3,"427":5,"429":3,"430":1,"431":2,"432":3,"433":1,"435":1,"438":1,"439":3,"440":3,"441":1,"444":1,"445":4,"446":4,"447":1,"449":1,"450":1,"451":4,"452":3,"453":3,"461":3,"464":1,"465":2,"467":1,"468":2,"469":6,"470":1,"471":2,"472":1,"473":2,"474":2,"477":2,"479":1,"480":1,"481":2,"482":2,"484":1,"486":2,"487":1,"488":1,"489":2,"491":1,"493":2,"498":1,"501":1,"502":2,"503":4,"506":1,"511":1,"512":1,"513":2,"514":4,"515":6,"516":4,"519":3,"520":11,"522":2,"524":2,"526":2,"527":2,"529":2,"531":1,"535":1,"540":1,"541":1,"548":1,"549":1,"550":1,"559":1,"561":1,"563":1,"564":1,"567":1,"573":1,"578":2,"601":1,"606":1,"625":1,"626":1,"634":1,"635":1,"637":1,"642":4,"643":3,"644":2,"647":4,"648":2,"651":3,"653":2,"659":1,"666":2,"668":1,"671":1,"672":1,"674":2,"677":1,"681":1,"692":1,"694":1,"702":3,"705":1,"707":3,"708":1,"709":1,"711":3,"716":2,"722":1,"723":1,"728":3,"734":1,"738":3,"741":3,"744":2,"750":5,"751":1,"752":4,"754":2,"755":1,"757":1,"760":1,"763":1,"769":1,"782":1,"793":1,"812":3,"814":1,"827":1,"829":1,"831":1,"833":2,"835":2,"836":1,"838":1,"840":1,"855":2,"856":1,"857":2,"858":2,"861":1,"864":1,"865":1,"866":1,"869":1,"870":1,"871":2,"874":1,"875":1,"876":1,"878":3,"881":1,"890":1,"897":1,"899":1,"906":1,"908":3,"909":3,"910":5,"912":6,"913":1,"919":1,"920":1,"921":1,"923":1,"925":2,"931":1,"932":1,"934":1,"935":1,"936":1,"939":1,"942":1,"945":1,"946":2,"948":1,"953":1,"954":2,"955":2,"963":1,"965":2,"968":1,"970":2,"972":5,"974":1,"976":1,"978":1,"979":1,"980":2,"983":1,"984":1,"985":2,"987":2,"988":1,"989":2,"992":2,"993":4,"994":1,"995":1,"998":1,"1003":1,"1005":1,"1008":2,"1010":1,"1011":1,"1013":2,"1018":1,"1019":1,"1025":1,"1028":2,"1033":3,"1035":1,"1037":1,"1038":1,"1039":2,"1040":1,"1050":1,"1054":1,"1057":1,"1064":2,"1068":1,"1069":1,"1077":2,"1081":1,"1082":1,"1088":5,"1089":3,"1090":2,"1091":1,"1094":1,"1095":1,"1096":1,"1104":4,"1107":1,"1113":5,"1114":1,"1116":1,"1119":2,"1123":1,"1124":1,"1125":19,"1127":1,"1129":1,"1130":1,"1132":1,"1134":1,"1139":1,"1140":3,"1141":1,"1144":1,"1146":1,"1147":2,"1149":2,"1150":1,"1151":1,"1155":1,"1157":2,"1160":1,"1162":1,"1167":1,"1168":1,"1169":1,"1171":1,"1174":1,"1178":5,"1181":2,"1182":2,"1185":1,"1186":1,"1188":2,"1191":1,"1193":1,"1195":4,"1199":1,"1205":2,"1211":1,"1214":1,"1215":1,"1219":4,"1221":2,"1222":4,"1224":1,"1227":2,"1232":2,"1235":1,"1236":1,"1240":1,"1245":1,"1246":1,"1251":1,"1252":1,"1255":1,"1259":1,"1262":1,"1263":1,"1266":1,"1270":2,"1271":1,"1272":1,"1273":1,"1275":1,"1276":3,"1280":4,"1287":1,"1289":3,"1290":1,"1292":1,"1293":1,"1300":1,"1303":2,"1304":3,"1310":2,"1313":1,"1315":2,"1318":2,"1319":1,"1321":1,"1329":2,"1334":1,"1336":2,"1339":2,"1344":3,"1345":2,"1349":1,"1355":1,"1358":1,"1360":1,"1361":1,"1363":1,"1364":3,"1368":1,"1369":1,"1370":1,"1374":1,"1376":1,"1377":1,"1378":1,"1381":1,"1382":2,"1384":1,"1388":1,"1392":2,"1396":1,"1405":1,"1410":1,"1411":1,"1415":1,"1417":1,"1419":2,"1420":2,"1421":3,"1424":1,"1426":1,"1428":1,"1429":1,"1435":2,"1436":2,"1442":2,"1448":2,"1450":1,"1452":1,"1454":1,"1457":1,"1459":1}}],["i++",{"2":{"1389":1}}],["iam",{"2":{"1363":1}}],["iana",{"2":{"11":1,"117":1,"138":1,"142":1,"154":1,"296":2,"634":1,"723":1,"872":1,"876":1,"881":1,"890":1,"899":1,"989":1}}],["iii",{"2":{"1281":4}}],["iife",{"2":{"671":1,"722":1}}],["iv",{"2":{"1270":1,"1276":1,"1280":1,"1289":1,"1303":1}}],["ieee",{"2":{"1039":1}}],["icalendar",{"2":{"1014":2,"1404":1,"1418":1}}],["icu",{"2":{"215":1,"365":3,"373":1}}],["ireland",{"2":{"1213":1}}],["irradiance",{"2":{"1081":1}}],["ir",{"2":{"884":1,"1116":1,"1150":1}}],["iot",{"0":{"1027":1},"1":{"1028":1,"1029":1,"1030":1},"2":{"1018":1,"1024":1,"1028":1,"1255":1,"1328":1,"1422":1,"1444":1}}],["io",{"2":{"709":1}}],["ios",{"2":{"34":1}}],["ipc",{"2":{"1367":1,"1370":1,"1377":1,"1388":1}}],["ipcountry",{"2":{"1193":2}}],["iplongitude",{"2":{"1363":5}}],["iplatitude",{"2":{"1363":5}}],["ipapiprovider",{"2":{"1166":1}}],["ip",{"0":{"1188":1},"2":{"526":1,"953":1,"954":2,"1008":5,"1168":4,"1169":1,"1175":1,"1176":1,"1178":1,"1188":7,"1190":1,"1193":1}}],["i7",{"2":{"419":2}}],["illuminate",{"2":{"1082":1}}],["illuminates",{"2":{"1067":1}}],["illuminated",{"2":{"1060":1,"1063":1}}],["illuminationpct",{"2":{"1085":1}}],["illumination",{"2":{"1052":1,"1053":1,"1054":1,"1055":2,"1058":1,"1059":2,"1067":1,"1080":1,"1085":3}}],["illustrative",{"2":{"246":1}}],["il",{"2":{"372":1}}],["ignored",{"2":{"125":1,"326":1,"505":1,"565":1,"1131":1,"1264":1}}],["ignore",{"0":{"125":1},"2":{"125":3,"647":1,"726":1}}],["ignores",{"2":{"115":1,"117":1,"125":3,"363":1,"386":1,"544":1}}],["i",{"0":{"52":1,"54":1,"55":1,"1167":1},"2":{"78":1,"106":1,"191":1,"202":1,"766":1,"870":1,"1089":1,"1103":2,"1104":2,"1125":3,"1307":1,"1389":3}}],["idibus",{"2":{"1269":3,"1270":1,"1276":1,"1280":1,"1289":1,"1313":2}}],["idioms",{"2":{"911":1}}],["idiomatically",{"2":{"24":1}}],["idus",{"2":{"1269":1,"1270":2,"1310":1}}],["ids",{"2":{"723":1,"856":1,"868":1}}],["id",{"0":{"868":1},"2":{"137":1,"154":2,"326":1,"500":1,"767":1,"853":3,"854":4,"856":2,"859":1,"872":1,"880":1,"882":1,"889":1,"891":1,"898":1,"900":1,"927":2,"930":2,"932":1,"933":1,"934":2,"935":1,"939":2,"947":3,"958":2,"961":1,"974":1,"978":1,"979":1,"982":1,"986":1,"988":1,"997":1,"1004":4,"1017":2,"1186":2,"1220":2,"1270":2,"1276":1,"1280":1,"1289":1,"1303":1,"1304":2}}],["identities",{"2":{"1012":1}}],["identity",{"2":{"383":1,"514":1,"621":1,"1363":1}}],["identify",{"2":{"888":1}}],["identifiable",{"2":{"500":1,"994":1}}],["identified",{"2":{"402":1,"954":1,"1092":1}}],["identifiers",{"0":{"385":1},"2":{"326":2,"690":1,"954":1}}],["identifier",{"2":{"138":2,"296":1,"301":2,"313":1,"315":1,"385":1,"505":1,"868":1,"872":1,"876":1,"958":1,"959":1,"1008":1,"1103":1,"1104":1,"1176":1,"1186":1}}],["identification",{"2":{"402":1,"654":1,"1058":1}}],["identically",{"2":{"651":1,"739":1}}],["identical",{"2":{"402":1,"412":1,"726":1,"908":1,"1329":1}}],["idempotency",{"0":{"327":1},"2":{"747":1}}],["idempotent",{"2":{"6":1,"262":1,"327":1,"481":1}}],["ides44bce",{"2":{"1313":3}}],["idesevecharter",{"2":{"1310":2}}],["idesofmarch",{"2":{"1280":4}}],["idesmarch44",{"2":{"1273":2}}],["ides",{"2":{"326":1,"1269":4,"1270":4,"1275":1,"1276":1,"1280":1,"1299":1,"1304":1,"1307":1}}],["ideal",{"2":{"110":1,"138":1,"326":1,"915":1,"1042":1,"1433":1,"1434":1}}],["ideas",{"2":{"15":1}}],["ide",{"0":{"24":1,"25":1,"26":1,"48":1,"692":1},"1":{"25":1,"26":2,"27":2,"28":2,"29":2,"30":1,"31":1,"32":1},"2":{"24":1,"48":2,"107":1,"234":1,"267":1,"269":1,"276":1,"285":1,"326":2,"687":1,"692":1,"709":1,"724":1,"774":1,"915":1}}],["italian",{"2":{"1216":1}}],["italy",{"2":{"1216":1}}],["iterables",{"2":{"496":1}}],["iterable",{"2":{"471":1,"496":1,"910":1,"919":1}}],["iterates",{"2":{"972":1}}],["iteratively",{"2":{"993":1}}],["iterative",{"2":{"987":1}}],["iterating",{"2":{"461":1,"468":1,"985":1}}],["iterations",{"2":{"442":1,"448":1,"1120":1}}],["iteration",{"0":{"408":1,"410":1,"492":1,"985":1},"1":{"409":1,"410":1},"2":{"403":1,"452":1,"461":1,"462":1,"468":1,"471":1,"473":1,"489":2,"792":1,"985":1,"1412":1}}],["iterators",{"2":{"473":1,"488":1,"1405":1}}],["iterator",{"2":{"410":2,"468":1,"602":1,"919":1,"985":1,"986":1}}],["items",{"2":{"489":1,"695":1,"972":1,"973":3,"983":2,"1043":1}}],["item",{"2":{"28":1,"489":1,"490":3,"920":1,"972":2,"973":2}}],["itself",{"2":{"118":1,"276":1,"340":1,"388":1,"431":1,"782":1,"1270":1}}],["its",{"2":{"43":1,"71":1,"110":1,"116":1,"129":1,"138":2,"155":1,"169":1,"172":1,"196":1,"198":1,"261":1,"265":1,"285":1,"289":1,"301":1,"317":1,"327":1,"330":1,"342":1,"349":1,"361":1,"362":2,"363":1,"382":1,"387":1,"402":1,"405":1,"418":1,"421":1,"440":1,"472":1,"481":1,"501":1,"502":1,"514":2,"526":1,"562":1,"574":1,"617":1,"643":1,"702":1,"757":1,"831":1,"874":1,"942":1,"1039":1,"1045":1,"1063":1,"1064":1,"1075":1,"1077":1,"1088":1,"1090":1,"1227":2,"1276":2,"1313":1,"1366":1,"1372":1,"1421":1,"1445":1}}],["it",{"0":{"71":1,"220":1,"235":1,"399":1,"412":1,"414":1,"416":1,"418":1,"427":1},"2":{"10":1,"11":2,"16":1,"28":1,"39":3,"42":1,"43":3,"44":1,"76":1,"92":1,"97":1,"102":1,"106":1,"110":2,"111":1,"113":2,"114":2,"125":1,"129":1,"131":1,"132":1,"146":2,"157":1,"159":1,"161":3,"162":2,"165":1,"170":2,"191":1,"198":1,"199":1,"202":1,"210":1,"211":1,"215":2,"220":2,"228":1,"229":3,"230":1,"239":1,"246":1,"250":1,"262":1,"264":1,"268":2,"269":1,"270":1,"273":1,"274":2,"276":1,"282":1,"283":1,"284":1,"285":2,"291":1,"292":1,"298":4,"317":1,"319":1,"321":1,"326":3,"327":1,"331":3,"334":1,"337":1,"338":1,"341":1,"349":1,"358":2,"359":4,"360":1,"361":2,"362":4,"363":2,"364":1,"378":1,"383":2,"385":2,"386":1,"387":1,"388":1,"399":1,"402":1,"403":1,"412":1,"421":1,"426":3,"427":3,"430":1,"434":1,"449":1,"451":2,"456":2,"462":1,"467":1,"468":1,"469":1,"470":1,"471":1,"474":1,"481":1,"486":2,"488":1,"492":1,"500":1,"501":1,"502":1,"503":4,"506":1,"513":1,"514":1,"515":1,"516":1,"517":1,"518":1,"520":1,"522":2,"525":1,"527":1,"528":2,"559":1,"560":1,"571":1,"687":1,"694":1,"711":1,"747":1,"763":1,"765":1,"855":1,"857":1,"869":1,"923":1,"932":1,"946":1,"972":2,"987":1,"993":6,"1001":1,"1012":1,"1025":1,"1057":1,"1067":1,"1069":1,"1089":1,"1091":1,"1093":1,"1094":1,"1095":1,"1096":1,"1097":1,"1099":1,"1107":1,"1113":2,"1147":1,"1155":1,"1160":3,"1161":1,"1174":1,"1188":1,"1193":1,"1195":3,"1211":1,"1216":3,"1224":1,"1252":1,"1300":1,"1321":1,"1329":1,"1349":1,"1367":1,"1369":1,"1372":1,"1377":1,"1378":1,"1384":1,"1392":1,"1410":1}}],["image",{"2":{"665":1}}],["images",{"2":{"365":1}}],["immobility",{"0":{"278":1}}],["immortal",{"2":{"92":1,"95":1,"695":1,"974":1}}],["immediate",{"2":{"262":1,"418":1,"707":1,"911":1,"1042":1,"1122":1,"1218":1,"1234":1,"1438":1,"1440":1,"1441":2}}],["immediately",{"2":{"87":1,"91":1,"250":1,"315":2,"377":1,"393":2,"502":1,"856":2,"894":1,"910":1,"912":1,"932":1,"946":1,"949":1,"1134":2,"1227":2,"1233":1,"1260":1,"1270":1,"1376":1,"1404":1,"1417":1,"1435":1}}],["immutable",{"0":{"424":1,"478":1,"682":1},"1":{"425":1,"426":1,"427":1,"428":1,"429":1},"2":{"7":1,"9":1,"62":1,"69":1,"120":2,"181":1,"227":1,"233":1,"340":1,"342":1,"412":1,"424":2,"428":1,"437":1,"453":1,"464":2,"465":1,"475":1,"478":1,"522":1,"578":1,"629":1,"657":1,"902":1,"1036":1,"1106":1,"1140":1,"1164":1,"1187":1,"1276":1,"1284":1,"1318":1,"1341":1,"1382":1}}],["immutability",{"0":{"120":1,"279":1,"340":1,"629":1,"864":1,"1173":1},"2":{"7":1,"24":1,"48":1,"69":1,"181":1,"233":1,"429":1,"430":1,"431":1,"453":1,"468":1,"478":1,"580":1,"597":1,"998":1,"1173":2}}],["imp",{"2":{"1281":2}}],["impractical",{"2":{"1117":1}}],["improving",{"2":{"626":1,"642":1,"644":2,"722":1}}],["improve",{"2":{"649":1,"672":1,"954":2}}],["improved",{"0":{"676":1},"2":{"580":1,"593":1,"609":1,"610":1,"613":1,"620":1,"621":1,"633":1,"634":1,"639":1,"649":1,"661":1,"671":1,"684":1,"714":1,"747":1}}],["improves",{"2":{"562":1}}],["improvements",{"0":{"622":1,"781":1,"785":1,"791":1,"801":1,"805":1,"811":1,"815":1,"822":1,"828":1},"1":{"782":1,"786":1,"787":1,"788":1,"792":1,"793":1,"802":1,"806":1,"807":1,"808":1,"812":1,"816":1,"817":1,"818":1,"819":1,"823":1,"824":1,"825":1,"829":1,"830":1,"831":1,"832":1},"2":{"549":1}}],["imperial",{"2":{"1306":1}}],["impersonal",{"2":{"1016":1}}],["imperative",{"0":{"289":1},"2":{"541":1,"542":1,"1446":1}}],["imperatively",{"2":{"288":1}}],["impenetrable",{"2":{"717":1}}],["impose",{"2":{"755":1}}],["impossible",{"0":{"1348":1,"1354":1,"1361":1,"1363":1},"1":{"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1},"2":{"431":1,"1162":1,"1339":1,"1343":2,"1348":1,"1354":1,"1361":1,"1362":1,"1363":1}}],["imported",{"2":{"276":1,"291":2,"421":1}}],["importing",{"2":{"131":1,"197":1,"462":1,"468":1,"678":1,"915":1,"1450":1}}],["imports",{"0":{"558":1,"812":1},"2":{"10":1,"42":1,"43":1,"44":1,"85":1,"88":1,"112":1,"262":1,"274":1,"276":1,"513":1,"537":2,"559":2,"560":1,"728":3,"810":1,"812":1,"840":1,"1147":1,"1451":1}}],["importmap",{"2":{"10":1,"42":1,"43":1,"44":1,"559":3,"560":1,"651":1,"655":1,"729":1}}],["import",{"0":{"459":1,"460":1,"917":1,"1020":1,"1056":1,"1102":1,"1154":1,"1165":1,"1241":1,"1277":1,"1278":1,"1281":1,"1317":1,"1342":1,"1380":1,"1400":1,"1451":1},"1":{"1278":1},"2":{"9":1,"10":3,"38":2,"42":2,"43":8,"46":2,"78":2,"87":1,"88":1,"98":1,"102":4,"103":3,"104":3,"107":1,"109":1,"111":1,"112":3,"114":1,"119":1,"136":1,"137":1,"170":2,"205":1,"211":1,"232":1,"234":1,"236":2,"250":6,"251":5,"259":1,"260":1,"261":3,"265":2,"267":1,"268":2,"269":1,"271":6,"274":5,"276":6,"282":1,"283":2,"285":2,"286":3,"289":4,"290":2,"310":1,"311":1,"313":1,"316":1,"333":1,"334":1,"335":1,"421":1,"448":1,"459":1,"460":1,"461":1,"509":1,"536":2,"537":4,"548":2,"551":1,"552":3,"555":2,"558":2,"559":2,"560":1,"594":1,"644":1,"651":1,"678":1,"728":2,"759":1,"782":1,"812":3,"848":2,"849":1,"880":1,"889":1,"898":1,"915":3,"916":1,"917":1,"918":1,"973":1,"978":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1019":1,"1020":1,"1030":1,"1033":1,"1036":1,"1041":1,"1046":1,"1049":2,"1055":1,"1056":1,"1059":1,"1067":1,"1076":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1101":1,"1102":1,"1113":1,"1141":1,"1144":1,"1147":1,"1150":1,"1153":1,"1154":2,"1158":1,"1164":1,"1165":1,"1171":1,"1172":1,"1178":1,"1184":1,"1190":1,"1191":2,"1192":1,"1193":1,"1195":1,"1209":1,"1214":1,"1216":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1239":1,"1241":1,"1243":1,"1254":2,"1261":1,"1263":1,"1273":1,"1278":5,"1280":1,"1281":1,"1282":1,"1304":1,"1307":1,"1310":1,"1313":2,"1316":1,"1317":1,"1326":1,"1329":1,"1332":1,"1335":1,"1337":1,"1341":1,"1342":1,"1347":1,"1352":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1,"1363":1,"1364":1,"1365":1,"1366":1,"1379":1,"1380":1,"1381":2,"1389":5,"1392":1,"1399":1,"1400":1,"1408":1,"1412":1,"1422":2,"1424":1,"1429":2,"1430":1,"1433":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1,"1451":3,"1452":1}}],["important",{"2":{"6":1,"199":1,"262":1,"337":1,"516":1,"921":1,"1011":1}}],["implemented",{"2":{"410":1,"627":1,"647":1,"663":1,"667":1,"668":1,"1045":1}}],["implementing",{"2":{"407":1,"473":1,"664":1}}],["implements",{"2":{"355":1,"404":1,"422":1,"440":1,"441":1,"472":1,"475":1,"486":1,"492":1,"494":1,"985":1,"1041":1,"1126":1,"1181":1,"1226":1,"1371":1,"1373":1,"1432":1,"1435":1,"1445":1}}],["implement",{"2":{"233":1,"293":1,"322":1,"325":1,"335":1,"531":1,"771":1,"775":4,"831":1,"833":1,"978":1,"1191":1,"1256":1}}],["implementation",{"0":{"436":1,"1030":1,"1141":1,"1304":1,"1307":1,"1310":1,"1313":1,"1326":1,"1389":1},"1":{"437":1,"438":1},"2":{"232":1,"234":1,"267":1,"412":1,"414":1,"565":1,"606":1,"1452":2}}],["implementations",{"2":{"34":1,"418":1,"661":1,"1088":1}}],["implicit",{"2":{"138":1,"202":1}}],["impacts",{"2":{"283":1}}],["impact",{"0":{"443":1},"1":{"444":1,"445":1},"2":{"22":1,"442":1,"635":1,"1076":1}}],["if",{"0":{"55":1,"551":1,"552":1},"2":{"6":1,"7":1,"10":1,"20":1,"43":3,"45":1,"46":1,"55":1,"76":2,"78":1,"102":1,"109":1,"112":1,"117":1,"120":1,"124":1,"128":1,"131":1,"132":1,"136":1,"137":1,"138":1,"139":2,"144":1,"145":1,"147":1,"150":1,"154":1,"157":1,"158":2,"159":1,"161":3,"162":1,"163":1,"170":1,"173":1,"174":1,"176":2,"177":2,"178":1,"179":1,"180":1,"183":1,"188":1,"191":3,"195":1,"197":1,"198":1,"202":2,"205":1,"211":1,"214":1,"215":3,"216":1,"217":1,"219":2,"220":1,"230":1,"233":2,"234":1,"235":2,"236":1,"243":1,"248":1,"250":2,"261":1,"264":1,"266":1,"268":1,"271":2,"276":1,"280":1,"281":5,"282":1,"283":1,"285":1,"286":1,"287":1,"291":1,"292":1,"293":1,"296":1,"313":1,"315":1,"320":1,"321":2,"324":6,"326":1,"341":1,"355":1,"358":2,"359":4,"360":2,"362":2,"365":2,"367":1,"377":1,"381":1,"383":2,"385":1,"387":1,"389":1,"394":1,"399":3,"424":1,"425":1,"427":1,"437":1,"461":6,"469":1,"484":2,"486":1,"490":1,"503":3,"505":1,"506":1,"510":1,"515":5,"517":1,"519":5,"548":1,"551":1,"552":1,"555":1,"559":1,"561":1,"569":1,"573":1,"728":1,"735":1,"739":1,"752":1,"759":1,"782":1,"812":1,"853":1,"855":2,"856":2,"860":5,"865":1,"866":1,"870":1,"871":5,"872":1,"874":1,"876":1,"881":4,"889":1,"890":4,"891":1,"899":4,"909":1,"920":1,"934":1,"937":1,"938":1,"942":2,"945":1,"946":2,"947":1,"950":3,"954":1,"955":4,"962":1,"968":1,"969":1,"970":3,"972":2,"973":1,"976":1,"977":1,"978":2,"980":2,"985":1,"986":3,"992":1,"993":3,"1004":1,"1008":1,"1011":1,"1049":1,"1054":2,"1061":3,"1062":1,"1081":2,"1089":1,"1104":2,"1141":1,"1178":2,"1181":1,"1182":1,"1188":1,"1192":1,"1195":1,"1219":1,"1221":2,"1222":4,"1223":2,"1232":1,"1233":1,"1257":2,"1259":1,"1260":1,"1261":1,"1263":1,"1266":1,"1335":2,"1345":2,"1361":1,"1363":1,"1364":1,"1374":1,"1376":1,"1389":1,"1391":1,"1394":1,"1409":1,"1420":1,"1421":1,"1422":1,"1427":1,"1434":1,"1436":1,"1442":1,"1445":1,"1446":1}}],["isjobcomplete",{"2":{"1445":1}}],["isjulian",{"0":{"1288":1,"1298":1},"2":{"1304":1}}],["isinsidezone",{"2":{"1364":2}}],["isimpossibletravel",{"0":{"1361":1},"2":{"1344":1,"1348":1,"1361":2,"1363":2}}],["iscartravelimpossible",{"2":{"1361":2}}],["iscalibrated",{"0":{"1249":1}}],["isclose",{"2":{"1335":1}}],["isleapintercalation",{"2":{"1310":1}}],["isleapyear",{"0":{"1298":1}}],["islamic",{"2":{"890":1}}],["islands",{"2":{"213":1}}],["isexpired",{"2":{"1261":2}}],["isriskofbreach",{"2":{"1220":2}}],["isrejected",{"2":{"475":1,"487":1}}],["isresolved",{"2":{"475":1,"487":1}}],["isbissextile",{"0":{"1288":1},"2":{"1271":1,"1304":1,"1310":1}}],["isbusinessday",{"2":{"1195":2,"1205":2,"1209":1,"1216":1,"1221":2,"1222":1,"1223":2,"1224":2}}],["isbluehour",{"2":{"1071":2,"1084":3}}],["isdaylight",{"2":{"1072":1}}],["isdisposed",{"2":{"336":3,"831":1}}],["isgoldenhour",{"2":{"1071":2,"1084":3}}],["isatdepot",{"2":{"1364":2}}],["isanomalous",{"2":{"1363":4}}],["isarray",{"2":{"1178":1}}],["isabovehorizon",{"2":{"1062":2}}],["isactive",{"2":{"463":1}}],["iswithin",{"0":{"1334":3},"1":{"1335":3},"2":{"1335":5,"1343":1,"1344":1,"1345":1,"1364":2}}],["iswaxing",{"2":{"1059":1,"1085":2}}],["isweekend",{"2":{"71":1}}],["iskingtide",{"0":{"1077":1},"2":{"1053":1,"1055":1,"1077":2,"1083":2}}],["ismidnightsun",{"2":{"1072":2}}],["ismicromoon",{"2":{"1052":1,"1053":1,"1064":2}}],["ismonthday",{"2":{"633":1}}],["isfraud",{"2":{"1361":2}}],["isfunction",{"2":{"702":1}}],["isfinite",{"2":{"982":1,"984":1,"985":1,"986":1}}],["isfirstdayofmonth",{"2":{"283":2}}],["isfiscalyearstart",{"2":{"265":2,"266":2,"267":1,"268":1,"269":2,"270":4,"711":1,"1153":1}}],["isnearby",{"2":{"1335":2}}],["isneaptide",{"2":{"1076":1}}],["isn",{"2":{"510":1,"511":1}}],["ispolarnight",{"2":{"1072":2}}],["ispending",{"2":{"475":1,"487":1}}],["ispaststart",{"2":{"317":2}}],["ispublicholiday",{"2":{"280":1}}],["ispublic",{"2":{"280":1}}],["ist",{"2":{"296":1}}],["isholiday",{"2":{"235":1,"1209":1,"1214":2,"1216":1,"1217":1,"1223":1}}],["issanjosenearby",{"2":{"1335":2}}],["issaweekend",{"2":{"71":1}}],["isspringtide",{"2":{"1054":1,"1055":1,"1076":1,"1077":1,"1083":2}}],["issuing",{"2":{"1262":1}}],["issupermoon",{"2":{"1052":1,"1053":1,"1064":2,"1085":2}}],["issuedate",{"2":{"1307":6}}],["issues",{"2":{"21":2,"43":1,"613":1,"634":1,"709":1,"1011":1,"1265":1,"1454":1}}],["issue",{"2":{"15":1,"22":2,"229":1,"402":1,"878":2,"922":1}}],["issettled",{"2":{"487":1}}],["isusweekend",{"2":{"71":1}}],["isvalid",{"2":{"55":1,"154":1,"199":2,"360":2,"912":1,"920":1,"973":3,"1136":1,"1141":1}}],["isodate",{"2":{"1310":1}}],["isoptimalshootingcondition",{"2":{"1084":1}}],["isomorphic",{"2":{"651":1}}],["isoyear",{"0":{"189":2},"2":{"189":2}}],["isoweekday",{"2":{"1089":1}}],["isoweekyear",{"2":{"1089":1}}],["isoweek",{"0":{"188":2,"369":1},"2":{"186":1,"188":2,"369":3,"817":2,"1089":1,"1098":1}}],["iso8601",{"2":{"117":1,"137":1,"154":1,"355":1,"907":1,"937":1}}],["isolate",{"2":{"1024":1}}],["isolates",{"2":{"370":1,"1041":2,"1392":1}}],["isolated",{"2":{"116":2,"233":1,"268":1,"325":1,"330":1,"331":1,"334":1,"402":1,"468":1,"479":1,"543":1,"639":1,"643":1,"702":1,"711":1,"778":1,"833":1,"1166":1,"1192":1,"1376":2}}],["isolation",{"0":{"643":1,"1002":1,"1041":1,"1375":1},"1":{"1003":1,"1004":1,"1005":1,"1376":1},"2":{"94":1,"328":1,"370":1,"402":1,"422":1,"446":1,"631":1,"635":1,"669":1,"714":1,"866":1,"972":1,"1004":1,"1024":1,"1039":1,"1096":1,"1166":1,"1185":1,"1186":1,"1375":1,"1376":1,"1378":1,"1383":1,"1459":2}}],["iso",{"0":{"152":1,"186":1,"187":2,"188":1,"189":1,"190":1,"369":1,"768":1,"1093":1},"1":{"188":2,"189":2,"190":2},"2":{"9":1,"71":1,"96":1,"97":1,"98":1,"128":1,"130":1,"132":2,"137":8,"138":2,"142":1,"152":4,"154":2,"158":3,"159":1,"186":4,"187":1,"188":4,"189":6,"190":1,"196":1,"201":1,"202":1,"205":1,"211":1,"251":1,"295":1,"325":1,"365":1,"366":1,"367":1,"368":1,"369":3,"370":1,"375":2,"376":1,"440":1,"445":1,"450":1,"507":1,"517":3,"522":2,"524":1,"630":1,"690":1,"743":1,"763":5,"765":1,"766":2,"768":3,"771":1,"778":1,"788":1,"792":3,"798":1,"817":1,"884":1,"893":2,"895":1,"902":1,"903":1,"907":1,"910":1,"950":1,"951":1,"971":1,"972":1,"1016":1,"1068":1,"1078":2,"1088":3,"1089":2,"1093":4,"1098":2,"1110":2,"1119":1,"1125":5,"1135":1,"1139":1,"1141":4,"1160":1,"1168":1,"1329":1,"1381":1,"1389":1,"1409":1,"1424":3,"1426":1,"1435":1}}],["is",{"0":{"55":1,"71":1,"221":1,"238":1,"239":1,"909":1,"1121":1},"2":{"0":1,"3":1,"5":1,"8":1,"14":1,"23":1,"33":1,"34":1,"37":2,"38":1,"39":2,"41":1,"42":1,"43":2,"44":1,"71":2,"72":1,"76":1,"77":1,"89":1,"93":4,"94":1,"96":1,"102":3,"103":1,"106":1,"109":1,"110":2,"111":2,"112":2,"113":4,"114":4,"116":1,"118":1,"120":2,"124":2,"125":1,"128":1,"129":1,"132":1,"133":1,"135":1,"137":5,"138":4,"139":1,"140":2,"144":2,"146":1,"147":1,"148":2,"150":2,"152":4,"154":1,"157":3,"159":1,"161":1,"162":1,"164":2,"165":1,"167":2,"169":1,"173":1,"174":2,"176":1,"180":1,"181":1,"186":1,"188":1,"191":1,"196":2,"198":1,"199":2,"200":1,"202":3,"208":1,"210":1,"215":2,"216":2,"224":1,"227":2,"228":1,"232":1,"233":2,"237":1,"238":1,"239":2,"243":1,"246":1,"249":1,"250":2,"256":1,"262":4,"266":4,"269":2,"271":1,"273":4,"276":3,"281":2,"282":1,"283":1,"291":2,"292":2,"294":1,"300":5,"301":3,"312":1,"326":4,"327":1,"328":1,"335":1,"340":2,"341":1,"343":1,"346":1,"349":1,"350":1,"351":2,"352":1,"357":1,"358":1,"359":4,"360":1,"361":3,"363":1,"364":1,"365":1,"369":1,"370":1,"371":1,"376":1,"377":3,"387":1,"388":2,"390":1,"393":1,"394":2,"399":1,"402":3,"403":2,"407":4,"408":2,"409":1,"411":1,"412":2,"415":1,"416":3,"418":1,"421":2,"422":1,"424":5,"425":2,"426":1,"427":4,"429":2,"430":1,"431":2,"434":1,"437":1,"438":2,"440":2,"445":1,"447":1,"449":1,"451":3,"453":3,"456":2,"461":4,"462":1,"464":1,"465":2,"467":2,"469":1,"470":1,"471":1,"474":1,"475":1,"479":1,"480":1,"481":1,"482":1,"483":2,"484":2,"486":2,"488":1,"491":1,"494":1,"495":1,"501":1,"503":2,"504":1,"506":1,"510":1,"511":1,"512":1,"513":2,"514":2,"515":1,"516":3,"518":1,"520":1,"522":5,"525":1,"527":1,"528":2,"529":1,"534":1,"537":1,"539":1,"541":2,"550":1,"551":1,"556":1,"559":3,"572":1,"573":1,"607":1,"631":1,"645":1,"649":1,"674":1,"675":1,"680":1,"699":1,"711":1,"714":1,"716":1,"717":1,"734":1,"735":1,"738":2,"739":1,"743":1,"747":1,"748":1,"751":1,"752":1,"765":1,"768":2,"782":1,"829":1,"830":1,"835":1,"852":1,"853":1,"855":2,"856":4,"862":1,"865":1,"869":3,"870":1,"874":1,"875":1,"876":1,"886":1,"896":1,"909":1,"910":1,"912":5,"913":1,"922":2,"923":2,"925":2,"926":1,"932":1,"934":1,"936":2,"942":1,"945":1,"946":1,"948":2,"949":2,"950":2,"958":1,"960":1,"965":2,"966":1,"968":1,"972":5,"993":1,"994":1,"996":1,"997":1,"998":1,"1001":1,"1008":2,"1011":3,"1012":2,"1014":1,"1018":1,"1019":1,"1025":3,"1038":1,"1039":2,"1040":1,"1054":4,"1057":2,"1062":1,"1064":2,"1067":2,"1069":1,"1071":3,"1072":2,"1080":1,"1084":1,"1087":1,"1088":9,"1089":2,"1091":3,"1093":1,"1094":4,"1098":1,"1103":1,"1106":1,"1107":3,"1108":1,"1112":1,"1117":1,"1120":1,"1125":2,"1132":1,"1139":1,"1143":1,"1146":1,"1155":2,"1157":1,"1158":1,"1167":1,"1173":1,"1174":2,"1182":1,"1185":1,"1190":1,"1195":1,"1197":2,"1203":1,"1205":4,"1211":3,"1221":1,"1222":4,"1224":1,"1233":1,"1234":1,"1235":2,"1240":1,"1252":3,"1254":1,"1257":1,"1261":1,"1262":1,"1265":1,"1267":1,"1270":1,"1276":1,"1300":2,"1315":1,"1321":3,"1334":1,"1335":2,"1345":1,"1349":3,"1363":2,"1364":2,"1366":1,"1367":1,"1369":1,"1373":1,"1374":2,"1376":1,"1377":1,"1378":1,"1379":1,"1384":3,"1388":1,"1394":1,"1410":3,"1412":1,"1417":1,"1421":3,"1422":2,"1426":1,"1431":1,"1433":2,"1442":2,"1444":1,"1445":2,"1447":1,"1459":1}}],["inboundingbox",{"0":{"1336":3},"1":{"1337":3,"1338":3},"2":{"1337":3,"1338":1,"1343":1,"1344":1,"1345":1,"1364":2}}],["inbound",{"2":{"1139":1,"1229":1}}],["ingress",{"2":{"860":2}}],["ingestedtelemetrybatch",{"2":{"1030":2}}],["ingesting",{"2":{"947":1}}],["ingestion",{"0":{"1138":1,"1264":1},"1":{"1139":1,"1140":1,"1141":1},"2":{"28":1,"867":1,"1018":1,"1099":1,"1105":1,"1141":1,"1388":1}}],["ingests",{"2":{"416":1,"1141":1,"1329":1}}],["ingest",{"2":{"247":1,"421":1,"1329":4}}],["inadvertently",{"2":{"833":1,"995":1,"1371":1,"1442":1}}],["inaccessible",{"2":{"340":1}}],["inline",{"2":{"581":1,"709":1}}],["inleapyear",{"2":{"149":1,"818":1}}],["innovations",{"0":{"647":1}}],["innate",{"2":{"427":1}}],["inner",{"2":{"266":2}}],["inherent",{"2":{"402":1}}],["inherently",{"2":{"362":1,"451":1}}],["inherits",{"2":{"330":1,"465":1,"511":1}}],["inherited",{"2":{"109":1,"464":2,"465":1,"468":1,"833":1}}],["inheriting",{"2":{"107":1,"331":1,"643":1}}],["inheritance",{"0":{"464":1,"465":1,"541":1},"1":{"465":1,"542":1},"2":{"107":2,"109":1,"155":1,"453":1,"535":1,"540":1,"541":2,"542":1,"617":1,"825":1,"829":2,"830":1,"832":1}}],["inherit",{"2":{"102":1,"105":1,"115":1,"117":1,"158":1,"468":2}}],["industrial",{"2":{"1024":1,"1028":1,"1081":1,"1258":1}}],["industry",{"2":{"400":1,"531":1,"1088":1}}],["india",{"2":{"1097":1}}],["indicative",{"0":{"450":1},"1":{"451":1}}],["indicating",{"2":{"336":1,"1062":1,"1249":1}}],["indicates",{"2":{"886":1,"1136":1}}],["indicate",{"2":{"393":1}}],["indicators",{"2":{"1053":1,"1060":1,"1074":1}}],["indicator",{"2":{"138":1,"1125":1}}],["indices",{"2":{"326":1,"881":1,"890":1,"899":1,"1039":1}}],["individually",{"2":{"465":1,"972":2}}],["individual",{"2":{"121":1,"251":1,"292":1,"457":1,"460":1,"563":1,"564":1,"918":1,"972":1,"996":1,"1009":1,"1130":1,"1131":1,"1328":1}}],["independência",{"2":{"1217":1}}],["independence",{"2":{"1189":1,"1195":1,"1197":1,"1213":1,"1222":1}}],["independently",{"2":{"117":1,"711":1,"1054":1}}],["independent",{"2":{"116":1,"330":1,"407":1,"410":1,"479":1,"643":1,"647":1,"810":1,"812":1,"1054":1,"1255":1,"1391":1,"1428":2}}],["indefinitely",{"2":{"982":1}}],["indentation",{"2":{"91":1}}],["indexing",{"2":{"138":1,"609":1,"972":1,"1303":1}}],["indexeddb",{"2":{"472":1,"857":1,"913":1,"1005":1}}],["indexed",{"2":{"138":1,"370":1,"454":1,"512":1,"1306":1}}],["index",{"0":{"1450":1},"2":{"10":1,"26":1,"42":1,"44":4,"45":2,"48":1,"102":1,"232":1,"234":1,"285":1,"286":1,"370":2,"381":1,"457":1,"458":1,"470":1,"537":1,"724":1,"850":2,"871":1,"893":1,"964":1,"972":1,"1059":2,"1369":1,"1450":2}}],["inputbuffer",{"2":{"1039":1}}],["inputs",{"2":{"117":2,"127":2,"204":2,"209":1,"358":1,"359":1,"390":1,"391":1,"395":1,"404":1,"407":1,"416":1,"445":1,"567":3,"593":1,"616":1,"639":1,"701":1,"869":1,"875":1,"913":1,"949":1,"972":1,"973":1}}],["input",{"0":{"132":1,"363":1,"991":1,"1013":1,"1289":1,"1290":1},"2":{"97":1,"127":1,"128":1,"129":1,"198":2,"204":1,"216":1,"224":1,"228":1,"281":2,"323":2,"324":2,"337":1,"351":2,"359":1,"375":1,"377":1,"402":1,"407":2,"517":1,"602":1,"642":2,"738":1,"754":1,"806":1,"807":1,"874":1,"904":1,"919":1,"962":1,"973":1,"982":1,"997":1,"1010":1,"1021":1,"1039":1,"1040":1,"1104":6,"1167":3,"1168":2}}],["insufficient",{"2":{"1157":1}}],["insights",{"2":{"786":1,"817":1}}],["inside",{"0":{"466":1,"504":1},"2":{"64":1,"107":1,"147":1,"191":1,"221":1,"279":1,"285":1,"291":1,"326":1,"402":1,"416":1,"498":1,"572":1,"739":1,"746":1,"782":1,"839":1,"989":1,"1121":1,"1126":1,"1235":1,"1336":1,"1344":1,"1345":1,"1389":1}}],["inscriptionrecord",{"2":{"1304":2}}],["inscriptionum",{"2":{"1303":1}}],["inscription",{"0":{"766":1,"1302":1},"1":{"1303":1,"1304":1},"2":{"1304":2}}],["inspected",{"2":{"967":1}}],["inspects",{"2":{"874":1,"996":1,"1015":1,"1038":1,"1113":1,"1134":1,"1262":1}}],["inspect",{"2":{"339":1,"343":1,"349":1,"497":1,"505":1,"691":1,"786":1,"857":1,"998":2,"1011":1,"1041":2,"1113":1,"1147":1}}],["inspection",{"0":{"497":1,"691":1},"2":{"473":1,"786":1,"817":1,"998":2,"1011":1,"1035":1,"1147":1}}],["inspections",{"2":{"149":1,"869":1}}],["inspecting",{"0":{"307":1,"367":1},"2":{"371":1}}],["inspiration",{"2":{"236":1}}],["inseparable",{"2":{"526":1}}],["inserted",{"2":{"1028":1}}],["insertion",{"2":{"191":1,"1328":1}}],["inserts",{"2":{"91":1,"1042":1}}],["insensitively",{"2":{"868":1}}],["insensitive",{"2":{"188":1,"189":1,"239":1}}],["instruction",{"2":{"1369":1,"1370":1}}],["instructions",{"2":{"22":1,"27":1,"48":1}}],["instructed",{"2":{"219":1,"910":1}}],["instruct",{"2":{"30":1,"859":1}}],["instead",{"2":{"21":1,"34":1,"108":1,"117":1,"147":1,"161":1,"164":1,"166":1,"181":1,"230":1,"233":1,"276":1,"280":1,"281":1,"282":1,"296":1,"322":1,"326":1,"358":2,"388":1,"389":1,"411":1,"471":1,"541":1,"544":1,"559":1,"560":1,"580":1,"592":1,"593":1,"597":1,"707":1,"750":1,"757":2,"832":1,"836":2,"843":1,"871":1,"881":1,"890":1,"899":1,"909":1,"955":1,"972":1,"1004":1,"1090":2,"1111":1,"1412":1,"1422":1,"1428":1,"1446":1}}],["instantaneously",{"2":{"1184":1,"1234":1}}],["instantaneous",{"2":{"415":1}}],["instantiating",{"0":{"168":1},"1":{"169":1,"170":1,"171":1},"2":{"357":1,"469":1,"677":1,"910":1}}],["instantiation",{"0":{"699":1},"2":{"69":1,"120":1,"264":1,"350":1,"357":1,"373":1,"407":1,"419":1,"441":1,"442":1,"444":1,"478":1,"483":1,"699":1,"720":1,"755":1,"824":1,"838":1}}],["instantiates",{"2":{"1369":1,"1382":1}}],["instantiated",{"2":{"169":1,"170":1,"349":1,"865":1,"891":2,"894":1}}],["instantiate",{"2":{"27":1,"107":1,"119":1,"360":1,"481":1,"1193":1,"1428":1}}],["instant",{"2":{"11":1,"28":1,"81":2,"85":1,"97":1,"107":1,"132":1,"170":3,"171":1,"228":1,"269":1,"372":1,"429":1,"699":1,"787":1,"894":1,"903":1,"984":2,"1207":1,"1257":1}}],["instantly",{"2":{"9":1,"66":1,"98":1,"165":1,"268":1,"274":1,"363":1,"407":1,"442":1,"444":1,"503":1,"520":2,"716":1,"932":1,"951":1,"970":1,"972":1,"974":1}}],["instanceof",{"2":{"276":1,"653":1,"970":1,"973":1}}],["instances",{"0":{"360":1,"894":1},"2":{"7":1,"56":1,"62":1,"102":1,"109":1,"116":1,"121":1,"124":1,"132":1,"144":1,"170":1,"173":1,"181":1,"233":1,"319":1,"320":1,"340":1,"344":1,"373":1,"406":2,"412":1,"431":1,"485":1,"501":1,"541":1,"616":1,"682":1,"699":2,"702":1,"754":1,"797":1,"864":1,"879":1,"888":1,"890":1,"903":1,"910":1,"913":1,"932":1,"960":1,"973":1,"983":1,"986":2,"991":1,"998":1,"1011":1,"1022":1,"1036":5,"1042":1,"1073":1,"1080":1,"1141":1,"1161":1,"1173":1,"1187":1,"1218":1,"1258":1,"1344":2,"1360":1,"1363":1}}],["instance",{"0":{"118":1,"244":1,"349":1,"968":1,"1169":1,"1172":1,"1187":1,"1217":1,"1345":1},"1":{"350":1,"351":1,"352":1,"353":1,"354":1,"355":1},"2":{"1":1,"7":1,"27":1,"45":1,"62":1,"69":1,"87":1,"100":1,"101":1,"117":1,"118":1,"119":1,"120":4,"121":1,"125":2,"129":2,"131":1,"132":1,"133":1,"138":1,"141":1,"142":1,"143":1,"147":2,"148":1,"149":2,"150":1,"158":7,"181":2,"182":1,"183":1,"192":1,"198":1,"199":2,"203":1,"224":2,"226":1,"227":1,"231":1,"233":3,"243":1,"253":1,"255":1,"261":1,"264":1,"265":2,"266":2,"273":1,"276":1,"279":3,"280":1,"281":1,"282":2,"300":2,"301":3,"314":1,"315":1,"316":1,"321":1,"326":1,"327":3,"338":1,"342":1,"343":1,"349":1,"350":1,"353":1,"359":1,"360":1,"367":4,"368":1,"371":1,"372":1,"373":1,"385":1,"389":1,"404":1,"405":1,"406":2,"408":2,"409":3,"410":1,"411":1,"416":1,"418":1,"423":1,"427":1,"429":2,"447":1,"448":1,"466":1,"475":1,"482":1,"484":1,"501":1,"546":1,"556":1,"561":1,"637":1,"647":1,"660":1,"667":1,"684":1,"711":1,"763":1,"768":1,"771":1,"776":4,"786":1,"818":1,"891":1,"897":1,"910":1,"912":2,"919":1,"936":1,"965":1,"968":1,"973":1,"980":1,"981":1,"1013":1,"1047":2,"1055":4,"1068":1,"1078":2,"1089":1,"1104":17,"1106":1,"1118":2,"1140":2,"1167":4,"1168":1,"1169":3,"1171":1,"1172":1,"1173":3,"1181":1,"1185":1,"1187":1,"1193":1,"1214":4,"1217":1,"1245":1,"1251":2,"1284":2,"1285":1,"1289":1,"1290":1,"1318":2,"1335":1,"1337":1,"1341":1,"1345":8,"1352":1,"1357":1,"1358":1,"1360":1,"1374":2,"1381":1,"1382":1,"1389":1,"1424":1,"1427":2,"1429":1,"1435":1,"1454":3}}],["installing",{"2":{"916":1,"1117":1,"1164":1,"1341":1}}],["installed",{"2":{"559":1,"812":1}}],["installs",{"2":{"409":1,"1278":2,"1281":1,"1313":1}}],["installation",{"0":{"10":1,"33":1,"846":1,"914":1,"917":1,"1019":1,"1020":1,"1051":1,"1056":1,"1100":1,"1102":1,"1152":1,"1154":1,"1163":1,"1165":1,"1179":1,"1208":1,"1237":1,"1239":1,"1241":1,"1277":1,"1316":1,"1317":1,"1340":1,"1342":1,"1378":1,"1380":1,"1397":1,"1399":1,"1400":1},"1":{"34":1,"35":1,"36":1,"37":1,"38":1,"39":1,"40":1,"41":1,"42":1,"43":1,"44":1,"45":1,"46":1,"47":1,"48":1,"1020":1,"1101":1,"1102":1,"1278":1,"1317":1,"1379":1,"1380":1,"1381":1},"2":{"10":1,"597":1,"620":1,"640":1,"648":2,"729":1,"810":1,"1278":1}}],["install",{"0":{"812":1},"2":{"4":1,"10":1,"35":2,"38":1,"78":1,"83":1,"205":1,"232":1,"233":1,"235":1,"274":3,"285":1,"548":1,"759":2,"810":1,"812":3,"844":1,"846":2,"914":1,"917":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1019":1,"1020":1,"1051":1,"1056":1,"1100":1,"1102":1,"1122":1,"1152":1,"1154":2,"1163":1,"1165":1,"1191":1,"1192":1,"1193":1,"1195":1,"1208":1,"1209":1,"1214":1,"1216":1,"1220":1,"1222":1,"1223":1,"1237":1,"1241":1,"1243":1,"1254":1,"1277":1,"1278":1,"1280":1,"1307":1,"1310":1,"1313":1,"1316":1,"1317":1,"1340":1,"1342":1,"1363":1,"1364":1,"1365":1,"1366":1,"1378":1,"1380":1,"1397":1,"1400":1,"1408":1,"1412":1,"1424":1,"1429":1,"1430":1,"1433":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1}}],["instabilities",{"2":{"3":1}}],["invite",{"2":{"905":1}}],["invites",{"2":{"897":1}}],["invitation",{"2":{"904":1}}],["invitations",{"2":{"888":1}}],["invisible",{"2":{"403":1}}],["invoicing",{"0":{"1222":1},"2":{"1222":1}}],["invoicedate",{"2":{"1190":2}}],["invoice",{"2":{"1128":2}}],["invocation",{"2":{"907":1,"947":1}}],["invocations",{"2":{"404":1,"816":1,"1118":1}}],["involves",{"2":{"248":1}}],["invokes",{"2":{"334":1,"1373":1}}],["invoke",{"2":{"285":1,"1181":1,"1235":1}}],["invoked",{"2":{"52":1,"748":1,"1106":1,"1257":1}}],["invoking",{"2":{"97":1,"282":1,"486":1,"833":1,"1370":1}}],["invaluable",{"2":{"1315":1,"1426":1}}],["invalidhour",{"2":{"1136":2}}],["invaliddate",{"2":{"973":1}}],["invalid",{"0":{"360":1},"2":{"55":1,"117":1,"146":1,"191":1,"281":1,"300":1,"358":2,"359":2,"388":1,"407":1,"445":1,"446":1,"448":1,"517":2,"738":1,"860":1,"920":2,"955":1,"973":3,"1010":1,"1266":1}}],["invariants",{"2":{"368":1,"817":1}}],["invariance",{"0":{"186":1}}],["inventing",{"2":{"1090":1}}],["investor",{"2":{"957":1}}],["invested",{"2":{"515":1}}],["investigate",{"2":{"22":1}}],["inverter",{"0":{"1081":1},"2":{"1052":1,"1081":1}}],["inverts",{"2":{"1046":1}}],["invert",{"2":{"461":1}}],["inverse",{"2":{"501":1}}],["inverses",{"2":{"157":1}}],["inversion",{"2":{"461":1}}],["incidents",{"2":{"1219":1}}],["incidental",{"2":{"451":1}}],["increasing",{"2":{"647":1}}],["increase",{"2":{"263":1}}],["incrementing",{"2":{"469":1}}],["incredible",{"2":{"269":1}}],["incredibly",{"2":{"146":1,"164":1,"266":1,"518":1}}],["inconsistent",{"2":{"1139":1,"1387":1,"1391":1}}],["inconsistently",{"2":{"1112":1}}],["incorporating",{"2":{"1009":1}}],["incorporates",{"2":{"994":1,"1069":1}}],["incorporate",{"2":{"904":1}}],["incorrectly",{"2":{"752":1,"1223":1}}],["incorrect",{"2":{"243":1,"714":1,"976":1}}],["incoming",{"2":{"227":1,"377":1,"1028":1,"1029":1,"1140":1,"1192":1,"1193":1,"1395":1}}],["incomplete",{"2":{"34":1}}],["inclusivity",{"2":{"383":1}}],["inclusively",{"2":{"1269":1,"1270":1}}],["inclusive",{"0":{"394":1,"1270":1},"2":{"63":3,"177":1,"383":2,"394":2,"1270":1,"1276":1,"1299":1,"1404":1,"1439":1}}],["inclusion",{"2":{"229":1}}],["including",{"2":{"138":1,"155":2,"288":1,"357":1,"370":1,"409":1,"618":1,"705":1,"717":1,"829":1,"912":1,"921":1,"936":1,"1008":1,"1067":1,"1099":1,"1103":1,"1225":1,"1276":1,"1423":1}}],["included",{"2":{"46":1,"251":1,"256":1,"276":1,"484":2,"551":1,"559":1,"724":1,"1278":2}}],["includes",{"2":{"10":1,"42":1,"71":2,"92":1,"117":1,"251":2,"296":1,"305":1,"344":1,"348":1,"446":1,"461":1,"468":1,"473":1,"498":1,"678":1,"767":1,"968":1,"970":1,"1113":1,"1263":1,"1273":1}}],["include",{"0":{"22":1},"2":{"6":1,"22":1,"34":1,"249":1,"314":1,"320":1,"326":1,"365":1,"376":1,"675":1,"985":1,"1096":1,"1193":1}}],["infinity",{"2":{"982":1,"986":2}}],["infinite",{"2":{"649":1,"986":1}}],["infrastructure",{"0":{"635":1,"642":1,"921":1},"2":{"618":1,"861":1,"995":1,"1007":1,"1454":1}}],["infrastructures",{"2":{"533":1}}],["influxdb",{"0":{"1327":1},"1":{"1328":1,"1329":1},"2":{"1320":1}}],["inflexible",{"2":{"1097":1}}],["inflection",{"2":{"1095":2,"1098":1}}],["inflections",{"0":{"1095":1}}],["inflected",{"2":{"221":1,"1095":1}}],["inflating",{"2":{"34":1}}],["infers",{"2":{"824":1}}],["infer",{"2":{"361":1,"869":1,"870":1,"1067":1}}],["inferred",{"2":{"117":1,"872":4,"875":1,"919":1,"1104":2}}],["inferences",{"0":{"824":1}}],["inference",{"0":{"456":1,"869":1,"1160":1},"1":{"870":1,"871":1,"872":1,"873":1,"874":1,"875":1,"876":1,"877":1,"878":1},"2":{"89":1,"121":1,"227":1,"312":1,"709":1,"874":1,"955":1,"1166":1,"1344":1}}],["informal",{"2":{"637":1,"1013":1}}],["information",{"2":{"17":1,"398":1,"517":1,"519":1,"714":2,"954":1,"994":1,"1008":2}}],["inform",{"2":{"234":1,"267":1}}],["info",{"0":{"366":1,"367":1,"786":1,"817":1},"1":{"367":1,"368":1,"369":1,"370":1},"2":{"112":1,"117":5,"129":1,"154":2,"302":1,"365":2,"366":1,"367":12,"370":1,"440":1,"446":1,"522":1,"534":1,"571":1,"784":1,"786":7,"1011":1,"1401":1,"1405":1,"1436":2,"1438":1,"1444":1}}],["injected",{"2":{"288":1,"902":1,"921":1}}],["injects",{"2":{"138":2,"146":1,"161":1,"319":1,"363":1,"411":1}}],["injecting",{"2":{"114":1,"140":1,"147":1,"709":1,"906":1}}],["injection",{"2":{"109":1,"274":1,"503":1,"921":1}}],["inject",{"2":{"26":1,"270":1,"707":1,"716":1,"854":1}}],["introspection",{"0":{"342":1,"343":1,"349":1,"998":1},"1":{"343":1,"344":2,"345":2,"346":2,"347":2,"348":2,"349":1,"350":2,"351":2,"352":2,"353":2,"354":2,"355":2,"356":1,"357":1,"358":1,"359":1,"360":1},"2":{"342":1,"712":1,"861":1,"921":1,"936":1}}],["introduced",{"2":{"567":1,"578":1,"600":1,"606":2,"609":1,"612":1,"625":1,"630":1,"642":1,"643":1,"647":1,"659":1,"671":1,"694":1,"701":1,"704":1,"707":1,"711":2,"741":1,"829":1,"830":1,"839":1}}],["introduces",{"2":{"43":1,"106":1,"328":1,"400":1,"509":1,"535":1,"538":1,"540":1,"543":1,"549":1,"557":1,"728":1,"766":1,"771":1,"784":1,"790":1,"795":1,"804":1,"810":1,"821":1,"1109":1,"1232":1,"1387":1}}],["introduction",{"0":{"522":1}}],["introducing",{"2":{"43":1,"835":1}}],["intuition",{"2":{"158":1}}],["intuitively",{"2":{"157":1}}],["intuitive",{"2":{"145":1,"181":1,"185":1,"274":1,"305":1,"522":1,"524":1,"684":1}}],["intact",{"2":{"76":1,"331":1}}],["into",{"2":{"13":1,"26":1,"43":1,"75":1,"89":2,"90":1,"95":1,"101":1,"102":1,"104":1,"111":1,"115":1,"120":2,"129":1,"138":2,"140":1,"146":1,"155":1,"158":2,"161":2,"164":2,"165":1,"166":1,"188":1,"195":2,"222":1,"233":1,"239":1,"243":1,"246":1,"247":1,"272":1,"276":1,"297":1,"298":1,"301":1,"303":1,"306":1,"319":1,"321":1,"331":1,"357":1,"363":1,"370":2,"381":3,"386":1,"402":1,"415":1,"416":1,"417":1,"427":1,"429":1,"468":1,"469":1,"479":1,"488":1,"496":1,"500":2,"501":1,"503":1,"509":1,"514":1,"515":1,"520":1,"522":1,"525":1,"526":1,"539":1,"541":2,"547":1,"548":1,"550":1,"562":1,"563":1,"564":1,"606":1,"633":1,"635":1,"642":1,"647":1,"653":1,"657":1,"661":1,"668":1,"675":1,"680":1,"690":1,"695":1,"702":1,"704":1,"705":1,"709":1,"712":1,"716":1,"720":1,"728":1,"737":1,"738":2,"741":1,"752":1,"757":1,"759":1,"771":1,"776":1,"856":1,"871":1,"878":1,"881":1,"888":1,"890":1,"895":1,"897":1,"899":1,"902":1,"910":1,"913":1,"936":1,"960":1,"972":1,"973":1,"985":1,"995":1,"1005":1,"1011":1,"1014":2,"1022":1,"1028":1,"1033":1,"1036":1,"1039":1,"1040":2,"1042":1,"1067":1,"1091":1,"1092":1,"1097":2,"1104":3,"1106":1,"1113":1,"1121":1,"1135":2,"1141":1,"1168":1,"1203":1,"1207":1,"1215":1,"1224":1,"1234":1,"1287":1,"1289":1,"1290":1,"1292":1,"1294":1,"1295":1,"1326":1,"1328":2,"1329":1,"1339":1,"1351":1,"1366":1,"1369":1,"1415":3,"1419":1,"1451":1}}],["intloptions",{"2":{"115":1,"117":1,"606":1}}],["intl",{"0":{"146":1,"361":1,"366":1,"367":1,"371":1,"786":3,"787":1,"817":2},"1":{"362":1,"363":1,"364":1,"365":1,"366":1,"367":2,"368":2,"369":2,"370":2,"371":1,"372":2,"373":2},"2":{"12":1,"71":4,"76":4,"109":1,"115":1,"117":1,"137":7,"138":1,"146":5,"147":3,"154":4,"157":1,"159":4,"165":1,"166":1,"215":2,"220":1,"221":1,"361":4,"363":1,"364":1,"365":2,"366":2,"367":26,"370":7,"371":6,"372":7,"373":2,"507":2,"513":2,"518":1,"520":2,"522":1,"572":4,"606":1,"634":2,"704":1,"723":1,"731":2,"737":1,"744":3,"746":1,"747":1,"750":2,"752":1,"754":2,"755":2,"757":1,"784":4,"786":10,"787":4,"814":1,"817":4,"876":1,"884":1,"1094":1,"1095":1,"1098":1,"1103":1,"1161":1,"1195":1,"1205":1,"1207":1,"1214":1}}],["intel",{"2":{"419":2}}],["intellisense",{"2":{"107":1,"285":1}}],["intelligent",{"0":{"161":1,"513":1,"517":1,"987":1},"1":{"162":1,"163":1,"164":1,"988":1,"989":1,"990":1,"991":1,"992":1,"993":1},"2":{"516":1,"520":1,"606":1}}],["intelligently",{"2":{"58":1,"212":1,"272":1,"750":1,"754":1,"763":1}}],["intelligence",{"0":{"509":1,"526":1},"2":{"96":1,"123":1,"1012":1}}],["intensive",{"2":{"660":1}}],["intentional",{"2":{"326":1}}],["intentionally",{"2":{"181":1,"361":1,"402":1,"522":1,"972":1,"1450":1}}],["intent",{"2":{"204":1,"301":2,"389":1,"522":1,"993":1}}],["intended",{"2":{"111":1,"341":1,"438":1,"528":1,"594":1,"637":1}}],["integers",{"2":{"138":1,"1019":2}}],["integer",{"2":{"138":4,"150":2,"152":1,"1295":1,"1368":1,"1421":1}}],["integral",{"2":{"1082":1}}],["integrating",{"2":{"1012":1,"1242":1}}],["integrations",{"2":{"129":1,"852":2,"995":1,"1139":1,"1423":1}}],["integration",{"0":{"24":1,"48":1,"98":1,"366":1,"692":1,"775":1,"808":1,"1253":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1,"99":1,"367":1,"368":1,"369":1,"370":1,"1254":1,"1255":1,"1256":1,"1257":1},"2":{"48":1,"109":1,"574":1,"648":1,"692":1,"697":1,"759":1,"776":1,"804":1,"915":1,"1098":1,"1137":1,"1242":1,"1392":1}}],["integrate",{"2":{"737":1,"771":1,"971":1,"1004":1}}],["integrated",{"2":{"420":1,"440":1,"635":1,"659":1,"671":1,"680":1,"1080":1}}],["integrates",{"2":{"326":1,"895":1,"904":1,"1215":1}}],["integrity",{"2":{"0":1,"439":1,"657":1,"702":1,"936":1,"998":1}}],["interveningholidaysskipped",{"2":{"1221":2}}],["intervening",{"2":{"1197":1}}],["intervention",{"2":{"1134":1}}],["interval=1",{"2":{"1418":2}}],["interval=2",{"2":{"982":1,"1014":2}}],["intervaloroptions",{"0":{"1403":1},"2":{"1403":1}}],["interval",{"0":{"167":1,"168":1,"1031":1},"1":{"168":1,"169":2,"170":2,"171":2,"172":1,"173":1,"174":1,"175":1,"176":1,"177":1,"178":1,"179":1,"180":1,"1032":1,"1033":1},"2":{"102":1,"167":4,"168":1,"169":3,"170":5,"171":4,"172":1,"173":1,"175":1,"176":1,"177":2,"178":3,"179":4,"180":4,"288":2,"289":2,"290":1,"291":1,"541":1,"542":1,"699":1,"711":4,"775":1,"790":1,"816":1,"882":1,"891":2,"894":1,"910":2,"920":1,"991":2,"992":3,"993":2,"1078":1,"1240":1,"1267":1,"1315":2,"1318":1,"1319":6,"1329":1,"1373":1,"1379":2,"1380":1,"1382":1,"1389":1,"1403":1,"1404":6,"1405":1,"1412":2,"1417":1,"1421":1,"1426":3,"1427":2,"1436":1,"1446":1}}],["intervals",{"0":{"886":1,"1411":1,"1412":1,"1414":1},"1":{"1412":1,"1413":2,"1414":1,"1415":2,"1416":1,"1417":1,"1418":1,"1419":1,"1420":1,"1421":1,"1422":1},"2":{"77":1,"176":1,"179":1,"180":1,"326":1,"775":1,"910":1,"920":1,"987":1,"989":1,"991":1,"992":1,"1023":1,"1081":1,"1083":1,"1242":1,"1253":1,"1316":1,"1325":1,"1331":1,"1401":1,"1412":2,"1443":2,"1444":1,"1446":1}}],["internet",{"2":{"1045":1,"1085":1}}],["interning",{"0":{"798":1}}],["internationalization",{"0":{"212":1,"361":1,"572":1,"1161":1},"1":{"213":1,"214":1,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1,"362":1,"363":1,"364":1,"365":1,"366":1,"367":1,"368":1,"369":1,"370":1,"371":1,"372":1,"373":1},"2":{"76":1,"109":2,"115":1,"117":1,"154":1,"361":1,"371":1,"751":1,"754":1,"787":1,"1166":1,"1214":1}}],["internationalized",{"0":{"219":1},"1":{"220":1,"221":1},"2":{"59":1,"109":1,"363":1}}],["international",{"2":{"71":1,"363":1,"1093":2,"1161":1,"1190":1}}],["internalnamespace",{"2":{"272":1}}],["internaltools",{"2":{"271":4}}],["internally",{"2":{"125":1,"129":1,"329":1,"466":2,"471":1,"478":1,"479":2,"504":1,"738":1}}],["internal",{"0":{"297":1,"405":1,"420":1,"434":1,"644":1,"712":1,"717":1,"724":1,"726":1,"738":1,"744":1,"748":1,"752":1,"755":1,"760":1,"993":1},"1":{"298":1,"421":1,"422":1},"2":{"7":3,"43":2,"44":1,"77":1,"110":1,"115":1,"125":1,"129":1,"138":1,"155":1,"232":1,"251":1,"261":1,"271":2,"272":1,"274":1,"294":1,"295":1,"297":1,"298":1,"315":1,"317":1,"326":1,"330":1,"336":1,"340":1,"349":1,"362":1,"371":1,"402":4,"405":1,"408":1,"414":1,"421":1,"427":2,"430":2,"439":1,"440":1,"449":1,"457":1,"495":1,"504":1,"513":1,"527":1,"559":2,"560":2,"571":1,"606":1,"616":1,"617":3,"626":1,"633":2,"642":1,"644":3,"649":1,"651":1,"653":1,"661":1,"667":1,"668":1,"676":1,"699":1,"702":2,"717":1,"728":1,"732":1,"738":1,"752":2,"755":1,"760":1,"766":1,"768":1,"782":1,"831":1,"840":1,"856":1,"932":2,"958":2,"983":1,"1120":1,"1168":1,"1175":1,"1191":4,"1254":1,"1263":1,"1309":1,"1369":1,"1445":1,"1454":1}}],["intercalary",{"2":{"1271":1}}],["intercalation",{"0":{"1271":1},"2":{"1271":1,"1299":1,"1314":1}}],["interception",{"2":{"1262":2}}],["interceptfetch",{"0":{"1262":1},"1":{"1263":1,"1264":1},"2":{"1239":1,"1240":2,"1242":1,"1263":6}}],["intercept",{"2":{"938":1}}],["intercepts",{"2":{"169":1,"773":1,"998":1}}],["interchangeably",{"2":{"750":1}}],["interim",{"2":{"514":1}}],["interact",{"2":{"994":1}}],["interacts",{"2":{"414":1}}],["interacting",{"2":{"367":1}}],["interactive",{"0":{"83":1,"84":1,"1124":1,"1243":1,"1323":1},"1":{"84":1,"85":1,"86":1,"87":1,"88":1,"89":1,"90":1,"91":1,"1324":1,"1325":1,"1326":1},"2":{"6":1,"13":1,"648":1,"671":1,"780":1,"810":1,"867":1,"921":1,"949":1,"1314":1,"1320":1,"1378":1}}],["inter",{"2":{"402":1,"1367":1,"1377":1,"1387":1,"1392":1}}],["interpolators",{"2":{"1106":1}}],["interpolation",{"2":{"927":1,"1103":1}}],["interpolations",{"2":{"357":1}}],["interpolate",{"2":{"823":1}}],["interpreter",{"2":{"647":1}}],["interpreted",{"2":{"208":1,"243":1,"351":1}}],["interprets",{"2":{"361":1}}],["interpretation",{"2":{"359":1,"561":1,"637":1}}],["interpret",{"2":{"132":1,"196":1,"201":1,"206":1,"525":1,"668":1}}],["intermediate",{"2":{"357":1,"408":1,"1076":1,"1116":1,"1121":1,"1150":1}}],["interruption",{"2":{"325":1}}],["interleaving",{"2":{"270":1}}],["intersection",{"0":{"179":1},"2":{"179":1,"699":1,"711":1}}],["interface",{"0":{"938":1,"986":1,"990":1,"1176":1},"2":{"119":1,"234":2,"261":1,"263":1,"267":1,"276":3,"280":1,"285":1,"326":4,"486":1,"546":1,"606":1,"617":2,"872":1,"882":1,"891":2,"900":1,"938":1,"986":1,"990":1,"992":1,"1015":1,"1030":1,"1176":1,"1191":1,"1220":1,"1304":1,"1307":1,"1326":1,"1329":1,"1363":1,"1411":1,"1427":1,"1446":1,"1449":1,"1452":2}}],["interfaces",{"2":{"29":1,"204":1,"276":1,"535":1,"1259":1,"1322":1}}],["interoperability",{"0":{"79":1,"903":1},"1":{"80":1,"81":1,"82":1},"2":{"50":1,"1086":1,"1103":1}}],["interested",{"2":{"851":1}}],["interest",{"2":{"0":1}}],["initiating",{"2":{"871":1}}],["initiates",{"2":{"934":1}}],["initiate",{"2":{"871":1,"881":1,"899":1}}],["initialbearingdeg",{"2":{"1365":4}}],["initially",{"2":{"412":1}}],["initial",{"2":{"250":1,"262":1,"276":1,"345":1,"352":1,"426":1,"428":1,"574":2,"659":1,"983":1,"997":1,"1243":1,"1254":1,"1344":1,"1345":1,"1358":2,"1362":1,"1365":1,"1404":1}}],["initializing",{"0":{"1379":1},"1":{"1380":1},"2":{"812":1,"1004":1}}],["initialization",{"0":{"116":1,"124":1,"848":1,"924":1},"1":{"117":1,"925":1,"926":1,"927":1,"928":1,"929":1,"930":1,"931":1,"932":1,"933":1,"934":1,"935":1,"936":1,"937":1,"938":1},"2":{"101":1,"102":1,"111":1,"117":1,"134":1,"262":1,"276":1,"331":1,"373":1,"446":1,"451":1,"538":1,"548":1,"588":1,"690":1,"695":1,"738":1,"759":1,"760":1,"782":1,"839":1,"848":1,"939":1,"1041":1,"1370":1,"1376":1,"1422":1}}],["initialized",{"2":{"124":1,"264":1,"408":1,"974":1,"1036":1}}],["initialize",{"2":{"56":1,"110":1,"119":1,"300":1,"317":1,"360":1,"361":1,"371":1,"429":1,"880":1,"889":1,"898":1,"918":1,"930":1,"933":1,"954":1,"961":1,"982":1,"988":1,"1017":1,"1220":1,"1363":1}}],["initializes",{"2":{"52":1,"408":1,"856":1,"932":1,"1382":1}}],["initaitempo",{"2":{"919":1}}],["initai",{"0":{"924":1,"958":1},"1":{"925":1,"926":1,"927":1,"928":1,"929":1,"930":1,"931":1,"932":1,"933":1,"934":1,"935":1,"936":1,"937":1,"938":1},"2":{"95":1,"98":2,"99":1,"853":4,"856":5,"859":3,"868":1,"870":1,"880":2,"889":2,"898":2,"915":1,"918":2,"924":1,"925":1,"926":1,"929":3,"930":2,"931":2,"932":3,"933":2,"934":1,"936":1,"939":2,"946":1,"947":1,"953":4,"954":2,"955":2,"958":2,"961":2,"974":2,"978":2,"979":1,"982":2,"988":2,"996":1,"997":2,"1008":2}}],["init",{"0":{"116":1,"290":1},"1":{"117":1},"2":{"9":1,"30":1,"31":1,"32":1,"43":1,"56":1,"76":1,"89":1,"94":2,"95":3,"99":1,"101":1,"102":2,"104":2,"110":1,"111":3,"116":4,"119":2,"121":2,"123":1,"125":3,"127":1,"128":1,"129":1,"134":1,"137":1,"145":1,"147":1,"166":2,"199":1,"203":1,"214":1,"218":1,"219":1,"222":1,"223":1,"225":1,"243":5,"247":1,"250":1,"262":4,"276":4,"290":2,"291":1,"295":1,"315":1,"317":2,"329":1,"331":1,"345":1,"357":1,"363":1,"368":1,"375":1,"402":1,"448":1,"485":3,"536":1,"541":1,"542":1,"545":2,"548":1,"606":1,"694":1,"695":1,"702":1,"731":1,"737":1,"738":1,"747":1,"748":1,"754":1,"759":1,"760":1,"776":1,"816":1,"833":1,"848":2,"916":1,"919":1,"1017":1}}],["in",{"0":{"53":1,"72":1,"136":1,"211":1,"242":1,"272":1,"311":1,"317":1,"361":1,"368":1,"555":1,"774":1,"823":1,"864":1,"960":1,"973":1,"1003":1,"1114":1,"1117":1,"1118":1,"1134":1,"1182":1,"1213":1},"1":{"362":1,"363":1,"364":1,"365":1,"366":1,"367":1,"368":1,"369":1,"370":1,"371":1,"372":1,"373":1,"961":1,"962":1,"963":1,"964":1,"965":1,"1118":1,"1119":1},"2":{"0":1,"7":1,"10":3,"15":1,"26":1,"27":2,"28":3,"34":1,"37":1,"42":2,"43":3,"46":2,"47":1,"54":1,"71":3,"75":2,"78":1,"83":2,"84":1,"88":1,"89":2,"90":2,"93":1,"94":1,"98":4,"100":1,"101":1,"102":4,"107":1,"109":1,"110":1,"111":1,"112":2,"114":2,"117":1,"119":2,"120":1,"121":1,"124":1,"125":1,"128":2,"131":1,"132":1,"135":2,"137":4,"138":6,"139":1,"142":1,"147":1,"150":4,"152":1,"154":1,"157":3,"161":1,"164":1,"167":2,"170":1,"177":1,"181":1,"186":2,"188":1,"191":5,"192":1,"195":1,"201":1,"202":1,"203":6,"205":1,"206":1,"210":2,"213":1,"219":5,"221":1,"222":2,"226":1,"228":2,"229":2,"233":1,"234":1,"235":3,"240":1,"243":3,"247":1,"250":1,"256":2,"258":1,"261":2,"262":4,"264":1,"266":1,"273":1,"276":2,"281":1,"283":1,"286":1,"289":1,"290":1,"291":3,"292":2,"296":1,"298":1,"308":3,"309":1,"314":1,"315":3,"317":1,"320":1,"321":1,"322":2,"326":2,"328":1,"331":1,"335":1,"336":1,"337":1,"338":1,"340":1,"351":1,"355":3,"357":2,"358":2,"359":1,"362":1,"363":2,"365":2,"366":2,"367":1,"370":14,"371":2,"380":1,"381":1,"382":1,"385":1,"388":1,"389":2,"393":3,"400":1,"402":2,"404":2,"407":1,"408":1,"409":1,"410":1,"418":1,"422":1,"425":1,"426":2,"427":2,"430":1,"437":1,"439":1,"441":1,"444":1,"447":2,"449":1,"450":1,"451":3,"453":1,"456":2,"457":2,"461":1,"467":1,"468":1,"477":2,"479":1,"484":2,"489":1,"502":1,"503":2,"505":1,"507":1,"510":1,"513":3,"514":1,"515":3,"516":1,"519":1,"520":1,"525":1,"534":1,"536":1,"537":1,"539":1,"541":2,"543":1,"546":1,"548":1,"552":1,"554":1,"556":1,"559":1,"560":2,"565":3,"572":1,"573":1,"585":1,"607":1,"617":3,"622":1,"626":1,"627":1,"631":2,"633":1,"634":2,"637":1,"639":1,"647":1,"653":2,"654":1,"657":1,"664":1,"665":1,"667":2,"669":1,"680":3,"684":1,"696":1,"702":3,"708":1,"709":2,"714":1,"724":2,"726":1,"732":1,"734":1,"737":1,"738":1,"741":1,"744":1,"747":1,"748":2,"752":5,"754":1,"757":1,"760":1,"767":1,"768":2,"773":1,"778":2,"790":1,"798":1,"800":1,"812":1,"817":4,"829":2,"830":1,"836":1,"844":1,"850":1,"851":1,"855":2,"856":2,"857":2,"859":1,"861":1,"862":1,"863":1,"864":1,"869":2,"870":2,"871":5,"874":1,"875":1,"877":1,"878":2,"879":1,"880":1,"881":1,"884":4,"889":1,"890":1,"895":1,"898":2,"899":1,"902":1,"904":1,"906":1,"909":2,"910":1,"912":2,"913":2,"918":1,"919":1,"920":3,"921":1,"925":3,"926":2,"930":1,"933":1,"934":2,"936":2,"937":4,"938":4,"942":3,"945":2,"946":2,"947":1,"948":2,"950":2,"951":1,"954":4,"955":1,"957":2,"958":1,"959":1,"961":1,"964":1,"967":1,"970":1,"972":1,"973":1,"974":1,"976":1,"978":1,"980":1,"982":1,"992":1,"996":2,"997":3,"998":3,"1004":6,"1005":1,"1008":3,"1009":1,"1011":3,"1012":2,"1013":2,"1016":3,"1017":2,"1029":1,"1030":1,"1032":1,"1033":1,"1039":3,"1040":1,"1041":1,"1044":1,"1045":1,"1053":1,"1054":2,"1058":1,"1062":3,"1063":2,"1064":2,"1066":1,"1070":1,"1071":4,"1072":1,"1074":1,"1075":1,"1078":1,"1081":1,"1086":1,"1088":7,"1089":4,"1090":1,"1091":4,"1093":7,"1095":1,"1096":2,"1097":3,"1098":1,"1099":1,"1103":2,"1104":2,"1106":1,"1110":3,"1111":1,"1113":1,"1114":1,"1115":1,"1116":1,"1117":1,"1118":1,"1125":5,"1127":1,"1128":1,"1130":1,"1131":2,"1132":2,"1134":1,"1135":1,"1136":1,"1137":1,"1139":1,"1147":1,"1149":2,"1150":1,"1156":1,"1157":2,"1158":2,"1168":1,"1172":1,"1173":1,"1176":1,"1181":1,"1182":1,"1185":2,"1188":2,"1189":1,"1190":3,"1191":4,"1192":3,"1193":1,"1195":3,"1203":1,"1205":3,"1207":3,"1210":1,"1213":3,"1215":3,"1219":3,"1221":2,"1223":1,"1224":2,"1225":1,"1233":1,"1235":1,"1240":1,"1247":1,"1255":1,"1258":1,"1259":1,"1267":1,"1269":8,"1270":3,"1271":1,"1273":4,"1276":1,"1278":1,"1280":1,"1286":1,"1301":1,"1303":1,"1310":1,"1319":1,"1324":1,"1329":1,"1331":1,"1333":1,"1338":1,"1344":1,"1350":1,"1352":3,"1354":1,"1360":2,"1361":1,"1362":1,"1363":3,"1366":3,"1368":3,"1369":1,"1370":3,"1371":1,"1376":2,"1377":1,"1378":2,"1379":1,"1382":3,"1387":2,"1388":1,"1391":1,"1392":1,"1394":2,"1395":1,"1404":1,"1414":1,"1420":1,"1421":1,"1429":1,"1437":1,"1441":1,"1442":3,"1443":1,"1444":1,"1445":2,"1446":1,"1447":1,"1449":1,"1450":1,"1451":1,"1452":2,"1459":4}}],["tlondon",{"2":{"1358":2}}],["tls",{"0":{"862":1,"1000":1},"2":{"862":3,"921":1,"1000":3}}],["t=0",{"2":{"1234":1}}],["t0=",{"2":{"1266":1}}],["t0",{"2":{"1227":2}}],["t+1",{"2":{"1221":1}}],["t+2",{"0":{"1221":1},"2":{"1210":1,"1221":3}}],["tt",{"2":{"1125":1}}],["ttlms",{"2":{"978":3}}],["ttl",{"0":{"979":1},"2":{"92":1,"94":4,"687":1,"694":3,"695":1,"863":1,"871":1,"881":1,"890":1,"895":1,"899":1,"904":1,"937":1,"938":1,"974":1,"978":6,"979":7,"1008":3,"1009":1,"1166":1,"1168":2,"1183":1,"1192":2,"1207":1,"1215":1}}],["tx",{"2":{"1065":1}}],["txt",{"0":{"24":1,"48":1,"692":1},"1":{"25":1,"26":1,"27":1,"28":1,"29":1,"30":1,"31":1,"32":1},"2":{"24":1,"26":1,"27":2,"28":1,"29":1,"31":1,"48":1,"247":4,"692":2}}],["tgt",{"2":{"437":5}}],["twilight",{"0":{"1073":1},"2":{"1050":1,"1052":1,"1053":3,"1066":1,"1067":10,"1070":1,"1071":1,"1072":3,"1073":1,"1080":1,"1082":2,"1084":1,"1353":1}}],["twice",{"2":{"261":1}}],["two",{"0":{"99":1,"915":1},"1":{"916":1,"917":1,"918":1},"2":{"12":1,"83":1,"117":1,"156":1,"157":1,"161":1,"167":1,"176":1,"179":1,"180":1,"191":1,"193":1,"219":1,"240":1,"273":1,"283":1,"301":1,"324":2,"384":1,"396":1,"397":2,"402":1,"405":1,"407":1,"431":1,"476":1,"520":1,"556":1,"684":1,"734":1,"879":1,"915":1,"951":1,"957":1,"967":1,"1039":1,"1095":1,"1112":1,"1127":1,"1201":1,"1203":1,"1273":1,"1334":1,"1344":4,"1355":1,"1359":1,"1360":1,"1366":1,"1382":1}}],["t3",{"2":{"217":1,"1141":2}}],["tnogeo",{"2":{"144":2}}],["tz",{"2":{"137":1,"138":20,"154":1,"191":2,"214":4,"224":1,"240":1,"247":1,"477":2,"723":1,"788":1,"907":1,"1114":1,"1125":4,"1158":1}}],["tm",{"2":{"127":1,"128":1,"214":2,"240":1,"241":1,"339":1}}],["tuser",{"2":{"1335":2}}],["tumbling",{"2":{"1328":1,"1329":1}}],["tullius",{"2":{"1313":1}}],["tullio",{"2":{"1292":1,"1313":1}}],["turtle",{"2":{"1085":1}}],["turbine",{"2":{"1030":1}}],["turns",{"2":{"525":1}}],["turnover",{"2":{"336":1}}],["tune",{"2":{"1008":2}}],["tuples",{"2":{"991":1,"1168":1}}],["tuple",{"2":{"285":1,"288":1,"289":1,"290":1,"816":1}}],["tue",{"2":{"231":1,"240":1,"363":1,"393":1,"454":2,"461":1,"1199":1,"1209":1}}],["tuesday",{"2":{"98":2,"99":1,"211":1,"393":1,"888":1,"906":1,"908":1,"911":1,"916":1,"917":1,"918":1,"934":1,"935":1,"951":1,"961":1,"976":1,"981":1,"1014":1,"1203":2,"1209":1,"1221":1}}],["tutorials",{"2":{"13":1,"953":1}}],["typos",{"2":{"1098":1}}],["typo",{"2":{"1088":1}}],["typographically",{"2":{"707":1}}],["typographical",{"2":{"707":1}}],["typical",{"2":{"439":1,"867":1}}],["typically",{"2":{"300":1,"391":1,"464":1,"469":1,"1008":1,"1351":1}}],["typings",{"2":{"709":1,"724":1}}],["typing",{"2":{"76":1,"170":2,"456":1,"469":3,"471":1,"580":1,"687":1}}],["typeahead",{"2":{"867":1,"949":1}}],["typeerror",{"2":{"503":1,"782":1}}],["typedoc",{"2":{"671":1}}],["typed",{"2":{"367":1,"466":1,"489":1,"571":1,"865":1,"910":1,"920":1,"936":1,"973":1,"1010":1,"1013":1,"1039":1,"1369":1}}],["types",{"0":{"132":1},"2":{"157":1,"161":1,"170":1,"206":1,"220":1,"266":1,"276":2,"326":1,"404":1,"456":2,"472":3,"477":1,"498":1,"500":1,"502":1,"503":2,"505":2,"522":1,"524":1,"546":1,"607":1,"616":1,"617":1,"724":1,"728":1,"790":1}}],["typescriptfunction",{"2":{"1114":1}}],["typescriptawait",{"2":{"932":1,"947":1}}],["typescriptasync",{"2":{"492":1,"1409":1}}],["typescriptconsole",{"2":{"497":1,"965":1}}],["typescriptconst",{"2":{"52":1,"53":1,"54":1,"55":1,"58":1,"62":1,"64":1,"65":1,"66":1,"68":1,"71":1,"72":1,"73":1,"75":1,"76":1,"80":1,"81":1,"82":1,"95":1,"140":1,"144":1,"146":1,"149":1,"171":1,"176":1,"177":1,"178":1,"179":1,"180":1,"182":1,"186":1,"191":1,"192":1,"215":1,"226":1,"231":1,"244":1,"336":1,"339":1,"357":1,"360":1,"367":1,"372":1,"482":1,"483":1,"493":1,"543":1,"695":1,"734":1,"768":1,"774":1,"786":1,"797":1,"806":3,"807":1,"875":1,"877":1,"887":1,"894":1,"895":1,"896":1,"904":1,"905":1,"912":1,"945":1,"946":1,"948":1,"949":1,"962":1,"964":1,"968":1,"974":1,"977":1,"983":1,"984":1,"985":1,"998":1,"1039":1,"1041":1,"1047":1,"1048":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1068":1,"1069":1,"1071":1,"1073":1,"1078":1,"1118":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1136":1,"1180":1,"1187":1,"1188":1,"1199":1,"1201":1,"1217":1,"1271":1,"1338":1,"1348":1,"1435":1,"1436":1}}],["typescriptpledge",{"2":{"485":2}}],["typescriptplugins",{"2":{"285":1}}],["typescriptdeclare",{"2":{"276":1,"1452":1}}],["typescriptinterface",{"2":{"1248":1,"1336":1}}],["typescriptinitai",{"2":{"854":1,"856":1,"935":1,"1004":3}}],["typescriptif",{"2":{"1077":1,"1372":1}}],["typescriptisfiscalyearstart",{"2":{"266":1}}],["typescriptimport",{"2":{"32":1,"69":1,"94":1,"98":1,"119":1,"131":1,"133":1,"136":1,"137":1,"169":1,"170":1,"197":1,"200":1,"205":1,"211":1,"236":1,"251":1,"258":1,"259":1,"260":1,"261":1,"268":1,"276":1,"282":1,"289":1,"290":1,"309":1,"310":1,"311":1,"322":1,"324":1,"333":1,"334":1,"335":1,"363":1,"448":1,"458":1,"459":1,"460":1,"461":1,"463":1,"464":1,"477":1,"481":1,"489":1,"500":1,"501":1,"502":1,"687":1,"765":1,"792":1,"793":1,"812":1,"853":1,"859":1,"870":1,"878":1,"880":1,"885":1,"889":1,"898":1,"903":1,"916":1,"917":1,"918":1,"925":1,"929":1,"930":1,"931":1,"933":1,"939":1,"954":1,"955":1,"957":1,"958":1,"961":1,"969":1,"970":1,"976":1,"978":1,"982":1,"988":1,"997":1,"1013":1,"1014":1,"1015":1,"1016":1,"1017":1,"1019":1,"1020":1,"1030":1,"1033":1,"1036":1,"1046":1,"1049":1,"1055":1,"1056":1,"1059":1,"1067":1,"1076":1,"1081":1,"1082":1,"1083":1,"1084":1,"1085":1,"1101":1,"1102":1,"1113":1,"1141":1,"1144":1,"1147":1,"1150":1,"1153":1,"1154":1,"1158":1,"1160":1,"1164":1,"1165":1,"1171":1,"1172":1,"1178":1,"1184":1,"1190":1,"1191":1,"1192":1,"1193":1,"1195":1,"1209":1,"1214":1,"1216":1,"1220":1,"1221":1,"1222":1,"1223":1,"1224":1,"1239":1,"1241":1,"1243":1,"1254":1,"1255":1,"1261":1,"1263":1,"1265":1,"1266":1,"1273":1,"1280":1,"1281":1,"1282":1,"1304":1,"1307":1,"1310":1,"1313":1,"1316":1,"1317":1,"1326":1,"1329":1,"1332":1,"1335":1,"1337":1,"1341":1,"1342":1,"1347":1,"1352":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1,"1363":1,"1364":1,"1365":1,"1366":1,"1379":1,"1380":1,"1392":1,"1395":1,"1399":1,"1400":1,"1408":1,"1412":1,"1422":1,"1424":1,"1426":1,"1429":1,"1430":1,"1433":1,"1444":1,"1445":1,"1446":1,"1447":1,"1448":1}}],["typescriptexport",{"2":{"233":1,"235":1,"437":1,"438":1,"454":1,"455":1,"456":1,"872":1,"882":1,"891":1,"900":1,"938":1,"986":1,"990":1,"991":1,"992":1,"1176":1,"1427":1}}],["typescriptusing",{"2":{"1439":1}}],["typescriptus",{"2":{"186":1}}],["typescriptt1",{"2":{"775":1}}],["typescriptt",{"2":{"139":1,"183":2,"184":1,"185":1,"186":1,"188":1,"189":1,"190":2,"194":1,"195":1,"369":1,"732":1,"823":1,"1091":1}}],["typescripttempo",{"2":{"56":1,"76":1,"134":1,"145":1,"147":1,"214":1,"218":1,"219":1,"222":1,"223":1,"225":1,"243":1,"291":1,"694":1,"731":1,"737":1,"816":1,"1179":1,"1452":1}}],["typescriptnew",{"2":{"59":1,"60":1,"394":1,"689":1,"766":1}}],["typescript",{"0":{"234":1,"267":1,"276":1,"467":1,"938":1},"1":{"468":1,"469":1},"2":{"5":1,"63":1,"71":1,"77":1,"78":1,"83":2,"84":1,"90":1,"102":1,"103":1,"104":1,"107":1,"121":1,"143":1,"146":1,"191":1,"203":1,"205":1,"207":1,"217":1,"232":1,"234":3,"243":1,"246":1,"261":2,"265":1,"267":2,"270":1,"271":2,"274":1,"281":1,"283":1,"285":1,"286":1,"332":1,"335":1,"358":1,"367":1,"368":1,"452":1,"456":2,"467":1,"468":2,"469":3,"471":1,"477":1,"478":1,"484":1,"486":1,"490":1,"491":1,"494":1,"496":1,"536":1,"537":1,"543":1,"582":1,"590":1,"618":1,"649":1,"719":1,"724":1,"728":1,"735":1,"787":1,"831":1,"839":1,"856":1,"860":1,"908":1,"934":1,"950":1,"955":1,"973":1,"975":1,"983":1,"1065":1,"1070":1,"1072":1,"1115":1,"1116":1,"1119":1,"1159":1,"1181":1,"1186":1,"1197":1,"1203":1,"1204":1,"1205":1,"1256":1,"1260":1,"1264":1,"1373":2,"1381":1,"1389":2,"1415":1,"1417":1,"1418":1,"1419":1,"1420":1,"1421":1,"1432":1,"1434":1,"1438":1,"1441":1,"1445":1,"1449":1,"1451":1,"1452":1}}],["typeof",{"2":{"34":1,"332":3,"456":2,"860":2,"1191":2,"1365":2,"1372":1}}],["type",{"0":{"276":1,"456":1,"546":1,"617":1,"644":1,"649":1,"793":1},"2":{"26":1,"107":1,"115":1,"117":1,"149":1,"150":1,"151":1,"152":1,"153":1,"154":1,"155":1,"167":1,"199":1,"204":1,"232":1,"235":1,"265":1,"271":1,"276":1,"285":2,"298":1,"312":1,"313":1,"322":2,"326":1,"339":1,"351":2,"367":1,"402":1,"418":1,"456":7,"461":1,"466":1,"469":2,"471":1,"546":2,"589":1,"617":4,"649":2,"687":1,"709":1,"712":1,"769":1,"774":1,"790":1,"860":4,"871":1,"872":1,"881":1,"889":1,"890":1,"891":1,"899":1,"910":1,"920":1,"937":1,"955":1,"959":1,"978":1,"989":1,"991":1,"1022":1,"1042":1,"1071":1,"1078":1,"1178":1,"1191":1,"1222":1,"1232":1,"1240":1,"1403":1,"1404":1,"1405":1,"1406":1,"1444":1}}],["type=",{"2":{"10":2,"42":2,"43":2,"44":1}}],["t2",{"2":{"62":1,"98":1,"191":1,"205":1,"223":1,"323":2,"333":1,"520":2,"773":2,"774":2,"775":2,"806":1,"1119":3,"1141":2,"1195":2}}],["t1",{"0":{"1229":1},"2":{"62":2,"98":1,"223":1,"323":2,"333":1,"773":2,"774":2,"775":1,"1119":2,"1141":2,"1195":2,"1227":2}}],["tromsø",{"2":{"1072":2}}],["tropical",{"2":{"1063":1}}],["troubleshoot",{"2":{"1011":1}}],["troubleshooting",{"2":{"661":1}}],["try",{"2":{"216":1,"404":1,"425":1,"616":1,"831":1,"860":1,"955":1,"970":1,"1139":1,"1441":2,"1444":1}}],["trigonometry",{"2":{"1362":1}}],["trigonometric",{"2":{"1353":1}}],["triggerdailyopeningauction",{"2":{"1447":1}}],["triggering",{"2":{"802":1,"1362":1}}],["trigger",{"2":{"300":1,"323":1,"409":1,"429":1,"486":1,"738":1,"1010":1,"1255":2,"1364":1,"1436":1}}],["triggers",{"2":{"98":1,"124":1,"276":1,"421":1,"446":1,"767":1,"865":1,"1405":1}}],["triggered",{"2":{"93":1,"409":1,"483":3,"1421":1,"1425":1}}],["trivial",{"2":{"1137":1}}],["trivia",{"2":{"1095":1}}],["trial",{"0":{"954":1,"1006":1,"1008":1},"1":{"1007":1,"1008":1,"1009":1},"2":{"918":1,"929":1,"954":6,"1008":6}}],["trimmed",{"2":{"705":1}}],["trips",{"2":{"1225":1,"1276":1}}],["tripping",{"2":{"763":1}}],["trip",{"0":{"765":1,"1228":1},"2":{"204":1,"763":1,"1135":1,"1240":1,"1242":1,"1246":1}}],["trajectories",{"2":{"1391":1}}],["trajectory",{"2":{"1353":1}}],["trajano",{"2":{"1281":2}}],["trajanyear",{"2":{"1281":3}}],["travail",{"2":{"1213":1}}],["travel",{"0":{"1348":1,"1354":1,"1361":1,"1363":1},"1":{"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1},"2":{"1162":1,"1258":1,"1339":1,"1343":2,"1344":2,"1345":1,"1348":1,"1354":1,"1360":1,"1361":1,"1362":1,"1363":2}}],["travels",{"2":{"1157":1}}],["traversal",{"2":{"318":1,"429":1,"465":1,"664":1}}],["traversals",{"0":{"321":1},"2":{"313":1,"649":1}}],["traverse",{"2":{"191":1,"321":1,"465":1}}],["traffic",{"2":{"1178":1}}],["trap",{"0":{"1088":1,"1110":1},"2":{"1105":1}}],["trapping",{"2":{"867":1}}],["traps",{"0":{"1109":1},"1":{"1110":1,"1111":1,"1112":1},"2":{"408":1,"429":1,"433":1,"437":1,"477":1,"747":1,"1086":1}}],["trashing",{"2":{"440":1}}],["tradingenginecluster",{"2":{"1389":1}}],["trading",{"0":{"1386":1},"1":{"1387":1,"1388":1,"1389":1},"2":{"511":1,"1032":2,"1218":1,"1221":1,"1367":1,"1377":1,"1383":1,"1387":2}}],["traditionally",{"2":{"995":1,"1272":2}}],["traditional",{"2":{"425":1,"1368":1}}],["tradedate",{"2":{"1221":2}}],["tradedateiso",{"2":{"1221":2}}],["trades",{"2":{"1221":1}}],["tradeoffs",{"2":{"106":1}}],["trade",{"0":{"467":1,"469":1,"1042":1,"1221":1},"1":{"468":1,"469":1,"1043":1},"2":{"43":2,"199":1,"472":1,"498":1,"1032":1,"1033":1,"1210":1,"1218":1,"1221":12}}],["train",{"2":{"1360":1}}],["training",{"2":{"1012":1}}],["trail",{"0":{"1142":1},"1":{"1143":1,"1144":1},"2":{"351":1}}],["trailing",{"2":{"202":1,"290":1,"688":1}}],["trait",{"2":{"326":1,"1098":1}}],["traits",{"2":{"305":1}}],["tracing",{"2":{"645":1,"1011":1,"1377":1}}],["tracker",{"2":{"922":1}}],["tracked",{"2":{"631":1,"714":1,"1115":1}}],["tracking",{"0":{"967":1,"1085":1},"1":{"968":1,"969":1},"2":{"475":1,"625":1,"921":1,"1353":2}}],["tracks",{"2":{"228":1,"449":1,"661":1,"966":1}}],["track",{"2":{"199":1,"403":1}}],["traces",{"2":{"864":1}}],["traceability",{"0":{"337":1},"1":{"338":1,"339":1},"2":{"625":1,"752":1}}],["trace",{"0":{"339":1,"936":1},"2":{"114":1,"117":2,"129":1,"342":1,"484":1,"571":1,"930":1,"936":2,"937":1,"938":1,"962":1,"1041":1}}],["transcribed",{"2":{"1309":1}}],["transcript",{"2":{"894":1}}],["transcripts",{"2":{"888":1}}],["transaction",{"2":{"1225":1}}],["transactional",{"2":{"414":1,"440":1}}],["transfer",{"2":{"1370":1,"1382":1}}],["transferred",{"2":{"1040":1}}],["transforms",{"2":{"1419":1}}],["transformed",{"2":{"1029":1}}],["transformations",{"2":{"1088":1}}],["transformation",{"2":{"699":1,"1029":1,"1033":1}}],["transforming",{"2":{"514":1,"522":1,"637":1}}],["transform",{"2":{"138":1,"1021":1}}],["transpiles",{"2":{"1104":1}}],["transpilation",{"0":{"1148":1},"1":{"1149":1,"1150":1},"2":{"1099":1}}],["transport",{"0":{"862":1,"999":1},"1":{"1000":1,"1001":1},"2":{"855":2,"1364":1}}],["transparently",{"2":{"737":1,"842":1,"856":1,"909":1,"1147":1}}],["transparent",{"2":{"300":1,"429":1,"439":1,"475":1,"1099":1}}],["transits",{"2":{"1052":1,"1058":1,"1078":1}}],["transit",{"0":{"1061":1,"1354":1,"1360":1},"1":{"1355":1,"1356":1,"1357":1,"1358":1,"1359":1,"1360":1,"1361":1},"2":{"994":1,"1011":1,"1052":1,"1053":2,"1054":1,"1061":3,"1068":1,"1075":1,"1083":2,"1339":1,"1343":2,"1344":2,"1353":1,"1354":1}}],["transitional",{"2":{"515":1}}],["transitions",{"2":{"514":1,"1072":1,"1331":1,"1447":1}}],["transitioning",{"2":{"507":1,"532":1,"1108":1}}],["transition",{"0":{"514":1},"2":{"158":1,"1122":1,"1360":1}}],["transient",{"2":{"505":1,"1233":1}}],["transliteration",{"2":{"364":1}}],["transliterates",{"2":{"138":1,"370":1}}],["translating",{"2":{"1104":1}}],["translations",{"2":{"145":1,"221":1,"364":1,"788":1}}],["translation",{"0":{"788":1,"981":1},"1":{"982":1,"983":1,"984":1,"985":1,"986":1},"2":{"78":1,"223":1,"297":1,"784":1,"808":1,"981":1,"1089":1,"1113":1,"1147":1}}],["translates",{"2":{"222":1,"272":1,"294":1,"500":1,"1113":1,"1190":1}}],["translated",{"2":{"219":1,"220":1,"239":1}}],["translate",{"2":{"138":1}}],["treasury",{"2":{"1221":1}}],["treated",{"2":{"292":1,"565":1,"567":1,"569":1,"1129":1}}],["treats",{"2":{"207":1,"427":1,"1224":1}}],["treat",{"2":{"76":1,"326":1,"378":1,"465":1,"950":1}}],["trees",{"2":{"867":1}}],["tree",{"0":{"97":1,"170":1,"915":1,"918":1},"1":{"916":1,"917":1,"918":1},"2":{"12":1,"14":1,"43":2,"147":1,"168":1,"198":1,"269":2,"274":1,"283":2,"515":1,"558":1,"672":1,"711":2,"812":2,"915":1,"919":1,"1357":1,"1450":1}}],["trustedorigins",{"2":{"1240":1,"1263":2}}],["trusted",{"2":{"856":2,"1001":2,"1188":1,"1239":1,"1263":2,"1264":2}}],["trust",{"0":{"856":1,"1263":1,"1363":1},"2":{"856":1,"993":1,"1343":1,"1362":1}}],["truth",{"0":{"434":1},"2":{"406":1,"439":1,"1213":1,"1429":1}}],["truncate",{"2":{"732":1}}],["truncated",{"2":{"29":1,"997":1}}],["truncation",{"0":{"493":1},"2":{"473":1,"1011":1}}],["trunc",{"2":{"324":1}}],["truenow",{"2":{"1261":3}}],["true",{"0":{"368":1,"1254":1,"1422":1,"1448":1},"2":{"56":1,"117":2,"127":1,"150":1,"154":2,"161":1,"163":2,"165":2,"178":1,"186":2,"217":1,"236":1,"268":1,"281":2,"282":2,"291":1,"300":1,"313":1,"315":1,"336":1,"368":2,"369":1,"377":2,"389":1,"404":1,"423":1,"426":4,"429":1,"437":1,"438":1,"448":1,"461":3,"463":1,"464":2,"497":1,"501":2,"563":1,"571":1,"606":1,"631":1,"699":1,"701":2,"702":1,"717":1,"754":2,"817":2,"869":1,"871":3,"881":2,"890":2,"896":1,"899":2,"905":1,"912":3,"920":1,"930":1,"936":3,"937":3,"938":2,"950":1,"959":2,"962":2,"972":1,"973":4,"975":2,"977":2,"980":1,"984":1,"986":1,"988":1,"992":1,"993":1,"996":2,"997":1,"1008":1,"1009":1,"1011":1,"1022":1,"1036":2,"1042":1,"1055":2,"1062":1,"1064":3,"1069":1,"1071":2,"1072":5,"1076":2,"1077":2,"1080":1,"1081":1,"1147":1,"1158":2,"1166":1,"1167":2,"1168":1,"1169":2,"1172":2,"1184":1,"1195":1,"1205":1,"1209":1,"1214":1,"1216":1,"1217":1,"1240":2,"1241":1,"1242":2,"1243":1,"1254":3,"1255":4,"1256":1,"1257":1,"1258":1,"1261":3,"1263":1,"1265":1,"1267":1,"1271":2,"1304":1,"1335":2,"1337":2,"1338":1,"1348":1,"1361":2,"1362":1,"1363":1,"1366":1,"1376":1,"1422":3,"1436":1,"1444":1,"1448":2}}],["tauri",{"2":{"1376":1}}],["tas",{"2":{"1213":1}}],["task",{"2":{"483":1,"888":1,"1255":1}}],["taskstream",{"2":{"489":1,"497":1}}],["tasks",{"2":{"199":1,"228":1,"515":1,"516":1,"524":1,"867":1,"945":1,"1018":1,"1372":1}}],["tax",{"2":{"1097":1}}],["taxyear",{"2":{"143":1,"230":1,"263":1,"265":1,"267":1,"273":1,"711":1,"823":1,"1153":1}}],["tap",{"2":{"588":1}}],["taking",{"2":{"425":1,"514":1,"932":1,"1203":1,"1207":1}}],["takeaways",{"0":{"451":1}}],["takes",{"2":{"219":1,"469":1,"1032":1,"1444":1}}],["taken",{"2":{"176":1,"449":1}}],["take",{"0":{"983":1},"2":{"20":1,"451":1,"919":1,"920":1,"983":6,"986":1,"1159":1}}],["tailored",{"2":{"293":1,"332":1,"405":1,"514":1,"533":1,"897":1}}],["tail",{"0":{"1215":1},"1":{"1216":1,"1217":1},"2":{"138":2,"1207":1}}],["tailwind",{"2":{"102":1,"741":1}}],["tampering",{"2":{"425":1,"427":1,"644":1,"998":1,"1106":1}}],["tamper",{"0":{"998":1},"2":{"114":1,"402":1,"861":1,"1173":1}}],["target2",{"2":{"1221":1}}],["targetlocale",{"2":{"1190":2}}],["targettype",{"2":{"793":1}}],["targeted",{"2":{"627":1}}],["targeting",{"2":{"394":1,"407":1}}],["targetdate",{"2":{"158":4,"998":1,"1082":3}}],["targets",{"2":{"109":1,"158":2,"520":1,"1098":1}}],["target",{"0":{"434":1,"1201":1},"2":{"96":1,"102":1,"138":1,"158":8,"367":1,"399":1,"402":1,"406":2,"408":1,"409":4,"410":1,"426":5,"427":3,"432":1,"437":7,"438":3,"477":2,"520":2,"594":1,"617":1,"859":1,"881":1,"890":2,"893":1,"898":2,"899":2,"904":1,"959":1,"989":1,"1009":1,"1082":2,"1088":1,"1094":1,"1104":5,"1115":1,"1150":1,"1222":5,"1318":1,"1345":4,"1353":1,"1421":2,"1444":1}}],["tagging",{"2":{"271":2}}],["tag",{"2":{"45":1,"47":1,"102":1,"117":1,"145":1,"483":1,"484":4,"487":1,"489":1,"497":1,"709":1,"722":1,"872":1,"890":1,"899":1,"1159":1,"1160":1,"1161":1,"1213":2,"1214":1}}],["tags",{"0":{"484":1},"2":{"44":1,"475":1,"651":1,"709":1,"722":1,"769":1,"850":1,"1124":1}}],["tabs",{"2":{"1178":1}}],["tab",{"2":{"21":1,"91":1,"1124":1}}],["tables",{"2":{"163":1,"322":1,"782":1,"869":1,"1097":1,"1328":1}}],["table",{"0":{"50":1},"2":{"19":1,"448":1,"709":1,"1105":1,"1125":1,"1307":1}}],["tc39",{"0":{"903":1},"2":{"12":1,"34":1,"157":1,"335":1,"473":1,"491":1,"540":1,"543":2,"792":1,"827":1,"831":2,"833":1,"897":1,"903":1}}],["tilt",{"0":{"1063":1},"2":{"1052":1,"1053":1,"1058":1,"1063":1,"1069":1}}],["tidalterm",{"2":{"1075":1,"1078":1}}],["tidal",{"0":{"1074":1,"1076":1,"1079":1},"1":{"1075":1,"1076":1,"1077":1,"1078":1,"1079":1},"2":{"1050":1,"1052":2,"1053":1,"1054":1,"1055":2,"1074":1,"1075":1,"1076":4,"1078":1,"1079":1,"1083":3}}],["tidestate",{"2":{"1083":1}}],["tides",{"0":{"1076":1,"1077":1},"2":{"1050":1,"1052":1,"1053":2,"1054":3,"1055":3,"1075":1,"1076":7,"1077":3,"1078":5,"1079":1,"1080":2,"1083":7}}],["tide",{"0":{"1076":1,"1078":1},"2":{"771":1,"775":1,"1050":1,"1053":1,"1055":3,"1074":2,"1075":1,"1076":1,"1077":4,"1078":2,"1080":1,"1083":1}}],["tie",{"0":{"911":1}}],["tiers",{"0":{"129":1},"2":{"994":1}}],["tiered",{"2":{"100":1}}],["tier",{"0":{"99":1,"895":1,"904":1,"952":1,"953":1,"954":1,"955":1,"956":1,"1009":1,"1353":1},"1":{"953":1,"957":1,"958":1},"2":{"89":1,"96":1,"116":1,"123":1,"129":1,"465":1,"513":1,"867":1,"895":1,"904":1,"935":1,"948":1,"953":4,"954":4,"1007":2,"1008":6,"1219":1}}],["tickcount",{"2":{"1444":1}}],["ticks",{"0":{"1390":1},"1":{"1391":1,"1392":1},"2":{"1032":2,"1405":1,"1408":1,"1426":2,"1427":1,"1436":1,"1438":1,"1444":2,"1446":1}}],["tickettime",{"2":{"1220":2}}],["ticketcreatedat",{"2":{"1220":2}}],["ticketcontext",{"2":{"878":3}}],["tickets",{"2":{"1219":1}}],["ticket",{"2":{"1203":2,"1219":1,"1220":4,"1259":1}}],["tickerinstance",{"0":{"1405":1}}],["tickermodule",{"2":{"657":1}}],["tickers",{"0":{"1420":1},"2":{"273":1,"407":1,"531":1,"845":1,"848":1,"1256":1,"1406":1,"1419":1,"1426":2,"1433":1,"1436":1,"1442":2,"1454":1}}],["tickerplugin",{"2":{"43":2,"102":2,"274":1,"276":2,"288":3,"289":4,"290":2,"291":1,"541":1,"542":2,"548":3,"757":1,"759":2,"816":1,"848":2,"1254":2,"1399":2,"1422":2}}],["ticker",{"0":{"77":1,"548":1,"683":1,"759":1,"1253":1,"1396":1,"1402":1,"1403":1,"1404":1,"1406":1,"1426":2,"1427":1},"1":{"1254":1,"1255":1,"1256":1,"1257":1,"1397":1,"1398":1,"1399":1,"1400":1,"1401":1,"1402":1,"1403":2,"1404":2,"1405":2,"1406":2,"1407":1,"1408":1,"1409":1,"1410":1,"1427":2},"2":{"12":1,"14":1,"43":3,"44":2,"77":3,"88":1,"102":2,"199":1,"276":3,"289":1,"290":1,"291":1,"318":1,"321":1,"326":2,"541":1,"542":1,"548":4,"551":1,"553":1,"555":1,"574":1,"596":1,"597":1,"600":1,"601":1,"634":1,"678":1,"683":1,"709":1,"757":2,"759":3,"846":4,"848":1,"1242":2,"1253":1,"1254":6,"1255":1,"1256":1,"1257":2,"1369":1,"1396":1,"1397":1,"1399":1,"1400":3,"1401":1,"1403":2,"1404":1,"1405":6,"1406":1,"1408":3,"1409":3,"1411":1,"1412":4,"1414":1,"1415":2,"1416":1,"1417":3,"1418":3,"1419":2,"1420":2,"1421":3,"1422":5,"1423":1,"1424":9,"1425":1,"1426":5,"1427":3,"1428":1,"1429":3,"1430":2,"1431":1,"1432":1,"1433":4,"1434":2,"1435":5,"1436":6,"1438":3,"1439":1,"1440":2,"1441":6,"1442":1,"1443":1,"1444":3,"1445":4,"1446":3,"1447":3,"1448":3}}],["tick",{"0":{"1031":1},"1":{"1032":1,"1033":1},"2":{"792":2,"1024":1,"1033":1,"1389":1,"1392":2,"1401":1,"1408":1,"1409":1,"1418":1,"1420":1,"1424":1,"1425":1,"1429":1,"1435":1,"1445":1,"1446":2,"1448":1}}],["timings",{"0":{"442":1},"2":{"419":1,"442":1}}],["timing",{"0":{"1232":1},"2":{"409":1,"451":1,"936":1,"1226":1,"1232":3,"1236":1,"1240":1,"1242":1,"1262":1,"1344":1,"1442":1}}],["timeunit",{"2":{"1363":1}}],["timeleftms",{"2":{"1260":1}}],["timelines",{"2":{"531":1,"729":1,"1218":1,"1303":1}}],["timeline",{"0":{"23":1},"2":{"167":1,"174":1,"176":1,"191":1,"1261":1,"1265":1}}],["time=date",{"2":{"1235":1}}],["time=",{"2":{"1232":1}}],["timeend",{"2":{"1033":1}}],["timed",{"2":{"955":1}}],["timer",{"0":{"1372":1},"2":{"940":1,"1219":1,"1371":1,"1372":3,"1374":1,"1383":1,"1396":1,"1421":1,"1423":1,"1431":1,"1433":1,"1434":1,"1442":2,"1445":1}}],["timers",{"0":{"1260":1,"1421":1},"2":{"164":1,"449":1,"476":1,"1259":2,"1405":1,"1426":1,"1428":2,"1431":1,"1433":1,"1436":1,"1442":1,"1443":2,"1445":1}}],["timeofday",{"0":{"306":1},"2":{"194":1,"306":1,"307":1,"380":1,"387":1,"1401":1,"1414":1,"1415":1}}],["timeoutid",{"2":{"860":2,"955":2}}],["timeouts",{"2":{"588":1,"871":1,"924":1}}],["timeout",{"0":{"935":1},"2":{"102":1,"289":1,"290":1,"291":1,"477":1,"484":1,"816":1,"829":1,"854":2,"860":2,"871":2,"927":1,"930":1,"935":6,"937":2,"938":2,"955":3,"958":1,"959":2,"962":2,"1421":2}}],["timescaledb",{"2":{"1029":1}}],["timestampns",{"2":{"1395":1}}],["timestampiso",{"2":{"1363":5}}],["timestamped",{"2":{"1344":2,"1345":1,"1360":1}}],["timestamp",{"0":{"690":1,"1229":1},"2":{"117":1,"137":2,"154":1,"207":3,"359":2,"567":1,"569":2,"613":1,"616":2,"888":1,"893":1,"897":1,"902":1,"904":2,"907":1,"992":2,"1019":1,"1039":1,"1084":2,"1096":1,"1141":1,"1144":2,"1227":3,"1232":1,"1245":1,"1265":1,"1324":1,"1326":1,"1329":5,"1368":1,"1369":1,"1382":2,"1388":1,"1392":1,"1404":1,"1444":1}}],["timestamps",{"0":{"60":1},"2":{"201":1,"206":1,"208":2,"450":2,"609":1,"613":1,"616":1,"690":1,"879":1,"895":1,"903":1,"942":1,"950":1,"1019":1,"1022":1,"1028":2,"1030":1,"1032":1,"1039":1,"1042":2,"1067":1,"1070":1,"1096":1,"1141":1,"1143":1,"1203":1,"1232":1,"1265":1,"1306":1,"1315":1,"1328":1,"1329":2,"1332":1,"1377":1,"1419":1}}],["times",{"2":{"43":1,"146":1,"174":1,"297":1,"364":1,"465":1,"726":1,"856":1,"863":1,"909":1,"1013":1,"1036":1,"1083":1,"1235":1,"1254":1,"1267":1,"1332":1}}],["timezones",{"0":{"67":1},"1":{"68":1,"69":1},"2":{"11":1,"50":1,"102":1,"112":1,"113":1,"115":1,"117":1,"146":1,"161":1,"191":1,"218":1,"296":1,"416":1,"527":1,"1105":1,"1189":1,"1366":1,"1458":1}}],["timezone",{"0":{"154":1,"212":1,"213":1,"214":1,"296":1,"689":1,"723":1,"876":1,"1245":1,"1366":1,"1447":1},"1":{"213":1,"214":2,"215":1,"216":1,"217":1,"218":1,"219":1,"220":1,"221":1,"222":1,"223":1,"224":1,"225":1},"2":{"6":1,"9":1,"53":1,"56":1,"58":2,"68":2,"69":4,"73":3,"102":2,"105":1,"110":3,"112":1,"113":1,"115":1,"116":1,"117":2,"118":1,"119":6,"120":1,"132":1,"137":1,"138":3,"142":2,"146":4,"161":1,"173":1,"191":3,"197":1,"213":2,"214":3,"215":4,"216":2,"217":1,"269":1,"294":1,"296":1,"334":1,"344":1,"371":1,"373":1,"413":1,"448":2,"477":1,"522":1,"536":3,"561":1,"620":1,"621":1,"634":2,"637":3,"648":1,"649":1,"660":1,"667":1,"687":1,"689":1,"690":1,"723":2,"776":1,"788":1,"798":1,"838":1,"855":1,"866":1,"869":1,"870":1,"872":1,"874":1,"876":2,"878":1,"881":2,"888":1,"889":1,"890":2,"893":1,"894":1,"899":2,"902":1,"904":1,"907":2,"908":2,"909":1,"910":2,"919":1,"921":1,"927":1,"933":4,"937":2,"938":2,"962":2,"988":1,"989":2,"1009":1,"1013":4,"1054":4,"1055":1,"1067":4,"1124":1,"1125":3,"1141":1,"1144":1,"1157":2,"1167":1,"1193":4,"1254":1,"1351":1,"1353":1,"1362":1,"1366":1,"1401":2,"1423":1,"1428":1,"1429":5,"1430":4,"1447":2}}],["time",{"0":{"52":1,"62":1,"66":1,"68":1,"151":1,"306":1,"398":1,"564":1,"960":1,"967":1,"1062":1,"1066":1,"1069":1,"1071":1,"1096":1,"1228":1,"1235":1,"1266":2,"1350":1,"1351":2,"1393":1,"1422":1},"1":{"961":1,"962":1,"963":1,"964":1,"965":1,"968":1,"969":1,"1067":1,"1068":1,"1069":1,"1070":1,"1071":1,"1072":1,"1073":1,"1351":1,"1352":1,"1353":1,"1394":1,"1395":1},"2":{"0":1,"30":1,"49":1,"52":1,"66":1,"69":1,"83":2,"94":1,"96":1,"97":1,"117":1,"120":1,"123":2,"124":2,"127":2,"137":4,"138":6,"139":3,"144":2,"154":2,"155":1,"156":2,"157":3,"158":8,"159":1,"167":3,"170":1,"171":1,"175":1,"176":1,"177":1,"179":1,"188":1,"189":3,"191":2,"196":1,"203":1,"213":2,"216":2,"224":3,"239":1,"240":4,"241":1,"255":1,"266":2,"273":1,"285":1,"296":1,"300":1,"301":1,"306":1,"307":1,"313":1,"314":1,"328":1,"342":1,"357":1,"359":1,"361":1,"364":1,"370":3,"372":1,"377":1,"378":1,"383":2,"389":1,"393":1,"397":1,"398":2,"399":3,"407":2,"409":1,"416":1,"418":1,"424":1,"425":2,"426":1,"427":1,"442":1,"449":1,"469":1,"470":1,"491":1,"500":1,"507":1,"513":1,"520":1,"522":1,"525":1,"526":3,"529":2,"531":1,"532":2,"578":1,"580":1,"610":1,"617":1,"625":1,"627":1,"633":1,"639":1,"648":1,"694":1,"699":1,"752":1,"774":1,"787":1,"788":1,"793":1,"817":1,"839":1,"855":1,"867":1,"871":1,"872":1,"878":1,"881":1,"888":1,"890":2,"891":2,"897":1,"899":2,"907":1,"910":1,"919":3,"920":1,"933":1,"937":1,"938":1,"949":1,"950":1,"960":1,"972":1,"989":3,"993":1,"1004":2,"1012":1,"1013":1,"1028":1,"1033":2,"1050":1,"1052":2,"1053":1,"1054":1,"1055":1,"1058":1,"1062":1,"1065":1,"1066":2,"1069":5,"1080":1,"1091":2,"1103":2,"1104":1,"1118":2,"1123":1,"1125":1,"1135":2,"1157":1,"1189":1,"1213":1,"1223":1,"1227":1,"1234":1,"1236":1,"1239":3,"1240":2,"1241":1,"1242":2,"1243":4,"1246":1,"1254":1,"1257":1,"1258":3,"1261":2,"1262":1,"1266":2,"1267":1,"1272":1,"1315":3,"1318":1,"1319":2,"1322":1,"1328":2,"1329":1,"1339":1,"1343":1,"1344":2,"1345":1,"1350":1,"1351":4,"1353":2,"1360":1,"1362":2,"1363":1,"1364":1,"1366":2,"1367":2,"1368":1,"1370":1,"1377":3,"1382":3,"1383":1,"1385":1,"1388":1,"1391":1,"1392":3,"1395":1,"1404":1,"1415":1,"1418":1,"1419":3,"1420":1,"1421":2,"1422":2,"1439":1,"1447":2,"1448":1}}],["tightly",{"2":{"408":1,"440":1,"445":1}}],["tight",{"2":{"371":1}}],["titlecase",{"2":{"138":1,"326":1}}],["title",{"2":{"138":3,"140":1,"143":1,"144":1,"145":1,"823":1,"891":1,"988":1,"991":1,"1088":1,"1090":3,"1307":1}}],["tired",{"2":{"76":1}}],["tiny",{"2":{"43":3,"515":1}}],["tip",{"2":{"26":1,"48":1,"76":1,"109":1,"116":1,"124":1,"125":1,"128":1,"129":1,"137":1,"138":4,"148":1,"174":1,"199":1,"204":1,"205":1,"296":1,"300":1,"365":1,"367":1,"412":1,"414":1,"419":1,"861":1,"869":1,"932":1,"936":1,"946":1,"958":1,"1098":1,"1103":1}}],["t",{"0":{"367":1,"786":1,"792":1,"793":1,"807":1,"817":1,"818":1,"819":1,"823":1,"1047":1,"1048":2,"1059":2,"1067":2,"1068":1,"1069":1,"1076":2,"1118":1,"1158":1,"1197":2,"1199":1,"1201":1,"1203":1,"1217":1,"1334":1,"1336":1,"1352":1},"1":{"1159":1,"1335":1,"1337":1,"1338":1},"2":{"10":1,"11":1,"36":1,"38":1,"40":1,"42":2,"43":1,"45":3,"46":1,"54":3,"55":2,"64":3,"65":2,"66":2,"69":1,"71":3,"72":2,"75":2,"76":5,"77":2,"78":5,"87":3,"118":1,"119":5,"121":4,"124":4,"125":2,"133":2,"134":2,"137":3,"138":2,"139":5,"140":4,"141":4,"142":2,"143":2,"144":2,"145":5,"146":2,"147":4,"148":1,"149":7,"150":2,"154":2,"157":1,"163":1,"182":2,"183":1,"185":1,"186":2,"188":2,"189":4,"190":3,"191":6,"192":1,"194":1,"198":1,"200":1,"205":1,"214":2,"217":1,"226":4,"227":2,"231":2,"236":2,"240":1,"243":1,"244":1,"266":1,"268":3,"269":2,"270":7,"271":2,"291":1,"295":1,"303":5,"304":5,"305":4,"306":3,"313":4,"317":2,"318":1,"321":1,"323":6,"325":2,"326":2,"339":2,"357":1,"358":1,"359":1,"360":2,"367":22,"368":5,"369":3,"370":1,"371":1,"372":9,"377":1,"380":1,"381":3,"382":2,"387":2,"427":2,"429":2,"437":2,"473":1,"477":5,"481":1,"482":1,"488":1,"489":2,"492":2,"494":1,"510":1,"511":1,"515":1,"518":3,"519":3,"520":5,"536":2,"546":4,"556":2,"680":2,"704":1,"711":2,"720":2,"731":2,"734":4,"735":1,"765":2,"768":6,"773":7,"777":5,"784":1,"786":10,"790":2,"792":1,"804":1,"806":3,"807":1,"814":1,"817":4,"818":1,"819":1,"824":2,"838":3,"848":1,"849":2,"850":2,"897":1,"909":1,"933":1,"993":1,"1004":1,"1045":4,"1047":3,"1049":2,"1050":6,"1052":3,"1053":2,"1054":7,"1055":23,"1056":2,"1059":7,"1061":7,"1062":4,"1067":5,"1068":3,"1069":3,"1073":4,"1075":2,"1076":5,"1077":2,"1079":1,"1081":2,"1082":1,"1083":1,"1085":1,"1089":12,"1098":2,"1101":4,"1102":2,"1104":16,"1106":1,"1114":2,"1118":3,"1122":2,"1127":1,"1128":1,"1129":1,"1130":2,"1131":1,"1132":1,"1135":2,"1144":1,"1147":1,"1153":4,"1154":2,"1158":4,"1159":1,"1167":1,"1169":2,"1171":2,"1172":3,"1173":1,"1180":2,"1194":1,"1207":2,"1209":5,"1214":4,"1227":1,"1316":7,"1317":2,"1318":1,"1319":6,"1325":1,"1329":2,"1332":4,"1345":6,"1353":2,"1366":2,"1381":2,"1403":1,"1405":1,"1408":2,"1409":2,"1412":6,"1415":5,"1417":4,"1418":2,"1419":2,"1420":3,"1421":3,"1422":2,"1424":8,"1425":3,"1429":2,"1430":5,"1433":2,"1434":2,"1435":2,"1438":4,"1439":2,"1441":2,"1444":3,"1447":2}}],["tse",{"2":{"1430":1}}],["tserver",{"2":{"1227":1}}],["tsydney",{"2":{"1352":2,"1357":2}}],["tsf",{"2":{"1337":2}}],["tsc",{"2":{"760":1}}],["tsconfig",{"2":{"541":1,"832":1}}],["tsconst",{"2":{"303":2,"304":2,"305":1,"306":1,"377":1}}],["tslib",{"2":{"657":1}}],["tsreturn",{"2":{"320":1}}],["tstype",{"2":{"315":1}}],["tstempo",{"2":{"307":1}}],["tsimport",{"2":{"313":1,"316":1,"319":1,"375":1}}],["ts2669",{"2":{"261":1}}],["ts",{"0":{"102":1,"437":1,"438":1,"1450":1},"1":{"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1},"2":{"7":1,"102":6,"103":2,"104":1,"106":1,"107":2,"117":1,"121":1,"137":1,"154":1,"232":1,"234":1,"261":2,"265":1,"267":1,"271":1,"285":1,"286":1,"290":1,"292":1,"317":1,"326":1,"415":1,"451":1,"457":1,"467":1,"468":3,"469":1,"471":1,"504":3,"537":1,"538":1,"568":2,"642":1,"651":1,"709":1,"724":2,"741":5,"760":1,"836":3,"839":1,"855":1,"926":1,"1125":1,"1381":1,"1389":2,"1450":1,"1459":3}}],["tech",{"2":{"1088":1}}],["technically",{"2":{"273":1,"468":1}}],["technical",{"2":{"8":1,"13":1,"1105":1}}],["telemetrypoint",{"2":{"1329":2}}],["telemetry",{"0":{"941":1,"948":1,"995":1,"1007":1,"1027":1,"1265":1,"1327":1,"1426":1,"1444":1},"1":{"942":1,"996":1,"997":1,"1028":1,"1029":1,"1030":1,"1328":1,"1329":1,"1427":1},"2":{"403":1,"863":1,"867":1,"869":1,"921":1,"934":1,"937":2,"938":2,"940":1,"948":1,"954":2,"959":2,"996":1,"997":1,"998":1,"1007":1,"1008":4,"1011":1,"1018":1,"1024":1,"1029":1,"1030":1,"1042":1,"1248":1,"1265":1,"1315":1,"1320":1,"1322":1,"1377":1,"1401":1,"1404":1,"1405":1,"1427":1,"1436":1,"1444":1}}],["terentius",{"2":{"1272":1}}],["terrestrial",{"2":{"1067":1}}],["territorial",{"2":{"1166":1}}],["territories",{"2":{"365":1,"1160":1}}],["territory",{"2":{"365":1,"1125":1,"1157":1,"1158":1}}],["term`",{"2":{"426":1}}],["termparsecontext",{"2":{"322":1,"323":2}}],["termplugins",{"2":{"155":1}}],["termplugin",{"2":{"115":1,"117":1}}],["termhook",{"0":{"773":1},"2":{"322":2,"323":6,"324":7,"773":6,"775":3,"776":1}}],["termination",{"0":{"1437":1},"1":{"1438":1,"1439":1},"2":{"634":1,"985":2,"1404":1}}],["terminates",{"2":{"955":1,"1421":1}}],["terminate",{"2":{"493":1,"1389":1}}],["terminalia",{"2":{"1271":1}}],["terminal",{"2":{"281":1,"300":1,"702":1,"869":1,"936":1,"996":1,"998":2}}],["terminology",{"2":{"185":1,"193":1,"237":1,"248":1,"388":1,"750":1}}],["termsmodule",{"2":{"251":2,"259":2,"310":2}}],["terms",{"0":{"70":1,"257":1,"299":1,"307":1,"308":1,"317":1,"318":1,"346":1,"509":1,"775":1},"1":{"71":1,"72":1,"73":1,"258":1,"259":1,"260":1,"300":1,"301":1,"302":1,"303":1,"304":1,"305":1,"306":1,"307":1,"308":1,"309":2,"310":2,"311":2,"312":1,"313":1,"314":1,"315":1,"316":1,"317":1,"318":1,"319":2,"320":2,"321":2,"322":1,"323":1,"324":1,"325":1,"326":1,"327":1},"2":{"50":1,"62":1,"63":2,"73":1,"87":1,"95":3,"97":1,"99":1,"102":2,"112":1,"113":1,"115":1,"117":1,"124":1,"131":3,"143":1,"155":1,"198":2,"220":1,"222":1,"257":2,"258":1,"260":1,"285":1,"293":1,"300":1,"307":2,"308":1,"309":1,"311":2,"316":1,"325":1,"326":2,"331":1,"352":1,"378":1,"387":2,"389":1,"406":1,"410":1,"416":1,"429":1,"451":1,"507":1,"509":2,"515":1,"519":4,"531":1,"541":3,"556":1,"609":1,"612":1,"617":1,"680":1,"695":1,"711":1,"716":1,"726":1,"754":1,"757":2,"771":3,"775":4,"782":1,"802":1,"830":1,"832":1,"879":1,"880":1,"938":1,"974":1,"1049":1,"1097":1,"1098":2,"1103":1,"1401":1,"1411":1,"1454":1}}],["term",{"0":{"257":1,"301":1,"312":1,"322":1,"353":1,"556":1,"654":1,"680":1,"681":1,"774":1,"842":1,"1047":1,"1048":2,"1059":2,"1067":2,"1068":1,"1069":1,"1076":2,"1414":1},"1":{"258":1,"259":1,"260":1,"313":1,"314":1,"315":1,"316":1,"317":1,"323":1,"324":1,"325":1,"1415":1},"2":{"9":1,"72":4,"73":4,"75":2,"77":2,"87":2,"102":2,"124":1,"138":1,"141":1,"143":2,"155":1,"185":1,"198":1,"222":1,"230":1,"251":2,"258":1,"259":1,"260":1,"273":2,"274":1,"292":1,"300":4,"301":4,"303":3,"304":3,"305":3,"306":2,"309":1,"310":1,"311":1,"312":1,"315":3,"316":3,"317":3,"318":1,"322":2,"323":7,"325":1,"326":10,"327":2,"334":1,"346":1,"353":1,"357":1,"382":1,"383":3,"406":1,"407":1,"408":2,"409":1,"411":1,"412":2,"421":1,"427":1,"429":2,"444":2,"504":1,"509":1,"519":2,"537":1,"542":1,"543":1,"556":3,"561":2,"588":2,"592":1,"612":1,"626":1,"637":2,"649":1,"653":1,"680":1,"681":1,"682":2,"699":2,"712":1,"717":1,"726":2,"739":1,"754":1,"755":3,"757":4,"771":3,"773":11,"774":2,"775":1,"776":2,"777":6,"778":2,"832":1,"835":1,"842":1,"845":1,"849":1,"851":1,"1045":4,"1046":8,"1047":2,"1048":2,"1049":1,"1050":6,"1052":3,"1053":2,"1054":7,"1055":14,"1056":1,"1059":6,"1060":2,"1061":6,"1062":3,"1063":1,"1064":4,"1065":4,"1067":4,"1068":2,"1069":3,"1070":2,"1071":5,"1072":5,"1073":4,"1075":2,"1076":4,"1077":2,"1078":4,"1079":1,"1081":1,"1082":2,"1083":2,"1084":1,"1085":2,"1181":1,"1271":1,"1353":2,"1403":1,"1414":1,"1415":1}}],["temperate",{"2":{"1063":1}}],["temperature",{"2":{"854":2,"860":1,"1329":5}}],["temp",{"2":{"588":1,"1329":3}}],["templates",{"2":{"205":1,"370":1,"504":1,"654":1,"855":1,"1115":1,"1150":1}}],["template",{"2":{"146":1,"313":2,"897":1,"927":1,"1089":1,"1150":1}}],["tempodate",{"2":{"1304":2}}],["tempodateinput",{"2":{"890":1,"899":1,"989":1,"991":5}}],["tempogateway",{"2":{"1178":2}}],["tempo>",{"2":{"991":1,"992":2}}],["tempoworkinghours",{"2":{"989":1}}],["tempoeventtype",{"2":{"891":1}}],["tempoextractedevent",{"2":{"891":2,"919":1}}],["tempoerror",{"2":{"271":1,"702":1}}],["tempoaierror",{"2":{"865":1,"871":2,"875":2,"876":1,"881":2,"890":2,"899":2,"912":3,"919":5,"920":4,"954":1,"962":1,"970":3,"973":4,"1010":1}}],["tempoaiextractresult",{"0":{"891":1},"2":{"864":1,"888":1,"891":1,"910":1,"919":3,"998":1}}],["tempoaidiffresult",{"0":{"882":1},"2":{"864":1,"882":1,"910":1,"919":3,"998":1}}],["tempoaiformatresulttempoaiextractresulttempoaidiffresulttempocontext",{"2":{"920":1}}],["tempoaiformatresult",{"0":{"900":1},"2":{"864":1,"900":1,"910":1,"919":3,"998":1}}],["tempointerval",{"0":{"990":1},"2":{"990":1,"991":2}}],["tempointlnamespace",{"2":{"154":1}}],["tempoinstance",{"2":{"546":2}}],["temporecurrenceresult",{"2":{"864":1,"919":1,"920":1,"985":1,"986":1,"998":1}}],["temporary",{"2":{"797":1}}],["temporal",{"0":{"34":1,"37":1,"81":1,"149":1,"514":1,"516":1,"522":1,"673":1,"818":1,"903":1,"907":1},"1":{"517":1,"518":1,"519":1,"520":1,"908":1,"909":1},"2":{"0":1,"3":3,"10":4,"11":2,"12":1,"14":1,"24":1,"34":10,"37":1,"38":2,"39":2,"42":3,"43":3,"44":2,"45":2,"81":3,"85":1,"120":1,"130":1,"131":3,"132":2,"146":7,"147":2,"148":1,"149":4,"150":1,"154":1,"156":1,"157":1,"158":2,"167":1,"169":1,"170":6,"171":1,"173":1,"174":1,"191":1,"192":1,"196":1,"197":2,"198":2,"199":2,"201":1,"224":2,"233":2,"251":1,"273":1,"323":2,"342":1,"351":1,"357":2,"361":2,"364":1,"506":1,"507":3,"511":1,"512":1,"513":3,"514":6,"515":3,"516":5,"517":4,"518":3,"519":3,"520":8,"522":3,"524":2,"528":1,"532":1,"574":1,"578":1,"620":2,"640":1,"648":1,"651":1,"673":1,"699":1,"711":1,"729":2,"750":1,"751":1,"752":1,"814":1,"818":2,"850":2,"863":1,"879":1,"888":1,"897":1,"903":7,"906":1,"913":2,"919":1,"922":1,"1004":1,"1007":1,"1008":1,"1012":1,"1026":1,"1041":1,"1121":1,"1136":1,"1303":1,"1396":1}}],["temporuntime",{"0":{"402":1},"2":{"402":2,"653":1}}],["tempotermregistry",{"2":{"326":2}}],["tempocontext",{"0":{"872":1},"2":{"864":1,"872":1,"910":1,"919":3}}],["tempoconfig",{"2":{"104":2}}],["tempoclass",{"2":{"232":1,"233":4,"235":3,"261":3,"275":1,"276":1,"285":1,"286":2,"291":1}}],["tempoplugin",{"2":{"232":2,"233":1,"235":1,"285":1}}],["temposcheduleoptions",{"0":{"989":1},"1":{"990":1,"991":1}}],["temposcheduleresult",{"0":{"992":1},"2":{"864":1,"919":1,"920":1,"992":1,"998":1}}],["tempostr",{"2":{"146":2}}],["tempos",{"0":{"82":1}}],["tempo`",{"2":{"27":1}}],["tempo",{"0":{"0":1,"11":1,"14":1,"32":1,"49":1,"98":1,"102":1,"116":1,"169":1,"204":1,"246":1,"249":1,"253":1,"254":1,"255":1,"256":1,"257":1,"273":1,"283":1,"289":1,"290":1,"299":1,"334":1,"342":1,"344":1,"345":1,"346":1,"347":1,"348":1,"361":1,"378":1,"405":1,"441":1,"452":1,"453":1,"457":1,"458":1,"466":1,"470":1,"498":1,"504":1,"506":1,"508":1,"521":1,"535":1,"537":1,"540":1,"543":1,"547":1,"548":1,"549":1,"557":1,"687":1,"694":1,"759":1,"776":1,"787":1,"797":1,"808":1,"831":1,"840":1,"841":1,"844":1,"849":1,"894":1,"913":1,"916":1,"927":1,"954":1,"1008":1,"1013":1,"1018":1,"1050":1,"1099":1,"1113":1,"1115":1,"1116":1,"1119":2,"1120":1,"1132":1,"1151":1,"1162":1,"1168":1,"1171":1,"1178":1,"1206":1,"1216":1,"1236":1,"1245":2,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":2,"1275":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":2,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1315":1,"1334":1,"1336":1,"1339":1,"1344":1,"1352":1,"1355":1,"1358":1,"1359":1,"1360":1,"1361":1,"1377":1,"1396":1,"1403":1,"1449":1,"1453":1},"1":{"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"12":1,"50":1,"51":1,"52":1,"53":1,"54":1,"55":1,"56":1,"57":1,"58":1,"59":1,"60":1,"61":1,"62":1,"63":1,"64":1,"65":1,"66":1,"67":1,"68":1,"69":1,"70":1,"71":1,"72":1,"73":1,"74":1,"75":1,"76":1,"77":1,"78":1,"79":1,"80":1,"81":1,"82":1,"99":1,"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"117":1,"250":1,"251":1,"252":1,"253":1,"254":1,"255":1,"256":1,"257":1,"258":2,"259":2,"260":2,"261":1,"262":1,"274":1,"275":1,"276":1,"277":1,"278":1,"279":1,"280":1,"281":1,"282":1,"283":1,"284":1,"285":1,"286":1,"287":1,"288":1,"289":1,"290":1,"291":1,"292":1,"293":1,"300":1,"301":1,"302":1,"303":1,"304":1,"305":1,"306":1,"307":1,"308":1,"309":1,"310":1,"311":1,"312":1,"313":1,"314":1,"315":1,"316":1,"317":1,"318":1,"319":1,"320":1,"321":1,"322":1,"323":1,"324":1,"325":1,"326":1,"327":1,"343":1,"344":1,"345":1,"346":1,"347":1,"348":1,"349":1,"350":1,"351":1,"352":1,"353":1,"354":1,"355":1,"356":1,"357":1,"358":1,"359":1,"360":1,"362":1,"363":1,"364":1,"365":1,"366":1,"367":1,"368":1,"369":1,"370":1,"371":1,"372":1,"373":1,"379":1,"380":1,"381":1,"382":1,"383":1,"384":1,"385":1,"386":1,"387":1,"388":1,"389":1,"442":1,"443":1,"444":1,"445":1,"446":1,"447":1,"448":1,"449":1,"450":1,"451":1,"453":1,"454":2,"455":2,"456":2,"457":1,"458":2,"459":2,"460":2,"461":2,"462":1,"463":1,"464":1,"465":1,"466":1,"467":1,"468":1,"469":1,"471":1,"472":1,"473":1,"474":1,"475":1,"476":1,"477":1,"478":1,"479":1,"499":1,"500":1,"501":1,"502":1,"503":1,"504":1,"505":1,"507":1,"508":1,"509":2,"510":2,"511":2,"512":2,"513":2,"514":1,"515":1,"522":1,"523":1,"524":1,"525":1,"526":1,"527":1,"528":1,"536":1,"537":1,"538":1,"539":1,"541":1,"542":1,"543":1,"544":1,"545":1,"546":1,"548":1,"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":2,"559":2,"560":1,"561":1,"562":1,"563":1,"564":1,"565":1,"566":1,"567":1,"568":1,"569":1,"570":1,"571":1,"572":1,"573":1,"845":1,"846":1,"847":1,"848":1,"849":1,"850":1,"851":1,"914":1,"915":1,"916":1,"917":2,"918":1,"919":1,"920":1,"921":1,"922":1,"923":1,"1019":1,"1020":1,"1021":1,"1022":1,"1023":1,"1024":1,"1025":1,"1051":1,"1052":1,"1053":1,"1054":1,"1055":1,"1056":1,"1057":1,"1100":1,"1101":1,"1102":1,"1103":1,"1104":1,"1105":1,"1106":1,"1107":1,"1114":1,"1121":1,"1122":1,"1152":1,"1153":1,"1154":1,"1155":1,"1163":1,"1164":1,"1165":1,"1166":1,"1167":1,"1168":1,"1169":2,"1170":1,"1171":1,"1172":1,"1173":1,"1174":1,"1207":1,"1208":1,"1209":1,"1210":1,"1211":1,"1237":1,"1238":1,"1239":1,"1240":1,"1241":1,"1242":1,"1243":1,"1244":1,"1245":1,"1246":1,"1247":1,"1248":1,"1249":1,"1250":1,"1251":1,"1252":1,"1276":1,"1277":1,"1278":1,"1279":1,"1280":1,"1281":1,"1282":1,"1283":1,"1284":1,"1285":1,"1286":1,"1287":1,"1288":1,"1289":1,"1290":1,"1291":1,"1292":1,"1293":1,"1294":1,"1295":1,"1296":1,"1297":1,"1298":1,"1299":1,"1300":1,"1316":1,"1317":1,"1318":1,"1319":1,"1320":1,"1321":1,"1335":1,"1337":1,"1338":1,"1340":1,"1341":1,"1342":1,"1343":1,"1344":1,"1345":2,"1346":1,"1347":1,"1348":1,"1349":1,"1356":1,"1357":1,"1378":1,"1379":1,"1380":1,"1381":1,"1382":1,"1383":1,"1384":1,"1397":1,"1398":1,"1399":1,"1400":1,"1401":1,"1402":1,"1403":1,"1404":1,"1405":1,"1406":1,"1407":1,"1408":1,"1409":1,"1410":1,"1450":1,"1451":1,"1452":1,"1454":1,"1455":1,"1456":1,"1457":1,"1458":1,"1459":1},"2":{"0":1,"1":1,"3":1,"5":2,"6":2,"7":2,"8":1,"9":5,"10":13,"11":2,"14":5,"20":1,"22":1,"24":3,"26":4,"27":4,"28":1,"30":2,"31":4,"32":4,"33":2,"34":2,"35":5,"36":3,"38":3,"39":2,"40":3,"41":1,"42":7,"43":9,"44":10,"45":7,"46":7,"47":2,"48":2,"49":1,"52":1,"53":1,"54":1,"55":1,"56":1,"58":2,"59":5,"60":3,"62":4,"63":3,"64":1,"65":1,"66":1,"68":1,"69":2,"71":3,"72":1,"73":5,"75":1,"76":2,"77":1,"78":5,"80":3,"81":3,"82":4,"83":1,"85":1,"87":4,"88":4,"89":4,"92":2,"93":9,"94":4,"95":5,"96":2,"97":1,"98":8,"99":1,"100":1,"101":3,"102":14,"103":6,"104":6,"105":3,"106":2,"108":1,"109":2,"110":5,"111":6,"112":4,"113":5,"114":5,"115":1,"116":9,"117":1,"118":1,"119":7,"120":3,"121":4,"122":1,"123":2,"124":4,"125":9,"127":1,"129":2,"130":1,"131":5,"132":2,"133":4,"134":2,"135":3,"136":5,"137":11,"138":3,"139":2,"140":1,"141":2,"142":2,"143":1,"144":2,"145":2,"146":7,"147":4,"148":2,"149":1,"155":1,"156":2,"157":3,"158":13,"159":3,"160":3,"161":5,"162":1,"163":1,"164":1,"165":1,"166":2,"167":1,"168":1,"169":6,"170":3,"171":3,"173":1,"176":3,"177":4,"178":6,"179":6,"180":6,"181":4,"182":2,"183":1,"186":1,"187":1,"188":1,"191":1,"193":1,"196":2,"197":3,"198":2,"199":4,"200":4,"202":3,"203":15,"204":5,"205":9,"206":2,"207":4,"209":1,"210":4,"211":5,"212":1,"213":2,"214":1,"215":4,"216":1,"217":2,"219":4,"220":1,"222":4,"223":2,"226":2,"227":1,"228":1,"229":4,"230":2,"231":2,"232":1,"233":3,"234":6,"236":4,"237":2,"239":1,"243":7,"244":1,"246":2,"247":5,"248":1,"249":1,"250":7,"251":12,"253":1,"258":1,"259":4,"260":4,"261":8,"262":8,"263":3,"264":2,"265":17,"266":6,"267":3,"268":5,"269":3,"270":10,"271":14,"272":2,"273":4,"274":9,"275":2,"276":29,"278":2,"279":1,"280":4,"281":2,"282":3,"283":7,"285":3,"286":1,"288":1,"289":11,"290":7,"292":2,"293":3,"294":3,"295":7,"296":2,"297":1,"298":2,"300":5,"301":5,"303":2,"304":2,"305":1,"306":1,"307":1,"308":2,"309":1,"310":4,"311":4,"312":1,"313":6,"315":4,"316":5,"317":6,"318":1,"319":3,"320":1,"322":3,"323":16,"324":12,"325":1,"326":3,"327":1,"328":2,"329":2,"330":1,"331":7,"332":4,"333":6,"334":6,"335":4,"336":1,"337":1,"338":4,"340":1,"341":1,"342":3,"343":1,"344":1,"345":2,"346":1,"347":1,"349":1,"350":2,"351":3,"355":3,"356":1,"357":4,"358":3,"359":1,"360":3,"361":4,"362":2,"363":10,"364":2,"365":4,"366":1,"367":2,"368":3,"370":1,"371":1,"372":1,"373":2,"374":2,"375":4,"377":2,"378":1,"385":1,"386":1,"387":2,"390":1,"393":1,"394":2,"398":1,"399":1,"400":1,"402":7,"403":1,"405":1,"406":3,"407":2,"408":3,"410":2,"411":3,"412":1,"413":4,"415":1,"417":1,"418":1,"420":1,"421":2,"422":2,"423":1,"426":1,"427":2,"428":1,"429":2,"430":1,"431":1,"441":1,"446":2,"447":2,"448":6,"450":3,"451":2,"452":2,"453":1,"457":5,"458":9,"459":1,"460":1,"461":13,"463":1,"464":1,"466":1,"469":1,"470":1,"471":1,"472":1,"473":1,"474":1,"476":1,"477":2,"478":1,"479":1,"481":1,"488":1,"489":1,"498":1,"500":1,"501":1,"502":1,"503":2,"504":1,"506":1,"507":1,"509":2,"510":1,"511":1,"512":1,"513":2,"514":2,"515":3,"516":5,"517":4,"518":2,"519":3,"520":5,"522":2,"524":1,"525":1,"526":1,"527":1,"528":1,"529":1,"531":1,"534":1,"535":1,"536":4,"537":5,"538":1,"539":4,"540":2,"541":7,"542":3,"543":3,"545":2,"546":5,"547":1,"548":8,"549":1,"550":1,"551":1,"552":2,"555":2,"557":1,"558":3,"559":11,"560":5,"561":1,"562":1,"563":3,"564":2,"565":2,"568":2,"569":1,"571":4,"572":2,"574":1,"575":1,"584":1,"588":1,"592":1,"596":2,"600":1,"601":1,"606":3,"612":1,"616":1,"617":1,"625":1,"626":1,"631":1,"637":1,"639":3,"643":2,"644":1,"647":1,"651":4,"666":2,"668":1,"674":1,"675":1,"677":2,"678":3,"681":1,"682":1,"687":3,"688":2,"689":3,"690":1,"691":2,"692":1,"695":1,"696":1,"697":1,"699":2,"701":1,"702":2,"705":3,"707":2,"708":4,"709":2,"711":3,"716":3,"717":1,"719":1,"720":1,"722":2,"724":1,"726":1,"728":4,"731":2,"734":2,"737":5,"738":1,"741":7,"746":1,"747":3,"748":1,"751":1,"754":2,"757":1,"759":6,"760":1,"763":1,"765":4,"766":4,"767":1,"768":1,"771":3,"773":3,"774":2,"775":4,"776":8,"780":1,"784":2,"786":1,"787":3,"790":2,"792":3,"793":1,"795":2,"797":2,"800":1,"804":2,"806":6,"807":1,"810":1,"812":5,"814":1,"817":1,"821":1,"824":1,"827":2,"829":3,"831":5,"832":5,"833":2,"835":1,"836":4,"838":1,"839":1,"840":1,"841":1,"843":3,"844":1,"845":2,"846":13,"847":1,"848":7,"849":6,"850":7,"852":1,"853":2,"856":3,"859":2,"861":1,"864":1,"865":1,"867":1,"870":3,"874":3,"878":1,"879":2,"880":5,"884":1,"885":2,"888":1,"889":4,"890":1,"891":4,"894":2,"895":1,"897":2,"898":5,"903":2,"906":1,"907":1,"908":1,"909":1,"910":3,"912":2,"913":2,"914":1,"915":3,"916":10,"917":4,"918":3,"919":7,"920":4,"922":3,"924":1,"925":3,"926":3,"927":1,"929":2,"930":1,"931":2,"933":1,"936":2,"937":2,"938":1,"939":2,"950":1,"951":3,"953":3,"954":7,"955":1,"957":1,"958":2,"960":1,"961":1,"965":1,"968":1,"969":1,"970":1,"971":2,"972":1,"973":3,"976":1,"978":2,"981":1,"982":2,"983":3,"986":4,"988":1,"990":2,"991":1,"992":3,"993":2,"994":1,"995":1,"997":1,"998":2,"1007":2,"1008":3,"1009":1,"1010":2,"1011":1,"1012":2,"1013":8,"1014":6,"1015":8,"1016":6,"1017":5,"1018":1,"1019":6,"1020":4,"1021":3,"1022":1,"1026":1,"1029":2,"1030":5,"1033":6,"1035":1,"1036":11,"1037":1,"1038":1,"1042":2,"1044":1,"1045":1,"1046":7,"1047":3,"1048":2,"1049":5,"1050":1,"1051":1,"1054":2,"1055":11,"1056":4,"1058":1,"1059":5,"1060":2,"1061":1,"1062":1,"1063":1,"1064":1,"1065":2,"1066":1,"1067":5,"1068":2,"1069":2,"1070":1,"1071":1,"1072":2,"1073":1,"1074":1,"1076":5,"1078":6,"1080":2,"1081":5,"1082":5,"1083":5,"1084":5,"1085":5,"1086":4,"1087":1,"1088":3,"1089":3,"1090":2,"1091":2,"1092":2,"1093":2,"1094":1,"1095":1,"1096":1,"1097":1,"1098":4,"1099":2,"1100":1,"1101":5,"1102":4,"1103":3,"1104":19,"1105":2,"1106":2,"1108":2,"1110":2,"1111":1,"1112":1,"1113":13,"1114":2,"1115":5,"1116":4,"1117":1,"1118":2,"1119":2,"1120":3,"1121":1,"1122":4,"1123":1,"1124":1,"1125":3,"1132":1,"1134":1,"1135":1,"1136":2,"1137":1,"1140":3,"1141":7,"1144":11,"1147":10,"1150":9,"1151":1,"1152":1,"1153":5,"1154":4,"1156":1,"1158":5,"1160":1,"1162":2,"1163":1,"1164":6,"1165":3,"1167":7,"1168":14,"1169":1,"1171":7,"1172":6,"1173":4,"1175":1,"1176":1,"1178":6,"1180":1,"1181":6,"1182":1,"1183":1,"1184":10,"1186":3,"1187":2,"1188":4,"1189":1,"1190":4,"1191":8,"1192":8,"1193":6,"1194":1,"1195":6,"1197":1,"1199":1,"1201":2,"1203":2,"1205":4,"1206":1,"1207":4,"1208":1,"1209":6,"1214":6,"1215":1,"1216":5,"1217":1,"1218":2,"1219":1,"1220":7,"1221":4,"1222":5,"1223":5,"1224":5,"1225":1,"1226":1,"1232":1,"1235":2,"1236":1,"1237":1,"1239":6,"1241":5,"1242":1,"1243":8,"1245":1,"1251":1,"1253":2,"1254":11,"1255":3,"1256":1,"1257":1,"1258":2,"1261":8,"1262":1,"1263":6,"1264":3,"1265":6,"1266":3,"1267":1,"1271":2,"1273":2,"1275":1,"1276":2,"1277":1,"1278":4,"1280":7,"1281":4,"1282":4,"1287":1,"1289":1,"1301":1,"1304":9,"1307":6,"1310":7,"1313":8,"1315":1,"1316":6,"1317":4,"1318":3,"1319":1,"1322":1,"1326":8,"1329":5,"1332":6,"1333":1,"1335":7,"1337":7,"1338":1,"1339":2,"1340":1,"1341":7,"1342":3,"1344":8,"1347":7,"1348":4,"1350":1,"1352":9,"1353":4,"1354":1,"1357":7,"1358":6,"1359":5,"1360":8,"1361":8,"1362":2,"1363":9,"1364":5,"1365":7,"1366":6,"1367":1,"1371":1,"1373":1,"1374":1,"1377":1,"1378":1,"1379":5,"1380":4,"1381":2,"1382":5,"1385":1,"1389":7,"1392":4,"1395":1,"1396":2,"1397":1,"1399":4,"1400":4,"1403":1,"1404":2,"1405":2,"1408":4,"1409":1,"1411":1,"1412":6,"1414":1,"1415":2,"1416":1,"1417":2,"1418":2,"1419":1,"1420":1,"1421":2,"1422":12,"1423":1,"1424":4,"1425":3,"1426":1,"1427":2,"1429":5,"1430":4,"1432":1,"1433":4,"1434":1,"1435":1,"1436":2,"1438":2,"1439":1,"1440":2,"1441":2,"1442":2,"1443":1,"1444":6,"1445":6,"1446":5,"1447":6,"1448":7,"1449":2,"1450":1,"1451":3,"1452":7,"1453":1,"1454":2,"1459":1}}],["tens",{"2":{"1032":1}}],["tentative",{"2":{"891":1}}],["tenth",{"2":{"203":2,"776":2}}],["tenths",{"2":{"138":2}}],["tenantcoords",{"2":{"1187":1}}],["tenanttime",{"2":{"1187":1}}],["tenantacoords",{"2":{"1186":1}}],["tenants",{"2":{"1185":2,"1189":1}}],["tenantstore",{"2":{"1004":1}}],["tenantid",{"2":{"119":2,"1192":2}}],["tenant",{"0":{"69":1,"1183":1,"1185":1,"1190":1,"1192":1,"1219":1},"1":{"1184":1,"1185":1,"1186":2,"1187":2,"1188":1,"1220":1},"2":{"116":2,"119":2,"333":1,"465":1,"536":1,"643":1,"838":2,"866":1,"921":1,"933":1,"1004":7,"1139":1,"1162":1,"1166":4,"1168":2,"1182":1,"1183":1,"1185":3,"1186":9,"1189":2,"1192":1,"1210":1}}],["tearing",{"2":{"1331":1}}],["tear",{"2":{"495":1,"1436":1}}],["teardowns",{"2":{"1371":1}}],["teardown",{"2":{"476":1,"1426":1,"1440":1,"1441":1,"1442":2}}],["teaches",{"2":{"737":1}}],["teach",{"2":{"223":1,"230":1,"237":1,"711":1}}],["tea",{"2":{"123":1}}],["teams",{"2":{"283":1,"529":1,"1085":1,"1146":1}}],["team",{"2":{"21":1,"248":1,"293":1,"532":1,"534":1,"859":1,"889":1,"896":1,"946":1,"988":3}}],["text",{"0":{"888":1,"1126":1},"1":{"889":1,"890":1,"891":1,"892":1,"893":1,"894":1,"895":1,"896":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1},"2":{"27":1,"204":2,"247":1,"326":1,"361":1,"364":1,"365":2,"370":3,"374":1,"377":3,"505":1,"869":1,"870":1,"882":1,"888":1,"891":1,"897":1,"907":1,"910":1,"919":3,"1004":1,"1009":1,"1017":1,"1091":3,"1098":1,"1112":3,"1126":1,"1127":1,"1128":2,"1129":1,"1130":3,"1132":1,"1304":1,"1309":1,"1313":1}}],["testimated=tserver+rtt2",{"2":{"1229":1}}],["testing",{"0":{"6":1,"573":1},"2":{"85":1,"89":2,"246":1,"329":1,"402":1,"422":1,"778":1,"996":1,"1000":1,"1032":1,"1459":1}}],["testability",{"2":{"644":1}}],["tests",{"0":{"602":1,"1455":1,"1456":1},"1":{"1456":1,"1457":1,"1458":1},"2":{"6":6,"329":1,"334":1,"602":1,"644":1,"679":1,"1441":1,"1445":1,"1454":2,"1457":1,"1459":2}}],["test",{"0":{"1453":1},"1":{"1454":1,"1455":1,"1456":1,"1457":1,"1458":1,"1459":1},"2":{"6":6,"8":1,"83":1,"116":1,"248":1,"402":1,"422":2,"446":1,"448":1,"451":3,"590":1,"635":1,"651":1,"665":2,"669":2,"702":1,"1371":1,"1378":1,"1426":1,"1431":1,"1453":1,"1454":1,"1456":1,"1457":1,"1458":1,"1459":5}}],["thought",{"2":{"701":1}}],["though",{"2":{"388":1,"453":1,"469":1,"732":1}}],["thousands",{"2":{"124":1,"174":1,"406":1,"407":1,"411":1,"1028":1,"1035":1,"1117":1,"1146":1,"1265":1}}],["those",{"2":{"250":1,"270":1,"376":1,"387":1,"504":1,"560":1,"1363":1,"1450":1}}],["thus",{"2":{"427":1,"511":1}}],["thu",{"2":{"393":1,"454":1,"1213":1,"1224":1}}],["thumb",{"2":{"250":1}}],["thursday",{"2":{"186":2,"190":1,"203":2,"369":1,"393":1,"896":1,"909":1,"925":1,"951":1,"954":1,"1093":1,"1197":2,"1221":2}}],["thin",{"2":{"527":1}}],["thinks",{"2":{"388":1}}],["third",{"0":{"1138":1},"1":{"1139":1,"1140":1,"1141":1},"2":{"43":1,"88":1,"114":1,"129":1,"204":1,"288":1,"413":1,"488":1,"867":1,"925":1,"934":1,"951":1,"954":1,"962":1,"966":1,"968":1,"970":1,"1011":1,"1012":1,"1059":2,"1076":1,"1225":1,"1263":2,"1264":1}}],["this",{"0":{"350":1,"351":1,"352":1,"353":1,"354":1},"2":{"0":1,"34":1,"43":1,"45":1,"76":1,"96":1,"102":2,"110":1,"114":1,"116":1,"118":1,"123":1,"124":1,"125":3,"128":1,"131":1,"137":1,"139":2,"148":1,"157":1,"158":2,"164":1,"167":1,"169":2,"176":1,"194":1,"197":1,"202":1,"207":1,"208":1,"213":1,"215":1,"218":1,"219":1,"220":1,"222":2,"224":19,"225":2,"228":2,"229":1,"230":1,"232":1,"233":6,"234":2,"235":2,"246":1,"249":1,"250":1,"256":1,"262":2,"263":2,"265":3,"266":1,"270":1,"274":1,"276":1,"279":2,"280":1,"281":7,"282":3,"294":1,"295":1,"296":1,"300":1,"301":2,"312":1,"313":5,"315":1,"316":1,"317":5,"319":2,"320":2,"321":2,"324":3,"326":3,"327":1,"328":1,"329":1,"331":1,"333":1,"342":1,"344":1,"346":1,"348":1,"350":2,"351":3,"352":1,"353":1,"355":1,"357":1,"360":1,"362":1,"364":1,"370":1,"371":1,"375":1,"377":1,"383":1,"387":1,"388":1,"390":1,"395":2,"402":2,"403":1,"406":1,"407":1,"409":1,"414":1,"415":1,"419":1,"422":1,"424":1,"425":1,"426":1,"427":1,"433":1,"434":1,"435":1,"438":1,"440":1,"441":1,"447":1,"451":2,"452":3,"456":1,"462":1,"465":1,"466":1,"468":1,"470":1,"471":1,"479":1,"484":2,"486":1,"491":1,"498":1,"502":1,"511":1,"513":1,"514":1,"519":1,"522":1,"536":1,"552":1,"562":1,"606":1,"617":2,"644":1,"651":1,"675":1,"676":1,"682":1,"702":3,"705":1,"716":2,"723":1,"724":1,"726":1,"728":2,"731":1,"732":1,"734":2,"737":4,"739":2,"741":1,"750":2,"844":1,"848":1,"869":1,"871":1,"881":1,"891":1,"898":2,"906":1,"908":1,"910":1,"911":1,"913":1,"921":1,"923":1,"933":1,"950":1,"970":1,"972":2,"993":1,"995":1,"1008":2,"1016":1,"1018":1,"1025":1,"1026":1,"1041":1,"1044":1,"1057":1,"1058":1,"1066":1,"1074":1,"1086":1,"1088":2,"1093":1,"1097":1,"1107":1,"1110":1,"1111":1,"1123":1,"1137":1,"1155":1,"1156":1,"1167":1,"1169":1,"1174":1,"1175":1,"1183":1,"1211":1,"1223":1,"1252":1,"1262":1,"1271":2,"1300":1,"1315":1,"1321":1,"1322":1,"1329":4,"1333":1,"1345":6,"1349":1,"1350":1,"1352":1,"1354":1,"1366":1,"1369":1,"1370":2,"1372":1,"1377":1,"1378":2,"1379":1,"1384":1,"1385":1,"1389":4,"1392":6,"1395":2,"1405":1,"1410":1,"1412":1,"1423":1,"1426":1,"1446":1,"1449":1,"1450":2,"1452":3,"1453":1}}],["threat",{"0":{"1011":1},"2":{"1011":2}}],["threaded",{"2":{"1367":1,"1385":1}}],["threadcount",{"2":{"1039":1}}],["threads",{"2":{"1018":1,"1019":1,"1021":1,"1022":2,"1029":1,"1033":2,"1037":1,"1041":1,"1368":1,"1370":1,"1373":1,"1376":1,"1377":1,"1381":1,"1382":1,"1387":1,"1388":1,"1389":2,"1392":1,"1394":1}}],["thread",{"0":{"1386":1},"1":{"1387":1,"1388":1,"1389":1},"2":{"15":1,"1029":1,"1033":1,"1039":2,"1040":1,"1042":2,"1367":1,"1368":2,"1369":1,"1377":1,"1378":1,"1382":1,"1383":1,"1387":1,"1388":1,"1389":1,"1391":1,"1394":4,"1395":1,"1443":1}}],["thresholds",{"0":{"875":1,"912":1},"2":{"1010":1,"1082":1,"1363":1,"1387":1}}],["threshold",{"2":{"871":1,"875":1,"881":1,"890":1,"899":1,"912":1,"920":1,"937":1,"938":1,"989":1,"1010":2,"1233":2,"1240":1,"1334":1,"1344":1,"1361":2,"1363":1}}],["three",{"0":{"379":1,"1269":1},"1":{"380":1,"381":1,"382":1},"2":{"161":1,"257":1,"285":1,"288":1,"290":1,"308":1,"321":1,"332":1,"361":1,"396":1,"397":1,"738":1,"920":1,"972":1,"1097":1,"1147":1,"1189":1,"1268":1,"1269":1}}],["throttleosm",{"2":{"1178":4}}],["throttle",{"2":{"1178":1}}],["throttling",{"2":{"947":1,"1258":1}}],["throw",{"2":{"161":1,"176":1,"271":1,"281":2,"282":1,"295":1,"358":1,"593":1,"782":1,"875":1,"912":1,"970":1,"973":1,"1004":1,"1010":1,"1141":1,"1221":1}}],["throws",{"2":{"146":1,"282":1,"358":1,"503":2,"517":2,"702":1,"806":1,"865":1,"871":1,"875":1,"876":1,"881":1,"890":1,"899":1,"912":1,"920":3,"962":1,"1088":1,"1376":1,"1445":1}}],["throwing",{"2":{"76":1,"117":1,"144":1,"261":1,"281":1,"389":1,"629":2,"651":1,"1257":1,"1422":1}}],["throughput",{"0":{"1027":1,"1039":1},"1":{"1028":1,"1029":1,"1030":1},"2":{"699":1,"798":1,"867":1,"947":1,"1018":1,"1022":1,"1030":1,"1122":2,"1147":1,"1225":1,"1368":1}}],["throughout",{"2":{"102":1,"462":1,"786":1}}],["through",{"2":{"21":2,"34":1,"117":1,"121":1,"168":1,"169":1,"203":1,"229":1,"273":1,"278":1,"321":1,"371":1,"375":1,"387":1,"407":1,"408":1,"420":1,"434":1,"453":1,"464":1,"466":1,"498":1,"502":2,"526":1,"574":1,"660":1,"709":1,"738":1,"763":1,"766":1,"776":2,"787":1,"854":1,"858":1,"859":1,"861":1,"913":1,"931":1,"947":1,"954":2,"955":1,"972":1,"995":1,"997":1,"1005":1,"1008":2,"1010":1,"1017":1,"1106":1,"1178":1,"1182":1,"1191":2,"1224":1,"1273":1,"1281":1,"1417":1,"1419":1}}],["than",{"2":{"44":1,"76":1,"94":1,"102":1,"125":1,"138":1,"144":1,"174":1,"181":1,"208":1,"247":1,"262":1,"276":1,"280":1,"445":1,"452":1,"469":1,"505":2,"559":1,"644":1,"744":1,"865":1,"875":1,"878":1,"886":1,"942":1,"1010":1,"1011":1,"1070":1,"1081":1,"1084":1,"1097":1,"1234":1,"1266":1,"1268":1,"1271":1}}],["thanksgivingthursday",{"2":{"1224":3}}],["thanksgiving",{"2":{"98":2,"908":1,"909":1,"918":1,"925":1,"934":1,"951":1,"954":1,"961":1,"973":1,"1213":4,"1224":2}}],["thanks",{"2":{"43":1}}],["thank",{"2":{"0":1,"23":1}}],["that",{"2":{"1":1,"5":1,"7":2,"11":1,"19":1,"34":3,"43":1,"47":1,"56":1,"69":1,"100":1,"102":1,"107":1,"110":2,"125":3,"127":1,"130":1,"147":1,"148":1,"170":1,"173":1,"180":1,"181":1,"198":2,"199":1,"202":1,"208":1,"214":1,"215":1,"219":1,"220":1,"228":1,"230":1,"231":1,"233":1,"234":2,"236":1,"238":1,"239":1,"243":1,"250":1,"260":1,"262":1,"263":1,"264":1,"265":1,"266":3,"274":1,"279":1,"281":5,"283":1,"291":2,"292":1,"295":1,"301":2,"310":1,"311":1,"315":1,"316":1,"317":2,"319":1,"325":1,"326":1,"329":1,"344":1,"345":1,"351":4,"356":1,"359":3,"364":2,"367":1,"375":1,"385":1,"387":2,"388":1,"398":1,"402":1,"407":2,"409":1,"414":2,"415":1,"416":3,"418":1,"423":1,"426":1,"428":1,"429":1,"430":1,"438":1,"440":1,"444":1,"446":1,"449":1,"451":1,"453":1,"464":2,"467":1,"470":1,"473":1,"476":1,"477":2,"479":1,"495":1,"502":1,"503":1,"504":2,"505":1,"506":1,"515":2,"516":2,"519":1,"522":2,"561":1,"573":1,"606":1,"631":1,"637":1,"642":1,"643":1,"651":1,"704":1,"709":1,"717":1,"724":1,"731":1,"741":1,"752":1,"757":1,"767":1,"831":1,"833":1,"836":1,"845":1,"875":1,"889":1,"891":1,"897":1,"900":1,"932":1,"939":1,"942":2,"948":1,"952":1,"968":2,"972":2,"973":1,"989":1,"992":1,"993":1,"1015":1,"1018":1,"1086":1,"1088":1,"1089":1,"1090":1,"1092":1,"1094":1,"1097":1,"1108":1,"1115":1,"1143":1,"1151":1,"1222":1,"1236":1,"1251":1,"1265":1,"1275":1,"1315":1,"1331":1,"1338":1,"1372":1,"1377":1,"1419":1,"1420":1,"1421":1,"1449":1,"1454":1}}],["theoretical",{"2":{"1231":1}}],["their",{"2":{"88":1,"155":1,"260":1,"266":1,"270":2,"275":1,"285":1,"291":1,"300":1,"311":1,"399":1,"403":1,"409":1,"447":1,"454":1,"498":2,"501":1,"514":1,"515":1,"522":1,"528":1,"618":1,"644":1,"716":1,"724":1,"732":1,"739":1,"758":1,"854":1,"869":1,"878":1,"936":1,"1004":1,"1039":1,"1093":1,"1124":1,"1157":1,"1190":2,"1223":1,"1259":1,"1260":1,"1351":1,"1376":1,"1391":1,"1448":1}}],["theme",{"2":{"622":1}}],["them",{"2":{"44":1,"76":1,"121":1,"124":1,"169":2,"180":1,"222":2,"229":1,"243":1,"263":1,"280":1,"286":1,"295":1,"326":1,"358":1,"388":1,"424":2,"427":1,"452":1,"456":1,"466":1,"468":2,"479":1,"481":1,"500":1,"509":1,"691":1,"708":1,"856":1,"906":1,"922":1,"958":1,"972":1,"1035":1,"1091":1,"1181":1,"1260":1}}],["thenable",{"2":{"592":1}}],["then",{"0":{"482":1},"2":{"43":1,"46":1,"102":1,"148":1,"270":1,"285":2,"319":1,"331":1,"359":1,"398":1,"424":1,"469":1,"482":3,"592":1,"1264":1,"1363":1}}],["thereafter",{"2":{"300":1}}],["there",{"2":{"43":1,"146":1,"180":1,"221":1,"257":1,"262":1,"549":1,"1089":2,"1225":1}}],["they",{"0":{"466":1,"504":1},"2":{"43":1,"44":1,"157":2,"173":1,"179":1,"181":2,"191":1,"198":1,"240":1,"266":1,"269":1,"279":1,"300":1,"302":1,"371":1,"399":1,"427":2,"452":1,"456":1,"470":1,"475":1,"479":2,"498":1,"503":1,"506":1,"510":1,"514":1,"559":1,"716":1,"732":1,"909":1,"1095":1,"1270":1,"1312":1}}],["these",{"2":{"0":1,"24":1,"125":1,"129":1,"173":2,"174":2,"220":1,"221":1,"237":1,"278":1,"280":1,"294":1,"295":2,"300":2,"315":1,"319":1,"326":1,"357":1,"363":2,"365":1,"374":1,"405":1,"407":2,"408":1,"410":1,"413":1,"421":1,"429":1,"441":1,"444":1,"446":1,"451":1,"457":1,"466":1,"470":2,"479":2,"483":1,"503":1,"504":1,"506":1,"559":1,"565":1,"737":1,"869":1,"878":1,"884":1,"902":1,"907":1,"909":1,"966":1,"1084":1,"1090":1,"1110":1,"1135":1,"1144":1,"1149":1,"1193":1,"1443":1,"1459":1}}],["the",{"0":{"12":1,"14":1,"42":1,"43":1,"51":1,"52":1,"71":1,"102":1,"160":1,"169":1,"170":1,"182":1,"183":1,"184":1,"218":1,"228":1,"231":1,"232":1,"233":1,"236":1,"258":1,"259":1,"260":1,"262":1,"264":1,"265":1,"266":1,"268":1,"269":1,"270":1,"272":1,"281":1,"286":1,"316":1,"319":1,"321":1,"323":1,"329":1,"330":1,"339":1,"357":1,"358":1,"379":1,"387":1,"407":1,"424":1,"425":1,"426":1,"429":1,"431":1,"432":1,"433":1,"434":1,"440":1,"445":1,"467":1,"468":1,"469":1,"499":1,"503":1,"506":1,"509":1,"514":1,"521":1,"524":1,"551":1,"878":1,"910":1,"1087":1,"1088":2,"1109":1,"1110":1,"1157":1,"1260":1,"1261":1,"1269":1,"1271":1,"1303":1,"1306":1,"1309":1,"1312":1,"1368":1,"1379":1},"1":{"52":1,"53":1,"54":1,"55":1,"56":1,"103":1,"104":1,"105":1,"106":1,"107":1,"108":1,"109":1,"185":1,"186":1,"187":1,"188":1,"189":1,"190":1,"191":1,"266":1,"270":1,"331":1,"332":1,"333":1,"334":1,"335":1,"336":1,"380":1,"381":1,"382":1,"425":1,"426":1,"427":2,"428":2,"429":1,"433":1,"434":1,"435":1,"468":1,"469":1,"500":1,"501":1,"502":1,"507":1,"508":1,"509":1,"510":1,"511":1,"512":1,"513":1,"514":1,"515":1,"522":1,"523":1,"524":1,"525":1,"526":1,"527":1,"528":1,"911":1,"912":1,"1088":1,"1089":1,"1090":1,"1091":1,"1110":1,"1111":1,"1112":1,"1369":1,"1370":1,"1380":1},"2":{"0":3,"6":4,"7":3,"8":4,"10":5,"11":2,"12":1,"13":1,"14":2,"17":1,"19":2,"20":1,"21":1,"22":4,"23":2,"24":1,"27":1,"28":1,"29":1,"30":1,"31":2,"32":1,"34":6,"35":1,"38":1,"39":4,"41":4,"42":4,"43":14,"44":5,"45":5,"46":6,"47":3,"48":1,"50":1,"52":2,"54":2,"59":1,"62":1,"63":7,"64":2,"69":1,"71":1,"72":2,"73":1,"75":2,"76":11,"77":2,"78":2,"87":1,"88":2,"89":4,"90":3,"91":1,"93":1,"94":3,"95":1,"96":1,"97":2,"98":3,"99":3,"100":1,"101":2,"102":5,"105":1,"106":1,"109":5,"110":3,"111":4,"112":2,"114":1,"115":1,"116":3,"117":2,"118":3,"120":5,"124":7,"125":9,"126":2,"127":1,"128":2,"129":5,"130":1,"131":4,"132":3,"133":2,"134":2,"135":3,"136":1,"137":3,"138":27,"139":6,"140":2,"141":1,"143":1,"144":3,"145":2,"146":10,"147":6,"148":5,"149":3,"150":11,"151":6,"152":8,"154":1,"155":5,"156":2,"157":2,"158":10,"159":2,"160":1,"161":5,"163":1,"164":2,"165":2,"167":4,"168":2,"169":3,"170":4,"171":2,"173":5,"174":4,"175":1,"177":2,"179":1,"180":1,"181":3,"182":1,"183":1,"184":1,"185":2,"186":2,"188":2,"189":1,"191":10,"194":4,"195":2,"197":2,"198":5,"199":4,"200":2,"201":1,"202":4,"203":2,"204":1,"205":4,"207":1,"208":2,"210":2,"211":1,"213":1,"214":2,"215":2,"216":4,"217":2,"218":3,"219":6,"220":3,"221":1,"222":2,"223":1,"224":3,"225":1,"226":1,"227":4,"228":5,"229":4,"230":5,"231":1,"232":3,"233":8,"234":3,"240":2,"243":1,"245":2,"246":2,"247":2,"248":1,"249":2,"250":1,"251":2,"253":1,"254":1,"255":1,"256":1,"260":1,"261":4,"262":5,"263":4,"264":2,"265":5,"266":10,"268":5,"269":8,"270":5,"271":6,"272":1,"273":5,"274":5,"275":3,"276":19,"278":4,"279":3,"280":6,"281":4,"282":5,"283":3,"284":1,"285":5,"286":1,"289":2,"290":1,"291":4,"292":1,"293":2,"294":1,"295":1,"297":5,"298":5,"300":7,"301":12,"302":1,"303":2,"304":2,"305":5,"306":1,"307":1,"309":1,"311":2,"312":3,"313":8,"314":3,"315":2,"316":4,"319":4,"321":8,"325":1,"326":7,"327":5,"328":2,"329":1,"330":1,"331":5,"334":2,"335":2,"336":3,"337":2,"339":2,"340":5,"341":1,"342":1,"343":3,"344":3,"345":2,"347":2,"348":2,"350":2,"351":14,"352":3,"353":1,"354":1,"355":4,"356":2,"357":9,"358":1,"359":9,"360":1,"361":4,"362":8,"363":4,"364":2,"365":5,"366":6,"367":3,"370":10,"371":2,"374":3,"375":1,"376":2,"377":4,"378":2,"380":6,"381":5,"382":7,"383":14,"384":1,"385":3,"386":2,"387":5,"388":4,"390":1,"391":1,"392":1,"393":6,"394":2,"396":1,"397":1,"398":2,"399":8,"402":7,"403":2,"404":1,"406":2,"407":6,"408":5,"409":4,"410":1,"411":2,"412":5,"414":6,"415":3,"416":14,"418":5,"419":9,"421":5,"422":3,"423":6,"424":5,"425":8,"426":6,"427":14,"428":1,"429":8,"430":2,"431":2,"433":3,"434":2,"435":3,"437":6,"438":2,"439":3,"440":8,"441":1,"442":1,"444":6,"445":2,"446":5,"447":3,"448":1,"449":5,"450":2,"451":4,"452":3,"453":5,"454":3,"456":12,"457":2,"458":2,"459":2,"461":3,"462":2,"463":1,"465":5,"466":5,"467":2,"468":5,"469":7,"470":1,"471":2,"472":1,"473":2,"475":3,"477":2,"479":5,"480":1,"481":2,"482":1,"484":3,"486":4,"487":1,"488":3,"489":3,"490":1,"491":1,"498":2,"499":2,"501":2,"502":1,"504":3,"505":3,"506":3,"509":2,"510":2,"511":1,"512":3,"513":2,"514":6,"515":3,"516":3,"517":2,"518":5,"519":7,"520":6,"522":2,"524":3,"525":1,"527":2,"528":3,"534":2,"539":2,"541":4,"543":1,"544":1,"546":3,"547":1,"548":3,"552":2,"553":1,"555":3,"556":4,"558":1,"559":6,"560":1,"561":3,"562":1,"563":1,"564":1,"565":7,"567":2,"569":1,"571":2,"572":1,"574":1,"578":1,"579":1,"584":3,"585":1,"606":3,"607":2,"616":1,"617":6,"625":5,"626":3,"627":1,"629":1,"630":1,"631":3,"634":1,"635":2,"637":1,"642":2,"643":1,"644":3,"645":1,"647":4,"648":2,"649":6,"651":2,"659":2,"665":2,"666":1,"667":4,"668":1,"671":1,"672":2,"675":1,"676":2,"678":2,"679":1,"680":1,"681":1,"683":1,"684":1,"687":1,"688":1,"689":1,"691":1,"692":1,"695":1,"697":1,"699":1,"701":2,"702":1,"704":2,"705":1,"707":5,"708":3,"709":4,"711":3,"712":3,"714":1,"717":2,"719":1,"720":2,"722":3,"723":3,"724":3,"729":2,"731":2,"732":5,"734":2,"735":1,"737":2,"738":10,"739":4,"741":1,"743":1,"744":1,"746":2,"747":3,"748":2,"750":6,"751":2,"752":6,"754":2,"755":1,"757":8,"759":4,"760":1,"763":1,"765":1,"766":2,"767":1,"769":1,"771":1,"776":2,"780":1,"782":2,"784":2,"786":2,"790":2,"792":1,"795":1,"800":1,"806":2,"808":1,"817":3,"818":1,"831":2,"832":1,"833":3,"836":1,"839":1,"841":1,"842":1,"845":2,"846":1,"848":1,"850":2,"851":1,"852":1,"853":1,"855":3,"856":9,"860":4,"861":1,"863":2,"865":1,"866":1,"867":1,"868":1,"869":1,"871":3,"872":1,"874":3,"875":2,"876":3,"878":2,"879":2,"881":2,"882":3,"884":2,"886":3,"890":1,"891":5,"893":2,"897":1,"899":2,"900":3,"902":3,"906":2,"907":7,"908":4,"909":6,"910":5,"911":8,"912":2,"913":1,"915":1,"916":1,"918":1,"919":1,"920":1,"921":2,"922":2,"923":1,"924":1,"925":2,"926":1,"929":1,"932":1,"933":1,"934":7,"935":1,"936":5,"941":2,"942":6,"945":1,"946":3,"947":3,"948":2,"949":2,"950":2,"951":1,"952":1,"954":7,"955":1,"958":2,"960":1,"961":1,"963":1,"965":1,"966":2,"968":3,"969":4,"970":7,"972":10,"973":3,"975":3,"976":3,"977":4,"979":1,"980":2,"981":1,"985":2,"986":2,"987":1,"989":3,"991":1,"992":9,"993":8,"994":2,"996":1,"998":3,"1001":1,"1004":2,"1007":1,"1008":7,"1009":2,"1010":2,"1011":5,"1012":3,"1013":3,"1015":1,"1018":1,"1019":3,"1021":4,"1022":1,"1023":1,"1025":1,"1028":1,"1029":3,"1030":1,"1033":3,"1035":2,"1036":2,"1037":1,"1038":2,"1039":7,"1040":5,"1042":1,"1045":4,"1047":4,"1049":1,"1054":3,"1057":1,"1059":1,"1060":2,"1062":6,"1063":8,"1064":3,"1065":3,"1067":5,"1068":5,"1069":7,"1071":2,"1072":6,"1075":4,"1077":1,"1078":4,"1079":2,"1080":1,"1081":2,"1082":1,"1084":3,"1085":1,"1086":3,"1088":8,"1089":4,"1090":2,"1091":1,"1092":1,"1093":10,"1094":3,"1095":5,"1096":1,"1097":3,"1099":1,"1103":2,"1104":2,"1105":2,"1106":1,"1107":1,"1108":1,"1110":10,"1111":3,"1113":4,"1115":1,"1118":2,"1124":1,"1125":4,"1134":1,"1136":2,"1140":2,"1144":2,"1147":2,"1153":1,"1154":1,"1155":1,"1156":1,"1157":3,"1158":5,"1162":1,"1164":1,"1168":3,"1173":4,"1174":1,"1176":1,"1178":1,"1179":2,"1182":2,"1184":1,"1185":1,"1186":1,"1188":5,"1189":2,"1190":1,"1191":1,"1194":2,"1195":2,"1197":2,"1201":1,"1203":1,"1205":2,"1206":1,"1211":1,"1212":1,"1213":3,"1214":2,"1215":4,"1217":1,"1218":1,"1219":5,"1220":1,"1221":5,"1222":5,"1224":3,"1227":4,"1231":1,"1232":3,"1233":4,"1234":4,"1235":1,"1236":1,"1239":1,"1243":1,"1245":1,"1246":1,"1247":1,"1248":1,"1250":1,"1251":1,"1254":2,"1257":1,"1258":1,"1260":1,"1261":1,"1262":2,"1265":1,"1266":1,"1268":1,"1269":14,"1270":19,"1271":12,"1272":5,"1273":10,"1275":1,"1276":3,"1281":1,"1284":2,"1285":1,"1286":1,"1291":2,"1292":1,"1293":1,"1300":1,"1303":2,"1304":2,"1309":1,"1312":2,"1313":1,"1315":2,"1316":1,"1318":3,"1319":1,"1321":1,"1325":2,"1329":2,"1332":1,"1334":1,"1338":2,"1339":1,"1341":1,"1344":1,"1349":1,"1351":3,"1352":1,"1355":2,"1358":2,"1359":2,"1360":1,"1362":1,"1365":3,"1366":3,"1367":1,"1368":2,"1369":2,"1370":4,"1371":1,"1372":4,"1374":5,"1375":1,"1376":1,"1377":1,"1378":2,"1382":6,"1384":1,"1388":3,"1392":4,"1394":3,"1395":3,"1396":1,"1405":1,"1410":1,"1411":1,"1414":1,"1415":5,"1417":4,"1419":1,"1421":5,"1423":1,"1425":1,"1426":1,"1427":3,"1429":2,"1432":1,"1433":3,"1434":1,"1435":1,"1436":1,"1442":3,"1443":1,"1444":1,"1445":4,"1446":2,"1448":6,"1450":2,"1451":1,"1452":3,"1453":2,"1454":2,"1457":1,"1458":1,"1459":3}}],["toclassical",{"0":{"1287":1}}],["toauc",{"0":{"1285":1},"2":{"1280":1,"1307":1}}],["toromanclassical",{"0":{"1284":1},"2":{"1271":1,"1280":4,"1307":1,"1310":1}}],["toronto",{"2":{"218":1}}],["totp",{"0":{"1266":1},"2":{"1242":1,"1266":1}}],["totalcalendardays",{"2":{"1223":3}}],["totaldaylighthours",{"2":{"1082":1}}],["totaltimems",{"2":{"449":1}}],["total",{"2":{"137":1,"138":1,"150":1,"442":1,"449":1,"720":1,"882":3,"986":1,"1053":3,"1065":4,"1067":1,"1072":1,"1082":1,"1089":1,"1131":2,"1132":2,"1203":1,"1427":1}}],["toussaint",{"2":{"1213":1}}],["tourist",{"2":{"1190":1}}],["touppercase",{"2":{"1178":2}}],["touching",{"2":{"1395":1}}],["touches",{"2":{"953":1,"1007":1}}],["touch",{"2":{"534":1,"1187":1,"1324":1}}],["tower",{"2":{"1233":1}}],["town",{"2":{"1178":2}}],["towards",{"2":{"1270":1}}],["toward",{"2":{"626":1}}],["tofixed",{"2":{"1082":1,"1329":1,"1347":2,"1348":1,"1365":2}}],["toformat",{"0":{"1118":1},"2":{"78":2,"1102":1,"1104":1,"1118":2,"1122":1,"1146":1,"1147":2}}],["toggle",{"2":{"937":1}}],["together",{"2":{"138":1,"140":1,"192":1,"407":1,"522":1,"747":1,"878":1,"1008":1}}],["tontptime",{"0":{"1251":1}}],["tone",{"2":{"898":1,"899":1,"973":1}}],["tones",{"2":{"897":1}}],["tonow",{"2":{"224":1}}],["tolerated",{"2":{"1367":1}}],["tolerant",{"2":{"939":1}}],["tolerance",{"2":{"896":1}}],["toldml",{"2":{"1116":2}}],["tolowercase",{"2":{"324":1}}],["tolocalestring",{"2":{"146":1,"147":1,"364":1,"513":1,"518":1,"731":1,"752":1}}],["tooroptions",{"2":{"1104":2}}],["too",{"2":{"860":1,"945":1,"948":1,"970":1,"1146":1}}],["tooling",{"0":{"669":1}}],["toolchain",{"2":{"618":1}}],["tools",{"2":{"116":1,"236":1,"263":1,"265":1,"273":1,"300":1,"498":1,"506":1,"692":1,"953":1,"1021":1,"1104":1,"1309":1}}],["tool",{"0":{"25":1},"1":{"26":1,"27":1,"28":1,"29":1},"2":{"48":1,"291":1,"298":1,"351":1,"423":1,"514":1,"528":1,"1147":1}}],["tojson",{"0":{"691":1},"2":{"691":1,"998":1}}],["toss",{"2":{"504":1}}],["tostring",{"2":{"45":1,"52":1,"125":1,"197":1,"355":1,"453":1,"468":1,"850":1,"1103":1,"1104":1}}],["tod",{"0":{"306":1},"2":{"306":1,"307":1,"309":1,"771":1,"775":1,"1415":1}}],["today",{"2":{"82":1,"87":1,"140":2,"157":3,"220":1,"393":4,"394":3,"506":1,"525":1,"528":1,"642":1,"680":1,"735":1,"824":1,"1280":3}}],["todatetime",{"2":{"81":1,"224":2,"233":1}}],["todate",{"2":{"80":1}}],["toholiday",{"2":{"276":1}}],["tokyotime",{"2":{"1429":1}}],["tokyonative",{"2":{"1190":2}}],["tokyodt",{"2":{"908":1}}],["tokyo",{"2":{"146":1,"296":1,"787":2,"908":1,"1157":1,"1160":1,"1359":2,"1429":2,"1430":1,"1447":1}}],["tokencount",{"2":{"1147":1}}],["tokenization",{"2":{"1106":1,"1121":1,"1134":1}}],["tokenized",{"2":{"1106":1}}],["tokens",{"0":{"137":1,"141":1,"142":1,"143":1,"147":1,"370":1,"518":1,"731":1,"823":1},"1":{"138":1,"139":1,"140":1,"142":1,"143":1,"144":1,"145":1},"2":{"30":1,"32":1,"75":1,"76":1,"83":1,"96":1,"97":1,"115":1,"117":1,"131":2,"137":2,"138":8,"139":1,"140":2,"141":1,"142":1,"145":1,"146":1,"147":2,"152":1,"186":1,"205":2,"243":1,"247":2,"369":1,"370":3,"421":1,"466":1,"507":1,"544":1,"588":1,"704":2,"705":1,"719":1,"731":2,"732":2,"738":1,"743":3,"758":3,"763":2,"766":1,"773":1,"788":1,"817":1,"821":1,"869":1,"909":1,"936":1,"941":1,"955":1,"968":1,"969":1,"972":3,"995":1,"997":1,"1003":1,"1004":1,"1011":1,"1088":1,"1089":1,"1090":3,"1091":1,"1096":1,"1097":1,"1098":3,"1099":1,"1105":2,"1112":2,"1113":1,"1115":1,"1121":1,"1123":1,"1124":1,"1128":1,"1132":1,"1136":1,"1147":1,"1266":1,"1313":1,"1363":1}}],["token",{"0":{"138":1,"732":1,"819":1,"972":1,"1087":1,"1089":1,"1090":1,"1109":1,"1123":1,"1124":1},"1":{"1088":1,"1089":1,"1090":1,"1091":1,"1110":1,"1111":1,"1112":1,"1124":1,"1125":1,"1126":1,"1127":1,"1128":1,"1129":1,"1130":1,"1131":1,"1132":1,"1133":1,"1134":1,"1135":1,"1136":1},"2":{"24":1,"27":1,"48":1,"78":1,"130":1,"137":2,"138":1,"139":4,"142":1,"144":1,"147":4,"150":3,"188":1,"204":1,"205":1,"214":1,"247":1,"256":1,"323":2,"324":3,"361":1,"388":1,"416":3,"477":1,"507":3,"513":1,"704":1,"707":2,"720":1,"723":1,"738":1,"743":1,"750":1,"752":1,"763":2,"766":4,"768":1,"771":1,"775":1,"778":1,"784":1,"806":2,"819":1,"854":4,"856":1,"859":1,"867":2,"897":2,"933":1,"940":1,"942":1,"949":1,"951":1,"954":1,"955":2,"958":1,"972":1,"978":2,"1004":3,"1008":1,"1025":1,"1055":1,"1086":5,"1088":1,"1089":2,"1090":3,"1095":2,"1096":1,"1098":3,"1103":2,"1104":4,"1105":4,"1107":1,"1109":1,"1113":4,"1120":1,"1121":2,"1122":1,"1132":1,"1134":1,"1147":1,"1149":1,"1211":1,"1252":1,"1321":1,"1349":1,"1363":1,"1384":1,"1410":1}}],["tozoneddatetime",{"2":{"146":1}}],["toinstant",{"2":{"81":1}}],["tomorrow",{"2":{"42":1,"59":1,"82":1,"158":1,"220":1,"223":2,"363":1,"888":1,"889":1,"909":1,"949":1,"951":1,"1012":1,"1157":1}}],["topic",{"0":{"1210":1,"1299":1}}],["topocentric",{"0":{"1058":1,"1062":1},"1":{"1059":1,"1060":1,"1061":1,"1062":1,"1063":1,"1064":1,"1065":1},"2":{"1052":2,"1053":2,"1058":1,"1061":1,"1064":1,"1071":2,"1080":1}}],["topologies",{"2":{"500":1}}],["topology",{"0":{"94":1},"2":{"504":1,"697":1}}],["toprimitive",{"2":{"355":1}}],["toplaindate",{"2":{"81":1}}],["top",{"2":{"0":1,"43":1,"102":1,"376":1,"458":1,"477":1,"513":1,"516":1,"544":3,"565":1,"644":1,"775":1,"786":1,"836":2,"1452":1}}],["to",{"0":{"0":1,"21":1,"22":1,"63":1,"68":1,"80":1,"81":1,"96":1,"169":1,"185":1,"204":1,"312":1,"315":1,"535":1,"547":1,"548":1,"549":1,"566":1,"1013":1,"1014":1,"1089":1,"1451":1,"1452":1},"1":{"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"97":1,"186":1,"187":1,"188":1,"189":1,"190":1,"313":1,"314":1,"315":1,"316":1,"317":1,"536":1,"537":1,"538":1,"539":1,"548":1,"550":1,"551":1,"552":1,"553":1,"554":1,"555":1,"556":1,"557":1,"558":1,"559":1,"560":1,"561":1,"562":1,"563":1,"564":1,"565":1,"566":1,"567":2,"568":2,"569":2,"570":1,"571":1,"572":1,"573":1},"2":{"0":2,"5":1,"6":1,"10":2,"22":2,"23":1,"24":2,"26":3,"27":2,"30":2,"33":1,"34":3,"39":2,"41":1,"42":1,"43":6,"44":5,"45":1,"46":2,"47":4,"48":1,"52":1,"56":1,"59":1,"63":3,"64":2,"69":1,"75":1,"76":5,"78":1,"83":1,"84":1,"90":2,"93":1,"94":2,"95":3,"97":1,"98":1,"100":1,"102":8,"106":1,"109":4,"110":3,"111":1,"112":1,"114":2,"115":3,"116":2,"117":4,"119":2,"121":1,"122":1,"123":1,"124":2,"125":4,"126":1,"127":1,"128":2,"129":3,"131":4,"132":2,"135":1,"137":4,"138":19,"139":2,"140":1,"142":2,"144":1,"146":2,"147":3,"148":1,"149":2,"152":1,"155":1,"157":1,"158":1,"161":6,"162":2,"163":2,"164":2,"165":1,"167":2,"169":1,"170":3,"172":1,"173":2,"179":1,"180":1,"184":1,"185":2,"186":10,"188":2,"189":3,"190":3,"191":6,"192":4,"194":4,"195":1,"197":1,"198":1,"199":1,"202":3,"204":1,"205":1,"208":1,"209":2,"210":2,"211":1,"212":1,"213":1,"215":1,"216":1,"217":2,"218":2,"219":3,"220":1,"221":3,"222":1,"223":3,"224":4,"225":2,"226":1,"227":2,"228":1,"229":5,"230":1,"231":3,"232":1,"233":4,"235":3,"236":2,"237":1,"238":1,"239":2,"243":1,"246":2,"247":2,"248":1,"249":1,"257":1,"258":1,"261":3,"262":3,"263":3,"264":1,"265":3,"266":4,"269":1,"270":2,"271":3,"272":1,"273":2,"274":5,"275":3,"276":6,"280":2,"281":1,"282":1,"283":1,"284":2,"286":1,"289":1,"290":1,"292":2,"293":4,"294":3,"295":2,"296":4,"297":8,"298":3,"300":6,"301":3,"304":1,"308":1,"309":1,"316":1,"317":1,"318":1,"319":1,"320":1,"321":5,"324":1,"325":2,"326":8,"327":1,"331":5,"335":1,"336":1,"337":1,"338":3,"339":1,"340":1,"341":2,"342":1,"343":1,"346":1,"349":1,"350":1,"351":2,"355":1,"356":1,"358":2,"359":2,"360":2,"361":2,"362":4,"363":2,"364":4,"365":3,"366":1,"367":2,"368":6,"369":3,"370":9,"371":3,"372":2,"373":2,"374":2,"375":3,"376":1,"377":2,"378":1,"380":3,"381":3,"382":4,"384":1,"387":1,"388":1,"389":4,"390":3,"393":8,"396":1,"398":2,"399":4,"402":4,"403":2,"405":1,"406":3,"407":1,"408":1,"409":2,"412":2,"413":1,"414":2,"416":3,"418":1,"421":1,"422":2,"425":3,"427":5,"429":1,"430":1,"431":1,"433":1,"434":1,"435":2,"437":1,"438":3,"439":1,"440":2,"441":1,"442":1,"445":1,"446":3,"447":4,"449":2,"451":3,"452":2,"454":1,"455":1,"456":1,"465":2,"468":3,"469":3,"470":1,"471":1,"472":2,"473":1,"474":2,"475":2,"476":2,"478":1,"479":2,"480":1,"481":1,"482":2,"483":1,"485":2,"489":3,"491":1,"498":1,"502":1,"503":1,"504":6,"509":2,"510":1,"511":1,"512":1,"513":2,"514":5,"515":3,"516":2,"517":1,"518":1,"519":5,"520":4,"522":2,"524":1,"525":1,"526":1,"527":2,"528":2,"529":1,"533":1,"534":2,"541":3,"543":1,"544":2,"546":3,"549":1,"555":1,"556":1,"559":3,"560":2,"561":1,"565":3,"567":1,"569":1,"571":1,"572":2,"579":1,"580":1,"582":1,"584":2,"590":1,"593":2,"603":1,"606":7,"607":2,"616":3,"617":3,"618":2,"625":3,"627":2,"629":1,"630":2,"631":1,"633":1,"634":2,"635":1,"637":4,"642":1,"644":2,"645":1,"647":2,"648":2,"649":3,"651":4,"653":1,"654":2,"657":3,"659":1,"663":2,"664":1,"665":1,"667":1,"668":2,"669":3,"672":2,"675":1,"680":3,"684":1,"691":1,"692":2,"694":1,"696":1,"699":1,"701":2,"702":3,"705":1,"707":2,"708":2,"709":3,"711":3,"712":1,"716":2,"717":1,"722":1,"723":1,"724":1,"726":1,"729":1,"731":2,"732":3,"734":4,"735":2,"738":2,"739":2,"741":1,"743":1,"747":4,"748":1,"750":2,"751":1,"755":2,"757":1,"758":1,"759":1,"760":2,"765":1,"767":1,"771":2,"776":1,"778":3,"782":1,"786":1,"797":1,"798":1,"806":2,"816":1,"817":2,"818":1,"825":1,"829":3,"831":1,"836":2,"838":1,"839":1,"842":1,"844":1,"845":2,"848":1,"850":1,"851":2,"852":1,"854":2,"855":2,"856":5,"857":1,"858":1,"859":1,"860":2,"862":2,"863":1,"864":1,"865":1,"866":2,"869":2,"871":7,"872":1,"876":1,"877":1,"878":3,"879":1,"881":7,"882":1,"884":2,"885":1,"886":1,"887":1,"888":2,"889":1,"890":9,"891":1,"893":2,"896":1,"897":2,"899":8,"902":2,"904":1,"906":1,"907":2,"908":2,"909":2,"910":2,"911":2,"912":1,"913":1,"918":1,"920":1,"921":1,"922":1,"931":1,"934":3,"936":3,"937":4,"938":7,"942":3,"945":2,"946":3,"947":2,"950":2,"953":2,"954":7,"958":1,"959":4,"963":1,"964":1,"965":1,"966":1,"970":2,"971":1,"972":2,"973":1,"974":1,"975":3,"977":1,"980":1,"983":1,"984":1,"985":1,"986":1,"987":1,"989":6,"992":1,"994":1,"996":1,"997":3,"998":1,"1001":1,"1004":1,"1005":2,"1008":5,"1009":1,"1010":1,"1011":5,"1012":2,"1014":1,"1017":3,"1019":1,"1022":1,"1028":1,"1029":3,"1033":1,"1035":2,"1036":2,"1039":2,"1040":1,"1041":3,"1042":2,"1043":1,"1053":1,"1054":4,"1055":3,"1063":2,"1064":3,"1065":1,"1067":2,"1069":2,"1070":1,"1072":2,"1075":1,"1077":3,"1078":1,"1081":1,"1083":1,"1086":4,"1088":2,"1090":2,"1091":1,"1092":1,"1093":3,"1094":1,"1095":2,"1097":2,"1098":2,"1099":2,"1103":1,"1104":5,"1105":1,"1106":1,"1108":2,"1109":1,"1110":1,"1113":1,"1114":2,"1115":6,"1116":3,"1121":1,"1122":2,"1123":3,"1124":2,"1125":3,"1127":1,"1129":1,"1132":1,"1134":1,"1136":3,"1140":1,"1143":2,"1144":1,"1147":4,"1149":2,"1150":3,"1157":1,"1158":1,"1160":1,"1161":1,"1167":3,"1168":2,"1172":1,"1175":2,"1176":4,"1178":1,"1181":1,"1182":1,"1184":1,"1185":1,"1187":1,"1188":1,"1190":3,"1195":2,"1197":1,"1203":4,"1204":1,"1209":1,"1215":2,"1220":1,"1223":1,"1224":2,"1225":1,"1232":1,"1234":3,"1240":1,"1242":1,"1243":1,"1245":1,"1246":1,"1250":1,"1254":1,"1255":2,"1257":1,"1258":1,"1262":1,"1263":4,"1268":1,"1269":1,"1270":1,"1271":2,"1272":1,"1273":1,"1276":2,"1281":1,"1288":1,"1303":1,"1304":2,"1309":1,"1312":1,"1315":2,"1316":1,"1318":2,"1319":7,"1324":2,"1325":1,"1326":1,"1329":3,"1332":4,"1334":1,"1338":1,"1341":1,"1344":7,"1345":6,"1358":3,"1360":1,"1361":1,"1365":1,"1368":1,"1370":1,"1374":1,"1375":1,"1376":1,"1377":1,"1378":2,"1379":1,"1382":2,"1387":1,"1388":1,"1392":2,"1408":1,"1415":1,"1422":2,"1427":1,"1428":2,"1435":2,"1442":1,"1443":2,"1444":3,"1447":1,"1448":1,"1450":2,"1452":1,"1454":1,"1457":1,"1458":1,"1459":4}}]],"serializationVersion":2}';export{e as default}; diff --git a/packages/tempo/public/v4/assets/chunks/VPLocalSearchBox.0TnTKVFI.js b/packages/tempo/public/v4/assets/chunks/VPLocalSearchBox.0TnTKVFI.js new file mode 100644 index 00000000..f03caa41 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/VPLocalSearchBox.0TnTKVFI.js @@ -0,0 +1,9 @@ +import{V as _t,q as De,a7 as Et,h as pe,a8 as He,a9 as Tt,aa as It,ab as kt,G as re,d as Nt,ac as Ge,p as ce,ad as Ft,ae as Rt,s as Ot,af as At,v as Fe,P as ue,O as ge,ag as Ct,ah as Mt,W as Lt,R as Dt,$ as Pt,o as W,b as zt,j as E,a0 as Vt,k as C,a3 as jt,a4 as $t,ai as Bt,c as q,n as Qe,e as be,B as Ye,F as Ze,a as de,t as fe,aj as Wt,ak as Xe,al as Kt,am as Jt,an as Ut,ao as qt,_ as Ht}from"./framework.DNL3hc5c.js";import{u as Gt,c as Qt}from"./theme.BHijFyhG.js";const Yt={root:()=>_t(()=>import("./@localSearchIndexroot._Rh608I2.js"),[])};/*! +* tabbable 6.5.0 +* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE +*/var ct=["input:not([inert]):not([inert] *)","select:not([inert]):not([inert] *)","textarea:not([inert]):not([inert] *)","a[href]:not([inert]):not([inert] *)","area[href]:not([inert]):not([inert] *)","button:not([inert]):not([inert] *)","[tabindex]:not(slot):not([inert]):not([inert] *)","audio[controls]:not([inert]):not([inert] *)","video[controls]:not([inert]):not([inert] *)",'[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)',"details>summary:first-of-type:not([inert]):not([inert] *)","details:not([inert]):not([inert] *)"],xe=ct.join(","),ut=typeof Element>"u",ee=ut?function(){}:Element.prototype.matches||Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector,_e=!ut&&Element.prototype.getRootNode?function(a){var e;return a==null||(e=a.getRootNode)===null||e===void 0?void 0:e.call(a)}:function(a){return a?.ownerDocument},Ee=function(e,t){var n;t===void 0&&(t=!0);var r=e==null||(n=e.getAttribute)===null||n===void 0?void 0:n.call(e,"inert"),s=r===""||r==="true",i=s||t&&e&&(typeof e.closest=="function"?e.closest("[inert]"):Ee(e.parentNode));return i},Zt=function(e){var t,n=e==null||(t=e.getAttribute)===null||t===void 0?void 0:t.call(e,"contenteditable");return n===""||n==="true"},dt=function(e,t,n){if(Ee(e))return[];var r=Array.prototype.slice.apply(e.querySelectorAll(xe));return t&&ee.call(e,xe)&&r.unshift(e),r=r.filter(n),r},Te=function(e,t,n){for(var r=[],s=Array.from(e);s.length;){var i=s.shift();if(!Ee(i,!1))if(i.tagName==="SLOT"){var o=i.assignedElements(),l=o.length?o:i.children,c=Te(l,!0,n);n.flatten?r.push.apply(r,c):r.push({scopeParent:i,candidates:c})}else{var h=ee.call(i,xe);h&&n.filter(i)&&(t||!e.includes(i))&&r.push(i);var v=i.shadowRoot||typeof n.getShadowRoot=="function"&&n.getShadowRoot(i),p=!Ee(v,!1)&&(!n.shadowRootFilter||n.shadowRootFilter(i));if(v&&p){var y=Te(v===!0?i.children:v.children,!0,n);n.flatten?r.push.apply(r,y):r.push({scopeParent:i,candidates:y})}else s.unshift.apply(s,i.children)}}return r},ft=function(e){return!isNaN(parseInt(e.getAttribute("tabindex"),10))},X=function(e){if(!e)throw new Error("No node provided");return e.tabIndex<0&&(/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName)||Zt(e))&&!ft(e)?0:e.tabIndex},Xt=function(e,t){var n=X(e);return n<0&&t&&!ft(e)?0:n},en=function(e,t){return e.tabIndex===t.tabIndex?e.documentOrder-t.documentOrder:e.tabIndex-t.tabIndex},ht=function(e){return e.tagName==="INPUT"},tn=function(e){return ht(e)&&e.type==="hidden"},nn=function(e){var t=e.tagName==="DETAILS"&&Array.prototype.slice.apply(e.children).some(function(n){return n.tagName==="SUMMARY"});return t},rn=function(e,t){for(var n=0;nsummary:first-of-type"),c=l?e.parentElement:e;if(ee.call(c,"details:not([open]) *"))return!0;if(!n||n==="full"||n==="full-native"||n==="legacy-full"){if(typeof r=="function"){for(var h=e;e;){var v=e.parentElement,p=_e(e);if(v&&!v.shadowRoot&&r(v)===!0)return et(e);e.assignedSlot?e=e.assignedSlot:!v&&p!==e.ownerDocument?e=p.host:e=v}e=h}if(ln(e))return!e.getClientRects().length;if(n!=="legacy-full")return!0}else if(n==="non-zero-area")return et(e);return!1},un=function(e){if(/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))for(var t=e.parentElement;t;){if(t.tagName==="FIELDSET"&&t.disabled){for(var n=0;n=0)},pt=function(e){var t=[],n=[];return e.forEach(function(r,s){var i=!!r.scopeParent,o=i?r.scopeParent:r,l=Xt(o,i),c=i?pt(r.candidates):o;l===0?i?t.push.apply(t,c):t.push(o):n.push({documentOrder:s,tabIndex:l,item:r,isScope:i,content:c})}),n.sort(en).reduce(function(r,s){return s.isScope?r.push.apply(r,s.content):r.push(s.content),r},[]).concat(t)},fn=function(e,t){t=t||{};var n;return t.getShadowRoot?n=Te([e],t.includeContainer,{filter:Pe.bind(null,t),flatten:!1,getShadowRoot:t.getShadowRoot,shadowRootFilter:dn}):n=dt(e,t.includeContainer,Pe.bind(null,t)),pt(n)},hn=function(e,t){t=t||{};var n;return t.getShadowRoot?n=Te([e],t.includeContainer,{filter:Ie.bind(null,t),flatten:!0,getShadowRoot:t.getShadowRoot}):n=dt(e,t.includeContainer,Ie.bind(null,t)),n},te=function(e,t){if(t=t||{},!e)throw new Error("No node provided");return ee.call(e,xe)===!1?!1:Pe(t,e)},pn=ct.concat("iframe:not([inert]):not([inert] *)").join(","),Re=function(e,t){if(t=t||{},!e)throw new Error("No node provided");return ee.call(e,pn)===!1?!1:Ie(t,e)};/*! +* focus-trap 7.8.0 +* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE +*/function ze(a,e){(e==null||e>a.length)&&(e=a.length);for(var t=0,n=Array(e);t=a.length?{done:!0}:{done:!1,value:a[n++]}},e:function(l){throw l},f:r}}throw new TypeError(`Invalid attempt to iterate non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var s,i=!0,o=!1;return{s:function(){t=t.call(a)},n:function(){var l=t.next();return i=l.done,l},e:function(l){o=!0,s=l},f:function(){try{i||t.return==null||t.return()}finally{if(o)throw s}}}}function mn(a,e,t){return(e=Sn(e))in a?Object.defineProperty(a,e,{value:t,enumerable:!0,configurable:!0,writable:!0}):a[e]=t,a}function gn(a){if(typeof Symbol<"u"&&a[Symbol.iterator]!=null||a["@@iterator"]!=null)return Array.from(a)}function bn(){throw new TypeError(`Invalid attempt to spread non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function nt(a,e){var t=Object.keys(a);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(a);e&&(n=n.filter(function(r){return Object.getOwnPropertyDescriptor(a,r).enumerable})),t.push.apply(t,n)}return t}function rt(a){for(var e=1;e0?e[e.length-1]:null},activateTrap:function(e,t){var n=K.getActiveTrap(e);t!==n&&K.pauseTrap(e);var r=e.indexOf(t);r===-1||e.splice(r,1),e.push(t)},deactivateTrap:function(e,t){var n=e.indexOf(t);n!==-1&&e.splice(n,1),K.unpauseTrap(e)},pauseTrap:function(e){var t=K.getActiveTrap(e);t?._setPausedState(!0)},unpauseTrap:function(e){var t=K.getActiveTrap(e);t&&!t._isManuallyPaused()&&t._setPausedState(!1)}},xn=function(e){return e.tagName&&e.tagName.toLowerCase()==="input"&&typeof e.select=="function"},_n=function(e){return e?.key==="Escape"||e?.key==="Esc"||e?.keyCode===27},ve=function(e){return e?.key==="Tab"||e?.keyCode===9},En=function(e){return ve(e)&&!e.shiftKey},Tn=function(e){return ve(e)&&e.shiftKey},it=function(e){return setTimeout(e,0)},he=function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;r1&&arguments[1]!==void 0?arguments[1]:{},g=d.hasFallback,T=g===void 0?!1:g,x=d.params,m=x===void 0?[]:x,f=s[u];if(typeof f=="function"&&(f=f.apply(void 0,yn(m))),f===!0&&(f=void 0),!f){if(f===void 0||f===!1)return f;throw new Error("`".concat(u,"` was specified but was not a node, or did not return a node"))}var b=f;if(typeof f=="string"){try{b=n.querySelector(f)}catch(_){throw new Error("`".concat(u,'` appears to be an invalid selector; error="').concat(_.message,'"'))}if(!b&&!T)throw new Error("`".concat(u,"` as selector refers to no known node"))}return b},v=function(){var u=h("initialFocus",{hasFallback:!0});if(u===!1)return!1;if(u===void 0||u&&!Re(u,s.tabbableOptions))if(c(n.activeElement)>=0)u=n.activeElement;else{var d=i.tabbableGroups[0],g=d&&d.firstTabbableNode;u=g||h("fallbackFocus")}else u===null&&(u=h("fallbackFocus"));if(!u)throw new Error("Your focus-trap needs to have at least one focusable element");return u},p=function(){if(i.containerGroups=i.containers.map(function(u){var d=fn(u,s.tabbableOptions),g=hn(u,s.tabbableOptions),T=d.length>0?d[0]:void 0,x=d.length>0?d[d.length-1]:void 0,m=g.find(function(_){return te(_)}),f=g.slice().reverse().find(function(_){return te(_)}),b=!!d.find(function(_){return X(_)>0});return{container:u,tabbableNodes:d,focusableNodes:g,posTabIndexesFound:b,firstTabbableNode:T,lastTabbableNode:x,firstDomTabbableNode:m,lastDomTabbableNode:f,nextTabbableNode:function(F){var A=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0,D=d.indexOf(F);return D<0?A?g.slice(g.indexOf(F)+1).find(function($){return te($)}):g.slice(0,g.indexOf(F)).reverse().find(function($){return te($)}):d[D+(A?1:-1)]}}}),i.tabbableGroups=i.containerGroups.filter(function(u){return u.tabbableNodes.length>0}),i.tabbableGroups.length<=0&&!h("fallbackFocus"))throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");if(i.containerGroups.find(function(u){return u.posTabIndexesFound})&&i.containerGroups.length>1)throw new Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.")},y=function(u){var d=u.activeElement;if(d)return d.shadowRoot&&d.shadowRoot.activeElement!==null?y(d.shadowRoot):d},S=function(u){if(u!==!1&&u!==y(document)){if(!u||!u.focus){S(v());return}u.focus({preventScroll:!!s.preventScroll}),i.mostRecentlyFocusedNode=u,xn(u)&&u.select()}},I=function(u){var d=h("setReturnFocus",{params:[u]});return d||(d===!1?!1:u)},w=function(u){var d=u.target,g=u.event,T=u.isBackward,x=T===void 0?!1:T;d=d||ye(g),p();var m=null;if(i.tabbableGroups.length>0){var f=c(d,g),b=f>=0?i.containerGroups[f]:void 0;if(f<0)x?m=i.tabbableGroups[i.tabbableGroups.length-1].lastTabbableNode:m=i.tabbableGroups[0].firstTabbableNode;else if(x){var _=i.tabbableGroups.findIndex(function(L){var U=L.firstTabbableNode;return d===U});if(_<0&&(b.container===d||Re(d,s.tabbableOptions)&&!te(d,s.tabbableOptions)&&!b.nextTabbableNode(d,!1))&&(_=f),_>=0){var F=_===0?i.tabbableGroups.length-1:_-1,A=i.tabbableGroups[F];m=X(d)>=0?A.lastTabbableNode:A.lastDomTabbableNode}else ve(g)||(m=b.nextTabbableNode(d,!1))}else{var D=i.tabbableGroups.findIndex(function(L){var U=L.lastTabbableNode;return d===U});if(D<0&&(b.container===d||Re(d,s.tabbableOptions)&&!te(d,s.tabbableOptions)&&!b.nextTabbableNode(d))&&(D=f),D>=0){var $=D===i.tabbableGroups.length-1?0:D+1,B=i.tabbableGroups[$];m=X(d)>=0?B.firstTabbableNode:B.firstDomTabbableNode}else ve(g)||(m=b.nextTabbableNode(d))}}else m=h("fallbackFocus");return m},N=function(u){var d=ye(u);if(!(c(d,u)>=0)){if(he(s.clickOutsideDeactivates,u)){o.deactivate({returnFocus:s.returnFocusOnDeactivate});return}he(s.allowOutsideClick,u)||u.preventDefault()}},O=function(u){var d=ye(u),g=c(d,u)>=0;if(g||d instanceof Document)g&&(i.mostRecentlyFocusedNode=d);else{u.stopImmediatePropagation();var T,x=!0;if(i.mostRecentlyFocusedNode)if(X(i.mostRecentlyFocusedNode)>0){var m=c(i.mostRecentlyFocusedNode),f=i.containerGroups[m].tabbableNodes;if(f.length>0){var b=f.findIndex(function(_){return _===i.mostRecentlyFocusedNode});b>=0&&(s.isKeyForward(i.recentNavEvent)?b+1=0&&(T=f[b-1],x=!1))}}else i.containerGroups.some(function(_){return _.tabbableNodes.some(function(F){return X(F)>0})})||(x=!1);else x=!1;x&&(T=w({target:i.mostRecentlyFocusedNode,isBackward:s.isKeyBackward(i.recentNavEvent)})),S(T||i.mostRecentlyFocusedNode||v())}i.recentNavEvent=void 0},j=function(u){var d=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;i.recentNavEvent=u;var g=w({event:u,isBackward:d});g&&(ve(u)&&u.preventDefault(),S(g))},J=function(u){(s.isKeyForward(u)||s.isKeyBackward(u))&&j(u,s.isKeyBackward(u))},V=function(u){_n(u)&&he(s.escapeDeactivates,u)!==!1&&(u.preventDefault(),o.deactivate())},P=function(u){var d=ye(u);c(d,u)>=0||he(s.clickOutsideDeactivates,u)||he(s.allowOutsideClick,u)||(u.preventDefault(),u.stopImmediatePropagation())},z=function(){if(i.active)return K.activateTrap(r,o),i.delayInitialFocusTimer=s.delayInitialFocus?it(function(){S(v())}):S(v()),n.addEventListener("focusin",O,!0),n.addEventListener("mousedown",N,{capture:!0,passive:!1}),n.addEventListener("touchstart",N,{capture:!0,passive:!1}),n.addEventListener("click",P,{capture:!0,passive:!1}),n.addEventListener("keydown",J,{capture:!0,passive:!1}),n.addEventListener("keydown",V),o},Ne=function(u){i.active&&!i.paused&&o._setSubtreeIsolation(!1),i.adjacentElements.clear(),i.alreadySilent.clear();var d=new Set,g=new Set,T=tt(u),x;try{for(T.s();!(x=T.n()).done;){var m=x.value;d.add(m);for(var f=typeof ShadowRoot<"u"&&m.getRootNode()instanceof ShadowRoot,b=m;b;){d.add(b);var _=b.parentElement,F=[];_?F=_.children:!_&&f&&(F=b.getRootNode().children,_=b.getRootNode().host,f=typeof ShadowRoot<"u"&&_.getRootNode()instanceof ShadowRoot);var A=tt(F),D;try{for(A.s();!(D=A.n()).done;){var $=D.value;g.add($)}}catch(B){A.e(B)}finally{A.f()}b=_}}}catch(B){T.e(B)}finally{T.f()}d.forEach(function(B){g.delete(B)}),i.adjacentElements=g},R=function(){if(i.active)return n.removeEventListener("focusin",O,!0),n.removeEventListener("mousedown",N,!0),n.removeEventListener("touchstart",N,!0),n.removeEventListener("click",P,!0),n.removeEventListener("keydown",J,!0),n.removeEventListener("keydown",V),o},G=function(u){var d=u.some(function(g){var T=Array.from(g.removedNodes);return T.some(function(x){return x===i.mostRecentlyFocusedNode})});d&&S(v())},Q=typeof window<"u"&&"MutationObserver"in window?new MutationObserver(G):void 0,Y=function(){Q&&(Q.disconnect(),i.active&&!i.paused&&i.containers.map(function(u){Q.observe(u,{subtree:!0,childList:!0})}))};return o={get active(){return i.active},get paused(){return i.paused},activate:function(u){if(i.active)return this;var d=l(u,"onActivate"),g=l(u,"onPostActivate"),T=l(u,"checkCanFocusTrap"),x=K.getActiveTrap(r),m=!1;if(x&&!x.paused){var f;(f=x._setSubtreeIsolation)===null||f===void 0||f.call(x,!1),m=!0}try{T||p(),i.active=!0,i.paused=!1,i.nodeFocusedBeforeActivation=y(n),d?.();var b=function(){T&&p(),z(),Y(),s.isolateSubtrees&&o._setSubtreeIsolation(!0),g?.()};if(T)return T(i.containers.concat()).then(b,b),this;b()}catch(F){if(x===K.getActiveTrap(r)&&m){var _;(_=x._setSubtreeIsolation)===null||_===void 0||_.call(x,!0)}throw F}return this},deactivate:function(u){if(!i.active)return this;var d=rt({onDeactivate:s.onDeactivate,onPostDeactivate:s.onPostDeactivate,checkCanReturnFocus:s.checkCanReturnFocus},u);clearTimeout(i.delayInitialFocusTimer),i.delayInitialFocusTimer=void 0,i.paused||o._setSubtreeIsolation(!1),i.alreadySilent.clear(),R(),i.active=!1,i.paused=!1,Y(),K.deactivateTrap(r,o);var g=l(d,"onDeactivate"),T=l(d,"onPostDeactivate"),x=l(d,"checkCanReturnFocus"),m=l(d,"returnFocus","returnFocusOnDeactivate");g?.();var f=function(){it(function(){m&&S(I(i.nodeFocusedBeforeActivation)),T?.()})};return m&&x?(x(I(i.nodeFocusedBeforeActivation)).then(f,f),this):(f(),this)},pause:function(u){return i.active?(i.manuallyPaused=!0,this._setPausedState(!0,u)):this},unpause:function(u){return i.active?(i.manuallyPaused=!1,r[r.length-1]!==this?this:this._setPausedState(!1,u)):this},updateContainerElements:function(u){var d=[].concat(u).filter(Boolean);return i.containers=d.map(function(g){return typeof g=="string"?n.querySelector(g):g}),s.isolateSubtrees&&Ne(i.containers),i.active&&(p(),s.isolateSubtrees&&!i.paused&&o._setSubtreeIsolation(!0)),Y(),this}},Object.defineProperties(o,{_isManuallyPaused:{value:function(){return i.manuallyPaused}},_setPausedState:{value:function(u,d){if(i.paused===u)return this;if(i.paused=u,u){var g=l(d,"onPause"),T=l(d,"onPostPause");g?.(),R(),Y(),o._setSubtreeIsolation(!1),T?.()}else{var x=l(d,"onUnpause"),m=l(d,"onPostUnpause");x?.(),o._setSubtreeIsolation(!0),p(),z(),Y(),m?.()}return this}},_setSubtreeIsolation:{value:function(u){s.isolateSubtrees&&i.adjacentElements.forEach(function(d){var g;u?s.isolateSubtrees==="aria-hidden"?((d.ariaHidden==="true"||((g=d.getAttribute("aria-hidden"))===null||g===void 0?void 0:g.toLowerCase())==="true")&&i.alreadySilent.add(d),d.setAttribute("aria-hidden","true")):((d.inert||d.hasAttribute("inert"))&&i.alreadySilent.add(d),d.setAttribute("inert",!0)):i.alreadySilent.has(d)||(s.isolateSubtrees==="aria-hidden"?d.removeAttribute("aria-hidden"):d.removeAttribute("inert"))})}}}),o.updateContainerElements(e),o};function Nn(a,e={}){let t;const{immediate:n,...r}=e,s=re(!1),i=re(!1),o=p=>t&&t.activate(p),l=p=>t&&t.deactivate(p),c=()=>{t&&(t.pause(),i.value=!0)},h=()=>{t&&(t.unpause(),i.value=!1)},v=pe(()=>{const p=He(a);return Tt(p).map(y=>{const S=He(y);return typeof S=="string"?S:It(S)}).filter(kt)});return De(v,p=>{p.length&&(t=kn(p,{...r,onActivate(){s.value=!0,e.onActivate&&e.onActivate()},onDeactivate(){s.value=!1,e.onDeactivate&&e.onDeactivate()}}),n&&o())},{flush:"post"}),Et(()=>l()),{hasFocus:s,isPaused:i,activate:o,deactivate:l,pause:c,unpause:h}}class ie{constructor(e,t=!0,n=[],r=5e3){this.ctx=e,this.iframes=t,this.exclude=n,this.iframesTimeout=r}static matches(e,t){const n=typeof t=="string"?[t]:t,r=e.matches||e.matchesSelector||e.msMatchesSelector||e.mozMatchesSelector||e.oMatchesSelector||e.webkitMatchesSelector;if(r){let s=!1;return n.every(i=>r.call(e,i)?(s=!0,!1):!0),s}else return!1}getContexts(){let e,t=[];return typeof this.ctx>"u"||!this.ctx?e=[]:NodeList.prototype.isPrototypeOf(this.ctx)?e=Array.prototype.slice.call(this.ctx):Array.isArray(this.ctx)?e=this.ctx:typeof this.ctx=="string"?e=Array.prototype.slice.call(document.querySelectorAll(this.ctx)):e=[this.ctx],e.forEach(n=>{const r=t.filter(s=>s.contains(n)).length>0;t.indexOf(n)===-1&&!r&&t.push(n)}),t}getIframeContents(e,t,n=()=>{}){let r;try{const s=e.contentWindow;if(r=s.document,!s||!r)throw new Error("iframe inaccessible")}catch{n()}r&&t(r)}isIframeBlank(e){const t="about:blank",n=e.getAttribute("src").trim();return e.contentWindow.location.href===t&&n!==t&&n}observeIframeLoad(e,t,n){let r=!1,s=null;const i=()=>{if(!r){r=!0,clearTimeout(s);try{this.isIframeBlank(e)||(e.removeEventListener("load",i),this.getIframeContents(e,t,n))}catch{n()}}};e.addEventListener("load",i),s=setTimeout(i,this.iframesTimeout)}onIframeReady(e,t,n){try{e.contentWindow.document.readyState==="complete"?this.isIframeBlank(e)?this.observeIframeLoad(e,t,n):this.getIframeContents(e,t,n):this.observeIframeLoad(e,t,n)}catch{n()}}waitForIframes(e,t){let n=0;this.forEachIframe(e,()=>!0,r=>{n++,this.waitForIframes(r.querySelector("html"),()=>{--n||t()})},r=>{r||t()})}forEachIframe(e,t,n,r=()=>{}){let s=e.querySelectorAll("iframe"),i=s.length,o=0;s=Array.prototype.slice.call(s);const l=()=>{--i<=0&&r(o)};i||l(),s.forEach(c=>{ie.matches(c,this.exclude)?l():this.onIframeReady(c,h=>{t(c)&&(o++,n(h)),l()},l)})}createIterator(e,t,n){return document.createNodeIterator(e,t,n,!1)}createInstanceOnIframe(e){return new ie(e.querySelector("html"),this.iframes)}compareNodeIframe(e,t,n){const r=e.compareDocumentPosition(n),s=Node.DOCUMENT_POSITION_PRECEDING;if(r&s)if(t!==null){const i=t.compareDocumentPosition(n),o=Node.DOCUMENT_POSITION_FOLLOWING;if(i&o)return!0}else return!0;return!1}getIteratorNode(e){const t=e.previousNode();let n;return t===null?n=e.nextNode():n=e.nextNode()&&e.nextNode(),{prevNode:t,node:n}}checkIframeFilter(e,t,n,r){let s=!1,i=!1;return r.forEach((o,l)=>{o.val===n&&(s=l,i=o.handled)}),this.compareNodeIframe(e,t,n)?(s===!1&&!i?r.push({val:n,handled:!0}):s!==!1&&!i&&(r[s].handled=!0),!0):(s===!1&&r.push({val:n,handled:!1}),!1)}handleOpenIframes(e,t,n,r){e.forEach(s=>{s.handled||this.getIframeContents(s.val,i=>{this.createInstanceOnIframe(i).forEachNode(t,n,r)})})}iterateThroughNodes(e,t,n,r,s){const i=this.createIterator(t,e,r);let o=[],l=[],c,h,v=()=>({prevNode:h,node:c}=this.getIteratorNode(i),c);for(;v();)this.iframes&&this.forEachIframe(t,p=>this.checkIframeFilter(c,h,p,o),p=>{this.createInstanceOnIframe(p).forEachNode(e,y=>l.push(y),r)}),l.push(c);l.forEach(p=>{n(p)}),this.iframes&&this.handleOpenIframes(o,e,n,r),s()}forEachNode(e,t,n,r=()=>{}){const s=this.getContexts();let i=s.length;i||r(),s.forEach(o=>{const l=()=>{this.iterateThroughNodes(e,o,t,n,()=>{--i<=0&&r()})};this.iframes?this.waitForIframes(o,l):l()})}}let Fn=class{constructor(e){this.ctx=e,this.ie=!1;const t=window.navigator.userAgent;(t.indexOf("MSIE")>-1||t.indexOf("Trident")>-1)&&(this.ie=!0)}set opt(e){this._opt=Object.assign({},{element:"",className:"",exclude:[],iframes:!1,iframesTimeout:5e3,separateWordSearch:!0,diacritics:!0,synonyms:{},accuracy:"partially",acrossElements:!1,caseSensitive:!1,ignoreJoiners:!1,ignoreGroups:0,ignorePunctuation:[],wildcards:"disabled",each:()=>{},noMatch:()=>{},filter:()=>!0,done:()=>{},debug:!1,log:window.console},e)}get opt(){return this._opt}get iterator(){return new ie(this.ctx,this.opt.iframes,this.opt.exclude,this.opt.iframesTimeout)}log(e,t="debug"){const n=this.opt.log;this.opt.debug&&typeof n=="object"&&typeof n[t]=="function"&&n[t](`mark.js: ${e}`)}escapeStr(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}createRegExp(e){return this.opt.wildcards!=="disabled"&&(e=this.setupWildcardsRegExp(e)),e=this.escapeStr(e),Object.keys(this.opt.synonyms).length&&(e=this.createSynonymsRegExp(e)),(this.opt.ignoreJoiners||this.opt.ignorePunctuation.length)&&(e=this.setupIgnoreJoinersRegExp(e)),this.opt.diacritics&&(e=this.createDiacriticsRegExp(e)),e=this.createMergedBlanksRegExp(e),(this.opt.ignoreJoiners||this.opt.ignorePunctuation.length)&&(e=this.createJoinersRegExp(e)),this.opt.wildcards!=="disabled"&&(e=this.createWildcardsRegExp(e)),e=this.createAccuracyRegExp(e),e}createSynonymsRegExp(e){const t=this.opt.synonyms,n=this.opt.caseSensitive?"":"i",r=this.opt.ignoreJoiners||this.opt.ignorePunctuation.length?"\0":"";for(let s in t)if(t.hasOwnProperty(s)){const i=t[s],o=this.opt.wildcards!=="disabled"?this.setupWildcardsRegExp(s):this.escapeStr(s),l=this.opt.wildcards!=="disabled"?this.setupWildcardsRegExp(i):this.escapeStr(i);o!==""&&l!==""&&(e=e.replace(new RegExp(`(${this.escapeStr(o)}|${this.escapeStr(l)})`,`gm${n}`),r+`(${this.processSynomyms(o)}|${this.processSynomyms(l)})`+r))}return e}processSynomyms(e){return(this.opt.ignoreJoiners||this.opt.ignorePunctuation.length)&&(e=this.setupIgnoreJoinersRegExp(e)),e}setupWildcardsRegExp(e){return e=e.replace(/(?:\\)*\?/g,t=>t.charAt(0)==="\\"?"?":""),e.replace(/(?:\\)*\*/g,t=>t.charAt(0)==="\\"?"*":"")}createWildcardsRegExp(e){let t=this.opt.wildcards==="withSpaces";return e.replace(/\u0001/g,t?"[\\S\\s]?":"\\S?").replace(/\u0002/g,t?"[\\S\\s]*?":"\\S*")}setupIgnoreJoinersRegExp(e){return e.replace(/[^(|)\\]/g,(t,n,r)=>{let s=r.charAt(n+1);return/[(|)\\]/.test(s)||s===""?t:t+"\0"})}createJoinersRegExp(e){let t=[];const n=this.opt.ignorePunctuation;return Array.isArray(n)&&n.length&&t.push(this.escapeStr(n.join(""))),this.opt.ignoreJoiners&&t.push("\\u00ad\\u200b\\u200c\\u200d"),t.length?e.split(/\u0000+/).join(`[${t.join("")}]*`):e}createDiacriticsRegExp(e){const t=this.opt.caseSensitive?"":"i",n=this.opt.caseSensitive?["aàáảãạăằắẳẵặâầấẩẫậäåāą","AÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ","cçćč","CÇĆČ","dđď","DĐĎ","eèéẻẽẹêềếểễệëěēę","EÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ","iìíỉĩịîïī","IÌÍỈĨỊÎÏĪ","lł","LŁ","nñňń","NÑŇŃ","oòóỏõọôồốổỗộơởỡớờợöøō","OÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ","rř","RŘ","sšśșş","SŠŚȘŞ","tťțţ","TŤȚŢ","uùúủũụưừứửữựûüůū","UÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ","yýỳỷỹỵÿ","YÝỲỶỸỴŸ","zžżź","ZŽŻŹ"]:["aàáảãạăằắẳẵặâầấẩẫậäåāąAÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ","cçćčCÇĆČ","dđďDĐĎ","eèéẻẽẹêềếểễệëěēęEÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ","iìíỉĩịîïīIÌÍỈĨỊÎÏĪ","lłLŁ","nñňńNÑŇŃ","oòóỏõọôồốổỗộơởỡớờợöøōOÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ","rřRŘ","sšśșşSŠŚȘŞ","tťțţTŤȚŢ","uùúủũụưừứửữựûüůūUÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ","yýỳỷỹỵÿYÝỲỶỸỴŸ","zžżźZŽŻŹ"];let r=[];return e.split("").forEach(s=>{n.every(i=>{if(i.indexOf(s)!==-1){if(r.indexOf(i)>-1)return!1;e=e.replace(new RegExp(`[${i}]`,`gm${t}`),`[${i}]`),r.push(i)}return!0})}),e}createMergedBlanksRegExp(e){return e.replace(/[\s]+/gmi,"[\\s]+")}createAccuracyRegExp(e){const t="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~¡¿";let n=this.opt.accuracy,r=typeof n=="string"?n:n.value,s=typeof n=="string"?[]:n.limiters,i="";switch(s.forEach(o=>{i+=`|${this.escapeStr(o)}`}),r){case"partially":default:return`()(${e})`;case"complementary":return i="\\s"+(i||this.escapeStr(t)),`()([^${i}]*${e}[^${i}]*)`;case"exactly":return`(^|\\s${i})(${e})(?=$|\\s${i})`}}getSeparatedKeywords(e){let t=[];return e.forEach(n=>{this.opt.separateWordSearch?n.split(" ").forEach(r=>{r.trim()&&t.indexOf(r)===-1&&t.push(r)}):n.trim()&&t.indexOf(n)===-1&&t.push(n)}),{keywords:t.sort((n,r)=>r.length-n.length),length:t.length}}isNumeric(e){return Number(parseFloat(e))==e}checkRanges(e){if(!Array.isArray(e)||Object.prototype.toString.call(e[0])!=="[object Object]")return this.log("markRanges() will only accept an array of objects"),this.opt.noMatch(e),[];const t=[];let n=0;return e.sort((r,s)=>r.start-s.start).forEach(r=>{let{start:s,end:i,valid:o}=this.callNoMatchOnInvalidRanges(r,n);o&&(r.start=s,r.length=i-s,t.push(r),n=i)}),t}callNoMatchOnInvalidRanges(e,t){let n,r,s=!1;return e&&typeof e.start<"u"?(n=parseInt(e.start,10),r=n+parseInt(e.length,10),this.isNumeric(e.start)&&this.isNumeric(e.length)&&r-t>0&&r-n>0?s=!0:(this.log(`Ignoring invalid or overlapping range: ${JSON.stringify(e)}`),this.opt.noMatch(e))):(this.log(`Ignoring invalid range: ${JSON.stringify(e)}`),this.opt.noMatch(e)),{start:n,end:r,valid:s}}checkWhitespaceRanges(e,t,n){let r,s=!0,i=n.length,o=t-i,l=parseInt(e.start,10)-o;return l=l>i?i:l,r=l+parseInt(e.length,10),r>i&&(r=i,this.log(`End range automatically set to the max value of ${i}`)),l<0||r-l<0||l>i||r>i?(s=!1,this.log(`Invalid range: ${JSON.stringify(e)}`),this.opt.noMatch(e)):n.substring(l,r).replace(/\s+/g,"")===""&&(s=!1,this.log("Skipping whitespace only range: "+JSON.stringify(e)),this.opt.noMatch(e)),{start:l,end:r,valid:s}}getTextNodes(e){let t="",n=[];this.iterator.forEachNode(NodeFilter.SHOW_TEXT,r=>{n.push({start:t.length,end:(t+=r.textContent).length,node:r})},r=>this.matchesExclude(r.parentNode)?NodeFilter.FILTER_REJECT:NodeFilter.FILTER_ACCEPT,()=>{e({value:t,nodes:n})})}matchesExclude(e){return ie.matches(e,this.opt.exclude.concat(["script","style","title","head","html"]))}wrapRangeInTextNode(e,t,n){const r=this.opt.element?this.opt.element:"mark",s=e.splitText(t),i=s.splitText(n-t);let o=document.createElement(r);return o.setAttribute("data-markjs","true"),this.opt.className&&o.setAttribute("class",this.opt.className),o.textContent=s.textContent,s.parentNode.replaceChild(o,s),i}wrapRangeInMappedTextNode(e,t,n,r,s){e.nodes.every((i,o)=>{const l=e.nodes[o+1];if(typeof l>"u"||l.start>t){if(!r(i.node))return!1;const c=t-i.start,h=(n>i.end?i.end:n)-i.start,v=e.value.substr(0,i.start),p=e.value.substr(h+i.start);if(i.node=this.wrapRangeInTextNode(i.node,c,h),e.value=v+p,e.nodes.forEach((y,S)=>{S>=o&&(e.nodes[S].start>0&&S!==o&&(e.nodes[S].start-=h),e.nodes[S].end-=h)}),n-=h,s(i.node.previousSibling,i.start),n>i.end)t=i.end;else return!1}return!0})}wrapMatches(e,t,n,r,s){const i=t===0?0:t+1;this.getTextNodes(o=>{o.nodes.forEach(l=>{l=l.node;let c;for(;(c=e.exec(l.textContent))!==null&&c[i]!=="";){if(!n(c[i],l))continue;let h=c.index;if(i!==0)for(let v=1;v{let l;for(;(l=e.exec(o.value))!==null&&l[i]!=="";){let c=l.index;if(i!==0)for(let v=1;vn(l[i],v),(v,p)=>{e.lastIndex=p,r(v)})}s()})}wrapRangeFromIndex(e,t,n,r){this.getTextNodes(s=>{const i=s.value.length;e.forEach((o,l)=>{let{start:c,end:h,valid:v}=this.checkWhitespaceRanges(o,i,s.value);v&&this.wrapRangeInMappedTextNode(s,c,h,p=>t(p,o,s.value.substring(c,h),l),p=>{n(p,o)})}),r()})}unwrapMatches(e){const t=e.parentNode;let n=document.createDocumentFragment();for(;e.firstChild;)n.appendChild(e.removeChild(e.firstChild));t.replaceChild(n,e),this.ie?this.normalizeTextNode(t):t.normalize()}normalizeTextNode(e){if(e){if(e.nodeType===3)for(;e.nextSibling&&e.nextSibling.nodeType===3;)e.nodeValue+=e.nextSibling.nodeValue,e.parentNode.removeChild(e.nextSibling);else this.normalizeTextNode(e.firstChild);this.normalizeTextNode(e.nextSibling)}}markRegExp(e,t){this.opt=t,this.log(`Searching with expression "${e}"`);let n=0,r="wrapMatches";const s=i=>{n++,this.opt.each(i)};this.opt.acrossElements&&(r="wrapMatchesAcrossElements"),this[r](e,this.opt.ignoreGroups,(i,o)=>this.opt.filter(o,i,n),s,()=>{n===0&&this.opt.noMatch(e),this.opt.done(n)})}mark(e,t){this.opt=t;let n=0,r="wrapMatches";const{keywords:s,length:i}=this.getSeparatedKeywords(typeof e=="string"?[e]:e),o=this.opt.caseSensitive?"":"i",l=c=>{let h=new RegExp(this.createRegExp(c),`gm${o}`),v=0;this.log(`Searching with expression "${h}"`),this[r](h,1,(p,y)=>this.opt.filter(y,c,n,v),p=>{v++,n++,this.opt.each(p)},()=>{v===0&&this.opt.noMatch(c),s[i-1]===c?this.opt.done(n):l(s[s.indexOf(c)+1])})};this.opt.acrossElements&&(r="wrapMatchesAcrossElements"),i===0?this.opt.done(n):l(s[0])}markRanges(e,t){this.opt=t;let n=0,r=this.checkRanges(e);r&&r.length?(this.log("Starting to mark with the following ranges: "+JSON.stringify(r)),this.wrapRangeFromIndex(r,(s,i,o,l)=>this.opt.filter(s,i,o,l),(s,i)=>{n++,this.opt.each(s,i)},()=>{this.opt.done(n)})):this.opt.done(n)}unmark(e){this.opt=e;let t=this.opt.element?this.opt.element:"*";t+="[data-markjs]",this.opt.className&&(t+=`.${this.opt.className}`),this.log(`Removal selector "${t}"`),this.iterator.forEachNode(NodeFilter.SHOW_ELEMENT,n=>{this.unwrapMatches(n)},n=>{const r=ie.matches(n,t),s=this.matchesExclude(n);return!r||s?NodeFilter.FILTER_REJECT:NodeFilter.FILTER_ACCEPT},this.opt.done)}};function Rn(a){const e=new Fn(a);return this.mark=(t,n)=>(e.mark(t,n),this),this.markRegExp=(t,n)=>(e.markRegExp(t,n),this),this.markRanges=(t,n)=>(e.markRanges(t,n),this),this.unmark=t=>(e.unmark(t),this),this}const On="ENTRIES",mt="KEYS",gt="VALUES",M="";class Oe{constructor(e,t){const n=e._tree,r=Array.from(n.keys());this.set=e,this._type=t,this._path=r.length>0?[{node:n,keys:r}]:[]}next(){const e=this.dive();return this.backtrack(),e}dive(){if(this._path.length===0)return{done:!0,value:void 0};const{node:e,keys:t}=ne(this._path);if(ne(t)===M)return{done:!1,value:this.result()};const n=e.get(ne(t));return this._path.push({node:n,keys:Array.from(n.keys())}),this.dive()}backtrack(){if(this._path.length===0)return;const e=ne(this._path).keys;e.pop(),!(e.length>0)&&(this._path.pop(),this.backtrack())}key(){return this.set._prefix+this._path.map(({keys:e})=>ne(e)).filter(e=>e!==M).join("")}value(){return ne(this._path).node.get(M)}result(){switch(this._type){case gt:return this.value();case mt:return this.key();default:return[this.key(),this.value()]}}[Symbol.iterator](){return this}}const ne=a=>a[a.length-1],An=(a,e,t)=>{const n=new Map;if(e===void 0)return n;const r=e.length+1,s=r+t,i=new Uint8Array(s*r).fill(t+1);for(let o=0;o{const l=s*i;e:for(const c of a.keys())if(c===M){const h=r[l-1];h<=t&&n.set(o,[a.get(c),h])}else{let h=s;for(let v=0;vt)continue e}bt(a.get(c),e,t,n,r,h,i,o+c)}};class H{constructor(e=new Map,t=""){this._size=void 0,this._tree=e,this._prefix=t}atPrefix(e){if(!e.startsWith(this._prefix))throw new Error("Mismatched prefix");const[t,n]=ke(this._tree,e.slice(this._prefix.length));if(t===void 0){const[r,s]=Be(n);for(const i of r.keys())if(i!==M&&i.startsWith(s)){const o=new Map;return o.set(i.slice(s.length),r.get(i)),new H(o,e)}}return new H(t,e)}clear(){this._size=void 0,this._tree.clear()}delete(e){return this._size=void 0,Cn(this._tree,e)}entries(){return new Oe(this,On)}forEach(e){for(const[t,n]of this)e(t,n,this)}fuzzyGet(e,t){return An(this._tree,e,t)}get(e){const t=Ve(this._tree,e);return t!==void 0?t.get(M):void 0}has(e){const t=Ve(this._tree,e);return t!==void 0&&t.has(M)}keys(){return new Oe(this,mt)}set(e,t){if(typeof e!="string")throw new Error("key must be a string");return this._size=void 0,Ae(this._tree,e).set(M,t),this}get size(){if(this._size)return this._size;this._size=0;const e=this.entries();for(;!e.next().done;)this._size+=1;return this._size}update(e,t){if(typeof e!="string")throw new Error("key must be a string");this._size=void 0;const n=Ae(this._tree,e);return n.set(M,t(n.get(M))),this}fetch(e,t){if(typeof e!="string")throw new Error("key must be a string");this._size=void 0;const n=Ae(this._tree,e);let r=n.get(M);return r===void 0&&n.set(M,r=t()),r}values(){return new Oe(this,gt)}[Symbol.iterator](){return this.entries()}static from(e){const t=new H;for(const[n,r]of e)t.set(n,r);return t}static fromObject(e){return H.from(Object.entries(e))}}const ke=(a,e,t=[])=>{if(e.length===0||a==null)return[a,t];for(const n of a.keys())if(n!==M&&e.startsWith(n))return t.push([a,n]),ke(a.get(n),e.slice(n.length),t);return t.push([a,e]),ke(void 0,"",t)},Ve=(a,e)=>{if(e.length===0||a==null)return a;for(const t of a.keys())if(t!==M&&e.startsWith(t))return Ve(a.get(t),e.slice(t.length))},Ae=(a,e)=>{const t=e.length;e:for(let n=0;a&&n{const[t,n]=ke(a,e);if(t!==void 0){if(t.delete(M),t.size===0)yt(n);else if(t.size===1){const[r,s]=t.entries().next().value;wt(n,r,s)}}},yt=a=>{if(a.length===0)return;const[e,t]=Be(a);if(e.delete(t),e.size===0)yt(a.slice(0,-1));else if(e.size===1){const[n,r]=e.entries().next().value;n!==M&&wt(a.slice(0,-1),n,r)}},wt=(a,e,t)=>{if(a.length===0)return;const[n,r]=Be(a);n.set(r+e,t),n.delete(r)},Be=a=>a[a.length-1],We="or",St="and",Mn="and_not";class se{constructor(e){if(e?.fields==null)throw new Error('MiniSearch: option "fields" must be provided');const t=e.autoVacuum==null||e.autoVacuum===!0?Le:e.autoVacuum;this._options={...Me,...e,autoVacuum:t,searchOptions:{...st,...e.searchOptions||{}},autoSuggestOptions:{...Vn,...e.autoSuggestOptions||{}}},this._index=new H,this._documentCount=0,this._documentIds=new Map,this._idToShortId=new Map,this._fieldIds={},this._fieldLength=new Map,this._avgFieldLength=[],this._nextId=0,this._storedFields=new Map,this._dirtCount=0,this._currentVacuum=null,this._enqueuedVacuum=null,this._enqueuedVacuumConditions=$e,this.addFields(this._options.fields)}add(e){const{extractField:t,stringifyField:n,tokenize:r,processTerm:s,fields:i,idField:o}=this._options,l=t(e,o);if(l==null)throw new Error(`MiniSearch: document does not have ID field "${o}"`);if(this._idToShortId.has(l))throw new Error(`MiniSearch: duplicate ID ${l}`);const c=this.addDocumentId(l);this.saveStoredFields(c,e);for(const h of i){const v=t(e,h);if(v==null)continue;const p=r(n(v,h),h),y=this._fieldIds[h],S=new Set(p).size;this.addFieldLength(c,y,this._documentCount-1,S);for(const I of p){const w=s(I,h);if(Array.isArray(w))for(const N of w)this.addTerm(y,c,N);else w&&this.addTerm(y,c,w)}}}addAll(e){for(const t of e)this.add(t)}addAllAsync(e,t={}){const{chunkSize:n=10}=t,r={chunk:[],promise:Promise.resolve()},{chunk:s,promise:i}=e.reduce(({chunk:o,promise:l},c,h)=>(o.push(c),(h+1)%n===0?{chunk:[],promise:l.then(()=>new Promise(v=>setTimeout(v,0))).then(()=>this.addAll(o))}:{chunk:o,promise:l}),r);return i.then(()=>this.addAll(s))}remove(e){const{tokenize:t,processTerm:n,extractField:r,stringifyField:s,fields:i,idField:o}=this._options,l=r(e,o);if(l==null)throw new Error(`MiniSearch: document does not have ID field "${o}"`);const c=this._idToShortId.get(l);if(c==null)throw new Error(`MiniSearch: cannot remove document with ID ${l}: it is not in the index`);for(const h of i){const v=r(e,h);if(v==null)continue;const p=t(s(v,h),h),y=this._fieldIds[h],S=new Set(p).size;this.removeFieldLength(c,y,this._documentCount,S);for(const I of p){const w=n(I,h);if(Array.isArray(w))for(const N of w)this.removeTerm(y,c,N);else w&&this.removeTerm(y,c,w)}}this._storedFields.delete(c),this._documentIds.delete(c),this._idToShortId.delete(l),this._fieldLength.delete(c),this._documentCount-=1}removeAll(e){if(e)for(const t of e)this.remove(t);else{if(arguments.length>0)throw new Error("Expected documents to be present. Omit the argument to remove all documents.");this._index=new H,this._documentCount=0,this._documentIds=new Map,this._idToShortId=new Map,this._fieldLength=new Map,this._avgFieldLength=[],this._storedFields=new Map,this._nextId=0}}discard(e){const t=this._idToShortId.get(e);if(t==null)throw new Error(`MiniSearch: cannot discard document with ID ${e}: it is not in the index`);this._idToShortId.delete(e),this._documentIds.delete(t),this._storedFields.delete(t),(this._fieldLength.get(t)||[]).forEach((n,r)=>{this.removeFieldLength(t,r,this._documentCount,n)}),this._fieldLength.delete(t),this._documentCount-=1,this._dirtCount+=1,this.maybeAutoVacuum()}maybeAutoVacuum(){if(this._options.autoVacuum===!1)return;const{minDirtFactor:e,minDirtCount:t,batchSize:n,batchWait:r}=this._options.autoVacuum;this.conditionalVacuum({batchSize:n,batchWait:r},{minDirtCount:t,minDirtFactor:e})}discardAll(e){const t=this._options.autoVacuum;try{this._options.autoVacuum=!1;for(const n of e)this.discard(n)}finally{this._options.autoVacuum=t}this.maybeAutoVacuum()}replace(e){const{idField:t,extractField:n}=this._options,r=n(e,t);this.discard(r),this.add(e)}vacuum(e={}){return this.conditionalVacuum(e)}conditionalVacuum(e,t){return this._currentVacuum?(this._enqueuedVacuumConditions=this._enqueuedVacuumConditions&&t,this._enqueuedVacuum!=null?this._enqueuedVacuum:(this._enqueuedVacuum=this._currentVacuum.then(()=>{const n=this._enqueuedVacuumConditions;return this._enqueuedVacuumConditions=$e,this.performVacuuming(e,n)}),this._enqueuedVacuum)):this.vacuumConditionsMet(t)===!1?Promise.resolve():(this._currentVacuum=this.performVacuuming(e),this._currentVacuum)}async performVacuuming(e,t){const n=this._dirtCount;if(this.vacuumConditionsMet(t)){const r=e.batchSize||je.batchSize,s=e.batchWait||je.batchWait;let i=1;for(const[o,l]of this._index){for(const[c,h]of l)for(const[v]of h)this._documentIds.has(v)||(h.size<=1?l.delete(c):h.delete(v));this._index.get(o).size===0&&this._index.delete(o),i%r===0&&await new Promise(c=>setTimeout(c,s)),i+=1}this._dirtCount-=n}await null,this._currentVacuum=this._enqueuedVacuum,this._enqueuedVacuum=null}vacuumConditionsMet(e){if(e==null)return!0;let{minDirtCount:t,minDirtFactor:n}=e;return t=t||Le.minDirtCount,n=n||Le.minDirtFactor,this.dirtCount>=t&&this.dirtFactor>=n}get isVacuuming(){return this._currentVacuum!=null}get dirtCount(){return this._dirtCount}get dirtFactor(){return this._dirtCount/(1+this._documentCount+this._dirtCount)}has(e){return this._idToShortId.has(e)}getStoredFields(e){const t=this._idToShortId.get(e);if(t!=null)return this._storedFields.get(t)}search(e,t={}){const{searchOptions:n}=this._options,r={...n,...t},s=this.executeQuery(e,t),i=[];for(const[o,{score:l,terms:c,match:h}]of s){const v=c.length||1,p={id:this._documentIds.get(o),score:l*v,terms:Object.keys(h),queryTerms:c,match:h};Object.assign(p,this._storedFields.get(o)),(r.filter==null||r.filter(p))&&i.push(p)}return e===se.wildcard&&r.boostDocument==null||i.sort(ot),i}autoSuggest(e,t={}){t={...this._options.autoSuggestOptions,...t};const n=new Map;for(const{score:s,terms:i}of this.search(e,t)){const o=i.join(" "),l=n.get(o);l!=null?(l.score+=s,l.count+=1):n.set(o,{score:s,terms:i,count:1})}const r=[];for(const[s,{score:i,terms:o,count:l}]of n)r.push({suggestion:s,terms:o,score:i/l});return r.sort(ot),r}get documentCount(){return this._documentCount}get termCount(){return this._index.size}static loadJSON(e,t){if(t==null)throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");return this.loadJS(JSON.parse(e),t)}static async loadJSONAsync(e,t){if(t==null)throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");return this.loadJSAsync(JSON.parse(e),t)}static getDefault(e){if(Me.hasOwnProperty(e))return Ce(Me,e);throw new Error(`MiniSearch: unknown option "${e}"`)}static loadJS(e,t){const{index:n,documentIds:r,fieldLength:s,storedFields:i,serializationVersion:o}=e,l=this.instantiateMiniSearch(e,t);l._documentIds=we(r),l._fieldLength=we(s),l._storedFields=we(i);for(const[c,h]of l._documentIds)l._idToShortId.set(h,c);for(const[c,h]of n){const v=new Map;for(const p of Object.keys(h)){let y=h[p];o===1&&(y=y.ds),v.set(parseInt(p,10),we(y))}l._index.set(c,v)}return l}static async loadJSAsync(e,t){const{index:n,documentIds:r,fieldLength:s,storedFields:i,serializationVersion:o}=e,l=this.instantiateMiniSearch(e,t);l._documentIds=await Se(r),l._fieldLength=await Se(s),l._storedFields=await Se(i);for(const[h,v]of l._documentIds)l._idToShortId.set(v,h);let c=0;for(const[h,v]of n){const p=new Map;for(const y of Object.keys(v)){let S=v[y];o===1&&(S=S.ds),p.set(parseInt(y,10),await Se(S))}++c%1e3===0&&await xt(0),l._index.set(h,p)}return l}static instantiateMiniSearch(e,t){const{documentCount:n,nextId:r,fieldIds:s,averageFieldLength:i,dirtCount:o,serializationVersion:l}=e;if(l!==1&&l!==2)throw new Error("MiniSearch: cannot deserialize an index created with an incompatible version");const c=new se(t);return c._documentCount=n,c._nextId=r,c._idToShortId=new Map,c._fieldIds=s,c._avgFieldLength=i,c._dirtCount=o||0,c._index=new H,c}executeQuery(e,t={}){if(e===se.wildcard)return this.executeWildcardQuery(t);if(typeof e!="string"){const p={...t,...e,queries:void 0},y=e.queries.map(S=>this.executeQuery(S,p));return this.combineResults(y,p.combineWith)}const{tokenize:n,processTerm:r,searchOptions:s}=this._options,i={tokenize:n,processTerm:r,...s,...t},{tokenize:o,processTerm:l}=i,v=o(e).flatMap(p=>l(p)).filter(p=>!!p).map(zn(i)).map(p=>this.executeQuerySpec(p,i));return this.combineResults(v,i.combineWith)}executeQuerySpec(e,t){const n={...this._options.searchOptions,...t},r=(n.fields||this._options.fields).reduce((I,w)=>({...I,[w]:Ce(n.boost,w)||1}),{}),{boostDocument:s,weights:i,maxFuzzy:o,bm25:l}=n,{fuzzy:c,prefix:h}={...st.weights,...i},v=this._index.get(e.term),p=this.termResults(e.term,e.term,1,e.termBoost,v,r,s,l);let y,S;if(e.prefix&&(y=this._index.atPrefix(e.term)),e.fuzzy){const I=e.fuzzy===!0?.2:e.fuzzy,w=I<1?Math.min(o,Math.round(e.term.length*I)):I;w&&(S=this._index.fuzzyGet(e.term,w))}if(y)for(const[I,w]of y){const N=I.length-e.term.length;if(!N)continue;S?.delete(I);const O=h*I.length/(I.length+.3*N);this.termResults(e.term,I,O,e.termBoost,w,r,s,l,p)}if(S)for(const I of S.keys()){const[w,N]=S.get(I);if(!N)continue;const O=c*I.length/(I.length+N);this.termResults(e.term,I,O,e.termBoost,w,r,s,l,p)}return p}executeWildcardQuery(e){const t=new Map,n={...this._options.searchOptions,...e};for(const[r,s]of this._documentIds){const i=n.boostDocument?n.boostDocument(s,"",this._storedFields.get(r)):1;t.set(r,{score:i,terms:[],match:{}})}return t}combineResults(e,t=We){if(e.length===0)return new Map;const n=t.toLowerCase(),r=Ln[n];if(!r)throw new Error(`Invalid combination operator: ${t}`);return e.reduce(r)||new Map}toJSON(){const e=[];for(const[t,n]of this._index){const r={};for(const[s,i]of n)r[s]=Object.fromEntries(i);e.push([t,r])}return{documentCount:this._documentCount,nextId:this._nextId,documentIds:Object.fromEntries(this._documentIds),fieldIds:this._fieldIds,fieldLength:Object.fromEntries(this._fieldLength),averageFieldLength:this._avgFieldLength,storedFields:Object.fromEntries(this._storedFields),dirtCount:this._dirtCount,index:e,serializationVersion:2}}termResults(e,t,n,r,s,i,o,l,c=new Map){if(s==null)return c;for(const h of Object.keys(i)){const v=i[h],p=this._fieldIds[h],y=s.get(p);if(y==null)continue;let S=y.size;const I=this._avgFieldLength[p];for(const w of y.keys()){if(!this._documentIds.has(w)){this.removeTerm(p,w,t),S-=1;continue}const N=o?o(this._documentIds.get(w),t,this._storedFields.get(w)):1;if(!N)continue;const O=y.get(w),j=this._fieldLength.get(w)[p],J=Pn(O,S,this._documentCount,j,I,l),V=n*r*v*N*J,P=c.get(w);if(P){P.score+=V,jn(P.terms,e);const z=Ce(P.match,t);z?z.push(h):P.match[t]=[h]}else c.set(w,{score:V,terms:[e],match:{[t]:[h]}})}}return c}addTerm(e,t,n){const r=this._index.fetch(n,lt);let s=r.get(e);if(s==null)s=new Map,s.set(t,1),r.set(e,s);else{const i=s.get(t);s.set(t,(i||0)+1)}}removeTerm(e,t,n){if(!this._index.has(n)){this.warnDocumentChanged(t,e,n);return}const r=this._index.fetch(n,lt),s=r.get(e);s==null||s.get(t)==null?this.warnDocumentChanged(t,e,n):s.get(t)<=1?s.size<=1?r.delete(e):s.delete(t):s.set(t,s.get(t)-1),this._index.get(n).size===0&&this._index.delete(n)}warnDocumentChanged(e,t,n){for(const r of Object.keys(this._fieldIds))if(this._fieldIds[r]===t){this._options.logger("warn",`MiniSearch: document with ID ${this._documentIds.get(e)} has changed before removal: term "${n}" was not present in field "${r}". Removing a document after it has changed can corrupt the index!`,"version_conflict");return}}addDocumentId(e){const t=this._nextId;return this._idToShortId.set(e,t),this._documentIds.set(t,e),this._documentCount+=1,this._nextId+=1,t}addFields(e){for(let t=0;tObject.prototype.hasOwnProperty.call(a,e)?a[e]:void 0,Ln={[We]:(a,e)=>{for(const t of e.keys()){const n=a.get(t);if(n==null)a.set(t,e.get(t));else{const{score:r,terms:s,match:i}=e.get(t);n.score=n.score+r,n.match=Object.assign(n.match,i),at(n.terms,s)}}return a},[St]:(a,e)=>{const t=new Map;for(const n of e.keys()){const r=a.get(n);if(r==null)continue;const{score:s,terms:i,match:o}=e.get(n);at(r.terms,i),t.set(n,{score:r.score+s,terms:r.terms,match:Object.assign(r.match,o)})}return t},[Mn]:(a,e)=>{for(const t of e.keys())a.delete(t);return a}},Dn={k:1.2,b:.7,d:.5},Pn=(a,e,t,n,r,s)=>{const{k:i,b:o,d:l}=s;return Math.log(1+(t-e+.5)/(e+.5))*(l+a*(i+1)/(a+i*(1-o+o*n/r)))},zn=a=>(e,t,n)=>{const r=typeof a.fuzzy=="function"?a.fuzzy(e,t,n):a.fuzzy||!1,s=typeof a.prefix=="function"?a.prefix(e,t,n):a.prefix===!0,i=typeof a.boostTerm=="function"?a.boostTerm(e,t,n):1;return{term:e,fuzzy:r,prefix:s,termBoost:i}},Me={idField:"id",extractField:(a,e)=>a[e],stringifyField:(a,e)=>a.toString(),tokenize:a=>a.split($n),processTerm:a=>a.toLowerCase(),fields:void 0,searchOptions:void 0,storeFields:[],logger:(a,e)=>{typeof console?.[a]=="function"&&console[a](e)},autoVacuum:!0},st={combineWith:We,prefix:!1,fuzzy:!1,maxFuzzy:6,boost:{},weights:{fuzzy:.45,prefix:.375},bm25:Dn},Vn={combineWith:St,prefix:(a,e,t)=>e===t.length-1},je={batchSize:1e3,batchWait:10},$e={minDirtFactor:.1,minDirtCount:20},Le={...je,...$e},jn=(a,e)=>{a.includes(e)||a.push(e)},at=(a,e)=>{for(const t of e)a.includes(t)||a.push(t)},ot=({score:a},{score:e})=>e-a,lt=()=>new Map,we=a=>{const e=new Map;for(const t of Object.keys(a))e.set(parseInt(t,10),a[t]);return e},Se=async a=>{const e=new Map;let t=0;for(const n of Object.keys(a))e.set(parseInt(n,10),a[n]),++t%1e3===0&&await xt(0);return e},xt=a=>new Promise(e=>setTimeout(e,a)),$n=/[\n\r\p{Z}\p{P}]+/u;class Bn{max;cache;constructor(e=10){this.max=e,this.cache=new Map}get(e){let t=this.cache.get(e);return t!==void 0&&(this.cache.delete(e),this.cache.set(e,t)),t}set(e,t){this.cache.has(e)?this.cache.delete(e):this.cache.size===this.max&&this.cache.delete(this.first()),this.cache.set(e,t)}first(){return this.cache.keys().next().value}clear(){this.cache.clear()}}const Wn=["aria-owns"],Kn={class:"shell"},Jn=["title"],Un={class:"search-actions before"},qn=["title"],Hn=["aria-activedescendant","aria-controls","placeholder"],Gn={class:"search-actions"},Qn=["title"],Yn=["disabled","title"],Zn=["id","role","aria-labelledby"],Xn=["id","aria-selected"],er=["href","aria-label","onMouseenter","onFocusin","data-index"],tr={class:"titles"},nr=["innerHTML"],rr={class:"title main"},ir=["innerHTML"],sr={key:0,class:"excerpt-wrapper"},ar={key:0,class:"excerpt",inert:""},or=["innerHTML"],lr={key:0,class:"no-results"},cr={class:"search-keyboard-shortcuts"},ur=["aria-label"],dr=["aria-label"],fr=["aria-label"],hr=["aria-label"],pr=Nt({__name:"VPLocalSearchBox",emits:["close"],setup(a,{emit:e}){const t=e,n=re(),r=re(),s=re(Yt),i=Gt(),{activate:o}=Nn(n,{immediate:!0,allowOutsideClick:!0,clickOutsideDeactivates:!0,escapeDeactivates:!0}),{localeIndex:l,theme:c}=i,h=Ge(async()=>Xe(se.loadJSON((await s.value[l.value]?.())?.default,{fields:["title","titles","text"],storeFields:["title","titles"],searchOptions:{fuzzy:.2,prefix:!0,boost:{title:4,text:2,titles:1},...c.value.search?.provider==="local"&&c.value.search.options?.miniSearch?.searchOptions},...c.value.search?.provider==="local"&&c.value.search.options?.miniSearch?.options}))),p=pe(()=>c.value.search?.provider==="local"&&c.value.search.options?.disableQueryPersistence===!0).value?ce(""):Ft("vitepress:local-search-filter",""),y=Rt("vitepress:local-search-detailed-list",c.value.search?.provider==="local"&&c.value.search.options?.detailedView===!0),S=pe(()=>c.value.search?.provider==="local"&&(c.value.search.options?.disableDetailedView===!0||c.value.search.options?.detailedView===!1)),I=pe(()=>{const m=c.value.search?.options??c.value.algolia;return m?.locales?.[l.value]?.translations?.button?.buttonText||m?.translations?.button?.buttonText||"Search"});Ot(()=>{S.value&&(y.value=!1)});const w=re([]),N=ce(!1);De(p,()=>{N.value=!1});const O=Ge(async()=>{if(r.value)return Xe(new Rn(r.value))},null),j=new Bn(16);At(()=>[h.value,p.value,y.value],async([m,f,b],_,F)=>{_?.[0]!==m&&j.clear();let A=!1;if(F(()=>{A=!0}),!m)return;w.value=m.search(f).slice(0,16),N.value=!0;const D=b?await Promise.all(w.value.map(L=>J(L.id))):[];if(A)return;for(const{id:L,mod:U}of D){const me=L.slice(0,L.indexOf("#"));let ae=j.get(me);if(ae)continue;ae=new Map,j.set(me,ae);const oe=U.default??U;if(oe?.render||oe?.setup){const Z=Kt(oe);Z.config.warnHandler=()=>{},Z.provide(Jt,i),Object.defineProperties(Z.config.globalProperties,{$frontmatter:{get(){return i.frontmatter.value}},$params:{get(){return i.page.value.params}}});const Ke=document.createElement("div");Z.mount(Ke),Ke.querySelectorAll("h1, h2, h3, h4, h5, h6").forEach(le=>{const Je=le.querySelector("a")?.getAttribute("href"),Ue=Je?.startsWith("#")&&Je.slice(1);if(!Ue)return;let qe="";for(;(le=le.nextElementSibling)&&!/^h[1-6]$/i.test(le.tagName);)qe+=le.outerHTML;ae.set(Ue,qe)}),Z.unmount()}if(A)return}const $=new Set;if(w.value=w.value.map(L=>{const[U,me]=L.id.split("#"),oe=j.get(U)?.get(me)??"";for(const Z in L.match)$.add(Z);return{...L,text:oe}}),await ue(),A)return;await new Promise(L=>{O.value?.unmark({done:()=>{O.value?.markRegExp(T($),{done:L})}})});const B=n.value?.querySelectorAll(".result .excerpt")??[];for(const L of B)L.querySelector('mark[data-markjs="true"]')?.scrollIntoView({block:"center"});r.value?.firstElementChild?.scrollIntoView({block:"start"})},{debounce:200,immediate:!0});async function J(m){const f=Ut(m.slice(0,m.indexOf("#")));try{if(!f)throw new Error(`Cannot find file for id: ${m}`);return{id:m,mod:await import(f)}}catch(b){return console.error(b),{id:m,mod:{}}}}const V=ce(),P=pe(()=>p.value?.length<=0);function z(m=!0){V.value?.focus(),m&&V.value?.select()}Fe(()=>{z()});function Ne(m){m.pointerType==="mouse"&&z()}const R=ce(-1),G=ce(!0);De(w,m=>{R.value=m.length?0:-1,Q()});function Q(){ue(()=>{document.querySelector(".result.selected")?.scrollIntoView({block:"nearest"})})}ge("ArrowUp",m=>{m.preventDefault(),R.value--,R.value<0&&(R.value=w.value.length-1),G.value=!0,Q()}),ge("ArrowDown",m=>{m.preventDefault(),R.value++,R.value>=w.value.length&&(R.value=0),G.value=!0,Q()});const Y=Ct();ge("Enter",m=>{if(m.isComposing||m.target instanceof HTMLButtonElement&&m.target.type!=="submit")return;const f=w.value[R.value];if(m.target instanceof HTMLInputElement&&!f){m.preventDefault();return}f&&(Y.go(f.id),t("close"))}),ge("Escape",()=>{t("close")});const u=Qt({modal:{displayDetails:"Display detailed list",resetButtonTitle:"Reset search",backButtonTitle:"Close search",noResultsText:"No results for",footer:{selectText:"to select",selectKeyAriaLabel:"enter",navigateText:"to navigate",navigateUpKeyAriaLabel:"up arrow",navigateDownKeyAriaLabel:"down arrow",closeText:"to close",closeKeyAriaLabel:"escape"}}});Fe(()=>{window.history.pushState(null,"",null)}),Mt("popstate",m=>{m.preventDefault(),t("close")});const d=Lt(Dt?document.body:null);Fe(()=>{ue(()=>{d.value=!0,ue().then(()=>o())})}),Pt(()=>{d.value=!1});function g(){p.value="",ue().then(()=>z(!1))}function T(m){return new RegExp([...m].sort((f,b)=>b.length-f.length).map(f=>`(${qt(f)})`).join("|"),"gi")}function x(m){if(!G.value)return;const f=m.target?.closest(".result"),b=Number.parseInt(f?.dataset.index);b>=0&&b!==R.value&&(R.value=b),G.value=!1}return(m,f)=>(W(),zt(Wt,{to:"body"},[E("div",{ref_key:"el",ref:n,role:"button","aria-owns":w.value?.length?"localsearch-list":void 0,"aria-expanded":"true","aria-haspopup":"listbox","aria-labelledby":"localsearch-label",class:"VPLocalSearchBox"},[E("div",{class:"backdrop",onClick:f[0]||(f[0]=b=>m.$emit("close"))}),E("div",Kn,[E("form",{class:"search-bar",onPointerup:f[4]||(f[4]=b=>Ne(b)),onSubmit:f[5]||(f[5]=Vt(()=>{},["prevent"]))},[E("label",{title:I.value,id:"localsearch-label",for:"localsearch-input"},[...f[7]||(f[7]=[E("span",{"aria-hidden":"true",class:"vpi-search search-icon local-search-icon"},null,-1)])],8,Jn),E("div",Un,[E("button",{class:"back-button",title:C(u)("modal.backButtonTitle"),onClick:f[1]||(f[1]=b=>m.$emit("close"))},[...f[8]||(f[8]=[E("span",{class:"vpi-arrow-left local-search-icon"},null,-1)])],8,qn)]),jt(E("input",{ref_key:"searchInput",ref:V,"onUpdate:modelValue":f[2]||(f[2]=b=>Bt(p)?p.value=b:null),"aria-activedescendant":R.value>-1?"localsearch-item-"+R.value:void 0,"aria-autocomplete":"both","aria-controls":w.value?.length?"localsearch-list":void 0,"aria-labelledby":"localsearch-label",autocapitalize:"off",autocomplete:"off",autocorrect:"off",class:"search-input",id:"localsearch-input",enterkeyhint:"go",maxlength:"64",placeholder:I.value,spellcheck:"false",type:"search"},null,8,Hn),[[$t,C(p)]]),E("div",Gn,[S.value?be("",!0):(W(),q("button",{key:0,class:Qe(["toggle-layout-button",{"detailed-list":C(y)}]),type:"button",title:C(u)("modal.displayDetails"),onClick:f[3]||(f[3]=b=>R.value>-1&&(y.value=!C(y)))},[...f[9]||(f[9]=[E("span",{class:"vpi-layout-list local-search-icon"},null,-1)])],10,Qn)),E("button",{class:"clear-button",type:"reset",disabled:P.value,title:C(u)("modal.resetButtonTitle"),onClick:g},[...f[10]||(f[10]=[E("span",{class:"vpi-delete local-search-icon"},null,-1)])],8,Yn)])],32),E("ul",{ref_key:"resultsEl",ref:r,id:w.value?.length?"localsearch-list":void 0,role:w.value?.length?"listbox":void 0,"aria-labelledby":w.value?.length?"localsearch-label":void 0,class:"results",onMousemove:x},[(W(!0),q(Ze,null,Ye(w.value,(b,_)=>(W(),q("li",{key:b.id,id:"localsearch-item-"+_,"aria-selected":R.value===_?"true":"false",role:"option"},[E("a",{href:b.id,class:Qe(["result",{selected:R.value===_}]),"aria-label":[...b.titles,b.title].join(" > "),onMouseenter:F=>!G.value&&(R.value=_),onFocusin:F=>R.value=_,onClick:f[6]||(f[6]=F=>m.$emit("close")),"data-index":_},[E("div",null,[E("div",tr,[f[12]||(f[12]=E("span",{class:"title-icon"},"#",-1)),(W(!0),q(Ze,null,Ye(b.titles,(F,A)=>(W(),q("span",{key:A,class:"title"},[E("span",{class:"text",innerHTML:F},null,8,nr),f[11]||(f[11]=E("span",{class:"vpi-chevron-right local-search-icon"},null,-1))]))),128)),E("span",rr,[E("span",{class:"text",innerHTML:b.title},null,8,ir)])]),C(y)?(W(),q("div",sr,[b.text?(W(),q("div",ar,[E("div",{class:"vp-doc",innerHTML:b.text},null,8,or)])):be("",!0),f[13]||(f[13]=E("div",{class:"excerpt-gradient-bottom"},null,-1)),f[14]||(f[14]=E("div",{class:"excerpt-gradient-top"},null,-1))])):be("",!0)])],42,er)],8,Xn))),128)),C(p)&&!w.value.length&&N.value?(W(),q("li",lr,[de(fe(C(u)("modal.noResultsText"))+' "',1),E("strong",null,fe(C(p)),1),f[15]||(f[15]=de('" ',-1))])):be("",!0)],40,Zn),E("div",cr,[E("span",null,[E("kbd",{"aria-label":C(u)("modal.footer.navigateUpKeyAriaLabel")},[...f[16]||(f[16]=[E("span",{class:"vpi-arrow-up navigate-icon"},null,-1)])],8,ur),E("kbd",{"aria-label":C(u)("modal.footer.navigateDownKeyAriaLabel")},[...f[17]||(f[17]=[E("span",{class:"vpi-arrow-down navigate-icon"},null,-1)])],8,dr),de(" "+fe(C(u)("modal.footer.navigateText")),1)]),E("span",null,[E("kbd",{"aria-label":C(u)("modal.footer.selectKeyAriaLabel")},[...f[18]||(f[18]=[E("span",{class:"vpi-corner-down-left navigate-icon"},null,-1)])],8,fr),de(" "+fe(C(u)("modal.footer.selectText")),1)]),E("span",null,[E("kbd",{"aria-label":C(u)("modal.footer.closeKeyAriaLabel")},"esc",8,hr),de(" "+fe(C(u)("modal.footer.closeText")),1)])])])],8,Wn)]))}}),yr=Ht(pr,[["__scopeId","data-v-c9af88f0"]]);export{yr as default}; diff --git a/packages/tempo/public/v4/assets/chunks/abnfDiagram-VCTEODGH.C-XKIPnK.js b/packages/tempo/public/v4/assets/chunks/abnfDiagram-VCTEODGH.C-XKIPnK.js new file mode 100644 index 00000000..86220d66 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/abnfDiagram-VCTEODGH.C-XKIPnK.js @@ -0,0 +1 @@ +import{g as p,r as u,d as a}from"./chunk-SVP7TREG.tNKCi1Yy.js";import{p as f}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as n,l as o}from"../app.CbekdYod.js";import{M as c,b as d}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var v=d().RailroadAbnf.parser.LangiumParser,i=n(e=>{const r=e.alternatives.map(g);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformAlternation"),g=n(e=>{const r=e.elements.map(y);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformConcatenation"),b=n(e=>{if(e.includes("*")){const[t,s]=e.split("*"),l=t?parseInt(t,10):0,m=s?parseInt(s,10):1/0;return{min:l,max:m}}const r=parseInt(e,10);return{min:r,max:r}},"parseRepeat"),y=n(e=>{const r=A(e.primary);if(!e.repeat)return r;const{min:t,max:s}=b(e.repeat);return t===0&&s===1?{type:"optional",element:r}:{type:"repetition",element:r,min:t,max:s}},"transformElement"),A=n(e=>{switch(e.$type){case"AbnfStringLiteral":return{type:"terminal",value:e.value};case"AbnfNumVal":return{type:"terminal",value:e.value};case"AbnfRuleName":return{type:"nonterminal",name:e.name};case"AbnfGroup":return i(e.element);case"AbnfOptionalGroup":return{type:"optional",element:i(e.element)};default:throw new Error(`Unsupported ABNF primary node: ${e.$type}`)}},"transformPrimary"),P=n(e=>({name:e.name,definition:i(e.definition)}),"transformRule"),h=n(e=>{f(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(P(r)))},"populateDb"),R={parse:n(e=>{a.clear(),o.debug("[ABNF Parser] Starting Langium parse");const r=v.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new c(r);const t=r.value;o.debug("[ABNF Parser] Parsed rules:",t.rules.length),h(t),o.debug("[ABNF Parser] Parse complete")},"parse"),parser:{yy:a}},F={parser:R,db:a,renderer:u,styles:p};export{F as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/arc.BFiNID6s.js b/packages/tempo/public/v4/assets/chunks/arc.BFiNID6s.js new file mode 100644 index 00000000..4e42b381 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/arc.BFiNID6s.js @@ -0,0 +1 @@ +import{H as ln,I as un,J as y,K as tn,L as Q,M as I,N as _,O as an,P as rn,Q as j,R as o,S as K,T as sn,V as on,W as fn}from"../app.CbekdYod.js";function cn(l){return l.innerRadius}function yn(l){return l.outerRadius}function gn(l){return l.startAngle}function dn(l){return l.endAngle}function mn(l){return l&&l.padAngle}function pn(l,h,q,O,v,R,L,u){var D=q-l,i=O-h,n=L-v,d=u-R,a=d*D-n*i;if(!(a*ar*r+N*N&&(H=w,J=p),{cx:H,cy:J,x01:-n,y01:-d,x11:H*(v/T-1),y11:J*(v/T-1)}}function hn(){var l=cn,h=yn,q=K(0),O=null,v=gn,R=dn,L=mn,u=null,D=ln(i);function i(){var n,d,a=+l.apply(this,arguments),s=+h.apply(this,arguments),f=v.apply(this,arguments)-un,c=R.apply(this,arguments)-un,M=an(c-f),t=c>f;if(u||(u=n=D()),sy))u.moveTo(0,0);else if(M>tn-y)u.moveTo(s*Q(f),s*I(f)),u.arc(0,0,s,f,c,!t),a>y&&(u.moveTo(a*Q(c),a*I(c)),u.arc(0,0,a,c,f,t));else{var m=f,g=c,A=f,T=c,P=M,E=M,H=L.apply(this,arguments)/2,J=H>y&&(O?+O.apply(this,arguments):j(a*a+s*s)),w=_(an(s-a)/2,+q.apply(this,arguments)),p=w,x=w,e,r;if(J>y){var N=sn(J/a*I(H)),z=sn(J/s*I(H));(P-=N*2)>y?(N*=t?1:-1,A+=N,T-=N):(P=0,A=T=(f+c)/2),(E-=z*2)>y?(z*=t?1:-1,m+=z,g-=z):(E=0,m=g=(f+c)/2)}var V=s*Q(m),W=s*I(m),B=a*Q(T),C=a*I(T);if(w>y){var F=s*Q(g),G=s*I(g),X=a*Q(A),Y=a*I(A),S;if(My?x>y?(e=U(X,Y,V,W,s,x,t),r=U(F,G,B,C,s,x,t),u.moveTo(e.cx+e.x01,e.cy+e.y01),xy)||!(P>y)?u.lineTo(B,C):p>y?(e=U(B,C,F,G,a,-p,t),r=U(V,W,X,Y,a,-p,t),u.lineTo(e.cx+e.x01,e.cy+e.y01),ps?(this.rect.x-=(this.labelWidth-s)/2,this.setWidth(this.labelWidth)):this.labelPosHorizontal=="right"&&this.setWidth(s+this.labelWidth)),this.labelHeight&&(this.labelPosVertical=="top"?(this.rect.y-=this.labelHeight,this.setHeight(o+this.labelHeight)):this.labelPosVertical=="center"&&this.labelHeight>o?(this.rect.y-=(this.labelHeight-o)/2,this.setHeight(this.labelHeight)):this.labelPosVertical=="bottom"&&this.setHeight(o+this.labelHeight))}}},r.prototype.getInclusionTreeDepth=function(){if(this.inclusionTreeDepth==h.MAX_VALUE)throw"assert failed";return this.inclusionTreeDepth},r.prototype.transform=function(t){var s=this.rect.x;s>e.WORLD_BOUNDARY?s=e.WORLD_BOUNDARY:s<-e.WORLD_BOUNDARY&&(s=-e.WORLD_BOUNDARY);var o=this.rect.y;o>e.WORLD_BOUNDARY?o=e.WORLD_BOUNDARY:o<-e.WORLD_BOUNDARY&&(o=-e.WORLD_BOUNDARY);var c=new f(s,o),l=t.inverseTransformPoint(c);this.setLocation(l.x,l.y)},r.prototype.getLeft=function(){return this.rect.x},r.prototype.getRight=function(){return this.rect.x+this.rect.width},r.prototype.getTop=function(){return this.rect.y},r.prototype.getBottom=function(){return this.rect.y+this.rect.height},r.prototype.getParent=function(){return this.owner==null?null:this.owner.getParent()},M.exports=r}),(function(M,P,N){var v=N(0);function h(){}for(var a in v)h[a]=v[a];h.MAX_ITERATIONS=2500,h.DEFAULT_EDGE_LENGTH=50,h.DEFAULT_SPRING_STRENGTH=.45,h.DEFAULT_REPULSION_STRENGTH=4500,h.DEFAULT_GRAVITY_STRENGTH=.4,h.DEFAULT_COMPOUND_GRAVITY_STRENGTH=1,h.DEFAULT_GRAVITY_RANGE_FACTOR=3.8,h.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR=1.5,h.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION=!0,h.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION=!0,h.DEFAULT_COOLING_FACTOR_INCREMENTAL=.3,h.COOLING_ADAPTATION_FACTOR=.33,h.ADAPTATION_LOWER_NODE_LIMIT=1e3,h.ADAPTATION_UPPER_NODE_LIMIT=5e3,h.MAX_NODE_DISPLACEMENT_INCREMENTAL=100,h.MAX_NODE_DISPLACEMENT=h.MAX_NODE_DISPLACEMENT_INCREMENTAL*3,h.MIN_REPULSION_DIST=h.DEFAULT_EDGE_LENGTH/10,h.CONVERGENCE_CHECK_PERIOD=100,h.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR=.1,h.MIN_EDGE_LENGTH=1,h.GRID_CALCULATION_CHECK_PERIOD=10,M.exports=h}),(function(M,P,N){function v(h,a){h==null&&a==null?(this.x=0,this.y=0):(this.x=h,this.y=a)}v.prototype.getX=function(){return this.x},v.prototype.getY=function(){return this.y},v.prototype.setX=function(h){this.x=h},v.prototype.setY=function(h){this.y=h},v.prototype.getDifference=function(h){return new DimensionD(this.x-h.x,this.y-h.y)},v.prototype.getCopy=function(){return new v(this.x,this.y)},v.prototype.translate=function(h){return this.x+=h.width,this.y+=h.height,this},M.exports=v}),(function(M,P,N){var v=N(2),h=N(10),a=N(0),e=N(7),i=N(3),f=N(1),r=N(13),u=N(12),t=N(11);function s(c,l,T){v.call(this,T),this.estimatedSize=h.MIN_VALUE,this.margin=a.DEFAULT_GRAPH_MARGIN,this.edges=[],this.nodes=[],this.isConnected=!1,this.parent=c,l!=null&&l instanceof e?this.graphManager=l:l!=null&&l instanceof Layout&&(this.graphManager=l.graphManager)}s.prototype=Object.create(v.prototype);for(var o in v)s[o]=v[o];s.prototype.getNodes=function(){return this.nodes},s.prototype.getEdges=function(){return this.edges},s.prototype.getGraphManager=function(){return this.graphManager},s.prototype.getParent=function(){return this.parent},s.prototype.getLeft=function(){return this.left},s.prototype.getRight=function(){return this.right},s.prototype.getTop=function(){return this.top},s.prototype.getBottom=function(){return this.bottom},s.prototype.isConnected=function(){return this.isConnected},s.prototype.add=function(c,l,T){if(l==null&&T==null){var g=c;if(this.graphManager==null)throw"Graph has no graph mgr!";if(this.getNodes().indexOf(g)>-1)throw"Node already in graph!";return g.owner=this,this.getNodes().push(g),g}else{var d=c;if(!(this.getNodes().indexOf(l)>-1&&this.getNodes().indexOf(T)>-1))throw"Source or target not in graph!";if(!(l.owner==T.owner&&l.owner==this))throw"Both owners must be this graph!";return l.owner!=T.owner?null:(d.source=l,d.target=T,d.isInterGraph=!1,this.getEdges().push(d),l.edges.push(d),T!=l&&T.edges.push(d),d)}},s.prototype.remove=function(c){var l=c;if(c instanceof i){if(l==null)throw"Node is null!";if(!(l.owner!=null&&l.owner==this))throw"Owner graph is invalid!";if(this.graphManager==null)throw"Owner graph manager is invalid!";for(var T=l.edges.slice(),g,d=T.length,L=0;L-1&&G>-1))throw"Source and/or target doesn't know this edge!";g.source.edges.splice(C,1),g.target!=g.source&&g.target.edges.splice(G,1);var R=g.source.owner.getEdges().indexOf(g);if(R==-1)throw"Not in owner's edge list!";g.source.owner.getEdges().splice(R,1)}},s.prototype.updateLeftTop=function(){for(var c=h.MAX_VALUE,l=h.MAX_VALUE,T,g,d,L=this.getNodes(),R=L.length,C=0;CT&&(c=T),l>g&&(l=g)}return c==h.MAX_VALUE?null:(L[0].getParent().paddingLeft!=null?d=L[0].getParent().paddingLeft:d=this.margin,this.left=l-d,this.top=c-d,new u(this.left,this.top))},s.prototype.updateBounds=function(c){for(var l=h.MAX_VALUE,T=-h.MAX_VALUE,g=h.MAX_VALUE,d=-h.MAX_VALUE,L,R,C,G,V,Y=this.nodes,z=Y.length,A=0;AL&&(l=L),TC&&(g=C),dL&&(l=L),TC&&(g=C),d=this.nodes.length){var z=0;T.forEach(function(A){A.owner==c&&z++}),z==this.nodes.length&&(this.isConnected=!0)}},M.exports=s}),(function(M,P,N){var v,h=N(1);function a(e){v=N(6),this.layout=e,this.graphs=[],this.edges=[]}a.prototype.addRoot=function(){var e=this.layout.newGraph(),i=this.layout.newNode(null),f=this.add(e,i);return this.setRootGraph(f),this.rootGraph},a.prototype.add=function(e,i,f,r,u){if(f==null&&r==null&&u==null){if(e==null)throw"Graph is null!";if(i==null)throw"Parent node is null!";if(this.graphs.indexOf(e)>-1)throw"Graph already in this graph mgr!";if(this.graphs.push(e),e.parent!=null)throw"Already has a parent!";if(i.child!=null)throw"Already has a child!";return e.parent=i,i.child=e,e}else{u=f,r=i,f=e;var t=r.getOwner(),s=u.getOwner();if(!(t!=null&&t.getGraphManager()==this))throw"Source not in this graph mgr!";if(!(s!=null&&s.getGraphManager()==this))throw"Target not in this graph mgr!";if(t==s)return f.isInterGraph=!1,t.add(f,r,u);if(f.isInterGraph=!0,f.source=r,f.target=u,this.edges.indexOf(f)>-1)throw"Edge already in inter-graph edge list!";if(this.edges.push(f),!(f.source!=null&&f.target!=null))throw"Edge source and/or target is null!";if(!(f.source.edges.indexOf(f)==-1&&f.target.edges.indexOf(f)==-1))throw"Edge already in source and/or target incidency list!";return f.source.edges.push(f),f.target.edges.push(f),f}},a.prototype.remove=function(e){if(e instanceof v){var i=e;if(i.getGraphManager()!=this)throw"Graph not in this graph mgr";if(!(i==this.rootGraph||i.parent!=null&&i.parent.graphManager==this))throw"Invalid parent node!";var f=[];f=f.concat(i.getEdges());for(var r,u=f.length,t=0;t=e.getRight()?i[0]+=Math.min(e.getX()-a.getX(),a.getRight()-e.getRight()):e.getX()<=a.getX()&&e.getRight()>=a.getRight()&&(i[0]+=Math.min(a.getX()-e.getX(),e.getRight()-a.getRight())),a.getY()<=e.getY()&&a.getBottom()>=e.getBottom()?i[1]+=Math.min(e.getY()-a.getY(),a.getBottom()-e.getBottom()):e.getY()<=a.getY()&&e.getBottom()>=a.getBottom()&&(i[1]+=Math.min(a.getY()-e.getY(),e.getBottom()-a.getBottom()));var u=Math.abs((e.getCenterY()-a.getCenterY())/(e.getCenterX()-a.getCenterX()));e.getCenterY()===a.getCenterY()&&e.getCenterX()===a.getCenterX()&&(u=1);var t=u*i[0],s=i[1]/u;i[0]t)return i[0]=f,i[1]=o,i[2]=u,i[3]=Y,!1;if(ru)return i[0]=s,i[1]=r,i[2]=G,i[3]=t,!1;if(fu?(i[0]=l,i[1]=T,n=!0):(i[0]=c,i[1]=o,n=!0):p===y&&(f>u?(i[0]=s,i[1]=o,n=!0):(i[0]=g,i[1]=T,n=!0)),-m===y?u>f?(i[2]=V,i[3]=Y,E=!0):(i[2]=G,i[3]=C,E=!0):m===y&&(u>f?(i[2]=R,i[3]=C,E=!0):(i[2]=z,i[3]=Y,E=!0)),n&&E)return!1;if(f>u?r>t?(I=this.getCardinalDirection(p,y,4),D=this.getCardinalDirection(m,y,2)):(I=this.getCardinalDirection(-p,y,3),D=this.getCardinalDirection(-m,y,1)):r>t?(I=this.getCardinalDirection(-p,y,1),D=this.getCardinalDirection(-m,y,3)):(I=this.getCardinalDirection(p,y,2),D=this.getCardinalDirection(m,y,4)),!n)switch(I){case 1:W=o,S=f+-L/y,i[0]=S,i[1]=W;break;case 2:S=g,W=r+d*y,i[0]=S,i[1]=W;break;case 3:W=T,S=f+L/y,i[0]=S,i[1]=W;break;case 4:S=l,W=r+-d*y,i[0]=S,i[1]=W;break}if(!E)switch(D){case 1:Q=C,x=u+-_/y,i[2]=x,i[3]=Q;break;case 2:x=z,Q=t+A*y,i[2]=x,i[3]=Q;break;case 3:Q=Y,x=u+_/y,i[2]=x,i[3]=Q;break;case 4:x=V,Q=t+-A*y,i[2]=x,i[3]=Q;break}}return!1},h.getCardinalDirection=function(a,e,i){return a>e?i:1+i%4},h.getIntersection=function(a,e,i,f){if(f==null)return this.getIntersection2(a,e,i);var r=a.x,u=a.y,t=e.x,s=e.y,o=i.x,c=i.y,l=f.x,T=f.y,g=void 0,d=void 0,L=void 0,R=void 0,C=void 0,G=void 0,V=void 0,Y=void 0,z=void 0;return L=s-u,C=r-t,V=t*u-r*s,R=T-c,G=o-l,Y=l*c-o*T,z=L*G-R*C,z===0?null:(g=(C*Y-G*V)/z,d=(R*V-L*Y)/z,new v(g,d))},h.angleOfVector=function(a,e,i,f){var r=void 0;return a!==i?(r=Math.atan((f-e)/(i-a)),i=0){var T=(-o+Math.sqrt(o*o-4*s*c))/(2*s),g=(-o-Math.sqrt(o*o-4*s*c))/(2*s),d=null;return T>=0&&T<=1?[T]:g>=0&&g<=1?[g]:d}else return null},h.HALF_PI=.5*Math.PI,h.ONE_AND_HALF_PI=1.5*Math.PI,h.TWO_PI=2*Math.PI,h.THREE_PI=3*Math.PI,M.exports=h}),(function(M,P,N){function v(){}v.sign=function(h){return h>0?1:h<0?-1:0},v.floor=function(h){return h<0?Math.ceil(h):Math.floor(h)},v.ceil=function(h){return h<0?Math.floor(h):Math.ceil(h)},M.exports=v}),(function(M,P,N){function v(){}v.MAX_VALUE=2147483647,v.MIN_VALUE=-2147483648,M.exports=v}),(function(M,P,N){var v=(function(){function r(u,t){for(var s=0;s"u"?"undefined":v(a);return a==null||e!="object"&&e!="function"},M.exports=h}),(function(M,P,N){function v(o){if(Array.isArray(o)){for(var c=0,l=Array(o.length);c0&&c;){for(L.push(C[0]);L.length>0&&c;){var G=L[0];L.splice(0,1),d.add(G);for(var V=G.getEdges(),g=0;g-1&&C.splice(_,1)}d=new Set,R=new Map}}return o},s.prototype.createDummyNodesForBendpoints=function(o){for(var c=[],l=o.source,T=this.graphManager.calcLowestCommonAncestor(o.source,o.target),g=0;g0){for(var T=this.edgeToDummyNodes.get(l),g=0;g=0&&c.splice(Y,1);var z=R.getNeighborsList();z.forEach(function(n){if(l.indexOf(n)<0){var E=T.get(n),p=E-1;p==1&&G.push(n),T.set(n,p)}})}l=l.concat(G),(c.length==1||c.length==2)&&(g=!0,d=c[0])}return d},s.prototype.setGraphManager=function(o){this.graphManager=o},M.exports=s}),(function(M,P,N){function v(){}v.seed=1,v.x=0,v.nextDouble=function(){return v.x=Math.sin(v.seed++)*1e4,v.x-Math.floor(v.x)},M.exports=v}),(function(M,P,N){var v=N(5);function h(a,e){this.lworldOrgX=0,this.lworldOrgY=0,this.ldeviceOrgX=0,this.ldeviceOrgY=0,this.lworldExtX=1,this.lworldExtY=1,this.ldeviceExtX=1,this.ldeviceExtY=1}h.prototype.getWorldOrgX=function(){return this.lworldOrgX},h.prototype.setWorldOrgX=function(a){this.lworldOrgX=a},h.prototype.getWorldOrgY=function(){return this.lworldOrgY},h.prototype.setWorldOrgY=function(a){this.lworldOrgY=a},h.prototype.getWorldExtX=function(){return this.lworldExtX},h.prototype.setWorldExtX=function(a){this.lworldExtX=a},h.prototype.getWorldExtY=function(){return this.lworldExtY},h.prototype.setWorldExtY=function(a){this.lworldExtY=a},h.prototype.getDeviceOrgX=function(){return this.ldeviceOrgX},h.prototype.setDeviceOrgX=function(a){this.ldeviceOrgX=a},h.prototype.getDeviceOrgY=function(){return this.ldeviceOrgY},h.prototype.setDeviceOrgY=function(a){this.ldeviceOrgY=a},h.prototype.getDeviceExtX=function(){return this.ldeviceExtX},h.prototype.setDeviceExtX=function(a){this.ldeviceExtX=a},h.prototype.getDeviceExtY=function(){return this.ldeviceExtY},h.prototype.setDeviceExtY=function(a){this.ldeviceExtY=a},h.prototype.transformX=function(a){var e=0,i=this.lworldExtX;return i!=0&&(e=this.ldeviceOrgX+(a-this.lworldOrgX)*this.ldeviceExtX/i),e},h.prototype.transformY=function(a){var e=0,i=this.lworldExtY;return i!=0&&(e=this.ldeviceOrgY+(a-this.lworldOrgY)*this.ldeviceExtY/i),e},h.prototype.inverseTransformX=function(a){var e=0,i=this.ldeviceExtX;return i!=0&&(e=this.lworldOrgX+(a-this.ldeviceOrgX)*this.lworldExtX/i),e},h.prototype.inverseTransformY=function(a){var e=0,i=this.ldeviceExtY;return i!=0&&(e=this.lworldOrgY+(a-this.ldeviceOrgY)*this.lworldExtY/i),e},h.prototype.inverseTransformPoint=function(a){var e=new v(this.inverseTransformX(a.x),this.inverseTransformY(a.y));return e},M.exports=h}),(function(M,P,N){function v(t){if(Array.isArray(t)){for(var s=0,o=Array(t.length);sa.ADAPTATION_LOWER_NODE_LIMIT&&(this.coolingFactor=Math.max(this.coolingFactor*a.COOLING_ADAPTATION_FACTOR,this.coolingFactor-(t-a.ADAPTATION_LOWER_NODE_LIMIT)/(a.ADAPTATION_UPPER_NODE_LIMIT-a.ADAPTATION_LOWER_NODE_LIMIT)*this.coolingFactor*(1-a.COOLING_ADAPTATION_FACTOR))),this.maxNodeDisplacement=a.MAX_NODE_DISPLACEMENT_INCREMENTAL):(t>a.ADAPTATION_LOWER_NODE_LIMIT?this.coolingFactor=Math.max(a.COOLING_ADAPTATION_FACTOR,1-(t-a.ADAPTATION_LOWER_NODE_LIMIT)/(a.ADAPTATION_UPPER_NODE_LIMIT-a.ADAPTATION_LOWER_NODE_LIMIT)*(1-a.COOLING_ADAPTATION_FACTOR)):this.coolingFactor=1,this.initialCoolingFactor=this.coolingFactor,this.maxNodeDisplacement=a.MAX_NODE_DISPLACEMENT),this.maxIterations=Math.max(this.getAllNodes().length*5,this.maxIterations),this.displacementThresholdPerNode=3*a.DEFAULT_EDGE_LENGTH/100,this.totalDisplacementThreshold=this.displacementThresholdPerNode*this.getAllNodes().length,this.repulsionRange=this.calcRepulsionRange()},r.prototype.calcSpringForces=function(){for(var t=this.getAllEdges(),s,o=0;o0&&arguments[0]!==void 0?arguments[0]:!0,s=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,o,c,l,T,g=this.getAllNodes(),d;if(this.useFRGridVariant)for(this.totalIterations%a.GRID_CALCULATION_CHECK_PERIOD==1&&t&&this.updateGrid(),d=new Set,o=0;oL||d>L)&&(t.gravitationForceX=-this.gravityConstant*l,t.gravitationForceY=-this.gravityConstant*T)):(L=s.getEstimatedSize()*this.compoundGravityRangeFactor,(g>L||d>L)&&(t.gravitationForceX=-this.gravityConstant*l*this.compoundGravityConstant,t.gravitationForceY=-this.gravityConstant*T*this.compoundGravityConstant))},r.prototype.isConverged=function(){var t,s=!1;return this.totalIterations>this.maxIterations/3&&(s=Math.abs(this.totalDisplacement-this.oldTotalDisplacement)<2),t=this.totalDisplacement=g.length||L>=g[0].length)){for(var R=0;Rr}}]),i})();M.exports=e}),(function(M,P,N){function v(){}v.svd=function(h){this.U=null,this.V=null,this.s=null,this.m=0,this.n=0,this.m=h.length,this.n=h[0].length;var a=Math.min(this.m,this.n);this.s=(function(Tt){for(var wt=[];Tt-- >0;)wt.push(0);return wt})(Math.min(this.m+1,this.n)),this.U=(function(Tt){var wt=function $t(bt){if(bt.length==0)return 0;for(var zt=[],St=0;St0;)wt.push(0);return wt})(this.n),i=(function(Tt){for(var wt=[];Tt-- >0;)wt.push(0);return wt})(this.m),f=!0,r=Math.min(this.m-1,this.n),u=Math.max(0,Math.min(this.n-2,this.m)),t=0;t=0;m--)if(this.s[m]!==0){for(var y=m+1;y=0;$--){if((function(Tt,wt){return Tt&&wt})($0;){var J=void 0,It=void 0;for(J=n-2;J>=-1&&J!==-1;J--)if(Math.abs(e[J])<=ht+tt*(Math.abs(this.s[J])+Math.abs(this.s[J+1]))){e[J]=0;break}if(J===n-2)It=4;else{var Nt=void 0;for(Nt=n-1;Nt>=J&&Nt!==J;Nt--){var vt=(Nt!==n?Math.abs(e[Nt]):0)+(Nt!==J+1?Math.abs(e[Nt-1]):0);if(Math.abs(this.s[Nt])<=ht+tt*vt){this.s[Nt]=0;break}}Nt===J?It=3:Nt===n-1?It=1:(It=2,J=Nt)}switch(J++,It){case 1:{var it=e[n-2];e[n-2]=0;for(var ut=n-2;ut>=J;ut--){var Et=v.hypot(this.s[ut],it),Ct=this.s[ut]/Et,Dt=it/Et;this.s[ut]=Et,ut!==J&&(it=-Dt*e[ut-1],e[ut-1]=Ct*e[ut-1]);for(var mt=0;mt=this.s[J+1]);){var Lt=this.s[J];if(this.s[J]=this.s[J+1],this.s[J+1]=Lt,JMath.abs(a)?(e=a/h,e=Math.abs(h)*Math.sqrt(1+e*e)):a!=0?(e=h/a,e=Math.abs(a)*Math.sqrt(1+e*e)):e=0,e},M.exports=v}),(function(M,P,N){var v=(function(){function e(i,f){for(var r=0;r2&&arguments[2]!==void 0?arguments[2]:1,u=arguments.length>3&&arguments[3]!==void 0?arguments[3]:-1,t=arguments.length>4&&arguments[4]!==void 0?arguments[4]:-1;h(this,e),this.sequence1=i,this.sequence2=f,this.match_score=r,this.mismatch_penalty=u,this.gap_penalty=t,this.iMax=i.length+1,this.jMax=f.length+1,this.grid=new Array(this.iMax);for(var s=0;s=0;i--){var f=this.listeners[i];f.event===a&&f.callback===e&&this.listeners.splice(i,1)}},h.emit=function(a,e){for(var i=0;i{var P={45:((a,e,i)=>{var f={};f.layoutBase=i(551),f.CoSEConstants=i(806),f.CoSEEdge=i(767),f.CoSEGraph=i(880),f.CoSEGraphManager=i(578),f.CoSELayout=i(765),f.CoSENode=i(991),f.ConstraintHandler=i(902),a.exports=f}),806:((a,e,i)=>{var f=i(551).FDLayoutConstants;function r(){}for(var u in f)r[u]=f[u];r.DEFAULT_USE_MULTI_LEVEL_SCALING=!1,r.DEFAULT_RADIAL_SEPARATION=f.DEFAULT_EDGE_LENGTH,r.DEFAULT_COMPONENT_SEPERATION=60,r.TILE=!0,r.TILING_PADDING_VERTICAL=10,r.TILING_PADDING_HORIZONTAL=10,r.TRANSFORM_ON_CONSTRAINT_HANDLING=!0,r.ENFORCE_CONSTRAINTS=!0,r.APPLY_LAYOUT=!0,r.RELAX_MOVEMENT_ON_CONSTRAINTS=!0,r.TREE_REDUCTION_ON_INCREMENTAL=!0,r.PURE_INCREMENTAL=r.DEFAULT_INCREMENTAL,a.exports=r}),767:((a,e,i)=>{var f=i(551).FDLayoutEdge;function r(t,s,o){f.call(this,t,s,o)}r.prototype=Object.create(f.prototype);for(var u in f)r[u]=f[u];a.exports=r}),880:((a,e,i)=>{var f=i(551).LGraph;function r(t,s,o){f.call(this,t,s,o)}r.prototype=Object.create(f.prototype);for(var u in f)r[u]=f[u];a.exports=r}),578:((a,e,i)=>{var f=i(551).LGraphManager;function r(t){f.call(this,t)}r.prototype=Object.create(f.prototype);for(var u in f)r[u]=f[u];a.exports=r}),765:((a,e,i)=>{var f=i(551).FDLayout,r=i(578),u=i(880),t=i(991),s=i(767),o=i(806),c=i(902),l=i(551).FDLayoutConstants,T=i(551).LayoutConstants,g=i(551).Point,d=i(551).PointD,L=i(551).DimensionD,R=i(551).Layout,C=i(551).Integer,G=i(551).IGeometry,V=i(551).LGraph,Y=i(551).Transform,z=i(551).LinkedList;function A(){f.call(this),this.toBeTiled={},this.constraints={}}A.prototype=Object.create(f.prototype);for(var _ in f)A[_]=f[_];A.prototype.newGraphManager=function(){var n=new r(this);return this.graphManager=n,n},A.prototype.newGraph=function(n){return new u(null,this.graphManager,n)},A.prototype.newNode=function(n){return new t(this.graphManager,n)},A.prototype.newEdge=function(n){return new s(null,null,n)},A.prototype.initParameters=function(){f.prototype.initParameters.call(this,arguments),this.isSubLayout||(o.DEFAULT_EDGE_LENGTH<10?this.idealEdgeLength=10:this.idealEdgeLength=o.DEFAULT_EDGE_LENGTH,this.useSmartIdealEdgeLengthCalculation=o.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION,this.gravityConstant=l.DEFAULT_GRAVITY_STRENGTH,this.compoundGravityConstant=l.DEFAULT_COMPOUND_GRAVITY_STRENGTH,this.gravityRangeFactor=l.DEFAULT_GRAVITY_RANGE_FACTOR,this.compoundGravityRangeFactor=l.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR,this.prunedNodesAll=[],this.growTreeIterations=0,this.afterGrowthIterations=0,this.isTreeGrowing=!1,this.isGrowthFinished=!1)},A.prototype.initSpringEmbedder=function(){f.prototype.initSpringEmbedder.call(this),this.coolingCycle=0,this.maxCoolingCycle=this.maxIterations/l.CONVERGENCE_CHECK_PERIOD,this.finalTemperature=.04,this.coolingAdjuster=1},A.prototype.layout=function(){var n=T.DEFAULT_CREATE_BENDS_AS_NEEDED;return n&&(this.createBendpoints(),this.graphManager.resetAllEdges()),this.level=0,this.classicLayout()},A.prototype.classicLayout=function(){if(this.nodesWithGravity=this.calculateNodesToApplyGravitationTo(),this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity),this.calcNoOfChildrenForAllNodes(),this.graphManager.calcLowestCommonAncestors(),this.graphManager.calcInclusionTreeDepths(),this.graphManager.getRoot().calcEstimatedSize(),this.calcIdealEdgeLengths(),this.incremental){if(o.TREE_REDUCTION_ON_INCREMENTAL){this.reduceTrees(),this.graphManager.resetAllNodesToApplyGravitation();var E=new Set(this.getAllNodes()),p=this.nodesWithGravity.filter(function(I){return E.has(I)});this.graphManager.setAllNodesToApplyGravitation(p)}}else{var n=this.getFlatForest();if(n.length>0)this.positionNodesRadially(n);else{this.reduceTrees(),this.graphManager.resetAllNodesToApplyGravitation();var E=new Set(this.getAllNodes()),p=this.nodesWithGravity.filter(function(m){return E.has(m)});this.graphManager.setAllNodesToApplyGravitation(p),this.positionNodesRandomly()}}return Object.keys(this.constraints).length>0&&(c.handleConstraints(this),this.initConstraintVariables()),this.initSpringEmbedder(),o.APPLY_LAYOUT&&this.runSpringEmbedder(),!0},A.prototype.tick=function(){if(this.totalIterations++,this.totalIterations===this.maxIterations&&!this.isTreeGrowing&&!this.isGrowthFinished)if(this.prunedNodesAll.length>0)this.isTreeGrowing=!0;else return!0;if(this.totalIterations%l.CONVERGENCE_CHECK_PERIOD==0&&!this.isTreeGrowing&&!this.isGrowthFinished){if(this.isConverged())if(this.prunedNodesAll.length>0)this.isTreeGrowing=!0;else return!0;this.coolingCycle++,this.layoutQuality==0?this.coolingAdjuster=this.coolingCycle:this.layoutQuality==1&&(this.coolingAdjuster=this.coolingCycle/3),this.coolingFactor=Math.max(this.initialCoolingFactor-Math.pow(this.coolingCycle,Math.log(100*(this.initialCoolingFactor-this.finalTemperature))/Math.log(this.maxCoolingCycle))/100*this.coolingAdjuster,this.finalTemperature),this.animationPeriod=Math.ceil(this.initialAnimationPeriod*Math.sqrt(this.coolingFactor))}if(this.isTreeGrowing){if(this.growTreeIterations%10==0)if(this.prunedNodesAll.length>0){this.graphManager.updateBounds(),this.updateGrid(),this.growTree(this.prunedNodesAll),this.graphManager.resetAllNodesToApplyGravitation();var n=new Set(this.getAllNodes()),E=this.nodesWithGravity.filter(function(y){return n.has(y)});this.graphManager.setAllNodesToApplyGravitation(E),this.graphManager.updateBounds(),this.updateGrid(),o.PURE_INCREMENTAL?this.coolingFactor=l.DEFAULT_COOLING_FACTOR_INCREMENTAL/2:this.coolingFactor=l.DEFAULT_COOLING_FACTOR_INCREMENTAL}else this.isTreeGrowing=!1,this.isGrowthFinished=!0;this.growTreeIterations++}if(this.isGrowthFinished){if(this.isConverged())return!0;this.afterGrowthIterations%10==0&&(this.graphManager.updateBounds(),this.updateGrid()),o.PURE_INCREMENTAL?this.coolingFactor=l.DEFAULT_COOLING_FACTOR_INCREMENTAL/2*((100-this.afterGrowthIterations)/100):this.coolingFactor=l.DEFAULT_COOLING_FACTOR_INCREMENTAL*((100-this.afterGrowthIterations)/100),this.afterGrowthIterations++}var p=!this.isTreeGrowing&&!this.isGrowthFinished,m=this.growTreeIterations%10==1&&this.isTreeGrowing||this.afterGrowthIterations%10==1&&this.isGrowthFinished;return this.totalDisplacement=0,this.graphManager.updateBounds(),this.calcSpringForces(),this.calcRepulsionForces(p,m),this.calcGravitationalForces(),this.moveNodes(),this.animate(),!1},A.prototype.getPositionsData=function(){for(var n=this.graphManager.getAllNodes(),E={},p=0;p0&&this.updateDisplacements();for(var p=0;p0&&(m.fixedNodeWeight=I)}}if(this.constraints.relativePlacementConstraint){var D=new Map,S=new Map;if(this.dummyToNodeForVerticalAlignment=new Map,this.dummyToNodeForHorizontalAlignment=new Map,this.fixedNodesOnHorizontal=new Set,this.fixedNodesOnVertical=new Set,this.fixedNodeSet.forEach(function(O){n.fixedNodesOnHorizontal.add(O),n.fixedNodesOnVertical.add(O)}),this.constraints.alignmentConstraint){if(this.constraints.alignmentConstraint.vertical)for(var W=this.constraints.alignmentConstraint.vertical,p=0;p=2*O.length/3;tt--)H=Math.floor(Math.random()*(tt+1)),k=O[tt],O[tt]=O[H],O[H]=k;return O},this.nodesInRelativeHorizontal=[],this.nodesInRelativeVertical=[],this.nodeToRelativeConstraintMapHorizontal=new Map,this.nodeToRelativeConstraintMapVertical=new Map,this.nodeToTempPositionMapHorizontal=new Map,this.nodeToTempPositionMapVertical=new Map,this.constraints.relativePlacementConstraint.forEach(function(O){if(O.left){var H=D.has(O.left)?D.get(O.left):O.left,k=D.has(O.right)?D.get(O.right):O.right;n.nodesInRelativeHorizontal.includes(H)||(n.nodesInRelativeHorizontal.push(H),n.nodeToRelativeConstraintMapHorizontal.set(H,[]),n.dummyToNodeForVerticalAlignment.has(H)?n.nodeToTempPositionMapHorizontal.set(H,n.idToNodeMap.get(n.dummyToNodeForVerticalAlignment.get(H)[0]).getCenterX()):n.nodeToTempPositionMapHorizontal.set(H,n.idToNodeMap.get(H).getCenterX())),n.nodesInRelativeHorizontal.includes(k)||(n.nodesInRelativeHorizontal.push(k),n.nodeToRelativeConstraintMapHorizontal.set(k,[]),n.dummyToNodeForVerticalAlignment.has(k)?n.nodeToTempPositionMapHorizontal.set(k,n.idToNodeMap.get(n.dummyToNodeForVerticalAlignment.get(k)[0]).getCenterX()):n.nodeToTempPositionMapHorizontal.set(k,n.idToNodeMap.get(k).getCenterX())),n.nodeToRelativeConstraintMapHorizontal.get(H).push({right:k,gap:O.gap}),n.nodeToRelativeConstraintMapHorizontal.get(k).push({left:H,gap:O.gap})}else{var tt=S.has(O.top)?S.get(O.top):O.top,ht=S.has(O.bottom)?S.get(O.bottom):O.bottom;n.nodesInRelativeVertical.includes(tt)||(n.nodesInRelativeVertical.push(tt),n.nodeToRelativeConstraintMapVertical.set(tt,[]),n.dummyToNodeForHorizontalAlignment.has(tt)?n.nodeToTempPositionMapVertical.set(tt,n.idToNodeMap.get(n.dummyToNodeForHorizontalAlignment.get(tt)[0]).getCenterY()):n.nodeToTempPositionMapVertical.set(tt,n.idToNodeMap.get(tt).getCenterY())),n.nodesInRelativeVertical.includes(ht)||(n.nodesInRelativeVertical.push(ht),n.nodeToRelativeConstraintMapVertical.set(ht,[]),n.dummyToNodeForHorizontalAlignment.has(ht)?n.nodeToTempPositionMapVertical.set(ht,n.idToNodeMap.get(n.dummyToNodeForHorizontalAlignment.get(ht)[0]).getCenterY()):n.nodeToTempPositionMapVertical.set(ht,n.idToNodeMap.get(ht).getCenterY())),n.nodeToRelativeConstraintMapVertical.get(tt).push({bottom:ht,gap:O.gap}),n.nodeToRelativeConstraintMapVertical.get(ht).push({top:tt,gap:O.gap})}});else{var Q=new Map,$=new Map;this.constraints.relativePlacementConstraint.forEach(function(O){if(O.left){var H=D.has(O.left)?D.get(O.left):O.left,k=D.has(O.right)?D.get(O.right):O.right;Q.has(H)?Q.get(H).push(k):Q.set(H,[k]),Q.has(k)?Q.get(k).push(H):Q.set(k,[H])}else{var tt=S.has(O.top)?S.get(O.top):O.top,ht=S.has(O.bottom)?S.get(O.bottom):O.bottom;$.has(tt)?$.get(tt).push(ht):$.set(tt,[ht]),$.has(ht)?$.get(ht).push(tt):$.set(ht,[tt])}});var X=function(H,k){var tt=[],ht=[],J=new z,It=new Set,Nt=0;return H.forEach(function(vt,it){if(!It.has(it)){tt[Nt]=[],ht[Nt]=!1;var ut=it;for(J.push(ut),It.add(ut),tt[Nt].push(ut);J.length!=0;){ut=J.shift(),k.has(ut)&&(ht[Nt]=!0);var Et=H.get(ut);Et.forEach(function(Ct){It.has(Ct)||(J.push(Ct),It.add(Ct),tt[Nt].push(Ct))})}Nt++}}),{components:tt,isFixed:ht}},rt=X(Q,n.fixedNodesOnHorizontal);this.componentsOnHorizontal=rt.components,this.fixedComponentsOnHorizontal=rt.isFixed;var B=X($,n.fixedNodesOnVertical);this.componentsOnVertical=B.components,this.fixedComponentsOnVertical=B.isFixed}}},A.prototype.updateDisplacements=function(){var n=this;if(this.constraints.fixedNodeConstraint&&this.constraints.fixedNodeConstraint.forEach(function(B){var O=n.idToNodeMap.get(B.nodeId);O.displacementX=0,O.displacementY=0}),this.constraints.alignmentConstraint){if(this.constraints.alignmentConstraint.vertical)for(var E=this.constraints.alignmentConstraint.vertical,p=0;p1){var S;for(S=0;Sm&&(m=Math.floor(D.y)),I=Math.floor(D.x+o.DEFAULT_COMPONENT_SEPERATION)}this.transform(new d(T.WORLD_CENTER_X-D.x/2,T.WORLD_CENTER_Y-D.y/2))},A.radialLayout=function(n,E,p){var m=Math.max(this.maxDiagonalInTree(n),o.DEFAULT_RADIAL_SEPARATION);A.branchRadialLayout(E,null,0,359,0,m);var y=V.calculateBounds(n),I=new Y;I.setDeviceOrgX(y.getMinX()),I.setDeviceOrgY(y.getMinY()),I.setWorldOrgX(p.x),I.setWorldOrgY(p.y);for(var D=0;D1;){var k=H[0];H.splice(0,1);var tt=$.indexOf(k);tt>=0&&$.splice(tt,1),B--,X--}E!=null?O=($.indexOf(H[0])+1)%B:O=0;for(var ht=Math.abs(m-p)/X,J=O;rt!=X;J=++J%B){var It=$[J].getOtherEnd(n);if(It!=E){var Nt=(p+rt*ht)%360,vt=(Nt+ht)%360;A.branchRadialLayout(It,n,Nt,vt,y+I,I),rt++}}},A.maxDiagonalInTree=function(n){for(var E=C.MIN_VALUE,p=0;pE&&(E=y)}return E},A.prototype.calcRepulsionRange=function(){return 2*(this.level+1)*this.idealEdgeLength},A.prototype.groupZeroDegreeMembers=function(){var n=this,E={};this.memberGroups={},this.idToDummyNode={};for(var p=[],m=this.graphManager.getAllNodes(),y=0;y"u"&&(E[S]=[]),E[S]=E[S].concat(I)}Object.keys(E).forEach(function(W){if(E[W].length>1){var x="DummyCompound_"+W;n.memberGroups[x]=E[W];var Q=E[W][0].getParent(),$=new t(n.graphManager);$.id=x,$.paddingLeft=Q.paddingLeft||0,$.paddingRight=Q.paddingRight||0,$.paddingBottom=Q.paddingBottom||0,$.paddingTop=Q.paddingTop||0,n.idToDummyNode[x]=$;var X=n.getGraphManager().add(n.newGraph(),$),rt=Q.getChild();rt.add($);for(var B=0;By?(m.rect.x-=(m.labelWidth-y)/2,m.setWidth(m.labelWidth),m.labelMarginLeft=(m.labelWidth-y)/2):m.labelPosHorizontal=="right"&&m.setWidth(y+m.labelWidth)),m.labelHeight&&(m.labelPosVertical=="top"?(m.rect.y-=m.labelHeight,m.setHeight(I+m.labelHeight),m.labelMarginTop=m.labelHeight):m.labelPosVertical=="center"&&m.labelHeight>I?(m.rect.y-=(m.labelHeight-I)/2,m.setHeight(m.labelHeight),m.labelMarginTop=(m.labelHeight-I)/2):m.labelPosVertical=="bottom"&&m.setHeight(I+m.labelHeight))}})},A.prototype.repopulateCompounds=function(){for(var n=this.compoundOrder.length-1;n>=0;n--){var E=this.compoundOrder[n],p=E.id,m=E.paddingLeft,y=E.paddingTop,I=E.labelMarginLeft,D=E.labelMarginTop;this.adjustLocations(this.tiledMemberPack[p],E.rect.x,E.rect.y,m,y,I,D)}},A.prototype.repopulateZeroDegreeMembers=function(){var n=this,E=this.tiledZeroDegreePack;Object.keys(E).forEach(function(p){var m=n.idToDummyNode[p],y=m.paddingLeft,I=m.paddingTop,D=m.labelMarginLeft,S=m.labelMarginTop;n.adjustLocations(E[p],m.rect.x,m.rect.y,y,I,D,S)})},A.prototype.getToBeTiled=function(n){var E=n.id;if(this.toBeTiled[E]!=null)return this.toBeTiled[E];var p=n.getChild();if(p==null)return this.toBeTiled[E]=!1,!1;for(var m=p.getNodes(),y=0;y0)return this.toBeTiled[E]=!1,!1;if(I.getChild()==null){this.toBeTiled[I.id]=!1;continue}if(!this.getToBeTiled(I))return this.toBeTiled[E]=!1,!1}return this.toBeTiled[E]=!0,!0},A.prototype.getNodeDegree=function(n){n.id;for(var E=n.getEdges(),p=0,m=0;mQ&&(Q=X.rect.height)}p+=Q+n.verticalPadding}},A.prototype.tileCompoundMembers=function(n,E){var p=this;this.tiledMemberPack=[],Object.keys(n).forEach(function(m){var y=E[m];if(p.tiledMemberPack[m]=p.tileNodes(n[m],y.paddingLeft+y.paddingRight),y.rect.width=p.tiledMemberPack[m].width,y.rect.height=p.tiledMemberPack[m].height,y.setCenter(p.tiledMemberPack[m].centerX,p.tiledMemberPack[m].centerY),y.labelMarginLeft=0,y.labelMarginTop=0,o.NODE_DIMENSIONS_INCLUDE_LABELS){var I=y.rect.width,D=y.rect.height;y.labelWidth&&(y.labelPosHorizontal=="left"?(y.rect.x-=y.labelWidth,y.setWidth(I+y.labelWidth),y.labelMarginLeft=y.labelWidth):y.labelPosHorizontal=="center"&&y.labelWidth>I?(y.rect.x-=(y.labelWidth-I)/2,y.setWidth(y.labelWidth),y.labelMarginLeft=(y.labelWidth-I)/2):y.labelPosHorizontal=="right"&&y.setWidth(I+y.labelWidth)),y.labelHeight&&(y.labelPosVertical=="top"?(y.rect.y-=y.labelHeight,y.setHeight(D+y.labelHeight),y.labelMarginTop=y.labelHeight):y.labelPosVertical=="center"&&y.labelHeight>D?(y.rect.y-=(y.labelHeight-D)/2,y.setHeight(y.labelHeight),y.labelMarginTop=(y.labelHeight-D)/2):y.labelPosVertical=="bottom"&&y.setHeight(D+y.labelHeight))}})},A.prototype.tileNodes=function(n,E){var p=this.tileNodesByFavoringDim(n,E,!0),m=this.tileNodesByFavoringDim(n,E,!1),y=this.getOrgRatio(p),I=this.getOrgRatio(m),D;return IS&&(S=B.getWidth())});var W=I/y,x=D/y,Q=Math.pow(p-m,2)+4*(W+m)*(x+p)*y,$=(m-p+Math.sqrt(Q))/(2*(W+m)),X;E?(X=Math.ceil($),X==$&&X++):X=Math.floor($);var rt=X*(W+m)-m;return S>rt&&(rt=S),rt+=m*2,rt},A.prototype.tileNodesByFavoringDim=function(n,E,p){var m=o.TILING_PADDING_VERTICAL,y=o.TILING_PADDING_HORIZONTAL,I=o.TILING_COMPARE_BY,D={rows:[],rowWidth:[],rowHeight:[],width:0,height:E,verticalPadding:m,horizontalPadding:y,centerX:0,centerY:0};I&&(D.idealRowWidth=this.calcIdealRowWidth(n,p));var S=function(O){return O.rect.width*O.rect.height},W=function(O,H){return S(H)-S(O)};n.sort(function(B,O){var H=W;return D.idealRowWidth?(H=I,H(B.id,O.id)):H(B,O)});for(var x=0,Q=0,$=0;$0&&(D+=n.horizontalPadding),n.rowWidth[p]=D,n.width0&&(S+=n.verticalPadding);var W=0;S>n.rowHeight[p]&&(W=n.rowHeight[p],n.rowHeight[p]=S,W=n.rowHeight[p]-W),n.height+=W,n.rows[p].push(E)},A.prototype.getShortestRowIndex=function(n){for(var E=-1,p=Number.MAX_VALUE,m=0;mp&&(E=m,p=n.rowWidth[m]);return E},A.prototype.canAddHorizontal=function(n,E,p){if(n.idealRowWidth){var m=n.rows.length-1,y=n.rowWidth[m];return y+E+n.horizontalPadding<=n.idealRowWidth}var I=this.getShortestRowIndex(n);if(I<0)return!0;var D=n.rowWidth[I];if(D+n.horizontalPadding+E<=n.width)return!0;var S=0;n.rowHeight[I]0&&(S=p+n.verticalPadding-n.rowHeight[I]);var W;n.width-D>=E+n.horizontalPadding?W=(n.height+S)/(D+E+n.horizontalPadding):W=(n.height+S)/n.width,S=p+n.verticalPadding;var x;return n.widthI&&E!=p){m.splice(-1,1),n.rows[p].push(y),n.rowWidth[E]=n.rowWidth[E]-I,n.rowWidth[p]=n.rowWidth[p]+I,n.width=n.rowWidth[instance.getLongestRowIndex(n)];for(var D=Number.MIN_VALUE,S=0;SD&&(D=m[S].height);E>0&&(D+=n.verticalPadding);var W=n.rowHeight[E]+n.rowHeight[p];n.rowHeight[E]=D,n.rowHeight[p]0)for(var rt=y;rt<=I;rt++)X[0]+=this.grid[rt][D-1].length+this.grid[rt][D].length-1;if(I0)for(var rt=D;rt<=S;rt++)X[3]+=this.grid[y-1][rt].length+this.grid[y][rt].length-1;for(var B=C.MAX_VALUE,O,H,k=0;k{var f=i(551).FDLayoutNode,r=i(551).IMath;function u(s,o,c,l){f.call(this,s,o,c,l)}u.prototype=Object.create(f.prototype);for(var t in f)u[t]=f[t];u.prototype.calculateDisplacement=function(){var s=this.graphManager.getLayout();this.getChild()!=null&&this.fixedNodeWeight?(this.displacementX+=s.coolingFactor*(this.springForceX+this.repulsionForceX+this.gravitationForceX)/this.fixedNodeWeight,this.displacementY+=s.coolingFactor*(this.springForceY+this.repulsionForceY+this.gravitationForceY)/this.fixedNodeWeight):(this.displacementX+=s.coolingFactor*(this.springForceX+this.repulsionForceX+this.gravitationForceX)/this.noOfChildren,this.displacementY+=s.coolingFactor*(this.springForceY+this.repulsionForceY+this.gravitationForceY)/this.noOfChildren),Math.abs(this.displacementX)>s.coolingFactor*s.maxNodeDisplacement&&(this.displacementX=s.coolingFactor*s.maxNodeDisplacement*r.sign(this.displacementX)),Math.abs(this.displacementY)>s.coolingFactor*s.maxNodeDisplacement&&(this.displacementY=s.coolingFactor*s.maxNodeDisplacement*r.sign(this.displacementY)),this.child&&this.child.getNodes().length>0&&this.propogateDisplacementToChildren(this.displacementX,this.displacementY)},u.prototype.propogateDisplacementToChildren=function(s,o){for(var c=this.getChild().getNodes(),l,T=0;T{function f(c){if(Array.isArray(c)){for(var l=0,T=Array(c.length);l0){var Lt=0;ot.forEach(function(st){Z=="horizontal"?(et.set(st,g.has(st)?d[g.get(st)]:q.get(st)),Lt+=et.get(st)):(et.set(st,g.has(st)?L[g.get(st)]:q.get(st)),Lt+=et.get(st))}),Lt=Lt/ot.length,lt.forEach(function(st){K.has(st)||et.set(st,Lt)})}else{var ft=0;lt.forEach(function(st){Z=="horizontal"?ft+=g.has(st)?d[g.get(st)]:q.get(st):ft+=g.has(st)?L[g.get(st)]:q.get(st)}),ft=ft/lt.length,lt.forEach(function(st){et.set(st,ft)})}});for(var Mt=function(){var ot=dt.shift(),Lt=U.get(ot);Lt.forEach(function(ft){if(et.get(ft.id)st&&(st=kt),KtXt&&(Xt=Kt)}}catch(ee){wt=!0,$t=ee}finally{try{!Tt&&bt.return&&bt.return()}finally{if(wt)throw $t}}var se=(Lt+st)/2-(ft+Xt)/2,Qt=!0,jt=!1,_t=void 0;try{for(var Jt=lt[Symbol.iterator](),ne;!(Qt=(ne=Jt.next()).done);Qt=!0){var te=ne.value;et.set(te,et.get(te)+se)}}catch(ee){jt=!0,_t=ee}finally{try{!Qt&&Jt.return&&Jt.return()}finally{if(jt)throw _t}}})}return et},_=function(U){var Z=0,K=0,q=0,at=0;if(U.forEach(function(j){j.left?d[g.get(j.left)]-d[g.get(j.right)]>=0?Z++:K++:L[g.get(j.top)]-L[g.get(j.bottom)]>=0?q++:at++}),Z>K&&q>at)for(var gt=0;gtK)for(var nt=0;ntat)for(var et=0;et1)l.fixedNodeConstraint.forEach(function(b,U){m[U]=[b.position.x,b.position.y],y[U]=[d[g.get(b.nodeId)],L[g.get(b.nodeId)]]}),I=!0;else if(l.alignmentConstraint)(function(){var b=0;if(l.alignmentConstraint.vertical){for(var U=l.alignmentConstraint.vertical,Z=function(et){var j=new Set;U[et].forEach(function(pt){j.add(pt)});var dt=new Set([].concat(f(j)).filter(function(pt){return S.has(pt)})),Mt=void 0;dt.size>0?Mt=d[g.get(dt.values().next().value)]:Mt=z(j).x,U[et].forEach(function(pt){m[b]=[Mt,L[g.get(pt)]],y[b]=[d[g.get(pt)],L[g.get(pt)]],b++})},K=0;K0?Mt=d[g.get(dt.values().next().value)]:Mt=z(j).y,q[et].forEach(function(pt){m[b]=[d[g.get(pt)],Mt],y[b]=[d[g.get(pt)],L[g.get(pt)]],b++})},gt=0;gt$&&($=Q[rt].length,X=rt);if($0){var mt={x:0,y:0};l.fixedNodeConstraint.forEach(function(b,U){var Z={x:d[g.get(b.nodeId)],y:L[g.get(b.nodeId)]},K=b.position,q=Y(K,Z);mt.x+=q.x,mt.y+=q.y}),mt.x/=l.fixedNodeConstraint.length,mt.y/=l.fixedNodeConstraint.length,d.forEach(function(b,U){d[U]+=mt.x}),L.forEach(function(b,U){L[U]+=mt.y}),l.fixedNodeConstraint.forEach(function(b){d[g.get(b.nodeId)]=b.position.x,L[g.get(b.nodeId)]=b.position.y})}if(l.alignmentConstraint){if(l.alignmentConstraint.vertical)for(var Ot=l.alignmentConstraint.vertical,Rt=function(U){var Z=new Set;Ot[U].forEach(function(at){Z.add(at)});var K=new Set([].concat(f(Z)).filter(function(at){return S.has(at)})),q=void 0;K.size>0?q=d[g.get(K.values().next().value)]:q=z(Z).x,Z.forEach(function(at){S.has(at)||(d[g.get(at)]=q)})},Ht=0;Ht0?q=L[g.get(K.values().next().value)]:q=z(Z).y,Z.forEach(function(at){S.has(at)||(L[g.get(at)]=q)})},Ft=0;Ft{a.exports=M})},N={};function v(a){var e=N[a];if(e!==void 0)return e.exports;var i=N[a]={exports:{}};return P[a](i,i.exports,v),i.exports}var h=v(45);return h})()})})(ge)),ge.exports}(function(w,F){(function(P,N){w.exports=N(dr())})(ye,function(M){return(()=>{var P={658:(a=>{a.exports=Object.assign!=null?Object.assign.bind(Object):function(e){for(var i=arguments.length,f=Array(i>1?i-1:0),r=1;r{var f=(function(){function t(s,o){var c=[],l=!0,T=!1,g=void 0;try{for(var d=s[Symbol.iterator](),L;!(l=(L=d.next()).done)&&(c.push(L.value),!(o&&c.length===o));l=!0);}catch(R){T=!0,g=R}finally{try{!l&&d.return&&d.return()}finally{if(T)throw g}}return c}return function(s,o){if(Array.isArray(s))return s;if(Symbol.iterator in Object(s))return t(s,o);throw new TypeError("Invalid attempt to destructure non-iterable instance")}})(),r=i(140).layoutBase.LinkedList,u={};u.getTopMostNodes=function(t){for(var s={},o=0;o0&&I.merge(x)});for(var D=0;D1){L=g[0],R=L.connectedEdges().length,g.forEach(function(y){y.connectedEdges().length0&&c.set("dummy"+(c.size+1),V),Y},u.relocateComponent=function(t,s,o){if(!o.fixedNodeConstraint){var c=Number.POSITIVE_INFINITY,l=Number.NEGATIVE_INFINITY,T=Number.POSITIVE_INFINITY,g=Number.NEGATIVE_INFINITY;if(o.quality=="draft"){var d=!0,L=!1,R=void 0;try{for(var C=s.nodeIndexes[Symbol.iterator](),G;!(d=(G=C.next()).done);d=!0){var V=G.value,Y=f(V,2),z=Y[0],A=Y[1],_=o.cy.getElementById(z);if(_){var n=_.boundingBox(),E=s.xCoords[A]-n.w/2,p=s.xCoords[A]+n.w/2,m=s.yCoords[A]-n.h/2,y=s.yCoords[A]+n.h/2;El&&(l=p),mg&&(g=y)}}}catch(x){L=!0,R=x}finally{try{!d&&C.return&&C.return()}finally{if(L)throw R}}var I=t.x-(l+c)/2,D=t.y-(g+T)/2;s.xCoords=s.xCoords.map(function(x){return x+I}),s.yCoords=s.yCoords.map(function(x){return x+D})}else{Object.keys(s).forEach(function(x){var Q=s[x],$=Q.getRect().x,X=Q.getRect().x+Q.getRect().width,rt=Q.getRect().y,B=Q.getRect().y+Q.getRect().height;$l&&(l=X),rtg&&(g=B)});var S=t.x-(l+c)/2,W=t.y-(g+T)/2;Object.keys(s).forEach(function(x){var Q=s[x];Q.setCenter(Q.getCenterX()+S,Q.getCenterY()+W)})}}},u.calcBoundingBox=function(t,s,o,c){for(var l=Number.MAX_SAFE_INTEGER,T=Number.MIN_SAFE_INTEGER,g=Number.MAX_SAFE_INTEGER,d=Number.MIN_SAFE_INTEGER,L=void 0,R=void 0,C=void 0,G=void 0,V=t.descendants().not(":parent"),Y=V.length,z=0;zL&&(l=L),TC&&(g=C),d{var f=i(548),r=i(140).CoSELayout,u=i(140).CoSENode,t=i(140).layoutBase.PointD,s=i(140).layoutBase.DimensionD,o=i(140).layoutBase.LayoutConstants,c=i(140).layoutBase.FDLayoutConstants,l=i(140).CoSEConstants,T=function(d,L){var R=d.cy,C=d.eles,G=C.nodes(),V=C.edges(),Y=void 0,z=void 0,A=void 0,_={};d.randomize&&(Y=L.nodeIndexes,z=L.xCoords,A=L.yCoords);var n=function(x){return typeof x=="function"},E=function(x,Q){return n(x)?x(Q):x},p=f.calcParentsWithoutChildren(R,C),m=function W(x,Q,$,X){for(var rt=Q.length,B=0;B0){var J=void 0;J=$.getGraphManager().add($.newGraph(),k),W(J,H,$,X)}}},y=function(x,Q,$){for(var X=0,rt=0,B=0;B<$.length;B++){var O=$[B],H=_[O.data("source")],k=_[O.data("target")];if(H&&k&&H!==k&&H.getEdgesBetween(k).length==0){var tt=Q.add(x.newEdge(),H,k);tt.id=O.id(),tt.idealLength=E(d.idealEdgeLength,O),tt.edgeElasticity=E(d.edgeElasticity,O),X+=tt.idealLength,rt++}}d.idealEdgeLength!=null&&(rt>0?l.DEFAULT_EDGE_LENGTH=c.DEFAULT_EDGE_LENGTH=X/rt:n(d.idealEdgeLength)?l.DEFAULT_EDGE_LENGTH=c.DEFAULT_EDGE_LENGTH=50:l.DEFAULT_EDGE_LENGTH=c.DEFAULT_EDGE_LENGTH=d.idealEdgeLength,l.MIN_REPULSION_DIST=c.MIN_REPULSION_DIST=c.DEFAULT_EDGE_LENGTH/10,l.DEFAULT_RADIAL_SEPARATION=c.DEFAULT_EDGE_LENGTH)},I=function(x,Q){Q.fixedNodeConstraint&&(x.constraints.fixedNodeConstraint=Q.fixedNodeConstraint),Q.alignmentConstraint&&(x.constraints.alignmentConstraint=Q.alignmentConstraint),Q.relativePlacementConstraint&&(x.constraints.relativePlacementConstraint=Q.relativePlacementConstraint)};d.nestingFactor!=null&&(l.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR=c.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR=d.nestingFactor),d.gravity!=null&&(l.DEFAULT_GRAVITY_STRENGTH=c.DEFAULT_GRAVITY_STRENGTH=d.gravity),d.numIter!=null&&(l.MAX_ITERATIONS=c.MAX_ITERATIONS=d.numIter),d.gravityRange!=null&&(l.DEFAULT_GRAVITY_RANGE_FACTOR=c.DEFAULT_GRAVITY_RANGE_FACTOR=d.gravityRange),d.gravityCompound!=null&&(l.DEFAULT_COMPOUND_GRAVITY_STRENGTH=c.DEFAULT_COMPOUND_GRAVITY_STRENGTH=d.gravityCompound),d.gravityRangeCompound!=null&&(l.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR=c.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR=d.gravityRangeCompound),d.initialEnergyOnIncremental!=null&&(l.DEFAULT_COOLING_FACTOR_INCREMENTAL=c.DEFAULT_COOLING_FACTOR_INCREMENTAL=d.initialEnergyOnIncremental),d.tilingCompareBy!=null&&(l.TILING_COMPARE_BY=d.tilingCompareBy),d.quality=="proof"?o.QUALITY=2:o.QUALITY=0,l.NODE_DIMENSIONS_INCLUDE_LABELS=c.NODE_DIMENSIONS_INCLUDE_LABELS=o.NODE_DIMENSIONS_INCLUDE_LABELS=d.nodeDimensionsIncludeLabels,l.DEFAULT_INCREMENTAL=c.DEFAULT_INCREMENTAL=o.DEFAULT_INCREMENTAL=!d.randomize,l.ANIMATE=c.ANIMATE=o.ANIMATE=d.animate,l.TILE=d.tile,l.TILING_PADDING_VERTICAL=typeof d.tilingPaddingVertical=="function"?d.tilingPaddingVertical.call():d.tilingPaddingVertical,l.TILING_PADDING_HORIZONTAL=typeof d.tilingPaddingHorizontal=="function"?d.tilingPaddingHorizontal.call():d.tilingPaddingHorizontal,l.DEFAULT_INCREMENTAL=c.DEFAULT_INCREMENTAL=o.DEFAULT_INCREMENTAL=!0,l.PURE_INCREMENTAL=!d.randomize,o.DEFAULT_UNIFORM_LEAF_NODE_SIZES=d.uniformNodeDimensions,d.step=="transformed"&&(l.TRANSFORM_ON_CONSTRAINT_HANDLING=!0,l.ENFORCE_CONSTRAINTS=!1,l.APPLY_LAYOUT=!1),d.step=="enforced"&&(l.TRANSFORM_ON_CONSTRAINT_HANDLING=!1,l.ENFORCE_CONSTRAINTS=!0,l.APPLY_LAYOUT=!1),d.step=="cose"&&(l.TRANSFORM_ON_CONSTRAINT_HANDLING=!1,l.ENFORCE_CONSTRAINTS=!1,l.APPLY_LAYOUT=!0),d.step=="all"&&(d.randomize?l.TRANSFORM_ON_CONSTRAINT_HANDLING=!0:l.TRANSFORM_ON_CONSTRAINT_HANDLING=!1,l.ENFORCE_CONSTRAINTS=!0,l.APPLY_LAYOUT=!0),d.fixedNodeConstraint||d.alignmentConstraint||d.relativePlacementConstraint?l.TREE_REDUCTION_ON_INCREMENTAL=!1:l.TREE_REDUCTION_ON_INCREMENTAL=!0;var D=new r,S=D.newGraphManager();return m(S.addRoot(),f.getTopMostNodes(G),D,d),y(D,S,V),I(D,d),D.runLayout(),_};a.exports={coseLayout:T}}),212:((a,e,i)=>{var f=(function(){function d(L,R){for(var C=0;C0)if(p){var I=t.getTopMostNodes(C.eles.nodes());if(A=t.connectComponents(G,C.eles,I),A.forEach(function(vt){var it=vt.boundingBox();_.push({x:it.x1+it.w/2,y:it.y1+it.h/2})}),C.randomize&&A.forEach(function(vt){C.eles=vt,Y.push(o(C))}),C.quality=="default"||C.quality=="proof"){var D=G.collection();if(C.tile){var S=new Map,W=[],x=[],Q=0,$={nodeIndexes:S,xCoords:W,yCoords:x},X=[];if(A.forEach(function(vt,it){vt.edges().length==0&&(vt.nodes().forEach(function(ut,Et){D.merge(vt.nodes()[Et]),ut.isParent()||($.nodeIndexes.set(vt.nodes()[Et].id(),Q++),$.xCoords.push(vt.nodes()[0].position().x),$.yCoords.push(vt.nodes()[0].position().y))}),X.push(it))}),D.length>1){var rt=D.boundingBox();_.push({x:rt.x1+rt.w/2,y:rt.y1+rt.h/2}),A.push(D),Y.push($);for(var B=X.length-1;B>=0;B--)A.splice(X[B],1),Y.splice(X[B],1),_.splice(X[B],1)}}A.forEach(function(vt,it){C.eles=vt,z.push(l(C,Y[it])),t.relocateComponent(_[it],z[it],C)})}else A.forEach(function(vt,it){t.relocateComponent(_[it],Y[it],C)});var O=new Set;if(A.length>1){var H=[],k=V.filter(function(vt){return vt.css("display")=="none"});A.forEach(function(vt,it){var ut=void 0;if(C.quality=="draft"&&(ut=Y[it].nodeIndexes),vt.nodes().not(k).length>0){var Et={};Et.edges=[],Et.nodes=[];var Ct=void 0;vt.nodes().not(k).forEach(function(Dt){if(C.quality=="draft")if(!Dt.isParent())Ct=ut.get(Dt.id()),Et.nodes.push({x:Y[it].xCoords[Ct]-Dt.boundingbox().w/2,y:Y[it].yCoords[Ct]-Dt.boundingbox().h/2,width:Dt.boundingbox().w,height:Dt.boundingbox().h});else{var mt=t.calcBoundingBox(Dt,Y[it].xCoords,Y[it].yCoords,ut);Et.nodes.push({x:mt.topLeftX,y:mt.topLeftY,width:mt.width,height:mt.height})}else z[it][Dt.id()]&&Et.nodes.push({x:z[it][Dt.id()].getLeft(),y:z[it][Dt.id()].getTop(),width:z[it][Dt.id()].getWidth(),height:z[it][Dt.id()].getHeight()})}),vt.edges().forEach(function(Dt){var mt=Dt.source(),Ot=Dt.target();if(mt.css("display")!="none"&&Ot.css("display")!="none")if(C.quality=="draft"){var Rt=ut.get(mt.id()),Ht=ut.get(Ot.id()),Ut=[],Gt=[];if(mt.isParent()){var Ft=t.calcBoundingBox(mt,Y[it].xCoords,Y[it].yCoords,ut);Ut.push(Ft.topLeftX+Ft.width/2),Ut.push(Ft.topLeftY+Ft.height/2)}else Ut.push(Y[it].xCoords[Rt]),Ut.push(Y[it].yCoords[Rt]);if(Ot.isParent()){var Yt=t.calcBoundingBox(Ot,Y[it].xCoords,Y[it].yCoords,ut);Gt.push(Yt.topLeftX+Yt.width/2),Gt.push(Yt.topLeftY+Yt.height/2)}else Gt.push(Y[it].xCoords[Ht]),Gt.push(Y[it].yCoords[Ht]);Et.edges.push({startX:Ut[0],startY:Ut[1],endX:Gt[0],endY:Gt[1]})}else z[it][mt.id()]&&z[it][Ot.id()]&&Et.edges.push({startX:z[it][mt.id()].getCenterX(),startY:z[it][mt.id()].getCenterY(),endX:z[it][Ot.id()].getCenterX(),endY:z[it][Ot.id()].getCenterY()})}),Et.nodes.length>0&&(H.push(Et),O.add(it))}});var tt=E.packComponents(H,C.randomize).shifts;if(C.quality=="draft")Y.forEach(function(vt,it){var ut=vt.xCoords.map(function(Ct){return Ct+tt[it].dx}),Et=vt.yCoords.map(function(Ct){return Ct+tt[it].dy});vt.xCoords=ut,vt.yCoords=Et});else{var ht=0;O.forEach(function(vt){Object.keys(z[vt]).forEach(function(it){var ut=z[vt][it];ut.setCenter(ut.getCenterX()+tt[ht].dx,ut.getCenterY()+tt[ht].dy)}),ht++})}}}else{var m=C.eles.boundingBox();if(_.push({x:m.x1+m.w/2,y:m.y1+m.h/2}),C.randomize){var y=o(C);Y.push(y)}C.quality=="default"||C.quality=="proof"?(z.push(l(C,Y[0])),t.relocateComponent(_[0],z[0],C)):t.relocateComponent(_[0],Y[0],C)}var J=function(it,ut){if(C.quality=="default"||C.quality=="proof"){typeof it=="number"&&(it=ut);var Et=void 0,Ct=void 0,Dt=it.data("id");return z.forEach(function(Ot){Dt in Ot&&(Et={x:Ot[Dt].getRect().getCenterX(),y:Ot[Dt].getRect().getCenterY()},Ct=Ot[Dt])}),C.nodeDimensionsIncludeLabels&&(Ct.labelWidth&&(Ct.labelPosHorizontal=="left"?Et.x+=Ct.labelWidth/2:Ct.labelPosHorizontal=="right"&&(Et.x-=Ct.labelWidth/2)),Ct.labelHeight&&(Ct.labelPosVertical=="top"?Et.y+=Ct.labelHeight/2:Ct.labelPosVertical=="bottom"&&(Et.y-=Ct.labelHeight/2))),Et==null&&(Et={x:it.position("x"),y:it.position("y")}),{x:Et.x,y:Et.y}}else{var mt=void 0;return Y.forEach(function(Ot){var Rt=Ot.nodeIndexes.get(it.id());Rt!=null&&(mt={x:Ot.xCoords[Rt],y:Ot.yCoords[Rt]})}),mt==null&&(mt={x:it.position("x"),y:it.position("y")}),{x:mt.x,y:mt.y}}};if(C.quality=="default"||C.quality=="proof"||C.randomize){var It=t.calcParentsWithoutChildren(G,V),Nt=V.filter(function(vt){return vt.css("display")=="none"});C.eles=V.not(Nt),V.nodes().not(":parent").not(Nt).layoutPositions(R,C,J),It.length>0&&It.forEach(function(vt){vt.position(J(vt))})}else console.log("If randomize option is set to false, then quality option must be 'default' or 'proof'.")}}]),d})();a.exports=g}),657:((a,e,i)=>{var f=i(548),r=i(140).layoutBase.Matrix,u=i(140).layoutBase.SVD,t=function(o){var c=o.cy,l=o.eles,T=l.nodes(),g=l.nodes(":parent"),d=new Map,L=new Map,R=new Map,C=[],G=[],V=[],Y=[],z=[],A=[],_=[],n=[],E=void 0,p=1e8,m=1e-9,y=o.piTol,I=o.samplingType,D=o.nodeSeparation,S=void 0,W=function(){for(var U=0,Z=0,K=!1;Z=at;){nt=q[at++];for(var xt=C[nt],lt=0;ltdt&&(dt=z[Lt],Mt=Lt)}return Mt},Q=function(U){var Z=void 0;if(U){Z=Math.floor(Math.random()*E);for(var q=0;q=1)break;j=et}for(var pt=0;pt=1)break;j=et}for(var lt=0;lt0&&(Z.isParent()?C[U].push(R.get(Z.id())):C[U].push(Z.id()))})});var Nt=function(U){var Z=L.get(U),K=void 0;d.get(U).forEach(function(q){c.getElementById(q).isParent()?K=R.get(q):K=q,C[Z].push(K),C[L.get(K)].push(U)})},vt=!0,it=!1,ut=void 0;try{for(var Et=d.keys()[Symbol.iterator](),Ct;!(vt=(Ct=Et.next()).done);vt=!0){var Dt=Ct.value;Nt(Dt)}}catch(b){it=!0,ut=b}finally{try{!vt&&Et.return&&Et.return()}finally{if(it)throw ut}}E=L.size;var mt=void 0;if(E>2){S=E{var f=i(212),r=function(t){t&&t("layout","fcose",f)};typeof cytoscape<"u"&&r(cytoscape),a.exports=r}),140:(a=>{a.exports=M})},N={};function v(a){var e=N[a];if(e!==void 0)return e.exports;var i=N[a]={exports:{}};return P[a](i,i.exports,v),i.exports}var h=v(579);return h})()})})(Fe);var vr=Fe.exports;const pr=qe(vr);var Oe={L:"left",R:"right",T:"top",B:"bottom"},xe={L:ct(w=>`${w},${w/2} 0,${w} 0,0`,"L"),R:ct(w=>`0,${w/2} ${w},0 ${w},${w}`,"R"),T:ct(w=>`0,0 ${w},0 ${w/2},${w}`,"T"),B:ct(w=>`${w/2},0 ${w},${w} 0,${w}`,"B")},oe={L:ct((w,F)=>w-F+2,"L"),R:ct((w,F)=>w-2,"R"),T:ct((w,F)=>w-F+2,"T"),B:ct((w,F)=>w-2,"B")},yr=ct(function(w){return Wt(w)?w==="L"?"R":"L":w==="T"?"B":"T"},"getOppositeArchitectureDirection"),Ie=ct(function(w){const F=w;return F==="L"||F==="R"||F==="T"||F==="B"},"isArchitectureDirection"),Wt=ct(function(w){const F=w;return F==="L"||F==="R"},"isArchitectureDirectionX"),qt=ct(function(w){const F=w;return F==="T"||F==="B"},"isArchitectureDirectionY"),Te=ct(function(w,F){const M=Wt(w)&&qt(F),P=qt(w)&&Wt(F);return M||P},"isArchitectureDirectionXY"),mr=ct(function(w){const F=w[0],M=w[1],P=Wt(F)&&qt(M),N=qt(F)&&Wt(M);return P||N},"isArchitecturePairXY"),Er=ct(function(w){return w!=="LL"&&w!=="RR"&&w!=="TT"&&w!=="BB"},"isValidArchitectureDirectionPair"),ve=ct(function(w,F){const M=`${w}${F}`;return Er(M)?M:void 0},"getArchitectureDirectionPair"),Tr=ct(function([w,F],M){const P=M[0],N=M[1];return Wt(P)?qt(N)?[w+(P==="L"?-1:1),F+(N==="T"?1:-1)]:[w+(P==="L"?-1:1),F]:Wt(N)?[w+(N==="L"?1:-1),F+(P==="T"?1:-1)]:[w,F+(P==="T"?1:-1)]},"shiftPositionByArchitectureDirectionPair"),Nr=ct(function(w){return w==="LT"||w==="TL"?[1,1]:w==="BL"||w==="LB"?[1,-1]:w==="BR"||w==="RB"?[-1,-1]:[-1,1]},"getArchitectureDirectionXYFactors"),Lr=ct(function(w,F){return Te(w,F)?"bend":Wt(w)?"horizontal":"vertical"},"getArchitectureDirectionAlignment"),wr=ct(function(w){return w.type==="service"},"isArchitectureService"),Cr=ct(function(w){return w.type==="junction"},"isArchitectureJunction"),be=ct((w,F)=>{const[M,P]=[w,F].sort();return`${JSON.stringify(M)}-${JSON.stringify(P)}`},"architectureGroupAlignmentKey"),Ge=ct(w=>w.data(),"edgeData"),ie=ct(w=>w.data(),"nodeData"),Mr=or.architecture,Pe=class{constructor(){this.nodes=new Map,this.groups=new Map,this.edges=[],this.layoutHints=[],this.registeredIds=new Map,this.elements=new Map,this.diagramId="",this.setAccTitle=Ke,this.getAccTitle=je,this.setDiagramTitle=_e,this.getDiagramTitle=tr,this.getAccDescription=er,this.setAccDescription=rr,this.clear()}static{ct(this,"ArchitectureDB")}setDiagramId(w){this.diagramId=w}getDiagramId(){return this.diagramId}clear(){this.nodes=new Map,this.groups=new Map,this.edges=[],this.layoutHints=[],this.registeredIds=new Map,this.dataStructures=void 0,this.elements=new Map,this.diagramId="",ir()}addService({id:w,icon:F,in:M,title:P,iconText:N}){if(this.registeredIds.has(w))throw new Error(`The service id [${w}] is already in use by another ${this.registeredIds.get(w)}`);if(M!==void 0){if(w===M)throw new Error(`The service [${w}] cannot be placed within itself`);if(!this.registeredIds.has(M))throw new Error(`The service [${w}]'s parent does not exist. Please make sure the parent is created before this service`);if(this.registeredIds.get(M)==="node")throw new Error(`The service [${w}]'s parent is not a group`)}this.registeredIds.set(w,"node"),this.nodes.set(w,{id:w,type:"service",icon:F,iconText:N,title:P,edges:[],in:M})}getServices(){return[...this.nodes.values()].filter(wr)}addJunction({id:w,in:F}){if(this.registeredIds.has(w))throw new Error(`The junction id [${w}] is already in use by another ${this.registeredIds.get(w)}`);if(F!==void 0){if(w===F)throw new Error(`The junction [${w}] cannot be placed within itself`);if(!this.registeredIds.has(F))throw new Error(`The junction [${w}]'s parent does not exist. Please make sure the parent is created before this junction`);if(this.registeredIds.get(F)==="node")throw new Error(`The junction [${w}]'s parent is not a group`)}this.registeredIds.set(w,"node"),this.nodes.set(w,{id:w,type:"junction",edges:[],in:F})}getJunctions(){return[...this.nodes.values()].filter(Cr)}getNodes(){return[...this.nodes.values()]}getNode(w){return this.nodes.get(w)??null}addGroup({id:w,icon:F,in:M,title:P}){if(this.registeredIds.has(w))throw new Error(`The group id [${w}] is already in use by another ${this.registeredIds.get(w)}`);if(M!==void 0){if(w===M)throw new Error(`The group [${w}] cannot be placed within itself`);if(!this.registeredIds.has(M))throw new Error(`The group [${w}]'s parent does not exist. Please make sure the parent is created before this group`);if(this.registeredIds.get(M)==="node")throw new Error(`The group [${w}]'s parent is not a group`)}this.registeredIds.set(w,"group"),this.groups.set(w,{id:w,icon:F,title:P,in:M})}getGroups(){return[...this.groups.values()]}addEdge({lhsId:w,rhsId:F,lhsDir:M,rhsDir:P,lhsInto:N,rhsInto:v,lhsGroup:h,rhsGroup:a,title:e}){if(!Ie(M))throw new Error(`Invalid direction given for left hand side of edge ${w}--${F}. Expected (L,R,T,B) got ${String(M)}`);if(!Ie(P))throw new Error(`Invalid direction given for right hand side of edge ${w}--${F}. Expected (L,R,T,B) got ${String(P)}`);if(!this.nodes.has(w)&&!this.groups.has(w))throw new Error(`The left-hand id [${w}] does not yet exist. Please create the service/group before declaring an edge to it.`);if(!this.nodes.has(F)&&!this.groups.has(F))throw new Error(`The right-hand id [${F}] does not yet exist. Please create the service/group before declaring an edge to it.`);const i=this.nodes.get(w).in,f=this.nodes.get(F).in;if(h&&i&&f&&i==f)throw new Error(`The left-hand id [${w}] is modified to traverse the group boundary, but the edge does not pass through two groups.`);if(a&&i&&f&&i==f)throw new Error(`The right-hand id [${F}] is modified to traverse the group boundary, but the edge does not pass through two groups.`);const r={lhsId:w,lhsDir:M,lhsInto:N,lhsGroup:h,rhsId:F,rhsDir:P,rhsInto:v,rhsGroup:a,title:e};this.edges.push(r);const u=this.nodes.get(w),t=this.nodes.get(F);u&&t&&(u.edges.push(this.edges[this.edges.length-1]),t.edges.push(this.edges[this.edges.length-1]))}getEdges(){return this.edges}addLayoutHint(w){if(w.members.length<2)throw new Error(`An align directive requires at least two members; got ${w.members.length}`);const F=new Set;w.members.forEach(M=>{if(this.registeredIds.get(M)!=="node")throw new Error(`align ${w.direction} references [${M}], which is not a service or junction`);if(F.has(M))throw new Error(`align ${w.direction} lists [${M}] more than once`);F.add(M)}),this.layoutHints.push(w)}getLayoutHints(){return this.layoutHints}getDataStructures(){if(this.dataStructures===void 0){const w=new Map,F=new Map;for(const[h,a]of this.nodes.entries()){const e=new Map;for(const i of a.edges){const f=this.getNode(i.lhsId)?.in,r=this.getNode(i.rhsId)?.in;if(f&&r&&f!==r){const u=Lr(i.lhsDir,i.rhsDir);u!=="bend"&&w.set(be(f,r),u)}if(i.lhsId===h){const u=ve(i.lhsDir,i.rhsDir);u&&e.set(u,i.rhsId)}else{const u=ve(i.rhsDir,i.lhsDir);u&&e.set(u,i.lhsId)}}F.set(h,e)}const M=new Set,P=new Set(F.keys()),N=ct(h=>{const a=new Map([[h,[0,0]]]),e=[h];for(;e.length>0;){const i=e.shift();if(i){M.add(i),P.delete(i);const f=F.get(i);if(!f)throw new Error(`BFS error: adjacency list for id ${i} not found. Please report this as a bug.`);const r=a.get(i);if(!r)throw new Error(`BFS error: position for id ${i} not found in spatial map. Please report this as a bug.`);const[u,t]=r;f.forEach((s,o)=>{M.has(s)||(a.set(s,Tr([u,t],o)),e.push(s))})}}return a},"BFS"),v=[];for(;P.size>0;){const h=P.values().next().value;v.push(N(h))}this.dataStructures={adjList:F,spatialMaps:v,groupAlignments:w}}return this.dataStructures}setElementForId(w,F){this.elements.set(w,F)}getElementById(w){return this.elements.get(w)}getConfig(){return ar({...Mr,...nr().architecture})}getConfigField(w){return this.getConfig()[w]}},Ar=ct((w,F)=>{Ze(w,F),w.groups.map(M=>F.addGroup(M)),w.services.map(M=>F.addService({...M,type:"service"})),w.junctions.map(M=>F.addJunction({...M,type:"junction"})),w.edges.map(M=>F.addEdge(M)),w.alignments?.map(M=>F.addLayoutHint({direction:M.direction,members:[...M.members]}))},"populateDb"),Ue={parser:{yy:void 0},parse:ct(async w=>{const F=await gr("architecture",w);Re.debug(F);const M=Ue.parser?.yy;if(!(M instanceof Pe))throw new Error("parser.parser?.yy was not a ArchitectureDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");Ar(F,M)},"parse")},Dr=ct(w=>` + .edge { + stroke-width: ${w.archEdgeWidth}; + stroke: ${w.archEdgeColor}; + fill: none; + } + + .arrow { + fill: ${w.archEdgeArrowColor}; + } + + .node-bkg { + fill: none; + stroke: ${w.archGroupBorderColor}; + stroke-width: ${w.archGroupBorderWidth}; + stroke-dasharray: 8; + } + .node-icon-text { + display: flex; + align-items: center; + } + + .node-icon-text > div { + color: #fff; + margin: 1px; + height: fit-content; + text-align: center; + overflow: hidden; + display: -webkit-box; + -webkit-box-orient: vertical; + } +`,"getStyles"),Or=Dr;function pe(w,F){if(w===0)return F();const M=Math.random;let P=w>>>0;Math.random=function(){P=P+1831565813>>>0;let N=P;return N=Math.imul(N^N>>>15,N|1),N^=N+Math.imul(N^N>>>7,N|61),((N^N>>>14)>>>0)/4294967296};try{return F()}finally{Math.random=M}}ct(pe,"withSeededRandom");var re=ct(w=>`${w}`,"wrapIcon"),ae={prefix:"mermaid-architecture",height:80,width:80,icons:{database:{body:re('')},server:{body:re('')},disk:{body:re('')},internet:{body:re('')},cloud:{body:re('')},unknown:cr,blank:{body:re("")}}},xr=ct(async function(w,F,M,P){const N=M.getConfigField("padding"),v=M.getConfigField("iconSize"),h=v/2,a=v/6,e=a/2;await Promise.all(F.edges().map(async i=>{const{source:f,sourceDir:r,sourceArrow:u,sourceGroup:t,target:s,targetDir:o,targetArrow:c,targetGroup:l,label:T}=Ge(i);let{x:g,y:d}=i[0].sourceEndpoint();const{x:L,y:R}=i[0].midpoint();let{x:C,y:G}=i[0].targetEndpoint();const V=N+4;if(t&&(Wt(r)?g+=r==="L"?-V:V:d+=r==="T"?-V:V+18),l&&(Wt(o)?C+=o==="L"?-V:V:G+=o==="T"?-V:V+18),!t&&M.getNode(f)?.type==="junction"&&(Wt(r)?g+=r==="L"?h:-h:d+=r==="T"?h:-h),!l&&M.getNode(s)?.type==="junction"&&(Wt(o)?C+=o==="L"?h:-h:G+=o==="T"?h:-h),i[0]._private.rscratch){const Y=w.insert("g");if(Y.insert("path").attr("d",`M ${g},${d} L ${L},${R} L${C},${G} `).attr("class","edge").attr("id",`${P}-${lr(f,s,{prefix:"L"})}`),u){const z=Wt(r)?oe[r](g,a):g-e,A=qt(r)?oe[r](d,a):d-e;Y.insert("polygon").attr("points",xe[r](a)).attr("transform",`translate(${z},${A})`).attr("class","arrow")}if(c){const z=Wt(o)?oe[o](C,a):C-e,A=qt(o)?oe[o](G,a):G-e;Y.insert("polygon").attr("points",xe[o](a)).attr("transform",`translate(${z},${A})`).attr("class","arrow")}if(T){const z=Te(r,o)?"XY":Wt(r)?"X":"Y";let A=0;z==="X"?A=Math.abs(g-C):z==="Y"?A=Math.abs(d-G)/1.5:A=Math.abs(g-C)/2;const _=Y.append("g");if(await Ee(_,T,{useHtmlLabels:!1,width:A,classes:"architecture-service-label"},me()),_.attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle"),z==="X")_.attr("transform","translate("+L+", "+R+")");else if(z==="Y")_.attr("transform","translate("+L+", "+R+") rotate(-90)");else if(z==="XY"){const n=ve(r,o);if(n&&mr(n)){const E=_.node().getBoundingClientRect(),[p,m]=Nr(n);_.attr("dominant-baseline","auto").attr("transform",`rotate(${-1*p*m*45})`);const y=_.node().getBoundingClientRect();_.attr("transform",` + translate(${L}, ${R-E.height/2}) + translate(${p*y.width/2}, ${m*y.height/2}) + rotate(${-1*p*m*45}, 0, ${E.height/2}) + `)}}}}}))},"drawEdges"),Ir=ct(async function(w,F,M,P){const v=M.getConfigField("padding")*.75,h=M.getConfigField("fontSize"),e=M.getConfigField("iconSize")/2;await Promise.all(F.nodes().map(async i=>{const f=ie(i);if(f.type==="group"){const{h:r,w:u,x1:t,y1:s}=i.boundingBox(),o=w.append("rect");o.attr("id",`${P}-group-${f.id}`).attr("x",t+e).attr("y",s+e).attr("width",u).attr("height",r).attr("class","node-bkg");const c=w.append("g");let l=t,T=s;if(f.icon){const g=c.append("g");g.html(`${await de(f.icon,{height:v,width:v,fallbackPrefix:ae.prefix})}`),g.attr("transform","translate("+(l+e+1)+", "+(T+e+1)+")"),l+=v,T+=h/2-1-2}if(f.label){const g=c.append("g");await Ee(g,f.label,{useHtmlLabels:!1,width:u,classes:"architecture-service-label"},me()),g.attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","start").attr("text-anchor","start"),g.attr("transform","translate("+(l+e+4)+", "+(T+e+2)+")")}M.setElementForId(f.id,o)}}))},"drawGroups"),Rr=ct(async function(w,F,M,P){const N=me();for(const v of M){const h=F.append("g"),a=w.getConfigField("iconSize");if(v.title){const r=h.append("g");await Ee(r,v.title,{useHtmlLabels:!1,width:a*1.5,classes:"architecture-service-label"},N),r.attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle"),r.attr("transform","translate("+a/2+", "+a+")")}const e=h.append("g");if(v.icon)e.html(`${await de(v.icon,{height:a,width:a,fallbackPrefix:ae.prefix})}`);else if(v.iconText){e.html(`${await de("blank",{height:a,width:a,fallbackPrefix:ae.prefix})}`);const t=e.append("g").append("foreignObject").attr("width",a).attr("height",a).append("div").attr("class","node-icon-text").attr("style",`height: ${a}px;`).append("div").html(sr(v.iconText,N)),s=parseInt(window.getComputedStyle(t.node(),null).getPropertyValue("font-size").replace(/\D/g,""))??16;t.attr("style",`-webkit-line-clamp: ${Math.floor((a-2)/s)};`)}else e.append("path").attr("class","node-bkg").attr("id",`${P}-node-${v.id}`).attr("d",`M0,${a} V5 Q0,0 5,0 H${a-5} Q${a},0 ${a},5 V${a} Z`);h.attr("id",`${P}-service-${v.id}`).attr("class","architecture-service");const{width:i,height:f}=h.node().getBBox();v.width=i,v.height=f,w.setElementForId(v.id,h)}return 0},"drawServices"),Sr=ct(function(w,F,M,P){M.forEach(N=>{const v=F.append("g"),h=w.getConfigField("iconSize");v.append("g").append("rect").attr("id",`${P}-node-${N.id}`).attr("fill-opacity","0").attr("width",h).attr("height",h),v.attr("class","architecture-junction");const{width:e,height:i}=v._groups[0][0].getBBox();v.width=e,v.height=i,w.setElementForId(N.id,v)})},"drawJunctions");fr([{name:ae.prefix,icons:ae}]);Se.use(pr);function Ye(w,F,M){w.forEach(P=>{F.add({group:"nodes",data:{type:"service",id:P.id,icon:P.icon,label:P.title,parent:P.in,width:M.getConfigField("iconSize"),height:M.getConfigField("iconSize")},classes:"node-service"})})}ct(Ye,"addServices");function Xe(w,F,M){w.forEach(P=>{F.add({group:"nodes",data:{type:"junction",id:P.id,parent:P.in,width:M.getConfigField("iconSize"),height:M.getConfigField("iconSize")},classes:"node-junction"})})}ct(Xe,"addJunctions");function He(w,F){F.nodes().map(M=>{const P=ie(M);if(P.type==="group")return;P.x=M.position().x,P.y=M.position().y,w.getElementById(P.id).attr("transform","translate("+(P.x||0)+","+(P.y||0)+")")})}ct(He,"positionNodes");function We(w,F){w.forEach(M=>{F.add({group:"nodes",data:{type:"group",id:M.id,icon:M.icon,label:M.title,parent:M.in},classes:"node-group"})})}ct(We,"addGroups");function Ve(w,F){w.forEach(M=>{const{lhsId:P,rhsId:N,lhsInto:v,lhsGroup:h,rhsInto:a,lhsDir:e,rhsDir:i,rhsGroup:f,title:r}=M,u=Te(M.lhsDir,M.rhsDir)?"segments":"straight",t={id:`${P}-${N}`,label:r,source:P,sourceDir:e,sourceArrow:v,sourceGroup:h,sourceEndpoint:e==="L"?"0 50%":e==="R"?"100% 50%":e==="T"?"50% 0":"50% 100%",target:N,targetDir:i,targetArrow:a,targetGroup:f,targetEndpoint:i==="L"?"0 50%":i==="R"?"100% 50%":i==="T"?"50% 0":"50% 100%"};F.add({group:"edges",data:t,classes:u})})}ct(Ve,"addEdges");function ze(w,F,M,P=[]){const N=ct((u,t)=>{const s=new Map;for(const[o,c]of u.entries()){const l=`${o}`;let T=0;const g=[...c.entries()];if(g.length===1){s.set(l,g[0][1]);continue}for(let d=0;d{const t=new Map,s=new Map;return u.forEach(([o,c],l)=>{const T=w.getNode(l)?.in??"default",g=t.get(c)??new Map;t.has(c)||t.set(c,g);const d=s.get(o)??new Map;s.has(o)||s.set(o,d);for(const L of[g,d]){const R=L.get(T)??[];L.has(T)||L.set(T,R),R.push(l)}}),{horiz:[...N(t,"horizontal").values()].filter(o=>o.length>1),vert:[...N(s,"vertical").values()].filter(o=>o.length>1)}}),[h,a]=v.reduce(([u,t],{horiz:s,vert:o})=>[[...u,...s],[...t,...o]],[[],[]]),e=new Set;P.forEach(u=>u.members.forEach(t=>e.add(t)));const i=ct(u=>u.filter(t=>!t.some(s=>e.has(s))),"dropOverlapping"),f=i(h),r=i(a);return P.forEach(u=>{u.members.length<2||(u.direction==="row"?f.push([...u.members]):r.push([...u.members]))}),{horizontal:f,vertical:r}}ct(ze,"getAlignments");function $e(w,F,M=[]){const P=[],N=F.getConfigField("iconSize"),v=F.getConfigField("idealEdgeLengthMultiplier"),h=v*N,a=new Set;M.forEach(f=>{for(let r=0;r`${f[0]},${f[1]}`,"posToStr"),i=ct(f=>f.split(",").map(r=>parseInt(r)),"strToPos");return w.forEach(f=>{const r=new Map([...f.entries()].map(([o,c])=>[e(c),o])),u=[e([0,0])],t={},s={L:[-1,0],R:[1,0],T:[0,1],B:[0,-1]};for(;u.length>0;){const o=u.shift();if(o){t[o]=1;const c=r.get(o);if(c){const l=i(o);Object.entries(s).forEach(([T,g])=>{const d=e([l[0]+g[0],l[1]+g[1]]),L=r.get(d);if(L&&!t[d]){if(u.push(d),a.has(`${c}|${L}`))return;P.push({[Oe[T]]:L,[Oe[yr(T)]]:c,gap:v*N})}})}}}}),P}ct($e,"getRelativeConstraints");function Be(w,F,M,P,N,{spatialMaps:v,groupAlignments:h}){return new Promise(a=>{const e=hr("body").append("div").attr("id","cy").attr("style","display:none"),i=Se({container:document.getElementById("cy"),style:[{selector:"edge",style:{"curve-style":"straight","source-endpoint":"data(sourceEndpoint)","target-endpoint":"data(targetEndpoint)"}},{selector:"edge[label]",style:{label:"data(label)"}},{selector:"edge.segments",style:{"curve-style":"segments","segment-weights":"0","segment-distances":[.5],"edge-distances":"endpoints","source-endpoint":"data(sourceEndpoint)","target-endpoint":"data(targetEndpoint)"}},{selector:"node",style:{"compound-sizing-wrt-labels":"include"}},{selector:"node[label]",style:{"text-valign":"bottom","text-halign":"center","font-size":`${N.getConfigField("fontSize")}px`}},{selector:".node-service",style:{label:"data(label)",width:"data(width)",height:"data(height)"}},{selector:".node-junction",style:{width:"data(width)",height:"data(height)"}},{selector:".node-group",style:{padding:`${N.getConfigField("padding")}px`}}],layout:{name:"grid",boundingBox:{x1:0,x2:100,y1:0,y2:100}}});e.remove(),We(M,i),Ye(w,i,N),Xe(F,i,N),Ve(P,i);const f=N.getLayoutHints(),r=ze(N,v,h,f),u=$e(v,N,f),t=N.getConfigField("iconSize"),s=N.getConfigField("idealEdgeLengthMultiplier")*t,o=.5*t,c=N.getConfigField("edgeElasticity"),l=N.getConfigField("seed"),T=i.layout({name:"fcose",quality:"proof",randomize:N.getConfigField("randomize"),nodeSeparation:N.getConfigField("nodeSeparation"),numIter:N.getConfigField("numIter"),styleEnabled:!1,animate:!1,nodeDimensionsIncludeLabels:!1,idealEdgeLength(g){const[d,L]=g.connectedNodes(),{parent:R}=ie(d),{parent:C}=ie(L);return R===C?s:o},edgeElasticity(g){const[d,L]=g.connectedNodes(),{parent:R}=ie(d),{parent:C}=ie(L);return R===C?c:.001},alignmentConstraint:r,relativePlacementConstraint:u});T.one("layoutstop",()=>{function g(d,L,R,C){let G,V;const{x:Y,y:z}=d,{x:A,y:_}=L;V=(C-z+(Y-R)*(z-_)/(Y-A))/Math.sqrt(1+Math.pow((z-_)/(Y-A),2)),G=Math.sqrt(Math.pow(C-z,2)+Math.pow(R-Y,2)-Math.pow(V,2));const n=Math.sqrt(Math.pow(A-Y,2)+Math.pow(_-z,2));G=G/n;let E=(A-Y)*(C-z)-(_-z)*(R-Y);switch(!0){case E>=0:E=1;break;case E<0:E=-1;break}let p=(A-Y)*(R-Y)+(_-z)*(C-z);switch(!0){case p>=0:p=1;break;case p<0:p=-1;break}return V=Math.abs(V)*E,G=G*p,{distances:V,weights:G}}ct(g,"getSegmentWeights"),i.startBatch();for(const d of Object.values(i.edges()))if(d.data?.()){const{x:L,y:R}=d.source().position(),{x:C,y:G}=d.target().position();if(L!==C&&R!==G){const V=d.sourceEndpoint(),Y=d.targetEndpoint(),{sourceDir:z}=Ge(d),[A,_]=qt(z)?[V.x,Y.y]:[Y.x,V.y],{weights:n,distances:E}=g(V,Y,A,_);d.style("segment-distances",E),d.style("segment-weights",n)}}i.endBatch(),pe(l,()=>T.run())});try{pe(l,()=>T.run())}catch(g){throw g instanceof RangeError&&g.message.includes("Invalid array length")?new Error("Architecture layout failed: a declared `align row|column` directive likely contradicts the edge directions, or two declared alignments overlap on a shared node. Check that the order of members in each `align` chain is consistent with the edges between them, and that no node appears in two `align` directives along the same axis."):g}i.ready(g=>{Re.info("Ready",g),a(i)})})}ct(Be,"layoutArchitecture");var Fr=ct(async(w,F,M,P)=>{const N=P.db;N.setDiagramId(F);const v=N.getServices(),h=N.getJunctions(),a=N.getGroups(),e=N.getEdges(),i=N.getDataStructures(),f=Qe(F),r=f.append("g");r.attr("class","architecture-edges");const u=f.append("g");u.attr("class","architecture-services");const t=f.append("g");t.attr("class","architecture-groups"),await Rr(N,u,v,F),Sr(N,u,h,F);const s=await Be(v,h,a,e,N,i);await xr(r,s,N,F),await Ir(t,s,N,F),He(N,s),Je(void 0,f,N.getConfigField("padding"),N.getConfigField("useMaxWidth"))},"draw"),br={draw:Fr},Wr={parser:Ue,get db(){return new Pe},renderer:br,styles:Or};export{Wr as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/blockDiagram-I7D4REHJ.BO9kROxn.js b/packages/tempo/public/v4/assets/chunks/blockDiagram-I7D4REHJ.BO9kROxn.js new file mode 100644 index 00000000..179825e2 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/blockDiagram-I7D4REHJ.BO9kROxn.js @@ -0,0 +1,129 @@ +import{g as Pe}from"./chunk-5VM5RSS4.-zPOtr2J.js";import{aD as Fe,aE as xe,aF as Me,aG as Ke,aH as Ye,aI as We,aJ as Ve,aK as Ue,aL as He,aM as Xe,aN as je,aO as Ge,aP as qe,aQ as Je,aR as Ze,aS as Qe,aT as $e,aU as et,aV as tt,aW as st,aX as rt,aY as it,aZ as at,a_ as nt,a$ as ot,_ as u,A as Y,j as X,b0 as ct,d as lt,l as y,r as ut,u as gt,c as Le,a8 as ht,az as dt,ay as pt,aA as ft,k as bt,b1 as St,ai as me,aj as xt}from"../app.CbekdYod.js";import{c as Lt}from"./channel.DScgq80D.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";function mt(e){return Array.isArray(e)}function yt(e){if(Fe(e))return e;const a=xe(e);if(!wt(e))return{};if(mt(e)){const r=Array.from(e);return e.length>0&&typeof e[0]=="string"&&Object.hasOwn(e,"index")&&(r.index=e.index,r.input=e.input),r}if(Me(e)){const r=e,l=r.constructor;return new l(r.buffer,r.byteOffset,r.length)}if(a==="[object ArrayBuffer]")return new ArrayBuffer(e.byteLength);if(a==="[object DataView]"){const r=e,l=r.buffer,d=r.byteOffset,s=r.byteLength,h=new ArrayBuffer(s),x=new Uint8Array(l,d,s);return new Uint8Array(h).set(x),new DataView(h)}if(a==="[object Boolean]"||a==="[object Number]"||a==="[object String]"){const r=e.constructor,l=new r(e.valueOf());return a==="[object String]"?_t(l,e):se(l,e),l}if(a==="[object Date]")return new Date(Number(e));if(a==="[object RegExp]"){const r=e,l=new RegExp(r.source,r.flags);return l.lastIndex=r.lastIndex,l}if(a==="[object Symbol]")return Object(Symbol.prototype.valueOf.call(e));if(a==="[object Map]"){const r=e,l=new Map;return r.forEach((d,s)=>{l.set(s,d)}),l}if(a==="[object Set]"){const r=e,l=new Set;return r.forEach(d=>{l.add(d)}),l}if(a==="[object Arguments]"){const r=e,l={};return se(l,r),l.length=r.length,l[Symbol.iterator]=r[Symbol.iterator],l}const o={};return kt(o,e),se(o,e),Et(o,e),o}function wt(e){switch(xe(e)){case ot:case nt:case at:case it:case rt:case st:case tt:case et:case $e:case Qe:case Ze:case Je:case qe:case Ge:case je:case Xe:case He:case Ue:case Ve:case We:case Ye:case Ke:return!0;default:return!1}}function se(e,a){for(const o in a)Object.hasOwn(a,o)&&(e[o]=a[o])}function Et(e,a){const o=Object.getOwnPropertySymbols(a);for(let r=0;r=o)&&(e[r]=a[r])}function kt(e,a){const o=Object.getPrototypeOf(a);o!==null&&typeof a.constructor=="function"&&Object.setPrototypeOf(e,o)}var ie=(function(){var e=u(function(v,g,i,c){for(i=i||{},c=v.length;c--;i[v[c]]=g);return i},"o"),a=[1,15],o=[1,7],r=[1,13],l=[1,14],d=[1,19],s=[1,16],h=[1,17],x=[1,18],m=[8,30],S=[8,10,21,28,29,30,31,39,43,46],f=[1,23],L=[1,24],w=[8,10,15,16,21,28,29,30,31,39,43,46],b=[8,10,15,16,21,27,28,29,30,31,39,43,46],k=[1,49],_={trace:u(function(){},"trace"),yy:{},symbols_:{error:2,spaceLines:3,SPACELINE:4,NL:5,separator:6,SPACE:7,EOF:8,start:9,BLOCK_DIAGRAM_KEY:10,document:11,stop:12,statement:13,link:14,LINK:15,START_LINK:16,LINK_LABEL:17,STR:18,nodeStatement:19,columnsStatement:20,SPACE_BLOCK:21,blockStatement:22,classDefStatement:23,cssClassStatement:24,styleStatement:25,node:26,SIZE:27,COLUMNS:28,"id-block":29,end:30,NODE_ID:31,nodeShapeNLabel:32,dirList:33,DIR:34,NODE_DSTART:35,NODE_DEND:36,BLOCK_ARROW_START:37,BLOCK_ARROW_END:38,classDef:39,CLASSDEF_ID:40,CLASSDEF_STYLEOPTS:41,DEFAULT:42,class:43,CLASSENTITY_IDS:44,STYLECLASS:45,style:46,STYLE_ENTITY_IDS:47,STYLE_DEFINITION_DATA:48,$accept:0,$end:1},terminals_:{2:"error",4:"SPACELINE",5:"NL",7:"SPACE",8:"EOF",10:"BLOCK_DIAGRAM_KEY",15:"LINK",16:"START_LINK",17:"LINK_LABEL",18:"STR",21:"SPACE_BLOCK",27:"SIZE",28:"COLUMNS",29:"id-block",30:"end",31:"NODE_ID",34:"DIR",35:"NODE_DSTART",36:"NODE_DEND",37:"BLOCK_ARROW_START",38:"BLOCK_ARROW_END",39:"classDef",40:"CLASSDEF_ID",41:"CLASSDEF_STYLEOPTS",42:"DEFAULT",43:"class",44:"CLASSENTITY_IDS",45:"STYLECLASS",46:"style",47:"STYLE_ENTITY_IDS",48:"STYLE_DEFINITION_DATA"},productions_:[0,[3,1],[3,2],[3,2],[6,1],[6,1],[6,1],[9,3],[12,1],[12,1],[12,2],[12,2],[11,1],[11,2],[14,1],[14,4],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[19,3],[19,2],[19,1],[20,1],[22,4],[22,3],[26,1],[26,2],[33,1],[33,2],[32,3],[32,4],[23,3],[23,3],[24,3],[25,3]],performAction:u(function(g,i,c,p,E,t,M){var n=t.length-1;switch(E){case 4:p.getLogger().debug("Rule: separator (NL) ");break;case 5:p.getLogger().debug("Rule: separator (Space) ");break;case 6:p.getLogger().debug("Rule: separator (EOF) ");break;case 7:p.getLogger().debug("Rule: hierarchy: ",t[n-1]),p.setHierarchy(t[n-1]);break;case 8:p.getLogger().debug("Stop NL ");break;case 9:p.getLogger().debug("Stop EOF ");break;case 10:p.getLogger().debug("Stop NL2 ");break;case 11:p.getLogger().debug("Stop EOF2 ");break;case 12:p.getLogger().debug("Rule: statement: ",t[n]),typeof t[n].length=="number"?this.$=t[n]:this.$=[t[n]];break;case 13:p.getLogger().debug("Rule: statement #2: ",t[n-1]),this.$=[t[n-1]].concat(t[n]);break;case 14:p.getLogger().debug("Rule: link: ",t[n],g),this.$={edgeTypeStr:t[n],label:""};break;case 15:p.getLogger().debug("Rule: LABEL link: ",t[n-3],t[n-1],t[n]),this.$={edgeTypeStr:t[n],label:t[n-1]};break;case 18:const P=parseInt(t[n]),W=p.generateId();this.$={id:W,type:"space",label:"",width:P,children:[]};break;case 23:p.getLogger().debug("Rule: (nodeStatement link node) ",t[n-2],t[n-1],t[n]," typestr: ",t[n-1].edgeTypeStr);const J=p.edgeStrToEdgeData(t[n-1].edgeTypeStr),V=p.edgeStrToEdgeStartData(t[n-1].edgeTypeStr),Z=p.edgeStrToThickness(t[n-1].edgeTypeStr),D=p.edgeStrToPattern(t[n-1].edgeTypeStr);this.$=[{id:t[n-2].id,label:t[n-2].label,type:t[n-2].type,directions:t[n-2].directions},{id:t[n-2].id+"-"+t[n].id,start:t[n-2].id,end:t[n].id,label:t[n-1].label,type:"edge",thickness:Z,pattern:D,directions:t[n].directions,arrowTypeEnd:J,arrowTypeStart:V},{id:t[n].id,label:t[n].label,type:p.typeStr2Type(t[n].typeStr),directions:t[n].directions}];break;case 24:p.getLogger().debug("Rule: nodeStatement (abc88 node size) ",t[n-1],t[n]),this.$={id:t[n-1].id,label:t[n-1].label,type:p.typeStr2Type(t[n-1].typeStr),directions:t[n-1].directions,widthInColumns:parseInt(t[n],10)};break;case 25:p.getLogger().debug("Rule: nodeStatement (node) ",t[n]),this.$={id:t[n].id,label:t[n].label,type:p.typeStr2Type(t[n].typeStr),directions:t[n].directions,widthInColumns:1};break;case 26:p.getLogger().debug("APA123",this?this:"na"),p.getLogger().debug("COLUMNS: ",t[n]),this.$={type:"column-setting",columns:t[n]==="auto"?-1:parseInt(t[n])};break;case 27:p.getLogger().debug("Rule: id-block statement : ",t[n-2],t[n-1]),p.generateId(),this.$={...t[n-2],type:"composite",children:t[n-1]};break;case 28:p.getLogger().debug("Rule: blockStatement : ",t[n-2],t[n-1],t[n]);const z=p.generateId();this.$={id:z,type:"composite",label:"",children:t[n-1]};break;case 29:p.getLogger().debug("Rule: node (NODE_ID separator): ",t[n]),this.$={id:t[n]};break;case 30:p.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ",t[n-1],t[n]),this.$={id:t[n-1],label:t[n].label,typeStr:t[n].typeStr,directions:t[n].directions};break;case 31:p.getLogger().debug("Rule: dirList: ",t[n]),this.$=[t[n]];break;case 32:p.getLogger().debug("Rule: dirList: ",t[n-1],t[n]),this.$=[t[n-1]].concat(t[n]);break;case 33:p.getLogger().debug("Rule: nodeShapeNLabel: ",t[n-2],t[n-1],t[n]),this.$={typeStr:t[n-2]+t[n],label:t[n-1]};break;case 34:p.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ",t[n-3],t[n-2]," #3:",t[n-1],t[n]),this.$={typeStr:t[n-3]+t[n],label:t[n-2],directions:t[n-1]};break;case 35:case 36:this.$={type:"classDef",id:t[n-1].trim(),css:t[n].trim()};break;case 37:this.$={type:"applyClass",id:t[n-1].trim(),styleClass:t[n].trim()};break;case 38:this.$={type:"applyStyles",id:t[n-1].trim(),stylesStr:t[n].trim()};break}},"anonymous"),table:[{9:1,10:[1,2]},{1:[3]},{10:a,11:3,13:4,19:5,20:6,21:o,22:8,23:9,24:10,25:11,26:12,28:r,29:l,31:d,39:s,43:h,46:x},{8:[1,20]},e(m,[2,12],{13:4,19:5,20:6,22:8,23:9,24:10,25:11,26:12,11:21,10:a,21:o,28:r,29:l,31:d,39:s,43:h,46:x}),e(S,[2,16],{14:22,15:f,16:L}),e(S,[2,17]),e(S,[2,18]),e(S,[2,19]),e(S,[2,20]),e(S,[2,21]),e(S,[2,22]),e(w,[2,25],{27:[1,25]}),e(S,[2,26]),{19:26,26:12,31:d},{10:a,11:27,13:4,19:5,20:6,21:o,22:8,23:9,24:10,25:11,26:12,28:r,29:l,31:d,39:s,43:h,46:x},{40:[1,28],42:[1,29]},{44:[1,30]},{47:[1,31]},e(b,[2,29],{32:32,35:[1,33],37:[1,34]}),{1:[2,7]},e(m,[2,13]),{26:35,31:d},{31:[2,14]},{17:[1,36]},e(w,[2,24]),{10:a,11:37,13:4,14:22,15:f,16:L,19:5,20:6,21:o,22:8,23:9,24:10,25:11,26:12,28:r,29:l,31:d,39:s,43:h,46:x},{30:[1,38]},{41:[1,39]},{41:[1,40]},{45:[1,41]},{48:[1,42]},e(b,[2,30]),{18:[1,43]},{18:[1,44]},e(w,[2,23]),{18:[1,45]},{30:[1,46]},e(S,[2,28]),e(S,[2,35]),e(S,[2,36]),e(S,[2,37]),e(S,[2,38]),{36:[1,47]},{33:48,34:k},{15:[1,50]},e(S,[2,27]),e(b,[2,33]),{38:[1,51]},{33:52,34:k,38:[2,31]},{31:[2,15]},e(b,[2,34]),{38:[2,32]}],defaultActions:{20:[2,7],23:[2,14],50:[2,15],52:[2,32]},parseError:u(function(g,i){if(i.recoverable)this.trace(g);else{var c=new Error(g);throw c.hash=i,c}},"parseError"),parse:u(function(g){var i=this,c=[0],p=[],E=[null],t=[],M=this.table,n="",P=0,W=0,J=2,V=1,Z=t.slice.call(arguments,1),D=Object.create(this.lexer),z={yy:{}};for(var Q in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Q)&&(z.yy[Q]=this.yy[Q]);D.setInput(g,z.yy),z.yy.lexer=D,z.yy.parser=this,typeof D.yylloc>"u"&&(D.yylloc={});var $=D.yylloc;t.push($);var Be=D.options&&D.options.ranges;typeof z.yy.parseError=="function"?this.parseError=z.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function Re(I){c.length=c.length-2*I,E.length=E.length-I,t.length=t.length-I}u(Re,"popStack");function de(){var I;return I=p.pop()||D.lex()||V,typeof I!="number"&&(I instanceof Array&&(p=I,I=p.pop()),I=i.symbols_[I]||I),I}u(de,"lex");for(var N,R,C,ee,F={},U,B,pe,H;;){if(R=c[c.length-1],this.defaultActions[R]?C=this.defaultActions[R]:((N===null||typeof N>"u")&&(N=de()),C=M[R]&&M[R][N]),typeof C>"u"||!C.length||!C[0]){var te="";H=[];for(U in M[R])this.terminals_[U]&&U>J&&H.push("'"+this.terminals_[U]+"'");D.showPosition?te="Parse error on line "+(P+1)+`: +`+D.showPosition()+` +Expecting `+H.join(", ")+", got '"+(this.terminals_[N]||N)+"'":te="Parse error on line "+(P+1)+": Unexpected "+(N==V?"end of input":"'"+(this.terminals_[N]||N)+"'"),this.parseError(te,{text:D.match,token:this.terminals_[N]||N,line:D.yylineno,loc:$,expected:H})}if(C[0]instanceof Array&&C.length>1)throw new Error("Parse Error: multiple actions possible at state: "+R+", token: "+N);switch(C[0]){case 1:c.push(N),E.push(D.yytext),t.push(D.yylloc),c.push(C[1]),N=null,W=D.yyleng,n=D.yytext,P=D.yylineno,$=D.yylloc;break;case 2:if(B=this.productions_[C[1]][1],F.$=E[E.length-B],F._$={first_line:t[t.length-(B||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(B||1)].first_column,last_column:t[t.length-1].last_column},Be&&(F._$.range=[t[t.length-(B||1)].range[0],t[t.length-1].range[1]]),ee=this.performAction.apply(F,[n,W,P,z.yy,C[1],E,t].concat(Z)),typeof ee<"u")return ee;B&&(c=c.slice(0,-1*B*2),E=E.slice(0,-1*B),t=t.slice(0,-1*B)),c.push(this.productions_[C[1]][0]),E.push(F.$),t.push(F._$),pe=M[c[c.length-2]][c[c.length-1]],c.push(pe);break;case 3:return!0}}return!0},"parse")},T=(function(){var v={EOF:1,parseError:u(function(i,c){if(this.yy.parser)this.yy.parser.parseError(i,c);else throw new Error(i)},"parseError"),setInput:u(function(g,i){return this.yy=i||this.yy||{},this._input=g,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:u(function(){var g=this._input[0];this.yytext+=g,this.yyleng++,this.offset++,this.match+=g,this.matched+=g;var i=g.match(/(?:\r\n?|\n).*/g);return i?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),g},"input"),unput:u(function(g){var i=g.length,c=g.split(/(?:\r\n?|\n)/g);this._input=g+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-i),this.offset-=i;var p=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),c.length-1&&(this.yylineno-=c.length-1);var E=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:c?(c.length===p.length?this.yylloc.first_column:0)+p[p.length-c.length].length-c[0].length:this.yylloc.first_column-i},this.options.ranges&&(this.yylloc.range=[E[0],E[0]+this.yyleng-i]),this.yyleng=this.yytext.length,this},"unput"),more:u(function(){return this._more=!0,this},"more"),reject:u(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:u(function(g){this.unput(this.match.slice(g))},"less"),pastInput:u(function(){var g=this.matched.substr(0,this.matched.length-this.match.length);return(g.length>20?"...":"")+g.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:u(function(){var g=this.match;return g.length<20&&(g+=this._input.substr(0,20-g.length)),(g.substr(0,20)+(g.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:u(function(){var g=this.pastInput(),i=new Array(g.length+1).join("-");return g+this.upcomingInput()+` +`+i+"^"},"showPosition"),test_match:u(function(g,i){var c,p,E;if(this.options.backtrack_lexer&&(E={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(E.yylloc.range=this.yylloc.range.slice(0))),p=g[0].match(/(?:\r\n?|\n).*/g),p&&(this.yylineno+=p.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:p?p[p.length-1].length-p[p.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+g[0].length},this.yytext+=g[0],this.match+=g[0],this.matches=g,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(g[0].length),this.matched+=g[0],c=this.performAction.call(this,this.yy,this,i,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),c)return c;if(this._backtrack){for(var t in E)this[t]=E[t];return!1}return!1},"test_match"),next:u(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var g,i,c,p;this._more||(this.yytext="",this.match="");for(var E=this._currentRules(),t=0;ti[0].length)){if(i=c,p=t,this.options.backtrack_lexer){if(g=this.test_match(c,E[t]),g!==!1)return g;if(this._backtrack){i=!1;continue}else return!1}else if(!this.options.flex)break}return i?(g=this.test_match(i,E[p]),g!==!1?g:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:u(function(){var i=this.next();return i||this.lex()},"lex"),begin:u(function(i){this.conditionStack.push(i)},"begin"),popState:u(function(){var i=this.conditionStack.length-1;return i>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:u(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:u(function(i){return i=this.conditionStack.length-1-Math.abs(i||0),i>=0?this.conditionStack[i]:"INITIAL"},"topState"),pushState:u(function(i){this.begin(i)},"pushState"),stateStackSize:u(function(){return this.conditionStack.length},"stateStackSize"),options:{},performAction:u(function(i,c,p,E){switch(p){case 0:return i.getLogger().debug("Found block-beta"),10;case 1:return i.getLogger().debug("Found id-block"),29;case 2:return i.getLogger().debug("Found block"),10;case 3:i.getLogger().debug(".",c.yytext);break;case 4:i.getLogger().debug("_",c.yytext);break;case 5:return 5;case 6:return c.yytext=-1,28;case 7:return c.yytext=c.yytext.replace(/columns\s+/,""),i.getLogger().debug("COLUMNS (LEX)",c.yytext),28;case 8:this.pushState("md_string");break;case 9:return"MD_STR";case 10:this.popState();break;case 11:this.pushState("string");break;case 12:i.getLogger().debug("LEX: POPPING STR:",c.yytext),this.popState();break;case 13:return i.getLogger().debug("LEX: STR end:",c.yytext),"STR";case 14:return c.yytext=c.yytext.replace(/space\:/,""),i.getLogger().debug("SPACE NUM (LEX)",c.yytext),21;case 15:return c.yytext="1",i.getLogger().debug("COLUMNS (LEX)",c.yytext),21;case 16:return 42;case 17:return"LINKSTYLE";case 18:return"INTERPOLATE";case 19:return this.pushState("CLASSDEF"),39;case 20:return this.popState(),this.pushState("CLASSDEFID"),"DEFAULT_CLASSDEF_ID";case 21:return this.popState(),this.pushState("CLASSDEFID"),40;case 22:return this.popState(),41;case 23:return this.pushState("CLASS"),43;case 24:return this.popState(),this.pushState("CLASS_STYLE"),44;case 25:return this.popState(),45;case 26:return this.pushState("STYLE_STMNT"),46;case 27:return this.popState(),this.pushState("STYLE_DEFINITION"),47;case 28:return this.popState(),48;case 29:return this.pushState("acc_title"),"acc_title";case 30:return this.popState(),"acc_title_value";case 31:return this.pushState("acc_descr"),"acc_descr";case 32:return this.popState(),"acc_descr_value";case 33:this.pushState("acc_descr_multiline");break;case 34:this.popState();break;case 35:return"acc_descr_multiline_value";case 36:return 30;case 37:return this.popState(),i.getLogger().debug("Lex: (("),"NODE_DEND";case 38:return this.popState(),i.getLogger().debug("Lex: (("),"NODE_DEND";case 39:return this.popState(),i.getLogger().debug("Lex: ))"),"NODE_DEND";case 40:return this.popState(),i.getLogger().debug("Lex: (("),"NODE_DEND";case 41:return this.popState(),i.getLogger().debug("Lex: (("),"NODE_DEND";case 42:return this.popState(),i.getLogger().debug("Lex: (-"),"NODE_DEND";case 43:return this.popState(),i.getLogger().debug("Lex: -)"),"NODE_DEND";case 44:return this.popState(),i.getLogger().debug("Lex: (("),"NODE_DEND";case 45:return this.popState(),i.getLogger().debug("Lex: ]]"),"NODE_DEND";case 46:return this.popState(),i.getLogger().debug("Lex: ("),"NODE_DEND";case 47:return this.popState(),i.getLogger().debug("Lex: ])"),"NODE_DEND";case 48:return this.popState(),i.getLogger().debug("Lex: /]"),"NODE_DEND";case 49:return this.popState(),i.getLogger().debug("Lex: /]"),"NODE_DEND";case 50:return this.popState(),i.getLogger().debug("Lex: )]"),"NODE_DEND";case 51:return this.popState(),i.getLogger().debug("Lex: )"),"NODE_DEND";case 52:return this.popState(),i.getLogger().debug("Lex: ]>"),"NODE_DEND";case 53:return this.popState(),i.getLogger().debug("Lex: ]"),"NODE_DEND";case 54:return i.getLogger().debug("Lexa: -)"),this.pushState("NODE"),35;case 55:return i.getLogger().debug("Lexa: (-"),this.pushState("NODE"),35;case 56:return i.getLogger().debug("Lexa: ))"),this.pushState("NODE"),35;case 57:return i.getLogger().debug("Lexa: )"),this.pushState("NODE"),35;case 58:return i.getLogger().debug("Lex: ((("),this.pushState("NODE"),35;case 59:return i.getLogger().debug("Lexa: )"),this.pushState("NODE"),35;case 60:return i.getLogger().debug("Lexa: )"),this.pushState("NODE"),35;case 61:return i.getLogger().debug("Lexa: )"),this.pushState("NODE"),35;case 62:return i.getLogger().debug("Lexc: >"),this.pushState("NODE"),35;case 63:return i.getLogger().debug("Lexa: (["),this.pushState("NODE"),35;case 64:return i.getLogger().debug("Lexa: )"),this.pushState("NODE"),35;case 65:return this.pushState("NODE"),35;case 66:return this.pushState("NODE"),35;case 67:return this.pushState("NODE"),35;case 68:return this.pushState("NODE"),35;case 69:return this.pushState("NODE"),35;case 70:return this.pushState("NODE"),35;case 71:return this.pushState("NODE"),35;case 72:return i.getLogger().debug("Lexa: ["),this.pushState("NODE"),35;case 73:return this.pushState("BLOCK_ARROW"),i.getLogger().debug("LEX ARR START"),37;case 74:return i.getLogger().debug("Lex: NODE_ID",c.yytext),31;case 75:return i.getLogger().debug("Lex: EOF",c.yytext),8;case 76:this.pushState("md_string");break;case 77:this.pushState("md_string");break;case 78:return"NODE_DESCR";case 79:this.popState();break;case 80:i.getLogger().debug("Lex: Starting string"),this.pushState("string");break;case 81:i.getLogger().debug("LEX ARR: Starting string"),this.pushState("string");break;case 82:return i.getLogger().debug("LEX: NODE_DESCR:",c.yytext),"NODE_DESCR";case 83:i.getLogger().debug("LEX POPPING"),this.popState();break;case 84:i.getLogger().debug("Lex: =>BAE"),this.pushState("ARROW_DIR");break;case 85:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (right): dir:",c.yytext),"DIR";case 86:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (left):",c.yytext),"DIR";case 87:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (x):",c.yytext),"DIR";case 88:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (y):",c.yytext),"DIR";case 89:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (up):",c.yytext),"DIR";case 90:return c.yytext=c.yytext.replace(/^,\s*/,""),i.getLogger().debug("Lex (down):",c.yytext),"DIR";case 91:return c.yytext="]>",i.getLogger().debug("Lex (ARROW_DIR end):",c.yytext),this.popState(),this.popState(),"BLOCK_ARROW_END";case 92:return i.getLogger().debug("Lex: LINK","#"+c.yytext+"#"),15;case 93:return i.getLogger().debug("Lex: LINK",c.yytext),15;case 94:return i.getLogger().debug("Lex: LINK",c.yytext),15;case 95:return i.getLogger().debug("Lex: LINK",c.yytext),15;case 96:return i.getLogger().debug("Lex: START_LINK",c.yytext),this.pushState("LLABEL"),16;case 97:return i.getLogger().debug("Lex: START_LINK",c.yytext),this.pushState("LLABEL"),16;case 98:return i.getLogger().debug("Lex: START_LINK",c.yytext),this.pushState("LLABEL"),16;case 99:this.pushState("md_string");break;case 100:return i.getLogger().debug("Lex: Starting string"),this.pushState("string"),"LINK_LABEL";case 101:return this.popState(),i.getLogger().debug("Lex: LINK","#"+c.yytext+"#"),15;case 102:return this.popState(),i.getLogger().debug("Lex: LINK",c.yytext),15;case 103:return this.popState(),i.getLogger().debug("Lex: LINK",c.yytext),15;case 104:return i.getLogger().debug("Lex: COLON",c.yytext),c.yytext=c.yytext.slice(1),27}},"anonymous"),rules:[/^(?:block-beta\b)/,/^(?:block:)/,/^(?:block\b)/,/^(?:[\s]+)/,/^(?:[\n]+)/,/^(?:((\u000D\u000A)|(\u000A)))/,/^(?:columns\s+auto\b)/,/^(?:columns\s+[\d]+)/,/^(?:["][`])/,/^(?:[^`"]+)/,/^(?:[`]["])/,/^(?:["])/,/^(?:["])/,/^(?:[^"]*)/,/^(?:space[:]\d+)/,/^(?:space\b)/,/^(?:default\b)/,/^(?:linkStyle\b)/,/^(?:interpolate\b)/,/^(?:classDef\s+)/,/^(?:DEFAULT\s+)/,/^(?:\w+\s+)/,/^(?:[^\n]*)/,/^(?:class\s+)/,/^(?:(\w+)+((,\s*\w+)*))/,/^(?:[^\n]*)/,/^(?:style\s+)/,/^(?:(\w+)+((,\s*\w+)*))/,/^(?:[^\n]*)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:end\b\s*)/,/^(?:\(\(\()/,/^(?:\)\)\))/,/^(?:[\)]\))/,/^(?:\}\})/,/^(?:\})/,/^(?:\(-)/,/^(?:-\))/,/^(?:\(\()/,/^(?:\]\])/,/^(?:\()/,/^(?:\]\))/,/^(?:\\\])/,/^(?:\/\])/,/^(?:\)\])/,/^(?:[\)])/,/^(?:\]>)/,/^(?:[\]])/,/^(?:-\))/,/^(?:\(-)/,/^(?:\)\))/,/^(?:\))/,/^(?:\(\(\()/,/^(?:\(\()/,/^(?:\{\{)/,/^(?:\{)/,/^(?:>)/,/^(?:\(\[)/,/^(?:\()/,/^(?:\[\[)/,/^(?:\[\|)/,/^(?:\[\()/,/^(?:\)\)\))/,/^(?:\[\\)/,/^(?:\[\/)/,/^(?:\[\\)/,/^(?:\[)/,/^(?:<\[)/,/^(?:[^\(\[\n\-\)\{\}\s\<\>:=]+)/,/^(?:$)/,/^(?:["][`])/,/^(?:["][`])/,/^(?:[^`"]+)/,/^(?:[`]["])/,/^(?:["])/,/^(?:["])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:\]>\s*\()/,/^(?:,?\s*right\s*)/,/^(?:,?\s*left\s*)/,/^(?:,?\s*x\s*)/,/^(?:,?\s*y\s*)/,/^(?:,?\s*up\s*)/,/^(?:,?\s*down\s*)/,/^(?:\)\s*)/,/^(?:\s*[xo<]?--+[-xo>]\s*)/,/^(?:\s*[xo<]?==+[=xo>]\s*)/,/^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,/^(?:\s*~~[\~]+\s*)/,/^(?:\s*[xo<]?--\s*)/,/^(?:\s*[xo<]?==\s*)/,/^(?:\s*[xo<]?-\.\s*)/,/^(?:["][`])/,/^(?:["])/,/^(?:\s*[xo<]?--+[-xo>]\s*)/,/^(?:\s*[xo<]?==+[=xo>]\s*)/,/^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,/^(?::\d+)/],conditions:{STYLE_DEFINITION:{rules:[28],inclusive:!1},STYLE_STMNT:{rules:[27],inclusive:!1},CLASSDEFID:{rules:[22],inclusive:!1},CLASSDEF:{rules:[20,21],inclusive:!1},CLASS_STYLE:{rules:[25],inclusive:!1},CLASS:{rules:[24],inclusive:!1},LLABEL:{rules:[99,100,101,102,103],inclusive:!1},ARROW_DIR:{rules:[85,86,87,88,89,90,91],inclusive:!1},BLOCK_ARROW:{rules:[76,81,84],inclusive:!1},NODE:{rules:[37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,77,80],inclusive:!1},md_string:{rules:[9,10,78,79],inclusive:!1},space:{rules:[],inclusive:!1},string:{rules:[12,13,82,83],inclusive:!1},acc_descr_multiline:{rules:[34,35],inclusive:!1},acc_descr:{rules:[32],inclusive:!1},acc_title:{rules:[30],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8,11,14,15,16,17,18,19,23,26,29,31,33,36,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,92,93,94,95,96,97,98,104],inclusive:!0}}};return v})();_.lexer=T;function O(){this.yy={}}return u(O,"Parser"),O.prototype=_,_.Parser=O,new O})();ie.parser=ie;var Dt=ie,A=new Map,oe=[],ae=new Map,fe="color",be="fill",Tt="bgFill",ye=",",j=new Map,ce="",Nt=u(e=>bt.sanitizeText(e,Le()),"sanitizeText"),It=u(function(e,a=""){let o=j.get(e);o||(o={id:e,styles:[],textStyles:[]},j.set(e,o)),a?.split(ye).forEach(r=>{const l=r.replace(/([^;]*);/,"$1").trim();if(RegExp(fe).exec(r)){const s=l.replace(be,Tt).replace(fe,be);o.textStyles.push(s)}o.styles.push(l)})},"addStyleClass"),Ot=u(function(e,a=""){const o=A.get(e);a!=null&&(o.styles=a.split(ye))},"addStyle2Node"),vt=u(function(e,a){e.split(",").forEach(function(o){let r=A.get(o);if(r===void 0){const l=o.trim();r={id:l,type:"na",children:[]},A.set(l,r)}r.classes||(r.classes=[]),r.classes.push(a)})},"setCssClass"),we=u((e,a)=>{const o=e.flat(),r=[],d=o.find(s=>s?.type==="column-setting")?.columns??-1;for(const s of o){if(typeof d=="number"&&d>0&&s.type!=="column-setting"&&typeof s.widthInColumns=="number"&&s.widthInColumns>d&&y.warn(`Block ${s.id} width ${s.widthInColumns} exceeds configured column width ${d}`),s.label&&(s.label=Nt(s.label)),s.type==="classDef"){It(s.id,s.css);continue}if(s.type==="applyClass"){vt(s.id,s?.styleClass??"");continue}if(s.type==="applyStyles"){s?.stylesStr&&Ot(s.id,s?.stylesStr);continue}if(s.type==="column-setting")a.columns=s.columns??-1;else if(s.type==="edge"){const h=(ae.get(s.id)??0)+1;ae.set(s.id,h),s.id=h+"-"+s.id,oe.push(s)}else{s.label||(s.type==="composite"?s.label="":s.label=s.id);const h=A.get(s.id);if(h===void 0?A.set(s.id,s):(s.type!=="na"&&(h.type=s.type),s.label!==s.id&&(h.label=s.label)),s.children&&we(s.children,s),s.type==="space"){const x=s.width??1;for(let m=0;m{y.debug("Clear called"),ut(),K={id:"root",type:"composite",children:[],columns:-1},A=new Map([["root",K]]),le=[],j=new Map,oe=[],ae=new Map,ce=""},"clear");function Ee(e){switch(y.debug("typeStr2Type",e),e){case"[]":return"square";case"()":return y.debug("we have a round"),"round";case"(())":return"circle";case">]":return"rect_left_inv_arrow";case"{}":return"diamond";case"{{}}":return"hexagon";case"([])":return"stadium";case"[[]]":return"subroutine";case"[()]":return"cylinder";case"((()))":return"doublecircle";case"[//]":return"lean_right";case"[\\\\]":return"lean_left";case"[/\\]":return"trapezoid";case"[\\/]":return"inv_trapezoid";case"<[]>":return"block_arrow";default:return"na"}}u(Ee,"typeStr2Type");function _e(e){return y.debug("typeStr2Type",e),e==="=="?"thick":"normal"}u(_e,"edgeTypeStr2Type");function ke(e){switch(e.trim().slice(-1)){case"x":return"arrow_cross";case"o":return"arrow_circle";case">":return"arrow_point";default:return""}}u(ke,"edgeStrToEdgeData");function De(e){switch(e.trim().charAt(0)){case"x":return"arrow_cross";case"o":return"arrow_circle";case"<":return"arrow_point";default:return"arrow_open"}}u(De,"edgeStrToEdgeStartData");function Te(e){return e.includes("==")?"thick":"normal"}u(Te,"edgeStrToThickness");function Ne(e){return e.includes(".-")?"dotted":"solid"}u(Ne,"edgeStrToPattern");var Se=0,At=u(()=>(Se++,"id-"+Math.random().toString(36).substr(2,12)+"-"+Se),"generateId"),zt=u(e=>{K.children=e,we(e,K),le=K.children},"setHierarchy"),Bt=u(e=>{const a=A.get(e);return a?a.columns?a.columns:a.children?a.children.length:-1:-1},"getColumns"),Rt=u(()=>[...A.values()],"getBlocksFlat"),Pt=u(()=>le||[],"getBlocks"),Ft=u(()=>oe,"getEdges"),Mt=u(e=>A.get(e),"getBlock"),Kt=u(e=>{A.set(e.id,e)},"setBlock"),Yt=u(e=>{ce=e},"setDiagramId"),Wt=u(()=>ce,"getDiagramId"),Vt=u(()=>y,"getLogger"),Ut=u(function(){return j},"getClasses"),Ht={getConfig:u(()=>Y().block,"getConfig"),typeStr2Type:Ee,edgeTypeStr2Type:_e,edgeStrToEdgeData:ke,edgeStrToEdgeStartData:De,edgeStrToThickness:Te,edgeStrToPattern:Ne,getLogger:Vt,getBlocksFlat:Rt,getBlocks:Pt,getEdges:Ft,setHierarchy:zt,getBlock:Mt,setBlock:Kt,getColumns:Bt,getClasses:Ut,clear:Ct,generateId:At,setDiagramId:Yt,getDiagramId:Wt},Xt=Ht,re=u((e,a)=>{const o=Lt,r=o(e,"r"),l=o(e,"g"),d=o(e,"b");return gt(r,l,d,a)},"fade"),jt=u(e=>`.label { + font-family: ${e.fontFamily}; + color: ${e.nodeTextColor||e.textColor}; + } + .cluster-label text { + fill: ${e.titleColor}; + } + .cluster-label span { + color: ${e.titleColor}; + } + + + + .label text,span { + fill: ${e.nodeTextColor||e.textColor}; + color: ${e.nodeTextColor||e.textColor}; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${e.mainBkg}; + stroke: ${e.nodeBorder}; + stroke-width: 1px; + } + .flowchart-label text { + text-anchor: middle; + } + // .flowchart-label .text-outer-tspan { + // text-anchor: middle; + // } + // .flowchart-label .text-inner-tspan { + // text-anchor: start; + // } + + .node .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + .arrowheadPath { + fill: ${e.arrowheadColor}; + } + + .edgePaths .path { + stroke: ${e.lineColor}; + stroke-width: 2.0px; + } + + .flowchart-link { + stroke: ${e.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${e.edgeLabelBackground}; + /* + * This is for backward compatibility with existing code that didn't + * add a \`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \` around edge labels. + * + * TODO: We should probably remove this in a future release. + */ + p { + margin: 0; + padding: 0; + display: inline; + } + rect { + opacity: 0.5; + background-color: ${e.edgeLabelBackground}; + fill: ${e.edgeLabelBackground}; + } + text-align: center; + } + + /* For html labels only */ + .labelBkg { + background-color: ${e.edgeLabelBackground}; + } + + .node .cluster { + // fill: ${re(e.mainBkg,.5)}; + fill: ${re(e.clusterBkg,.5)}; + stroke: ${re(e.clusterBorder,.2)}; + box-shadow: rgba(50, 50, 93, 0.25) 0px 13px 27px -5px, rgba(0, 0, 0, 0.3) 0px 8px 16px -8px; + stroke-width: 1px; + } + + .cluster text { + fill: ${e.titleColor}; + } + + .cluster span { + color: ${e.titleColor}; + } + /* .cluster div { + color: ${e.titleColor}; + } */ + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${e.fontFamily}; + font-size: 12px; + background: ${e.tertiaryColor}; + border: 1px solid ${e.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .flowchartTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${e.textColor}; + } + ${Pe()} +`,"getStyles"),Gt=jt;function ne(e,a){if(e===0||!Number.isInteger(e))throw new Error("Columns must be an integer !== 0.");if(a<0||!Number.isInteger(a))throw new Error("Position must be a non-negative integer."+a);if(e<0)return{px:a,py:0};if(e===1)return{px:0,py:a};const o=a%e,r=Math.floor(a/e);return{px:o,py:r}}u(ne,"calculateBlockPosition");var qt=u(e=>{let a=0,o=0;for(const r of e.children){const{width:l,height:d,x:s,y:h}=r.size??{width:0,height:0,x:0,y:0};if(y.debug("getMaxChildSize abc95 child:",r.id,"width:",l,"height:",d,"x:",s,"y:",h,r.type),r.type==="space")continue;const x=l/(r.widthInColumns??1);x>a&&(a=x),d>o&&(o=d)}return{width:a,height:o}},"getMaxChildSize");function G(e,a,o=0,r=0,l=8){y.debug("setBlockSizes abc95 (start)",e.id,e?.size?.x,"block width =",e?.size,"siblingWidth",o),e?.size?.width||(e.size={width:o,height:r,x:0,y:0});let d=0,s=0;if(e.children?.length>0){for(const b of e.children)G(b,a,0,0,l);const h=qt(e);d=h.width,s=h.height,y.debug("setBlockSizes abc95 maxWidth of",e.id,":s children is ",d,s);for(const b of e.children)b.size&&(y.debug(`abc95 Setting size of children of ${e.id} id=${b.id} ${d} ${s} ${JSON.stringify(b.size)}`),b.size.width=d*(b.widthInColumns??1)+l*((b.widthInColumns??1)-1),b.size.height=s,b.size.x=0,b.size.y=0,y.debug(`abc95 updating size of ${e.id} children child:${b.id} maxWidth:${d} maxHeight:${s}`));for(const b of e.children)G(b,a,d,s,l);const x=e.columns??-1;let m=0;for(const b of e.children)m+=b.widthInColumns??1;let S=e.children.length;x>0&&x0?Math.min(e.children.length,x):e.children.length;if(b>0){const k=(L-b*l-l)/b;y.debug("abc95 (growing to fit) width",e.id,L,e.size?.width,k);for(const _ of e.children)_.size&&(_.size.width=k)}}e.size={width:L,height:w,x:0,y:0}}y.debug("setBlockSizes abc94 (done)",e.id,e?.size?.x,e?.size?.width,e?.size?.y,e?.size?.height)}u(G,"setBlockSizes");function ue(e,a,o=8){y.debug(`abc85 layout blocks (=>layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`);const r=e.columns??-1;if(y.debug("layoutBlocks columns abc95",e.id,"=>",r,e),e.children&&e.children.length>0){const l=e?.children[0]?.size?.width??0,d=e.children.length*l+(e.children.length-1)*o;y.debug("widthOfChildren 88",d,"posX");const s=new Map;{let f=0;for(const L of e.children){if(!L.size)continue;const{py:w}=ne(r,f),b=s.get(w)??0;L.size.height>b&&s.set(w,L.size.height);let k=L?.widthInColumns??1;r>0&&(k=Math.min(k,r-f%r)),f+=k}}const h=new Map;{let f=0;const L=[...s.keys()].sort((w,b)=>w-b);for(const w of L)h.set(w,f),f+=(s.get(w)??0)+o}let x=0;y.debug("abc91 block?.size?.x",e.id,e?.size?.x);let m=e?.size?.x?e?.size?.x+(-e?.size?.width/2||0):-o,S=0;for(const f of e.children){const L=e;if(!f.size)continue;const{width:w,height:b}=f.size,{px:k,py:_}=ne(r,x);if(_!=S&&(S=_,m=e?.size?.x?e?.size?.x+(-e?.size?.width/2||0):-o,y.debug("New row in layout for block",e.id," and child ",f.id,S)),y.debug(`abc89 layout blocks (child) id: ${f.id} Pos: ${x} (px, py) ${k},${_} (${L?.size?.x},${L?.size?.y}) parent: ${L.id} width: ${w}${o}`),L.size){const O=w/2;f.size.x=m+o+O,y.debug(`abc91 layout blocks (calc) px, pyid:${f.id} startingPos=X${m} new startingPosX${f.size.x} ${O} padding=${o} width=${w} halfWidth=${O} => x:${f.size.x} y:${f.size.y} ${f.widthInColumns} (width * (child?.w || 1)) / 2 ${w*(f?.widthInColumns??1)/2}`),m=f.size.x+O;const v=h.get(_)??0,g=s.get(_)??b;f.size.y=L.size.y-L.size.height/2+v+g/2+o,y.debug(`abc88 layout blocks (calc) px, pyid:${f.id}startingPosX${m}${o}${O}=>x:${f.size.x}y:${f.size.y}${f.widthInColumns}(width * (child?.w || 1)) / 2${w*(f?.widthInColumns??1)/2}`)}f.children&&ue(f,a,o);let T=f?.widthInColumns??1;r>0&&(T=Math.min(T,r-x%r)),x+=T,y.debug("abc88 columnsPos",f,x)}}y.debug(`layout blocks (<==layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`)}u(ue,"layoutBlocks");function ge(e,{minX:a,minY:o,maxX:r,maxY:l}={minX:0,minY:0,maxX:0,maxY:0}){if(e.size&&e.id!=="root"){const{x:d,y:s,width:h,height:x}=e.size;d-h/2r&&(r=d+h/2),s+x/2>l&&(l=s+x/2)}if(e.children)for(const d of e.children)({minX:a,minY:o,maxX:r,maxY:l}=ge(d,{minX:a,minY:o,maxX:r,maxY:l}));return{minX:a,minY:o,maxX:r,maxY:l}}u(ge,"findBounds");function Ie(e){const a=e.getBlock("root");if(!a)return;const o=Le()?.block?.padding??8;G(a,e,0,0,o),ue(a,e,o),y.debug("getBlocks",JSON.stringify(a,null,2));const{minX:r,minY:l,maxX:d,maxY:s}=ge(a),h=s-l,x=d-r;return{x:r,y:l,width:x,height:h}}u(Ie,"layout");function he(e,a,o=!1){const r=e;let l="default";(r?.classes?.length||0)>0&&(l=(r?.classes??[]).join(" ")),l=l+" flowchart-label";const d=(r?.classes??[]).flatMap(b=>a.getClasses().get(b)?.styles??[]);let s=0,h="rect",x;switch(r.type){case"round":s=5,h="rect";break;case"composite":s=0,h="composite",x=0;break;case"square":h="rect";break;case"diamond":h="question";break;case"hexagon":h="hexagon";break;case"block_arrow":h="block_arrow";break;case"odd":h="rect_left_inv_arrow";break;case"lean_right":h="lean_right";break;case"lean_left":h="lean_left";break;case"trapezoid":h="trapezoid";break;case"inv_trapezoid":h="inv_trapezoid";break;case"rect_left_inv_arrow":h="rect_left_inv_arrow";break;case"circle":h="circle";break;case"ellipse":h="ellipse";break;case"stadium":h="stadium";break;case"subroutine":h="subroutine";break;case"cylinder":h="cylinder";break;case"group":h="rect";break;case"doublecircle":h="doublecircle";break;default:h="rect"}const m=St(r?.styles??[]),S=r.label,f=r.size??{width:0,height:0,x:0,y:0},L=a.getDiagramId();return{labelStyle:m.labelStyle,shape:h,label:S,labelText:S,rx:s,ry:s,class:l,cssClasses:l,cssStyles:r?.styles??[],cssCompiledStyles:d,style:m.style,id:r.id,domId:L?`${L}-${r.id}`:r.id,isGroup:!1,directions:r.directions,width:f.width||void 0,height:f.height||void 0,wrappingWidth:f.width||Number.POSITIVE_INFINITY,x:f.x,y:f.y,positioned:o,intersect:void 0,padding:x??Y()?.block?.padding??0,widthInColumns:r.widthInColumns??1}}u(he,"getNodeFromBlock");async function Oe(e,a,o){const r=he(a,o,!1);if(a.type==="group")return;const l=Y(),d=await me(e,r,{config:l}),s=d.node()?.getBBox()??{width:0,height:0},h=o.getBlock(r.id);h.size={width:s.width,height:s.height,x:0,y:0,node:d},o.setBlock(h),d.remove()}u(Oe,"calculateBlockSize");async function ve(e,a,o){const r=he(a,o,!0);if(o.getBlock(r.id).type!=="space"){const d=Y();await me(e,r,{config:d}),a.intersect=r?.intersect,xt(r)}}u(ve,"insertBlockPositioned");async function q(e,a,o,r){for(const l of a)await r(e,l,o),l.children&&await q(e,l.children,o,r)}u(q,"performOperations");async function Ce(e,a,o){await q(e,a,o,Oe)}u(Ce,"calculateBlockSizes");async function Ae(e,a,o){await q(e,a,o,ve)}u(Ae,"insertBlocks");async function ze(e,a,o,r,l){const d=new ht({multigraph:!0,compound:!0});d.setGraph({rankdir:"TB",nodesep:10,ranksep:10,marginx:8,marginy:8});for(const s of o)s.size&&d.setNode(s.id,{width:s.size.width,height:s.size.height,intersect:s.intersect});for(const s of a)if(s.start&&s.end){const h=r.getBlock(s.start),x=r.getBlock(s.end);if(h?.size&&x?.size){const m=h.size,S=x.size,f=[{x:m.x,y:m.y},{x:m.x+(S.x-m.x)/2,y:m.y+(S.y-m.y)/2},{x:S.x,y:S.y}],L=l?`${l}-${s.id}`:s.id,w=s.thickness==="thick"?"edge-thickness-thick":"edge-thickness-normal",b=s.pattern==="dotted"?"edge-pattern-dotted":"edge-pattern-solid",k=`${w} ${b} flowchart-link LS-a1 LE-b1`;dt(e,{...s,id:L,arrowTypeEnd:s.arrowTypeEnd,arrowTypeStart:s.arrowTypeStart,points:f,classes:k},{},"block",d.node(s.start),d.node(s.end),l),s.label&&(await pt(e,{...s,label:s.label,labelStyle:"stroke: #333; stroke-width: 1.5px;fill:none;",arrowTypeEnd:s.arrowTypeEnd,arrowTypeStart:s.arrowTypeStart,points:f,classes:k}),ft({...s,x:f[1].x,y:f[1].y},{originalPath:f}))}}}u(ze,"insertEdges");var Jt=u(function(e,a){return a.db.getClasses()},"getClasses"),Zt=u(async function(e,a,o,r){const{securityLevel:l,block:d}=Y(),s=r.db;s.setDiagramId(a);let h;l==="sandbox"&&(h=X("#i"+a));const x=l==="sandbox"?X(h.nodes()[0].contentDocument.body):X("body"),m=l==="sandbox"?x.select(`[id="${a}"]`):X(`[id="${a}"]`);ct(m,["point","circle","cross"],r.type,a);const f=s.getBlocks(),L=s.getBlocksFlat(),w=s.getEdges(),b=m.insert("g").attr("class","block");await Ce(b,f,s);const k=Ie(s);await Ae(b,f,s),await ze(b,w,L,s,a);const _=b.node()?.getBBox(),T=_&&Number.isFinite(_.width)&&Number.isFinite(_.height)?_:k;if(T){const O=Math.max(1,Math.round(.125*(T.width/T.height))),v=T.height+O+10,g=T.width+10,{useMaxWidth:i}=d;lt(m,v,g,!!i),y.debug("Here Bounds",k,T),m.attr("viewBox",`${T.x-5} ${T.y-5} ${T.width+10} ${T.height+10}`)}},"draw"),Qt={draw:Zt,getClasses:Jt},is={parser:Dt,db:Xt,renderer:Qt,styles:Gt};export{is as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/c4Diagram-7LVT6UL2.C1MP3r9C.js b/packages/tempo/public/v4/assets/chunks/c4Diagram-7LVT6UL2.C1MP3r9C.js new file mode 100644 index 00000000..6fb4649a --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/c4Diagram-7LVT6UL2.C1MP3r9C.js @@ -0,0 +1,38 @@ +import{d as Ne}from"./chunk-F27PBJKO.CcniKEe6.js";import{s as Ae,g as Le,a as Ie,b as Me,_ as d,c as Ct,l as ce,d as Be,e as Ve,f as Ot,h as Ye,i as ye,j as Kt,w as Fe,k as Jt,m as ue}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var Yt=(function(){var t=d(function(yt,m,x,E){for(x=x||{},E=yt.length;E--;x[yt[E]]=m);return x},"o"),e=[1,24],r=[1,25],a=[1,26],u=[1,27],i=[1,28],n=[1,63],l=[1,64],s=[1,65],h=[1,66],y=[1,67],f=[1,68],b=[1,69],v=[1,29],w=[1,30],N=[1,31],O=[1,32],P=[1,33],I=[1,34],W=[1,35],X=[1,36],q=[1,37],H=[1,38],Q=[1,39],K=[1,40],G=[1,41],J=[1,42],Z=[1,43],$=[1,44],tt=[1,45],et=[1,46],nt=[1,47],st=[1,48],rt=[1,50],at=[1,51],it=[1,52],ot=[1,53],lt=[1,54],ct=[1,55],ut=[1,56],ht=[1,57],dt=[1,58],pt=[1,59],ft=[1,60],kt=[14,42],jt=[14,34,36,37,38,39,40,41,42,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],Rt=[12,14,34,36,37,38,39,40,41,42,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],S=[1,82],k=[1,83],T=[1,84],C=[1,85],R=[12,14,42],re=[12,14,33,42],Lt=[12,14,33,42,76,77,79,80],gt=[12,33],zt=[34,36,37,38,39,40,41,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],Wt={trace:d(function(){},"trace"),yy:{},symbols_:{error:2,start:3,mermaidDoc:4,direction:5,direction_tb:6,direction_bt:7,direction_rl:8,direction_lr:9,graphConfig:10,C4_CONTEXT:11,NEWLINE:12,statements:13,EOF:14,C4_CONTAINER:15,C4_COMPONENT:16,C4_DYNAMIC:17,C4_DEPLOYMENT:18,otherStatements:19,diagramStatements:20,otherStatement:21,title:22,accDescription:23,acc_title:24,acc_title_value:25,acc_descr:26,acc_descr_value:27,acc_descr_multiline_value:28,boundaryStatement:29,boundaryStartStatement:30,boundaryStopStatement:31,boundaryStart:32,LBRACE:33,ENTERPRISE_BOUNDARY:34,attributes:35,SYSTEM_BOUNDARY:36,BOUNDARY:37,CONTAINER_BOUNDARY:38,NODE:39,NODE_L:40,NODE_R:41,RBRACE:42,diagramStatement:43,PERSON:44,PERSON_EXT:45,SYSTEM:46,SYSTEM_DB:47,SYSTEM_QUEUE:48,SYSTEM_EXT:49,SYSTEM_EXT_DB:50,SYSTEM_EXT_QUEUE:51,CONTAINER:52,CONTAINER_DB:53,CONTAINER_QUEUE:54,CONTAINER_EXT:55,CONTAINER_EXT_DB:56,CONTAINER_EXT_QUEUE:57,COMPONENT:58,COMPONENT_DB:59,COMPONENT_QUEUE:60,COMPONENT_EXT:61,COMPONENT_EXT_DB:62,COMPONENT_EXT_QUEUE:63,REL:64,BIREL:65,REL_U:66,REL_D:67,REL_L:68,REL_R:69,REL_B:70,REL_INDEX:71,UPDATE_EL_STYLE:72,UPDATE_REL_STYLE:73,UPDATE_LAYOUT_CONFIG:74,attribute:75,STR:76,STR_KEY:77,STR_VALUE:78,ATTRIBUTE:79,ATTRIBUTE_EMPTY:80,$accept:0,$end:1},terminals_:{2:"error",6:"direction_tb",7:"direction_bt",8:"direction_rl",9:"direction_lr",11:"C4_CONTEXT",12:"NEWLINE",14:"EOF",15:"C4_CONTAINER",16:"C4_COMPONENT",17:"C4_DYNAMIC",18:"C4_DEPLOYMENT",22:"title",23:"accDescription",24:"acc_title",25:"acc_title_value",26:"acc_descr",27:"acc_descr_value",28:"acc_descr_multiline_value",33:"LBRACE",34:"ENTERPRISE_BOUNDARY",36:"SYSTEM_BOUNDARY",37:"BOUNDARY",38:"CONTAINER_BOUNDARY",39:"NODE",40:"NODE_L",41:"NODE_R",42:"RBRACE",44:"PERSON",45:"PERSON_EXT",46:"SYSTEM",47:"SYSTEM_DB",48:"SYSTEM_QUEUE",49:"SYSTEM_EXT",50:"SYSTEM_EXT_DB",51:"SYSTEM_EXT_QUEUE",52:"CONTAINER",53:"CONTAINER_DB",54:"CONTAINER_QUEUE",55:"CONTAINER_EXT",56:"CONTAINER_EXT_DB",57:"CONTAINER_EXT_QUEUE",58:"COMPONENT",59:"COMPONENT_DB",60:"COMPONENT_QUEUE",61:"COMPONENT_EXT",62:"COMPONENT_EXT_DB",63:"COMPONENT_EXT_QUEUE",64:"REL",65:"BIREL",66:"REL_U",67:"REL_D",68:"REL_L",69:"REL_R",70:"REL_B",71:"REL_INDEX",72:"UPDATE_EL_STYLE",73:"UPDATE_REL_STYLE",74:"UPDATE_LAYOUT_CONFIG",76:"STR",77:"STR_KEY",78:"STR_VALUE",79:"ATTRIBUTE",80:"ATTRIBUTE_EMPTY"},productions_:[0,[3,1],[3,1],[5,1],[5,1],[5,1],[5,1],[4,1],[10,4],[10,4],[10,4],[10,4],[10,4],[13,1],[13,1],[13,2],[19,1],[19,2],[19,3],[21,1],[21,1],[21,2],[21,2],[21,1],[29,3],[30,3],[30,3],[30,4],[32,2],[32,2],[32,2],[32,2],[32,2],[32,2],[32,2],[31,1],[20,1],[20,2],[20,3],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,1],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[35,1],[35,2],[75,1],[75,2],[75,1],[75,1]],performAction:d(function(m,x,E,_,D,o,wt){var p=o.length-1;switch(D){case 3:_.setDirection("TB");break;case 4:_.setDirection("BT");break;case 5:_.setDirection("RL");break;case 6:_.setDirection("LR");break;case 8:case 9:case 10:case 11:case 12:_.setC4Type(o[p-3]);break;case 19:_.setTitle(o[p].substring(6)),this.$=o[p].substring(6);break;case 20:_.setAccDescription(o[p].substring(15)),this.$=o[p].substring(15);break;case 21:this.$=o[p].trim(),_.setTitle(this.$);break;case 22:case 23:this.$=o[p].trim(),_.setAccDescription(this.$);break;case 28:o[p].splice(2,0,"ENTERPRISE"),_.addPersonOrSystemBoundary(...o[p]),this.$=o[p];break;case 29:o[p].splice(2,0,"SYSTEM"),_.addPersonOrSystemBoundary(...o[p]),this.$=o[p];break;case 30:_.addPersonOrSystemBoundary(...o[p]),this.$=o[p];break;case 31:o[p].splice(2,0,"CONTAINER"),_.addContainerBoundary(...o[p]),this.$=o[p];break;case 32:_.addDeploymentNode("node",...o[p]),this.$=o[p];break;case 33:_.addDeploymentNode("nodeL",...o[p]),this.$=o[p];break;case 34:_.addDeploymentNode("nodeR",...o[p]),this.$=o[p];break;case 35:_.popBoundaryParseStack();break;case 39:_.addPersonOrSystem("person",...o[p]),this.$=o[p];break;case 40:_.addPersonOrSystem("external_person",...o[p]),this.$=o[p];break;case 41:_.addPersonOrSystem("system",...o[p]),this.$=o[p];break;case 42:_.addPersonOrSystem("system_db",...o[p]),this.$=o[p];break;case 43:_.addPersonOrSystem("system_queue",...o[p]),this.$=o[p];break;case 44:_.addPersonOrSystem("external_system",...o[p]),this.$=o[p];break;case 45:_.addPersonOrSystem("external_system_db",...o[p]),this.$=o[p];break;case 46:_.addPersonOrSystem("external_system_queue",...o[p]),this.$=o[p];break;case 47:_.addContainer("container",...o[p]),this.$=o[p];break;case 48:_.addContainer("container_db",...o[p]),this.$=o[p];break;case 49:_.addContainer("container_queue",...o[p]),this.$=o[p];break;case 50:_.addContainer("external_container",...o[p]),this.$=o[p];break;case 51:_.addContainer("external_container_db",...o[p]),this.$=o[p];break;case 52:_.addContainer("external_container_queue",...o[p]),this.$=o[p];break;case 53:_.addComponent("component",...o[p]),this.$=o[p];break;case 54:_.addComponent("component_db",...o[p]),this.$=o[p];break;case 55:_.addComponent("component_queue",...o[p]),this.$=o[p];break;case 56:_.addComponent("external_component",...o[p]),this.$=o[p];break;case 57:_.addComponent("external_component_db",...o[p]),this.$=o[p];break;case 58:_.addComponent("external_component_queue",...o[p]),this.$=o[p];break;case 60:_.addRel("rel",...o[p]),this.$=o[p];break;case 61:_.addRel("birel",...o[p]),this.$=o[p];break;case 62:_.addRel("rel_u",...o[p]),this.$=o[p];break;case 63:_.addRel("rel_d",...o[p]),this.$=o[p];break;case 64:_.addRel("rel_l",...o[p]),this.$=o[p];break;case 65:_.addRel("rel_r",...o[p]),this.$=o[p];break;case 66:_.addRel("rel_b",...o[p]),this.$=o[p];break;case 67:o[p].splice(0,1),_.addRel("rel",...o[p]),this.$=o[p];break;case 68:_.updateElStyle("update_el_style",...o[p]),this.$=o[p];break;case 69:_.updateRelStyle("update_rel_style",...o[p]),this.$=o[p];break;case 70:_.updateLayoutConfig("update_layout_config",...o[p]),this.$=o[p];break;case 71:this.$=[o[p]];break;case 72:o[p].unshift(o[p-1]),this.$=o[p];break;case 73:case 75:this.$=o[p].trim();break;case 74:let xt={};xt[o[p-1].trim()]=o[p].trim(),this.$=xt;break;case 76:this.$="";break}},"anonymous"),table:[{3:1,4:2,5:3,6:[1,5],7:[1,6],8:[1,7],9:[1,8],10:4,11:[1,9],15:[1,10],16:[1,11],17:[1,12],18:[1,13]},{1:[3]},{1:[2,1]},{1:[2,2]},{1:[2,7]},{1:[2,3]},{1:[2,4]},{1:[2,5]},{1:[2,6]},{12:[1,14]},{12:[1,15]},{12:[1,16]},{12:[1,17]},{12:[1,18]},{13:19,19:20,20:21,21:22,22:e,23:r,24:a,26:u,28:i,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{13:70,19:20,20:21,21:22,22:e,23:r,24:a,26:u,28:i,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{13:71,19:20,20:21,21:22,22:e,23:r,24:a,26:u,28:i,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{13:72,19:20,20:21,21:22,22:e,23:r,24:a,26:u,28:i,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{13:73,19:20,20:21,21:22,22:e,23:r,24:a,26:u,28:i,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{14:[1,74]},t(kt,[2,13],{43:23,29:49,30:61,32:62,20:75,34:n,36:l,37:s,38:h,39:y,40:f,41:b,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft}),t(kt,[2,14]),t(jt,[2,16],{12:[1,76]}),t(kt,[2,36],{12:[1,77]}),t(Rt,[2,19]),t(Rt,[2,20]),{25:[1,78]},{27:[1,79]},t(Rt,[2,23]),{35:80,75:81,76:S,77:k,79:T,80:C},{35:86,75:81,76:S,77:k,79:T,80:C},{35:87,75:81,76:S,77:k,79:T,80:C},{35:88,75:81,76:S,77:k,79:T,80:C},{35:89,75:81,76:S,77:k,79:T,80:C},{35:90,75:81,76:S,77:k,79:T,80:C},{35:91,75:81,76:S,77:k,79:T,80:C},{35:92,75:81,76:S,77:k,79:T,80:C},{35:93,75:81,76:S,77:k,79:T,80:C},{35:94,75:81,76:S,77:k,79:T,80:C},{35:95,75:81,76:S,77:k,79:T,80:C},{35:96,75:81,76:S,77:k,79:T,80:C},{35:97,75:81,76:S,77:k,79:T,80:C},{35:98,75:81,76:S,77:k,79:T,80:C},{35:99,75:81,76:S,77:k,79:T,80:C},{35:100,75:81,76:S,77:k,79:T,80:C},{35:101,75:81,76:S,77:k,79:T,80:C},{35:102,75:81,76:S,77:k,79:T,80:C},{35:103,75:81,76:S,77:k,79:T,80:C},{35:104,75:81,76:S,77:k,79:T,80:C},t(R,[2,59]),{35:105,75:81,76:S,77:k,79:T,80:C},{35:106,75:81,76:S,77:k,79:T,80:C},{35:107,75:81,76:S,77:k,79:T,80:C},{35:108,75:81,76:S,77:k,79:T,80:C},{35:109,75:81,76:S,77:k,79:T,80:C},{35:110,75:81,76:S,77:k,79:T,80:C},{35:111,75:81,76:S,77:k,79:T,80:C},{35:112,75:81,76:S,77:k,79:T,80:C},{35:113,75:81,76:S,77:k,79:T,80:C},{35:114,75:81,76:S,77:k,79:T,80:C},{35:115,75:81,76:S,77:k,79:T,80:C},{20:116,29:49,30:61,32:62,34:n,36:l,37:s,38:h,39:y,40:f,41:b,43:23,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft},{12:[1,118],33:[1,117]},{35:119,75:81,76:S,77:k,79:T,80:C},{35:120,75:81,76:S,77:k,79:T,80:C},{35:121,75:81,76:S,77:k,79:T,80:C},{35:122,75:81,76:S,77:k,79:T,80:C},{35:123,75:81,76:S,77:k,79:T,80:C},{35:124,75:81,76:S,77:k,79:T,80:C},{35:125,75:81,76:S,77:k,79:T,80:C},{14:[1,126]},{14:[1,127]},{14:[1,128]},{14:[1,129]},{1:[2,8]},t(kt,[2,15]),t(jt,[2,17],{21:22,19:130,22:e,23:r,24:a,26:u,28:i}),t(kt,[2,37],{19:20,20:21,21:22,43:23,29:49,30:61,32:62,13:131,22:e,23:r,24:a,26:u,28:i,34:n,36:l,37:s,38:h,39:y,40:f,41:b,44:v,45:w,46:N,47:O,48:P,49:I,50:W,51:X,52:q,53:H,54:Q,55:K,56:G,57:J,58:Z,59:$,60:tt,61:et,62:nt,63:st,64:rt,65:at,66:it,67:ot,68:lt,69:ct,70:ut,71:ht,72:dt,73:pt,74:ft}),t(Rt,[2,21]),t(Rt,[2,22]),t(R,[2,39]),t(re,[2,71],{75:81,35:132,76:S,77:k,79:T,80:C}),t(Lt,[2,73]),{78:[1,133]},t(Lt,[2,75]),t(Lt,[2,76]),t(R,[2,40]),t(R,[2,41]),t(R,[2,42]),t(R,[2,43]),t(R,[2,44]),t(R,[2,45]),t(R,[2,46]),t(R,[2,47]),t(R,[2,48]),t(R,[2,49]),t(R,[2,50]),t(R,[2,51]),t(R,[2,52]),t(R,[2,53]),t(R,[2,54]),t(R,[2,55]),t(R,[2,56]),t(R,[2,57]),t(R,[2,58]),t(R,[2,60]),t(R,[2,61]),t(R,[2,62]),t(R,[2,63]),t(R,[2,64]),t(R,[2,65]),t(R,[2,66]),t(R,[2,67]),t(R,[2,68]),t(R,[2,69]),t(R,[2,70]),{31:134,42:[1,135]},{12:[1,136]},{33:[1,137]},t(gt,[2,28]),t(gt,[2,29]),t(gt,[2,30]),t(gt,[2,31]),t(gt,[2,32]),t(gt,[2,33]),t(gt,[2,34]),{1:[2,9]},{1:[2,10]},{1:[2,11]},{1:[2,12]},t(jt,[2,18]),t(kt,[2,38]),t(re,[2,72]),t(Lt,[2,74]),t(R,[2,24]),t(R,[2,35]),t(zt,[2,25]),t(zt,[2,26],{12:[1,138]}),t(zt,[2,27])],defaultActions:{2:[2,1],3:[2,2],4:[2,7],5:[2,3],6:[2,4],7:[2,5],8:[2,6],74:[2,8],126:[2,9],127:[2,10],128:[2,11],129:[2,12]},parseError:d(function(m,x){if(x.recoverable)this.trace(m);else{var E=new Error(m);throw E.hash=x,E}},"parseError"),parse:d(function(m){var x=this,E=[0],_=[],D=[null],o=[],wt=this.table,p="",xt=0,ae=0,we=2,ie=1,Oe=o.slice.call(arguments,1),A=Object.create(this.lexer),vt={yy:{}};for(var Xt in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Xt)&&(vt.yy[Xt]=this.yy[Xt]);A.setInput(m,vt.yy),vt.yy.lexer=A,vt.yy.parser=this,typeof A.yylloc>"u"&&(A.yylloc={});var qt=A.yylloc;o.push(qt);var Pe=A.options&&A.options.ranges;typeof vt.yy.parseError=="function"?this.parseError=vt.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function De(B){E.length=E.length-2*B,D.length=D.length-B,o.length=o.length-B}d(De,"popStack");function oe(){var B;return B=_.pop()||A.lex()||ie,typeof B!="number"&&(B instanceof Array&&(_=B,B=_.pop()),B=x.symbols_[B]||B),B}d(oe,"lex");for(var M,Et,V,Ht,Tt={},Mt,j,le,Bt;;){if(Et=E[E.length-1],this.defaultActions[Et]?V=this.defaultActions[Et]:((M===null||typeof M>"u")&&(M=oe()),V=wt[Et]&&wt[Et][M]),typeof V>"u"||!V.length||!V[0]){var Qt="";Bt=[];for(Mt in wt[Et])this.terminals_[Mt]&&Mt>we&&Bt.push("'"+this.terminals_[Mt]+"'");A.showPosition?Qt="Parse error on line "+(xt+1)+`: +`+A.showPosition()+` +Expecting `+Bt.join(", ")+", got '"+(this.terminals_[M]||M)+"'":Qt="Parse error on line "+(xt+1)+": Unexpected "+(M==ie?"end of input":"'"+(this.terminals_[M]||M)+"'"),this.parseError(Qt,{text:A.match,token:this.terminals_[M]||M,line:A.yylineno,loc:qt,expected:Bt})}if(V[0]instanceof Array&&V.length>1)throw new Error("Parse Error: multiple actions possible at state: "+Et+", token: "+M);switch(V[0]){case 1:E.push(M),D.push(A.yytext),o.push(A.yylloc),E.push(V[1]),M=null,ae=A.yyleng,p=A.yytext,xt=A.yylineno,qt=A.yylloc;break;case 2:if(j=this.productions_[V[1]][1],Tt.$=D[D.length-j],Tt._$={first_line:o[o.length-(j||1)].first_line,last_line:o[o.length-1].last_line,first_column:o[o.length-(j||1)].first_column,last_column:o[o.length-1].last_column},Pe&&(Tt._$.range=[o[o.length-(j||1)].range[0],o[o.length-1].range[1]]),Ht=this.performAction.apply(Tt,[p,ae,xt,vt.yy,V[1],D,o].concat(Oe)),typeof Ht<"u")return Ht;j&&(E=E.slice(0,-1*j*2),D=D.slice(0,-1*j),o=o.slice(0,-1*j)),E.push(this.productions_[V[1]][0]),D.push(Tt.$),o.push(Tt._$),le=wt[E[E.length-2]][E[E.length-1]],E.push(le);break;case 3:return!0}}return!0},"parse")},Re=(function(){var yt={EOF:1,parseError:d(function(x,E){if(this.yy.parser)this.yy.parser.parseError(x,E);else throw new Error(x)},"parseError"),setInput:d(function(m,x){return this.yy=x||this.yy||{},this._input=m,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:d(function(){var m=this._input[0];this.yytext+=m,this.yyleng++,this.offset++,this.match+=m,this.matched+=m;var x=m.match(/(?:\r\n?|\n).*/g);return x?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),m},"input"),unput:d(function(m){var x=m.length,E=m.split(/(?:\r\n?|\n)/g);this._input=m+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-x),this.offset-=x;var _=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),E.length-1&&(this.yylineno-=E.length-1);var D=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:E?(E.length===_.length?this.yylloc.first_column:0)+_[_.length-E.length].length-E[0].length:this.yylloc.first_column-x},this.options.ranges&&(this.yylloc.range=[D[0],D[0]+this.yyleng-x]),this.yyleng=this.yytext.length,this},"unput"),more:d(function(){return this._more=!0,this},"more"),reject:d(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:d(function(m){this.unput(this.match.slice(m))},"less"),pastInput:d(function(){var m=this.matched.substr(0,this.matched.length-this.match.length);return(m.length>20?"...":"")+m.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:d(function(){var m=this.match;return m.length<20&&(m+=this._input.substr(0,20-m.length)),(m.substr(0,20)+(m.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:d(function(){var m=this.pastInput(),x=new Array(m.length+1).join("-");return m+this.upcomingInput()+` +`+x+"^"},"showPosition"),test_match:d(function(m,x){var E,_,D;if(this.options.backtrack_lexer&&(D={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(D.yylloc.range=this.yylloc.range.slice(0))),_=m[0].match(/(?:\r\n?|\n).*/g),_&&(this.yylineno+=_.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:_?_[_.length-1].length-_[_.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+m[0].length},this.yytext+=m[0],this.match+=m[0],this.matches=m,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(m[0].length),this.matched+=m[0],E=this.performAction.call(this,this.yy,this,x,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),E)return E;if(this._backtrack){for(var o in D)this[o]=D[o];return!1}return!1},"test_match"),next:d(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var m,x,E,_;this._more||(this.yytext="",this.match="");for(var D=this._currentRules(),o=0;ox[0].length)){if(x=E,_=o,this.options.backtrack_lexer){if(m=this.test_match(E,D[o]),m!==!1)return m;if(this._backtrack){x=!1;continue}else return!1}else if(!this.options.flex)break}return x?(m=this.test_match(x,D[_]),m!==!1?m:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:d(function(){var x=this.next();return x||this.lex()},"lex"),begin:d(function(x){this.conditionStack.push(x)},"begin"),popState:d(function(){var x=this.conditionStack.length-1;return x>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:d(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:d(function(x){return x=this.conditionStack.length-1-Math.abs(x||0),x>=0?this.conditionStack[x]:"INITIAL"},"topState"),pushState:d(function(x){this.begin(x)},"pushState"),stateStackSize:d(function(){return this.conditionStack.length},"stateStackSize"),options:{},performAction:d(function(x,E,_,D){switch(_){case 0:return 6;case 1:return 7;case 2:return 8;case 3:return 9;case 4:return 22;case 5:return 23;case 6:return this.begin("acc_title"),24;case 7:return this.popState(),"acc_title_value";case 8:return this.begin("acc_descr"),26;case 9:return this.popState(),"acc_descr_value";case 10:this.begin("acc_descr_multiline");break;case 11:this.popState();break;case 12:return"acc_descr_multiline_value";case 13:break;case 14:c;break;case 15:return 12;case 16:break;case 17:return 11;case 18:return 15;case 19:return 16;case 20:return 17;case 21:return 18;case 22:return this.begin("person_ext"),45;case 23:return this.begin("person"),44;case 24:return this.begin("system_ext_queue"),51;case 25:return this.begin("system_ext_db"),50;case 26:return this.begin("system_ext"),49;case 27:return this.begin("system_queue"),48;case 28:return this.begin("system_db"),47;case 29:return this.begin("system"),46;case 30:return this.begin("boundary"),37;case 31:return this.begin("enterprise_boundary"),34;case 32:return this.begin("system_boundary"),36;case 33:return this.begin("container_ext_queue"),57;case 34:return this.begin("container_ext_db"),56;case 35:return this.begin("container_ext"),55;case 36:return this.begin("container_queue"),54;case 37:return this.begin("container_db"),53;case 38:return this.begin("container"),52;case 39:return this.begin("container_boundary"),38;case 40:return this.begin("component_ext_queue"),63;case 41:return this.begin("component_ext_db"),62;case 42:return this.begin("component_ext"),61;case 43:return this.begin("component_queue"),60;case 44:return this.begin("component_db"),59;case 45:return this.begin("component"),58;case 46:return this.begin("node"),39;case 47:return this.begin("node"),39;case 48:return this.begin("node_l"),40;case 49:return this.begin("node_r"),41;case 50:return this.begin("rel"),64;case 51:return this.begin("birel"),65;case 52:return this.begin("rel_u"),66;case 53:return this.begin("rel_u"),66;case 54:return this.begin("rel_d"),67;case 55:return this.begin("rel_d"),67;case 56:return this.begin("rel_l"),68;case 57:return this.begin("rel_l"),68;case 58:return this.begin("rel_r"),69;case 59:return this.begin("rel_r"),69;case 60:return this.begin("rel_b"),70;case 61:return this.begin("rel_index"),71;case 62:return this.begin("update_el_style"),72;case 63:return this.begin("update_rel_style"),73;case 64:return this.begin("update_layout_config"),74;case 65:return"EOF_IN_STRUCT";case 66:return this.begin("attribute"),"ATTRIBUTE_EMPTY";case 67:this.begin("attribute");break;case 68:this.popState(),this.popState();break;case 69:return 80;case 70:break;case 71:return 80;case 72:this.begin("string");break;case 73:this.popState();break;case 74:return"STR";case 75:this.begin("string_kv");break;case 76:return this.begin("string_kv_key"),"STR_KEY";case 77:this.popState(),this.begin("string_kv_value");break;case 78:return"STR_VALUE";case 79:this.popState(),this.popState();break;case 80:return"STR";case 81:return"LBRACE";case 82:return"RBRACE";case 83:return"SPACE";case 84:return"EOL";case 85:return 14}},"anonymous"),rules:[/^(?:.*direction\s+TB[^\n]*)/,/^(?:.*direction\s+BT[^\n]*)/,/^(?:.*direction\s+RL[^\n]*)/,/^(?:.*direction\s+LR[^\n]*)/,/^(?:title\s[^#\n;]+)/,/^(?:accDescription\s[^#\n;]+)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:%%(?!\{)*[^\n]*(\r?\n?)+)/,/^(?:%%[^\n]*(\r?\n)*)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:C4Context\b)/,/^(?:C4Container\b)/,/^(?:C4Component\b)/,/^(?:C4Dynamic\b)/,/^(?:C4Deployment\b)/,/^(?:Person_Ext\b)/,/^(?:Person\b)/,/^(?:SystemQueue_Ext\b)/,/^(?:SystemDb_Ext\b)/,/^(?:System_Ext\b)/,/^(?:SystemQueue\b)/,/^(?:SystemDb\b)/,/^(?:System\b)/,/^(?:Boundary\b)/,/^(?:Enterprise_Boundary\b)/,/^(?:System_Boundary\b)/,/^(?:ContainerQueue_Ext\b)/,/^(?:ContainerDb_Ext\b)/,/^(?:Container_Ext\b)/,/^(?:ContainerQueue\b)/,/^(?:ContainerDb\b)/,/^(?:Container\b)/,/^(?:Container_Boundary\b)/,/^(?:ComponentQueue_Ext\b)/,/^(?:ComponentDb_Ext\b)/,/^(?:Component_Ext\b)/,/^(?:ComponentQueue\b)/,/^(?:ComponentDb\b)/,/^(?:Component\b)/,/^(?:Deployment_Node\b)/,/^(?:Node\b)/,/^(?:Node_L\b)/,/^(?:Node_R\b)/,/^(?:Rel\b)/,/^(?:BiRel\b)/,/^(?:Rel_Up\b)/,/^(?:Rel_U\b)/,/^(?:Rel_Down\b)/,/^(?:Rel_D\b)/,/^(?:Rel_Left\b)/,/^(?:Rel_L\b)/,/^(?:Rel_Right\b)/,/^(?:Rel_R\b)/,/^(?:Rel_Back\b)/,/^(?:RelIndex\b)/,/^(?:UpdateElementStyle\b)/,/^(?:UpdateRelStyle\b)/,/^(?:UpdateLayoutConfig\b)/,/^(?:$)/,/^(?:[(][ ]*[,])/,/^(?:[(])/,/^(?:[)])/,/^(?:,,)/,/^(?:,)/,/^(?:[ ]*["]["])/,/^(?:[ ]*["])/,/^(?:["])/,/^(?:[^"]*)/,/^(?:[ ]*[\$])/,/^(?:[^=]*)/,/^(?:[=][ ]*["])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:[^,]+)/,/^(?:\{)/,/^(?:\})/,/^(?:[\s]+)/,/^(?:[\n\r]+)/,/^(?:$)/],conditions:{acc_descr_multiline:{rules:[11,12],inclusive:!1},acc_descr:{rules:[9],inclusive:!1},acc_title:{rules:[7],inclusive:!1},string_kv_value:{rules:[78,79],inclusive:!1},string_kv_key:{rules:[77],inclusive:!1},string_kv:{rules:[76],inclusive:!1},string:{rules:[73,74],inclusive:!1},attribute:{rules:[68,69,70,71,72,75,80],inclusive:!1},update_layout_config:{rules:[65,66,67,68],inclusive:!1},update_rel_style:{rules:[65,66,67,68],inclusive:!1},update_el_style:{rules:[65,66,67,68],inclusive:!1},rel_b:{rules:[65,66,67,68],inclusive:!1},rel_r:{rules:[65,66,67,68],inclusive:!1},rel_l:{rules:[65,66,67,68],inclusive:!1},rel_d:{rules:[65,66,67,68],inclusive:!1},rel_u:{rules:[65,66,67,68],inclusive:!1},rel_bi:{rules:[],inclusive:!1},rel:{rules:[65,66,67,68],inclusive:!1},node_r:{rules:[65,66,67,68],inclusive:!1},node_l:{rules:[65,66,67,68],inclusive:!1},node:{rules:[65,66,67,68],inclusive:!1},index:{rules:[],inclusive:!1},rel_index:{rules:[65,66,67,68],inclusive:!1},component_ext_queue:{rules:[65,66,67,68],inclusive:!1},component_ext_db:{rules:[65,66,67,68],inclusive:!1},component_ext:{rules:[65,66,67,68],inclusive:!1},component_queue:{rules:[65,66,67,68],inclusive:!1},component_db:{rules:[65,66,67,68],inclusive:!1},component:{rules:[65,66,67,68],inclusive:!1},container_boundary:{rules:[65,66,67,68],inclusive:!1},container_ext_queue:{rules:[65,66,67,68],inclusive:!1},container_ext_db:{rules:[65,66,67,68],inclusive:!1},container_ext:{rules:[65,66,67,68],inclusive:!1},container_queue:{rules:[65,66,67,68],inclusive:!1},container_db:{rules:[65,66,67,68],inclusive:!1},container:{rules:[65,66,67,68],inclusive:!1},birel:{rules:[65,66,67,68],inclusive:!1},system_boundary:{rules:[65,66,67,68],inclusive:!1},enterprise_boundary:{rules:[65,66,67,68],inclusive:!1},boundary:{rules:[65,66,67,68],inclusive:!1},system_ext_queue:{rules:[65,66,67,68],inclusive:!1},system_ext_db:{rules:[65,66,67,68],inclusive:!1},system_ext:{rules:[65,66,67,68],inclusive:!1},system_queue:{rules:[65,66,67,68],inclusive:!1},system_db:{rules:[65,66,67,68],inclusive:!1},system:{rules:[65,66,67,68],inclusive:!1},person_ext:{rules:[65,66,67,68],inclusive:!1},person:{rules:[65,66,67,68],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,81,82,83,84,85],inclusive:!0}}};return yt})();Wt.lexer=Re;function It(){this.yy={}}return d(It,"Parser"),It.prototype=Wt,Wt.Parser=It,new It})();Yt.parser=Yt;var Ue=Yt,_e=d(t=>Ct()[t],"getRequiredConfig"),St=d((t,e)=>{for(const[r,a]of Object.entries(e))if(a!==void 0)if(typeof a=="object"){const[u,i]=Object.entries(a)[0];t[u]=i}else t[r]=a},"assignAttributes"),be=d(()=>({alias:"global",label:{text:"global"},type:{text:"global"},tags:null,link:null,parentBoundary:""}),"createGlobalBoundary"),F=[],_t=[""],L="global",Y="",U=[be()],At=[],ee="",ne=!1,Ft=4,Ut=2,me,je=d(function(){return me},"getC4Type"),ze=d(function(t){me=ye(t,Ct())},"setC4Type"),We=d(function(t,e,r,a,u,i,n,l,s){if(t==null||e===void 0||e===null||r===void 0||r===null||a===void 0||a===null)return;let h={};const y=At.find(f=>f.from===e&&f.to===r);if(y?h=y:At.push(h),h.type=t,h.from=e,h.to=r,h.label={text:a},u==null)h.techn={text:""};else if(typeof u=="object"){const[f,b]=Object.entries(u)[0];h[f]={text:b}}else h.techn={text:u};if(i==null)h.descr={text:""};else if(typeof i=="object"){const[f,b]=Object.entries(i)[0];h[f]={text:b}}else h.descr={text:i};St(h,{sprite:n,tags:l,link:s}),h.wrap=mt()},"addRel"),Xe=d(function(t,e,r,a,u,i,n){if(e===null||r===null)return;let l={};const s=F.find(h=>h.alias===e);if(s&&e===s.alias?l=s:(l.alias=e,F.push(l)),r==null?l.label={text:""}:l.label={text:r},a==null)l.descr={text:""};else if(typeof a=="object"){const[h,y]=Object.entries(a)[0];l[h]={text:y}}else l.descr={text:a};St(l,{sprite:u,tags:i,link:n}),l.typeC4Shape={text:t},l.parentBoundary=L,l.wrap=mt()},"addPersonOrSystem"),qe=d(function(t,e,r,a,u,i,n,l){if(e===null||r===null)return;let s={};const h=F.find(y=>y.alias===e);if(h&&e===h.alias?s=h:(s.alias=e,F.push(s)),r==null?s.label={text:""}:s.label={text:r},a==null)s.techn={text:""};else if(typeof a=="object"){const[y,f]=Object.entries(a)[0];s[y]={text:f}}else s.techn={text:a};if(u==null)s.descr={text:""};else if(typeof u=="object"){const[y,f]=Object.entries(u)[0];s[y]={text:f}}else s.descr={text:u};St(s,{sprite:i,tags:n,link:l}),s.wrap=mt(),s.typeC4Shape={text:t},s.parentBoundary=L},"addContainer"),He=d(function(t,e,r,a,u,i,n,l){if(e===null||r===null)return;let s={};const h=F.find(y=>y.alias===e);if(h&&e===h.alias?s=h:(s.alias=e,F.push(s)),r==null?s.label={text:""}:s.label={text:r},a==null)s.techn={text:""};else if(typeof a=="object"){const[y,f]=Object.entries(a)[0];s[y]={text:f}}else s.techn={text:a};if(u==null)s.descr={text:""};else if(typeof u=="object"){const[y,f]=Object.entries(u)[0];s[y]={text:f}}else s.descr={text:u};St(s,{sprite:i,tags:n,link:l}),s.wrap=mt(),s.typeC4Shape={text:t},s.parentBoundary=L},"addComponent"),Qe=d(function(t,e,r,a,u){if(t===null||e===null)return;let i={};const n=U.find(l=>l.alias===t);if(n&&t===n.alias?i=n:(i.alias=t,U.push(i)),e==null?i.label={text:""}:i.label={text:e},r==null)i.type={text:"system"};else if(typeof r=="object"){const[l,s]=Object.entries(r)[0];i[l]={text:s}}else i.type={text:r};St(i,{tags:a,link:u}),i.parentBoundary=L,i.wrap=mt(),Y=L,L=t,_t.push(Y)},"addPersonOrSystemBoundary"),Ke=d(function(t,e,r,a,u){if(t===null||e===null)return;let i={};const n=U.find(l=>l.alias===t);if(n&&t===n.alias?i=n:(i.alias=t,U.push(i)),e==null?i.label={text:""}:i.label={text:e},r==null)i.type={text:"container"};else if(typeof r=="object"){const[l,s]=Object.entries(r)[0];i[l]={text:s}}else i.type={text:r};St(i,{tags:a,link:u}),i.parentBoundary=L,i.wrap=mt(),Y=L,L=t,_t.push(Y)},"addContainerBoundary"),Ge=d(function(t,e,r,a,u,i,n,l){if(e===null||r===null)return;let s={};const h=U.find(y=>y.alias===e);if(h&&e===h.alias?s=h:(s.alias=e,U.push(s)),r==null?s.label={text:""}:s.label={text:r},a==null)s.type={text:"node"};else if(typeof a=="object"){const[y,f]=Object.entries(a)[0];s[y]={text:f}}else s.type={text:a};if(u==null)s.descr={text:""};else if(typeof u=="object"){const[y,f]=Object.entries(u)[0];s[y]={text:f}}else s.descr={text:u};St(s,{tags:n,link:l}),s.nodeType=t,s.parentBoundary=L,s.wrap=mt(),Y=L,L=e,_t.push(Y)},"addDeploymentNode"),Je=d(function(){L=Y,_t.pop(),Y=_t.pop(),_t.push(Y)},"popBoundaryParseStack"),Ze=d(function(t,e,r,a,u,i,n,l,s,h,y){let f=F.find(b=>b.alias===e);if(!(f===void 0&&(f=U.find(b=>b.alias===e),f===void 0))){if(r!=null)if(typeof r=="object"){const[b,v]=Object.entries(r)[0];f[b]=v}else f.bgColor=r;if(a!=null)if(typeof a=="object"){const[b,v]=Object.entries(a)[0];f[b]=v}else f.fontColor=a;if(u!=null)if(typeof u=="object"){const[b,v]=Object.entries(u)[0];f[b]=v}else f.borderColor=u;if(i!=null)if(typeof i=="object"){const[b,v]=Object.entries(i)[0];f[b]=v}else f.shadowing=i;if(n!=null)if(typeof n=="object"){const[b,v]=Object.entries(n)[0];f[b]=v}else f.shape=n;if(l!=null)if(typeof l=="object"){const[b,v]=Object.entries(l)[0];f[b]=v}else f.sprite=l;if(s!=null)if(typeof s=="object"){const[b,v]=Object.entries(s)[0];f[b]=v}else f.techn=s;if(h!=null)if(typeof h=="object"){const[b,v]=Object.entries(h)[0];f[b]=v}else f.legendText=h;if(y!=null)if(typeof y=="object"){const[b,v]=Object.entries(y)[0];f[b]=v}else f.legendSprite=y}},"updateElStyle"),$e=d(function(t,e,r,a,u,i,n){const l=At.find(s=>s.from===e&&s.to===r);if(l!==void 0){if(a!=null)if(typeof a=="object"){const[s,h]=Object.entries(a)[0];l[s]=h}else l.textColor=a;if(u!=null)if(typeof u=="object"){const[s,h]=Object.entries(u)[0];l[s]=h}else l.lineColor=u;if(i!=null)if(typeof i=="object"){const[s,h]=Object.entries(i)[0];l[s]=parseInt(h)}else l.offsetX=parseInt(i);if(n!=null)if(typeof n=="object"){const[s,h]=Object.entries(n)[0];l[s]=parseInt(h)}else l.offsetY=parseInt(n)}},"updateRelStyle"),t0=d(function(t,e,r){let a=Ft,u=Ut;if(typeof e=="object"){const i=Object.values(e)[0];a=parseInt(i)}else a=parseInt(e);if(typeof r=="object"){const i=Object.values(r)[0];u=parseInt(i)}else u=parseInt(r);a>=1&&(Ft=a),u>=1&&(Ut=u)},"updateLayoutConfig"),e0=d(function(){return Ft},"getC4ShapeInRow"),n0=d(function(){return Ut},"getC4BoundaryInRow"),s0=d(function(){return L},"getCurrentBoundaryParse"),r0=d(function(){return Y},"getParentBoundaryParse"),ge=d(function(t){return t==null?F:F.filter(e=>e.parentBoundary===t)},"getC4ShapeArray"),a0=d(function(t){return F.find(e=>e.alias===t)},"getC4Shape"),i0=d(function(t){return Object.keys(ge(t))},"getC4ShapeKeys"),xe=d(function(t){return t==null?U:U.filter(e=>e.parentBoundary===t)},"getBoundaries"),o0=xe,l0=d(function(){return At},"getRels"),c0=d(function(){return ee},"getTitle"),u0=d(function(t){ne=t},"setWrap"),mt=d(function(){return ne},"autoWrap"),h0=d(function(){F=[],U=[be()],Y="",L="global",_t=[""],At=[],_t=[""],ee="",ne=!1,Ft=4,Ut=2},"clear"),d0={SOLID:0,DOTTED:1,NOTE:2,SOLID_CROSS:3,DOTTED_CROSS:4,SOLID_OPEN:5,DOTTED_OPEN:6,LOOP_START:10,LOOP_END:11,ALT_START:12,ALT_ELSE:13,ALT_END:14,OPT_START:15,OPT_END:16,ACTIVE_START:17,ACTIVE_END:18,PAR_START:19,PAR_AND:20,PAR_END:21,RECT_START:22,RECT_END:23,SOLID_POINT:24,DOTTED_POINT:25},p0={FILLED:0,OPEN:1},f0={LEFTOF:0,RIGHTOF:1,OVER:2},y0=d(function(t){ee=ye(t,Ct())},"setTitle"),Zt={addPersonOrSystem:Xe,addPersonOrSystemBoundary:Qe,addContainer:qe,addContainerBoundary:Ke,addComponent:He,addDeploymentNode:Ge,popBoundaryParseStack:Je,addRel:We,updateElStyle:Ze,updateRelStyle:$e,updateLayoutConfig:t0,autoWrap:mt,setWrap:u0,getC4ShapeArray:ge,getC4Shape:a0,getC4ShapeKeys:i0,getBoundaries:xe,getBoundarys:o0,getCurrentBoundaryParse:s0,getParentBoundaryParse:r0,getRels:l0,getTitle:c0,getC4Type:je,getC4ShapeInRow:e0,getC4BoundaryInRow:n0,setAccTitle:Me,getAccTitle:Ie,getAccDescription:Le,setAccDescription:Ae,getConfig:d(()=>_e("c4"),"getConfig"),clear:h0,LINETYPE:d0,ARROWTYPE:p0,PLACEMENT:f0,setTitle:y0,setC4Type:ze},ve=d(function(t,e){return Ne(t,e)},"drawRect"),_0=d((t,e,r,a)=>{const u=t.append("g");let i=0;for(const n of e){const l=n.textColor?n.textColor:"#444444",s=n.lineColor?n.lineColor:"#444444",h=n.offsetX?parseInt(String(n.offsetX)):0,y=n.offsetY?parseInt(String(n.offsetY)):0,f="";if(i===0){const w=u.append("line");w.attr("x1",n.startPoint.x),w.attr("y1",n.startPoint.y),w.attr("x2",n.endPoint.x),w.attr("y2",n.endPoint.y),w.attr("stroke-width","1"),w.attr("stroke",s),w.style("fill","none"),n.type!=="rel_b"&&w.attr("marker-end","url("+f+"#"+a+"-arrowhead)"),(n.type==="birel"||n.type==="rel_b")&&w.attr("marker-start","url("+f+"#"+a+"-arrowend)"),i=-1}else{const w=u.append("path");w.attr("fill","none").attr("stroke-width","1").attr("stroke",s).attr("d","Mstartx,starty Qcontrolx,controly stopx,stopy ".replaceAll("startx",n.startPoint.x).replaceAll("starty",n.startPoint.y).replaceAll("controlx",n.startPoint.x+(n.endPoint.x-n.startPoint.x)/2-(n.endPoint.x-n.startPoint.x)/4).replaceAll("controly",n.startPoint.y+(n.endPoint.y-n.startPoint.y)/2).replaceAll("stopx",n.endPoint.x).replaceAll("stopy",n.endPoint.y)),n.type!=="rel_b"&&w.attr("marker-end","url("+f+"#"+a+"-arrowhead)"),(n.type==="birel"||n.type==="rel_b")&&w.attr("marker-start","url("+f+"#"+a+"-arrowend)")}const b=n.label.width;let v=r.messageFont();Pt(r)(n.label.text,u,Math.min(n.startPoint.x,n.endPoint.x)+Math.abs(n.endPoint.x-n.startPoint.x)/2+h,Math.min(n.startPoint.y,n.endPoint.y)+Math.abs(n.endPoint.y-n.startPoint.y)/2+y,b,n.label.height,{fill:l},v),n.techn&&n.techn.text!==""&&(v=r.messageFont(),Pt(r)("["+n.techn.text+"]",u,Math.min(n.startPoint.x,n.endPoint.x)+Math.abs(n.endPoint.x-n.startPoint.x)/2+h,Math.min(n.startPoint.y,n.endPoint.y)+Math.abs(n.endPoint.y-n.startPoint.y)/2+r.messageFontSize+5+y,Math.max(b,n.techn.width),n.techn.height,{fill:l,"font-style":"italic"},v))}},"drawRels"),b0=d(function(t,e,r){const a=t.append("g"),u=e.bgColor?e.bgColor:"none",i=e.borderColor?e.borderColor:"#444444",n=e.fontColor?e.fontColor:"black";let l={"stroke-width":1,"stroke-dasharray":"7.0,7.0"};e.nodeType&&(l={"stroke-width":1});const s={x:e.x,y:e.y,fill:u,stroke:i,width:e.width,height:e.height,rx:2.5,ry:2.5,attrs:l};ve(a,s);let h=r.boundaryFont();h.fontWeight="bold",h.fontSize=h.fontSize+2,h.fontColor=n,Pt(r)(e.label.text,a,e.x,e.y+e.label.Y,e.width,e.height,{fill:"#444444"},h),e.type&&e.type.text!==""&&(h=r.boundaryFont(),h.fontColor=n,Pt(r)(e.type.text,a,e.x,e.y+e.type.Y,e.width,e.height,{fill:"#444444"},h)),e.descr&&e.descr.text!==""&&(h=r.boundaryFont(),h.fontSize=h.fontSize-2,h.fontColor=n,Pt(r)(e.descr.text,a,e.x,e.y+e.descr.Y,e.width,e.height,{fill:"#444444"},h))},"drawBoundary"),m0=d(function(t,e){t.append("defs").append("symbol").attr("id",e+"-database").attr("fill-rule","evenodd").attr("clip-rule","evenodd").append("path").attr("transform","scale(.5)").attr("d","M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z")},"insertDatabaseIcon"),g0=d(function(t,e){t.append("defs").append("symbol").attr("id",e+"-computer").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z")},"insertComputerIcon"),x0=d(function(t,e){t.append("defs").append("symbol").attr("id",e+"-clock").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z")},"insertClockIcon"),v0=d(function(t,e){t.append("defs").append("marker").attr("id",e+"-arrowhead").attr("refX",9).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z")},"insertArrowHead"),E0=d(function(t,e){t.append("defs").append("marker").attr("id",e+"-arrowend").attr("refX",1).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 10 0 L 0 5 L 10 10 z")},"insertArrowEnd"),S0=d(function(t,e){t.append("defs").append("marker").attr("id",e+"-filled-head").attr("refX",18).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},"insertArrowFilledHead"),k0=d(function(t,e){const a=t.append("defs").append("marker").attr("id",e+"-crosshead").attr("markerWidth",15).attr("markerHeight",8).attr("orient","auto").attr("refX",16).attr("refY",4);a.append("path").attr("fill","black").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 9,2 V 6 L16,4 Z"),a.append("path").attr("fill","none").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 0,1 L 6,7 M 6,1 L 0,7")},"insertArrowCrossHead"),Pt=(function(){function t(u,i,n,l,s,h,y){const f=i.append("text").attr("x",n+s/2).attr("y",l+h/2+5).style("text-anchor","middle").text(u);a(f,y)}d(t,"byText");function e(u,i,n,l,s,h,y,f){const{fontSize:b,fontFamily:v,fontWeight:w}=f,N=u.split(Jt.lineBreakRegex);for(let O=0;O{if(e==="sandbox"){const a=Kt("#i"+t).node()?.contentDocument;if(!a)throw new Error(`Sandbox iframe #i${t} is missing its content document`);return{root:Kt(a.body),doc:a}}return{root:Kt("body"),doc:document}},"getDiagramRoot"),C0=new Set(["system_queue","external_system_queue","container_queue","external_container_queue","component_queue","external_component_queue"]),R0=new Set(["system_db","external_system_db","container_db","external_container_db","component_db","external_component_db"]),w0={person:"person",box:"rounded",rounded:"rounded",cylinder:"cylinder",database:"cylinder",db:"cylinder",queue:"h-cyl",pipe:"h-cyl",component:"fr-rect"},Gt=d(t=>t?w0[t.toLowerCase()]:void 0,"keywordShape"),O0=d(t=>{const e=Gt(t.shape)??Gt(t.sprite);if(e)return e;if(t.tags)for(const a of t.tags.split(",")){const u=Gt(a.trim());if(u)return u}const r=t.typeC4Shape.text;return r==="person"||r==="external_person"?"person":R0.has(r)?"cylinder":C0.has(r)?"h-cyl":"rounded"},"resolveNodeShape"),P0={person:"Person",system:"Software System",container:"Container",component:"Component"},D0=d(t=>{const e=t.replace(/^external_/,"").replace(/_(db|queue)$/,"");return P0[e]??e.replace(/_/g," ")},"stereotypeLabel"),N0=d(t=>t.startsWith("external_"),"isExternal"),A0=d(t=>{const e=D0(t.typeC4Shape.text);return t.techn?.text?`[${e}: ${t.techn.text}]`:`[${e}]`},"stereotypeText"),Ee=["person","system","system_db","system_queue","container","container_db","container_queue","component","component_db","component_queue"].flatMap(t=>[t,`external_${t}`]),L0=new Set(Ee),he=d(t=>L0.has(t),"isC4ElementType"),I0=d((t,e)=>{const r=t.typeC4Shape.text,a=t.bgColor??(he(r)&&e[`${r}_bg_color`]),u=t.borderColor??(he(r)&&e[`${r}_border_color`]),i=[];return a&&i.push(`fill:${a}`),u&&i.push(`stroke:${u}`),i.push(`color:${t.fontColor??"#FFFFFF"}`),i},"elementCssStyles"),de=d((t,e,r,a,u)=>{const i=t.typeC4Shape.text,n=["c4-shape",`c4-${i}`];N0(i)&&n.push("c4-external");const l=O0(t),s=I0(t,e);return(l==="rounded"||l==="fr-rect")&&s.push("rx:12px","ry:12px"),{id:t.alias,label:t.label.text,stereotype:A0(t),description:t.descr?.text?[t.descr.text]:void 0,labelType:"string",isGroup:!1,shape:l,cssClasses:n.join(" "),cssStyles:s,padding:r,look:a,useHtmlLabels:!1,width:u}},"buildC4Node"),Dt=0,Nt=0,Se=4,$t=2;Yt.yy=Zt;var g={},ke=class{static{d(this,"Bounds")}constructor(t){this.name="",this.data={},this.data.startx=void 0,this.data.stopx=void 0,this.data.starty=void 0,this.data.stopy=void 0,this.data.widthLimit=void 0,this.nextData={},this.nextData.startx=void 0,this.nextData.stopx=void 0,this.nextData.starty=void 0,this.nextData.stopy=void 0,this.nextData.cnt=0,te(t.db.getConfig())}setData(t,e,r,a){this.nextData.startx=this.data.startx=t,this.nextData.stopx=this.data.stopx=e,this.nextData.starty=this.data.starty=r,this.nextData.stopy=this.data.stopy=a}updateVal(t,e,r,a){t[e]===void 0?t[e]=r:t[e]=a(r,t[e])}insert(t){this.nextData.cnt=this.nextData.cnt+1;const e=this.nextData.stopx,r=this.data.widthLimit;let a=this.nextData.startx===this.nextData.stopx?e+t.margin:e+t.margin*2,u=a+t.width,i=this.nextData.starty+t.margin*2,n=i+t.height;(a>=r||u>=r||this.nextData.cnt>Se)&&(a=this.nextData.startx+t.margin+g.nextLinePaddingX,i=this.nextData.stopy+t.margin*2,this.nextData.stopx=u=a+t.width,this.nextData.starty=this.nextData.stopy,this.nextData.stopy=n=i+t.height,this.nextData.cnt=1),t.x=a,t.y=i,this.updateVal(this.data,"startx",a,Math.min),this.updateVal(this.data,"starty",i,Math.min),this.updateVal(this.data,"stopx",u,Math.max),this.updateVal(this.data,"stopy",n,Math.max),this.updateVal(this.nextData,"startx",a,Math.min),this.updateVal(this.nextData,"starty",i,Math.min),this.updateVal(this.nextData,"stopx",u,Math.max),this.updateVal(this.nextData,"stopy",n,Math.max)}init(t){this.name="",this.data={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0,widthLimit:void 0},this.nextData={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0,cnt:0},te(t.db.getConfig())}bumpLastMargin(t){this.data.stopx+=t,this.data.stopy+=t}},te=d(function(t){Ve(g,t),t?.fontFamily&&(g.personFontFamily=g.systemFontFamily=g.messageFontFamily=t.fontFamily),t?.fontSize&&(g.personFontSize=g.systemFontSize=g.messageFontSize=t.fontSize),t?.fontWeight&&(g.personFontWeight=g.systemFontWeight=g.messageFontWeight=t.fontWeight)},"setConf"),Vt=d(t=>({fontFamily:t.boundaryFontFamily,fontSize:t.boundaryFontSize,fontWeight:t.boundaryFontWeight}),"boundaryFont"),M0=d(t=>({fontFamily:t.messageFontFamily,fontSize:t.messageFontSize,fontWeight:t.messageFontWeight}),"messageFont");function bt(t,e,r,a,u){const i=e[t];if(!i.width)if(r)i.text=Fe(i.text,u,a),i.textLines=i.text.split(Jt.lineBreakRegex).length,i.width=u,i.height=ue(i.text,a);else{const n=i.text.split(Jt.lineBreakRegex);i.textLines=n.length;let l=0;i.height=0,i.width=0;for(const s of n)i.width=Math.max(Ot(s,a),i.width),l=ue(s,a),i.height=i.height+l}return i}d(bt,"calcC4ShapeTextWH");var Te=d(function(t,e,r){const a=r.data.startx,u=r.data.starty;e.x=a,e.y=u,e.width=r.data.stopx-a,e.height=r.data.stopy-u,e.label.y=g.c4ShapeMargin-35;const i=e.wrap&&g.wrap,n=Vt(g);n.fontSize=n.fontSize+2,n.fontWeight="bold";const l=Ot(e.label.text,n);bt("label",e,i,n,l),z.drawBoundary(t,e,g)},"drawBoundary"),Ce=d(async function(t,e,r,a){const u=Ct(),i=u.look??"classic",n={config:u},l=e.attr("id")??"",s=a.map(y=>r[Number(y)]),h=d(y=>{const f=y.shape?Ye[y.shape]:void 0;if(!f)throw new Error(`C4: no shape handler for "${y.shape}"`);return f},"shapeHandlerFor");await Promise.all(s.map(async y=>{const f=de(y,g,g.c4ShapePadding,i,g.width);f.domId=`${l}-${f.id}`;const b=await h(f)(e,f,n);y.width=f.width??g.width,y.height=f.height??g.height,y.margin=g.c4ShapeMargin,b.remove()}));for(const y of s)t.insert(y);await Promise.all(s.map(async y=>{const f=de(y,g,g.c4ShapePadding,i,g.width);f.domId=`${l}-${f.id}`,f.x=y.x+y.width/2,f.y=y.y+y.height/2;const b=e.append("g").attr("transform",`translate(${y.x+y.width/2}, ${y.y+y.height/2})`);await h(f)(b,f,n),y.intersect=f.intersect})),t.bumpLastMargin(g.c4ShapeMargin)},"drawC4ShapeArray"),B0=class{static{d(this,"Point")}constructor(t,e){this.x=t,this.y=e}},pe=d(function(t,e){if(!t.intersect)throw new Error(`C4 shape "${t.alias}" has no intersect function. Please report this to https://github.com/mermaid-js/mermaid/issues`);const{x:r,y:a}=t.intersect(e);return new B0(r,a)},"getIntersectPoint"),V0=d(function(t,e){const r={x:0,y:0};r.x=e.x+e.width/2,r.y=e.y+e.height/2;const a=pe(t,r);r.x=t.x+t.width/2,r.y=t.y+t.height/2;const u=pe(e,r);return{startPoint:a,endPoint:u}},"getIntersectPoints"),Y0=d(function(t,e,r,a,u){const i=a.db.getC4Type();let n=0;for(const l of e){n=n+1;const s=l.wrap&&g.wrap,h=M0(g);i==="C4Dynamic"&&(l.label.text=n+": "+l.label.text);let y=Ot(l.label.text,h);bt("label",l,s,h,y),l.techn&&l.techn.text!==""&&(y=Ot(l.techn.text,h),bt("techn",l,s,h,y)),l.descr&&l.descr.text!==""&&(y=Ot(l.descr.text,h),bt("descr",l,s,h,y));const f=r(l.from),b=r(l.to);if(!f||!b)throw new Error(`C4 rel "${l.from}" -> "${l.to}" references an unknown shape`);const v=V0(f,b);if(!v.startPoint||!v.endPoint)throw new Error(`Could not calculate intersection points for rel "${l.from}" -> "${l.to}"`);l.startPoint=v.startPoint,l.endPoint=v.endPoint}z.drawRels(t,e,g,u)},"drawRels");async function se(t,e,r,a,u){const i=u.db,n=new ke(u);n.data.widthLimit=r.data.widthLimit/Math.min($t,a.length);for(const[l,s]of a.entries()){let h=0;s.image={width:0,height:0,Y:0},s.sprite&&(s.image.width=48,s.image.height=48,s.image.Y=h,h=s.image.Y+s.image.height);const y=s.wrap&&g.wrap,f=Vt(g);f.fontSize=f.fontSize+2,f.fontWeight="bold";const b=bt("label",s,y,f,n.data.widthLimit);if(b.Y=h+8,h=b.Y+b.height,s.type&&s.type.text!==""){s.type.text="["+s.type.text+"]";const O=Vt(g),P=bt("type",s,y,O,n.data.widthLimit);P.Y=h+5,h=P.Y+P.height}if(s.descr&&s.descr.text!==""){const O=Vt(g);O.fontSize=O.fontSize-2;const P=bt("descr",s,y,O,n.data.widthLimit);P.Y=h+20,h=P.Y+P.height}if(l==0||l%$t===0){const O=r.data.startx+g.diagramMarginX,P=r.data.stopy+g.diagramMarginY+h;n.setData(O,O,P,P)}else{const O=n.data.stopx!==n.data.startx?n.data.stopx+g.diagramMarginX:n.data.startx,P=n.data.starty;n.setData(O,O,P,P)}n.name=s.alias;const v=i.getC4ShapeArray(s.alias),w=i.getC4ShapeKeys(s.alias);w.length>0&&await Ce(n,t,v,w),e=s.alias;const N=i.getBoundaries(e);N.length>0&&await se(t,e,n,N,u),s.alias!=="global"&&Te(t,s,n),r.data.stopy=Math.max(n.data.stopy+g.c4ShapeMargin,r.data.stopy),r.data.stopx=Math.max(n.data.stopx+g.c4ShapeMargin,r.data.stopx),Dt=Math.max(Dt,r.data.stopx),Nt=Math.max(Nt,r.data.stopy)}}d(se,"drawInsideBoundary");var F0=d(async function(t,e,r,a){g=_e("c4");const u=Ct().securityLevel,{root:i}=T0(e,u),n=a.db;n.setWrap(g.wrap),Se=n.getC4ShapeInRow(),$t=n.getC4BoundaryInRow(),ce.debug(`C:${JSON.stringify(g,null,2)}`);const l=i.select(`[id="${e}"]`);z.insertComputerIcon(l,e),z.insertDatabaseIcon(l,e),z.insertClockIcon(l,e);const s=new ke(a);s.setData(g.diagramMarginX,g.diagramMarginX,g.diagramMarginY,g.diagramMarginY),s.data.widthLimit=screen.availWidth,Dt=g.diagramMarginX,Nt=g.diagramMarginY;const h=n.getTitle(),y=n.getBoundaries("");await se(l,"",s,y,a),z.insertArrowHead(l,e),z.insertArrowEnd(l,e),z.insertArrowCrossHead(l,e),z.insertArrowFilledHead(l,e),Y0(l,n.getRels(),n.getC4Shape,a,e),s.data.stopx=Dt,s.data.stopy=Nt;const f=s.data,b=f.startx,v=f.starty,N=Nt-v+2*g.diagramMarginY,O=Dt-b,P=O+2*g.diagramMarginX;h&&l.append("text").text(h).attr("x",O/2-4*g.diagramMarginX).attr("y",v+g.diagramMarginY),Be(l,N,P,g.useMaxWidth);const I=h?60:0;l.attr("viewBox",b-g.diagramMarginX+" -"+(g.diagramMarginY+I)+" "+P+" "+(N+I)),ce.debug("models:",f)},"draw"),fe={drawPersonOrSystemArray:Ce,drawBoundary:Te,setConf:te,draw:F0},U0=d(()=>{const t=Ct().c4??{},e=new CSSStyleSheet;for(const r of Ee){const a=e.cssRules[e.insertRule(`.c4-shape.c4-${r} .label {}`,e.cssRules.length)],u=t[`${r}FontFamily`],i=t[`${r}FontSize`],n=t[`${r}FontWeight`];u&&a.style.setProperty("font-family",u),i&&a.style.setProperty("font-size",typeof i=="number"?`${i}px`:i),n&&a.style.setProperty("font-weight",String(n))}return[...e.cssRules].filter(r=>r.style.length>0).map(r=>` ${r.cssText}`).join(` +`)},"elementFontStyles"),j0=d(t=>`.person { + stroke: ${t.personBorder}; + fill: ${t.personBkg}; + } +${U0()} + + /* The element font colour is set inline per element (default white); the + label text takes it via currentColor. */ + .c4-shape .label, + .c4-shape .label text { + color: inherit; + fill: currentColor; + } + /* Structurizr typography: bold name, smaller stereotype/type and description lines. */ + .c4-shape .label .c4-name { + font-weight: bold; + } + .c4-shape .label .c4-type { + font-size: 0.75em; + } + .c4-shape .label .c4-descr { + font-size: 0.82em; + } + .c4-shape .basic, + .c4-shape rect, + .c4-shape path, + .c4-shape circle, + .c4-shape ellipse, + .c4-shape line { + stroke-width: 2px; + } +`,"getStyles"),z0=j0,Q0={parser:Ue,db:Zt,renderer:fe,styles:z0,init:d(({c4:t,wrap:e})=>{fe.setConf(t),Zt.setWrap(e)},"init")};export{Q0 as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/channel.DScgq80D.js b/packages/tempo/public/v4/assets/chunks/channel.DScgq80D.js new file mode 100644 index 00000000..8a0508e5 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/channel.DScgq80D.js @@ -0,0 +1 @@ +import{U as a,C as n}from"../app.CbekdYod.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-2Q5K7J3B.3yPGAHkH.js b/packages/tempo/public/v4/assets/chunks/chunk-2Q5K7J3B.3yPGAHkH.js new file mode 100644 index 00000000..0b729c81 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-2Q5K7J3B.3yPGAHkH.js @@ -0,0 +1 @@ +import{_ as i}from"../app.CbekdYod.js";var r=class{constructor(t){this.init=t,this.records=this.init()}static{i(this,"ImperativeState")}reset(){this.records=this.init()}};export{r as I}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-5VM5RSS4.-zPOtr2J.js b/packages/tempo/public/v4/assets/chunks/chunk-5VM5RSS4.-zPOtr2J.js new file mode 100644 index 00000000..cf987a62 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-5VM5RSS4.-zPOtr2J.js @@ -0,0 +1,15 @@ +import{_ as e}from"../app.CbekdYod.js";var l=e(()=>` + /* Font Awesome icon styling - consolidated */ + .label-icon { + display: inline-block; + height: 1em; + overflow: visible; + vertical-align: -0.125em; + } + + .node .label-icon path { + fill: currentColor; + stroke: revert; + stroke-width: revert; + } +`,"getIconStyles");export{l as g}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-F27PBJKO.CcniKEe6.js b/packages/tempo/public/v4/assets/chunks/chunk-F27PBJKO.CcniKEe6.js new file mode 100644 index 00000000..d6b6d31c --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-F27PBJKO.CcniKEe6.js @@ -0,0 +1 @@ +import{_ as n,j as l,n as d,o}from"../app.CbekdYod.js";var x=n((r,t)=>{const e=r.append("rect");if(e.attr("x",t.x),e.attr("y",t.y),e.attr("fill",t.fill),e.attr("stroke",t.stroke),e.attr("width",t.width),e.attr("height",t.height),t.name&&e.attr("name",t.name),t.rx&&e.attr("rx",t.rx),t.ry&&e.attr("ry",t.ry),t.attrs!==void 0)for(const s in t.attrs)e.attr(s,t.attrs[s]);return t.class&&e.attr("class",t.class),e},"drawRect"),p=n((r,t)=>{const e={x:t.startx,y:t.starty,width:t.stopx-t.startx,height:t.stopy-t.starty,fill:t.fill,stroke:t.stroke,class:"rect"};x(r,e).lower()},"drawBackgroundRect"),y=n((r,t)=>{const e=t.text.replace(d," "),s=r.append("text");s.attr("x",t.x),s.attr("y",t.y),s.attr("class","legend"),s.style("text-anchor",t.anchor),t.class&&s.attr("class",t.class);const a=s.append("tspan");return a.attr("x",t.x+t.textMargin*2),a.text(e),s},"drawText"),m=n((r,t,e,s)=>{const a=r.append("image");a.attr("x",t),a.attr("y",e);const i=o(s);a.attr("xlink:href",i)},"drawImage"),g=n((r,t,e,s)=>{const a=r.append("use");a.attr("x",t),a.attr("y",e);const i=o(s);a.attr("xlink:href",`#${i}`)},"drawEmbeddedImage"),h=n(()=>({x:0,y:0,width:100,height:100,fill:"#EDF2AE",stroke:"#666",anchor:"start",rx:0,ry:0}),"getNoteRect"),f=n(()=>({x:0,y:0,width:100,height:100,"text-anchor":"start",style:"#666",textMargin:0,rx:0,ry:0,tspan:!0}),"getTextObj"),w=n(()=>{let r=l(".mermaidTooltip");return r.empty()&&(r=l("body").append("div").attr("class","mermaidTooltip").style("opacity",0).style("position","absolute").style("text-align","center").style("max-width","200px").style("padding","2px").style("font-size","12px").style("background","#ffffde").style("border","1px solid #333").style("border-radius","2px").style("pointer-events","none").style("z-index","100")),r},"createTooltip");export{p as a,h as b,g as c,x as d,m as e,w as f,f as g,y as h}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-IMKFNOWR.GyfNfwKa.js b/packages/tempo/public/v4/assets/chunks/chunk-IMKFNOWR.GyfNfwKa.js new file mode 100644 index 00000000..d6106b7d --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-IMKFNOWR.GyfNfwKa.js @@ -0,0 +1,231 @@ +import{g as te}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as ee}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as f,l as _,c as $,y as se,z as ie,a as re,b as ae,g as ne,s as oe,p as le,q as ce,ab as he,k as j,r as ue,j as bt,a6 as de}from"../app.CbekdYod.js";import{f as fe}from"./chunk-F27PBJKO.CcniKEe6.js";var vt=(function(){var t=f(function(V,a,u,r){for(u=u||{},r=V.length;r--;u[V[r]]=a);return u},"o"),e=[1,2],o=[1,3],s=[1,4],c=[2,4],h=[1,9],p=[1,11],y=[1,16],n=[1,17],T=[1,18],m=[1,19],N=[1,33],x=[1,20],k=[1,21],d=[1,22],L=[1,23],R=[1,24],v=[1,26],F=[1,27],C=[1,28],P=[1,29],I=[1,30],H=[1,31],it=[1,32],rt=[1,35],at=[1,36],nt=[1,37],ot=[1,38],z=[1,34],S=[1,4,5,16,17,19,21,22,24,25,26,27,28,29,33,35,37,38,41,45,48,51,52,53,54,57],lt=[1,4,5,14,15,16,17,19,21,22,24,25,26,27,28,29,33,35,37,38,39,40,41,45,48,51,52,53,54,57],xt=[4,5,16,17,19,21,22,24,25,26,27,28,29,33,35,37,38,41,45,48,51,52,53,54,57],yt={trace:f(function(){},"trace"),yy:{},symbols_:{error:2,start:3,SPACE:4,NL:5,SD:6,document:7,line:8,statement:9,classDefStatement:10,styleStatement:11,cssClassStatement:12,idStatement:13,DESCR:14,"-->":15,HIDE_EMPTY:16,scale:17,WIDTH:18,COMPOSIT_STATE:19,STRUCT_START:20,STRUCT_STOP:21,STATE_DESCR:22,AS:23,ID:24,FORK:25,JOIN:26,CHOICE:27,CONCURRENT:28,note:29,notePosition:30,NOTE_TEXT:31,direction:32,acc_title:33,acc_title_value:34,acc_descr:35,acc_descr_value:36,acc_descr_multiline_value:37,CLICK:38,STRING:39,HREF:40,classDef:41,CLASSDEF_ID:42,CLASSDEF_STYLEOPTS:43,DEFAULT:44,style:45,STYLE_IDS:46,STYLEDEF_STYLEOPTS:47,class:48,CLASSENTITY_IDS:49,STYLECLASS:50,direction_tb:51,direction_bt:52,direction_rl:53,direction_lr:54,eol:55,";":56,EDGE_STATE:57,STYLE_SEPARATOR:58,left_of:59,right_of:60,$accept:0,$end:1},terminals_:{2:"error",4:"SPACE",5:"NL",6:"SD",14:"DESCR",15:"-->",16:"HIDE_EMPTY",17:"scale",18:"WIDTH",19:"COMPOSIT_STATE",20:"STRUCT_START",21:"STRUCT_STOP",22:"STATE_DESCR",23:"AS",24:"ID",25:"FORK",26:"JOIN",27:"CHOICE",28:"CONCURRENT",29:"note",31:"NOTE_TEXT",33:"acc_title",34:"acc_title_value",35:"acc_descr",36:"acc_descr_value",37:"acc_descr_multiline_value",38:"CLICK",39:"STRING",40:"HREF",41:"classDef",42:"CLASSDEF_ID",43:"CLASSDEF_STYLEOPTS",44:"DEFAULT",45:"style",46:"STYLE_IDS",47:"STYLEDEF_STYLEOPTS",48:"class",49:"CLASSENTITY_IDS",50:"STYLECLASS",51:"direction_tb",52:"direction_bt",53:"direction_rl",54:"direction_lr",56:";",57:"EDGE_STATE",58:"STYLE_SEPARATOR",59:"left_of",60:"right_of"},productions_:[0,[3,2],[3,2],[3,2],[7,0],[7,2],[8,2],[8,1],[8,1],[9,1],[9,1],[9,1],[9,1],[9,2],[9,3],[9,4],[9,1],[9,2],[9,1],[9,4],[9,3],[9,6],[9,1],[9,1],[9,1],[9,1],[9,4],[9,4],[9,1],[9,2],[9,2],[9,1],[9,5],[9,5],[10,3],[10,3],[11,3],[12,3],[32,1],[32,1],[32,1],[32,1],[55,1],[55,1],[13,1],[13,1],[13,3],[13,3],[30,1],[30,1]],performAction:f(function(a,u,r,g,E,i,B){var l=i.length-1;switch(E){case 3:return g.setRootDoc(i[l]),i[l];case 4:this.$=[];break;case 5:i[l]!="nl"&&(i[l-1].push(i[l]),this.$=i[l-1]);break;case 6:case 7:this.$=i[l];break;case 8:this.$="nl";break;case 12:this.$=i[l];break;case 13:const Q=i[l-1];Q.description=g.trimColon(i[l]),this.$=Q;break;case 14:this.$={stmt:"relation",state1:i[l-2],state2:i[l]};break;case 15:const gt=g.trimColon(i[l]);this.$={stmt:"relation",state1:i[l-3],state2:i[l-1],description:gt};break;case 19:this.$={stmt:"state",id:i[l-3],type:"default",description:"",doc:i[l-1]};break;case 20:var Y=i[l],K=i[l-2].trim();if(i[l].match(":")){var ht=i[l].split(":");Y=ht[0],K=[K,ht[1]]}this.$={stmt:"state",id:Y,type:"default",description:K};break;case 21:this.$={stmt:"state",id:i[l-3],type:"default",description:i[l-5],doc:i[l-1]};break;case 22:this.$={stmt:"state",id:i[l],type:"fork"};break;case 23:this.$={stmt:"state",id:i[l],type:"join"};break;case 24:this.$={stmt:"state",id:i[l],type:"choice"};break;case 25:this.$={stmt:"state",id:g.getDividerId(),type:"divider"};break;case 26:this.$={stmt:"state",id:i[l-1].trim(),note:{position:i[l-2].trim(),text:i[l].trim()}};break;case 29:this.$=i[l].trim(),g.setAccTitle(this.$);break;case 30:case 31:this.$=i[l].trim(),g.setAccDescription(this.$);break;case 32:this.$={stmt:"click",id:i[l-3],url:i[l-2],tooltip:i[l-1]};break;case 33:this.$={stmt:"click",id:i[l-3],url:i[l-1],tooltip:""};break;case 34:case 35:this.$={stmt:"classDef",id:i[l-1].trim(),classes:i[l].trim()};break;case 36:this.$={stmt:"style",id:i[l-1].trim(),styleClass:i[l].trim()};break;case 37:this.$={stmt:"applyClass",id:i[l-1].trim(),styleClass:i[l].trim()};break;case 38:g.setDirection("TB"),this.$={stmt:"dir",value:"TB"};break;case 39:g.setDirection("BT"),this.$={stmt:"dir",value:"BT"};break;case 40:g.setDirection("RL"),this.$={stmt:"dir",value:"RL"};break;case 41:g.setDirection("LR"),this.$={stmt:"dir",value:"LR"};break;case 44:case 45:this.$={stmt:"state",id:i[l].trim(),type:"default",description:""};break;case 46:this.$={stmt:"state",id:i[l-2].trim(),classes:[i[l].trim()],type:"default",description:""};break;case 47:this.$={stmt:"state",id:i[l-2].trim(),classes:[i[l].trim()],type:"default",description:""};break}},"anonymous"),table:[{3:1,4:e,5:o,6:s},{1:[3]},{3:5,4:e,5:o,6:s},{3:6,4:e,5:o,6:s},t([1,4,5,16,17,19,22,24,25,26,27,28,29,33,35,37,38,41,45,48,51,52,53,54,57],c,{7:7}),{1:[2,1]},{1:[2,2]},{1:[2,3],4:h,5:p,8:8,9:10,10:12,11:13,12:14,13:15,16:y,17:n,19:T,22:m,24:N,25:x,26:k,27:d,28:L,29:R,32:25,33:v,35:F,37:C,38:P,41:I,45:H,48:it,51:rt,52:at,53:nt,54:ot,57:z},t(S,[2,5]),{9:39,10:12,11:13,12:14,13:15,16:y,17:n,19:T,22:m,24:N,25:x,26:k,27:d,28:L,29:R,32:25,33:v,35:F,37:C,38:P,41:I,45:H,48:it,51:rt,52:at,53:nt,54:ot,57:z},t(S,[2,7]),t(S,[2,8]),t(S,[2,9]),t(S,[2,10]),t(S,[2,11]),t(S,[2,12],{14:[1,40],15:[1,41]}),t(S,[2,16]),{18:[1,42]},t(S,[2,18],{20:[1,43]}),{23:[1,44]},t(S,[2,22]),t(S,[2,23]),t(S,[2,24]),t(S,[2,25]),{30:45,31:[1,46],59:[1,47],60:[1,48]},t(S,[2,28]),{34:[1,49]},{36:[1,50]},t(S,[2,31]),{13:51,24:N,57:z},{42:[1,52],44:[1,53]},{46:[1,54]},{49:[1,55]},t(lt,[2,44],{58:[1,56]}),t(lt,[2,45],{58:[1,57]}),t(S,[2,38]),t(S,[2,39]),t(S,[2,40]),t(S,[2,41]),t(S,[2,6]),t(S,[2,13]),{13:58,24:N,57:z},t(S,[2,17]),t(xt,c,{7:59}),{24:[1,60]},{24:[1,61]},{23:[1,62]},{24:[2,48]},{24:[2,49]},t(S,[2,29]),t(S,[2,30]),{39:[1,63],40:[1,64]},{43:[1,65]},{43:[1,66]},{47:[1,67]},{50:[1,68]},{24:[1,69]},{24:[1,70]},t(S,[2,14],{14:[1,71]}),{4:h,5:p,8:8,9:10,10:12,11:13,12:14,13:15,16:y,17:n,19:T,21:[1,72],22:m,24:N,25:x,26:k,27:d,28:L,29:R,32:25,33:v,35:F,37:C,38:P,41:I,45:H,48:it,51:rt,52:at,53:nt,54:ot,57:z},t(S,[2,20],{20:[1,73]}),{31:[1,74]},{24:[1,75]},{39:[1,76]},{39:[1,77]},t(S,[2,34]),t(S,[2,35]),t(S,[2,36]),t(S,[2,37]),t(lt,[2,46]),t(lt,[2,47]),t(S,[2,15]),t(S,[2,19]),t(xt,c,{7:78}),t(S,[2,26]),t(S,[2,27]),{5:[1,79]},{5:[1,80]},{4:h,5:p,8:8,9:10,10:12,11:13,12:14,13:15,16:y,17:n,19:T,21:[1,81],22:m,24:N,25:x,26:k,27:d,28:L,29:R,32:25,33:v,35:F,37:C,38:P,41:I,45:H,48:it,51:rt,52:at,53:nt,54:ot,57:z},t(S,[2,32]),t(S,[2,33]),t(S,[2,21])],defaultActions:{5:[2,1],6:[2,2],47:[2,48],48:[2,49]},parseError:f(function(a,u){if(u.recoverable)this.trace(a);else{var r=new Error(a);throw r.hash=u,r}},"parseError"),parse:f(function(a){var u=this,r=[0],g=[],E=[null],i=[],B=this.table,l="",Y=0,K=0,ht=2,Q=1,gt=i.slice.call(arguments,1),b=Object.create(this.lexer),U={yy:{}};for(var Tt in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Tt)&&(U.yy[Tt]=this.yy[Tt]);b.setInput(a,U.yy),U.yy.lexer=b,U.yy.parser=this,typeof b.yylloc>"u"&&(b.yylloc={});var Et=b.yylloc;i.push(Et);var Qt=b.options&&b.options.ranges;typeof U.yy.parseError=="function"?this.parseError=U.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function Zt(w){r.length=r.length-2*w,E.length=E.length-w,i.length=i.length-w}f(Zt,"popStack");function Lt(){var w;return w=g.pop()||b.lex()||Q,typeof w!="number"&&(w instanceof Array&&(g=w,w=g.pop()),w=u.symbols_[w]||w),w}f(Lt,"lex");for(var A,W,O,_t,X={},ut,G,It,dt;;){if(W=r[r.length-1],this.defaultActions[W]?O=this.defaultActions[W]:((A===null||typeof A>"u")&&(A=Lt()),O=B[W]&&B[W][A]),typeof O>"u"||!O.length||!O[0]){var mt="";dt=[];for(ut in B[W])this.terminals_[ut]&&ut>ht&&dt.push("'"+this.terminals_[ut]+"'");b.showPosition?mt="Parse error on line "+(Y+1)+`: +`+b.showPosition()+` +Expecting `+dt.join(", ")+", got '"+(this.terminals_[A]||A)+"'":mt="Parse error on line "+(Y+1)+": Unexpected "+(A==Q?"end of input":"'"+(this.terminals_[A]||A)+"'"),this.parseError(mt,{text:b.match,token:this.terminals_[A]||A,line:b.yylineno,loc:Et,expected:dt})}if(O[0]instanceof Array&&O.length>1)throw new Error("Parse Error: multiple actions possible at state: "+W+", token: "+A);switch(O[0]){case 1:r.push(A),E.push(b.yytext),i.push(b.yylloc),r.push(O[1]),A=null,K=b.yyleng,l=b.yytext,Y=b.yylineno,Et=b.yylloc;break;case 2:if(G=this.productions_[O[1]][1],X.$=E[E.length-G],X._$={first_line:i[i.length-(G||1)].first_line,last_line:i[i.length-1].last_line,first_column:i[i.length-(G||1)].first_column,last_column:i[i.length-1].last_column},Qt&&(X._$.range=[i[i.length-(G||1)].range[0],i[i.length-1].range[1]]),_t=this.performAction.apply(X,[l,K,Y,U.yy,O[1],E,i].concat(gt)),typeof _t<"u")return _t;G&&(r=r.slice(0,-1*G*2),E=E.slice(0,-1*G),i=i.slice(0,-1*G)),r.push(this.productions_[O[1]][0]),E.push(X.$),i.push(X._$),It=B[r[r.length-2]][r[r.length-1]],r.push(It);break;case 3:return!0}}return!0},"parse")},qt=(function(){var V={EOF:1,parseError:f(function(u,r){if(this.yy.parser)this.yy.parser.parseError(u,r);else throw new Error(u)},"parseError"),setInput:f(function(a,u){return this.yy=u||this.yy||{},this._input=a,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:f(function(){var a=this._input[0];this.yytext+=a,this.yyleng++,this.offset++,this.match+=a,this.matched+=a;var u=a.match(/(?:\r\n?|\n).*/g);return u?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),a},"input"),unput:f(function(a){var u=a.length,r=a.split(/(?:\r\n?|\n)/g);this._input=a+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-u),this.offset-=u;var g=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),r.length-1&&(this.yylineno-=r.length-1);var E=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:r?(r.length===g.length?this.yylloc.first_column:0)+g[g.length-r.length].length-r[0].length:this.yylloc.first_column-u},this.options.ranges&&(this.yylloc.range=[E[0],E[0]+this.yyleng-u]),this.yyleng=this.yytext.length,this},"unput"),more:f(function(){return this._more=!0,this},"more"),reject:f(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:f(function(a){this.unput(this.match.slice(a))},"less"),pastInput:f(function(){var a=this.matched.substr(0,this.matched.length-this.match.length);return(a.length>20?"...":"")+a.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:f(function(){var a=this.match;return a.length<20&&(a+=this._input.substr(0,20-a.length)),(a.substr(0,20)+(a.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:f(function(){var a=this.pastInput(),u=new Array(a.length+1).join("-");return a+this.upcomingInput()+` +`+u+"^"},"showPosition"),test_match:f(function(a,u){var r,g,E;if(this.options.backtrack_lexer&&(E={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(E.yylloc.range=this.yylloc.range.slice(0))),g=a[0].match(/(?:\r\n?|\n).*/g),g&&(this.yylineno+=g.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:g?g[g.length-1].length-g[g.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+a[0].length},this.yytext+=a[0],this.match+=a[0],this.matches=a,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(a[0].length),this.matched+=a[0],r=this.performAction.call(this,this.yy,this,u,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),r)return r;if(this._backtrack){for(var i in E)this[i]=E[i];return!1}return!1},"test_match"),next:f(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var a,u,r,g;this._more||(this.yytext="",this.match="");for(var E=this._currentRules(),i=0;iu[0].length)){if(u=r,g=i,this.options.backtrack_lexer){if(a=this.test_match(r,E[i]),a!==!1)return a;if(this._backtrack){u=!1;continue}else return!1}else if(!this.options.flex)break}return u?(a=this.test_match(u,E[g]),a!==!1?a:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:f(function(){var u=this.next();return u||this.lex()},"lex"),begin:f(function(u){this.conditionStack.push(u)},"begin"),popState:f(function(){var u=this.conditionStack.length-1;return u>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:f(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:f(function(u){return u=this.conditionStack.length-1-Math.abs(u||0),u>=0?this.conditionStack[u]:"INITIAL"},"topState"),pushState:f(function(u){this.begin(u)},"pushState"),stateStackSize:f(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:f(function(u,r,g,E){function i(){const B=r.yytext.indexOf("%%");if(B===0)return!1;if(B>0){const l=r.yytext.slice(0,B),Y=r.yytext.slice(B);Y&&u.lexer.unput(Y),r.yytext=l}return!0}switch(f(i,"processId"),g){case 0:return 38;case 1:return 40;case 2:return 39;case 3:return 44;case 4:return 51;case 5:return 52;case 6:return 53;case 7:return 54;case 8:return 5;case 9:break;case 10:break;case 11:break;case 12:break;case 13:return this.pushState("SCALE"),17;case 14:return 18;case 15:this.popState();break;case 16:return this.begin("acc_title"),33;case 17:return this.popState(),"acc_title_value";case 18:return this.begin("acc_descr"),35;case 19:return this.popState(),"acc_descr_value";case 20:this.begin("acc_descr_multiline");break;case 21:this.popState();break;case 22:return"acc_descr_multiline_value";case 23:return this.pushState("CLASSDEF"),41;case 24:return this.popState(),this.pushState("CLASSDEFID"),"DEFAULT_CLASSDEF_ID";case 25:return this.popState(),this.pushState("CLASSDEFID"),42;case 26:return this.popState(),43;case 27:return this.pushState("CLASS"),48;case 28:return this.popState(),this.pushState("CLASS_STYLE"),49;case 29:return this.popState(),50;case 30:return this.pushState("STYLE"),45;case 31:return this.popState(),this.pushState("STYLEDEF_STYLES"),46;case 32:return this.popState(),47;case 33:return this.pushState("SCALE"),17;case 34:return 18;case 35:this.popState();break;case 36:this.pushState("STATE");break;case 37:return this.popState(),r.yytext=r.yytext.slice(0,-8).trim(),25;case 38:return this.popState(),r.yytext=r.yytext.slice(0,-8).trim(),26;case 39:return this.popState(),r.yytext=r.yytext.slice(0,-10).trim(),27;case 40:return this.popState(),r.yytext=r.yytext.slice(0,-8).trim(),25;case 41:return this.popState(),r.yytext=r.yytext.slice(0,-8).trim(),26;case 42:return this.popState(),r.yytext=r.yytext.slice(0,-10).trim(),27;case 43:return 51;case 44:return 52;case 45:return 53;case 46:return 54;case 47:this.pushState("STATE_STRING");break;case 48:return this.pushState("STATE_ID"),"AS";case 49:return i()?(this.popState(),"ID"):void 0;case 50:this.popState();break;case 51:return"STATE_DESCR";case 52:throw new Error('Error: State name must be a single word. Found: "'+r.yytext.trim()+'"');case 53:return 19;case 54:this.popState();break;case 55:return this.popState(),this.pushState("struct"),20;case 56:return this.popState(),21;case 57:break;case 58:return this.begin("NOTE"),29;case 59:return this.popState(),this.pushState("NOTE_ID"),59;case 60:return this.popState(),this.pushState("NOTE_ID"),60;case 61:this.popState(),this.pushState("FLOATING_NOTE");break;case 62:return this.popState(),this.pushState("FLOATING_NOTE_ID"),"AS";case 63:break;case 64:return"NOTE_TEXT";case 65:return i()?(this.popState(),"ID"):void 0;case 66:return i()?(this.popState(),this.pushState("NOTE_TEXT"),24):void 0;case 67:return this.popState(),r.yytext=r.yytext.substr(2).trim(),31;case 68:return this.popState(),r.yytext=r.yytext.slice(0,-8).trim(),31;case 69:return 6;case 70:return 6;case 71:return 16;case 72:return 57;case 73:return i()?24:void 0;case 74:return r.yytext=r.yytext.trim(),14;case 75:return 15;case 76:return 28;case 77:return 58;case 78:return 5;case 79:return"INVALID"}},"anonymous"),rules:[/^(?:click\b)/i,/^(?:href\b)/i,/^(?:"[^"]*")/i,/^(?:default\b)/i,/^(?:.*direction\s+TB[^\n]*)/i,/^(?:.*direction\s+BT[^\n]*)/i,/^(?:.*direction\s+RL[^\n]*)/i,/^(?:.*direction\s+LR[^\n]*)/i,/^(?:[\n]+)/i,/^(?:[\s]+)/i,/^(?:((?!\n)\s)+)/i,/^(?:#[^\n]*)/i,/^(?:%%(?!\{)[^\n]*)/i,/^(?:scale\s+)/i,/^(?:\d+)/i,/^(?:\s+width\b)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:classDef\s+)/i,/^(?:DEFAULT\s+)/i,/^(?:\w+\s+)/i,/^(?:[^\n]*)/i,/^(?:class\s+)/i,/^(?:(\w+)+((,\s*\w+)*))/i,/^(?:[^\n]*)/i,/^(?:style\s+)/i,/^(?:[\w,]+\s+)/i,/^(?:[^\n]*)/i,/^(?:scale\s+)/i,/^(?:\d+)/i,/^(?:\s+width\b)/i,/^(?:state\s+)/i,/^(?:.*<>)/i,/^(?:.*<>)/i,/^(?:.*<>)/i,/^(?:.*\[\[fork\]\])/i,/^(?:.*\[\[join\]\])/i,/^(?:.*\[\[choice\]\])/i,/^(?:.*direction\s+TB[^\n]*)/i,/^(?:.*direction\s+BT[^\n]*)/i,/^(?:.*direction\s+RL[^\n]*)/i,/^(?:.*direction\s+LR[^\n]*)/i,/^(?:["])/i,/^(?:\s*as\s+)/i,/^(?:[^\n\{]*)/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:\w+\s+\w+.*?\{)/i,/^(?:[^\n\s\{]+)/i,/^(?:\n)/i,/^(?:\{)/i,/^(?:\})/i,/^(?:[\n])/i,/^(?:note\s+)/i,/^(?:left of\b)/i,/^(?:right of\b)/i,/^(?:")/i,/^(?:\s*as\s*)/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:[^\n]*)/i,/^(?:\s*[^:\n\s\-]+)/i,/^(?:\s*:[^:\n;]+)/i,/^(?:[\s\S]*?\n\s*end note\b)/i,/^(?:stateDiagram\s+)/i,/^(?:stateDiagram-v2\s+)/i,/^(?:hide empty description\b)/i,/^(?:\[\*\])/i,/^(?:[^:\n\s\-\{]+)/i,/^(?:\s*:(?:[^:\n;]|:[^:\n;])+)/i,/^(?:-->)/i,/^(?:--)/i,/^(?::::)/i,/^(?:$)/i,/^(?:.)/i],conditions:{LINE:{rules:[10,11,12],inclusive:!1},struct:{rules:[10,11,12,23,27,30,36,43,44,45,46,56,57,58,72,73,74,75,76,77],inclusive:!1},FLOATING_NOTE_ID:{rules:[65],inclusive:!1},FLOATING_NOTE:{rules:[62,63,64],inclusive:!1},NOTE_TEXT:{rules:[67,68],inclusive:!1},NOTE_ID:{rules:[66],inclusive:!1},NOTE:{rules:[59,60,61],inclusive:!1},STYLEDEF_STYLEOPTS:{rules:[],inclusive:!1},STYLEDEF_STYLES:{rules:[32],inclusive:!1},STYLE_IDS:{rules:[],inclusive:!1},STYLE:{rules:[31],inclusive:!1},CLASS_STYLE:{rules:[29],inclusive:!1},CLASS:{rules:[28],inclusive:!1},CLASSDEFID:{rules:[26],inclusive:!1},CLASSDEF:{rules:[24,25],inclusive:!1},acc_descr_multiline:{rules:[21,22],inclusive:!1},acc_descr:{rules:[19],inclusive:!1},acc_title:{rules:[17],inclusive:!1},SCALE:{rules:[14,15,34,35],inclusive:!1},ALIAS:{rules:[],inclusive:!1},STATE_ID:{rules:[49],inclusive:!1},STATE_STRING:{rules:[50,51],inclusive:!1},FORK_STATE:{rules:[],inclusive:!1},STATE:{rules:[10,11,12,37,38,39,40,41,42,47,48,52,53,54,55],inclusive:!1},ID:{rules:[10,11,12],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8,9,11,12,13,16,18,20,23,27,30,33,36,55,58,69,70,71,72,73,74,75,77,78,79],inclusive:!0}}};return V})();yt.lexer=qt;function ct(){this.yy={}}return f(ct,"Parser"),ct.prototype=yt,yt.Parser=ct,new ct})();vt.parser=vt;var Ue=vt,pe="TB",Bt="TB",wt="dir",q="state",J="root",Ct="relation",Se="classDef",ye="style",ge="applyClass",et="default",Yt="divider",Gt="fill:none",Vt="fill: #333",Mt="c",Ut="markdown",Wt="normal",kt="rect",Dt="rectWithTitle",Te="stateStart",Ee="stateEnd",Nt="divider",Ot="roundedWithTitle",_e="note",me="noteGroup",st="statediagram",be="state",ke=`${st}-${be}`,jt="transition",De="note",ve="note-edge",Ce=`${jt} ${ve}`,Ae=`${st}-${De}`,xe="cluster",Le=`${st}-${xe}`,Ie="cluster-alt",we=`${st}-${Ie}`,Ht="parent",zt="note",Ne="state",At="----",Oe=`${At}${zt}`,Rt=`${At}${Ht}`,Kt=f((t,e=Bt)=>{if(!t.doc)return e;let o=e;for(const s of t.doc)s.stmt==="dir"&&(o=s.value);return o},"getDir"),Re=f(function(t,e){return e.db.getClasses()},"getClasses"),$e=f(async function(t,e,o,s){_.info("REF0:"),_.info("Drawing state diagram (v2)",e);const{securityLevel:c,state:h,layout:p}=$();s.db.extract(s.db.getRootDocV2());const y=s.db.getData(),n=te(e,c);y.type=s.type,y.layoutAlgorithm=p,y.nodeSpacing=h?.nodeSpacing||50,y.rankSpacing=h?.rankSpacing||50,$().look==="neo"?y.markers=["barbNeo"]:y.markers=["barb"],y.diagramId=e,await se(y,n);const m=8;try{(typeof s.db.getLinks=="function"?s.db.getLinks():new Map).forEach((x,k)=>{const d=typeof k=="string"?k:typeof k?.id=="string"?k.id:"",L=y.nodes.find(I=>I.id===d);if(!d){_.warn("⚠️ Invalid or missing stateId from key:",JSON.stringify(k));return}const R=n.node()?.querySelectorAll("g.node, g.rough-node");let v;if(R?.forEach(I=>{const H=I.textContent?.trim();(I.id===L?.domId||H===d)&&(v=I)}),!v){_.warn("⚠️ Could not find node matching text:",d);return}const F=v.parentNode;if(!F){_.warn("⚠️ Node has no parent, cannot wrap:",d);return}const C=document.createElementNS("http://www.w3.org/2000/svg","a"),P=x.url.replace(/^"+|"+$/g,"");if(C.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",P),C.setAttribute("target","_blank"),x.tooltip){const I=x.tooltip.replace(/^"+|"+$/g,"");C.setAttribute("title",I),v.setAttribute("title",I)}F.replaceChild(C,v),C.appendChild(v),_.info("🔗 Wrapped node in tag for:",d,x.url)})}catch(N){_.error("❌ Error injecting clickable links:",N)}ie.insertTitle(n,"statediagramTitleText",h?.titleTopMargin??25,s.db.getDiagramTitle()),ee(n,m,st,h?.useMaxWidth??!0)},"draw"),We={getClasses:Re,draw:$e,getDir:Kt},pt=new Map,M=0;function St(t="",e=0,o="",s=At){const c=o!==null&&o.length>0?`${s}${o}`:"";return`${Ne}-${t}${c}-${e}`}f(St,"stateDomId");var Fe=f((t,e,o,s,c,h,p,y)=>{_.trace("items",e),e.forEach(n=>{switch(n.stmt){case q:tt(t,n,o,s,c,h,p,y);break;case et:tt(t,n,o,s,c,h,p,y);break;case Ct:{tt(t,n.state1,o,s,c,h,p,y),tt(t,n.state2,o,s,c,h,p,y);const T=p==="neo",m={id:"edge"+M,start:n.state1.id,end:n.state2.id,arrowhead:"normal",arrowTypeEnd:T?"arrow_barb_neo":"arrow_barb",style:Gt,labelStyle:"",label:j.sanitizeText(n.description??"",$()),arrowheadStyle:Vt,labelpos:Mt,labelType:Ut,thickness:Wt,classes:jt,look:p};c.push(m),M++}break}})},"setupDoc"),$t=f((t,e=Bt)=>{let o=e;if(t.doc)for(const s of t.doc)s.stmt==="dir"&&(o=s.value);return o},"getDir");function Z(t,e,o){if(!e.id||e.id===""||e.id==="")return;e.cssClasses&&(Array.isArray(e.cssCompiledStyles)||(e.cssCompiledStyles=[]),e.cssClasses.split(" ").forEach(c=>{const h=o.get(c);h&&(e.cssCompiledStyles=[...e.cssCompiledStyles??[],...h.styles])}));const s=t.find(c=>c.id===e.id);s?Object.assign(s,e):t.push(e)}f(Z,"insertOrUpdateNode");function Xt(t){return t?.classes?.join(" ")??""}f(Xt,"getClassesFromDbInfo");function Jt(t){return t?.styles??[]}f(Jt,"getStylesFromDbInfo");var tt=f((t,e,o,s,c,h,p,y)=>{const n=e.id,T=o.get(n),m=Xt(T),N=Jt(T),x=$();if(_.info("dataFetcher parsedItem",e,T,N),n!=="root"){let k=kt;e.start===!0?k=Te:e.start===!1&&(k=Ee),e.type!==et&&(k=e.type),pt.get(n)||pt.set(n,{id:n,shape:k,description:j.sanitizeText(n,x),cssClasses:`${m} ${ke}`,cssStyles:N});const d=pt.get(n);e.description&&(Array.isArray(d.description)?(d.shape=Dt,d.description.push(e.description)):d.description?.length&&d.description.length>0?(d.shape=Dt,d.description===n?d.description=[e.description]:d.description=[d.description,e.description]):(d.shape=kt,d.description=e.description),d.description=j.sanitizeTextOrArray(d.description,x)),d.description?.length===1&&d.shape===Dt&&(d.type==="group"?d.shape=Ot:d.shape=kt),!d.type&&e.doc&&(_.info("Setting cluster for XCX",n,$t(e)),d.type="group",d.isGroup=!0,d.dir=$t(e),d.shape=e.type===Yt?Nt:Ot,d.cssClasses=`${d.cssClasses} ${Le} ${h?we:""}`);const L={labelStyle:"",shape:d.shape,label:d.description,cssClasses:d.cssClasses,cssCompiledStyles:[],cssStyles:d.cssStyles,id:n,dir:d.dir,domId:St(n,M),type:d.type,isGroup:d.type==="group",padding:8,rx:10,ry:10,look:p,labelType:"markdown"};if(L.shape===Nt&&(L.label=""),t&&t.id!=="root"&&(_.trace("Setting node ",n," to be child of its parent ",t.id),L.parentId=t.id),L.centerLabel=!0,e.note){const R={labelStyle:"",shape:_e,label:e.note.text,labelType:"markdown",cssClasses:Ae,cssStyles:[],cssCompiledStyles:[],id:n+Oe+"-"+M,domId:St(n,M,zt),type:d.type,isGroup:d.type==="group",padding:x.flowchart?.padding,look:p,position:e.note.position},v=n+Rt,F={labelStyle:"",shape:me,label:e.note.text,cssClasses:d.cssClasses,cssStyles:[],id:n+Rt,domId:St(n,M,Ht),type:"group",isGroup:!0,padding:16,look:p,position:e.note.position};M++,F.id=v,R.parentId=v,Z(s,F,y),Z(s,R,y),Z(s,L,y);let C=n,P=R.id;e.note.position==="left of"&&(C=R.id,P=n),c.push({id:C+"-"+P,start:C,end:P,arrowhead:"none",arrowTypeEnd:"",style:Gt,labelStyle:"",classes:Ce,arrowheadStyle:Vt,labelpos:Mt,labelType:Ut,thickness:Wt,look:p})}else Z(s,L,y)}e.doc&&(_.trace("Adding nodes children "),Fe(e,e.doc,o,s,c,!h,p,y))},"dataFetcher"),Pe=f(()=>{pt.clear(),M=0},"reset"),D={START_NODE:"[*]",START_TYPE:"start",END_NODE:"[*]",END_TYPE:"end",COLOR_KEYWORD:"color",FILL_KEYWORD:"fill",BG_FILL:"bgFill",STYLECLASS_SEP:","},Ft=f(()=>new Map,"newClassesList"),Pt=f(()=>({relations:[],states:new Map,documents:{}}),"newDoc"),ft=f(t=>JSON.parse(JSON.stringify(t)),"clone"),je=class{constructor(t){this.version=t,this.nodes=[],this.edges=[],this.rootDoc=[],this.classes=Ft(),this.documents={root:Pt()},this.currentDocument=this.documents.root,this.startEndCount=0,this.dividerCnt=0,this.links=new Map,this.funs=[],this.getAccTitle=re,this.setAccTitle=ae,this.getAccDescription=ne,this.setAccDescription=oe,this.setDiagramTitle=le,this.getDiagramTitle=ce,this.clear(),this.setRootDoc=this.setRootDoc.bind(this),this.getDividerId=this.getDividerId.bind(this),this.setDirection=this.setDirection.bind(this),this.trimColon=this.trimColon.bind(this),this.bindFunctions=this.bindFunctions.bind(this)}static{f(this,"StateDB")}static{this.relationType={AGGREGATION:0,EXTENSION:1,COMPOSITION:2,DEPENDENCY:3}}extract(t){this.clear(!0);for(const s of Array.isArray(t)?t:t.doc)switch(s.stmt){case q:this.addState(s.id.trim(),s.type,s.doc,s.description,s.note);break;case Ct:this.addRelation(s.state1,s.state2,s.description);break;case Se:this.addStyleClass(s.id.trim(),s.classes);break;case ye:this.handleStyleDef(s);break;case ge:this.setCssClass(s.id.trim(),s.styleClass);break;case"click":this.addLink(s.id,s.url,s.tooltip);break}const e=this.getStates(),o=$();Pe(),tt(void 0,this.getRootDocV2(),e,this.nodes,this.edges,!0,o.look,this.classes);for(const s of this.nodes)if(Array.isArray(s.label)){if(s.description=s.label.slice(1),s.isGroup&&s.description.length>0)throw new Error(`Group nodes can only have label. Remove the additional description for node [${s.id}]`);s.label=s.label[0]}}handleStyleDef(t){const e=t.id.trim().split(","),o=t.styleClass.split(",");for(const s of e){let c=this.getState(s);if(!c){const h=s.trim();this.addState(h),c=this.getState(h)}c&&(c.styles=o.map(h=>h.replace(/;/g,"")?.trim()))}}setRootDoc(t){_.info("Setting root doc",t),this.rootDoc=t,this.version===1?this.extract(t):this.extract(this.getRootDocV2())}docTranslator(t,e,o){if(e.stmt===Ct){this.docTranslator(t,e.state1,!0),this.docTranslator(t,e.state2,!1);return}if(e.stmt===q&&(e.id===D.START_NODE?(e.id=t.id+(o?"_start":"_end"),e.start=o):e.id=e.id.trim()),e.stmt!==J&&e.stmt!==q||!e.doc)return;const s=[];let c=[];for(const h of e.doc)if(h.type===Yt){const p=ft(h);p.doc=ft(c),s.push(p),c=[]}else c.push(h);if(s.length>0&&c.length>0){const h={stmt:q,id:he(),type:"divider",doc:ft(c)};s.push(ft(h)),e.doc=s}e.doc.forEach(h=>this.docTranslator(e,h,!0))}getRootDocV2(){return this.docTranslator({id:J,stmt:J},{id:J,stmt:J,doc:this.rootDoc},!0),{id:J,doc:this.rootDoc}}addState(t,e=et,o=void 0,s=void 0,c=void 0,h=void 0,p=void 0,y=void 0){const n=t?.trim();if(!this.currentDocument.states.has(n))_.info("Adding state ",n,s),this.currentDocument.states.set(n,{stmt:q,id:n,descriptions:[],type:e,doc:o,note:c,classes:[],styles:[],textStyles:[]});else{const T=this.currentDocument.states.get(n);if(!T)throw new Error(`State not found: ${n}`);T.doc||(T.doc=o),T.type||(T.type=e)}if(s&&(_.info("Setting state description",n,s),(Array.isArray(s)?s:[s]).forEach(m=>this.addDescription(n,m.trim()))),c){const T=this.currentDocument.states.get(n);if(!T)throw new Error(`State not found: ${n}`);T.note=c,T.note.text=j.sanitizeText(T.note.text,$())}h&&(_.info("Setting state classes",n,h),(Array.isArray(h)?h:[h]).forEach(m=>this.setCssClass(n,m.trim()))),p&&(_.info("Setting state styles",n,p),(Array.isArray(p)?p:[p]).forEach(m=>this.setStyle(n,m.trim()))),y&&(_.info("Setting state styles",n,p),(Array.isArray(y)?y:[y]).forEach(m=>this.setTextStyle(n,m.trim())))}clear(t){this.nodes=[],this.edges=[],this.funs=[this.setupToolTips.bind(this)],this.documents={root:Pt()},this.currentDocument=this.documents.root,this.startEndCount=0,this.classes=Ft(),t||(this.links=new Map,ue())}getState(t){return this.currentDocument.states.get(t)}getStates(){return this.currentDocument.states}logDocuments(){_.info("Documents = ",this.documents)}getRelations(){return this.currentDocument.relations}addLink(t,e,o){this.links.set(t,{url:e,tooltip:o}),_.warn("Adding link",t,e,o)}getLinks(){return this.links}startIdIfNeeded(t=""){return t===D.START_NODE?(this.startEndCount++,`${D.START_TYPE}${this.startEndCount}`):t}startTypeIfNeeded(t="",e=et){return t===D.START_NODE?D.START_TYPE:e}endIdIfNeeded(t=""){return t===D.END_NODE?(this.startEndCount++,`${D.END_TYPE}${this.startEndCount}`):t}endTypeIfNeeded(t="",e=et){return t===D.END_NODE?D.END_TYPE:e}addRelationObjs(t,e,o=""){const s=this.startIdIfNeeded(t.id.trim()),c=this.startTypeIfNeeded(t.id.trim(),t.type),h=this.startIdIfNeeded(e.id.trim()),p=this.startTypeIfNeeded(e.id.trim(),e.type);this.addState(s,c,t.doc,t.description,t.note,t.classes,t.styles,t.textStyles),this.addState(h,p,e.doc,e.description,e.note,e.classes,e.styles,e.textStyles),this.currentDocument.relations.push({id1:s,id2:h,relationTitle:j.sanitizeText(o,$())})}addRelation(t,e,o){if(typeof t=="object"&&typeof e=="object")this.addRelationObjs(t,e,o);else if(typeof t=="string"&&typeof e=="string"){const s=this.startIdIfNeeded(t.trim()),c=this.startTypeIfNeeded(t),h=this.endIdIfNeeded(e.trim()),p=this.endTypeIfNeeded(e);this.addState(s,c),this.addState(h,p),this.currentDocument.relations.push({id1:s,id2:h,relationTitle:o?j.sanitizeText(o,$()):void 0})}}addDescription(t,e){const o=this.currentDocument.states.get(t),s=e.startsWith(":")?e.replace(":","").trim():e;o?.descriptions?.push(j.sanitizeText(s,$()))}cleanupLabel(t){return t.startsWith(":")?t.slice(2).trim():t.trim()}getDividerId(){return this.dividerCnt++,`divider-id-${this.dividerCnt}`}addStyleClass(t,e=""){this.classes.has(t)||this.classes.set(t,{id:t,styles:[],textStyles:[]});const o=this.classes.get(t);e&&o&&e.split(D.STYLECLASS_SEP).forEach(s=>{const c=s.replace(/([^;]*);/,"$1").trim();if(RegExp(D.COLOR_KEYWORD).exec(s)){const p=c.replace(D.FILL_KEYWORD,D.BG_FILL).replace(D.COLOR_KEYWORD,D.FILL_KEYWORD);o.textStyles.push(p)}o.styles.push(c)})}getClasses(){return this.classes}setupToolTips(t){const e=fe();bt(t).select("svg").selectAll("g.node, g.rough-node").on("mouseover",c=>{const h=bt(c.currentTarget),p=h.attr("title");if(p===null)return;const y=c.currentTarget?.getBoundingClientRect();e.transition().duration(200).style("opacity",".9"),e.style("left",window.scrollX+y.left+(y.right-y.left)/2+"px").style("top",window.scrollY+y.bottom+"px"),e.html(de.sanitize(p)),h.classed("hover",!0)}).on("mouseout",c=>{e.transition().duration(500).style("opacity",0),bt(c.currentTarget).classed("hover",!1)})}setCssClass(t,e){t.split(",").forEach(o=>{let s=this.getState(o);if(!s){const c=o.trim();this.addState(c),s=this.getState(c)}s?.classes?.push(e)})}setStyle(t,e){this.getState(t)?.styles?.push(e)}setTextStyle(t,e){this.getState(t)?.textStyles?.push(e)}bindFunctions(t){this.funs.forEach(e=>{e(t)})}getDirectionStatement(){return this.rootDoc.find(t=>t.stmt===wt)}getDirection(){return this.getDirectionStatement()?.value??pe}setDirection(t){const e=this.getDirectionStatement();e?e.value=t:this.rootDoc.unshift({stmt:wt,value:t})}trimColon(t){return t.startsWith(":")?t.slice(1).trim():t.trim()}getData(){const t=$();return{nodes:this.nodes,edges:this.edges,other:{},config:t,direction:Kt(this.getRootDocV2())}}getConfig(){return $().state}},Be=f(t=>` +defs [id$="-barbEnd"] { + fill: ${t.transitionColor}; + stroke: ${t.transitionColor}; + } +g.stateGroup text { + fill: ${t.nodeBorder}; + stroke: none; + font-size: 10px; +} +g.stateGroup text { + fill: ${t.textColor}; + stroke: none; + font-size: 10px; + +} +g.stateGroup .state-title { + font-weight: bolder; + fill: ${t.stateLabelColor}; +} + +g.stateGroup rect { + fill: ${t.mainBkg}; + stroke: ${t.nodeBorder}; +} + +g.stateGroup line { + stroke: ${t.lineColor}; + stroke-width: ${t.strokeWidth||1}; +} + +.transition { + stroke: ${t.transitionColor}; + stroke-width: ${t.strokeWidth||1}; + fill: none; +} + +.stateGroup .composit { + fill: ${t.background}; + border-bottom: 1px +} + +.stateGroup .alt-composit { + fill: #e0e0e0; + border-bottom: 1px +} + +.state-note { + stroke: ${t.noteBorderColor}; + fill: ${t.noteBkgColor}; + + text { + fill: ${t.noteTextColor}; + stroke: none; + font-size: 10px; + } +} + +.stateLabel .box { + stroke: none; + stroke-width: 0; + fill: ${t.mainBkg}; + opacity: 0.5; +} + +.edgeLabel .label rect { + fill: ${t.labelBackgroundColor}; + opacity: 0.5; +} +.edgeLabel { + background-color: ${t.edgeLabelBackground}; + p { + background-color: ${t.edgeLabelBackground}; + } + rect { + opacity: 0.5; + background-color: ${t.edgeLabelBackground}; + fill: ${t.edgeLabelBackground}; + } + text-align: center; +} +.edgeLabel .label text { + fill: ${t.transitionLabelColor||t.tertiaryTextColor}; +} +.label div .edgeLabel { + color: ${t.transitionLabelColor||t.tertiaryTextColor}; +} + +.stateLabel text { + fill: ${t.stateLabelColor}; + font-size: 10px; + font-weight: bold; +} + +.node circle.state-start { + fill: ${t.specialStateColor}; + stroke: ${t.specialStateColor}; +} + +.node .fork-join { + fill: ${t.specialStateColor}; + stroke: ${t.specialStateColor}; +} + +.node circle.state-end { + fill: ${t.innerEndBackground}; + stroke: ${t.background}; + stroke-width: 1.5 +} +.end-state-inner { + fill: ${t.compositeBackground||t.background}; + // stroke: ${t.background}; + stroke-width: 1.5 +} + +.node rect { + fill: ${t.stateBkg||t.mainBkg}; + stroke: ${t.stateBorder||t.nodeBorder}; + stroke-width: ${t.strokeWidth||1}px; +} +.node polygon { + fill: ${t.mainBkg}; + stroke: ${t.stateBorder||t.nodeBorder};; + stroke-width: ${t.strokeWidth||1}px; +} +[id$="-barbEnd"] { + fill: ${t.lineColor}; +} + +.statediagram-cluster rect { + fill: ${t.compositeTitleBackground}; + stroke: ${t.stateBorder||t.nodeBorder}; + stroke-width: ${t.strokeWidth||1}px; +} + +.cluster-label, .nodeLabel { + color: ${t.stateLabelColor}; + // line-height: 1; +} + +.statediagram-cluster rect.outer { + rx: 5px; + ry: 5px; +} +.statediagram-state .divider { + stroke: ${t.stateBorder||t.nodeBorder}; +} + +.statediagram-state .title-state { + rx: 5px; + ry: 5px; +} +.statediagram-cluster.statediagram-cluster .inner { + fill: ${t.compositeBackground||t.background}; +} +.statediagram-cluster.statediagram-cluster-alt .inner { + fill: ${t.altBackground?t.altBackground:"#efefef"}; +} + +.statediagram-cluster .inner { + rx:0; + ry:0; +} + +.statediagram-state rect.basic { + rx: 5px; + ry: 5px; +} +.statediagram-state rect.divider { + stroke-dasharray: 10,10; + fill: ${t.altBackground?t.altBackground:"#efefef"}; +} + +.note-edge { + stroke-dasharray: 5; +} + +.statediagram-note rect { + fill: ${t.noteBkgColor}; + stroke: ${t.noteBorderColor}; + stroke-width: 1px; + rx: 0; + ry: 0; +} +.statediagram-note rect { + fill: ${t.noteBkgColor}; + stroke: ${t.noteBorderColor}; + stroke-width: 1px; + rx: 0; + ry: 0; +} + +.statediagram-note text { + fill: ${t.noteTextColor}; +} + +.statediagram-note .nodeLabel { + color: ${t.noteTextColor}; +} +.statediagram .edgeLabel { + color: red; // ${t.noteTextColor}; +} + +[id$="-dependencyStart"], [id$="-dependencyEnd"] { + fill: ${t.lineColor}; + stroke: ${t.lineColor}; + stroke-width: ${t.strokeWidth||1}; +} + +.statediagramTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${t.textColor}; +} + +[data-look="neo"].statediagram-cluster rect { + fill: ${t.mainBkg}; + stroke: ${t.useGradient?"url("+t.svgId+"-gradient)":t.stateBorder||t.nodeBorder}; + stroke-width: ${t.strokeWidth??1}; +} +[data-look="neo"].statediagram-cluster rect.outer { + rx: ${t.radius}px; + ry: ${t.radius}px; + filter: ${t.dropShadow?t.dropShadow.replace("url(#drop-shadow)",`url(${t.svgId}-drop-shadow)`):"none"} +} +`,"getStyles"),He=Be;export{je as S,Ue as a,We as b,He as s}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-JWPE2WC7.5yopTNlD.js b/packages/tempo/public/v4/assets/chunks/chunk-JWPE2WC7.5yopTNlD.js new file mode 100644 index 00000000..d5a79011 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-JWPE2WC7.5yopTNlD.js @@ -0,0 +1 @@ +import{_ as i}from"../app.CbekdYod.js";function t(c,e){c.accDescr&&e.setAccDescription?.(c.accDescr),c.accTitle&&e.setAccTitle?.(c.accTitle),c.title&&e.setDiagramTitle?.(c.title)}i(t,"populateCommonDb");export{t as p}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-POPQ4Y6H.DEs7vhGS.js b/packages/tempo/public/v4/assets/chunks/chunk-POPQ4Y6H.DEs7vhGS.js new file mode 100644 index 00000000..1f31f26b --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-POPQ4Y6H.DEs7vhGS.js @@ -0,0 +1 @@ +import{_ as a,d as w,l as x}from"../app.CbekdYod.js";var B=a((e,t,i,r)=>{e.attr("class",i);const{width:o,height:h,x:n,y:c}=u(e,t);w(e,h,o,r);const s=d(n,c,o,h,t);e.attr("viewBox",s),x.debug(`viewBox configured: ${s} with padding: ${t}`)},"setupViewPortForSVG"),u=a((e,t)=>{const i=e.node()?.getBBox()||{width:0,height:0,x:0,y:0};return{width:i.width+t*2,height:i.height+t*2,x:i.x,y:i.y}},"calculateDimensionsWithPadding"),d=a((e,t,i,r,o)=>`${e-o} ${t-o} ${i} ${r}`,"createViewBox");export{B as s}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-SVP7TREG.tNKCi1Yy.js b/packages/tempo/public/v4/assets/chunks/chunk-SVP7TREG.tNKCi1Yy.js new file mode 100644 index 00000000..f8cd55d4 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-SVP7TREG.tNKCi1Yy.js @@ -0,0 +1,88 @@ +import{_ as p,l as w,G as L,A as E,r as X,X as I,d as G,i as H,c as q}from"../app.CbekdYod.js";var z="",b="",N="",A=[],R=new Map,k=p(e=>H(e,q()),"sanitizeText"),F=p(e=>{switch(e.type){case"terminal":return{...e,value:k(e.value)};case"nonterminal":return{...e,name:k(e.name)};case"sequence":return{...e,elements:e.elements.map(F)};case"choice":return{...e,alternatives:e.alternatives.map(F)};case"optional":return{...e,element:F(e.element)};case"repetition":return{...e,element:F(e.element),separator:e.separator?F(e.separator):void 0};case"special":return{...e,text:k(e.text)}}},"sanitizeAstNode"),U=p(()=>{z="",b="",N="",A.length=0,R.clear(),X(),w.debug("[Railroad] Database cleared")},"clear"),_=p(e=>{z=k(e),w.debug("[Railroad] Title set:",e)},"setTitle"),W=p(()=>z,"getTitle"),j=p(e=>{const i={...e,name:k(e.name),definition:F(e.definition),comment:e.comment?k(e.comment):void 0};w.debug("[Railroad] Adding rule:",i.name),R.has(i.name)&&w.warn(`[Railroad] Rule '${i.name}' is already defined. Overwriting.`),A.push(i),R.set(i.name,i)},"addRule"),K=p(()=>A,"getRules"),J=p(e=>R.get(e),"getRule"),Q=p(e=>{b=k(e).replace(/^\s+/g,""),w.debug("[Railroad] Accessibility title set:",e)},"setAccTitle"),Z=p(()=>b,"getAccTitle"),V=p(e=>{N=k(e).replace(/\n\s+/g,` +`),w.debug("[Railroad] Accessibility description set:",e)},"setAccDescription"),ee=p(()=>N,"getAccDescription"),te=_,re=W,ie={clear:U,setTitle:_,getTitle:W,addRule:j,getRules:K,getRule:J,setAccTitle:Q,getAccTitle:Z,setAccDescription:V,getAccDescription:ee,setDiagramTitle:te,getDiagramTitle:re},g={compactMode:!1,padding:10,verticalSeparation:8,horizontalSeparation:10,arcRadius:10,fontSize:14,fontFamily:"monospace",terminalFill:"#FFFFC0",terminalStroke:"#000000",terminalTextColor:"#000000",nonTerminalFill:"#FFFFFF",nonTerminalStroke:"#000000",nonTerminalTextColor:"#000000",lineColor:"#000000",strokeWidth:2,markerFill:"#000000",commentFill:"#E8E8E8",commentStroke:"#888888",commentTextColor:"#666666",specialFill:"#F0E0FF",specialStroke:"#8800CC",ruleNameColor:"#000066",showMarkers:!0,markerRadius:5},ne=/^#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$|^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\([\d\s%+,./-]+\)$|^[a-z]+$/i,ae=/^[\w "',.-]+$/,oe=new Set(["compactMode","padding","verticalSeparation","horizontalSeparation","arcRadius","fontSize","fontFamily","terminalFill","terminalStroke","terminalTextColor","nonTerminalFill","nonTerminalStroke","nonTerminalTextColor","lineColor","strokeWidth","markerFill","commentFill","commentStroke","commentTextColor","specialFill","specialStroke","ruleNameColor","showMarkers","markerRadius"]),B=p(e=>e?Object.keys(e).every(i=>i==="railroad"||oe.has(i)):!1,"isRailroadStyleOptions"),le=p(e=>e?"railroad"in e&&e.railroad?e.railroad:B(e)?e:{}:{},"extractRailroadOverrides"),se=p(e=>{if(!e||B(e))return{};const{railroad:i,svgId:a,theme:r,look:t,...n}=e;return n},"extractThemeOverrides"),m=p((e,i)=>{if(typeof e!="string")return i;const a=e.trim();return ne.test(a)?a:i},"sanitizeColorValue"),Y=p((e,i)=>{if(typeof e!="string")return i;const a=e.trim();return ae.test(a)?a:i},"sanitizeFontFamilyValue"),S=p((e,i)=>{const a=typeof e=="number"?e:typeof e=="string"?Number.parseFloat(e):Number.NaN;return Number.isFinite(a)&&a>=0?a:i},"sanitizeNumberValue"),de=p(e=>{const i=typeof e=="number"?e:typeof e=="string"?Number.parseFloat(e):Number.NaN;return Number.isFinite(i)&&i>0?i:void 0},"parseThemeFontSize"),ce=p(e=>{const i=Y(e.fontFamily,g.fontFamily),a=de(e.fontSize)??g.fontSize;return{...g,fontFamily:i,fontSize:a,terminalFill:m(e.secondBkg??e.secondaryColor,g.terminalFill),terminalStroke:m(e.secondaryBorderColor??e.lineColor,g.terminalStroke),terminalTextColor:m(e.secondaryTextColor??e.textColor,g.terminalTextColor),nonTerminalFill:m(e.mainBkg??e.background,g.nonTerminalFill),nonTerminalStroke:m(e.primaryBorderColor??e.lineColor,g.nonTerminalStroke),nonTerminalTextColor:m(e.primaryTextColor??e.textColor,g.nonTerminalTextColor),lineColor:m(e.lineColor,g.lineColor),markerFill:m(e.lineColor,g.markerFill),commentFill:m(e.labelBackground??e.tertiaryColor,g.commentFill),commentStroke:m(e.tertiaryBorderColor??e.lineColor,g.commentStroke),commentTextColor:m(e.tertiaryTextColor??e.textColor,g.commentTextColor),specialFill:m(e.tertiaryColor??e.secondaryColor,g.specialFill),specialStroke:m(e.tertiaryBorderColor??e.secondaryBorderColor,g.specialStroke),ruleNameColor:m(e.titleColor??e.textColor,g.ruleNameColor)}},"buildThemeDefaults"),M=p(e=>{const i=E(),a={...I(),...i.themeVariables??{},...se(e)},r=ce(a),t={...i.railroad??{},...le(e)};return{compactMode:t.compactMode??r.compactMode,padding:S(t.padding,r.padding),verticalSeparation:S(t.verticalSeparation,r.verticalSeparation),horizontalSeparation:S(t.horizontalSeparation,r.horizontalSeparation),arcRadius:S(t.arcRadius,r.arcRadius),fontSize:S(t.fontSize,r.fontSize),fontFamily:Y(t.fontFamily,r.fontFamily),terminalFill:m(t.terminalFill,r.terminalFill),terminalStroke:m(t.terminalStroke,r.terminalStroke),terminalTextColor:m(t.terminalTextColor,r.terminalTextColor),nonTerminalFill:m(t.nonTerminalFill,r.nonTerminalFill),nonTerminalStroke:m(t.nonTerminalStroke,r.nonTerminalStroke),nonTerminalTextColor:m(t.nonTerminalTextColor,r.nonTerminalTextColor),lineColor:m(t.lineColor,r.lineColor),strokeWidth:S(t.strokeWidth,r.strokeWidth),markerFill:m(t.markerFill,r.markerFill),commentFill:m(t.commentFill,r.commentFill),commentStroke:m(t.commentStroke,r.commentStroke),commentTextColor:m(t.commentTextColor,r.commentTextColor),specialFill:m(t.specialFill,r.specialFill),specialStroke:m(t.specialStroke,r.specialStroke),ruleNameColor:m(t.ruleNameColor,r.ruleNameColor),showMarkers:t.showMarkers??r.showMarkers,markerRadius:S(t.markerRadius,r.markerRadius)}},"buildRailroadStyleOptions"),ue=p(e=>{const{fontFamily:i,fontSize:a,terminalFill:r,terminalStroke:t,terminalTextColor:n,nonTerminalFill:h,nonTerminalStroke:s,nonTerminalTextColor:o,lineColor:u,strokeWidth:c,markerFill:d,commentFill:x,commentStroke:l,commentTextColor:f,specialFill:y,specialStroke:v,ruleNameColor:C}=M(e);return` + .railroad-diagram { + font-family: ${i}; + font-size: ${a}px; + } + + .railroad-terminal rect { + fill: ${r}; + stroke: ${t}; + stroke-width: ${c}px; + } + + .railroad-terminal text { + fill: ${n}; + font-family: ${i}; + font-size: ${a}px; + text-anchor: middle; + dominant-baseline: middle; + } + + .railroad-nonterminal rect { + fill: ${h}; + stroke: ${s}; + stroke-width: ${c}px; + } + + .railroad-nonterminal text { + fill: ${o}; + font-family: ${i}; + font-size: ${a}px; + text-anchor: middle; + dominant-baseline: middle; + } + + .railroad-line { + stroke: ${u}; + stroke-width: ${c}px; + fill: none; + } + + .railroad-start circle, + .railroad-end circle { + fill: ${d}; + } + + .railroad-comment ellipse { + fill: ${x}; + stroke: ${l}; + stroke-width: ${c}px; + } + + .railroad-comment text { + fill: ${f}; + font-style: italic; + font-family: ${i}; + font-size: ${a}px; + text-anchor: middle; + dominant-baseline: middle; + } + + .railroad-special rect { + fill: ${y}; + stroke: ${v}; + stroke-width: ${c}px; + stroke-dasharray: 5,3; + } + + .railroad-special text { + fill: ${o}; + font-family: ${i}; + font-size: ${a}px; + text-anchor: middle; + dominant-baseline: middle; + } + + .railroad-rule-name { + font-weight: bold; + fill: ${C}; + font-family: ${i}; + font-size: ${a}px; + } + + .railroad-group { + /* Grouping container, no specific styles */ + } +`},"getStyles"),T=class{constructor(){this.d=""}static{p(this,"PathBuilder")}moveTo(e,i){return this.d+=`M ${e} ${i} `,this}lineTo(e,i){return this.d+=`L ${e} ${i} `,this}horizontalTo(e){return this.d+=`H ${e} `,this}verticalTo(e){return this.d+=`V ${e} `,this}arcTo(e,i,a,r,t,n,h){return this.d+=`A ${e} ${i} ${a} ${r?1:0} ${t?1:0} ${n} ${h} `,this}build(){return this.d.trim()}},me=class{constructor(e,i=M()){this.textCache=new Map,this.svg=e,this.config=i}static{p(this,"RailroadRenderer")}measureText(e){if(this.textCache.has(e))return this.textCache.get(e);const i=this.svg.append("text").attr("font-family",this.config.fontFamily).attr("font-size",this.config.fontSize).text(e),a=i.node().getBBox(),r={width:a.width,height:a.height};return i.remove(),this.textCache.set(e,r),r}renderTerminal(e,i){const a=this.measureText(i),r=a.width+this.config.padding*2,t=a.height+this.config.padding*2,n=e.append("g").attr("class","railroad-terminal");return n.append("rect").attr("x",0).attr("y",0).attr("width",r).attr("height",t).attr("rx",10).attr("ry",10),n.append("text").attr("x",r/2).attr("y",t/2).text(i),{element:n.node(),dimensions:{width:r,height:t,up:t/2,down:t/2}}}renderNonTerminal(e,i){const a=this.measureText(i),r=a.width+this.config.padding*2,t=a.height+this.config.padding*2,n=e.append("g").attr("class","railroad-nonterminal");return n.append("rect").attr("x",0).attr("y",0).attr("width",r).attr("height",t),n.append("text").attr("x",r/2).attr("y",t/2).text(i),{element:n.node(),dimensions:{width:r,height:t,up:t/2,down:t/2}}}renderSequence(e,i){const a=i.map(o=>this.renderExpression(e,o));let r=0,t=0,n=0;for(const o of a)r+=o.dimensions.width,t=Math.max(t,o.dimensions.up),n=Math.max(n,o.dimensions.down);r+=(a.length-1)*this.config.horizontalSeparation;const h=e.append("g").attr("class","railroad-sequence");let s=0;for(let o=0;othis.renderExpression(e,d));let r=0,t=0;for(const d of a)r=Math.max(r,d.dimensions.width),t+=d.dimensions.height;t+=(a.length-1)*this.config.verticalSeparation;const n=this.config.arcRadius,h=n*4,s=r+h,o=e.append("g").attr("class","railroad-choice");let u=0;const c=t/2;for(const d of a){const x=u,l=x+d.dimensions.up,f=n*2+(r-d.dimensions.width)/2;o.node().appendChild(d.element).setAttribute("transform",`translate(${f}, ${x})`);const v=new T,C=l>c;l===c?v.moveTo(0,c).lineTo(f,l):v.moveTo(0,c).arcTo(n,n,0,!1,C,n,c+(C?n:-n)).lineTo(n,l-(C?n:-n)).arcTo(n,n,0,!1,!C,n*2,l).lineTo(f,l),o.append("path").attr("class","railroad-line").attr("d",v.build());const $=new T,O=f+d.dimensions.width,P=s-n*2;l===c?$.moveTo(O,l).lineTo(s,c):$.moveTo(O,l).lineTo(P,l).arcTo(n,n,0,!1,!C,s-n,l+(C?-n:n)).lineTo(s-n,c+(C?n:-n)).arcTo(n,n,0,!1,C,s,c),o.append("path").attr("class","railroad-line").attr("d",$.build()),u+=d.dimensions.height+this.config.verticalSeparation}return{element:o.node(),dimensions:{width:s,height:t,up:c,down:t-c}}}renderOptional(e,i){const a=this.renderExpression(e,i),r=this.config.arcRadius,t=r*2,n=a.dimensions.width+r*4,h=a.dimensions.height+t,s=e.append("g").attr("class","railroad-optional"),o=r*2,u=t;s.node().appendChild(a.element).setAttribute("transform",`translate(${o}, ${u})`);const d=u+a.dimensions.up,x=new T().moveTo(0,d).lineTo(r*2,d);s.append("path").attr("class","railroad-line").attr("d",x.build());const l=new T().moveTo(o+a.dimensions.width,d).lineTo(n,d);s.append("path").attr("class","railroad-line").attr("d",l.build());const f=new T().moveTo(0,d).arcTo(r,r,0,!1,!1,r,d-r).lineTo(r,r).arcTo(r,r,0,!1,!0,r*2,0).lineTo(n-r*2,0).arcTo(r,r,0,!1,!0,n-r,r).lineTo(n-r,d-r).arcTo(r,r,0,!1,!1,n,d);return s.append("path").attr("class","railroad-line").attr("d",f.build()),{element:s.node(),dimensions:{width:n,height:h,up:d,down:h-d}}}renderRepetition(e,i,a){const r=this.renderExpression(e,i),t=this.config.arcRadius,n=t*2,h=r.dimensions.width+t*4,s=a===0,o=r.dimensions.height+n+(s?n:0),u=e.append("g").attr("class","railroad-repetition"),c=t*2,d=s?n:0;u.node().appendChild(r.element).setAttribute("transform",`translate(${c}, ${d})`);const l=d+r.dimensions.up;u.append("path").attr("class","railroad-line").attr("d",new T().moveTo(0,l).lineTo(t*2,l).build()),u.append("path").attr("class","railroad-line").attr("d",new T().moveTo(c+r.dimensions.width,l).lineTo(h,l).build());const f=d+r.dimensions.height+t,y=new T().moveTo(c+r.dimensions.width,l).arcTo(t,t,0,!1,!0,c+r.dimensions.width+t,l+t).lineTo(c+r.dimensions.width+t,f).arcTo(t,t,0,!1,!0,c+r.dimensions.width,f+t).lineTo(t*2,f+t).arcTo(t,t,0,!1,!0,t,f).lineTo(t,l+t).arcTo(t,t,0,!1,!0,t*2,l);if(u.append("path").attr("class","railroad-line").attr("d",y.build()),s){const v=new T().moveTo(0,l).arcTo(t,t,0,!1,!1,t,l-t).lineTo(t,t).arcTo(t,t,0,!1,!0,t*2,0).lineTo(h-t*2,0).arcTo(t,t,0,!1,!0,h-t,t).lineTo(h-t,l-t).arcTo(t,t,0,!1,!1,h,l);u.append("path").attr("class","railroad-line").attr("d",v.build())}return{element:u.node(),dimensions:{width:h,height:o,up:l,down:o-l}}}renderSpecial(e,i){const a=this.measureText("? "+i+" ?"),r=a.width+this.config.padding*2,t=a.height+this.config.padding*2,n=e.append("g").attr("class","railroad-special");return n.append("rect").attr("x",0).attr("y",0).attr("width",r).attr("height",t),n.append("text").attr("x",r/2).attr("y",t/2).text("? "+i+" ?"),{element:n.node(),dimensions:{width:r,height:t,up:t/2,down:t/2}}}renderExpression(e,i){switch(i.type){case"terminal":return this.renderTerminal(e,i.value);case"nonterminal":return this.renderNonTerminal(e,i.name);case"sequence":return this.renderSequence(e,i.elements);case"choice":return this.renderChoice(e,i.alternatives);case"optional":return this.renderOptional(e,i.element);case"repetition":return this.renderRepetition(e,i.element,i.min);case"special":return this.renderSpecial(e,i.text);default:throw new Error(`Unknown node type: ${i.type}`)}}renderRule(e,i){const a=this.svg.append("g").attr("class","railroad-rule").attr("transform",`translate(0, ${i})`),r=e.name+" =",t=this.measureText(r).width+20,n=t+20,h=a.append("g"),s=this.renderExpression(h,e.definition),o=Math.max(20,s.dimensions.up),u=o-s.dimensions.up;return h.attr("transform",`translate(${n}, ${u})`),a.append("g").attr("class","railroad-rule-name-group").append("text").attr("class","railroad-rule-name").attr("x",0).attr("y",o).text(r),a.append("g").attr("class","railroad-start").append("circle").attr("cx",t).attr("cy",o).attr("r",this.config.markerRadius),a.append("g").attr("class","railroad-end").append("circle").attr("cx",n+s.dimensions.width+10).attr("cy",o).attr("r",this.config.markerRadius),a.append("path").attr("class","railroad-line").attr("d",new T().moveTo(t+this.config.markerRadius,o).lineTo(n,o).build()),a.append("path").attr("class","railroad-line").attr("d",new T().moveTo(n+s.dimensions.width,o).lineTo(n+s.dimensions.width+10-this.config.markerRadius,o).build()),{height:Math.max(40,u+s.dimensions.height+this.config.padding*2),width:n+s.dimensions.width+10+this.config.markerRadius}}renderDiagram(e){let i=this.config.padding,a=0;for(const r of e){const t=this.renderRule(r,i);i+=t.height+this.config.verticalSeparation,a=Math.max(a,t.width)}return{width:a+this.config.padding*2,height:i+this.config.padding}}},D=p((e,i,a)=>{G(e,i.height,i.width,a),e.attr("viewBox",`0 0 ${i.width} ${i.height}`)},"configureRailroadSvgSize"),he=p((e,i,a)=>{w.debug(`[Railroad] Rendering diagram +`+e);try{const r=L(i);r.attr("class","railroad-diagram");const n=E().railroad?.useMaxWidth??!0,h=ie.getRules();if(w.debug(`[Railroad] Rendering ${h.length} rules`),h.length===0){w.warn("[Railroad] No rules to render"),D(r,{height:100,width:200},n);return}const o=new me(r,M()).renderDiagram(h);D(r,o,n),w.debug("[Railroad] Render complete")}catch(r){throw w.error("[Railroad] Render error:",r),r}},"draw"),ge={draw:he};export{ie as d,ue as g,ge as r}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-TICWLB2K.E0Eenl49.js b/packages/tempo/public/v4/assets/chunks/chunk-TICWLB2K.E0Eenl49.js new file mode 100644 index 00000000..244aa241 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-TICWLB2K.E0Eenl49.js @@ -0,0 +1,206 @@ +import{g as tt}from"./chunk-5VM5RSS4.-zPOtr2J.js";import{g as st}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as it}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as f,l as Ie,c as F,x as at,y as nt,z as Oe,j as de,a6 as rt,b as ut,a as lt,s as ct,g as ot,p as ht,q as dt,k as I,r as pt,t as At,i as ft,a7 as G}from"../app.CbekdYod.js";import{f as gt}from"./chunk-F27PBJKO.CcniKEe6.js";var we=(function(){var t=f(function(O,o,h,p){for(h=h||{},p=O.length;p--;h[O[p]]=o);return h},"o"),i=[1,18],a=[1,19],n=[1,20],r=[1,41],c=[1,26],u=[1,42],d=[1,24],m=[1,25],g=[1,32],N=[1,33],Ae=[1,34],b=[1,45],fe=[1,35],ge=[1,36],me=[1,37],Ce=[1,38],be=[1,27],ke=[1,28],Ee=[1,29],Te=[1,30],ye=[1,31],k=[1,44],E=[1,46],T=[1,43],y=[1,47],De=[1,9],A=[1,8,9],Z=[1,58],$=[1,59],ee=[1,60],te=[1,61],se=[1,62],Fe=[1,63],Be=[1,64],_=[1,8,9,41],Pe=[1,77],M=[1,8,9,12,13,22,39,41,44,46,68,69,70,71,72,73,74,79,81],ie=[1,8,9,12,13,18,20,22,39,41,44,46,47,60,68,69,70,71,72,73,74,79,81,86,100,102,103],ae=[13,60,86,100,102,103],U=[13,60,73,74,86,100,102,103],Me=[13,60,68,69,70,71,72,86,100,102,103],ne=[1,103],z=[1,121],Y=[1,117],K=[1,113],W=[1,119],Q=[1,114],j=[1,115],X=[1,116],q=[1,118],H=[1,120],Re=[22,50,60,61,82,86,87,88,89,90],Ge=[1,128],re=[12,39],_e=[1,8,9,39,41,44,46],ue=[1,8,9,22],Ue=[1,153],ze=[1,8,9,61],x=[1,8,9,22,50,60,61,82,86,87,88,89,90],Se={trace:f(function(){},"trace"),yy:{},symbols_:{error:2,start:3,mermaidDoc:4,statements:5,graphConfig:6,CLASS_DIAGRAM:7,NEWLINE:8,EOF:9,statement:10,classLabel:11,SQS:12,STR:13,SQE:14,namespaceName:15,alphaNumToken:16,classLiteralName:17,DOT:18,className:19,GENERICTYPE:20,relationStatement:21,LABEL:22,namespaceStatement:23,classStatement:24,memberStatement:25,annotationStatement:26,clickStatement:27,styleStatement:28,cssClassStatement:29,noteStatement:30,classDefStatement:31,direction:32,acc_title:33,acc_title_value:34,acc_descr:35,acc_descr_value:36,acc_descr_multiline_value:37,namespaceIdentifier:38,STRUCT_START:39,classStatements:40,STRUCT_STOP:41,NAMESPACE:42,classIdentifier:43,STYLE_SEPARATOR:44,members:45,ANNOTATION_START:46,ANNOTATION_END:47,CLASS:48,emptyBody:49,SPACE:50,MEMBER:51,SEPARATOR:52,relation:53,NOTE_FOR:54,noteText:55,NOTE:56,CLASSDEF:57,classList:58,stylesOpt:59,ALPHA:60,COMMA:61,direction_tb:62,direction_bt:63,direction_rl:64,direction_lr:65,relationType:66,lineType:67,AGGREGATION:68,EXTENSION:69,COMPOSITION:70,DEPENDENCY:71,LOLLIPOP:72,LINE:73,DOTTED_LINE:74,CALLBACK:75,LINK:76,LINK_TARGET:77,CLICK:78,CALLBACK_NAME:79,CALLBACK_ARGS:80,HREF:81,STYLE:82,CSSCLASS:83,style:84,styleComponent:85,NUM:86,COLON:87,UNIT:88,BRKT:89,PCT:90,commentToken:91,textToken:92,graphCodeTokens:93,textNoTagsToken:94,TAGSTART:95,TAGEND:96,"==":97,"--":98,DEFAULT:99,MINUS:100,keywords:101,UNICODE_TEXT:102,BQUOTE_STR:103,$accept:0,$end:1},terminals_:{2:"error",7:"CLASS_DIAGRAM",8:"NEWLINE",9:"EOF",12:"SQS",13:"STR",14:"SQE",18:"DOT",20:"GENERICTYPE",22:"LABEL",33:"acc_title",34:"acc_title_value",35:"acc_descr",36:"acc_descr_value",37:"acc_descr_multiline_value",39:"STRUCT_START",41:"STRUCT_STOP",42:"NAMESPACE",44:"STYLE_SEPARATOR",46:"ANNOTATION_START",47:"ANNOTATION_END",48:"CLASS",50:"SPACE",51:"MEMBER",52:"SEPARATOR",54:"NOTE_FOR",56:"NOTE",57:"CLASSDEF",60:"ALPHA",61:"COMMA",62:"direction_tb",63:"direction_bt",64:"direction_rl",65:"direction_lr",68:"AGGREGATION",69:"EXTENSION",70:"COMPOSITION",71:"DEPENDENCY",72:"LOLLIPOP",73:"LINE",74:"DOTTED_LINE",75:"CALLBACK",76:"LINK",77:"LINK_TARGET",78:"CLICK",79:"CALLBACK_NAME",80:"CALLBACK_ARGS",81:"HREF",82:"STYLE",83:"CSSCLASS",86:"NUM",87:"COLON",88:"UNIT",89:"BRKT",90:"PCT",93:"graphCodeTokens",95:"TAGSTART",96:"TAGEND",97:"==",98:"--",99:"DEFAULT",100:"MINUS",101:"keywords",102:"UNICODE_TEXT",103:"BQUOTE_STR"},productions_:[0,[3,1],[3,1],[4,1],[6,4],[5,1],[5,2],[5,3],[11,3],[15,1],[15,1],[15,3],[15,2],[19,1],[19,3],[19,1],[19,2],[19,2],[19,2],[10,1],[10,2],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,2],[10,2],[10,1],[23,4],[23,5],[38,2],[38,3],[40,1],[40,2],[40,3],[40,1],[40,2],[40,3],[40,1],[40,2],[40,3],[24,1],[24,3],[24,4],[24,3],[24,6],[24,4],[24,7],[24,6],[43,2],[43,3],[49,0],[49,2],[49,2],[26,4],[45,1],[45,2],[25,1],[25,2],[25,1],[25,1],[21,3],[21,4],[21,4],[21,5],[30,3],[30,2],[31,3],[58,1],[58,3],[32,1],[32,1],[32,1],[32,1],[53,3],[53,2],[53,2],[53,1],[66,1],[66,1],[66,1],[66,1],[66,1],[67,1],[67,1],[27,3],[27,4],[27,3],[27,4],[27,4],[27,5],[27,3],[27,4],[27,4],[27,5],[27,4],[27,5],[27,5],[27,6],[28,3],[29,3],[59,1],[59,3],[84,1],[84,2],[85,1],[85,1],[85,1],[85,1],[85,1],[85,1],[85,1],[85,1],[85,1],[91,1],[91,1],[92,1],[92,1],[92,1],[92,1],[92,1],[92,1],[92,1],[94,1],[94,1],[94,1],[94,1],[16,1],[16,1],[16,1],[16,1],[17,1],[55,1]],performAction:f(function(o,h,p,l,C,e,J){var s=e.length-1;switch(C){case 8:this.$=e[s-1];break;case 9:case 10:case 13:case 15:this.$=e[s];break;case 11:case 14:this.$=e[s-2]+"."+e[s];break;case 12:case 16:this.$=e[s-1]+e[s];break;case 17:case 18:this.$=e[s-1]+"~"+e[s]+"~";break;case 19:l.addRelation(e[s]);break;case 20:e[s-1].title=l.cleanupLabel(e[s]),l.addRelation(e[s-1]);break;case 31:this.$=e[s].trim(),l.setAccTitle(this.$);break;case 32:case 33:this.$=e[s].trim(),l.setAccDescription(this.$);break;case 34:l.addClassesToNamespace(e[s-3],e[s-1][0],e[s-1][1]),l.popNamespace();break;case 35:l.addClassesToNamespace(e[s-4],e[s-1][0],e[s-1][1]),l.popNamespace();break;case 36:this.$=l.addNamespace(e[s]);break;case 37:this.$=l.addNamespace(e[s-1],e[s]);break;case 38:this.$=[[e[s]],[]];break;case 39:this.$=[[e[s-1]],[]];break;case 40:e[s][0].unshift(e[s-2]),this.$=e[s];break;case 41:this.$=[[],[e[s]]];break;case 42:this.$=[[],[e[s-1]]];break;case 43:e[s][1].unshift(e[s-2]),this.$=e[s];break;case 44:case 45:this.$=[[],[]];break;case 46:this.$=e[s];break;case 48:l.setCssClass(e[s-2],e[s]);break;case 49:l.addMembers(e[s-3],e[s-1]);break;case 51:l.setCssClass(e[s-5],e[s-3]),l.addMembers(e[s-5],e[s-1]);break;case 52:l.addAnnotation(e[s-3],e[s-1]);break;case 53:l.addAnnotation(e[s-6],e[s-4]),l.addMembers(e[s-6],e[s-1]);break;case 54:l.addAnnotation(e[s-5],e[s-3]);break;case 55:this.$=e[s],l.addClass(e[s]);break;case 56:this.$=e[s-1],l.addClass(e[s-1]),l.setClassLabel(e[s-1],e[s]);break;case 60:l.addAnnotation(e[s],e[s-2]);break;case 61:case 74:this.$=[e[s]];break;case 62:e[s].push(e[s-1]),this.$=e[s];break;case 63:break;case 64:l.addMember(e[s-1],l.cleanupLabel(e[s]));break;case 65:break;case 66:break;case 67:this.$={id1:e[s-2],id2:e[s],relation:e[s-1],relationTitle1:"none",relationTitle2:"none"};break;case 68:this.$={id1:e[s-3],id2:e[s],relation:e[s-1],relationTitle1:e[s-2],relationTitle2:"none"};break;case 69:this.$={id1:e[s-3],id2:e[s],relation:e[s-2],relationTitle1:"none",relationTitle2:e[s-1]};break;case 70:this.$={id1:e[s-4],id2:e[s],relation:e[s-2],relationTitle1:e[s-3],relationTitle2:e[s-1]};break;case 71:this.$=l.addNote(e[s],e[s-1]);break;case 72:this.$=l.addNote(e[s]);break;case 73:this.$=e[s-2],l.defineClass(e[s-1],e[s]);break;case 75:this.$=e[s-2].concat([e[s]]);break;case 76:l.setDirection("TB");break;case 77:l.setDirection("BT");break;case 78:l.setDirection("RL");break;case 79:l.setDirection("LR");break;case 80:this.$={type1:e[s-2],type2:e[s],lineType:e[s-1]};break;case 81:this.$={type1:"none",type2:e[s],lineType:e[s-1]};break;case 82:this.$={type1:e[s-1],type2:"none",lineType:e[s]};break;case 83:this.$={type1:"none",type2:"none",lineType:e[s]};break;case 84:this.$=l.relationType.AGGREGATION;break;case 85:this.$=l.relationType.EXTENSION;break;case 86:this.$=l.relationType.COMPOSITION;break;case 87:this.$=l.relationType.DEPENDENCY;break;case 88:this.$=l.relationType.LOLLIPOP;break;case 89:this.$=l.lineType.LINE;break;case 90:this.$=l.lineType.DOTTED_LINE;break;case 91:case 97:this.$=e[s-2],l.setClickEvent(e[s-1],e[s]);break;case 92:case 98:this.$=e[s-3],l.setClickEvent(e[s-2],e[s-1]),l.setTooltip(e[s-2],e[s]);break;case 93:this.$=e[s-2],l.setLink(e[s-1],e[s]);break;case 94:this.$=e[s-3],l.setLink(e[s-2],e[s-1],e[s]);break;case 95:this.$=e[s-3],l.setLink(e[s-2],e[s-1]),l.setTooltip(e[s-2],e[s]);break;case 96:this.$=e[s-4],l.setLink(e[s-3],e[s-2],e[s]),l.setTooltip(e[s-3],e[s-1]);break;case 99:this.$=e[s-3],l.setClickEvent(e[s-2],e[s-1],e[s]);break;case 100:this.$=e[s-4],l.setClickEvent(e[s-3],e[s-2],e[s-1]),l.setTooltip(e[s-3],e[s]);break;case 101:this.$=e[s-3],l.setLink(e[s-2],e[s]);break;case 102:this.$=e[s-4],l.setLink(e[s-3],e[s-1],e[s]);break;case 103:this.$=e[s-4],l.setLink(e[s-3],e[s-1]),l.setTooltip(e[s-3],e[s]);break;case 104:this.$=e[s-5],l.setLink(e[s-4],e[s-2],e[s]),l.setTooltip(e[s-4],e[s-1]);break;case 105:this.$=e[s-2],l.setCssStyle(e[s-1],e[s]);break;case 106:l.setCssClass(e[s-1],e[s]);break;case 107:this.$=[e[s]];break;case 108:e[s-2].push(e[s]),this.$=e[s-2];break;case 110:this.$=e[s-1]+e[s];break}},"anonymous"),table:[{3:1,4:2,5:3,6:4,7:[1,6],10:5,16:39,17:40,19:21,21:7,23:8,24:9,25:10,26:11,27:12,28:13,29:14,30:15,31:16,32:17,33:i,35:a,37:n,38:22,42:r,43:23,46:c,48:u,51:d,52:m,54:g,56:N,57:Ae,60:b,62:fe,63:ge,64:me,65:Ce,75:be,76:ke,78:Ee,82:Te,83:ye,86:k,100:E,102:T,103:y},{1:[3]},{1:[2,1]},{1:[2,2]},{1:[2,3]},t(De,[2,5],{8:[1,48]}),{8:[1,49]},t(A,[2,19],{22:[1,50]}),t(A,[2,21]),t(A,[2,22]),t(A,[2,23]),t(A,[2,24]),t(A,[2,25]),t(A,[2,26]),t(A,[2,27]),t(A,[2,28]),t(A,[2,29]),t(A,[2,30]),{34:[1,51]},{36:[1,52]},t(A,[2,33]),t(A,[2,63],{53:53,66:56,67:57,13:[1,54],22:[1,55],68:Z,69:$,70:ee,71:te,72:se,73:Fe,74:Be}),{39:[1,65]},t(_,[2,47],{39:[1,67],44:[1,66],46:[1,68]}),t(A,[2,65]),t(A,[2,66]),{16:69,60:b,86:k,100:E,102:T},{16:39,17:40,19:70,60:b,86:k,100:E,102:T,103:y},{16:39,17:40,19:71,60:b,86:k,100:E,102:T,103:y},{16:39,17:40,19:72,60:b,86:k,100:E,102:T,103:y},{60:[1,73]},{13:[1,74]},{16:39,17:40,19:75,60:b,86:k,100:E,102:T,103:y},{13:Pe,55:76},{58:78,60:[1,79]},t(A,[2,76]),t(A,[2,77]),t(A,[2,78]),t(A,[2,79]),t(M,[2,13],{16:39,17:40,19:81,18:[1,80],20:[1,82],60:b,86:k,100:E,102:T,103:y}),t(M,[2,15],{20:[1,83]}),{15:84,16:85,17:86,60:b,86:k,100:E,102:T,103:y},{16:39,17:40,19:87,60:b,86:k,100:E,102:T,103:y},t(ie,[2,133]),t(ie,[2,134]),t(ie,[2,135]),t(ie,[2,136]),t([1,8,9,12,13,20,22,39,41,44,46,68,69,70,71,72,73,74,79,81],[2,137]),t(De,[2,6],{10:5,21:7,23:8,24:9,25:10,26:11,27:12,28:13,29:14,30:15,31:16,32:17,19:21,38:22,43:23,16:39,17:40,5:88,33:i,35:a,37:n,42:r,46:c,48:u,51:d,52:m,54:g,56:N,57:Ae,60:b,62:fe,63:ge,64:me,65:Ce,75:be,76:ke,78:Ee,82:Te,83:ye,86:k,100:E,102:T,103:y}),{5:89,10:5,16:39,17:40,19:21,21:7,23:8,24:9,25:10,26:11,27:12,28:13,29:14,30:15,31:16,32:17,33:i,35:a,37:n,38:22,42:r,43:23,46:c,48:u,51:d,52:m,54:g,56:N,57:Ae,60:b,62:fe,63:ge,64:me,65:Ce,75:be,76:ke,78:Ee,82:Te,83:ye,86:k,100:E,102:T,103:y},t(A,[2,20]),t(A,[2,31]),t(A,[2,32]),{13:[1,91],16:39,17:40,19:90,60:b,86:k,100:E,102:T,103:y},{53:92,66:56,67:57,68:Z,69:$,70:ee,71:te,72:se,73:Fe,74:Be},t(A,[2,64]),{67:93,73:Fe,74:Be},t(ae,[2,83],{66:94,68:Z,69:$,70:ee,71:te,72:se}),t(U,[2,84]),t(U,[2,85]),t(U,[2,86]),t(U,[2,87]),t(U,[2,88]),t(Me,[2,89]),t(Me,[2,90]),{8:[1,96],23:99,24:97,30:98,38:22,40:95,42:r,43:23,48:u,54:g,56:N},{16:100,60:b,86:k,100:E,102:T},{41:[1,102],45:101,51:ne},{16:104,60:b,86:k,100:E,102:T},{47:[1,105]},{13:[1,106]},{13:[1,107]},{79:[1,108],81:[1,109]},{22:z,50:Y,59:110,60:K,82:W,84:111,85:112,86:Q,87:j,88:X,89:q,90:H},{60:[1,122]},{13:Pe,55:123},t(_,[2,72]),t(_,[2,138]),{22:z,50:Y,59:124,60:K,61:[1,125],82:W,84:111,85:112,86:Q,87:j,88:X,89:q,90:H},t(Re,[2,74]),{16:39,17:40,19:126,60:b,86:k,100:E,102:T,103:y},t(M,[2,16]),t(M,[2,17]),t(M,[2,18]),{11:127,12:Ge,39:[2,36]},t(re,[2,9],{16:85,17:86,15:130,18:[1,129],60:b,86:k,100:E,102:T,103:y}),t(re,[2,10]),t(_e,[2,55],{11:131,12:Ge}),t(De,[2,7]),{9:[1,132]},t(ue,[2,67]),{16:39,17:40,19:133,60:b,86:k,100:E,102:T,103:y},{13:[1,135],16:39,17:40,19:134,60:b,86:k,100:E,102:T,103:y},t(ae,[2,82],{66:136,68:Z,69:$,70:ee,71:te,72:se}),t(ae,[2,81]),{41:[1,137]},{23:99,24:97,30:98,38:22,40:138,42:r,43:23,48:u,54:g,56:N},{8:[1,139],41:[2,38]},{8:[1,140],41:[2,41]},{8:[1,141],41:[2,44]},t(_,[2,48],{39:[1,142]}),{41:[1,143]},t(_,[2,50]),{41:[2,61],45:144,51:ne},{47:[1,145]},{16:39,17:40,19:146,60:b,86:k,100:E,102:T,103:y},t(A,[2,91],{13:[1,147]}),t(A,[2,93],{13:[1,149],77:[1,148]}),t(A,[2,97],{13:[1,150],80:[1,151]}),{13:[1,152]},t(A,[2,105],{61:Ue}),t(ze,[2,107],{85:154,22:z,50:Y,60:K,82:W,86:Q,87:j,88:X,89:q,90:H}),t(x,[2,109]),t(x,[2,111]),t(x,[2,112]),t(x,[2,113]),t(x,[2,114]),t(x,[2,115]),t(x,[2,116]),t(x,[2,117]),t(x,[2,118]),t(x,[2,119]),t(A,[2,106]),t(_,[2,71]),t(A,[2,73],{61:Ue}),{60:[1,155]},t(M,[2,14]),{39:[2,37]},{13:[1,156]},{15:157,16:85,17:86,60:b,86:k,100:E,102:T,103:y},t(re,[2,12]),t(_e,[2,56]),{1:[2,4]},t(ue,[2,69]),t(ue,[2,68]),{16:39,17:40,19:158,60:b,86:k,100:E,102:T,103:y},t(ae,[2,80]),t(_,[2,34]),{41:[1,159]},{23:99,24:97,30:98,38:22,40:160,41:[2,39],42:r,43:23,48:u,54:g,56:N},{23:99,24:97,30:98,38:22,40:161,41:[2,42],42:r,43:23,48:u,54:g,56:N},{23:99,24:97,30:98,38:22,40:162,41:[2,45],42:r,43:23,48:u,54:g,56:N},{45:163,51:ne},t(_,[2,49]),{41:[2,62]},t(_,[2,52],{39:[1,164]}),t(A,[2,60]),t(A,[2,92]),t(A,[2,94]),t(A,[2,95],{77:[1,165]}),t(A,[2,98]),t(A,[2,99],{13:[1,166]}),t(A,[2,101],{13:[1,168],77:[1,167]}),{22:z,50:Y,60:K,82:W,84:169,85:112,86:Q,87:j,88:X,89:q,90:H},t(x,[2,110]),t(Re,[2,75]),{14:[1,170]},t(re,[2,11]),t(ue,[2,70]),t(_,[2,35]),{41:[2,40]},{41:[2,43]},{41:[2,46]},{41:[1,171]},{41:[1,173],45:172,51:ne},t(A,[2,96]),t(A,[2,100]),t(A,[2,102]),t(A,[2,103],{77:[1,174]}),t(ze,[2,108],{85:154,22:z,50:Y,60:K,82:W,86:Q,87:j,88:X,89:q,90:H}),t(_e,[2,8]),t(_,[2,51]),{41:[1,175]},t(_,[2,54]),t(A,[2,104]),t(_,[2,53])],defaultActions:{2:[2,1],3:[2,2],4:[2,3],127:[2,37],132:[2,4],144:[2,62],160:[2,40],161:[2,43],162:[2,46]},parseError:f(function(o,h){if(h.recoverable)this.trace(o);else{var p=new Error(o);throw p.hash=h,p}},"parseError"),parse:f(function(o){var h=this,p=[0],l=[],C=[null],e=[],J=this.table,s="",ce=0,Ye=0,Je=2,Ke=1,Ze=e.slice.call(arguments,1),D=Object.create(this.lexer),w={yy:{}};for(var Ne in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Ne)&&(w.yy[Ne]=this.yy[Ne]);D.setInput(o,w.yy),w.yy.lexer=D,w.yy.parser=this,typeof D.yylloc>"u"&&(D.yylloc={});var Le=D.yylloc;e.push(Le);var $e=D.options&&D.options.ranges;typeof w.yy.parseError=="function"?this.parseError=w.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function et(S){p.length=p.length-2*S,C.length=C.length-S,e.length=e.length-S}f(et,"popStack");function We(){var S;return S=l.pop()||D.lex()||Ke,typeof S!="number"&&(S instanceof Array&&(l=S,S=l.pop()),S=h.symbols_[S]||S),S}f(We,"lex");for(var B,V,L,xe,R={},oe,v,Qe,he;;){if(V=p[p.length-1],this.defaultActions[V]?L=this.defaultActions[V]:((B===null||typeof B>"u")&&(B=We()),L=J[V]&&J[V][B]),typeof L>"u"||!L.length||!L[0]){var ve="";he=[];for(oe in J[V])this.terminals_[oe]&&oe>Je&&he.push("'"+this.terminals_[oe]+"'");D.showPosition?ve="Parse error on line "+(ce+1)+`: +`+D.showPosition()+` +Expecting `+he.join(", ")+", got '"+(this.terminals_[B]||B)+"'":ve="Parse error on line "+(ce+1)+": Unexpected "+(B==Ke?"end of input":"'"+(this.terminals_[B]||B)+"'"),this.parseError(ve,{text:D.match,token:this.terminals_[B]||B,line:D.yylineno,loc:Le,expected:he})}if(L[0]instanceof Array&&L.length>1)throw new Error("Parse Error: multiple actions possible at state: "+V+", token: "+B);switch(L[0]){case 1:p.push(B),C.push(D.yytext),e.push(D.yylloc),p.push(L[1]),B=null,Ye=D.yyleng,s=D.yytext,ce=D.yylineno,Le=D.yylloc;break;case 2:if(v=this.productions_[L[1]][1],R.$=C[C.length-v],R._$={first_line:e[e.length-(v||1)].first_line,last_line:e[e.length-1].last_line,first_column:e[e.length-(v||1)].first_column,last_column:e[e.length-1].last_column},$e&&(R._$.range=[e[e.length-(v||1)].range[0],e[e.length-1].range[1]]),xe=this.performAction.apply(R,[s,Ye,ce,w.yy,L[1],C,e].concat(Ze)),typeof xe<"u")return xe;v&&(p=p.slice(0,-1*v*2),C=C.slice(0,-1*v),e=e.slice(0,-1*v)),p.push(this.productions_[L[1]][0]),C.push(R.$),e.push(R._$),Qe=J[p[p.length-2]][p[p.length-1]],p.push(Qe);break;case 3:return!0}}return!0},"parse")},He=(function(){var O={EOF:1,parseError:f(function(h,p){if(this.yy.parser)this.yy.parser.parseError(h,p);else throw new Error(h)},"parseError"),setInput:f(function(o,h){return this.yy=h||this.yy||{},this._input=o,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:f(function(){var o=this._input[0];this.yytext+=o,this.yyleng++,this.offset++,this.match+=o,this.matched+=o;var h=o.match(/(?:\r\n?|\n).*/g);return h?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),o},"input"),unput:f(function(o){var h=o.length,p=o.split(/(?:\r\n?|\n)/g);this._input=o+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-h),this.offset-=h;var l=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),p.length-1&&(this.yylineno-=p.length-1);var C=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:p?(p.length===l.length?this.yylloc.first_column:0)+l[l.length-p.length].length-p[0].length:this.yylloc.first_column-h},this.options.ranges&&(this.yylloc.range=[C[0],C[0]+this.yyleng-h]),this.yyleng=this.yytext.length,this},"unput"),more:f(function(){return this._more=!0,this},"more"),reject:f(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:f(function(o){this.unput(this.match.slice(o))},"less"),pastInput:f(function(){var o=this.matched.substr(0,this.matched.length-this.match.length);return(o.length>20?"...":"")+o.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:f(function(){var o=this.match;return o.length<20&&(o+=this._input.substr(0,20-o.length)),(o.substr(0,20)+(o.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:f(function(){var o=this.pastInput(),h=new Array(o.length+1).join("-");return o+this.upcomingInput()+` +`+h+"^"},"showPosition"),test_match:f(function(o,h){var p,l,C;if(this.options.backtrack_lexer&&(C={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(C.yylloc.range=this.yylloc.range.slice(0))),l=o[0].match(/(?:\r\n?|\n).*/g),l&&(this.yylineno+=l.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:l?l[l.length-1].length-l[l.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+o[0].length},this.yytext+=o[0],this.match+=o[0],this.matches=o,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(o[0].length),this.matched+=o[0],p=this.performAction.call(this,this.yy,this,h,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),p)return p;if(this._backtrack){for(var e in C)this[e]=C[e];return!1}return!1},"test_match"),next:f(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var o,h,p,l;this._more||(this.yytext="",this.match="");for(var C=this._currentRules(),e=0;eh[0].length)){if(h=p,l=e,this.options.backtrack_lexer){if(o=this.test_match(p,C[e]),o!==!1)return o;if(this._backtrack){h=!1;continue}else return!1}else if(!this.options.flex)break}return h?(o=this.test_match(h,C[l]),o!==!1?o:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:f(function(){var h=this.next();return h||this.lex()},"lex"),begin:f(function(h){this.conditionStack.push(h)},"begin"),popState:f(function(){var h=this.conditionStack.length-1;return h>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:f(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:f(function(h){return h=this.conditionStack.length-1-Math.abs(h||0),h>=0?this.conditionStack[h]:"INITIAL"},"topState"),pushState:f(function(h){this.begin(h)},"pushState"),stateStackSize:f(function(){return this.conditionStack.length},"stateStackSize"),options:{},performAction:f(function(h,p,l,C){switch(l){case 0:return 62;case 1:return 63;case 2:return 64;case 3:return 65;case 4:break;case 5:break;case 6:return this.begin("acc_title"),33;case 7:return this.popState(),"acc_title_value";case 8:return this.begin("acc_descr"),35;case 9:return this.popState(),"acc_descr_value";case 10:this.begin("acc_descr_multiline");break;case 11:this.popState();break;case 12:return"acc_descr_multiline_value";case 13:return 8;case 14:break;case 15:return 7;case 16:return 7;case 17:return"EDGE_STATE";case 18:this.begin("callback_name");break;case 19:this.popState();break;case 20:this.popState(),this.begin("callback_args");break;case 21:return 79;case 22:this.popState();break;case 23:return 80;case 24:this.popState();break;case 25:return"STR";case 26:this.begin("string");break;case 27:return 82;case 28:return 57;case 29:return this.begin("namespace"),42;case 30:return this.popState(),8;case 31:break;case 32:return this.begin("namespace-body"),39;case 33:this.popState(),this.less(0);break;case 34:return this.popState(),41;case 35:return"EOF_IN_STRUCT";case 36:return 8;case 37:break;case 38:return"EDGE_STATE";case 39:return this.begin("class"),48;case 40:return this.popState(),8;case 41:break;case 42:return this.popState(),this.popState(),41;case 43:return this.begin("class-body"),39;case 44:return this.popState(),41;case 45:return"EOF_IN_STRUCT";case 46:return"EDGE_STATE";case 47:return"OPEN_IN_STRUCT";case 48:break;case 49:return"MEMBER";case 50:return 83;case 51:return 75;case 52:return 76;case 53:return 78;case 54:return 54;case 55:return 56;case 56:return 46;case 57:return 47;case 58:return 81;case 59:this.popState();break;case 60:return"GENERICTYPE";case 61:this.begin("generic");break;case 62:this.popState();break;case 63:return"BQUOTE_STR";case 64:this.begin("bqstring");break;case 65:return 77;case 66:return 77;case 67:return 77;case 68:return 77;case 69:return 69;case 70:return 69;case 71:return 71;case 72:return 71;case 73:return 70;case 74:return 68;case 75:return 72;case 76:return 73;case 77:return 74;case 78:return 22;case 79:return 44;case 80:return 100;case 81:return 18;case 82:return"PLUS";case 83:return 87;case 84:return 61;case 85:return 89;case 86:return 89;case 87:return 90;case 88:return"EQUALS";case 89:return"EQUALS";case 90:return 60;case 91:return 12;case 92:return 14;case 93:return"PUNCTUATION";case 94:return 86;case 95:return 102;case 96:return 50;case 97:return 50;case 98:return 9}},"anonymous"),rules:[/^(?:.*direction\s+TB[^\n]*)/,/^(?:.*direction\s+BT[^\n]*)/,/^(?:.*direction\s+RL[^\n]*)/,/^(?:.*direction\s+LR[^\n]*)/,/^(?:%%(?!\{)*[^\n]*(\r?\n?)+)/,/^(?:%%[^\n]*(\r?\n)*)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:classDiagram-v2\b)/,/^(?:classDiagram\b)/,/^(?:\[\*\])/,/^(?:call[\s]+)/,/^(?:\([\s]*\))/,/^(?:\()/,/^(?:[^(]*)/,/^(?:\))/,/^(?:[^)]*)/,/^(?:["])/,/^(?:[^"]*)/,/^(?:["])/,/^(?:style\b)/,/^(?:classDef\b)/,/^(?:namespace\b)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:[{])/,/^(?:[}])/,/^(?:[}])/,/^(?:$)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:\[\*\])/,/^(?:class\b)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:[}])/,/^(?:[{])/,/^(?:[}])/,/^(?:$)/,/^(?:\[\*\])/,/^(?:[{])/,/^(?:[\n])/,/^(?:[^{}\n]*)/,/^(?:cssClass\b)/,/^(?:callback\b)/,/^(?:link\b)/,/^(?:click\b)/,/^(?:note for\b)/,/^(?:note\b)/,/^(?:<<)/,/^(?:>>)/,/^(?:href\b)/,/^(?:[~])/,/^(?:[^~]*)/,/^(?:~)/,/^(?:[`])/,/^(?:[^`]+)/,/^(?:[`])/,/^(?:_self\b)/,/^(?:_blank\b)/,/^(?:_parent\b)/,/^(?:_top\b)/,/^(?:\s*<\|)/,/^(?:\s*\|>)/,/^(?:\s*>)/,/^(?:\s*<)/,/^(?:\s*\*)/,/^(?:\s*o\b)/,/^(?:\s*\(\))/,/^(?:--)/,/^(?:\.\.)/,/^(?::{1}[^:\n;]+)/,/^(?::{3})/,/^(?:-)/,/^(?:\.)/,/^(?:\+)/,/^(?::)/,/^(?:,)/,/^(?:#)/,/^(?:#)/,/^(?:%)/,/^(?:=)/,/^(?:=)/,/^(?:\w+)/,/^(?:\[)/,/^(?:\])/,/^(?:[!"#$%&'*+,-.`?\\/])/,/^(?:[0-9]+)/,/^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/,/^(?:\s)/,/^(?:\s)/,/^(?:$)/],conditions:{"namespace-body":{rules:[26,29,34,35,36,37,38,39,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},namespace:{rules:[26,29,30,31,32,33,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},"class-body":{rules:[26,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},class:{rules:[26,40,41,42,43,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},acc_descr_multiline:{rules:[11,12,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},acc_descr:{rules:[9,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},acc_title:{rules:[7,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},callback_args:{rules:[22,23,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},callback_name:{rules:[19,20,21,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},href:{rules:[26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},struct:{rules:[26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},generic:{rules:[26,50,51,52,53,54,55,56,57,58,59,60,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},bqstring:{rules:[26,50,51,52,53,54,55,56,57,58,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},string:{rules:[24,25,26,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,87,88,89,90,91,92,93,94,95,96,98],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,8,10,13,14,15,16,17,18,26,27,28,29,39,50,51,52,53,54,55,56,57,58,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98],inclusive:!0}}};return O})();Se.lexer=He;function le(){this.yy={}}return f(le,"Parser"),le.prototype=Se,Se.Parser=le,new le})();we.parser=we;var Bt=we,je=["#","+","~","-",""],Xe=class{static{f(this,"ClassMember")}constructor(t,i){this.memberType=i,this.visibility="",this.classifier="",this.text="";const a=ft(t,F());this.parseMember(a)}getDisplayDetails(){let t=this.visibility+G(this.id);this.memberType==="method"&&(t+=`(${G(this.parameters.trim())})`,this.returnType&&(t+=" : "+G(this.returnType))),t=t.trim();const i=this.parseClassifier();return{displayText:t,cssStyle:i}}parseMember(t){let i="";if(this.memberType==="method"){const r=/([#+~-])?(.+)\((.*)\)([\s$*])?(.*)([$*])?/.exec(t);if(r){const c=r[1]?r[1].trim():"";if(je.includes(c)&&(this.visibility=c),this.id=r[2],this.parameters=r[3]?r[3].trim():"",i=r[4]?r[4].trim():"",this.returnType=r[5]?r[5].trim():"",i===""){const u=this.returnType.substring(this.returnType.length-1);/[$*]/.exec(u)&&(i=u,this.returnType=this.returnType.substring(0,this.returnType.length-1))}}}else{const n=t.length,r=t.substring(0,1),c=t.substring(n-1);je.includes(r)&&(this.visibility=r),/[$*]/.exec(c)&&(i=c),this.id=t.substring(this.visibility===""?0:1,i===""?n:n-1)}this.classifier=i,this.id=this.id.startsWith(" ")?" "+this.id.trim():this.id.trim();const a=`${this.visibility?"\\"+this.visibility:""}${G(this.id)}${this.memberType==="method"?`(${G(this.parameters)})${this.returnType?" : "+G(this.returnType):""}`:""}`;this.text=a.replaceAll("<","<").replaceAll(">",">"),this.text.startsWith("\\<")&&(this.text=this.text.replace("\\<","~"))}parseClassifier(){switch(this.classifier){case"*":return"font-style:italic;";case"$":return"text-decoration:underline;";default:return""}}},pe="classId-",qe=0,P=f(t=>I.sanitizeText(t,F()),"sanitizeText"),_t=class Ve{constructor(){this.relations=[],this.classes=new Map,this.styleClasses=new Map,this.notes=new Map,this.interfaces=[],this.namespaces=new Map,this.namespaceCounter=0,this.namespaceStack=[],this.diagramId="",this.functions=[],this.lineType={LINE:0,DOTTED_LINE:1},this.relationType={AGGREGATION:0,EXTENSION:1,COMPOSITION:2,DEPENDENCY:3,LOLLIPOP:4},this.setupToolTips=f(i=>{const a=gt();de(i).select("svg").selectAll("g").filter(function(){return de(this).attr("title")!==null}).on("mouseover",c=>{const u=de(c.currentTarget),d=u.attr("title");if(!d)return;const m=c.currentTarget.getBoundingClientRect();a.transition().duration(200).style("opacity",".9"),a.html(rt.sanitize(d)).style("left",`${window.scrollX+m.left+m.width/2}px`).style("top",`${window.scrollY+m.bottom+4}px`),u.classed("hover",!0)}).on("mouseout",c=>{a.transition().duration(500).style("opacity",0),de(c.currentTarget).classed("hover",!1)})},"setupToolTips"),this.direction="TB",this.setAccTitle=ut,this.getAccTitle=lt,this.setAccDescription=ct,this.getAccDescription=ot,this.setDiagramTitle=ht,this.getDiagramTitle=dt,this.getConfig=f(()=>F().class,"getConfig"),this.functions.push(this.setupToolTips.bind(this)),this.clear(),this.addRelation=this.addRelation.bind(this),this.addClassesToNamespace=this.addClassesToNamespace.bind(this),this.addNamespace=this.addNamespace.bind(this),this.popNamespace=this.popNamespace.bind(this),this.setCssClass=this.setCssClass.bind(this),this.addMembers=this.addMembers.bind(this),this.addClass=this.addClass.bind(this),this.setClassLabel=this.setClassLabel.bind(this),this.addAnnotation=this.addAnnotation.bind(this),this.addMember=this.addMember.bind(this),this.cleanupLabel=this.cleanupLabel.bind(this),this.addNote=this.addNote.bind(this),this.defineClass=this.defineClass.bind(this),this.setDirection=this.setDirection.bind(this),this.setLink=this.setLink.bind(this),this.bindFunctions=this.bindFunctions.bind(this),this.clear=this.clear.bind(this),this.setTooltip=this.setTooltip.bind(this),this.setClickEvent=this.setClickEvent.bind(this),this.setCssStyle=this.setCssStyle.bind(this)}static{f(this,"ClassDB")}splitClassNameAndType(i){const a=I.sanitizeText(i,F());let n="",r=a;if(a.indexOf("~")>0){const c=a.split("~");r=P(c[0]),n=P(c[1])}return{className:r,type:n}}setClassLabel(i,a){const n=I.sanitizeText(i,F());a&&(a=P(a));const{className:r}=this.splitClassNameAndType(n);this.classes.get(r).label=a,this.classes.get(r).text=`${a}${this.classes.get(r).type?`<${this.classes.get(r).type}>`:""}`}addClass(i){const a=I.sanitizeText(i,F()),{className:n,type:r}=this.splitClassNameAndType(a);if(this.classes.has(n))return;const c=I.sanitizeText(n,F());this.classes.set(c,{id:c,type:r,label:c,text:`${c}${r?`<${r}>`:""}`,shape:"classBox",cssClasses:"default",methods:[],members:[],annotations:[],styles:[],domId:pe+c+"-"+qe}),qe++}addInterface(i,a){const n={id:`interface${this.interfaces.length}`,label:i,classId:a};this.interfaces.push(n)}setDiagramId(i){this.diagramId=i}lookUpDomId(i){const a=I.sanitizeText(i,F());if(this.classes.has(a)){const n=this.classes.get(a).domId;return this.diagramId?`${this.diagramId}-${n}`:n}throw new Error("Class not found: "+a)}clear(){this.relations=[],this.classes=new Map,this.notes=new Map,this.interfaces=[],this.functions=[],this.functions.push(this.setupToolTips.bind(this)),this.namespaces=new Map,this.namespaceCounter=0,this.namespaceStack=[],this.diagramId="",this.direction="TB",pt()}getClass(i){return this.classes.get(i)}getClasses(){return this.classes}getRelations(){return this.relations}getNote(i){const a=typeof i=="number"?`note${i}`:i;return this.notes.get(a)}getNotes(){return this.notes}addRelation(i){Ie.debug("Adding relation: "+JSON.stringify(i));const a=[this.relationType.LOLLIPOP,this.relationType.AGGREGATION,this.relationType.COMPOSITION,this.relationType.DEPENDENCY,this.relationType.EXTENSION];i.relation.type1===this.relationType.LOLLIPOP&&!a.includes(i.relation.type2)?(this.addClass(i.id2),this.addInterface(i.id1,i.id2),i.id1=`interface${this.interfaces.length-1}`):i.relation.type2===this.relationType.LOLLIPOP&&!a.includes(i.relation.type1)?(this.addClass(i.id1),this.addInterface(i.id2,i.id1),i.id2=`interface${this.interfaces.length-1}`):(this.addClass(i.id1),this.addClass(i.id2)),i.id1=this.splitClassNameAndType(i.id1).className,i.id2=this.splitClassNameAndType(i.id2).className,i.relationTitle1=I.sanitizeText(i.relationTitle1.trim(),F()),i.relationTitle2=I.sanitizeText(i.relationTitle2.trim(),F()),this.relations.push(i)}addAnnotation(i,a){const n=this.splitClassNameAndType(i).className;this.classes.get(n).annotations.push(a)}addMember(i,a){this.addClass(i);const n=this.splitClassNameAndType(i).className,r=this.classes.get(n);if(typeof a=="string"){const c=a.trim();c.startsWith("<<")&&c.endsWith(">>")?r.annotations.push(P(c.substring(2,c.length-2))):c.indexOf(")")>0?r.methods.push(new Xe(c,"method")):c&&r.members.push(new Xe(c,"attribute"))}}addMembers(i,a){Array.isArray(a)&&(a.reverse(),a.forEach(n=>this.addMember(i,n)))}addNote(i,a){const n=this.notes.size,r={id:`note${n}`,class:a,text:i,index:n};return this.notes.set(r.id,r),r.id}cleanupLabel(i){return i.startsWith(":")&&(i=i.substring(1)),P(i.trim())}setCssClass(i,a){i.split(",").forEach(n=>{let r=n;/\d/.exec(n[0])&&(r=pe+r),r=this.splitClassNameAndType(r).className;const c=this.classes.get(r);c&&(c.cssClasses+=" "+a)})}defineClass(i,a){for(const n of i){let r=this.styleClasses.get(n);r===void 0&&(r={id:n,styles:[],textStyles:[]},this.styleClasses.set(n,r)),a&&a.forEach(c=>{if(/color/.exec(c)){const u=c.replace("fill","bgFill");r.textStyles.push(u)}r.styles.push(c)}),this.classes.forEach(c=>{c.cssClasses.includes(n)&&c.styles.push(...a.flatMap(u=>u.split(",")))})}}setTooltip(i,a){i.split(",").forEach(n=>{if(a!==void 0){const r=this.splitClassNameAndType(n).className,c=this.classes.get(r);c&&(c.tooltip=P(a))}})}getTooltip(i,a){return a&&this.namespaces.has(a)?this.namespaces.get(a).classes.get(i).tooltip:this.classes.get(i).tooltip}setLink(i,a,n){const r=F();i.split(",").forEach(c=>{let u=c;/\d/.exec(c[0])&&(u=pe+u),u=this.splitClassNameAndType(u).className;const d=this.classes.get(u);d&&(d.link=Oe.formatUrl(a,r),r.securityLevel==="sandbox"?d.linkTarget="_top":typeof n=="string"?d.linkTarget=P(n):d.linkTarget="_blank")}),this.setCssClass(i,"clickable")}setClickEvent(i,a,n){i.split(",").forEach(r=>{this.setClickFunc(r,a,n);const c=this.splitClassNameAndType(r).className,u=this.classes.get(c);u&&(u.haveCallback=!0)}),this.setCssClass(i,"clickable")}setClickFunc(i,a,n){const r=I.sanitizeText(i,F());if(F().securityLevel!=="loose"||a===void 0)return;const u=this.splitClassNameAndType(r).className;if(this.classes.has(u)){let d=[];if(typeof n=="string"){d=n.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);for(let m=0;m{const m=this.lookUpDomId(u),g=document.querySelector(`[id="${m}"]`);g!==null&&g.addEventListener("click",()=>{Oe.runFunc(a,...d)},!1)})}}bindFunctions(i){this.functions.forEach(a=>{a(i)})}escapeHtml(i){return i.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}getDirection(){return this.direction}setDirection(i){this.direction=i}static resolveQualifiedId(i,a){const n=a.at(-1);return n?`${n}.${i}`:i}static getAncestorIds(i){const a=i.split("."),n=new Array(a.length);n[0]=a[0];for(let r=1;r0?c[u-1]:void 0,g=u===c.length-1,N=g&&a?a:r[u];this.namespaces.has(d)?g&&(this.namespaces.get(d).explicit=!0):this.namespaces.set(d,this.createNamespaceNode(d,N,m,g)),m&&this.linkParentChild(m,d)}return n}popNamespace(){this.namespaceStack.pop()}getNamespace(i){return this.namespaces.get(i)}getNamespaces(){return this.namespaces}addClassesToNamespace(i,a,n){if(this.namespaces.has(i)){for(const r of a){const{className:c}=this.splitClassNameAndType(r),u=this.getClass(c);u.parent=i,this.namespaces.get(i).classes.set(c,u)}for(const r of n){const c=this.getNote(r);c.parent=i,this.namespaces.get(i).notes.set(r,c)}}}setCssStyle(i,a){const n=this.classes.get(i);if(!(!a||!n))for(const r of a)r.includes(",")?n.styles.push(...r.split(",")):n.styles.push(r)}getArrowMarker(i){let a;switch(i){case 0:a="aggregation";break;case 1:a="extension";break;case 2:a="composition";break;case 3:a="dependency";break;case 4:a="lollipop";break;default:a="none"}return a}resolveExplicitAncestor(i){let a=i;for(;a;){const n=this.namespaces.get(a);if(!n)return;if(n.explicit)return a;a=n.parent}}getData(){const i=[],a=[],n=F(),r=n.class?.hierarchicalNamespaces??!0;for(const u of this.namespaces.values()){if(!r&&!u.explicit)continue;const d={id:u.id,label:r?u.label:u.id,isGroup:!0,padding:n.class.padding??16,shape:"rect",cssStyles:[],look:n.look,parentId:r?u.parent:void 0};i.push(d)}for(const u of this.classes.values()){const d=r?u.parent:this.resolveExplicitAncestor(u.parent),m={...u,type:void 0,isGroup:!1,parentId:d,look:n.look};i.push(m)}for(const u of this.notes.values()){const d=r?u.parent:this.resolveExplicitAncestor(u.parent),m={id:u.id,label:u.text,isGroup:!1,shape:"note",padding:n.class.padding??6,cssStyles:["text-align: left","white-space: nowrap",`fill: ${n.themeVariables.noteBkgColor}`,`stroke: ${n.themeVariables.noteBorderColor}`],look:n.look,parentId:d,labelType:"markdown"};i.push(m);const g=this.classes.get(u.class)?.id;if(g){const N={id:`edgeNote${u.index}`,start:u.id,end:g,type:"normal",thickness:"normal",classes:"relation",arrowTypeStart:"none",arrowTypeEnd:"none",arrowheadStyle:"",labelStyle:[""],style:["fill: none"],pattern:"dotted",look:n.look};a.push(N)}}for(const u of this.interfaces){const d={id:u.id,label:u.label,isGroup:!1,shape:"rect",cssStyles:["opacity: 0;"],look:n.look};i.push(d)}let c=0;for(const u of this.relations){c++;const d={id:At(u.id1,u.id2,{prefix:"id",counter:c}),start:u.id1,end:u.id2,type:"normal",label:u.title,labelpos:"c",thickness:"normal",classes:"relation",arrowTypeStart:this.getArrowMarker(u.relation.type1),arrowTypeEnd:this.getArrowMarker(u.relation.type2),startLabelRight:u.relationTitle1==="none"?"":u.relationTitle1,endLabelLeft:u.relationTitle2==="none"?"":u.relationTitle2,arrowheadStyle:"",labelStyle:["display: inline-block"],style:u.style||"",pattern:u.relation.lineType==1?"dashed":"solid",look:n.look,labelType:"markdown"};a.push(d)}return{nodes:i,edges:a,other:{},config:n,direction:this.getDirection()}}},mt=f(t=>`g.classGroup text { + fill: ${t.nodeBorder||t.classText}; + stroke: none; + font-family: ${t.fontFamily}; + font-size: 10px; + + .title { + font-weight: bolder; + } + +} + + .cluster-label text { + fill: ${t.titleColor}; + } + .cluster-label span { + color: ${t.titleColor}; + } + .cluster-label span p { + background-color: transparent; + } + + .cluster rect { + fill: ${t.clusterBkg}; + stroke: ${t.clusterBorder}; + stroke-width: 1px; + } + + .cluster text { + fill: ${t.titleColor}; + } + + .cluster span { + color: ${t.titleColor}; + } + +.nodeLabel, .edgeLabel { + color: ${t.classText}; +} + +.noteLabel .nodeLabel, .noteLabel .edgeLabel { + color: ${t.noteTextColor}; +} +.edgeLabel .label rect { + fill: ${t.mainBkg}; +} +.label text { + fill: ${t.classText}; +} + +.labelBkg { + background: ${t.mainBkg}; +} +.edgeLabel .label span { + background: ${t.mainBkg}; +} + +.classTitle { + font-weight: bolder; +} +.node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${t.mainBkg}; + stroke: ${t.nodeBorder}; + stroke-width: ${t.strokeWidth}; + } + + +.divider { + stroke: ${t.nodeBorder}; + stroke-width: 1; +} + +g.clickable { + cursor: pointer; +} + +g.classGroup rect { + fill: ${t.mainBkg}; + stroke: ${t.nodeBorder}; +} + +g.classGroup line { + stroke: ${t.nodeBorder}; + stroke-width: 1; +} + +.classLabel .box { + stroke: none; + stroke-width: 0; + fill: ${t.mainBkg}; + opacity: 0.5; +} + +.classLabel .label { + fill: ${t.nodeBorder}; + font-size: 10px; +} + +.relation { + stroke: ${t.lineColor}; + stroke-width: ${t.strokeWidth}; + fill: none; +} + +.dashed-line{ + stroke-dasharray: 3; +} + +.dotted-line{ + stroke-dasharray: 1 2; +} + +[id$="-compositionStart"], .composition { + fill: ${t.lineColor} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-compositionEnd"], .composition { + fill: ${t.lineColor} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-dependencyStart"], .dependency { + fill: ${t.lineColor} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-dependencyEnd"], .dependency { + fill: ${t.lineColor} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-extensionStart"], .extension { + fill: transparent !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-extensionEnd"], .extension { + fill: transparent !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-aggregationStart"], .aggregation { + fill: transparent !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-aggregationEnd"], .aggregation { + fill: transparent !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-lollipopStart"], .lollipop { + fill: ${t.mainBkg} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +[id$="-lollipopEnd"], .lollipop { + fill: ${t.mainBkg} !important; + stroke: ${t.lineColor} !important; + stroke-width: 1; +} + +.edgeTerminals { + font-size: 11px; + line-height: initial; +} + +.classTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${t.textColor}; +} + +.edgeLabel[data-look="neo"] { + background-color: ${t.edgeLabelBackground}; + p { + background-color: ${t.edgeLabelBackground}; + } + rect { + opacity: 0.5; + background-color: ${t.edgeLabelBackground}; + fill: ${t.edgeLabelBackground}; + } + text-align: center; +} + ${tt()} +`,"getStyles"),St=mt,Ct=f((t,i="TB")=>{if(!t.doc)return i;let a=i;for(const n of t.doc)n.stmt==="dir"&&(a=n.value);return a},"getDir"),bt=f(function(t,i){return i.db.getClasses()},"getClasses"),kt=f(async function(t,i,a,n){Ie.info("REF0:"),Ie.info("Drawing class diagram (v3)",i);const{securityLevel:r,state:c,layout:u}=F();n.db.setDiagramId(i);const d=n.db.getData(),m=st(i,r);d.type=n.type,d.layoutAlgorithm=at(u),d.nodeSpacing=c?.nodeSpacing||50,d.rankSpacing=c?.rankSpacing||50,d.markers=["aggregation","extension","composition","dependency","lollipop"],d.diagramId=i,await nt(d,m);const g=8;Oe.insertTitle(m,"classDiagramTitleText",c?.titleTopMargin??25,n.db.getDiagramTitle()),it(m,g,"classDiagram",c?.useMaxWidth??!0)},"draw"),Nt={getClasses:bt,draw:kt,getDir:Ct};export{_t as C,Bt as a,Nt as c,St as s}; diff --git a/packages/tempo/public/v4/assets/chunks/chunk-XXDRQBXY.C52oJrTB.js b/packages/tempo/public/v4/assets/chunks/chunk-XXDRQBXY.C52oJrTB.js new file mode 100644 index 00000000..4f61b1fb --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/chunk-XXDRQBXY.C52oJrTB.js @@ -0,0 +1 @@ +import{_ as a,j as o}from"../app.CbekdYod.js";var g=a((t,e)=>{let n;return e==="sandbox"&&(n=o("#i"+t)),(e==="sandbox"?o(n.nodes()[0].contentDocument.body):o("body")).select(`[id="${t}"]`)},"getDiagramElement");export{g}; diff --git a/packages/tempo/public/v4/assets/chunks/classDiagram-ZZMXUADV.BCySuZ6w.js b/packages/tempo/public/v4/assets/chunks/classDiagram-ZZMXUADV.BCySuZ6w.js new file mode 100644 index 00000000..f2685b10 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/classDiagram-ZZMXUADV.BCySuZ6w.js @@ -0,0 +1 @@ +import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K.E0Eenl49.js";import{_ as i}from"../app.CbekdYod.js";import"./chunk-5VM5RSS4.-zPOtr2J.js";import"./chunk-XXDRQBXY.C52oJrTB.js";import"./chunk-POPQ4Y6H.DEs7vhGS.js";import"./chunk-F27PBJKO.CcniKEe6.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/classDiagram-v2-VYDZK3BY.BCySuZ6w.js b/packages/tempo/public/v4/assets/chunks/classDiagram-v2-VYDZK3BY.BCySuZ6w.js new file mode 100644 index 00000000..f2685b10 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/classDiagram-v2-VYDZK3BY.BCySuZ6w.js @@ -0,0 +1 @@ +import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K.E0Eenl49.js";import{_ as i}from"../app.CbekdYod.js";import"./chunk-5VM5RSS4.-zPOtr2J.js";import"./chunk-XXDRQBXY.C52oJrTB.js";import"./chunk-POPQ4Y6H.DEs7vhGS.js";import"./chunk-F27PBJKO.CcniKEe6.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/cose-bilkent-JH36ORCC.DH3k0r7k.js b/packages/tempo/public/v4/assets/chunks/cose-bilkent-JH36ORCC.DH3k0r7k.js new file mode 100644 index 00000000..d137a195 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/cose-bilkent-JH36ORCC.DH3k0r7k.js @@ -0,0 +1 @@ +import{b5 as $,b6 as lt,_ as V,l as k,j as gt}from"../app.CbekdYod.js";import{c as J}from"./cytoscape.esm.DdbNXSXN.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var tt={exports:{}},Z={exports:{}},Q={exports:{}},q;function ut(){return q||(q=1,(function(G,b){(function(I,L){G.exports=L()})($,function(){return(function(N){var I={};function L(o){if(I[o])return I[o].exports;var e=I[o]={i:o,l:!1,exports:{}};return N[o].call(e.exports,e,e.exports,L),e.l=!0,e.exports}return L.m=N,L.c=I,L.i=function(o){return o},L.d=function(o,e,t){L.o(o,e)||Object.defineProperty(o,e,{configurable:!1,enumerable:!0,get:t})},L.n=function(o){var e=o&&o.__esModule?function(){return o.default}:function(){return o};return L.d(e,"a",e),e},L.o=function(o,e){return Object.prototype.hasOwnProperty.call(o,e)},L.p="",L(L.s=26)})([(function(N,I,L){function o(){}o.QUALITY=1,o.DEFAULT_CREATE_BENDS_AS_NEEDED=!1,o.DEFAULT_INCREMENTAL=!1,o.DEFAULT_ANIMATION_ON_LAYOUT=!0,o.DEFAULT_ANIMATION_DURING_LAYOUT=!1,o.DEFAULT_ANIMATION_PERIOD=50,o.DEFAULT_UNIFORM_LEAF_NODE_SIZES=!1,o.DEFAULT_GRAPH_MARGIN=15,o.NODE_DIMENSIONS_INCLUDE_LABELS=!1,o.SIMPLE_NODE_SIZE=40,o.SIMPLE_NODE_HALF_SIZE=o.SIMPLE_NODE_SIZE/2,o.EMPTY_COMPOUND_NODE_SIZE=40,o.MIN_EDGE_LENGTH=1,o.WORLD_BOUNDARY=1e6,o.INITIAL_WORLD_BOUNDARY=o.WORLD_BOUNDARY/1e3,o.WORLD_CENTER_X=1200,o.WORLD_CENTER_Y=900,N.exports=o}),(function(N,I,L){var o=L(2),e=L(8),t=L(9);function i(g,n,d){o.call(this,d),this.isOverlapingSourceAndTarget=!1,this.vGraphObject=d,this.bendpoints=[],this.source=g,this.target=n}i.prototype=Object.create(o.prototype);for(var l in o)i[l]=o[l];i.prototype.getSource=function(){return this.source},i.prototype.getTarget=function(){return this.target},i.prototype.isInterGraph=function(){return this.isInterGraph},i.prototype.getLength=function(){return this.length},i.prototype.isOverlapingSourceAndTarget=function(){return this.isOverlapingSourceAndTarget},i.prototype.getBendpoints=function(){return this.bendpoints},i.prototype.getLca=function(){return this.lca},i.prototype.getSourceInLca=function(){return this.sourceInLca},i.prototype.getTargetInLca=function(){return this.targetInLca},i.prototype.getOtherEnd=function(g){if(this.source===g)return this.target;if(this.target===g)return this.source;throw"Node is not incident with this edge"},i.prototype.getOtherEndInGraph=function(g,n){for(var d=this.getOtherEnd(g),r=n.getGraphManager().getRoot();;){if(d.getOwner()==n)return d;if(d.getOwner()==r)break;d=d.getOwner().getParent()}return null},i.prototype.updateLength=function(){var g=new Array(4);this.isOverlapingSourceAndTarget=e.getIntersection(this.target.getRect(),this.source.getRect(),g),this.isOverlapingSourceAndTarget||(this.lengthX=g[0]-g[2],this.lengthY=g[1]-g[3],Math.abs(this.lengthX)<1&&(this.lengthX=t.sign(this.lengthX)),Math.abs(this.lengthY)<1&&(this.lengthY=t.sign(this.lengthY)),this.length=Math.sqrt(this.lengthX*this.lengthX+this.lengthY*this.lengthY))},i.prototype.updateLengthSimple=function(){this.lengthX=this.target.getCenterX()-this.source.getCenterX(),this.lengthY=this.target.getCenterY()-this.source.getCenterY(),Math.abs(this.lengthX)<1&&(this.lengthX=t.sign(this.lengthX)),Math.abs(this.lengthY)<1&&(this.lengthY=t.sign(this.lengthY)),this.length=Math.sqrt(this.lengthX*this.lengthX+this.lengthY*this.lengthY)},N.exports=i}),(function(N,I,L){function o(e){this.vGraphObject=e}N.exports=o}),(function(N,I,L){var o=L(2),e=L(10),t=L(13),i=L(0),l=L(16),g=L(4);function n(r,h,a,p){a==null&&p==null&&(p=h),o.call(this,p),r.graphManager!=null&&(r=r.graphManager),this.estimatedSize=e.MIN_VALUE,this.inclusionTreeDepth=e.MAX_VALUE,this.vGraphObject=p,this.edges=[],this.graphManager=r,a!=null&&h!=null?this.rect=new t(h.x,h.y,a.width,a.height):this.rect=new t}n.prototype=Object.create(o.prototype);for(var d in o)n[d]=o[d];n.prototype.getEdges=function(){return this.edges},n.prototype.getChild=function(){return this.child},n.prototype.getOwner=function(){return this.owner},n.prototype.getWidth=function(){return this.rect.width},n.prototype.setWidth=function(r){this.rect.width=r},n.prototype.getHeight=function(){return this.rect.height},n.prototype.setHeight=function(r){this.rect.height=r},n.prototype.getCenterX=function(){return this.rect.x+this.rect.width/2},n.prototype.getCenterY=function(){return this.rect.y+this.rect.height/2},n.prototype.getCenter=function(){return new g(this.rect.x+this.rect.width/2,this.rect.y+this.rect.height/2)},n.prototype.getLocation=function(){return new g(this.rect.x,this.rect.y)},n.prototype.getRect=function(){return this.rect},n.prototype.getDiagonal=function(){return Math.sqrt(this.rect.width*this.rect.width+this.rect.height*this.rect.height)},n.prototype.getHalfTheDiagonal=function(){return Math.sqrt(this.rect.height*this.rect.height+this.rect.width*this.rect.width)/2},n.prototype.setRect=function(r,h){this.rect.x=r.x,this.rect.y=r.y,this.rect.width=h.width,this.rect.height=h.height},n.prototype.setCenter=function(r,h){this.rect.x=r-this.rect.width/2,this.rect.y=h-this.rect.height/2},n.prototype.setLocation=function(r,h){this.rect.x=r,this.rect.y=h},n.prototype.moveBy=function(r,h){this.rect.x+=r,this.rect.y+=h},n.prototype.getEdgeListToNode=function(r){var h=[],a=this;return a.edges.forEach(function(p){if(p.target==r){if(p.source!=a)throw"Incorrect edge source!";h.push(p)}}),h},n.prototype.getEdgesBetween=function(r){var h=[],a=this;return a.edges.forEach(function(p){if(!(p.source==a||p.target==a))throw"Incorrect edge source and/or target";(p.target==r||p.source==r)&&h.push(p)}),h},n.prototype.getNeighborsList=function(){var r=new Set,h=this;return h.edges.forEach(function(a){if(a.source==h)r.add(a.target);else{if(a.target!=h)throw"Incorrect incidency!";r.add(a.source)}}),r},n.prototype.withChildren=function(){var r=new Set,h,a;if(r.add(this),this.child!=null)for(var p=this.child.getNodes(),v=0;vh&&(this.rect.x-=(this.labelWidth-h)/2,this.setWidth(this.labelWidth)),this.labelHeight>a&&(this.labelPos=="center"?this.rect.y-=(this.labelHeight-a)/2:this.labelPos=="top"&&(this.rect.y-=this.labelHeight-a),this.setHeight(this.labelHeight))}}},n.prototype.getInclusionTreeDepth=function(){if(this.inclusionTreeDepth==e.MAX_VALUE)throw"assert failed";return this.inclusionTreeDepth},n.prototype.transform=function(r){var h=this.rect.x;h>i.WORLD_BOUNDARY?h=i.WORLD_BOUNDARY:h<-i.WORLD_BOUNDARY&&(h=-i.WORLD_BOUNDARY);var a=this.rect.y;a>i.WORLD_BOUNDARY?a=i.WORLD_BOUNDARY:a<-i.WORLD_BOUNDARY&&(a=-i.WORLD_BOUNDARY);var p=new g(h,a),v=r.inverseTransformPoint(p);this.setLocation(v.x,v.y)},n.prototype.getLeft=function(){return this.rect.x},n.prototype.getRight=function(){return this.rect.x+this.rect.width},n.prototype.getTop=function(){return this.rect.y},n.prototype.getBottom=function(){return this.rect.y+this.rect.height},n.prototype.getParent=function(){return this.owner==null?null:this.owner.getParent()},N.exports=n}),(function(N,I,L){function o(e,t){e==null&&t==null?(this.x=0,this.y=0):(this.x=e,this.y=t)}o.prototype.getX=function(){return this.x},o.prototype.getY=function(){return this.y},o.prototype.setX=function(e){this.x=e},o.prototype.setY=function(e){this.y=e},o.prototype.getDifference=function(e){return new DimensionD(this.x-e.x,this.y-e.y)},o.prototype.getCopy=function(){return new o(this.x,this.y)},o.prototype.translate=function(e){return this.x+=e.width,this.y+=e.height,this},N.exports=o}),(function(N,I,L){var o=L(2),e=L(10),t=L(0),i=L(6),l=L(3),g=L(1),n=L(13),d=L(12),r=L(11);function h(p,v,D){o.call(this,D),this.estimatedSize=e.MIN_VALUE,this.margin=t.DEFAULT_GRAPH_MARGIN,this.edges=[],this.nodes=[],this.isConnected=!1,this.parent=p,v!=null&&v instanceof i?this.graphManager=v:v!=null&&v instanceof Layout&&(this.graphManager=v.graphManager)}h.prototype=Object.create(o.prototype);for(var a in o)h[a]=o[a];h.prototype.getNodes=function(){return this.nodes},h.prototype.getEdges=function(){return this.edges},h.prototype.getGraphManager=function(){return this.graphManager},h.prototype.getParent=function(){return this.parent},h.prototype.getLeft=function(){return this.left},h.prototype.getRight=function(){return this.right},h.prototype.getTop=function(){return this.top},h.prototype.getBottom=function(){return this.bottom},h.prototype.isConnected=function(){return this.isConnected},h.prototype.add=function(p,v,D){if(v==null&&D==null){var u=p;if(this.graphManager==null)throw"Graph has no graph mgr!";if(this.getNodes().indexOf(u)>-1)throw"Node already in graph!";return u.owner=this,this.getNodes().push(u),u}else{var T=p;if(!(this.getNodes().indexOf(v)>-1&&this.getNodes().indexOf(D)>-1))throw"Source or target not in graph!";if(!(v.owner==D.owner&&v.owner==this))throw"Both owners must be this graph!";return v.owner!=D.owner?null:(T.source=v,T.target=D,T.isInterGraph=!1,this.getEdges().push(T),v.edges.push(T),D!=v&&D.edges.push(T),T)}},h.prototype.remove=function(p){var v=p;if(p instanceof l){if(v==null)throw"Node is null!";if(!(v.owner!=null&&v.owner==this))throw"Owner graph is invalid!";if(this.graphManager==null)throw"Owner graph manager is invalid!";for(var D=v.edges.slice(),u,T=D.length,y=0;y-1&&f>-1))throw"Source and/or target doesn't know this edge!";u.source.edges.splice(s,1),u.target!=u.source&&u.target.edges.splice(f,1);var O=u.source.owner.getEdges().indexOf(u);if(O==-1)throw"Not in owner's edge list!";u.source.owner.getEdges().splice(O,1)}},h.prototype.updateLeftTop=function(){for(var p=e.MAX_VALUE,v=e.MAX_VALUE,D,u,T,y=this.getNodes(),O=y.length,s=0;sD&&(p=D),v>u&&(v=u)}return p==e.MAX_VALUE?null:(y[0].getParent().paddingLeft!=null?T=y[0].getParent().paddingLeft:T=this.margin,this.left=v-T,this.top=p-T,new d(this.left,this.top))},h.prototype.updateBounds=function(p){for(var v=e.MAX_VALUE,D=-e.MAX_VALUE,u=e.MAX_VALUE,T=-e.MAX_VALUE,y,O,s,f,c,E=this.nodes,A=E.length,m=0;my&&(v=y),Ds&&(u=s),Ty&&(v=y),Ds&&(u=s),T=this.nodes.length){var A=0;D.forEach(function(m){m.owner==p&&A++}),A==this.nodes.length&&(this.isConnected=!0)}},N.exports=h}),(function(N,I,L){var o,e=L(1);function t(i){o=L(5),this.layout=i,this.graphs=[],this.edges=[]}t.prototype.addRoot=function(){var i=this.layout.newGraph(),l=this.layout.newNode(null),g=this.add(i,l);return this.setRootGraph(g),this.rootGraph},t.prototype.add=function(i,l,g,n,d){if(g==null&&n==null&&d==null){if(i==null)throw"Graph is null!";if(l==null)throw"Parent node is null!";if(this.graphs.indexOf(i)>-1)throw"Graph already in this graph mgr!";if(this.graphs.push(i),i.parent!=null)throw"Already has a parent!";if(l.child!=null)throw"Already has a child!";return i.parent=l,l.child=i,i}else{d=g,n=l,g=i;var r=n.getOwner(),h=d.getOwner();if(!(r!=null&&r.getGraphManager()==this))throw"Source not in this graph mgr!";if(!(h!=null&&h.getGraphManager()==this))throw"Target not in this graph mgr!";if(r==h)return g.isInterGraph=!1,r.add(g,n,d);if(g.isInterGraph=!0,g.source=n,g.target=d,this.edges.indexOf(g)>-1)throw"Edge already in inter-graph edge list!";if(this.edges.push(g),!(g.source!=null&&g.target!=null))throw"Edge source and/or target is null!";if(!(g.source.edges.indexOf(g)==-1&&g.target.edges.indexOf(g)==-1))throw"Edge already in source and/or target incidency list!";return g.source.edges.push(g),g.target.edges.push(g),g}},t.prototype.remove=function(i){if(i instanceof o){var l=i;if(l.getGraphManager()!=this)throw"Graph not in this graph mgr";if(!(l==this.rootGraph||l.parent!=null&&l.parent.graphManager==this))throw"Invalid parent node!";var g=[];g=g.concat(l.getEdges());for(var n,d=g.length,r=0;r=i.getRight()?l[0]+=Math.min(i.getX()-t.getX(),t.getRight()-i.getRight()):i.getX()<=t.getX()&&i.getRight()>=t.getRight()&&(l[0]+=Math.min(t.getX()-i.getX(),i.getRight()-t.getRight())),t.getY()<=i.getY()&&t.getBottom()>=i.getBottom()?l[1]+=Math.min(i.getY()-t.getY(),t.getBottom()-i.getBottom()):i.getY()<=t.getY()&&i.getBottom()>=t.getBottom()&&(l[1]+=Math.min(t.getY()-i.getY(),i.getBottom()-t.getBottom()));var d=Math.abs((i.getCenterY()-t.getCenterY())/(i.getCenterX()-t.getCenterX()));i.getCenterY()===t.getCenterY()&&i.getCenterX()===t.getCenterX()&&(d=1);var r=d*l[0],h=l[1]/d;l[0]r)return l[0]=g,l[1]=a,l[2]=d,l[3]=E,!1;if(nd)return l[0]=h,l[1]=n,l[2]=f,l[3]=r,!1;if(gd?(l[0]=v,l[1]=D,C=!0):(l[0]=p,l[1]=a,C=!0):S===w&&(g>d?(l[0]=h,l[1]=a,C=!0):(l[0]=u,l[1]=D,C=!0)),-Y===w?d>g?(l[2]=c,l[3]=E,M=!0):(l[2]=f,l[3]=s,M=!0):Y===w&&(d>g?(l[2]=O,l[3]=s,M=!0):(l[2]=A,l[3]=E,M=!0)),C&&M)return!1;if(g>d?n>r?(x=this.getCardinalDirection(S,w,4),F=this.getCardinalDirection(Y,w,2)):(x=this.getCardinalDirection(-S,w,3),F=this.getCardinalDirection(-Y,w,1)):n>r?(x=this.getCardinalDirection(-S,w,1),F=this.getCardinalDirection(-Y,w,3)):(x=this.getCardinalDirection(S,w,2),F=this.getCardinalDirection(Y,w,4)),!C)switch(x){case 1:P=a,U=g+-y/w,l[0]=U,l[1]=P;break;case 2:U=u,P=n+T*w,l[0]=U,l[1]=P;break;case 3:P=D,U=g+y/w,l[0]=U,l[1]=P;break;case 4:U=v,P=n+-T*w,l[0]=U,l[1]=P;break}if(!M)switch(F){case 1:X=s,_=d+-R/w,l[2]=_,l[3]=X;break;case 2:_=A,X=r+m*w,l[2]=_,l[3]=X;break;case 3:X=E,_=d+R/w,l[2]=_,l[3]=X;break;case 4:_=c,X=r+-m*w,l[2]=_,l[3]=X;break}}return!1},e.getCardinalDirection=function(t,i,l){return t>i?l:1+l%4},e.getIntersection=function(t,i,l,g){if(g==null)return this.getIntersection2(t,i,l);var n=t.x,d=t.y,r=i.x,h=i.y,a=l.x,p=l.y,v=g.x,D=g.y,u=void 0,T=void 0,y=void 0,O=void 0,s=void 0,f=void 0,c=void 0,E=void 0,A=void 0;return y=h-d,s=n-r,c=r*d-n*h,O=D-p,f=a-v,E=v*p-a*D,A=y*f-O*s,A===0?null:(u=(s*E-f*c)/A,T=(O*c-y*E)/A,new o(u,T))},e.angleOfVector=function(t,i,l,g){var n=void 0;return t!==l?(n=Math.atan((g-i)/(l-t)),l0?1:e<0?-1:0},o.floor=function(e){return e<0?Math.ceil(e):Math.floor(e)},o.ceil=function(e){return e<0?Math.floor(e):Math.ceil(e)},N.exports=o}),(function(N,I,L){function o(){}o.MAX_VALUE=2147483647,o.MIN_VALUE=-2147483648,N.exports=o}),(function(N,I,L){var o=(function(){function n(d,r){for(var h=0;h"u"?"undefined":o(t);return t==null||i!="object"&&i!="function"},N.exports=e}),(function(N,I,L){function o(a){if(Array.isArray(a)){for(var p=0,v=Array(a.length);p0&&p;){for(y.push(s[0]);y.length>0&&p;){var f=y[0];y.splice(0,1),T.add(f);for(var c=f.getEdges(),u=0;u-1&&s.splice(R,1)}T=new Set,O=new Map}}return a},h.prototype.createDummyNodesForBendpoints=function(a){for(var p=[],v=a.source,D=this.graphManager.calcLowestCommonAncestor(a.source,a.target),u=0;u0){for(var D=this.edgeToDummyNodes.get(v),u=0;u=0&&p.splice(E,1);var A=O.getNeighborsList();A.forEach(function(C){if(v.indexOf(C)<0){var M=D.get(C),S=M-1;S==1&&f.push(C),D.set(C,S)}})}v=v.concat(f),(p.length==1||p.length==2)&&(u=!0,T=p[0])}return T},h.prototype.setGraphManager=function(a){this.graphManager=a},N.exports=h}),(function(N,I,L){function o(){}o.seed=1,o.x=0,o.nextDouble=function(){return o.x=Math.sin(o.seed++)*1e4,o.x-Math.floor(o.x)},N.exports=o}),(function(N,I,L){var o=L(4);function e(t,i){this.lworldOrgX=0,this.lworldOrgY=0,this.ldeviceOrgX=0,this.ldeviceOrgY=0,this.lworldExtX=1,this.lworldExtY=1,this.ldeviceExtX=1,this.ldeviceExtY=1}e.prototype.getWorldOrgX=function(){return this.lworldOrgX},e.prototype.setWorldOrgX=function(t){this.lworldOrgX=t},e.prototype.getWorldOrgY=function(){return this.lworldOrgY},e.prototype.setWorldOrgY=function(t){this.lworldOrgY=t},e.prototype.getWorldExtX=function(){return this.lworldExtX},e.prototype.setWorldExtX=function(t){this.lworldExtX=t},e.prototype.getWorldExtY=function(){return this.lworldExtY},e.prototype.setWorldExtY=function(t){this.lworldExtY=t},e.prototype.getDeviceOrgX=function(){return this.ldeviceOrgX},e.prototype.setDeviceOrgX=function(t){this.ldeviceOrgX=t},e.prototype.getDeviceOrgY=function(){return this.ldeviceOrgY},e.prototype.setDeviceOrgY=function(t){this.ldeviceOrgY=t},e.prototype.getDeviceExtX=function(){return this.ldeviceExtX},e.prototype.setDeviceExtX=function(t){this.ldeviceExtX=t},e.prototype.getDeviceExtY=function(){return this.ldeviceExtY},e.prototype.setDeviceExtY=function(t){this.ldeviceExtY=t},e.prototype.transformX=function(t){var i=0,l=this.lworldExtX;return l!=0&&(i=this.ldeviceOrgX+(t-this.lworldOrgX)*this.ldeviceExtX/l),i},e.prototype.transformY=function(t){var i=0,l=this.lworldExtY;return l!=0&&(i=this.ldeviceOrgY+(t-this.lworldOrgY)*this.ldeviceExtY/l),i},e.prototype.inverseTransformX=function(t){var i=0,l=this.ldeviceExtX;return l!=0&&(i=this.lworldOrgX+(t-this.ldeviceOrgX)*this.lworldExtX/l),i},e.prototype.inverseTransformY=function(t){var i=0,l=this.ldeviceExtY;return l!=0&&(i=this.lworldOrgY+(t-this.ldeviceOrgY)*this.lworldExtY/l),i},e.prototype.inverseTransformPoint=function(t){var i=new o(this.inverseTransformX(t.x),this.inverseTransformY(t.y));return i},N.exports=e}),(function(N,I,L){function o(r){if(Array.isArray(r)){for(var h=0,a=Array(r.length);ht.ADAPTATION_LOWER_NODE_LIMIT&&(this.coolingFactor=Math.max(this.coolingFactor*t.COOLING_ADAPTATION_FACTOR,this.coolingFactor-(r-t.ADAPTATION_LOWER_NODE_LIMIT)/(t.ADAPTATION_UPPER_NODE_LIMIT-t.ADAPTATION_LOWER_NODE_LIMIT)*this.coolingFactor*(1-t.COOLING_ADAPTATION_FACTOR))),this.maxNodeDisplacement=t.MAX_NODE_DISPLACEMENT_INCREMENTAL):(r>t.ADAPTATION_LOWER_NODE_LIMIT?this.coolingFactor=Math.max(t.COOLING_ADAPTATION_FACTOR,1-(r-t.ADAPTATION_LOWER_NODE_LIMIT)/(t.ADAPTATION_UPPER_NODE_LIMIT-t.ADAPTATION_LOWER_NODE_LIMIT)*(1-t.COOLING_ADAPTATION_FACTOR)):this.coolingFactor=1,this.initialCoolingFactor=this.coolingFactor,this.maxNodeDisplacement=t.MAX_NODE_DISPLACEMENT),this.maxIterations=Math.max(this.getAllNodes().length*5,this.maxIterations),this.totalDisplacementThreshold=this.displacementThresholdPerNode*this.getAllNodes().length,this.repulsionRange=this.calcRepulsionRange()},n.prototype.calcSpringForces=function(){for(var r=this.getAllEdges(),h,a=0;a0&&arguments[0]!==void 0?arguments[0]:!0,h=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,a,p,v,D,u=this.getAllNodes(),T;if(this.useFRGridVariant)for(this.totalIterations%t.GRID_CALCULATION_CHECK_PERIOD==1&&r&&this.updateGrid(),T=new Set,a=0;ay||T>y)&&(r.gravitationForceX=-this.gravityConstant*v,r.gravitationForceY=-this.gravityConstant*D)):(y=h.getEstimatedSize()*this.compoundGravityRangeFactor,(u>y||T>y)&&(r.gravitationForceX=-this.gravityConstant*v*this.compoundGravityConstant,r.gravitationForceY=-this.gravityConstant*D*this.compoundGravityConstant))},n.prototype.isConverged=function(){var r,h=!1;return this.totalIterations>this.maxIterations/3&&(h=Math.abs(this.totalDisplacement-this.oldTotalDisplacement)<2),r=this.totalDisplacement=u.length||y>=u[0].length)){for(var O=0;On}}]),l})();N.exports=i}),(function(N,I,L){var o=(function(){function i(l,g){for(var n=0;n2&&arguments[2]!==void 0?arguments[2]:1,d=arguments.length>3&&arguments[3]!==void 0?arguments[3]:-1,r=arguments.length>4&&arguments[4]!==void 0?arguments[4]:-1;e(this,i),this.sequence1=l,this.sequence2=g,this.match_score=n,this.mismatch_penalty=d,this.gap_penalty=r,this.iMax=l.length+1,this.jMax=g.length+1,this.grid=new Array(this.iMax);for(var h=0;h=0;l--){var g=this.listeners[l];g.event===t&&g.callback===i&&this.listeners.splice(l,1)}},e.emit=function(t,i){for(var l=0;lg.coolingFactor*g.maxNodeDisplacement&&(this.displacementX=g.coolingFactor*g.maxNodeDisplacement*t.sign(this.displacementX)),Math.abs(this.displacementY)>g.coolingFactor*g.maxNodeDisplacement&&(this.displacementY=g.coolingFactor*g.maxNodeDisplacement*t.sign(this.displacementY)),this.child==null?this.moveBy(this.displacementX,this.displacementY):this.child.getNodes().length==0?this.moveBy(this.displacementX,this.displacementY):this.propogateDisplacementToChildren(this.displacementX,this.displacementY),g.totalDisplacement+=Math.abs(this.displacementX)+Math.abs(this.displacementY),this.springForceX=0,this.springForceY=0,this.repulsionForceX=0,this.repulsionForceY=0,this.gravitationForceX=0,this.gravitationForceY=0,this.displacementX=0,this.displacementY=0},i.prototype.propogateDisplacementToChildren=function(g,n){for(var d=this.getChild().getNodes(),r,h=0;h0)this.positionNodesRadially(s);else{this.reduceTrees(),this.graphManager.resetAllNodesToApplyGravitation();var f=new Set(this.getAllNodes()),c=this.nodesWithGravity.filter(function(E){return f.has(E)});this.graphManager.setAllNodesToApplyGravitation(c),this.positionNodesRandomly()}}return this.initSpringEmbedder(),this.runSpringEmbedder(),!0},y.prototype.tick=function(){if(this.totalIterations++,this.totalIterations===this.maxIterations&&!this.isTreeGrowing&&!this.isGrowthFinished)if(this.prunedNodesAll.length>0)this.isTreeGrowing=!0;else return!0;if(this.totalIterations%d.CONVERGENCE_CHECK_PERIOD==0&&!this.isTreeGrowing&&!this.isGrowthFinished){if(this.isConverged())if(this.prunedNodesAll.length>0)this.isTreeGrowing=!0;else return!0;this.coolingCycle++,this.layoutQuality==0?this.coolingAdjuster=this.coolingCycle:this.layoutQuality==1&&(this.coolingAdjuster=this.coolingCycle/3),this.coolingFactor=Math.max(this.initialCoolingFactor-Math.pow(this.coolingCycle,Math.log(100*(this.initialCoolingFactor-this.finalTemperature))/Math.log(this.maxCoolingCycle))/100*this.coolingAdjuster,this.finalTemperature),this.animationPeriod=Math.ceil(this.initialAnimationPeriod*Math.sqrt(this.coolingFactor))}if(this.isTreeGrowing){if(this.growTreeIterations%10==0)if(this.prunedNodesAll.length>0){this.graphManager.updateBounds(),this.updateGrid(),this.growTree(this.prunedNodesAll),this.graphManager.resetAllNodesToApplyGravitation();var s=new Set(this.getAllNodes()),f=this.nodesWithGravity.filter(function(A){return s.has(A)});this.graphManager.setAllNodesToApplyGravitation(f),this.graphManager.updateBounds(),this.updateGrid(),this.coolingFactor=d.DEFAULT_COOLING_FACTOR_INCREMENTAL}else this.isTreeGrowing=!1,this.isGrowthFinished=!0;this.growTreeIterations++}if(this.isGrowthFinished){if(this.isConverged())return!0;this.afterGrowthIterations%10==0&&(this.graphManager.updateBounds(),this.updateGrid()),this.coolingFactor=d.DEFAULT_COOLING_FACTOR_INCREMENTAL*((100-this.afterGrowthIterations)/100),this.afterGrowthIterations++}var c=!this.isTreeGrowing&&!this.isGrowthFinished,E=this.growTreeIterations%10==1&&this.isTreeGrowing||this.afterGrowthIterations%10==1&&this.isGrowthFinished;return this.totalDisplacement=0,this.graphManager.updateBounds(),this.calcSpringForces(),this.calcRepulsionForces(c,E),this.calcGravitationalForces(),this.moveNodes(),this.animate(),!1},y.prototype.getPositionsData=function(){for(var s=this.graphManager.getAllNodes(),f={},c=0;c1){var C;for(C=0;CE&&(E=Math.floor(R.y)),m=Math.floor(R.x+n.DEFAULT_COMPONENT_SEPERATION)}this.transform(new a(r.WORLD_CENTER_X-R.x/2,r.WORLD_CENTER_Y-R.y/2))},y.radialLayout=function(s,f,c){var E=Math.max(this.maxDiagonalInTree(s),n.DEFAULT_RADIAL_SEPARATION);y.branchRadialLayout(f,null,0,359,0,E);var A=u.calculateBounds(s),m=new T;m.setDeviceOrgX(A.getMinX()),m.setDeviceOrgY(A.getMinY()),m.setWorldOrgX(c.x),m.setWorldOrgY(c.y);for(var R=0;R1;){var X=_[0];_.splice(0,1);var H=w.indexOf(X);H>=0&&w.splice(H,1),U--,x--}f!=null?P=(w.indexOf(_[0])+1)%U:P=0;for(var W=Math.abs(E-c)/x,B=P;F!=x;B=++B%U){var K=w[B].getOtherEnd(s);if(K!=f){var j=(c+F*W)%360,ht=(j+W)%360;y.branchRadialLayout(K,s,j,ht,A+m,m),F++}}},y.maxDiagonalInTree=function(s){for(var f=v.MIN_VALUE,c=0;cf&&(f=A)}return f},y.prototype.calcRepulsionRange=function(){return 2*(this.level+1)*this.idealEdgeLength},y.prototype.groupZeroDegreeMembers=function(){var s=this,f={};this.memberGroups={},this.idToDummyNode={};for(var c=[],E=this.graphManager.getAllNodes(),A=0;A"u"&&(f[C]=[]),f[C]=f[C].concat(m)}Object.keys(f).forEach(function(M){if(f[M].length>1){var S="DummyCompound_"+M;s.memberGroups[S]=f[M];var Y=f[M][0].getParent(),w=new l(s.graphManager);w.id=S,w.paddingLeft=Y.paddingLeft||0,w.paddingRight=Y.paddingRight||0,w.paddingBottom=Y.paddingBottom||0,w.paddingTop=Y.paddingTop||0,s.idToDummyNode[S]=w;var x=s.getGraphManager().add(s.newGraph(),w),F=Y.getChild();F.add(w);for(var U=0;U=0;s--){var f=this.compoundOrder[s],c=f.id,E=f.paddingLeft,A=f.paddingTop;this.adjustLocations(this.tiledMemberPack[c],f.rect.x,f.rect.y,E,A)}},y.prototype.repopulateZeroDegreeMembers=function(){var s=this,f=this.tiledZeroDegreePack;Object.keys(f).forEach(function(c){var E=s.idToDummyNode[c],A=E.paddingLeft,m=E.paddingTop;s.adjustLocations(f[c],E.rect.x,E.rect.y,A,m)})},y.prototype.getToBeTiled=function(s){var f=s.id;if(this.toBeTiled[f]!=null)return this.toBeTiled[f];var c=s.getChild();if(c==null)return this.toBeTiled[f]=!1,!1;for(var E=c.getNodes(),A=0;A0)return this.toBeTiled[f]=!1,!1;if(m.getChild()==null){this.toBeTiled[m.id]=!1;continue}if(!this.getToBeTiled(m))return this.toBeTiled[f]=!1,!1}return this.toBeTiled[f]=!0,!0},y.prototype.getNodeDegree=function(s){s.id;for(var f=s.getEdges(),c=0,E=0;EM&&(M=Y.rect.height)}c+=M+s.verticalPadding}},y.prototype.tileCompoundMembers=function(s,f){var c=this;this.tiledMemberPack=[],Object.keys(s).forEach(function(E){var A=f[E];c.tiledMemberPack[E]=c.tileNodes(s[E],A.paddingLeft+A.paddingRight),A.rect.width=c.tiledMemberPack[E].width,A.rect.height=c.tiledMemberPack[E].height})},y.prototype.tileNodes=function(s,f){var c=n.TILING_PADDING_VERTICAL,E=n.TILING_PADDING_HORIZONTAL,A={rows:[],rowWidth:[],rowHeight:[],width:0,height:f,verticalPadding:c,horizontalPadding:E};s.sort(function(C,M){return C.rect.width*C.rect.height>M.rect.width*M.rect.height?-1:C.rect.width*C.rect.height0&&(R+=s.horizontalPadding),s.rowWidth[c]=R,s.width0&&(C+=s.verticalPadding);var M=0;C>s.rowHeight[c]&&(M=s.rowHeight[c],s.rowHeight[c]=C,M=s.rowHeight[c]-M),s.height+=M,s.rows[c].push(f)},y.prototype.getShortestRowIndex=function(s){for(var f=-1,c=Number.MAX_VALUE,E=0;Ec&&(f=E,c=s.rowWidth[E]);return f},y.prototype.canAddHorizontal=function(s,f,c){var E=this.getShortestRowIndex(s);if(E<0)return!0;var A=s.rowWidth[E];if(A+s.horizontalPadding+f<=s.width)return!0;var m=0;s.rowHeight[E]0&&(m=c+s.verticalPadding-s.rowHeight[E]);var R;s.width-A>=f+s.horizontalPadding?R=(s.height+m)/(A+f+s.horizontalPadding):R=(s.height+m)/s.width,m=c+s.verticalPadding;var C;return s.widthm&&f!=c){E.splice(-1,1),s.rows[c].push(A),s.rowWidth[f]=s.rowWidth[f]-m,s.rowWidth[c]=s.rowWidth[c]+m,s.width=s.rowWidth[instance.getLongestRowIndex(s)];for(var R=Number.MIN_VALUE,C=0;CR&&(R=E[C].height);f>0&&(R+=s.verticalPadding);var M=s.rowHeight[f]+s.rowHeight[c];s.rowHeight[f]=R,s.rowHeight[c]0)for(var F=A;F<=m;F++)x[0]+=this.grid[F][R-1].length+this.grid[F][R].length-1;if(m0)for(var F=R;F<=C;F++)x[3]+=this.grid[A-1][F].length+this.grid[A][F].length-1;for(var U=v.MAX_VALUE,P,_,X=0;X0){var C;C=T.getGraphManager().add(T.newGraph(),c),this.processChildrenList(C,f,T)}}},a.prototype.stop=function(){return this.stopped=!0,this};var v=function(u){u("layout","cose-bilkent",a)};typeof cytoscape<"u"&&v(cytoscape),I.exports=v})])})})(tt);var ct=tt.exports;const pt=lt(ct);J.use(pt);function et(G,b){G.forEach(N=>{const I={id:N.id,labelText:N.label,height:N.height,width:N.width,padding:N.padding??0};Object.keys(N).forEach(L=>{["id","label","height","width","padding","x","y"].includes(L)||(I[L]=N[L])}),b.add({group:"nodes",data:I,position:{x:N.x??0,y:N.y??0}})})}V(et,"addNodes");function rt(G,b){G.forEach(N=>{const I={id:N.id,source:N.start,target:N.end};Object.keys(N).forEach(L=>{["id","start","end"].includes(L)||(I[L]=N[L])}),b.add({group:"edges",data:I})})}V(rt,"addEdges");function it(G){return new Promise(b=>{const N=gt("body").append("div").attr("id","cy").attr("style","display:none"),I=J({container:document.getElementById("cy"),style:[{selector:"edge",style:{"curve-style":"bezier"}}]});N.remove(),et(G.nodes,I),rt(G.edges,I),I.nodes().forEach(function(o){o.layoutDimensions=()=>{const e=o.data();return{w:e.width,h:e.height}}});const L={name:"cose-bilkent",quality:"proof",styleEnabled:!1,animate:!1};I.layout(L).run(),I.ready(o=>{k.info("Cytoscape ready",o),b(I)})})}V(it,"createCytoscapeInstance");function nt(G){return G.nodes().map(b=>{const N=b.data(),I=b.position(),L={id:N.id,x:I.x,y:I.y};return Object.keys(N).forEach(o=>{o!=="id"&&(L[o]=N[o])}),L})}V(nt,"extractPositionedNodes");function ot(G){return G.edges().map(b=>{const N=b.data(),I=b._private.rscratch,L={id:N.id,source:N.source,target:N.target,startX:I.startX,startY:I.startY,midX:I.midX,midY:I.midY,endX:I.endX,endY:I.endY};return Object.keys(N).forEach(o=>{["id","source","target"].includes(o)||(L[o]=N[o])}),L})}V(ot,"extractPositionedEdges");async function st(G,b){k.debug("Starting cose-bilkent layout algorithm");try{at(G);const N=await it(G),I=nt(N),L=ot(N);return k.debug(`Layout completed: ${I.length} nodes, ${L.length} edges`),{nodes:I,edges:L}}catch(N){throw k.error("Error in cose-bilkent layout algorithm:",N),N}}V(st,"executeCoseBilkentLayout");function at(G){if(!G)throw new Error("Layout data is required");if(!G.config)throw new Error("Configuration is required in layout data");if(!G.rootNode)throw new Error("Root node is required");if(!G.nodes||!Array.isArray(G.nodes))throw new Error("No nodes found in layout data");if(!Array.isArray(G.edges))throw new Error("Edges array is required in layout data");return!0}V(at,"validateLayoutData");var dt=V(async(G,b,{insertCluster:N,insertEdge:I,insertEdgeLabel:L,insertMarkers:o,insertNode:e,log:t,positionEdgeLabel:i},{algorithm:l})=>{const g={},n={},d=b.select("g");o(d,G.markers,G.type,G.diagramId);const r=d.insert("g").attr("class","subgraphs"),h=d.insert("g").attr("class","edgePaths"),a=d.insert("g").attr("class","edgeLabels"),p=d.insert("g").attr("class","nodes");t.debug("Inserting nodes into DOM for dimension calculation"),await Promise.all(G.nodes.map(async u=>{if(u.isGroup){const T={...u};n[u.id]=T,g[u.id]=T,await N(r,u)}else{const T={...u};g[u.id]=T;const y=await e(p,u,{config:G.config,dir:G.direction||"TB"}),O=y.node().getBBox();T.width=O.width,T.height=O.height,T.domId=y,t.debug(`Node ${u.id} dimensions: ${O.width}x${O.height}`)}})),t.debug("Running cose-bilkent layout algorithm");const v={...G,nodes:G.nodes.map(u=>{const T=g[u.id];return{...u,width:T.width,height:T.height}})},D=await st(v,G.config);t.debug("Positioning nodes based on layout results"),D.nodes.forEach(u=>{const T=g[u.id];T?.domId&&(T.domId.attr("transform",`translate(${u.x}, ${u.y})`),T.x=u.x,T.y=u.y,t.debug(`Positioned node ${T.id} at center (${u.x}, ${u.y})`))}),D.edges.forEach(u=>{const T=G.edges.find(y=>y.id===u.id);T&&(T.points=[{x:u.startX,y:u.startY},{x:u.midX,y:u.midY},{x:u.endX,y:u.endY}])}),t.debug("Inserting and positioning edges"),await Promise.all(G.edges.map(async u=>{await L(a,u);const T=g[u.start??""],y=g[u.end??""];if(T&&y){const O=D.edges.find(s=>s.id===u.id);if(O){t.debug("APA01 positionedEdge",O);const s={...u},f=I(h,s,n,G.type,T,y,G.diagramId);i(s,f)}else{const s={...u,points:[{x:T.x||0,y:T.y||0},{x:y.x||0,y:y.y||0}]},f=I(h,s,n,G.type,T,y,G.diagramId);i(s,f)}}})),t.debug("Cose-bilkent rendering completed")},"render"),Tt=dt;export{Tt as render}; diff --git a/packages/tempo/public/v4/assets/chunks/cynefin-OW5HDTMX.C9PKCYHo.js b/packages/tempo/public/v4/assets/chunks/cynefin-OW5HDTMX.C9PKCYHo.js new file mode 100644 index 00000000..bb916ab6 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/cynefin-OW5HDTMX.C9PKCYHo.js @@ -0,0 +1,178 @@ +import{V as et}from"./framework.DNL3hc5c.js";var RI=Object.create,Ds=Object.defineProperty,AI=Object.getOwnPropertyDescriptor,Ad=Object.getOwnPropertyNames,EI=Object.getPrototypeOf,CI=Object.prototype.hasOwnProperty,i=(e,t)=>Ds(e,"name",{value:t,configurable:!0}),_I=(e,t)=>function(){return e&&(t=(0,e[Ad(e)[0]])(e=0)),t},H=(e,t)=>function(){return t||(0,e[Ad(e)[0]])((t={exports:{}}).exports,t),t.exports},Vr=(e,t)=>{for(var r in t)Ds(e,r,{get:t[r],enumerable:!0})},Ed=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of Ad(t))!CI.call(e,a)&&a!==r&&Ds(e,a,{get:()=>t[a],enumerable:!(n=AI(t,a))||n.enumerable});return e},Ll=(e,t,r)=>(Ed(e,t,"default"),r),Cd=(e,t,r)=>(r=e!=null?RI(EI(e)):{},Ed(Ds(r,"default",{value:e,enumerable:!0}),e)),_d=e=>Ed(Ds({},"__esModule",{value:!0}),e),Dl={};Vr(Dl,{AnnotatedTextEdit:()=>mr,ChangeAnnotation:()=>an,ChangeAnnotationIdentifier:()=>Ke,CodeAction:()=>ef,CodeActionContext:()=>Qc,CodeActionKind:()=>Zc,CodeActionTriggerKind:()=>Xi,CodeDescription:()=>Nc,CodeLens:()=>tf,Color:()=>Co,ColorInformation:()=>Cc,ColorPresentation:()=>_c,Command:()=>nn,CompletionItem:()=>zc,CompletionItemKind:()=>Lc,CompletionItemLabelDetails:()=>Fc,CompletionItemTag:()=>xc,CompletionList:()=>jc,CreateFile:()=>ya,DeleteFile:()=>va,Diagnostic:()=>Vi,DiagnosticRelatedInformation:()=>_o,DiagnosticSeverity:()=>wc,DiagnosticTag:()=>Ic,DocumentHighlight:()=>Vc,DocumentHighlightKind:()=>Wc,DocumentLink:()=>nf,DocumentSymbol:()=>Jc,DocumentUri:()=>Rc,EOL:()=>zg,FoldingRange:()=>Sc,FoldingRangeKind:()=>bc,FormattingOptions:()=>rf,Hover:()=>Bc,InlayHint:()=>pf,InlayHintKind:()=>wo,InlayHintLabelPart:()=>Io,InlineCompletionContext:()=>Tf,InlineCompletionItem:()=>hf,InlineCompletionList:()=>yf,InlineCompletionTriggerKind:()=>gf,InlineValueContext:()=>df,InlineValueEvaluatableExpression:()=>ff,InlineValueText:()=>uf,InlineValueVariableLookup:()=>cf,InsertReplaceEdit:()=>Mc,InsertTextFormat:()=>Dc,InsertTextMode:()=>Gc,Location:()=>Wi,LocationLink:()=>Ec,MarkedString:()=>Yi,MarkupContent:()=>Ta,MarkupKind:()=>So,OptionalVersionedTextDocumentIdentifier:()=>Hi,ParameterInformation:()=>Uc,Position:()=>ie,Range:()=>Q,RenameFile:()=>ga,SelectedCompletionInfo:()=>vf,SelectionRange:()=>af,SemanticTokenModifiers:()=>of,SemanticTokenTypes:()=>sf,SemanticTokens:()=>lf,SignatureInformation:()=>Kc,StringValue:()=>mf,SymbolInformation:()=>Yc,SymbolKind:()=>qc,SymbolTag:()=>Hc,TextDocument:()=>Rf,TextDocumentEdit:()=>qi,TextDocumentIdentifier:()=>Pc,TextDocumentItem:()=>Oc,TextEdit:()=>Yt,URI:()=>Eo,VersionedTextDocumentIdentifier:()=>kc,WorkspaceChange:()=>Fg,WorkspaceEdit:()=>bo,WorkspaceFolder:()=>$f,WorkspaceSymbol:()=>Xc,integer:()=>Ac,uinteger:()=>Ki});var Rc,Eo,Ac,Ki,ie,Q,Wi,Ec,Co,Cc,_c,bc,Sc,_o,wc,Ic,Nc,Vi,nn,Yt,an,Ke,mr,qi,ya,ga,va,bo,ki,Ku,Fg,Pc,kc,Hi,Oc,So,Ta,Lc,Dc,xc,Mc,Gc,Fc,zc,jc,Yi,Bc,Uc,Kc,Wc,Vc,qc,Hc,Yc,Xc,Jc,Zc,Xi,Qc,ef,tf,rf,nf,af,sf,of,lf,uf,cf,ff,df,wo,Io,pf,mf,hf,yf,gf,vf,Tf,$f,zg,Rf,lh,A,xs=_I({"../../node_modules/.pnpm/vscode-languageserver-types@3.17.5/node_modules/vscode-languageserver-types/lib/esm/main.js"(){(function(e){function t(r){return typeof r=="string"}i(t,"is"),e.is=t})(Rc||(Rc={})),(function(e){function t(r){return typeof r=="string"}i(t,"is"),e.is=t})(Eo||(Eo={})),(function(e){e.MIN_VALUE=-2147483648,e.MAX_VALUE=2147483647;function t(r){return typeof r=="number"&&e.MIN_VALUE<=r&&r<=e.MAX_VALUE}i(t,"is"),e.is=t})(Ac||(Ac={})),(function(e){e.MIN_VALUE=0,e.MAX_VALUE=2147483647;function t(r){return typeof r=="number"&&e.MIN_VALUE<=r&&r<=e.MAX_VALUE}i(t,"is"),e.is=t})(Ki||(Ki={})),(function(e){function t(n,a){return n===Number.MAX_VALUE&&(n=Ki.MAX_VALUE),a===Number.MAX_VALUE&&(a=Ki.MAX_VALUE),{line:n,character:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.objectLiteral(a)&&A.uinteger(a.line)&&A.uinteger(a.character)}i(r,"is"),e.is=r})(ie||(ie={})),(function(e){function t(n,a,s,o){if(A.uinteger(n)&&A.uinteger(a)&&A.uinteger(s)&&A.uinteger(o))return{start:ie.create(n,a),end:ie.create(s,o)};if(ie.is(n)&&ie.is(a))return{start:n,end:a};throw new Error(`Range#create called with invalid arguments[${n}, ${a}, ${s}, ${o}]`)}i(t,"create"),e.create=t;function r(n){let a=n;return A.objectLiteral(a)&&ie.is(a.start)&&ie.is(a.end)}i(r,"is"),e.is=r})(Q||(Q={})),(function(e){function t(n,a){return{uri:n,range:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.objectLiteral(a)&&Q.is(a.range)&&(A.string(a.uri)||A.undefined(a.uri))}i(r,"is"),e.is=r})(Wi||(Wi={})),(function(e){function t(n,a,s,o){return{targetUri:n,targetRange:a,targetSelectionRange:s,originSelectionRange:o}}i(t,"create"),e.create=t;function r(n){let a=n;return A.objectLiteral(a)&&Q.is(a.targetRange)&&A.string(a.targetUri)&&Q.is(a.targetSelectionRange)&&(Q.is(a.originSelectionRange)||A.undefined(a.originSelectionRange))}i(r,"is"),e.is=r})(Ec||(Ec={})),(function(e){function t(n,a,s,o){return{red:n,green:a,blue:s,alpha:o}}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&A.numberRange(a.red,0,1)&&A.numberRange(a.green,0,1)&&A.numberRange(a.blue,0,1)&&A.numberRange(a.alpha,0,1)}i(r,"is"),e.is=r})(Co||(Co={})),(function(e){function t(n,a){return{range:n,color:a}}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&Q.is(a.range)&&Co.is(a.color)}i(r,"is"),e.is=r})(Cc||(Cc={})),(function(e){function t(n,a,s){return{label:n,textEdit:a,additionalTextEdits:s}}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&A.string(a.label)&&(A.undefined(a.textEdit)||Yt.is(a))&&(A.undefined(a.additionalTextEdits)||A.typedArray(a.additionalTextEdits,Yt.is))}i(r,"is"),e.is=r})(_c||(_c={})),(function(e){e.Comment="comment",e.Imports="imports",e.Region="region"})(bc||(bc={})),(function(e){function t(n,a,s,o,l,u){const c={startLine:n,endLine:a};return A.defined(s)&&(c.startCharacter=s),A.defined(o)&&(c.endCharacter=o),A.defined(l)&&(c.kind=l),A.defined(u)&&(c.collapsedText=u),c}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&A.uinteger(a.startLine)&&A.uinteger(a.startLine)&&(A.undefined(a.startCharacter)||A.uinteger(a.startCharacter))&&(A.undefined(a.endCharacter)||A.uinteger(a.endCharacter))&&(A.undefined(a.kind)||A.string(a.kind))}i(r,"is"),e.is=r})(Sc||(Sc={})),(function(e){function t(n,a){return{location:n,message:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&Wi.is(a.location)&&A.string(a.message)}i(r,"is"),e.is=r})(_o||(_o={})),(function(e){e.Error=1,e.Warning=2,e.Information=3,e.Hint=4})(wc||(wc={})),(function(e){e.Unnecessary=1,e.Deprecated=2})(Ic||(Ic={})),(function(e){function t(r){const n=r;return A.objectLiteral(n)&&A.string(n.href)}i(t,"is"),e.is=t})(Nc||(Nc={})),(function(e){function t(n,a,s,o,l,u){let c={range:n,message:a};return A.defined(s)&&(c.severity=s),A.defined(o)&&(c.code=o),A.defined(l)&&(c.source=l),A.defined(u)&&(c.relatedInformation=u),c}i(t,"create"),e.create=t;function r(n){var a;let s=n;return A.defined(s)&&Q.is(s.range)&&A.string(s.message)&&(A.number(s.severity)||A.undefined(s.severity))&&(A.integer(s.code)||A.string(s.code)||A.undefined(s.code))&&(A.undefined(s.codeDescription)||A.string((a=s.codeDescription)===null||a===void 0?void 0:a.href))&&(A.string(s.source)||A.undefined(s.source))&&(A.undefined(s.relatedInformation)||A.typedArray(s.relatedInformation,_o.is))}i(r,"is"),e.is=r})(Vi||(Vi={})),(function(e){function t(n,a,...s){let o={title:n,command:a};return A.defined(s)&&s.length>0&&(o.arguments=s),o}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.string(a.title)&&A.string(a.command)}i(r,"is"),e.is=r})(nn||(nn={})),(function(e){function t(s,o){return{range:s,newText:o}}i(t,"replace"),e.replace=t;function r(s,o){return{range:{start:s,end:s},newText:o}}i(r,"insert"),e.insert=r;function n(s){return{range:s,newText:""}}i(n,"del"),e.del=n;function a(s){const o=s;return A.objectLiteral(o)&&A.string(o.newText)&&Q.is(o.range)}i(a,"is"),e.is=a})(Yt||(Yt={})),(function(e){function t(n,a,s){const o={label:n};return a!==void 0&&(o.needsConfirmation=a),s!==void 0&&(o.description=s),o}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&A.string(a.label)&&(A.boolean(a.needsConfirmation)||a.needsConfirmation===void 0)&&(A.string(a.description)||a.description===void 0)}i(r,"is"),e.is=r})(an||(an={})),(function(e){function t(r){const n=r;return A.string(n)}i(t,"is"),e.is=t})(Ke||(Ke={})),(function(e){function t(s,o,l){return{range:s,newText:o,annotationId:l}}i(t,"replace"),e.replace=t;function r(s,o,l){return{range:{start:s,end:s},newText:o,annotationId:l}}i(r,"insert"),e.insert=r;function n(s,o){return{range:s,newText:"",annotationId:o}}i(n,"del"),e.del=n;function a(s){const o=s;return Yt.is(o)&&(an.is(o.annotationId)||Ke.is(o.annotationId))}i(a,"is"),e.is=a})(mr||(mr={})),(function(e){function t(n,a){return{textDocument:n,edits:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&Hi.is(a.textDocument)&&Array.isArray(a.edits)}i(r,"is"),e.is=r})(qi||(qi={})),(function(e){function t(n,a,s){let o={kind:"create",uri:n};return a!==void 0&&(a.overwrite!==void 0||a.ignoreIfExists!==void 0)&&(o.options=a),s!==void 0&&(o.annotationId=s),o}i(t,"create"),e.create=t;function r(n){let a=n;return a&&a.kind==="create"&&A.string(a.uri)&&(a.options===void 0||(a.options.overwrite===void 0||A.boolean(a.options.overwrite))&&(a.options.ignoreIfExists===void 0||A.boolean(a.options.ignoreIfExists)))&&(a.annotationId===void 0||Ke.is(a.annotationId))}i(r,"is"),e.is=r})(ya||(ya={})),(function(e){function t(n,a,s,o){let l={kind:"rename",oldUri:n,newUri:a};return s!==void 0&&(s.overwrite!==void 0||s.ignoreIfExists!==void 0)&&(l.options=s),o!==void 0&&(l.annotationId=o),l}i(t,"create"),e.create=t;function r(n){let a=n;return a&&a.kind==="rename"&&A.string(a.oldUri)&&A.string(a.newUri)&&(a.options===void 0||(a.options.overwrite===void 0||A.boolean(a.options.overwrite))&&(a.options.ignoreIfExists===void 0||A.boolean(a.options.ignoreIfExists)))&&(a.annotationId===void 0||Ke.is(a.annotationId))}i(r,"is"),e.is=r})(ga||(ga={})),(function(e){function t(n,a,s){let o={kind:"delete",uri:n};return a!==void 0&&(a.recursive!==void 0||a.ignoreIfNotExists!==void 0)&&(o.options=a),s!==void 0&&(o.annotationId=s),o}i(t,"create"),e.create=t;function r(n){let a=n;return a&&a.kind==="delete"&&A.string(a.uri)&&(a.options===void 0||(a.options.recursive===void 0||A.boolean(a.options.recursive))&&(a.options.ignoreIfNotExists===void 0||A.boolean(a.options.ignoreIfNotExists)))&&(a.annotationId===void 0||Ke.is(a.annotationId))}i(r,"is"),e.is=r})(va||(va={})),(function(e){function t(r){let n=r;return n&&(n.changes!==void 0||n.documentChanges!==void 0)&&(n.documentChanges===void 0||n.documentChanges.every(a=>A.string(a.kind)?ya.is(a)||ga.is(a)||va.is(a):qi.is(a)))}i(t,"is"),e.is=t})(bo||(bo={})),ki=class{static{i(this,"TextEditChangeImpl")}constructor(e,t){this.edits=e,this.changeAnnotations=t}insert(e,t,r){let n,a;if(r===void 0?n=Yt.insert(e,t):Ke.is(r)?(a=r,n=mr.insert(e,t,r)):(this.assertChangeAnnotations(this.changeAnnotations),a=this.changeAnnotations.manage(r),n=mr.insert(e,t,a)),this.edits.push(n),a!==void 0)return a}replace(e,t,r){let n,a;if(r===void 0?n=Yt.replace(e,t):Ke.is(r)?(a=r,n=mr.replace(e,t,r)):(this.assertChangeAnnotations(this.changeAnnotations),a=this.changeAnnotations.manage(r),n=mr.replace(e,t,a)),this.edits.push(n),a!==void 0)return a}delete(e,t){let r,n;if(t===void 0?r=Yt.del(e):Ke.is(t)?(n=t,r=mr.del(e,t)):(this.assertChangeAnnotations(this.changeAnnotations),n=this.changeAnnotations.manage(t),r=mr.del(e,n)),this.edits.push(r),n!==void 0)return n}add(e){this.edits.push(e)}all(){return this.edits}clear(){this.edits.splice(0,this.edits.length)}assertChangeAnnotations(e){if(e===void 0)throw new Error("Text edit change is not configured to manage change annotations.")}},Ku=class{static{i(this,"ChangeAnnotations")}constructor(e){this._annotations=e===void 0?Object.create(null):e,this._counter=0,this._size=0}all(){return this._annotations}get size(){return this._size}manage(e,t){let r;if(Ke.is(e)?r=e:(r=this.nextId(),t=e),this._annotations[r]!==void 0)throw new Error(`Id ${r} is already in use.`);if(t===void 0)throw new Error(`No annotation provided for id ${r}`);return this._annotations[r]=t,this._size++,r}nextId(){return this._counter++,this._counter.toString()}},Fg=class{static{i(this,"WorkspaceChange")}constructor(e){this._textEditChanges=Object.create(null),e!==void 0?(this._workspaceEdit=e,e.documentChanges?(this._changeAnnotations=new Ku(e.changeAnnotations),e.changeAnnotations=this._changeAnnotations.all(),e.documentChanges.forEach(t=>{if(qi.is(t)){const r=new ki(t.edits,this._changeAnnotations);this._textEditChanges[t.textDocument.uri]=r}})):e.changes&&Object.keys(e.changes).forEach(t=>{const r=new ki(e.changes[t]);this._textEditChanges[t]=r})):this._workspaceEdit={}}get edit(){return this.initDocumentChanges(),this._changeAnnotations!==void 0&&(this._changeAnnotations.size===0?this._workspaceEdit.changeAnnotations=void 0:this._workspaceEdit.changeAnnotations=this._changeAnnotations.all()),this._workspaceEdit}getTextEditChange(e){if(Hi.is(e)){if(this.initDocumentChanges(),this._workspaceEdit.documentChanges===void 0)throw new Error("Workspace edit is not configured for document changes.");const t={uri:e.uri,version:e.version};let r=this._textEditChanges[t.uri];if(!r){const n=[],a={textDocument:t,edits:n};this._workspaceEdit.documentChanges.push(a),r=new ki(n,this._changeAnnotations),this._textEditChanges[t.uri]=r}return r}else{if(this.initChanges(),this._workspaceEdit.changes===void 0)throw new Error("Workspace edit is not configured for normal text edit changes.");let t=this._textEditChanges[e];if(!t){let r=[];this._workspaceEdit.changes[e]=r,t=new ki(r),this._textEditChanges[e]=t}return t}}initDocumentChanges(){this._workspaceEdit.documentChanges===void 0&&this._workspaceEdit.changes===void 0&&(this._changeAnnotations=new Ku,this._workspaceEdit.documentChanges=[],this._workspaceEdit.changeAnnotations=this._changeAnnotations.all())}initChanges(){this._workspaceEdit.documentChanges===void 0&&this._workspaceEdit.changes===void 0&&(this._workspaceEdit.changes=Object.create(null))}createFile(e,t,r){if(this.initDocumentChanges(),this._workspaceEdit.documentChanges===void 0)throw new Error("Workspace edit is not configured for document changes.");let n;an.is(t)||Ke.is(t)?n=t:r=t;let a,s;if(n===void 0?a=ya.create(e,r):(s=Ke.is(n)?n:this._changeAnnotations.manage(n),a=ya.create(e,r,s)),this._workspaceEdit.documentChanges.push(a),s!==void 0)return s}renameFile(e,t,r,n){if(this.initDocumentChanges(),this._workspaceEdit.documentChanges===void 0)throw new Error("Workspace edit is not configured for document changes.");let a;an.is(r)||Ke.is(r)?a=r:n=r;let s,o;if(a===void 0?s=ga.create(e,t,n):(o=Ke.is(a)?a:this._changeAnnotations.manage(a),s=ga.create(e,t,n,o)),this._workspaceEdit.documentChanges.push(s),o!==void 0)return o}deleteFile(e,t,r){if(this.initDocumentChanges(),this._workspaceEdit.documentChanges===void 0)throw new Error("Workspace edit is not configured for document changes.");let n;an.is(t)||Ke.is(t)?n=t:r=t;let a,s;if(n===void 0?a=va.create(e,r):(s=Ke.is(n)?n:this._changeAnnotations.manage(n),a=va.create(e,r,s)),this._workspaceEdit.documentChanges.push(a),s!==void 0)return s}},(function(e){function t(n){return{uri:n}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.string(a.uri)}i(r,"is"),e.is=r})(Pc||(Pc={})),(function(e){function t(n,a){return{uri:n,version:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.string(a.uri)&&A.integer(a.version)}i(r,"is"),e.is=r})(kc||(kc={})),(function(e){function t(n,a){return{uri:n,version:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.string(a.uri)&&(a.version===null||A.integer(a.version))}i(r,"is"),e.is=r})(Hi||(Hi={})),(function(e){function t(n,a,s,o){return{uri:n,languageId:a,version:s,text:o}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.string(a.uri)&&A.string(a.languageId)&&A.integer(a.version)&&A.string(a.text)}i(r,"is"),e.is=r})(Oc||(Oc={})),(function(e){e.PlainText="plaintext",e.Markdown="markdown";function t(r){const n=r;return n===e.PlainText||n===e.Markdown}i(t,"is"),e.is=t})(So||(So={})),(function(e){function t(r){const n=r;return A.objectLiteral(r)&&So.is(n.kind)&&A.string(n.value)}i(t,"is"),e.is=t})(Ta||(Ta={})),(function(e){e.Text=1,e.Method=2,e.Function=3,e.Constructor=4,e.Field=5,e.Variable=6,e.Class=7,e.Interface=8,e.Module=9,e.Property=10,e.Unit=11,e.Value=12,e.Enum=13,e.Keyword=14,e.Snippet=15,e.Color=16,e.File=17,e.Reference=18,e.Folder=19,e.EnumMember=20,e.Constant=21,e.Struct=22,e.Event=23,e.Operator=24,e.TypeParameter=25})(Lc||(Lc={})),(function(e){e.PlainText=1,e.Snippet=2})(Dc||(Dc={})),(function(e){e.Deprecated=1})(xc||(xc={})),(function(e){function t(n,a,s){return{newText:n,insert:a,replace:s}}i(t,"create"),e.create=t;function r(n){const a=n;return a&&A.string(a.newText)&&Q.is(a.insert)&&Q.is(a.replace)}i(r,"is"),e.is=r})(Mc||(Mc={})),(function(e){e.asIs=1,e.adjustIndentation=2})(Gc||(Gc={})),(function(e){function t(r){const n=r;return n&&(A.string(n.detail)||n.detail===void 0)&&(A.string(n.description)||n.description===void 0)}i(t,"is"),e.is=t})(Fc||(Fc={})),(function(e){function t(r){return{label:r}}i(t,"create"),e.create=t})(zc||(zc={})),(function(e){function t(r,n){return{items:r||[],isIncomplete:!!n}}i(t,"create"),e.create=t})(jc||(jc={})),(function(e){function t(n){return n.replace(/[\\`*_{}[\]()#+\-.!]/g,"\\$&")}i(t,"fromPlainText"),e.fromPlainText=t;function r(n){const a=n;return A.string(a)||A.objectLiteral(a)&&A.string(a.language)&&A.string(a.value)}i(r,"is"),e.is=r})(Yi||(Yi={})),(function(e){function t(r){let n=r;return!!n&&A.objectLiteral(n)&&(Ta.is(n.contents)||Yi.is(n.contents)||A.typedArray(n.contents,Yi.is))&&(r.range===void 0||Q.is(r.range))}i(t,"is"),e.is=t})(Bc||(Bc={})),(function(e){function t(r,n){return n?{label:r,documentation:n}:{label:r}}i(t,"create"),e.create=t})(Uc||(Uc={})),(function(e){function t(r,n,...a){let s={label:r};return A.defined(n)&&(s.documentation=n),A.defined(a)?s.parameters=a:s.parameters=[],s}i(t,"create"),e.create=t})(Kc||(Kc={})),(function(e){e.Text=1,e.Read=2,e.Write=3})(Wc||(Wc={})),(function(e){function t(r,n){let a={range:r};return A.number(n)&&(a.kind=n),a}i(t,"create"),e.create=t})(Vc||(Vc={})),(function(e){e.File=1,e.Module=2,e.Namespace=3,e.Package=4,e.Class=5,e.Method=6,e.Property=7,e.Field=8,e.Constructor=9,e.Enum=10,e.Interface=11,e.Function=12,e.Variable=13,e.Constant=14,e.String=15,e.Number=16,e.Boolean=17,e.Array=18,e.Object=19,e.Key=20,e.Null=21,e.EnumMember=22,e.Struct=23,e.Event=24,e.Operator=25,e.TypeParameter=26})(qc||(qc={})),(function(e){e.Deprecated=1})(Hc||(Hc={})),(function(e){function t(r,n,a,s,o){let l={name:r,kind:n,location:{uri:s,range:a}};return o&&(l.containerName=o),l}i(t,"create"),e.create=t})(Yc||(Yc={})),(function(e){function t(r,n,a,s){return s!==void 0?{name:r,kind:n,location:{uri:a,range:s}}:{name:r,kind:n,location:{uri:a}}}i(t,"create"),e.create=t})(Xc||(Xc={})),(function(e){function t(n,a,s,o,l,u){let c={name:n,detail:a,kind:s,range:o,selectionRange:l};return u!==void 0&&(c.children=u),c}i(t,"create"),e.create=t;function r(n){let a=n;return a&&A.string(a.name)&&A.number(a.kind)&&Q.is(a.range)&&Q.is(a.selectionRange)&&(a.detail===void 0||A.string(a.detail))&&(a.deprecated===void 0||A.boolean(a.deprecated))&&(a.children===void 0||Array.isArray(a.children))&&(a.tags===void 0||Array.isArray(a.tags))}i(r,"is"),e.is=r})(Jc||(Jc={})),(function(e){e.Empty="",e.QuickFix="quickfix",e.Refactor="refactor",e.RefactorExtract="refactor.extract",e.RefactorInline="refactor.inline",e.RefactorRewrite="refactor.rewrite",e.Source="source",e.SourceOrganizeImports="source.organizeImports",e.SourceFixAll="source.fixAll"})(Zc||(Zc={})),(function(e){e.Invoked=1,e.Automatic=2})(Xi||(Xi={})),(function(e){function t(n,a,s){let o={diagnostics:n};return a!=null&&(o.only=a),s!=null&&(o.triggerKind=s),o}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.typedArray(a.diagnostics,Vi.is)&&(a.only===void 0||A.typedArray(a.only,A.string))&&(a.triggerKind===void 0||a.triggerKind===Xi.Invoked||a.triggerKind===Xi.Automatic)}i(r,"is"),e.is=r})(Qc||(Qc={})),(function(e){function t(n,a,s){let o={title:n},l=!0;return typeof a=="string"?(l=!1,o.kind=a):nn.is(a)?o.command=a:o.edit=a,l&&s!==void 0&&(o.kind=s),o}i(t,"create"),e.create=t;function r(n){let a=n;return a&&A.string(a.title)&&(a.diagnostics===void 0||A.typedArray(a.diagnostics,Vi.is))&&(a.kind===void 0||A.string(a.kind))&&(a.edit!==void 0||a.command!==void 0)&&(a.command===void 0||nn.is(a.command))&&(a.isPreferred===void 0||A.boolean(a.isPreferred))&&(a.edit===void 0||bo.is(a.edit))}i(r,"is"),e.is=r})(ef||(ef={})),(function(e){function t(n,a){let s={range:n};return A.defined(a)&&(s.data=a),s}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&Q.is(a.range)&&(A.undefined(a.command)||nn.is(a.command))}i(r,"is"),e.is=r})(tf||(tf={})),(function(e){function t(n,a){return{tabSize:n,insertSpaces:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&A.uinteger(a.tabSize)&&A.boolean(a.insertSpaces)}i(r,"is"),e.is=r})(rf||(rf={})),(function(e){function t(n,a,s){return{range:n,target:a,data:s}}i(t,"create"),e.create=t;function r(n){let a=n;return A.defined(a)&&Q.is(a.range)&&(A.undefined(a.target)||A.string(a.target))}i(r,"is"),e.is=r})(nf||(nf={})),(function(e){function t(n,a){return{range:n,parent:a}}i(t,"create"),e.create=t;function r(n){let a=n;return A.objectLiteral(a)&&Q.is(a.range)&&(a.parent===void 0||e.is(a.parent))}i(r,"is"),e.is=r})(af||(af={})),(function(e){e.namespace="namespace",e.type="type",e.class="class",e.enum="enum",e.interface="interface",e.struct="struct",e.typeParameter="typeParameter",e.parameter="parameter",e.variable="variable",e.property="property",e.enumMember="enumMember",e.event="event",e.function="function",e.method="method",e.macro="macro",e.keyword="keyword",e.modifier="modifier",e.comment="comment",e.string="string",e.number="number",e.regexp="regexp",e.operator="operator",e.decorator="decorator"})(sf||(sf={})),(function(e){e.declaration="declaration",e.definition="definition",e.readonly="readonly",e.static="static",e.deprecated="deprecated",e.abstract="abstract",e.async="async",e.modification="modification",e.documentation="documentation",e.defaultLibrary="defaultLibrary"})(of||(of={})),(function(e){function t(r){const n=r;return A.objectLiteral(n)&&(n.resultId===void 0||typeof n.resultId=="string")&&Array.isArray(n.data)&&(n.data.length===0||typeof n.data[0]=="number")}i(t,"is"),e.is=t})(lf||(lf={})),(function(e){function t(n,a){return{range:n,text:a}}i(t,"create"),e.create=t;function r(n){const a=n;return a!=null&&Q.is(a.range)&&A.string(a.text)}i(r,"is"),e.is=r})(uf||(uf={})),(function(e){function t(n,a,s){return{range:n,variableName:a,caseSensitiveLookup:s}}i(t,"create"),e.create=t;function r(n){const a=n;return a!=null&&Q.is(a.range)&&A.boolean(a.caseSensitiveLookup)&&(A.string(a.variableName)||a.variableName===void 0)}i(r,"is"),e.is=r})(cf||(cf={})),(function(e){function t(n,a){return{range:n,expression:a}}i(t,"create"),e.create=t;function r(n){const a=n;return a!=null&&Q.is(a.range)&&(A.string(a.expression)||a.expression===void 0)}i(r,"is"),e.is=r})(ff||(ff={})),(function(e){function t(n,a){return{frameId:n,stoppedLocation:a}}i(t,"create"),e.create=t;function r(n){const a=n;return A.defined(a)&&Q.is(n.stoppedLocation)}i(r,"is"),e.is=r})(df||(df={})),(function(e){e.Type=1,e.Parameter=2;function t(r){return r===1||r===2}i(t,"is"),e.is=t})(wo||(wo={})),(function(e){function t(n){return{value:n}}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&(a.tooltip===void 0||A.string(a.tooltip)||Ta.is(a.tooltip))&&(a.location===void 0||Wi.is(a.location))&&(a.command===void 0||nn.is(a.command))}i(r,"is"),e.is=r})(Io||(Io={})),(function(e){function t(n,a,s){const o={position:n,label:a};return s!==void 0&&(o.kind=s),o}i(t,"create"),e.create=t;function r(n){const a=n;return A.objectLiteral(a)&&ie.is(a.position)&&(A.string(a.label)||A.typedArray(a.label,Io.is))&&(a.kind===void 0||wo.is(a.kind))&&a.textEdits===void 0||A.typedArray(a.textEdits,Yt.is)&&(a.tooltip===void 0||A.string(a.tooltip)||Ta.is(a.tooltip))&&(a.paddingLeft===void 0||A.boolean(a.paddingLeft))&&(a.paddingRight===void 0||A.boolean(a.paddingRight))}i(r,"is"),e.is=r})(pf||(pf={})),(function(e){function t(r){return{kind:"snippet",value:r}}i(t,"createSnippet"),e.createSnippet=t})(mf||(mf={})),(function(e){function t(r,n,a,s){return{insertText:r,filterText:n,range:a,command:s}}i(t,"create"),e.create=t})(hf||(hf={})),(function(e){function t(r){return{items:r}}i(t,"create"),e.create=t})(yf||(yf={})),(function(e){e.Invoked=0,e.Automatic=1})(gf||(gf={})),(function(e){function t(r,n){return{range:r,text:n}}i(t,"create"),e.create=t})(vf||(vf={})),(function(e){function t(r,n){return{triggerKind:r,selectedCompletionInfo:n}}i(t,"create"),e.create=t})(Tf||(Tf={})),(function(e){function t(r){const n=r;return A.objectLiteral(n)&&Eo.is(n.uri)&&A.string(n.name)}i(t,"is"),e.is=t})($f||($f={})),zg=[` +`,`\r +`,"\r"],(function(e){function t(s,o,l,u){return new lh(s,o,l,u)}i(t,"create"),e.create=t;function r(s){let o=s;return!!(A.defined(o)&&A.string(o.uri)&&(A.undefined(o.languageId)||A.string(o.languageId))&&A.uinteger(o.lineCount)&&A.func(o.getText)&&A.func(o.positionAt)&&A.func(o.offsetAt))}i(r,"is"),e.is=r;function n(s,o){let l=s.getText(),u=a(o,(f,d)=>{let m=f.range.start.line-d.range.start.line;return m===0?f.range.start.character-d.range.start.character:m}),c=l.length;for(let f=u.length-1;f>=0;f--){let d=u[f],m=s.offsetAt(d.range.start),g=s.offsetAt(d.range.end);if(g<=c)l=l.substring(0,m)+d.newText+l.substring(g,l.length);else throw new Error("Overlapping edit");c=m}return l}i(n,"applyEdits"),e.applyEdits=n;function a(s,o){if(s.length<=1)return s;const l=s.length/2|0,u=s.slice(0,l),c=s.slice(l);a(u,o),a(c,o);let f=0,d=0,m=0;for(;f0&&e.push(t.length),this._lineOffsets=e}return this._lineOffsets}positionAt(e){e=Math.max(Math.min(e,this._content.length),0);let t=this.getLineOffsets(),r=0,n=t.length;if(n===0)return ie.create(0,e);for(;re?n=s:r=s+1}let a=r-1;return ie.create(a,e-t[a])}offsetAt(e){let t=this.getLineOffsets();if(e.line>=t.length)return this._content.length;if(e.line<0)return 0;let r=t[e.line],n=e.line+1"u"}i(n,"undefined"),e.undefined=n;function a(g){return g===!0||g===!1}i(a,"boolean"),e.boolean=a;function s(g){return t.call(g)==="[object String]"}i(s,"string"),e.string=s;function o(g){return t.call(g)==="[object Number]"}i(o,"number"),e.number=o;function l(g,v,_){return t.call(g)==="[object Number]"&&v<=g&&g<=_}i(l,"numberRange"),e.numberRange=l;function u(g){return t.call(g)==="[object Number]"&&-2147483648<=g&&g<=2147483647}i(u,"integer"),e.integer=u;function c(g){return t.call(g)==="[object Number]"&&0<=g&&g<=2147483647}i(c,"uinteger"),e.uinteger=c;function f(g){return t.call(g)==="[object Function]"}i(f,"func"),e.func=f;function d(g){return g!==null&&typeof g=="object"}i(d,"objectLiteral"),e.objectLiteral=d;function m(g,v){return Array.isArray(g)&&g.every(v)}i(m,"typedArray"),e.typedArray=m})(A||(A={}))}}),Dn=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/ral.js"(e){Object.defineProperty(e,"__esModule",{value:!0});var t;function r(){if(t===void 0)throw new Error("No runtime abstraction layer installed");return t}i(r,"RAL"),(function(n){function a(s){if(s===void 0)throw new Error("No runtime abstraction layer provided");t=s}i(a,"install"),n.install=a})(r||(r={})),e.default=r}}),Ms=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/is.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.stringArray=e.array=e.func=e.error=e.number=e.string=e.boolean=void 0;function t(u){return u===!0||u===!1}i(t,"boolean"),e.boolean=t;function r(u){return typeof u=="string"||u instanceof String}i(r,"string"),e.string=r;function n(u){return typeof u=="number"||u instanceof Number}i(n,"number"),e.number=n;function a(u){return u instanceof Error}i(a,"error"),e.error=a;function s(u){return typeof u=="function"}i(s,"func"),e.func=s;function o(u){return Array.isArray(u)}i(o,"array"),e.array=o;function l(u){return o(u)&&u.every(c=>r(c))}i(l,"stringArray"),e.stringArray=l}}),ei=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/events.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.Emitter=e.Event=void 0;var t=Dn(),r;(function(s){const o={dispose(){}};s.None=function(){return o}})(r||(e.Event=r={}));var n=class{static{i(this,"CallbackList")}add(s,o=null,l){this._callbacks||(this._callbacks=[],this._contexts=[]),this._callbacks.push(s),this._contexts.push(o),Array.isArray(l)&&l.push({dispose:i(()=>this.remove(s,o),"dispose")})}remove(s,o=null){if(!this._callbacks)return;let l=!1;for(let u=0,c=this._callbacks.length;u{this._callbacks||(this._callbacks=new n),this._options&&this._options.onFirstListenerAdd&&this._callbacks.isEmpty()&&this._options.onFirstListenerAdd(this),this._callbacks.add(o,l);const c={dispose:i(()=>{this._callbacks&&(this._callbacks.remove(o,l),c.dispose=jg._noop,this._options&&this._options.onLastListenerRemove&&this._callbacks.isEmpty()&&this._options.onLastListenerRemove(this))},"dispose")};return Array.isArray(u)&&u.push(c),c}),this._event}fire(o){this._callbacks&&this._callbacks.invoke.call(this._callbacks,o)}dispose(){this._callbacks&&(this._callbacks.dispose(),this._callbacks=void 0)}};e.Emitter=a,a._noop=function(){}}}),xl=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/cancellation.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.CancellationTokenSource=e.CancellationToken=void 0;var t=Dn(),r=Ms(),n=ei(),a;(function(u){u.None=Object.freeze({isCancellationRequested:!1,onCancellationRequested:n.Event.None}),u.Cancelled=Object.freeze({isCancellationRequested:!0,onCancellationRequested:n.Event.None});function c(f){const d=f;return d&&(d===u.None||d===u.Cancelled||r.boolean(d.isCancellationRequested)&&!!d.onCancellationRequested)}i(c,"is"),u.is=c})(a||(e.CancellationToken=a={}));var s=Object.freeze(function(u,c){const f=(0,t.default)().timer.setTimeout(u.bind(c),0);return{dispose(){f.dispose()}}}),o=class{static{i(this,"MutableToken")}constructor(){this._isCancelled=!1}cancel(){this._isCancelled||(this._isCancelled=!0,this._emitter&&(this._emitter.fire(void 0),this.dispose()))}get isCancellationRequested(){return this._isCancelled}get onCancellationRequested(){return this._isCancelled?s:(this._emitter||(this._emitter=new n.Emitter),this._emitter.event)}dispose(){this._emitter&&(this._emitter.dispose(),this._emitter=void 0)}},l=class{static{i(this,"CancellationTokenSource")}get token(){return this._token||(this._token=new o),this._token}cancel(){this._token?this._token.cancel():this._token=a.Cancelled}dispose(){this._token?this._token instanceof o&&this._token.dispose():this._token=a.None}};e.CancellationTokenSource=l}}),Bg=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messages.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.Message=e.NotificationType9=e.NotificationType8=e.NotificationType7=e.NotificationType6=e.NotificationType5=e.NotificationType4=e.NotificationType3=e.NotificationType2=e.NotificationType1=e.NotificationType0=e.NotificationType=e.RequestType9=e.RequestType8=e.RequestType7=e.RequestType6=e.RequestType5=e.RequestType4=e.RequestType3=e.RequestType2=e.RequestType1=e.RequestType=e.RequestType0=e.AbstractMessageSignature=e.ParameterStructures=e.ResponseError=e.ErrorCodes=void 0;var t=Ms(),r;(function(y){y.ParseError=-32700,y.InvalidRequest=-32600,y.MethodNotFound=-32601,y.InvalidParams=-32602,y.InternalError=-32603,y.jsonrpcReservedErrorRangeStart=-32099,y.serverErrorStart=-32099,y.MessageWriteError=-32099,y.MessageReadError=-32098,y.PendingResponseRejected=-32097,y.ConnectionInactive=-32096,y.ServerNotInitialized=-32002,y.UnknownErrorCode=-32001,y.jsonrpcReservedErrorRangeEnd=-32e3,y.serverErrorEnd=-32e3})(r||(e.ErrorCodes=r={}));var n=class Ug extends Error{static{i(this,"ResponseError")}constructor(E,T,$){super(T),this.code=t.number(E)?E:r.UnknownErrorCode,this.data=$,Object.setPrototypeOf(this,Ug.prototype)}toJson(){const E={code:this.code,message:this.message};return this.data!==void 0&&(E.data=this.data),E}};e.ResponseError=n;var a=class No{static{i(this,"ParameterStructures")}constructor(E){this.kind=E}static is(E){return E===No.auto||E===No.byName||E===No.byPosition}toString(){return this.kind}};e.ParameterStructures=a,a.auto=new a("auto"),a.byPosition=new a("byPosition"),a.byName=new a("byName");var s=class{static{i(this,"AbstractMessageSignature")}constructor(y,E){this.method=y,this.numberOfParams=E}get parameterStructures(){return a.auto}};e.AbstractMessageSignature=s;var o=class extends s{static{i(this,"RequestType0")}constructor(y){super(y,0)}};e.RequestType0=o;var l=class extends s{static{i(this,"RequestType")}constructor(y,E=a.auto){super(y,1),this._parameterStructures=E}get parameterStructures(){return this._parameterStructures}};e.RequestType=l;var u=class extends s{static{i(this,"RequestType1")}constructor(y,E=a.auto){super(y,1),this._parameterStructures=E}get parameterStructures(){return this._parameterStructures}};e.RequestType1=u;var c=class extends s{static{i(this,"RequestType2")}constructor(y){super(y,2)}};e.RequestType2=c;var f=class extends s{static{i(this,"RequestType3")}constructor(y){super(y,3)}};e.RequestType3=f;var d=class extends s{static{i(this,"RequestType4")}constructor(y){super(y,4)}};e.RequestType4=d;var m=class extends s{static{i(this,"RequestType5")}constructor(y){super(y,5)}};e.RequestType5=m;var g=class extends s{static{i(this,"RequestType6")}constructor(y){super(y,6)}};e.RequestType6=g;var v=class extends s{static{i(this,"RequestType7")}constructor(y){super(y,7)}};e.RequestType7=v;var _=class extends s{static{i(this,"RequestType8")}constructor(y){super(y,8)}};e.RequestType8=_;var S=class extends s{static{i(this,"RequestType9")}constructor(y){super(y,9)}};e.RequestType9=S;var w=class extends s{static{i(this,"NotificationType")}constructor(y,E=a.auto){super(y,1),this._parameterStructures=E}get parameterStructures(){return this._parameterStructures}};e.NotificationType=w;var I=class extends s{static{i(this,"NotificationType0")}constructor(y){super(y,0)}};e.NotificationType0=I;var R=class extends s{static{i(this,"NotificationType1")}constructor(y,E=a.auto){super(y,1),this._parameterStructures=E}get parameterStructures(){return this._parameterStructures}};e.NotificationType1=R;var P=class extends s{static{i(this,"NotificationType2")}constructor(y){super(y,2)}};e.NotificationType2=P;var z=class extends s{static{i(this,"NotificationType3")}constructor(y){super(y,3)}};e.NotificationType3=z;var X=class extends s{static{i(this,"NotificationType4")}constructor(y){super(y,4)}};e.NotificationType4=X;var Z=class extends s{static{i(this,"NotificationType5")}constructor(y){super(y,5)}};e.NotificationType5=Z;var ce=class extends s{static{i(this,"NotificationType6")}constructor(y){super(y,6)}};e.NotificationType6=ce;var se=class extends s{static{i(this,"NotificationType7")}constructor(y){super(y,7)}};e.NotificationType7=se;var Se=class extends s{static{i(this,"NotificationType8")}constructor(y){super(y,8)}};e.NotificationType8=Se;var k=class extends s{static{i(this,"NotificationType9")}constructor(y){super(y,9)}};e.NotificationType9=k;var C;(function(y){function E(b){const O=b;return O&&t.string(O.method)&&(t.string(O.id)||t.number(O.id))}i(E,"isRequest"),y.isRequest=E;function T(b){const O=b;return O&&t.string(O.method)&&b.id===void 0}i(T,"isNotification"),y.isNotification=T;function $(b){const O=b;return O&&(O.result!==void 0||!!O.error)&&(t.string(O.id)||t.number(O.id)||O.id===null)}i($,"isResponse"),y.isResponse=$})(C||(e.Message=C={}))}}),Kg=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/linkedMap.js"(e){var t;Object.defineProperty(e,"__esModule",{value:!0}),e.LRUCache=e.LinkedMap=e.Touch=void 0;var r;(function(s){s.None=0,s.First=1,s.AsOld=s.First,s.Last=2,s.AsNew=s.Last})(r||(e.Touch=r={}));var n=class{static{i(this,"LinkedMap")}constructor(){this[t]="LinkedMap",this._map=new Map,this._head=void 0,this._tail=void 0,this._size=0,this._state=0}clear(){this._map.clear(),this._head=void 0,this._tail=void 0,this._size=0,this._state++}isEmpty(){return!this._head&&!this._tail}get size(){return this._size}get first(){return this._head?.value}get last(){return this._tail?.value}has(s){return this._map.has(s)}get(s,o=r.None){const l=this._map.get(s);if(l)return o!==r.None&&this.touch(l,o),l.value}set(s,o,l=r.None){let u=this._map.get(s);if(u)u.value=o,l!==r.None&&this.touch(u,l);else{switch(u={key:s,value:o,next:void 0,previous:void 0},l){case r.None:this.addItemLast(u);break;case r.First:this.addItemFirst(u);break;case r.Last:this.addItemLast(u);break;default:this.addItemLast(u);break}this._map.set(s,u),this._size++}return this}delete(s){return!!this.remove(s)}remove(s){const o=this._map.get(s);if(o)return this._map.delete(s),this.removeItem(o),this._size--,o.value}shift(){if(!this._head&&!this._tail)return;if(!this._head||!this._tail)throw new Error("Invalid list");const s=this._head;return this._map.delete(s.key),this.removeItem(s),this._size--,s.value}forEach(s,o){const l=this._state;let u=this._head;for(;u;){if(o?s.bind(o)(u.value,u.key,this):s(u.value,u.key,this),this._state!==l)throw new Error("LinkedMap got modified during iteration.");u=u.next}}keys(){const s=this._state;let o=this._head;const l={[Symbol.iterator]:()=>l,next:i(()=>{if(this._state!==s)throw new Error("LinkedMap got modified during iteration.");if(o){const u={value:o.key,done:!1};return o=o.next,u}else return{value:void 0,done:!0}},"next")};return l}values(){const s=this._state;let o=this._head;const l={[Symbol.iterator]:()=>l,next:i(()=>{if(this._state!==s)throw new Error("LinkedMap got modified during iteration.");if(o){const u={value:o.value,done:!1};return o=o.next,u}else return{value:void 0,done:!0}},"next")};return l}entries(){const s=this._state;let o=this._head;const l={[Symbol.iterator]:()=>l,next:i(()=>{if(this._state!==s)throw new Error("LinkedMap got modified during iteration.");if(o){const u={value:[o.key,o.value],done:!1};return o=o.next,u}else return{value:void 0,done:!0}},"next")};return l}[(t=Symbol.toStringTag,Symbol.iterator)](){return this.entries()}trimOld(s){if(s>=this.size)return;if(s===0){this.clear();return}let o=this._head,l=this.size;for(;o&&l>s;)this._map.delete(o.key),o=o.next,l--;this._head=o,this._size=l,o&&(o.previous=void 0),this._state++}addItemFirst(s){if(!this._head&&!this._tail)this._tail=s;else if(this._head)s.next=this._head,this._head.previous=s;else throw new Error("Invalid list");this._head=s,this._state++}addItemLast(s){if(!this._head&&!this._tail)this._head=s;else if(this._tail)s.previous=this._tail,this._tail.next=s;else throw new Error("Invalid list");this._tail=s,this._state++}removeItem(s){if(s===this._head&&s===this._tail)this._head=void 0,this._tail=void 0;else if(s===this._head){if(!s.next)throw new Error("Invalid list");s.next.previous=void 0,this._head=s.next}else if(s===this._tail){if(!s.previous)throw new Error("Invalid list");s.previous.next=void 0,this._tail=s.previous}else{const o=s.next,l=s.previous;if(!o||!l)throw new Error("Invalid list");o.previous=l,l.next=o}s.next=void 0,s.previous=void 0,this._state++}touch(s,o){if(!this._head||!this._tail)throw new Error("Invalid list");if(!(o!==r.First&&o!==r.Last)){if(o===r.First){if(s===this._head)return;const l=s.next,u=s.previous;s===this._tail?(u.next=void 0,this._tail=u):(l.previous=u,u.next=l),s.previous=void 0,s.next=this._head,this._head.previous=s,this._head=s,this._state++}else if(o===r.Last){if(s===this._tail)return;const l=s.next,u=s.previous;s===this._head?(l.previous=void 0,this._head=l):(l.previous=u,u.next=l),s.next=void 0,s.previous=this._tail,this._tail.next=s,this._tail=s,this._state++}}}toJSON(){const s=[];return this.forEach((o,l)=>{s.push([l,o])}),s}fromJSON(s){this.clear();for(const[o,l]of s)this.set(o,l)}};e.LinkedMap=n;var a=class extends n{static{i(this,"LRUCache")}constructor(s,o=1){super(),this._limit=s,this._ratio=Math.min(Math.max(0,o),1)}get limit(){return this._limit}set limit(s){this._limit=s,this.checkTrim()}get ratio(){return this._ratio}set ratio(s){this._ratio=Math.min(Math.max(0,s),1),this.checkTrim()}get(s,o=r.AsNew){return super.get(s,o)}peek(s){return super.get(s,r.None)}set(s,o){return super.set(s,o,r.Last),this.checkTrim(),this}checkTrim(){this.size>this._limit&&this.trimOld(Math.round(this._limit*this._ratio))}};e.LRUCache=a}}),bI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/disposable.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.Disposable=void 0;var t;(function(r){function n(a){return{dispose:a}}i(n,"create"),r.create=n})(t||(e.Disposable=t={}))}}),SI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.SharedArrayReceiverStrategy=e.SharedArraySenderStrategy=void 0;var t=xl(),r;(function(l){l.Continue=0,l.Cancelled=1})(r||(r={}));var n=class{static{i(this,"SharedArraySenderStrategy")}constructor(){this.buffers=new Map}enableCancellation(l){if(l.id===null)return;const u=new SharedArrayBuffer(4),c=new Int32Array(u,0,1);c[0]=r.Continue,this.buffers.set(l.id,u),l.$cancellationData=u}async sendCancellation(l,u){const c=this.buffers.get(u);if(c===void 0)return;const f=new Int32Array(c,0,1);Atomics.store(f,0,r.Cancelled)}cleanup(l){this.buffers.delete(l)}dispose(){this.buffers.clear()}};e.SharedArraySenderStrategy=n;var a=class{static{i(this,"SharedArrayBufferCancellationToken")}constructor(l){this.data=new Int32Array(l,0,1)}get isCancellationRequested(){return Atomics.load(this.data,0)===r.Cancelled}get onCancellationRequested(){throw new Error("Cancellation over SharedArrayBuffer doesn't support cancellation events")}},s=class{static{i(this,"SharedArrayBufferCancellationTokenSource")}constructor(l){this.token=new a(l)}cancel(){}dispose(){}},o=class{static{i(this,"SharedArrayReceiverStrategy")}constructor(){this.kind="request"}createCancellationTokenSource(l){const u=l.$cancellationData;return u===void 0?new t.CancellationTokenSource:new s(u)}};e.SharedArrayReceiverStrategy=o}}),Wg=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/semaphore.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.Semaphore=void 0;var t=Dn(),r=class{static{i(this,"Semaphore")}constructor(n=1){if(n<=0)throw new Error("Capacity must be greater than 0");this._capacity=n,this._active=0,this._waiting=[]}lock(n){return new Promise((a,s)=>{this._waiting.push({thunk:n,resolve:a,reject:s}),this.runNext()})}get active(){return this._active}runNext(){this._waiting.length===0||this._active===this._capacity||(0,t.default)().timer.setImmediate(()=>this.doRunNext())}doRunNext(){if(this._waiting.length===0||this._active===this._capacity)return;const n=this._waiting.shift();if(this._active++,this._active>this._capacity)throw new Error("To many thunks active");try{const a=n.thunk();a instanceof Promise?a.then(s=>{this._active--,n.resolve(s),this.runNext()},s=>{this._active--,n.reject(s),this.runNext()}):(this._active--,n.resolve(a),this.runNext())}catch(a){this._active--,n.reject(a),this.runNext()}}};e.Semaphore=r}}),wI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messageReader.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ReadableStreamMessageReader=e.AbstractMessageReader=e.MessageReader=void 0;var t=Dn(),r=Ms(),n=ei(),a=Wg(),s;(function(c){function f(d){let m=d;return m&&r.func(m.listen)&&r.func(m.dispose)&&r.func(m.onError)&&r.func(m.onClose)&&r.func(m.onPartialMessage)}i(f,"is"),c.is=f})(s||(e.MessageReader=s={}));var o=class{static{i(this,"AbstractMessageReader")}constructor(){this.errorEmitter=new n.Emitter,this.closeEmitter=new n.Emitter,this.partialMessageEmitter=new n.Emitter}dispose(){this.errorEmitter.dispose(),this.closeEmitter.dispose()}get onError(){return this.errorEmitter.event}fireError(c){this.errorEmitter.fire(this.asError(c))}get onClose(){return this.closeEmitter.event}fireClose(){this.closeEmitter.fire(void 0)}get onPartialMessage(){return this.partialMessageEmitter.event}firePartialMessage(c){this.partialMessageEmitter.fire(c)}asError(c){return c instanceof Error?c:new Error(`Reader received error. Reason: ${r.string(c.message)?c.message:"unknown"}`)}};e.AbstractMessageReader=o;var l;(function(c){function f(d){let m,g;const v=new Map;let _;const S=new Map;if(d===void 0||typeof d=="string")m=d??"utf-8";else{if(m=d.charset??"utf-8",d.contentDecoder!==void 0&&(g=d.contentDecoder,v.set(g.name,g)),d.contentDecoders!==void 0)for(const w of d.contentDecoders)v.set(w.name,w);if(d.contentTypeDecoder!==void 0&&(_=d.contentTypeDecoder,S.set(_.name,_)),d.contentTypeDecoders!==void 0)for(const w of d.contentTypeDecoders)S.set(w.name,w)}return _===void 0&&(_=(0,t.default)().applicationJson.decoder,S.set(_.name,_)),{charset:m,contentDecoder:g,contentDecoders:v,contentTypeDecoder:_,contentTypeDecoders:S}}i(f,"fromOptions"),c.fromOptions=f})(l||(l={}));var u=class extends o{static{i(this,"ReadableStreamMessageReader")}constructor(c,f){super(),this.readable=c,this.options=l.fromOptions(f),this.buffer=(0,t.default)().messageBuffer.create(this.options.charset),this._partialMessageTimeout=1e4,this.nextMessageLength=-1,this.messageToken=0,this.readSemaphore=new a.Semaphore(1)}set partialMessageTimeout(c){this._partialMessageTimeout=c}get partialMessageTimeout(){return this._partialMessageTimeout}listen(c){this.nextMessageLength=-1,this.messageToken=0,this.partialMessageTimer=void 0,this.callback=c;const f=this.readable.onData(d=>{this.onData(d)});return this.readable.onError(d=>this.fireError(d)),this.readable.onClose(()=>this.fireClose()),f}onData(c){try{for(this.buffer.append(c);;){if(this.nextMessageLength===-1){const d=this.buffer.tryReadHeaders(!0);if(!d)return;const m=d.get("content-length");if(!m){this.fireError(new Error(`Header must provide a Content-Length property. +${JSON.stringify(Object.fromEntries(d))}`));return}const g=parseInt(m);if(isNaN(g)){this.fireError(new Error(`Content-Length value must be a number. Got ${m}`));return}this.nextMessageLength=g}const f=this.buffer.tryReadBody(this.nextMessageLength);if(f===void 0){this.setPartialMessageTimer();return}this.clearPartialMessageTimer(),this.nextMessageLength=-1,this.readSemaphore.lock(async()=>{const d=this.options.contentDecoder!==void 0?await this.options.contentDecoder.decode(f):f,m=await this.options.contentTypeDecoder.decode(d,this.options);this.callback(m)}).catch(d=>{this.fireError(d)})}}catch(f){this.fireError(f)}}clearPartialMessageTimer(){this.partialMessageTimer&&(this.partialMessageTimer.dispose(),this.partialMessageTimer=void 0)}setPartialMessageTimer(){this.clearPartialMessageTimer(),!(this._partialMessageTimeout<=0)&&(this.partialMessageTimer=(0,t.default)().timer.setTimeout((c,f)=>{this.partialMessageTimer=void 0,c===this.messageToken&&(this.firePartialMessage({messageToken:c,waitingTime:f}),this.setPartialMessageTimer())},this._partialMessageTimeout,this.messageToken,this._partialMessageTimeout))}};e.ReadableStreamMessageReader=u}}),II=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messageWriter.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.WriteableStreamMessageWriter=e.AbstractMessageWriter=e.MessageWriter=void 0;var t=Dn(),r=Ms(),n=Wg(),a=ei(),s="Content-Length: ",o=`\r +`,l;(function(d){function m(g){let v=g;return v&&r.func(v.dispose)&&r.func(v.onClose)&&r.func(v.onError)&&r.func(v.write)}i(m,"is"),d.is=m})(l||(e.MessageWriter=l={}));var u=class{static{i(this,"AbstractMessageWriter")}constructor(){this.errorEmitter=new a.Emitter,this.closeEmitter=new a.Emitter}dispose(){this.errorEmitter.dispose(),this.closeEmitter.dispose()}get onError(){return this.errorEmitter.event}fireError(d,m,g){this.errorEmitter.fire([this.asError(d),m,g])}get onClose(){return this.closeEmitter.event}fireClose(){this.closeEmitter.fire(void 0)}asError(d){return d instanceof Error?d:new Error(`Writer received error. Reason: ${r.string(d.message)?d.message:"unknown"}`)}};e.AbstractMessageWriter=u;var c;(function(d){function m(g){return g===void 0||typeof g=="string"?{charset:g??"utf-8",contentTypeEncoder:(0,t.default)().applicationJson.encoder}:{charset:g.charset??"utf-8",contentEncoder:g.contentEncoder,contentTypeEncoder:g.contentTypeEncoder??(0,t.default)().applicationJson.encoder}}i(m,"fromOptions"),d.fromOptions=m})(c||(c={}));var f=class extends u{static{i(this,"WriteableStreamMessageWriter")}constructor(d,m){super(),this.writable=d,this.options=c.fromOptions(m),this.errorCount=0,this.writeSemaphore=new n.Semaphore(1),this.writable.onError(g=>this.fireError(g)),this.writable.onClose(()=>this.fireClose())}async write(d){return this.writeSemaphore.lock(async()=>this.options.contentTypeEncoder.encode(d,this.options).then(g=>this.options.contentEncoder!==void 0?this.options.contentEncoder.encode(g):g).then(g=>{const v=[];return v.push(s,g.byteLength.toString(),o),v.push(o),this.doWrite(d,v,g)},g=>{throw this.fireError(g),g}))}async doWrite(d,m,g){try{return await this.writable.write(m.join(""),"ascii"),this.writable.write(g)}catch(v){return this.handleError(v,d),Promise.reject(v)}}handleError(d,m){this.errorCount++,this.fireError(d,m,this.errorCount)}end(){this.writable.end()}};e.WriteableStreamMessageWriter=f}}),NI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.AbstractMessageBuffer=void 0;var t=13,r=10,n=`\r +`,a=class{static{i(this,"AbstractMessageBuffer")}constructor(s="utf-8"){this._encoding=s,this._chunks=[],this._totalLength=0}get encoding(){return this._encoding}append(s){const o=typeof s=="string"?this.fromString(s,this._encoding):s;this._chunks.push(o),this._totalLength+=o.byteLength}tryReadHeaders(s=!1){if(this._chunks.length===0)return;let o=0,l=0,u=0,c=0;e:for(;lthis._totalLength)throw new Error("Cannot read so many bytes!");if(this._chunks[0].byteLength===s){const c=this._chunks[0];return this._chunks.shift(),this._totalLength-=s,this.asNative(c)}if(this._chunks[0].byteLength>s){const c=this._chunks[0],f=this.asNative(c,s);return this._chunks[0]=c.slice(s),this._totalLength-=s,f}const o=this.allocNative(s);let l=0,u=0;for(;s>0;){const c=this._chunks[u];if(c.byteLength>s){const f=c.slice(0,s);o.set(f,l),l+=s,this._chunks[u]=c.slice(s),this._totalLength-=s,s-=s}else o.set(c,l),l+=c.byteLength,this._chunks.shift(),this._totalLength-=c.byteLength,s-=c.byteLength}return o}};e.AbstractMessageBuffer=a}}),PI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/connection.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.createMessageConnection=e.ConnectionOptions=e.MessageStrategy=e.CancellationStrategy=e.CancellationSenderStrategy=e.CancellationReceiverStrategy=e.RequestCancellationReceiverStrategy=e.IdCancellationReceiverStrategy=e.ConnectionStrategy=e.ConnectionError=e.ConnectionErrors=e.LogTraceNotification=e.SetTraceNotification=e.TraceFormat=e.TraceValues=e.Trace=e.NullLogger=e.ProgressType=e.ProgressToken=void 0;var t=Dn(),r=Ms(),n=Bg(),a=Kg(),s=ei(),o=xl(),l;(function(y){y.type=new n.NotificationType("$/cancelRequest")})(l||(l={}));var u;(function(y){function E(T){return typeof T=="string"||typeof T=="number"}i(E,"is"),y.is=E})(u||(e.ProgressToken=u={}));var c;(function(y){y.type=new n.NotificationType("$/progress")})(c||(c={}));var f=class{static{i(this,"ProgressType")}constructor(){}};e.ProgressType=f;var d;(function(y){function E(T){return r.func(T)}i(E,"is"),y.is=E})(d||(d={})),e.NullLogger=Object.freeze({error:i(()=>{},"error"),warn:i(()=>{},"warn"),info:i(()=>{},"info"),log:i(()=>{},"log")});var m;(function(y){y[y.Off=0]="Off",y[y.Messages=1]="Messages",y[y.Compact=2]="Compact",y[y.Verbose=3]="Verbose"})(m||(e.Trace=m={}));var g;(function(y){y.Off="off",y.Messages="messages",y.Compact="compact",y.Verbose="verbose"})(g||(e.TraceValues=g={})),(function(y){function E($){if(!r.string($))return y.Off;switch($=$.toLowerCase(),$){case"off":return y.Off;case"messages":return y.Messages;case"compact":return y.Compact;case"verbose":return y.Verbose;default:return y.Off}}i(E,"fromString"),y.fromString=E;function T($){switch($){case y.Off:return"off";case y.Messages:return"messages";case y.Compact:return"compact";case y.Verbose:return"verbose";default:return"off"}}i(T,"toString"),y.toString=T})(m||(e.Trace=m={}));var v;(function(y){y.Text="text",y.JSON="json"})(v||(e.TraceFormat=v={})),(function(y){function E(T){return r.string(T)?(T=T.toLowerCase(),T==="json"?y.JSON:y.Text):y.Text}i(E,"fromString"),y.fromString=E})(v||(e.TraceFormat=v={}));var _;(function(y){y.type=new n.NotificationType("$/setTrace")})(_||(e.SetTraceNotification=_={}));var S;(function(y){y.type=new n.NotificationType("$/logTrace")})(S||(e.LogTraceNotification=S={}));var w;(function(y){y[y.Closed=1]="Closed",y[y.Disposed=2]="Disposed",y[y.AlreadyListening=3]="AlreadyListening"})(w||(e.ConnectionErrors=w={}));var I=class Vg extends Error{static{i(this,"ConnectionError")}constructor(E,T){super(T),this.code=E,Object.setPrototypeOf(this,Vg.prototype)}};e.ConnectionError=I;var R;(function(y){function E(T){const $=T;return $&&r.func($.cancelUndispatched)}i(E,"is"),y.is=E})(R||(e.ConnectionStrategy=R={}));var P;(function(y){function E(T){const $=T;return $&&($.kind===void 0||$.kind==="id")&&r.func($.createCancellationTokenSource)&&($.dispose===void 0||r.func($.dispose))}i(E,"is"),y.is=E})(P||(e.IdCancellationReceiverStrategy=P={}));var z;(function(y){function E(T){const $=T;return $&&$.kind==="request"&&r.func($.createCancellationTokenSource)&&($.dispose===void 0||r.func($.dispose))}i(E,"is"),y.is=E})(z||(e.RequestCancellationReceiverStrategy=z={}));var X;(function(y){y.Message=Object.freeze({createCancellationTokenSource(T){return new o.CancellationTokenSource}});function E(T){return P.is(T)||z.is(T)}i(E,"is"),y.is=E})(X||(e.CancellationReceiverStrategy=X={}));var Z;(function(y){y.Message=Object.freeze({sendCancellation(T,$){return T.sendNotification(l.type,{id:$})},cleanup(T){}});function E(T){const $=T;return $&&r.func($.sendCancellation)&&r.func($.cleanup)}i(E,"is"),y.is=E})(Z||(e.CancellationSenderStrategy=Z={}));var ce;(function(y){y.Message=Object.freeze({receiver:X.Message,sender:Z.Message});function E(T){const $=T;return $&&X.is($.receiver)&&Z.is($.sender)}i(E,"is"),y.is=E})(ce||(e.CancellationStrategy=ce={}));var se;(function(y){function E(T){const $=T;return $&&r.func($.handleMessage)}i(E,"is"),y.is=E})(se||(e.MessageStrategy=se={}));var Se;(function(y){function E(T){const $=T;return $&&(ce.is($.cancellationStrategy)||R.is($.connectionStrategy)||se.is($.messageStrategy))}i(E,"is"),y.is=E})(Se||(e.ConnectionOptions=Se={}));var k;(function(y){y[y.New=1]="New",y[y.Listening=2]="Listening",y[y.Closed=3]="Closed",y[y.Disposed=4]="Disposed"})(k||(k={}));function C(y,E,T,$){const b=T!==void 0?T:e.NullLogger;let O=0,x=0,D=0;const G="2.0";let W;const Y=new Map;let V;const Pe=new Map,oe=new Map;let Le,De=new a.LinkedMap,ke=new Map,Ze=new Set,Je=new Map,ne=m.Off,Kt=v.Text,Ee,kt=k.New;const ra=new s.Emitter,fi=new s.Emitter,di=new s.Emitter,pi=new s.Emitter,mi=new s.Emitter,Ot=$&&$.cancellationStrategy?$.cancellationStrategy:ce.Message;function na(h){if(h===null)throw new Error("Can't send requests with id null since the response can't be correlated.");return"req-"+h.toString()}i(na,"createRequestQueueKey");function hi(h){return h===null?"res-unknown-"+(++D).toString():"res-"+h.toString()}i(hi,"createResponseQueueKey");function yi(){return"not-"+(++x).toString()}i(yi,"createNotificationQueueKey");function gi(h,N){n.Message.isRequest(N)?h.set(na(N.id),N):n.Message.isResponse(N)?h.set(hi(N.id),N):h.set(yi(),N)}i(gi,"addMessageToQueue");function vi(h){}i(vi,"cancelUndispatched");function aa(){return kt===k.Listening}i(aa,"isListening");function ia(){return kt===k.Closed}i(ia,"isClosed");function Wt(){return kt===k.Disposed}i(Wt,"isDisposed");function sa(){(kt===k.New||kt===k.Listening)&&(kt=k.Closed,fi.fire(void 0))}i(sa,"closeHandler");function Ti(h){ra.fire([h,void 0,void 0])}i(Ti,"readErrorHandler");function $i(h){ra.fire(h)}i($i,"writeErrorHandler"),y.onClose(sa),y.onError(Ti),E.onClose(sa),E.onError($i);function oa(){Le||De.size===0||(Le=(0,t.default)().timer.setImmediate(()=>{Le=void 0,Ri()}))}i(oa,"triggerMessageQueue");function la(h){n.Message.isRequest(h)?Ai(h):n.Message.isNotification(h)?Ci(h):n.Message.isResponse(h)?Ei(h):_i(h)}i(la,"handleMessage");function Ri(){if(De.size===0)return;const h=De.shift();try{const N=$?.messageStrategy;se.is(N)?N.handleMessage(h,la):la(h)}finally{oa()}}i(Ri,"processMessageQueue");const no=i(h=>{try{if(n.Message.isNotification(h)&&h.method===l.type.method){const N=h.params.id,L=na(N),M=De.get(L);if(n.Message.isRequest(M)){const fe=$?.connectionStrategy,Ce=fe&&fe.cancelUndispatched?fe.cancelUndispatched(M,vi):void 0;if(Ce&&(Ce.error!==void 0||Ce.result!==void 0)){De.delete(L),Je.delete(N),Ce.id=M.id,Lr(Ce,h.method,Date.now()),E.write(Ce).catch(()=>b.error("Sending response for canceled message failed."));return}}const he=Je.get(N);if(he!==void 0){he.cancel(),Jr(h);return}else Ze.add(N)}gi(De,h)}finally{oa()}},"callback");function Ai(h){if(Wt())return;function N(te,$e,le){const xe={jsonrpc:G,id:h.id};te instanceof n.ResponseError?xe.error=te.toJson():xe.result=te===void 0?null:te,Lr(xe,$e,le),E.write(xe).catch(()=>b.error("Sending response failed."))}i(N,"reply");function L(te,$e,le){const xe={jsonrpc:G,id:h.id,error:te.toJson()};Lr(xe,$e,le),E.write(xe).catch(()=>b.error("Sending response failed."))}i(L,"replyError");function M(te,$e,le){te===void 0&&(te=null);const xe={jsonrpc:G,id:h.id,result:te};Lr(xe,$e,le),E.write(xe).catch(()=>b.error("Sending response failed."))}i(M,"replySuccess"),wi(h);const he=Y.get(h.method);let fe,Ce;he&&(fe=he.type,Ce=he.handler);const we=Date.now();if(Ce||W){const te=h.id??String(Date.now()),$e=P.is(Ot.receiver)?Ot.receiver.createCancellationTokenSource(te):Ot.receiver.createCancellationTokenSource(h);h.id!==null&&Ze.has(h.id)&&$e.cancel(),h.id!==null&&Je.set(te,$e);try{let le;if(Ce)if(h.params===void 0){if(fe!==void 0&&fe.numberOfParams!==0){L(new n.ResponseError(n.ErrorCodes.InvalidParams,`Request ${h.method} defines ${fe.numberOfParams} params but received none.`),h.method,we);return}le=Ce($e.token)}else if(Array.isArray(h.params)){if(fe!==void 0&&fe.parameterStructures===n.ParameterStructures.byName){L(new n.ResponseError(n.ErrorCodes.InvalidParams,`Request ${h.method} defines parameters by name but received parameters by position`),h.method,we);return}le=Ce(...h.params,$e.token)}else{if(fe!==void 0&&fe.parameterStructures===n.ParameterStructures.byPosition){L(new n.ResponseError(n.ErrorCodes.InvalidParams,`Request ${h.method} defines parameters by position but received parameters by name`),h.method,we);return}le=Ce(h.params,$e.token)}else W&&(le=W(h.method,h.params,$e.token));const xe=le;le?xe.then?xe.then(Qe=>{Je.delete(te),N(Qe,h.method,we)},Qe=>{Je.delete(te),Qe instanceof n.ResponseError?L(Qe,h.method,we):Qe&&r.string(Qe.message)?L(new n.ResponseError(n.ErrorCodes.InternalError,`Request ${h.method} failed with message: ${Qe.message}`),h.method,we):L(new n.ResponseError(n.ErrorCodes.InternalError,`Request ${h.method} failed unexpectedly without providing any details.`),h.method,we)}):(Je.delete(te),N(le,h.method,we)):(Je.delete(te),M(le,h.method,we))}catch(le){Je.delete(te),le instanceof n.ResponseError?N(le,h.method,we):le&&r.string(le.message)?L(new n.ResponseError(n.ErrorCodes.InternalError,`Request ${h.method} failed with message: ${le.message}`),h.method,we):L(new n.ResponseError(n.ErrorCodes.InternalError,`Request ${h.method} failed unexpectedly without providing any details.`),h.method,we)}}else L(new n.ResponseError(n.ErrorCodes.MethodNotFound,`Unhandled method ${h.method}`),h.method,we)}i(Ai,"handleRequest");function Ei(h){if(!Wt())if(h.id===null)h.error?b.error(`Received response message without id: Error is: +${JSON.stringify(h.error,void 0,4)}`):b.error("Received response message without id. No further error information provided.");else{const N=h.id,L=ke.get(N);if(Ii(h,L),L!==void 0){ke.delete(N);try{if(h.error){const M=h.error;L.reject(new n.ResponseError(M.code,M.message,M.data))}else if(h.result!==void 0)L.resolve(h.result);else throw new Error("Should never happen.")}catch(M){M.message?b.error(`Response handler '${L.method}' failed with message: ${M.message}`):b.error(`Response handler '${L.method}' failed unexpectedly.`)}}}}i(Ei,"handleResponse");function Ci(h){if(Wt())return;let N,L;if(h.method===l.type.method){const M=h.params.id;Ze.delete(M),Jr(h);return}else{const M=Pe.get(h.method);M&&(L=M.handler,N=M.type)}if(L||V)try{if(Jr(h),L)if(h.params===void 0)N!==void 0&&N.numberOfParams!==0&&N.parameterStructures!==n.ParameterStructures.byName&&b.error(`Notification ${h.method} defines ${N.numberOfParams} params but received none.`),L();else if(Array.isArray(h.params)){const M=h.params;h.method===c.type.method&&M.length===2&&u.is(M[0])?L({token:M[0],value:M[1]}):(N!==void 0&&(N.parameterStructures===n.ParameterStructures.byName&&b.error(`Notification ${h.method} defines parameters by name but received parameters by position`),N.numberOfParams!==h.params.length&&b.error(`Notification ${h.method} defines ${N.numberOfParams} params but received ${M.length} arguments`)),L(...M))}else N!==void 0&&N.parameterStructures===n.ParameterStructures.byPosition&&b.error(`Notification ${h.method} defines parameters by position but received parameters by name`),L(h.params);else V&&V(h.method,h.params)}catch(M){M.message?b.error(`Notification handler '${h.method}' failed with message: ${M.message}`):b.error(`Notification handler '${h.method}' failed unexpectedly.`)}else di.fire(h)}i(Ci,"handleNotification");function _i(h){if(!h){b.error("Received empty message.");return}b.error(`Received message which is neither a response nor a notification message: +${JSON.stringify(h,null,4)}`);const N=h;if(r.string(N.id)||r.number(N.id)){const L=N.id,M=ke.get(L);M&&M.reject(new Error("The received response has neither a result nor an error property."))}}i(_i,"handleInvalidMessage");function _t(h){if(h!=null)switch(ne){case m.Verbose:return JSON.stringify(h,null,4);case m.Compact:return JSON.stringify(h);default:return}}i(_t,"stringifyTrace");function bi(h){if(!(ne===m.Off||!Ee))if(Kt===v.Text){let N;(ne===m.Verbose||ne===m.Compact)&&h.params&&(N=`Params: ${_t(h.params)} + +`),Ee.log(`Sending request '${h.method} - (${h.id})'.`,N)}else Vt("send-request",h)}i(bi,"traceSendingRequest");function Si(h){if(!(ne===m.Off||!Ee))if(Kt===v.Text){let N;(ne===m.Verbose||ne===m.Compact)&&(h.params?N=`Params: ${_t(h.params)} + +`:N=`No parameters provided. + +`),Ee.log(`Sending notification '${h.method}'.`,N)}else Vt("send-notification",h)}i(Si,"traceSendingNotification");function Lr(h,N,L){if(!(ne===m.Off||!Ee))if(Kt===v.Text){let M;(ne===m.Verbose||ne===m.Compact)&&(h.error&&h.error.data?M=`Error data: ${_t(h.error.data)} + +`:h.result?M=`Result: ${_t(h.result)} + +`:h.error===void 0&&(M=`No result returned. + +`)),Ee.log(`Sending response '${N} - (${h.id})'. Processing request took ${Date.now()-L}ms`,M)}else Vt("send-response",h)}i(Lr,"traceSendingResponse");function wi(h){if(!(ne===m.Off||!Ee))if(Kt===v.Text){let N;(ne===m.Verbose||ne===m.Compact)&&h.params&&(N=`Params: ${_t(h.params)} + +`),Ee.log(`Received request '${h.method} - (${h.id})'.`,N)}else Vt("receive-request",h)}i(wi,"traceReceivedRequest");function Jr(h){if(!(ne===m.Off||!Ee||h.method===S.type.method))if(Kt===v.Text){let N;(ne===m.Verbose||ne===m.Compact)&&(h.params?N=`Params: ${_t(h.params)} + +`:N=`No parameters provided. + +`),Ee.log(`Received notification '${h.method}'.`,N)}else Vt("receive-notification",h)}i(Jr,"traceReceivedNotification");function Ii(h,N){if(!(ne===m.Off||!Ee))if(Kt===v.Text){let L;if((ne===m.Verbose||ne===m.Compact)&&(h.error&&h.error.data?L=`Error data: ${_t(h.error.data)} + +`:h.result?L=`Result: ${_t(h.result)} + +`:h.error===void 0&&(L=`No result returned. + +`)),N){const M=h.error?` Request failed: ${h.error.message} (${h.error.code}).`:"";Ee.log(`Received response '${N.method} - (${h.id})' in ${Date.now()-N.timerStart}ms.${M}`,L)}else Ee.log(`Received response ${h.id} without active response promise.`,L)}else Vt("receive-response",h)}i(Ii,"traceReceivedResponse");function Vt(h,N){if(!Ee||ne===m.Off)return;const L={isLSPMessage:!0,type:h,message:N,timestamp:Date.now()};Ee.log(L)}i(Vt,"logLSPMessage");function cr(){if(ia())throw new I(w.Closed,"Connection is closed.");if(Wt())throw new I(w.Disposed,"Connection is disposed.")}i(cr,"throwIfClosedOrDisposed");function Ni(){if(aa())throw new I(w.AlreadyListening,"Connection is already listening")}i(Ni,"throwIfListening");function Pi(){if(!aa())throw new Error("Call listen() first.")}i(Pi,"throwIfNotListening");function fr(h){return h===void 0?null:h}i(fr,"undefinedToNull");function ua(h){if(h!==null)return h}i(ua,"nullToUndefined");function p(h){return h!=null&&!Array.isArray(h)&&typeof h=="object"}i(p,"isNamedParam");function ae(h,N){switch(h){case n.ParameterStructures.auto:return p(N)?ua(N):[fr(N)];case n.ParameterStructures.byName:if(!p(N))throw new Error("Received parameters by name but param is not an object literal.");return ua(N);case n.ParameterStructures.byPosition:return[fr(N)];default:throw new Error(`Unknown parameter structure ${h.toString()}`)}}i(ae,"computeSingleParam");function Te(h,N){let L;const M=h.numberOfParams;switch(M){case 0:L=void 0;break;case 1:L=ae(h.parameterStructures,N[0]);break;default:L=[];for(let he=0;he{cr();let L,M;if(r.string(h)){L=h;const fe=N[0];let Ce=0,we=n.ParameterStructures.auto;n.ParameterStructures.is(fe)&&(Ce=1,we=fe);let te=N.length;const $e=te-Ce;switch($e){case 0:M=void 0;break;case 1:M=ae(we,N[Ce]);break;default:if(we===n.ParameterStructures.byName)throw new Error(`Received ${$e} parameters for 'by Name' notification parameter structure.`);M=N.slice(Ce,te).map(le=>fr(le));break}}else{const fe=N;L=h.method,M=Te(h,fe)}const he={jsonrpc:G,method:L,params:M};return Si(he),E.write(he).catch(fe=>{throw b.error("Sending notification failed."),fe})},"sendNotification"),onNotification:i((h,N)=>{cr();let L;return r.func(h)?V=h:N&&(r.string(h)?(L=h,Pe.set(h,{type:void 0,handler:N})):(L=h.method,Pe.set(h.method,{type:h,handler:N}))),{dispose:i(()=>{L!==void 0?Pe.delete(L):V=void 0},"dispose")}},"onNotification"),onProgress:i((h,N,L)=>{if(oe.has(N))throw new Error(`Progress handler for token ${N} already registered`);return oe.set(N,L),{dispose:i(()=>{oe.delete(N)},"dispose")}},"onProgress"),sendProgress:i((h,N,L)=>q.sendNotification(c.type,{token:N,value:L}),"sendProgress"),onUnhandledProgress:pi.event,sendRequest:i((h,...N)=>{cr(),Pi();let L,M,he;if(r.string(h)){L=h;const te=N[0],$e=N[N.length-1];let le=0,xe=n.ParameterStructures.auto;n.ParameterStructures.is(te)&&(le=1,xe=te);let Qe=N.length;o.CancellationToken.is($e)&&(Qe=Qe-1,he=$e);const qt=Qe-le;switch(qt){case 0:M=void 0;break;case 1:M=ae(xe,N[le]);break;default:if(xe===n.ParameterStructures.byName)throw new Error(`Received ${qt} parameters for 'by Name' request parameter structure.`);M=N.slice(le,Qe).map($I=>fr($I));break}}else{const te=N;L=h.method,M=Te(h,te);const $e=h.numberOfParams;he=o.CancellationToken.is(te[$e])?te[$e]:void 0}const fe=O++;let Ce;he&&(Ce=he.onCancellationRequested(()=>{const te=Ot.sender.sendCancellation(q,fe);return te===void 0?(b.log(`Received no promise from cancellation strategy when cancelling id ${fe}`),Promise.resolve()):te.catch(()=>{b.log(`Sending cancellation messages for id ${fe} failed`)})}));const we={jsonrpc:G,id:fe,method:L,params:M};return bi(we),typeof Ot.sender.enableCancellation=="function"&&Ot.sender.enableCancellation(we),new Promise(async(te,$e)=>{const le=i(qt=>{te(qt),Ot.sender.cleanup(fe),Ce?.dispose()},"resolveWithCleanup"),xe=i(qt=>{$e(qt),Ot.sender.cleanup(fe),Ce?.dispose()},"rejectWithCleanup"),Qe={method:L,timerStart:Date.now(),resolve:le,reject:xe};try{await E.write(we),ke.set(fe,Qe)}catch(qt){throw b.error("Sending request failed."),Qe.reject(new n.ResponseError(n.ErrorCodes.MessageWriteError,qt.message?qt.message:"Unknown reason")),qt}})},"sendRequest"),onRequest:i((h,N)=>{cr();let L=null;return d.is(h)?(L=void 0,W=h):r.string(h)?(L=null,N!==void 0&&(L=h,Y.set(h,{handler:N,type:void 0}))):N!==void 0&&(L=h.method,Y.set(h.method,{type:h,handler:N})),{dispose:i(()=>{L!==null&&(L!==void 0?Y.delete(L):W=void 0)},"dispose")}},"onRequest"),hasPendingResponse:i(()=>ke.size>0,"hasPendingResponse"),trace:i(async(h,N,L)=>{let M=!1,he=v.Text;L!==void 0&&(r.boolean(L)?M=L:(M=L.sendNotification||!1,he=L.traceFormat||v.Text)),ne=h,Kt=he,ne===m.Off?Ee=void 0:Ee=N,M&&!ia()&&!Wt()&&await q.sendNotification(_.type,{value:m.toString(h)})},"trace"),onError:ra.event,onClose:fi.event,onUnhandledNotification:di.event,onDispose:mi.event,end:i(()=>{E.end()},"end"),dispose:i(()=>{if(Wt())return;kt=k.Disposed,mi.fire(void 0);const h=new n.ResponseError(n.ErrorCodes.PendingResponseRejected,"Pending response rejected since connection got disposed");for(const N of ke.values())N.reject(h);ke=new Map,Je=new Map,Ze=new Set,De=new a.LinkedMap,r.func(E.dispose)&&E.dispose(),r.func(y.dispose)&&y.dispose()},"dispose"),listen:i(()=>{cr(),Ni(),kt=k.Listening,y.listen(no)},"listen"),inspect:i(()=>{(0,t.default)().console.log("inspect")},"inspect")};return q.onNotification(S.type,h=>{if(ne===m.Off||!Ee)return;const N=ne===m.Verbose||ne===m.Compact;Ee.log(h.message,N?h.verbose:void 0)}),q.onNotification(c.type,h=>{const N=oe.get(h.token);N?N(h.value):pi.fire(h)}),q}i(C,"createMessageConnection"),e.createMessageConnection=C}}),Af=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/api.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ProgressType=e.ProgressToken=e.createMessageConnection=e.NullLogger=e.ConnectionOptions=e.ConnectionStrategy=e.AbstractMessageBuffer=e.WriteableStreamMessageWriter=e.AbstractMessageWriter=e.MessageWriter=e.ReadableStreamMessageReader=e.AbstractMessageReader=e.MessageReader=e.SharedArrayReceiverStrategy=e.SharedArraySenderStrategy=e.CancellationToken=e.CancellationTokenSource=e.Emitter=e.Event=e.Disposable=e.LRUCache=e.Touch=e.LinkedMap=e.ParameterStructures=e.NotificationType9=e.NotificationType8=e.NotificationType7=e.NotificationType6=e.NotificationType5=e.NotificationType4=e.NotificationType3=e.NotificationType2=e.NotificationType1=e.NotificationType0=e.NotificationType=e.ErrorCodes=e.ResponseError=e.RequestType9=e.RequestType8=e.RequestType7=e.RequestType6=e.RequestType5=e.RequestType4=e.RequestType3=e.RequestType2=e.RequestType1=e.RequestType0=e.RequestType=e.Message=e.RAL=void 0,e.MessageStrategy=e.CancellationStrategy=e.CancellationSenderStrategy=e.CancellationReceiverStrategy=e.ConnectionError=e.ConnectionErrors=e.LogTraceNotification=e.SetTraceNotification=e.TraceFormat=e.TraceValues=e.Trace=void 0;var t=Bg();Object.defineProperty(e,"Message",{enumerable:!0,get:i(function(){return t.Message},"get")}),Object.defineProperty(e,"RequestType",{enumerable:!0,get:i(function(){return t.RequestType},"get")}),Object.defineProperty(e,"RequestType0",{enumerable:!0,get:i(function(){return t.RequestType0},"get")}),Object.defineProperty(e,"RequestType1",{enumerable:!0,get:i(function(){return t.RequestType1},"get")}),Object.defineProperty(e,"RequestType2",{enumerable:!0,get:i(function(){return t.RequestType2},"get")}),Object.defineProperty(e,"RequestType3",{enumerable:!0,get:i(function(){return t.RequestType3},"get")}),Object.defineProperty(e,"RequestType4",{enumerable:!0,get:i(function(){return t.RequestType4},"get")}),Object.defineProperty(e,"RequestType5",{enumerable:!0,get:i(function(){return t.RequestType5},"get")}),Object.defineProperty(e,"RequestType6",{enumerable:!0,get:i(function(){return t.RequestType6},"get")}),Object.defineProperty(e,"RequestType7",{enumerable:!0,get:i(function(){return t.RequestType7},"get")}),Object.defineProperty(e,"RequestType8",{enumerable:!0,get:i(function(){return t.RequestType8},"get")}),Object.defineProperty(e,"RequestType9",{enumerable:!0,get:i(function(){return t.RequestType9},"get")}),Object.defineProperty(e,"ResponseError",{enumerable:!0,get:i(function(){return t.ResponseError},"get")}),Object.defineProperty(e,"ErrorCodes",{enumerable:!0,get:i(function(){return t.ErrorCodes},"get")}),Object.defineProperty(e,"NotificationType",{enumerable:!0,get:i(function(){return t.NotificationType},"get")}),Object.defineProperty(e,"NotificationType0",{enumerable:!0,get:i(function(){return t.NotificationType0},"get")}),Object.defineProperty(e,"NotificationType1",{enumerable:!0,get:i(function(){return t.NotificationType1},"get")}),Object.defineProperty(e,"NotificationType2",{enumerable:!0,get:i(function(){return t.NotificationType2},"get")}),Object.defineProperty(e,"NotificationType3",{enumerable:!0,get:i(function(){return t.NotificationType3},"get")}),Object.defineProperty(e,"NotificationType4",{enumerable:!0,get:i(function(){return t.NotificationType4},"get")}),Object.defineProperty(e,"NotificationType5",{enumerable:!0,get:i(function(){return t.NotificationType5},"get")}),Object.defineProperty(e,"NotificationType6",{enumerable:!0,get:i(function(){return t.NotificationType6},"get")}),Object.defineProperty(e,"NotificationType7",{enumerable:!0,get:i(function(){return t.NotificationType7},"get")}),Object.defineProperty(e,"NotificationType8",{enumerable:!0,get:i(function(){return t.NotificationType8},"get")}),Object.defineProperty(e,"NotificationType9",{enumerable:!0,get:i(function(){return t.NotificationType9},"get")}),Object.defineProperty(e,"ParameterStructures",{enumerable:!0,get:i(function(){return t.ParameterStructures},"get")});var r=Kg();Object.defineProperty(e,"LinkedMap",{enumerable:!0,get:i(function(){return r.LinkedMap},"get")}),Object.defineProperty(e,"LRUCache",{enumerable:!0,get:i(function(){return r.LRUCache},"get")}),Object.defineProperty(e,"Touch",{enumerable:!0,get:i(function(){return r.Touch},"get")});var n=bI();Object.defineProperty(e,"Disposable",{enumerable:!0,get:i(function(){return n.Disposable},"get")});var a=ei();Object.defineProperty(e,"Event",{enumerable:!0,get:i(function(){return a.Event},"get")}),Object.defineProperty(e,"Emitter",{enumerable:!0,get:i(function(){return a.Emitter},"get")});var s=xl();Object.defineProperty(e,"CancellationTokenSource",{enumerable:!0,get:i(function(){return s.CancellationTokenSource},"get")}),Object.defineProperty(e,"CancellationToken",{enumerable:!0,get:i(function(){return s.CancellationToken},"get")});var o=SI();Object.defineProperty(e,"SharedArraySenderStrategy",{enumerable:!0,get:i(function(){return o.SharedArraySenderStrategy},"get")}),Object.defineProperty(e,"SharedArrayReceiverStrategy",{enumerable:!0,get:i(function(){return o.SharedArrayReceiverStrategy},"get")});var l=wI();Object.defineProperty(e,"MessageReader",{enumerable:!0,get:i(function(){return l.MessageReader},"get")}),Object.defineProperty(e,"AbstractMessageReader",{enumerable:!0,get:i(function(){return l.AbstractMessageReader},"get")}),Object.defineProperty(e,"ReadableStreamMessageReader",{enumerable:!0,get:i(function(){return l.ReadableStreamMessageReader},"get")});var u=II();Object.defineProperty(e,"MessageWriter",{enumerable:!0,get:i(function(){return u.MessageWriter},"get")}),Object.defineProperty(e,"AbstractMessageWriter",{enumerable:!0,get:i(function(){return u.AbstractMessageWriter},"get")}),Object.defineProperty(e,"WriteableStreamMessageWriter",{enumerable:!0,get:i(function(){return u.WriteableStreamMessageWriter},"get")});var c=NI();Object.defineProperty(e,"AbstractMessageBuffer",{enumerable:!0,get:i(function(){return c.AbstractMessageBuffer},"get")});var f=PI();Object.defineProperty(e,"ConnectionStrategy",{enumerable:!0,get:i(function(){return f.ConnectionStrategy},"get")}),Object.defineProperty(e,"ConnectionOptions",{enumerable:!0,get:i(function(){return f.ConnectionOptions},"get")}),Object.defineProperty(e,"NullLogger",{enumerable:!0,get:i(function(){return f.NullLogger},"get")}),Object.defineProperty(e,"createMessageConnection",{enumerable:!0,get:i(function(){return f.createMessageConnection},"get")}),Object.defineProperty(e,"ProgressToken",{enumerable:!0,get:i(function(){return f.ProgressToken},"get")}),Object.defineProperty(e,"ProgressType",{enumerable:!0,get:i(function(){return f.ProgressType},"get")}),Object.defineProperty(e,"Trace",{enumerable:!0,get:i(function(){return f.Trace},"get")}),Object.defineProperty(e,"TraceValues",{enumerable:!0,get:i(function(){return f.TraceValues},"get")}),Object.defineProperty(e,"TraceFormat",{enumerable:!0,get:i(function(){return f.TraceFormat},"get")}),Object.defineProperty(e,"SetTraceNotification",{enumerable:!0,get:i(function(){return f.SetTraceNotification},"get")}),Object.defineProperty(e,"LogTraceNotification",{enumerable:!0,get:i(function(){return f.LogTraceNotification},"get")}),Object.defineProperty(e,"ConnectionErrors",{enumerable:!0,get:i(function(){return f.ConnectionErrors},"get")}),Object.defineProperty(e,"ConnectionError",{enumerable:!0,get:i(function(){return f.ConnectionError},"get")}),Object.defineProperty(e,"CancellationReceiverStrategy",{enumerable:!0,get:i(function(){return f.CancellationReceiverStrategy},"get")}),Object.defineProperty(e,"CancellationSenderStrategy",{enumerable:!0,get:i(function(){return f.CancellationSenderStrategy},"get")}),Object.defineProperty(e,"CancellationStrategy",{enumerable:!0,get:i(function(){return f.CancellationStrategy},"get")}),Object.defineProperty(e,"MessageStrategy",{enumerable:!0,get:i(function(){return f.MessageStrategy},"get")});var d=Dn();e.RAL=d.default}}),kI=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/browser/ril.js"(e){Object.defineProperty(e,"__esModule",{value:!0});var t=Af(),r=class qg extends t.AbstractMessageBuffer{static{i(this,"MessageBuffer")}constructor(c="utf-8"){super(c),this.asciiDecoder=new TextDecoder("ascii")}emptyBuffer(){return qg.emptyBuffer}fromString(c,f){return new TextEncoder().encode(c)}toString(c,f){return f==="ascii"?this.asciiDecoder.decode(c):new TextDecoder(f).decode(c)}asNative(c,f){return f===void 0?c:c.slice(0,f)}allocNative(c){return new Uint8Array(c)}};r.emptyBuffer=new Uint8Array(0);var n=class{static{i(this,"ReadableStreamWrapper")}constructor(u){this.socket=u,this._onData=new t.Emitter,this._messageListener=c=>{c.data.arrayBuffer().then(d=>{this._onData.fire(new Uint8Array(d))},()=>{(0,t.RAL)().console.error("Converting blob to array buffer failed.")})},this.socket.addEventListener("message",this._messageListener)}onClose(u){return this.socket.addEventListener("close",u),t.Disposable.create(()=>this.socket.removeEventListener("close",u))}onError(u){return this.socket.addEventListener("error",u),t.Disposable.create(()=>this.socket.removeEventListener("error",u))}onEnd(u){return this.socket.addEventListener("end",u),t.Disposable.create(()=>this.socket.removeEventListener("end",u))}onData(u){return this._onData.event(u)}},a=class{static{i(this,"WritableStreamWrapper")}constructor(u){this.socket=u}onClose(u){return this.socket.addEventListener("close",u),t.Disposable.create(()=>this.socket.removeEventListener("close",u))}onError(u){return this.socket.addEventListener("error",u),t.Disposable.create(()=>this.socket.removeEventListener("error",u))}onEnd(u){return this.socket.addEventListener("end",u),t.Disposable.create(()=>this.socket.removeEventListener("end",u))}write(u,c){if(typeof u=="string"){if(c!==void 0&&c!=="utf-8")throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${c}`);this.socket.send(u)}else this.socket.send(u);return Promise.resolve()}end(){this.socket.close()}},s=new TextEncoder,o=Object.freeze({messageBuffer:Object.freeze({create:i(u=>new r(u),"create")}),applicationJson:Object.freeze({encoder:Object.freeze({name:"application/json",encode:i((u,c)=>{if(c.charset!=="utf-8")throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${c.charset}`);return Promise.resolve(s.encode(JSON.stringify(u,void 0,0)))},"encode")}),decoder:Object.freeze({name:"application/json",decode:i((u,c)=>{if(!(u instanceof Uint8Array))throw new Error("In a Browser environments only Uint8Arrays are supported.");return Promise.resolve(JSON.parse(new TextDecoder(c.charset).decode(u)))},"decode")})}),stream:Object.freeze({asReadableStream:i(u=>new n(u),"asReadableStream"),asWritableStream:i(u=>new a(u),"asWritableStream")}),console,timer:Object.freeze({setTimeout(u,c,...f){const d=setTimeout(u,c,...f);return{dispose:i(()=>clearTimeout(d),"dispose")}},setImmediate(u,...c){const f=setTimeout(u,0,...c);return{dispose:i(()=>clearTimeout(f),"dispose")}},setInterval(u,c,...f){const d=setInterval(u,c,...f);return{dispose:i(()=>clearInterval(d),"dispose")}}})});function l(){return o}i(l,"RIL"),(function(u){function c(){t.RAL.install(o)}i(c,"install"),u.install=c})(l||(l={})),e.default=l}}),ti=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/browser/main.js"(e){var t=e&&e.__createBinding||(Object.create?(function(u,c,f,d){d===void 0&&(d=f);var m=Object.getOwnPropertyDescriptor(c,f);(!m||("get"in m?!c.__esModule:m.writable||m.configurable))&&(m={enumerable:!0,get:i(function(){return c[f]},"get")}),Object.defineProperty(u,d,m)}):(function(u,c,f,d){d===void 0&&(d=f),u[d]=c[f]})),r=e&&e.__exportStar||function(u,c){for(var f in u)f!=="default"&&!Object.prototype.hasOwnProperty.call(c,f)&&t(c,u,f)};Object.defineProperty(e,"__esModule",{value:!0}),e.createMessageConnection=e.BrowserMessageWriter=e.BrowserMessageReader=void 0;var n=kI();n.default.install();var a=Af();r(Af(),e);var s=class extends a.AbstractMessageReader{static{i(this,"BrowserMessageReader")}constructor(u){super(),this._onData=new a.Emitter,this._messageListener=c=>{this._onData.fire(c.data)},u.addEventListener("error",c=>this.fireError(c)),u.onmessage=this._messageListener}listen(u){return this._onData.event(u)}};e.BrowserMessageReader=s;var o=class extends a.AbstractMessageWriter{static{i(this,"BrowserMessageWriter")}constructor(u){super(),this.port=u,this.errorCount=0,u.addEventListener("error",c=>this.fireError(c))}write(u){try{return this.port.postMessage(u),Promise.resolve()}catch(c){return this.handleError(c,u),Promise.reject(c)}}handleError(u,c){this.errorCount++,this.fireError(u,c,this.errorCount)}end(){}};e.BrowserMessageWriter=o;function l(u,c,f,d){return f===void 0&&(f=a.NullLogger),a.ConnectionStrategy.is(d)&&(d={connectionStrategy:d}),(0,a.createMessageConnection)(u,c,f,d)}i(l,"createMessageConnection"),e.createMessageConnection=l}}),uh=H({"../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/browser.js"(e,t){t.exports=ti()}}),Ae=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/messages.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ProtocolNotificationType=e.ProtocolNotificationType0=e.ProtocolRequestType=e.ProtocolRequestType0=e.RegistrationType=e.MessageDirection=void 0;var t=ti(),r;(function(u){u.clientToServer="clientToServer",u.serverToClient="serverToClient",u.both="both"})(r||(e.MessageDirection=r={}));var n=class{static{i(this,"RegistrationType")}constructor(u){this.method=u}};e.RegistrationType=n;var a=class extends t.RequestType0{static{i(this,"ProtocolRequestType0")}constructor(u){super(u)}};e.ProtocolRequestType0=a;var s=class extends t.RequestType{static{i(this,"ProtocolRequestType")}constructor(u){super(u,t.ParameterStructures.byName)}};e.ProtocolRequestType=s;var o=class extends t.NotificationType0{static{i(this,"ProtocolNotificationType0")}constructor(u){super(u)}};e.ProtocolNotificationType0=o;var l=class extends t.NotificationType{static{i(this,"ProtocolNotificationType")}constructor(u){super(u,t.ParameterStructures.byName)}};e.ProtocolNotificationType=l}}),bd=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.objectLiteral=e.typedArray=e.stringArray=e.array=e.func=e.error=e.number=e.string=e.boolean=void 0;function t(f){return f===!0||f===!1}i(t,"boolean"),e.boolean=t;function r(f){return typeof f=="string"||f instanceof String}i(r,"string"),e.string=r;function n(f){return typeof f=="number"||f instanceof Number}i(n,"number"),e.number=n;function a(f){return f instanceof Error}i(a,"error"),e.error=a;function s(f){return typeof f=="function"}i(s,"func"),e.func=s;function o(f){return Array.isArray(f)}i(o,"array"),e.array=o;function l(f){return o(f)&&f.every(d=>r(d))}i(l,"stringArray"),e.stringArray=l;function u(f,d){return Array.isArray(f)&&f.every(d)}i(u,"typedArray"),e.typedArray=u;function c(f){return f!==null&&typeof f=="object"}i(c,"objectLiteral"),e.objectLiteral=c}}),OI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ImplementationRequest=void 0;var t=Ae(),r;(function(n){n.method="textDocument/implementation",n.messageDirection=t.MessageDirection.clientToServer,n.type=new t.ProtocolRequestType(n.method)})(r||(e.ImplementationRequest=r={}))}}),LI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.TypeDefinitionRequest=void 0;var t=Ae(),r;(function(n){n.method="textDocument/typeDefinition",n.messageDirection=t.MessageDirection.clientToServer,n.type=new t.ProtocolRequestType(n.method)})(r||(e.TypeDefinitionRequest=r={}))}}),DI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.DidChangeWorkspaceFoldersNotification=e.WorkspaceFoldersRequest=void 0;var t=Ae(),r;(function(a){a.method="workspace/workspaceFolders",a.messageDirection=t.MessageDirection.serverToClient,a.type=new t.ProtocolRequestType0(a.method)})(r||(e.WorkspaceFoldersRequest=r={}));var n;(function(a){a.method="workspace/didChangeWorkspaceFolders",a.messageDirection=t.MessageDirection.clientToServer,a.type=new t.ProtocolNotificationType(a.method)})(n||(e.DidChangeWorkspaceFoldersNotification=n={}))}}),xI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ConfigurationRequest=void 0;var t=Ae(),r;(function(n){n.method="workspace/configuration",n.messageDirection=t.MessageDirection.serverToClient,n.type=new t.ProtocolRequestType(n.method)})(r||(e.ConfigurationRequest=r={}))}}),MI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ColorPresentationRequest=e.DocumentColorRequest=void 0;var t=Ae(),r;(function(a){a.method="textDocument/documentColor",a.messageDirection=t.MessageDirection.clientToServer,a.type=new t.ProtocolRequestType(a.method)})(r||(e.DocumentColorRequest=r={}));var n;(function(a){a.method="textDocument/colorPresentation",a.messageDirection=t.MessageDirection.clientToServer,a.type=new t.ProtocolRequestType(a.method)})(n||(e.ColorPresentationRequest=n={}))}}),GI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.FoldingRangeRefreshRequest=e.FoldingRangeRequest=void 0;var t=Ae(),r;(function(a){a.method="textDocument/foldingRange",a.messageDirection=t.MessageDirection.clientToServer,a.type=new t.ProtocolRequestType(a.method)})(r||(e.FoldingRangeRequest=r={}));var n;(function(a){a.method="workspace/foldingRange/refresh",a.messageDirection=t.MessageDirection.serverToClient,a.type=new t.ProtocolRequestType0(a.method)})(n||(e.FoldingRangeRefreshRequest=n={}))}}),FI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.DeclarationRequest=void 0;var t=Ae(),r;(function(n){n.method="textDocument/declaration",n.messageDirection=t.MessageDirection.clientToServer,n.type=new t.ProtocolRequestType(n.method)})(r||(e.DeclarationRequest=r={}))}}),zI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.SelectionRangeRequest=void 0;var t=Ae(),r;(function(n){n.method="textDocument/selectionRange",n.messageDirection=t.MessageDirection.clientToServer,n.type=new t.ProtocolRequestType(n.method)})(r||(e.SelectionRangeRequest=r={}))}}),jI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.WorkDoneProgressCancelNotification=e.WorkDoneProgressCreateRequest=e.WorkDoneProgress=void 0;var t=ti(),r=Ae(),n;(function(o){o.type=new t.ProgressType;function l(u){return u===o.type}i(l,"is"),o.is=l})(n||(e.WorkDoneProgress=n={}));var a;(function(o){o.method="window/workDoneProgress/create",o.messageDirection=r.MessageDirection.serverToClient,o.type=new r.ProtocolRequestType(o.method)})(a||(e.WorkDoneProgressCreateRequest=a={}));var s;(function(o){o.method="window/workDoneProgress/cancel",o.messageDirection=r.MessageDirection.clientToServer,o.type=new r.ProtocolNotificationType(o.method)})(s||(e.WorkDoneProgressCancelNotification=s={}))}}),BI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.CallHierarchyOutgoingCallsRequest=e.CallHierarchyIncomingCallsRequest=e.CallHierarchyPrepareRequest=void 0;var t=Ae(),r;(function(s){s.method="textDocument/prepareCallHierarchy",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(r||(e.CallHierarchyPrepareRequest=r={}));var n;(function(s){s.method="callHierarchy/incomingCalls",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(n||(e.CallHierarchyIncomingCallsRequest=n={}));var a;(function(s){s.method="callHierarchy/outgoingCalls",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(a||(e.CallHierarchyOutgoingCallsRequest=a={}))}}),UI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.SemanticTokensRefreshRequest=e.SemanticTokensRangeRequest=e.SemanticTokensDeltaRequest=e.SemanticTokensRequest=e.SemanticTokensRegistrationType=e.TokenFormat=void 0;var t=Ae(),r;(function(u){u.Relative="relative"})(r||(e.TokenFormat=r={}));var n;(function(u){u.method="textDocument/semanticTokens",u.type=new t.RegistrationType(u.method)})(n||(e.SemanticTokensRegistrationType=n={}));var a;(function(u){u.method="textDocument/semanticTokens/full",u.messageDirection=t.MessageDirection.clientToServer,u.type=new t.ProtocolRequestType(u.method),u.registrationMethod=n.method})(a||(e.SemanticTokensRequest=a={}));var s;(function(u){u.method="textDocument/semanticTokens/full/delta",u.messageDirection=t.MessageDirection.clientToServer,u.type=new t.ProtocolRequestType(u.method),u.registrationMethod=n.method})(s||(e.SemanticTokensDeltaRequest=s={}));var o;(function(u){u.method="textDocument/semanticTokens/range",u.messageDirection=t.MessageDirection.clientToServer,u.type=new t.ProtocolRequestType(u.method),u.registrationMethod=n.method})(o||(e.SemanticTokensRangeRequest=o={}));var l;(function(u){u.method="workspace/semanticTokens/refresh",u.messageDirection=t.MessageDirection.serverToClient,u.type=new t.ProtocolRequestType0(u.method)})(l||(e.SemanticTokensRefreshRequest=l={}))}}),KI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.ShowDocumentRequest=void 0;var t=Ae(),r;(function(n){n.method="window/showDocument",n.messageDirection=t.MessageDirection.serverToClient,n.type=new t.ProtocolRequestType(n.method)})(r||(e.ShowDocumentRequest=r={}))}}),WI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.LinkedEditingRangeRequest=void 0;var t=Ae(),r;(function(n){n.method="textDocument/linkedEditingRange",n.messageDirection=t.MessageDirection.clientToServer,n.type=new t.ProtocolRequestType(n.method)})(r||(e.LinkedEditingRangeRequest=r={}))}}),VI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.WillDeleteFilesRequest=e.DidDeleteFilesNotification=e.DidRenameFilesNotification=e.WillRenameFilesRequest=e.DidCreateFilesNotification=e.WillCreateFilesRequest=e.FileOperationPatternKind=void 0;var t=Ae(),r;(function(c){c.file="file",c.folder="folder"})(r||(e.FileOperationPatternKind=r={}));var n;(function(c){c.method="workspace/willCreateFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolRequestType(c.method)})(n||(e.WillCreateFilesRequest=n={}));var a;(function(c){c.method="workspace/didCreateFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolNotificationType(c.method)})(a||(e.DidCreateFilesNotification=a={}));var s;(function(c){c.method="workspace/willRenameFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolRequestType(c.method)})(s||(e.WillRenameFilesRequest=s={}));var o;(function(c){c.method="workspace/didRenameFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolNotificationType(c.method)})(o||(e.DidRenameFilesNotification=o={}));var l;(function(c){c.method="workspace/didDeleteFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolNotificationType(c.method)})(l||(e.DidDeleteFilesNotification=l={}));var u;(function(c){c.method="workspace/willDeleteFiles",c.messageDirection=t.MessageDirection.clientToServer,c.type=new t.ProtocolRequestType(c.method)})(u||(e.WillDeleteFilesRequest=u={}))}}),qI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.MonikerRequest=e.MonikerKind=e.UniquenessLevel=void 0;var t=Ae(),r;(function(s){s.document="document",s.project="project",s.group="group",s.scheme="scheme",s.global="global"})(r||(e.UniquenessLevel=r={}));var n;(function(s){s.$import="import",s.$export="export",s.local="local"})(n||(e.MonikerKind=n={}));var a;(function(s){s.method="textDocument/moniker",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(a||(e.MonikerRequest=a={}))}}),HI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.TypeHierarchySubtypesRequest=e.TypeHierarchySupertypesRequest=e.TypeHierarchyPrepareRequest=void 0;var t=Ae(),r;(function(s){s.method="textDocument/prepareTypeHierarchy",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(r||(e.TypeHierarchyPrepareRequest=r={}));var n;(function(s){s.method="typeHierarchy/supertypes",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(n||(e.TypeHierarchySupertypesRequest=n={}));var a;(function(s){s.method="typeHierarchy/subtypes",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(a||(e.TypeHierarchySubtypesRequest=a={}))}}),YI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.InlineValueRefreshRequest=e.InlineValueRequest=void 0;var t=Ae(),r;(function(a){a.method="textDocument/inlineValue",a.messageDirection=t.MessageDirection.clientToServer,a.type=new t.ProtocolRequestType(a.method)})(r||(e.InlineValueRequest=r={}));var n;(function(a){a.method="workspace/inlineValue/refresh",a.messageDirection=t.MessageDirection.serverToClient,a.type=new t.ProtocolRequestType0(a.method)})(n||(e.InlineValueRefreshRequest=n={}))}}),XI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.InlayHintRefreshRequest=e.InlayHintResolveRequest=e.InlayHintRequest=void 0;var t=Ae(),r;(function(s){s.method="textDocument/inlayHint",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(r||(e.InlayHintRequest=r={}));var n;(function(s){s.method="inlayHint/resolve",s.messageDirection=t.MessageDirection.clientToServer,s.type=new t.ProtocolRequestType(s.method)})(n||(e.InlayHintResolveRequest=n={}));var a;(function(s){s.method="workspace/inlayHint/refresh",s.messageDirection=t.MessageDirection.serverToClient,s.type=new t.ProtocolRequestType0(s.method)})(a||(e.InlayHintRefreshRequest=a={}))}}),JI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.DiagnosticRefreshRequest=e.WorkspaceDiagnosticRequest=e.DocumentDiagnosticRequest=e.DocumentDiagnosticReportKind=e.DiagnosticServerCancellationData=void 0;var t=ti(),r=bd(),n=Ae(),a;(function(c){function f(d){const m=d;return m&&r.boolean(m.retriggerRequest)}i(f,"is"),c.is=f})(a||(e.DiagnosticServerCancellationData=a={}));var s;(function(c){c.Full="full",c.Unchanged="unchanged"})(s||(e.DocumentDiagnosticReportKind=s={}));var o;(function(c){c.method="textDocument/diagnostic",c.messageDirection=n.MessageDirection.clientToServer,c.type=new n.ProtocolRequestType(c.method),c.partialResult=new t.ProgressType})(o||(e.DocumentDiagnosticRequest=o={}));var l;(function(c){c.method="workspace/diagnostic",c.messageDirection=n.MessageDirection.clientToServer,c.type=new n.ProtocolRequestType(c.method),c.partialResult=new t.ProgressType})(l||(e.WorkspaceDiagnosticRequest=l={}));var u;(function(c){c.method="workspace/diagnostic/refresh",c.messageDirection=n.MessageDirection.serverToClient,c.type=new n.ProtocolRequestType0(c.method)})(u||(e.DiagnosticRefreshRequest=u={}))}}),ZI=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.DidCloseNotebookDocumentNotification=e.DidSaveNotebookDocumentNotification=e.DidChangeNotebookDocumentNotification=e.NotebookCellArrayChange=e.DidOpenNotebookDocumentNotification=e.NotebookDocumentSyncRegistrationType=e.NotebookDocument=e.NotebookCell=e.ExecutionSummary=e.NotebookCellKind=void 0;var t=(xs(),_d(Dl)),r=bd(),n=Ae(),a;(function(v){v.Markup=1,v.Code=2;function _(S){return S===1||S===2}i(_,"is"),v.is=_})(a||(e.NotebookCellKind=a={}));var s;(function(v){function _(I,R){const P={executionOrder:I};return(R===!0||R===!1)&&(P.success=R),P}i(_,"create"),v.create=_;function S(I){const R=I;return r.objectLiteral(R)&&t.uinteger.is(R.executionOrder)&&(R.success===void 0||r.boolean(R.success))}i(S,"is"),v.is=S;function w(I,R){return I===R?!0:I==null||R===null||R===void 0?!1:I.executionOrder===R.executionOrder&&I.success===R.success}i(w,"equals"),v.equals=w})(s||(e.ExecutionSummary=s={}));var o;(function(v){function _(R,P){return{kind:R,document:P}}i(_,"create"),v.create=_;function S(R){const P=R;return r.objectLiteral(P)&&a.is(P.kind)&&t.DocumentUri.is(P.document)&&(P.metadata===void 0||r.objectLiteral(P.metadata))}i(S,"is"),v.is=S;function w(R,P){const z=new Set;return R.document!==P.document&&z.add("document"),R.kind!==P.kind&&z.add("kind"),R.executionSummary!==P.executionSummary&&z.add("executionSummary"),(R.metadata!==void 0||P.metadata!==void 0)&&!I(R.metadata,P.metadata)&&z.add("metadata"),(R.executionSummary!==void 0||P.executionSummary!==void 0)&&!s.equals(R.executionSummary,P.executionSummary)&&z.add("executionSummary"),z}i(w,"diff"),v.diff=w;function I(R,P){if(R===P)return!0;if(R==null||P===null||P===void 0||typeof R!=typeof P||typeof R!="object")return!1;const z=Array.isArray(R),X=Array.isArray(P);if(z!==X)return!1;if(z&&X){if(R.length!==P.length)return!1;for(let Z=0;Z0}i(ae,"hasId"),p.hasId=ae})(O||(e.StaticRegistrationOptions=O={}));var x;(function(p){function ae(Te){const q=Te;return q&&(q.documentSelector===null||C.is(q.documentSelector))}i(ae,"is"),p.is=ae})(x||(e.TextDocumentRegistrationOptions=x={}));var D;(function(p){function ae(q){const h=q;return n.objectLiteral(h)&&(h.workDoneProgress===void 0||n.boolean(h.workDoneProgress))}i(ae,"is"),p.is=ae;function Te(q){const h=q;return h&&n.boolean(h.workDoneProgress)}i(Te,"hasWorkDoneProgress"),p.hasWorkDoneProgress=Te})(D||(e.WorkDoneProgressOptions=D={}));var G;(function(p){p.method="initialize",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(G||(e.InitializeRequest=G={}));var W;(function(p){p.unknownProtocolVersion=1})(W||(e.InitializeErrorCodes=W={}));var Y;(function(p){p.method="initialized",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(Y||(e.InitializedNotification=Y={}));var V;(function(p){p.method="shutdown",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType0(p.method)})(V||(e.ShutdownRequest=V={}));var Pe;(function(p){p.method="exit",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType0(p.method)})(Pe||(e.ExitNotification=Pe={}));var oe;(function(p){p.method="workspace/didChangeConfiguration",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(oe||(e.DidChangeConfigurationNotification=oe={}));var Le;(function(p){p.Error=1,p.Warning=2,p.Info=3,p.Log=4,p.Debug=5})(Le||(e.MessageType=Le={}));var De;(function(p){p.method="window/showMessage",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolNotificationType(p.method)})(De||(e.ShowMessageNotification=De={}));var ke;(function(p){p.method="window/showMessageRequest",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolRequestType(p.method)})(ke||(e.ShowMessageRequest=ke={}));var Ze;(function(p){p.method="window/logMessage",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolNotificationType(p.method)})(Ze||(e.LogMessageNotification=Ze={}));var Je;(function(p){p.method="telemetry/event",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolNotificationType(p.method)})(Je||(e.TelemetryEventNotification=Je={}));var ne;(function(p){p.None=0,p.Full=1,p.Incremental=2})(ne||(e.TextDocumentSyncKind=ne={}));var Kt;(function(p){p.method="textDocument/didOpen",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(Kt||(e.DidOpenTextDocumentNotification=Kt={}));var Ee;(function(p){function ae(q){let h=q;return h!=null&&typeof h.text=="string"&&h.range!==void 0&&(h.rangeLength===void 0||typeof h.rangeLength=="number")}i(ae,"isIncremental"),p.isIncremental=ae;function Te(q){let h=q;return h!=null&&typeof h.text=="string"&&h.range===void 0&&h.rangeLength===void 0}i(Te,"isFull"),p.isFull=Te})(Ee||(e.TextDocumentContentChangeEvent=Ee={}));var kt;(function(p){p.method="textDocument/didChange",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(kt||(e.DidChangeTextDocumentNotification=kt={}));var ra;(function(p){p.method="textDocument/didClose",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(ra||(e.DidCloseTextDocumentNotification=ra={}));var fi;(function(p){p.method="textDocument/didSave",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(fi||(e.DidSaveTextDocumentNotification=fi={}));var di;(function(p){p.Manual=1,p.AfterDelay=2,p.FocusOut=3})(di||(e.TextDocumentSaveReason=di={}));var pi;(function(p){p.method="textDocument/willSave",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(pi||(e.WillSaveTextDocumentNotification=pi={}));var mi;(function(p){p.method="textDocument/willSaveWaitUntil",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(mi||(e.WillSaveTextDocumentWaitUntilRequest=mi={}));var Ot;(function(p){p.method="workspace/didChangeWatchedFiles",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolNotificationType(p.method)})(Ot||(e.DidChangeWatchedFilesNotification=Ot={}));var na;(function(p){p.Created=1,p.Changed=2,p.Deleted=3})(na||(e.FileChangeType=na={}));var hi;(function(p){function ae(Te){const q=Te;return n.objectLiteral(q)&&(r.URI.is(q.baseUri)||r.WorkspaceFolder.is(q.baseUri))&&n.string(q.pattern)}i(ae,"is"),p.is=ae})(hi||(e.RelativePattern=hi={}));var yi;(function(p){p.Create=1,p.Change=2,p.Delete=4})(yi||(e.WatchKind=yi={}));var gi;(function(p){p.method="textDocument/publishDiagnostics",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolNotificationType(p.method)})(gi||(e.PublishDiagnosticsNotification=gi={}));var vi;(function(p){p.Invoked=1,p.TriggerCharacter=2,p.TriggerForIncompleteCompletions=3})(vi||(e.CompletionTriggerKind=vi={}));var aa;(function(p){p.method="textDocument/completion",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(aa||(e.CompletionRequest=aa={}));var ia;(function(p){p.method="completionItem/resolve",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(ia||(e.CompletionResolveRequest=ia={}));var Wt;(function(p){p.method="textDocument/hover",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Wt||(e.HoverRequest=Wt={}));var sa;(function(p){p.Invoked=1,p.TriggerCharacter=2,p.ContentChange=3})(sa||(e.SignatureHelpTriggerKind=sa={}));var Ti;(function(p){p.method="textDocument/signatureHelp",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ti||(e.SignatureHelpRequest=Ti={}));var $i;(function(p){p.method="textDocument/definition",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})($i||(e.DefinitionRequest=$i={}));var oa;(function(p){p.method="textDocument/references",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(oa||(e.ReferencesRequest=oa={}));var la;(function(p){p.method="textDocument/documentHighlight",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(la||(e.DocumentHighlightRequest=la={}));var Ri;(function(p){p.method="textDocument/documentSymbol",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ri||(e.DocumentSymbolRequest=Ri={}));var no;(function(p){p.method="textDocument/codeAction",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(no||(e.CodeActionRequest=no={}));var Ai;(function(p){p.method="codeAction/resolve",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ai||(e.CodeActionResolveRequest=Ai={}));var Ei;(function(p){p.method="workspace/symbol",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ei||(e.WorkspaceSymbolRequest=Ei={}));var Ci;(function(p){p.method="workspaceSymbol/resolve",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ci||(e.WorkspaceSymbolResolveRequest=Ci={}));var _i;(function(p){p.method="textDocument/codeLens",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(_i||(e.CodeLensRequest=_i={}));var _t;(function(p){p.method="codeLens/resolve",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(_t||(e.CodeLensResolveRequest=_t={}));var bi;(function(p){p.method="workspace/codeLens/refresh",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolRequestType0(p.method)})(bi||(e.CodeLensRefreshRequest=bi={}));var Si;(function(p){p.method="textDocument/documentLink",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Si||(e.DocumentLinkRequest=Si={}));var Lr;(function(p){p.method="documentLink/resolve",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Lr||(e.DocumentLinkResolveRequest=Lr={}));var wi;(function(p){p.method="textDocument/formatting",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(wi||(e.DocumentFormattingRequest=wi={}));var Jr;(function(p){p.method="textDocument/rangeFormatting",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Jr||(e.DocumentRangeFormattingRequest=Jr={}));var Ii;(function(p){p.method="textDocument/rangesFormatting",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ii||(e.DocumentRangesFormattingRequest=Ii={}));var Vt;(function(p){p.method="textDocument/onTypeFormatting",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Vt||(e.DocumentOnTypeFormattingRequest=Vt={}));var cr;(function(p){p.Identifier=1})(cr||(e.PrepareSupportDefaultBehavior=cr={}));var Ni;(function(p){p.method="textDocument/rename",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Ni||(e.RenameRequest=Ni={}));var Pi;(function(p){p.method="textDocument/prepareRename",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(Pi||(e.PrepareRenameRequest=Pi={}));var fr;(function(p){p.method="workspace/executeCommand",p.messageDirection=t.MessageDirection.clientToServer,p.type=new t.ProtocolRequestType(p.method)})(fr||(e.ExecuteCommandRequest=fr={}));var ua;(function(p){p.method="workspace/applyEdit",p.messageDirection=t.MessageDirection.serverToClient,p.type=new t.ProtocolRequestType("workspace/applyEdit")})(ua||(e.ApplyWorkspaceEditRequest=ua={}))}}),tN=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/connection.js"(e){Object.defineProperty(e,"__esModule",{value:!0}),e.createProtocolConnection=void 0;var t=ti();function r(n,a,s,o){return t.ConnectionStrategy.is(o)&&(o={connectionStrategy:o}),(0,t.createMessageConnection)(n,a,s,o)}i(r,"createProtocolConnection"),e.createProtocolConnection=r}}),rN=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/common/api.js"(e){var t=e&&e.__createBinding||(Object.create?(function(s,o,l,u){u===void 0&&(u=l);var c=Object.getOwnPropertyDescriptor(o,l);(!c||("get"in c?!o.__esModule:c.writable||c.configurable))&&(c={enumerable:!0,get:i(function(){return o[l]},"get")}),Object.defineProperty(s,u,c)}):(function(s,o,l,u){u===void 0&&(u=l),s[u]=o[l]})),r=e&&e.__exportStar||function(s,o){for(var l in s)l!=="default"&&!Object.prototype.hasOwnProperty.call(o,l)&&t(o,s,l)};Object.defineProperty(e,"__esModule",{value:!0}),e.LSPErrorCodes=e.createProtocolConnection=void 0,r(ti(),e),r((xs(),_d(Dl)),e),r(Ae(),e),r(eN(),e);var n=tN();Object.defineProperty(e,"createProtocolConnection",{enumerable:!0,get:i(function(){return n.createProtocolConnection},"get")});var a;(function(s){s.lspReservedErrorRangeStart=-32899,s.RequestFailed=-32803,s.ServerCancelled=-32802,s.ContentModified=-32801,s.RequestCancelled=-32800,s.lspReservedErrorRangeEnd=-32800})(a||(e.LSPErrorCodes=a={}))}}),nN=H({"../../node_modules/.pnpm/vscode-languageserver-protocol@3.17.5/node_modules/vscode-languageserver-protocol/lib/browser/main.js"(e){var t=e&&e.__createBinding||(Object.create?(function(s,o,l,u){u===void 0&&(u=l);var c=Object.getOwnPropertyDescriptor(o,l);(!c||("get"in c?!o.__esModule:c.writable||c.configurable))&&(c={enumerable:!0,get:i(function(){return o[l]},"get")}),Object.defineProperty(s,u,c)}):(function(s,o,l,u){u===void 0&&(u=l),s[u]=o[l]})),r=e&&e.__exportStar||function(s,o){for(var l in s)l!=="default"&&!Object.prototype.hasOwnProperty.call(o,l)&&t(o,s,l)};Object.defineProperty(e,"__esModule",{value:!0}),e.createProtocolConnection=void 0;var n=uh();r(uh(),e),r(rN(),e);function a(s,o,l,u){return(0,n.createMessageConnection)(s,o,l,u)}i(a,"createProtocolConnection"),e.createProtocolConnection=a}}),Hg={};Vr(Hg,{AbstractAstReflection:()=>Id,AbstractCstNode:()=>Pm,AbstractLangiumParser:()=>Om,AbstractParserErrorMessageProvider:()=>MS,AbstractThreadedAsyncParser:()=>SF,AstUtils:()=>Nd,BiMap:()=>Nl,Cancellation:()=>pe,CompositeCstNodeImpl:()=>ku,ContextCache:()=>Fu,CstNodeBuilder:()=>OS,CstUtils:()=>Sd,DEFAULT_TOKENIZE_OPTIONS:()=>Jm,DONE_RESULT:()=>tt,DatatypeSymbol:()=>bl,DefaultAstNodeDescriptionProvider:()=>pw,DefaultAstNodeLocator:()=>hw,DefaultAsyncParser:()=>Ow,DefaultCommentProvider:()=>kw,DefaultConfigurationProvider:()=>yw,DefaultDocumentBuilder:()=>gw,DefaultDocumentValidator:()=>dw,DefaultHydrator:()=>Dw,DefaultIndexManager:()=>vw,DefaultJsonSerializer:()=>lw,DefaultLangiumDocumentFactory:()=>QS,DefaultLangiumDocuments:()=>ew,DefaultLangiumProfiler:()=>kF,DefaultLexer:()=>Zm,DefaultLexerErrorMessageProvider:()=>$w,DefaultLinker:()=>tw,DefaultNameProvider:()=>rw,DefaultReferenceDescriptionProvider:()=>mw,DefaultReferences:()=>nw,DefaultScopeComputation:()=>aw,DefaultScopeProvider:()=>ow,DefaultServiceRegistry:()=>uw,DefaultTokenBuilder:()=>Du,DefaultValueConverter:()=>zm,DefaultWorkspaceLock:()=>Lw,DefaultWorkspaceManager:()=>Tw,Deferred:()=>wr,Disposable:()=>Nn,DisposableCache:()=>Gu,DocumentCache:()=>sw,DocumentState:()=>J,DocumentValidator:()=>bt,EMPTY_SCOPE:()=>EF,EMPTY_STREAM:()=>Ua,EmptyFileSystem:()=>Xe,EmptyFileSystemProvider:()=>Gw,ErrorWithLocation:()=>Wl,GrammarAST:()=>Jg,GrammarUtils:()=>sp,IndentationAwareLexer:()=>IF,IndentationAwareTokenBuilder:()=>Mw,JSDocDocumentationProvider:()=>Pw,LangiumCompletionParser:()=>GS,LangiumParser:()=>xS,LangiumParserErrorMessageProvider:()=>Lm,LeafCstNodeImpl:()=>_l,LexingMode:()=>wn,MapScope:()=>AF,Module:()=>nd,MultiMap:()=>Ir,MultiMapScope:()=>iw,OperationCancelled:()=>tr,ParserWorker:()=>wF,ProfilingTask:()=>zw,Reduction:()=>Ts,RefResolving:()=>un,RegExpUtils:()=>lp,RootCstNodeImpl:()=>km,SimpleCache:()=>Vm,StreamImpl:()=>er,StreamScope:()=>Qf,TextDocument:()=>wl,TreeStreamImpl:()=>Ka,URI:()=>Tt,UriTrie:()=>Km,UriUtils:()=>nt,VALIDATE_EACH_NODE:()=>fw,ValidationCategory:()=>Pl,ValidationRegistry:()=>cw,ValueConverter:()=>Zt,WorkspaceCache:()=>qm,assertCondition:()=>op,assertUnreachable:()=>qr,createCompletionParser:()=>Mm,createDefaultCoreModule:()=>je,createDefaultSharedCoreModule:()=>Be,createGrammarConfig:()=>bp,createLangiumParser:()=>Gm,createParser:()=>Ou,delayNextTick:()=>xu,diagnosticData:()=>Sn,eagerLoad:()=>ih,getDiagnosticRange:()=>Ym,indentationBuilderDefaultOptions:()=>id,inject:()=>ee,interruptAndCheck:()=>ze,isAstNode:()=>Oe,isAstNodeDescription:()=>wd,isAstNodeWithComment:()=>Hm,isCompositeCstNode:()=>$r,isIMultiModeLexerDefinition:()=>Bu,isJSDoc:()=>eh,isLeafCstNode:()=>xn,isLinkingError:()=>pn,isMultiReference:()=>rr,isNamed:()=>Wm,isOperationCancelled:()=>ta,isReference:()=>rt,isRootCstNode:()=>Ml,isTokenTypeArray:()=>ju,isTokenTypeDictionary:()=>kl,loadGrammarFromJson:()=>Ue,parseJSDoc:()=>Qm,prepareLangiumParser:()=>Fm,setInterruptionPeriod:()=>jm,startCancelableOperation:()=>Mu,stream:()=>ue,toDiagnosticData:()=>Xm,toDiagnosticSeverity:()=>gs});var Sd={};Vr(Sd,{DefaultNameRegexp:()=>tp,RangeComparison:()=>Qt,compareRange:()=>Qd,findCommentNode:()=>rp,findDeclarationNodeAtOffset:()=>yv,findLeafNodeAtOffset:()=>Kl,findLeafNodeBeforeOffset:()=>np,flattenCst:()=>hv,getDatatypeNode:()=>mv,getInteriorNodes:()=>Tv,getNextNode:()=>gv,getPreviousNode:()=>ip,getStartlineNode:()=>vv,inRange:()=>ep,isChildNode:()=>Zd,isCommentNode:()=>ul,streamCst:()=>Ha,toDocumentSegment:()=>Ya,tokenToRange:()=>$s});function Oe(e){return typeof e=="object"&&e!==null&&typeof e.$type=="string"}i(Oe,"isAstNode");function rt(e){return typeof e=="object"&&e!==null&&typeof e.$refText=="string"&&"ref"in e}i(rt,"isReference");function rr(e){return typeof e=="object"&&e!==null&&typeof e.$refText=="string"&&"items"in e}i(rr,"isMultiReference");function wd(e){return typeof e=="object"&&e!==null&&typeof e.name=="string"&&typeof e.type=="string"&&typeof e.path=="string"}i(wd,"isAstNodeDescription");function pn(e){return typeof e=="object"&&e!==null&&typeof e.info=="object"&&typeof e.message=="string"}i(pn,"isLinkingError");var Id=class{static{i(this,"AbstractAstReflection")}constructor(){this.subtypes={},this.allSubtypes={}}getAllTypes(){return Object.keys(this.types)}getReferenceType(e){const t=this.types[e.container.$type];if(!t)throw new Error(`Type ${e.container.$type||"undefined"} not found.`);const r=t.properties[e.property]?.referenceType;if(!r)throw new Error(`Property ${e.property||"undefined"} of type ${e.container.$type} is not a reference.`);return r}getTypeMetaData(e){const t=this.types[e];return t||{name:e,properties:{},superTypes:[]}}isInstance(e,t){return Oe(e)&&this.isSubtype(e.$type,t)}isSubtype(e,t){if(e===t)return!0;let r=this.subtypes[e];r||(r=this.subtypes[e]={});const n=r[t];if(n!==void 0)return n;{const a=this.types[e],s=a?a.superTypes.some(o=>this.isSubtype(o,t)):!1;return r[t]=s,s}}getAllSubTypes(e){const t=this.allSubtypes[e];if(t)return t;{const r=this.getAllTypes(),n=[];for(const a of r)this.isSubtype(a,e)&&n.push(a);return this.allSubtypes[e]=n,n}}};function $r(e){return typeof e=="object"&&e!==null&&Array.isArray(e.content)}i($r,"isCompositeCstNode");function xn(e){return typeof e=="object"&&e!==null&&typeof e.tokenType=="object"}i(xn,"isLeafCstNode");function Ml(e){return $r(e)&&typeof e.fullText=="string"}i(Ml,"isRootCstNode");var er=class hr{static{i(this,"StreamImpl")}constructor(t,r){this.startFn=t,this.nextFn=r}iterator(){const t={state:this.startFn(),next:i(()=>this.nextFn(t.state),"next"),[Symbol.iterator]:()=>t};return t}[Symbol.iterator](){return this.iterator()}isEmpty(){return!!this.iterator().next().done}count(){const t=this.iterator();let r=0,n=t.next();for(;!n.done;)r++,n=t.next();return r}toArray(){const t=[],r=this.iterator();let n;do n=r.next(),n.value!==void 0&&t.push(n.value);while(!n.done);return t}toSet(){return new Set(this)}toMap(t,r){const n=this.map(a=>[t?t(a):a,r?r(a):a]);return new Map(n)}toString(){return this.join()}concat(t){return new hr(()=>({first:this.startFn(),firstDone:!1,iterator:t[Symbol.iterator]()}),r=>{let n;if(!r.firstDone){do if(n=this.nextFn(r.first),!n.done)return n;while(!n.done);r.firstDone=!0}do if(n=r.iterator.next(),!n.done)return n;while(!n.done);return tt})}join(t=","){const r=this.iterator();let n="",a,s=!1;do a=r.next(),a.done||(s&&(n+=t),n+=Yg(a.value)),s=!0;while(!a.done);return n}indexOf(t,r=0){const n=this.iterator();let a=0,s=n.next();for(;!s.done;){if(a>=r&&s.value===t)return a;s=n.next(),a++}return-1}every(t){const r=this.iterator();let n=r.next();for(;!n.done;){if(!t(n.value))return!1;n=r.next()}return!0}some(t){const r=this.iterator();let n=r.next();for(;!n.done;){if(t(n.value))return!0;n=r.next()}return!1}forEach(t){const r=this.iterator();let n=0,a=r.next();for(;!a.done;)t(a.value,n),a=r.next(),n++}map(t){return new hr(this.startFn,r=>{const{done:n,value:a}=this.nextFn(r);return n?tt:{done:!1,value:t(a)}})}filter(t){return new hr(this.startFn,r=>{let n;do if(n=this.nextFn(r),!n.done&&t(n.value))return n;while(!n.done);return tt})}nonNullable(){return this.filter(t=>t!=null)}reduce(t,r){const n=this.iterator();let a=r,s=n.next();for(;!s.done;)a===void 0?a=s.value:a=t(a,s.value),s=n.next();return a}reduceRight(t,r){return this.recursiveReduce(this.iterator(),t,r)}recursiveReduce(t,r,n){const a=t.next();if(a.done)return n;const s=this.recursiveReduce(t,r,n);return s===void 0?a.value:r(s,a.value)}find(t){const r=this.iterator();let n=r.next();for(;!n.done;){if(t(n.value))return n.value;n=r.next()}}findIndex(t){const r=this.iterator();let n=0,a=r.next();for(;!a.done;){if(t(a.value))return n;a=r.next(),n++}return-1}includes(t){const r=this.iterator();let n=r.next();for(;!n.done;){if(n.value===t)return!0;n=r.next()}return!1}flatMap(t){return new hr(()=>({this:this.startFn()}),r=>{do{if(r.iterator){const s=r.iterator.next();if(s.done)r.iterator=void 0;else return s}const{done:n,value:a}=this.nextFn(r.this);if(!n){const s=t(a);if(vs(s))r.iterator=s[Symbol.iterator]();else return{done:!1,value:s}}}while(r.iterator);return tt})}flat(t){if(t===void 0&&(t=1),t<=0)return this;const r=t>1?this.flat(t-1):this;return new hr(()=>({this:r.startFn()}),n=>{do{if(n.iterator){const o=n.iterator.next();if(o.done)n.iterator=void 0;else return o}const{done:a,value:s}=r.nextFn(n.this);if(!a)if(vs(s))n.iterator=s[Symbol.iterator]();else return{done:!1,value:s}}while(n.iterator);return tt})}head(){const r=this.iterator().next();if(!r.done)return r.value}tail(t=1){return new hr(()=>{const r=this.startFn();for(let n=0;n({size:0,state:this.startFn()}),r=>(r.size++,r.size>t?tt:this.nextFn(r.state)))}distinct(t){return new hr(()=>({set:new Set,internalState:this.startFn()}),r=>{let n;do if(n=this.nextFn(r.internalState),!n.done){const a=t?t(n.value):n.value;if(!r.set.has(a))return r.set.add(a),n}while(!n.done);return tt})}exclude(t,r){const n=new Set;for(const a of t){const s=r?r(a):a;n.add(s)}return this.filter(a=>{const s=r?r(a):a;return!n.has(s)})}};function Yg(e){return typeof e=="string"?e:typeof e>"u"?"undefined":typeof e.toString=="function"?e.toString():Object.prototype.toString.call(e)}i(Yg,"toString");function vs(e){return!!e&&typeof e[Symbol.iterator]=="function"}i(vs,"isIterable");var Ua=new er(()=>{},()=>tt),tt=Object.freeze({done:!0,value:void 0});function ue(...e){if(e.length===1){const t=e[0];if(t instanceof er)return t;if(vs(t))return new er(()=>t[Symbol.iterator](),r=>r.next());if(typeof t.length=="number")return new er(()=>({index:0}),r=>r.index1?new er(()=>({collIndex:0,arrIndex:0}),t=>{do{if(t.iterator){const r=t.iterator.next();if(!r.done)return r;t.iterator=void 0}if(t.array){if(t.arrIndex({iterators:r?.includeRoot?[[e][Symbol.iterator]()]:[t(e)[Symbol.iterator]()],pruned:!1}),n=>{for(n.pruned&&(n.iterators.pop(),n.pruned=!1);n.iterators.length>0;){const s=n.iterators[n.iterators.length-1].next();if(s.done)n.iterators.pop();else return n.iterators.push(t(s.value)[Symbol.iterator]()),s}return tt})}iterator(){const e={state:this.startFn(),next:i(()=>this.nextFn(e.state),"next"),prune:i(()=>{e.state.pruned=!0},"prune"),[Symbol.iterator]:()=>e};return e}},Ts;(function(e){function t(s){return s.reduce((o,l)=>o+l,0)}i(t,"sum"),e.sum=t;function r(s){return s.reduce((o,l)=>o*l,0)}i(r,"product"),e.product=r;function n(s){return s.reduce((o,l)=>Math.min(o,l))}i(n,"min"),e.min=n;function a(s){return s.reduce((o,l)=>Math.max(o,l))}i(a,"max"),e.max=a})(Ts||(Ts={}));var Nd={};Vr(Nd,{assignMandatoryProperties:()=>Pd,copyAstNode:()=>Yo,findRootNode:()=>Fa,getContainerOfType:()=>Mn,getDocument:()=>Mt,getReferenceNodes:()=>qo,hasContainerOfType:()=>Xg,linkContentToContainer:()=>Wa,streamAllContents:()=>Nr,streamAst:()=>Gt,streamContents:()=>Gs,streamReferences:()=>Va});function Wa(e,t={}){for(const[r,n]of Object.entries(e))r.startsWith("$")||(Array.isArray(n)?n.forEach((a,s)=>{Oe(a)&&(a.$container=e,a.$containerProperty=r,a.$containerIndex=s,t.deep&&Wa(a,t))}):Oe(n)&&(n.$container=e,n.$containerProperty=r,t.deep&&Wa(n,t)))}i(Wa,"linkContentToContainer");function Mn(e,t){let r=e;for(;r;){if(t(r))return r;r=r.$container}}i(Mn,"getContainerOfType");function Xg(e,t){let r=e;for(;r;){if(t(r))return!0;r=r.$container}return!1}i(Xg,"hasContainerOfType");function Mt(e){const r=Fa(e).$document;if(!r)throw new Error("AST node has no document.");return r}i(Mt,"getDocument");function Fa(e){for(;e.$container;)e=e.$container;return e}i(Fa,"findRootNode");function qo(e){return rt(e)?e.ref?[e.ref]:[]:rr(e)?e.items.map(t=>t.ref):[]}i(qo,"getReferenceNodes");function Gs(e,t){if(!e)throw new Error("Node must be an AstNode.");const r=t?.range;return new er(()=>({keys:Object.keys(e),keyIndex:0,arrayIndex:0}),n=>{for(;n.keyIndexGs(r,t))}i(Nr,"streamAllContents");function Gt(e,t){if(e){if(t?.range&&!Ho(e,t.range))return new Ka(e,()=>[])}else throw new Error("Root node must be an AstNode.");return new Ka(e,r=>Gs(r,t),{includeRoot:!0})}i(Gt,"streamAst");function Ho(e,t){if(!t)return!0;const r=e.$cstNode?.range;return r?ep(r,t):!1}i(Ho,"isAstNodeInRange");function Va(e){return new er(()=>({keys:Object.keys(e),keyIndex:0,arrayIndex:0}),t=>{for(;t.keyIndexdt,AbstractParserRule:()=>ns,AbstractRule:()=>Pa,AbstractType:()=>vt,Action:()=>xr,Alternatives:()=>as,ArrayLiteral:()=>Xo,ArrayType:()=>Jo,Assignment:()=>Mr,BooleanLiteral:()=>Zo,CharacterRange:()=>Gr,Condition:()=>Fr,Conjunction:()=>is,CrossReference:()=>zr,Disjunction:()=>ss,EndOfFile:()=>Qo,Grammar:()=>gr,GrammarImport:()=>el,Group:()=>mn,InferredType:()=>tl,InfixRule:()=>Jt,InfixRuleOperatorList:()=>os,InfixRuleOperators:()=>rl,Interface:()=>ka,Keyword:()=>Oa,LangiumGrammarAstReflection:()=>Jd,LangiumGrammarTerminals:()=>aN,NamedArgument:()=>La,NegatedToken:()=>hn,Negation:()=>nl,NumberLiteral:()=>al,Parameter:()=>Da,ParameterReference:()=>il,ParserRule:()=>Lt,ReferenceType:()=>ls,RegexToken:()=>yn,ReturnType:()=>sl,RuleCall:()=>gn,SimpleType:()=>xa,StringLiteral:()=>ol,TerminalAlternatives:()=>vn,TerminalElement:()=>pt,TerminalGroup:()=>Tn,TerminalRule:()=>vr,TerminalRuleCall:()=>$n,Type:()=>us,TypeAttribute:()=>Rn,TypeDefinition:()=>An,UnionType:()=>ll,UnorderedGroup:()=>cs,UntilToken:()=>En,ValueLiteral:()=>Cn,Wildcard:()=>Ma,isAbstractElement:()=>Gl,isAbstractParserRule:()=>Gn,isAbstractRule:()=>Zg,isAbstractType:()=>Qg,isAction:()=>jr,isAlternatives:()=>Fl,isArrayLiteral:()=>ev,isArrayType:()=>Od,isAssignment:()=>Rr,isBooleanLiteral:()=>Ld,isCharacterRange:()=>Dd,isCondition:()=>tv,isConjunction:()=>xd,isCrossReference:()=>Fn,isDisjunction:()=>Md,isEndOfFile:()=>Gd,isGrammar:()=>rv,isGrammarImport:()=>nv,isGroup:()=>zn,isInferredType:()=>Fs,isInfixRule:()=>qa,isInfixRuleOperatorList:()=>av,isInfixRuleOperators:()=>iv,isInterface:()=>Fd,isKeyword:()=>Ar,isNamedArgument:()=>sv,isNegatedToken:()=>zd,isNegation:()=>jd,isNumberLiteral:()=>ov,isParameter:()=>lv,isParameterReference:()=>Bd,isParserRule:()=>it,isReferenceType:()=>Ud,isRegexToken:()=>Kd,isReturnType:()=>Wd,isRuleCall:()=>Er,isSimpleType:()=>zl,isStringLiteral:()=>uv,isTerminalAlternatives:()=>Vd,isTerminalElement:()=>cv,isTerminalGroup:()=>qd,isTerminalRule:()=>Nt,isTerminalRuleCall:()=>jl,isType:()=>Bl,isTypeAttribute:()=>fv,isTypeDefinition:()=>dv,isUnionType:()=>Hd,isUnorderedGroup:()=>Ul,isUntilToken:()=>Yd,isValueLiteral:()=>pv,isWildcard:()=>Xd,reflection:()=>j});var aN={ID:/\^?[_a-zA-Z][\w_]*/,STRING:/"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,NUMBER:/NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)/,RegexLiteral:/\/(?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\/[a-z]*/,WS:/\s+/,ML_COMMENT:/\/\*[\s\S]*?\*\//,SL_COMMENT:/\/\/[^\n\r]*/},dt={$type:"AbstractElement",cardinality:"cardinality"};function Gl(e){return j.isInstance(e,dt.$type)}i(Gl,"isAbstractElement");var ns={$type:"AbstractParserRule"};function Gn(e){return j.isInstance(e,ns.$type)}i(Gn,"isAbstractParserRule");var Pa={$type:"AbstractRule"};function Zg(e){return j.isInstance(e,Pa.$type)}i(Zg,"isAbstractRule");var vt={$type:"AbstractType"};function Qg(e){return j.isInstance(e,vt.$type)}i(Qg,"isAbstractType");var xr={$type:"Action",cardinality:"cardinality",feature:"feature",inferredType:"inferredType",operator:"operator",type:"type"};function jr(e){return j.isInstance(e,xr.$type)}i(jr,"isAction");var as={$type:"Alternatives",cardinality:"cardinality",elements:"elements"};function Fl(e){return j.isInstance(e,as.$type)}i(Fl,"isAlternatives");var Xo={$type:"ArrayLiteral",elements:"elements"};function ev(e){return j.isInstance(e,Xo.$type)}i(ev,"isArrayLiteral");var Jo={$type:"ArrayType",elementType:"elementType"};function Od(e){return j.isInstance(e,Jo.$type)}i(Od,"isArrayType");var Mr={$type:"Assignment",cardinality:"cardinality",feature:"feature",operator:"operator",predicate:"predicate",terminal:"terminal"};function Rr(e){return j.isInstance(e,Mr.$type)}i(Rr,"isAssignment");var Zo={$type:"BooleanLiteral",true:"true"};function Ld(e){return j.isInstance(e,Zo.$type)}i(Ld,"isBooleanLiteral");var Gr={$type:"CharacterRange",cardinality:"cardinality",left:"left",lookahead:"lookahead",parenthesized:"parenthesized",right:"right"};function Dd(e){return j.isInstance(e,Gr.$type)}i(Dd,"isCharacterRange");var Fr={$type:"Condition"};function tv(e){return j.isInstance(e,Fr.$type)}i(tv,"isCondition");var is={$type:"Conjunction",left:"left",right:"right"};function xd(e){return j.isInstance(e,is.$type)}i(xd,"isConjunction");var zr={$type:"CrossReference",cardinality:"cardinality",deprecatedSyntax:"deprecatedSyntax",isMulti:"isMulti",terminal:"terminal",type:"type"};function Fn(e){return j.isInstance(e,zr.$type)}i(Fn,"isCrossReference");var ss={$type:"Disjunction",left:"left",right:"right"};function Md(e){return j.isInstance(e,ss.$type)}i(Md,"isDisjunction");var Qo={$type:"EndOfFile",cardinality:"cardinality"};function Gd(e){return j.isInstance(e,Qo.$type)}i(Gd,"isEndOfFile");var gr={$type:"Grammar",imports:"imports",interfaces:"interfaces",isDeclared:"isDeclared",name:"name",rules:"rules",types:"types"};function rv(e){return j.isInstance(e,gr.$type)}i(rv,"isGrammar");var el={$type:"GrammarImport",path:"path"};function nv(e){return j.isInstance(e,el.$type)}i(nv,"isGrammarImport");var mn={$type:"Group",cardinality:"cardinality",elements:"elements",guardCondition:"guardCondition",predicate:"predicate"};function zn(e){return j.isInstance(e,mn.$type)}i(zn,"isGroup");var tl={$type:"InferredType",name:"name"};function Fs(e){return j.isInstance(e,tl.$type)}i(Fs,"isInferredType");var Jt={$type:"InfixRule",call:"call",dataType:"dataType",inferredType:"inferredType",name:"name",operators:"operators",parameters:"parameters",returnType:"returnType"};function qa(e){return j.isInstance(e,Jt.$type)}i(qa,"isInfixRule");var os={$type:"InfixRuleOperatorList",associativity:"associativity",operators:"operators"};function av(e){return j.isInstance(e,os.$type)}i(av,"isInfixRuleOperatorList");var rl={$type:"InfixRuleOperators",precedences:"precedences"};function iv(e){return j.isInstance(e,rl.$type)}i(iv,"isInfixRuleOperators");var ka={$type:"Interface",attributes:"attributes",name:"name",superTypes:"superTypes"};function Fd(e){return j.isInstance(e,ka.$type)}i(Fd,"isInterface");var Oa={$type:"Keyword",cardinality:"cardinality",predicate:"predicate",value:"value"};function Ar(e){return j.isInstance(e,Oa.$type)}i(Ar,"isKeyword");var La={$type:"NamedArgument",calledByName:"calledByName",parameter:"parameter",value:"value"};function sv(e){return j.isInstance(e,La.$type)}i(sv,"isNamedArgument");var hn={$type:"NegatedToken",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized",terminal:"terminal"};function zd(e){return j.isInstance(e,hn.$type)}i(zd,"isNegatedToken");var nl={$type:"Negation",value:"value"};function jd(e){return j.isInstance(e,nl.$type)}i(jd,"isNegation");var al={$type:"NumberLiteral",value:"value"};function ov(e){return j.isInstance(e,al.$type)}i(ov,"isNumberLiteral");var Da={$type:"Parameter",name:"name"};function lv(e){return j.isInstance(e,Da.$type)}i(lv,"isParameter");var il={$type:"ParameterReference",parameter:"parameter"};function Bd(e){return j.isInstance(e,il.$type)}i(Bd,"isParameterReference");var Lt={$type:"ParserRule",dataType:"dataType",definition:"definition",entry:"entry",fragment:"fragment",inferredType:"inferredType",name:"name",parameters:"parameters",returnType:"returnType"};function it(e){return j.isInstance(e,Lt.$type)}i(it,"isParserRule");var ls={$type:"ReferenceType",isMulti:"isMulti",referenceType:"referenceType"};function Ud(e){return j.isInstance(e,ls.$type)}i(Ud,"isReferenceType");var yn={$type:"RegexToken",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized",regex:"regex"};function Kd(e){return j.isInstance(e,yn.$type)}i(Kd,"isRegexToken");var sl={$type:"ReturnType",name:"name"};function Wd(e){return j.isInstance(e,sl.$type)}i(Wd,"isReturnType");var gn={$type:"RuleCall",arguments:"arguments",cardinality:"cardinality",predicate:"predicate",rule:"rule"};function Er(e){return j.isInstance(e,gn.$type)}i(Er,"isRuleCall");var xa={$type:"SimpleType",primitiveType:"primitiveType",stringType:"stringType",typeRef:"typeRef"};function zl(e){return j.isInstance(e,xa.$type)}i(zl,"isSimpleType");var ol={$type:"StringLiteral",value:"value"};function uv(e){return j.isInstance(e,ol.$type)}i(uv,"isStringLiteral");var vn={$type:"TerminalAlternatives",cardinality:"cardinality",elements:"elements",lookahead:"lookahead",parenthesized:"parenthesized"};function Vd(e){return j.isInstance(e,vn.$type)}i(Vd,"isTerminalAlternatives");var pt={$type:"TerminalElement",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized"};function cv(e){return j.isInstance(e,pt.$type)}i(cv,"isTerminalElement");var Tn={$type:"TerminalGroup",cardinality:"cardinality",elements:"elements",lookahead:"lookahead",parenthesized:"parenthesized"};function qd(e){return j.isInstance(e,Tn.$type)}i(qd,"isTerminalGroup");var vr={$type:"TerminalRule",definition:"definition",fragment:"fragment",hidden:"hidden",name:"name",type:"type"};function Nt(e){return j.isInstance(e,vr.$type)}i(Nt,"isTerminalRule");var $n={$type:"TerminalRuleCall",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized",rule:"rule"};function jl(e){return j.isInstance(e,$n.$type)}i(jl,"isTerminalRuleCall");var us={$type:"Type",name:"name",type:"type"};function Bl(e){return j.isInstance(e,us.$type)}i(Bl,"isType");var Rn={$type:"TypeAttribute",defaultValue:"defaultValue",isOptional:"isOptional",name:"name",type:"type"};function fv(e){return j.isInstance(e,Rn.$type)}i(fv,"isTypeAttribute");var An={$type:"TypeDefinition"};function dv(e){return j.isInstance(e,An.$type)}i(dv,"isTypeDefinition");var ll={$type:"UnionType",types:"types"};function Hd(e){return j.isInstance(e,ll.$type)}i(Hd,"isUnionType");var cs={$type:"UnorderedGroup",cardinality:"cardinality",elements:"elements"};function Ul(e){return j.isInstance(e,cs.$type)}i(Ul,"isUnorderedGroup");var En={$type:"UntilToken",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized",terminal:"terminal"};function Yd(e){return j.isInstance(e,En.$type)}i(Yd,"isUntilToken");var Cn={$type:"ValueLiteral"};function pv(e){return j.isInstance(e,Cn.$type)}i(pv,"isValueLiteral");var Ma={$type:"Wildcard",cardinality:"cardinality",lookahead:"lookahead",parenthesized:"parenthesized"};function Xd(e){return j.isInstance(e,Ma.$type)}i(Xd,"isWildcard");var Jd=class extends Id{static{i(this,"LangiumGrammarAstReflection")}constructor(){super(...arguments),this.types={AbstractElement:{name:dt.$type,properties:{cardinality:{name:dt.cardinality}},superTypes:[]},AbstractParserRule:{name:ns.$type,properties:{},superTypes:[Pa.$type,vt.$type]},AbstractRule:{name:Pa.$type,properties:{},superTypes:[]},AbstractType:{name:vt.$type,properties:{},superTypes:[]},Action:{name:xr.$type,properties:{cardinality:{name:xr.cardinality},feature:{name:xr.feature},inferredType:{name:xr.inferredType},operator:{name:xr.operator},type:{name:xr.type,referenceType:vt.$type}},superTypes:[dt.$type]},Alternatives:{name:as.$type,properties:{cardinality:{name:as.cardinality},elements:{name:as.elements,defaultValue:[]}},superTypes:[dt.$type]},ArrayLiteral:{name:Xo.$type,properties:{elements:{name:Xo.elements,defaultValue:[]}},superTypes:[Cn.$type]},ArrayType:{name:Jo.$type,properties:{elementType:{name:Jo.elementType}},superTypes:[An.$type]},Assignment:{name:Mr.$type,properties:{cardinality:{name:Mr.cardinality},feature:{name:Mr.feature},operator:{name:Mr.operator},predicate:{name:Mr.predicate},terminal:{name:Mr.terminal}},superTypes:[dt.$type]},BooleanLiteral:{name:Zo.$type,properties:{true:{name:Zo.true,defaultValue:!1}},superTypes:[Fr.$type,Cn.$type]},CharacterRange:{name:Gr.$type,properties:{cardinality:{name:Gr.cardinality},left:{name:Gr.left},lookahead:{name:Gr.lookahead},parenthesized:{name:Gr.parenthesized,defaultValue:!1},right:{name:Gr.right}},superTypes:[pt.$type]},Condition:{name:Fr.$type,properties:{},superTypes:[]},Conjunction:{name:is.$type,properties:{left:{name:is.left},right:{name:is.right}},superTypes:[Fr.$type]},CrossReference:{name:zr.$type,properties:{cardinality:{name:zr.cardinality},deprecatedSyntax:{name:zr.deprecatedSyntax,defaultValue:!1},isMulti:{name:zr.isMulti,defaultValue:!1},terminal:{name:zr.terminal},type:{name:zr.type,referenceType:vt.$type}},superTypes:[dt.$type]},Disjunction:{name:ss.$type,properties:{left:{name:ss.left},right:{name:ss.right}},superTypes:[Fr.$type]},EndOfFile:{name:Qo.$type,properties:{cardinality:{name:Qo.cardinality}},superTypes:[dt.$type]},Grammar:{name:gr.$type,properties:{imports:{name:gr.imports,defaultValue:[]},interfaces:{name:gr.interfaces,defaultValue:[]},isDeclared:{name:gr.isDeclared,defaultValue:!1},name:{name:gr.name},rules:{name:gr.rules,defaultValue:[]},types:{name:gr.types,defaultValue:[]}},superTypes:[]},GrammarImport:{name:el.$type,properties:{path:{name:el.path}},superTypes:[]},Group:{name:mn.$type,properties:{cardinality:{name:mn.cardinality},elements:{name:mn.elements,defaultValue:[]},guardCondition:{name:mn.guardCondition},predicate:{name:mn.predicate}},superTypes:[dt.$type]},InferredType:{name:tl.$type,properties:{name:{name:tl.name}},superTypes:[vt.$type]},InfixRule:{name:Jt.$type,properties:{call:{name:Jt.call},dataType:{name:Jt.dataType},inferredType:{name:Jt.inferredType},name:{name:Jt.name},operators:{name:Jt.operators},parameters:{name:Jt.parameters,defaultValue:[]},returnType:{name:Jt.returnType,referenceType:vt.$type}},superTypes:[ns.$type]},InfixRuleOperatorList:{name:os.$type,properties:{associativity:{name:os.associativity},operators:{name:os.operators,defaultValue:[]}},superTypes:[]},InfixRuleOperators:{name:rl.$type,properties:{precedences:{name:rl.precedences,defaultValue:[]}},superTypes:[]},Interface:{name:ka.$type,properties:{attributes:{name:ka.attributes,defaultValue:[]},name:{name:ka.name},superTypes:{name:ka.superTypes,defaultValue:[],referenceType:vt.$type}},superTypes:[vt.$type]},Keyword:{name:Oa.$type,properties:{cardinality:{name:Oa.cardinality},predicate:{name:Oa.predicate},value:{name:Oa.value}},superTypes:[dt.$type]},NamedArgument:{name:La.$type,properties:{calledByName:{name:La.calledByName,defaultValue:!1},parameter:{name:La.parameter,referenceType:Da.$type},value:{name:La.value}},superTypes:[]},NegatedToken:{name:hn.$type,properties:{cardinality:{name:hn.cardinality},lookahead:{name:hn.lookahead},parenthesized:{name:hn.parenthesized,defaultValue:!1},terminal:{name:hn.terminal}},superTypes:[pt.$type]},Negation:{name:nl.$type,properties:{value:{name:nl.value}},superTypes:[Fr.$type]},NumberLiteral:{name:al.$type,properties:{value:{name:al.value}},superTypes:[Cn.$type]},Parameter:{name:Da.$type,properties:{name:{name:Da.name}},superTypes:[]},ParameterReference:{name:il.$type,properties:{parameter:{name:il.parameter,referenceType:Da.$type}},superTypes:[Fr.$type]},ParserRule:{name:Lt.$type,properties:{dataType:{name:Lt.dataType},definition:{name:Lt.definition},entry:{name:Lt.entry,defaultValue:!1},fragment:{name:Lt.fragment,defaultValue:!1},inferredType:{name:Lt.inferredType},name:{name:Lt.name},parameters:{name:Lt.parameters,defaultValue:[]},returnType:{name:Lt.returnType,referenceType:vt.$type}},superTypes:[ns.$type]},ReferenceType:{name:ls.$type,properties:{isMulti:{name:ls.isMulti,defaultValue:!1},referenceType:{name:ls.referenceType}},superTypes:[An.$type]},RegexToken:{name:yn.$type,properties:{cardinality:{name:yn.cardinality},lookahead:{name:yn.lookahead},parenthesized:{name:yn.parenthesized,defaultValue:!1},regex:{name:yn.regex}},superTypes:[pt.$type]},ReturnType:{name:sl.$type,properties:{name:{name:sl.name}},superTypes:[]},RuleCall:{name:gn.$type,properties:{arguments:{name:gn.arguments,defaultValue:[]},cardinality:{name:gn.cardinality},predicate:{name:gn.predicate},rule:{name:gn.rule,referenceType:Pa.$type}},superTypes:[dt.$type]},SimpleType:{name:xa.$type,properties:{primitiveType:{name:xa.primitiveType},stringType:{name:xa.stringType},typeRef:{name:xa.typeRef,referenceType:vt.$type}},superTypes:[An.$type]},StringLiteral:{name:ol.$type,properties:{value:{name:ol.value}},superTypes:[Cn.$type]},TerminalAlternatives:{name:vn.$type,properties:{cardinality:{name:vn.cardinality},elements:{name:vn.elements,defaultValue:[]},lookahead:{name:vn.lookahead},parenthesized:{name:vn.parenthesized,defaultValue:!1}},superTypes:[pt.$type]},TerminalElement:{name:pt.$type,properties:{cardinality:{name:pt.cardinality},lookahead:{name:pt.lookahead},parenthesized:{name:pt.parenthesized,defaultValue:!1}},superTypes:[dt.$type]},TerminalGroup:{name:Tn.$type,properties:{cardinality:{name:Tn.cardinality},elements:{name:Tn.elements,defaultValue:[]},lookahead:{name:Tn.lookahead},parenthesized:{name:Tn.parenthesized,defaultValue:!1}},superTypes:[pt.$type]},TerminalRule:{name:vr.$type,properties:{definition:{name:vr.definition},fragment:{name:vr.fragment,defaultValue:!1},hidden:{name:vr.hidden,defaultValue:!1},name:{name:vr.name},type:{name:vr.type}},superTypes:[Pa.$type]},TerminalRuleCall:{name:$n.$type,properties:{cardinality:{name:$n.cardinality},lookahead:{name:$n.lookahead},parenthesized:{name:$n.parenthesized,defaultValue:!1},rule:{name:$n.rule,referenceType:vr.$type}},superTypes:[pt.$type]},Type:{name:us.$type,properties:{name:{name:us.name},type:{name:us.type}},superTypes:[vt.$type]},TypeAttribute:{name:Rn.$type,properties:{defaultValue:{name:Rn.defaultValue},isOptional:{name:Rn.isOptional,defaultValue:!1},name:{name:Rn.name},type:{name:Rn.type}},superTypes:[]},TypeDefinition:{name:An.$type,properties:{},superTypes:[]},UnionType:{name:ll.$type,properties:{types:{name:ll.types,defaultValue:[]}},superTypes:[An.$type]},UnorderedGroup:{name:cs.$type,properties:{cardinality:{name:cs.cardinality},elements:{name:cs.elements,defaultValue:[]}},superTypes:[dt.$type]},UntilToken:{name:En.$type,properties:{cardinality:{name:En.cardinality},lookahead:{name:En.lookahead},parenthesized:{name:En.parenthesized,defaultValue:!1},terminal:{name:En.terminal}},superTypes:[pt.$type]},ValueLiteral:{name:Cn.$type,properties:{},superTypes:[]},Wildcard:{name:Ma.$type,properties:{cardinality:{name:Ma.cardinality},lookahead:{name:Ma.lookahead},parenthesized:{name:Ma.parenthesized,defaultValue:!1}},superTypes:[pt.$type]}}}},j=new Jd;function mv(e){let t=e,r=!1;for(;t;){const n=Mn(t.grammarSource,it);if(n&&n.dataType)t=t.container,r=!0;else return r?t:void 0}}i(mv,"getDatatypeNode");function Ha(e){return new Ka(e,t=>$r(t)?t.content:[],{includeRoot:!0})}i(Ha,"streamCst");function hv(e){return Ha(e).filter(xn)}i(hv,"flattenCst");function Zd(e,t){for(;e.container;)if(e=e.container,e===t)return!0;return!1}i(Zd,"isChildNode");function $s(e){return{start:{character:e.startColumn-1,line:e.startLine-1},end:{character:e.endColumn,line:e.endLine-1}}}i($s,"tokenToRange");function Ya(e){if(!e)return;const{offset:t,end:r,range:n}=e;return{range:n,offset:t,end:r,length:r-t}}i(Ya,"toDocumentSegment");var Qt;(function(e){e[e.Before=0]="Before",e[e.After=1]="After",e[e.OverlapFront=2]="OverlapFront",e[e.OverlapBack=3]="OverlapBack",e[e.Inside=4]="Inside",e[e.Outside=5]="Outside"})(Qt||(Qt={}));function Qd(e,t){if(e.end.linet.end.line||e.start.line===t.end.line&&e.start.character>=t.end.character)return Qt.After;const r=e.start.line>t.start.line||e.start.line===t.start.line&&e.start.character>=t.start.character,n=e.end.lineQt.After}i(ep,"inRange");var tp=/^[\w\p{L}]$/u;function yv(e,t,r=tp){if(e){if(t>0){const n=t-e.offset,a=e.text.charAt(n);r.test(a)||t--}return Kl(e,t)}}i(yv,"findDeclarationNodeAtOffset");function rp(e,t){if(e){const r=ip(e,!0);if(r&&ul(r,t))return r;if(Ml(e)){const n=e.content.findIndex(a=>!a.hidden);for(let a=n-1;a>=0;a--){const s=e.content[a];if(ul(s,t))return s}}}}i(rp,"findCommentNode");function ul(e,t){return xn(e)&&t.includes(e.tokenType.name)}i(ul,"isCommentNode");function Kl(e,t){if(xn(e))return e;if($r(e)){const r=ap(e,t,!1);if(r)return Kl(r,t)}}i(Kl,"findLeafNodeAtOffset");function np(e,t){if(xn(e))return e;if($r(e)){const r=ap(e,t,!0);if(r)return np(r,t)}}i(np,"findLeafNodeBeforeOffset");function ap(e,t,r){let n=0,a=e.content.length-1,s;for(;n<=a;){const o=Math.floor((n+a)/2),l=e.content[o];if(l.offset<=t&&l.end>t)return l;l.end<=t?(s=r?l:void 0,n=o+1):a=o-1}return s}i(ap,"binarySearch");function ip(e,t=!0){for(;e.container;){const r=e.container;let n=r.content.indexOf(e);for(;n>0;){n--;const a=r.content[n];if(t||!a.hidden)return a}e=r}}i(ip,"getPreviousNode");function gv(e,t=!0){for(;e.container;){const r=e.container;let n=r.content.indexOf(e);const a=r.content.length-1;for(;nTp,findNameAssignment:()=>Zl,findNodeForKeyword:()=>vp,findNodeForProperty:()=>Yl,findNodesForKeyword:()=>wv,findNodesForKeywordInternal:()=>Jl,findNodesForProperty:()=>gp,getActionAtElement:()=>Rp,getActionType:()=>Ep,getAllReachableRules:()=>Hl,getAllRulesUsedForCrossReferences:()=>Sv,getCrossReferenceTerminal:()=>hp,getEntryRule:()=>dp,getExplicitRuleType:()=>js,getHiddenRules:()=>pp,getRuleType:()=>Cp,getRuleTypeName:()=>Ov,getTypeName:()=>Pn,isArrayCardinality:()=>Nv,isArrayOperator:()=>Pv,isCommentTerminal:()=>yp,isDataType:()=>kv,isDataTypeRule:()=>zs,isOptionalCardinality:()=>Iv,terminalRegex:()=>Bs});var Wl=class extends Error{static{i(this,"ErrorWithLocation")}constructor(e,t){super(e?`${t} at ${e.range.start.line}:${e.range.start.character}`:t)}};function qr(e,t="Error: Got unexpected value."){throw new Error(t)}i(qr,"assertUnreachable");function op(e,t="Error: Condition is violated."){if(!e)throw new Error(t)}i(op,"assertCondition");var lp={};Vr(lp,{NEWLINE_REGEXP:()=>Ev,escapeRegExp:()=>ri,getTerminalParts:()=>_v,isMultilineComment:()=>up,isWhitespace:()=>ql,partialMatches:()=>cp,partialRegExp:()=>fp,whitespaceCharacters:()=>bv});function U(e){return e.charCodeAt(0)}i(U,"cc");function Po(e,t){Array.isArray(e)?e.forEach(function(r){t.push(r)}):t.push(e)}i(Po,"insertToSet");function $a(e,t){if(e[t]===!0)throw"duplicate flag "+t;e[t],e[t]=!0}i($a,"addFlag");function sn(e){if(e===void 0)throw Error("Internal Error - Should never get here!");return!0}i(sn,"ASSERT_EXISTS");function Rv(){throw Error("Internal Error - Should never get here!")}i(Rv,"ASSERT_NEVER_REACH_HERE");function Cf(e){return e.type==="Character"}i(Cf,"isCharacter");var cl=[];for(let e=U("0");e<=U("9");e++)cl.push(e);var fl=[U("_")].concat(cl);for(let e=U("a");e<=U("z");e++)fl.push(e);for(let e=U("A");e<=U("Z");e++)fl.push(e);var ch=[U(" "),U("\f"),U(` +`),U("\r"),U(" "),U("\v"),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U(" "),U("\u2028"),U("\u2029"),U(" "),U(" "),U("　"),U("\uFEFF")],iN=/[0-9a-fA-F]/,ao=/[0-9]/,sN=/[1-9]/,Av=class{static{i(this,"RegExpParser")}constructor(){this.idx=0,this.input="",this.groupIdx=0}saveState(){return{idx:this.idx,input:this.input,groupIdx:this.groupIdx}}restoreState(e){this.idx=e.idx,this.input=e.input,this.groupIdx=e.groupIdx}pattern(e){this.idx=0,this.input=e,this.groupIdx=0,this.consumeChar("/");const t=this.disjunction();this.consumeChar("/");const r={type:"Flags",loc:{begin:this.idx,end:e.length},global:!1,ignoreCase:!1,multiLine:!1,unicode:!1,sticky:!1};for(;this.isRegExpFlag();)switch(this.popChar()){case"g":$a(r,"global");break;case"i":$a(r,"ignoreCase");break;case"m":$a(r,"multiLine");break;case"u":$a(r,"unicode");break;case"y":$a(r,"sticky");break}if(this.idx!==this.input.length)throw Error("Redundant input: "+this.input.substring(this.idx));return{type:"Pattern",flags:r,value:t,loc:this.loc(0)}}disjunction(){const e=[],t=this.idx;for(e.push(this.alternative());this.peekChar()==="|";)this.consumeChar("|"),e.push(this.alternative());return{type:"Disjunction",value:e,loc:this.loc(t)}}alternative(){const e=[],t=this.idx;for(;this.isTerm();)e.push(this.term());return{type:"Alternative",value:e,loc:this.loc(t)}}term(){return this.isAssertion()?this.assertion():this.atom()}assertion(){const e=this.idx;switch(this.popChar()){case"^":return{type:"StartAnchor",loc:this.loc(e)};case"$":return{type:"EndAnchor",loc:this.loc(e)};case"\\":switch(this.popChar()){case"b":return{type:"WordBoundary",loc:this.loc(e)};case"B":return{type:"NonWordBoundary",loc:this.loc(e)}}throw Error("Invalid Assertion Escape");case"(":this.consumeChar("?");let t;switch(this.popChar()){case"=":t="Lookahead";break;case"!":t="NegativeLookahead";break;case"<":{switch(this.popChar()){case"=":t="Lookbehind";break;case"!":t="NegativeLookbehind"}break}}sn(t);const r=this.disjunction();return this.consumeChar(")"),{type:t,value:r,loc:this.loc(e)}}return Rv()}quantifier(e=!1){let t;const r=this.idx;switch(this.popChar()){case"*":t={atLeast:0,atMost:1/0};break;case"+":t={atLeast:1,atMost:1/0};break;case"?":t={atLeast:0,atMost:1};break;case"{":const n=this.integerIncludingZero();switch(this.popChar()){case"}":t={atLeast:n,atMost:n};break;case",":let a;this.isDigit()?(a=this.integerIncludingZero(),t={atLeast:n,atMost:a}):t={atLeast:n,atMost:1/0},this.consumeChar("}");break}if(e===!0&&t===void 0)return;sn(t);break}if(!(e===!0&&t===void 0)&&sn(t))return this.peekChar(0)==="?"?(this.consumeChar("?"),t.greedy=!1):t.greedy=!0,t.type="Quantifier",t.loc=this.loc(r),t}atom(){let e;const t=this.idx;switch(this.peekChar()){case".":e=this.dotAll();break;case"\\":e=this.atomEscape();break;case"[":e=this.characterClass();break;case"(":e=this.group();break}if(e===void 0&&this.isPatternCharacter()&&(e=this.patternCharacter()),sn(e))return e.loc=this.loc(t),this.isQuantifier()&&(e.quantifier=this.quantifier()),e}dotAll(){return this.consumeChar("."),{type:"Set",complement:!0,value:[U(` +`),U("\r"),U("\u2028"),U("\u2029")]}}atomEscape(){switch(this.consumeChar("\\"),this.peekChar()){case"1":case"2":case"3":case"4":case"5":case"6":case"7":case"8":case"9":return this.decimalEscapeAtom();case"d":case"D":case"s":case"S":case"w":case"W":return this.characterClassEscape();case"f":case"n":case"r":case"t":case"v":return this.controlEscapeAtom();case"c":return this.controlLetterEscapeAtom();case"0":return this.nulCharacterAtom();case"x":return this.hexEscapeSequenceAtom();case"u":return this.regExpUnicodeEscapeSequenceAtom();default:return this.identityEscapeAtom()}}decimalEscapeAtom(){return{type:"GroupBackReference",value:this.positiveInteger()}}characterClassEscape(){let e,t=!1;switch(this.popChar()){case"d":e=cl;break;case"D":e=cl,t=!0;break;case"s":e=ch;break;case"S":e=ch,t=!0;break;case"w":e=fl;break;case"W":e=fl,t=!0;break}if(sn(e))return{type:"Set",value:e,complement:t}}controlEscapeAtom(){let e;switch(this.popChar()){case"f":e=U("\f");break;case"n":e=U(` +`);break;case"r":e=U("\r");break;case"t":e=U(" ");break;case"v":e=U("\v");break}if(sn(e))return{type:"Character",value:e}}controlLetterEscapeAtom(){this.consumeChar("c");const e=this.popChar();if(/[a-zA-Z]/.test(e)===!1)throw Error("Invalid ");return{type:"Character",value:e.toUpperCase().charCodeAt(0)-64}}nulCharacterAtom(){return this.consumeChar("0"),{type:"Character",value:U("\0")}}hexEscapeSequenceAtom(){return this.consumeChar("x"),this.parseHexDigits(2)}regExpUnicodeEscapeSequenceAtom(){return this.consumeChar("u"),this.parseHexDigits(4)}identityEscapeAtom(){const e=this.popChar();return{type:"Character",value:U(e)}}classPatternCharacterAtom(){switch(this.peekChar()){case` +`:case"\r":case"\u2028":case"\u2029":case"\\":case"]":throw Error("TBD");default:const e=this.popChar();return{type:"Character",value:U(e)}}}characterClass(){const e=[];let t=!1;for(this.consumeChar("["),this.peekChar(0)==="^"&&(this.consumeChar("^"),t=!0);this.isClassAtom();){const r=this.classAtom();if(r.type,Cf(r)&&this.isRangeDash()){this.consumeChar("-");const n=this.classAtom();if(n.type,Cf(n)){if(n.value=this.input.length)throw Error("Unexpected end of input");this.idx++}loc(e){return{begin:e,end:this.idx}}},Vl=class{static{i(this,"BaseRegExpVisitor")}visitChildren(e){for(const t in e){const r=e[t];e.hasOwnProperty(t)&&(r.type!==void 0?this.visit(r):Array.isArray(r)&&r.forEach(n=>{this.visit(n)},this))}}visit(e){switch(e.type){case"Pattern":this.visitPattern(e);break;case"Flags":this.visitFlags(e);break;case"Disjunction":this.visitDisjunction(e);break;case"Alternative":this.visitAlternative(e);break;case"StartAnchor":this.visitStartAnchor(e);break;case"EndAnchor":this.visitEndAnchor(e);break;case"WordBoundary":this.visitWordBoundary(e);break;case"NonWordBoundary":this.visitNonWordBoundary(e);break;case"Lookahead":this.visitLookahead(e);break;case"NegativeLookahead":this.visitNegativeLookahead(e);break;case"Lookbehind":this.visitLookbehind(e);break;case"NegativeLookbehind":this.visitNegativeLookbehind(e);break;case"Character":this.visitCharacter(e);break;case"Set":this.visitSet(e);break;case"Group":this.visitGroup(e);break;case"GroupBackReference":this.visitGroupBackReference(e);break;case"Quantifier":this.visitQuantifier(e);break}this.visitChildren(e)}visitPattern(e){}visitFlags(e){}visitDisjunction(e){}visitAlternative(e){}visitStartAnchor(e){}visitEndAnchor(e){}visitWordBoundary(e){}visitNonWordBoundary(e){}visitLookahead(e){}visitNegativeLookahead(e){}visitLookbehind(e){}visitNegativeLookbehind(e){}visitCharacter(e){}visitSet(e){}visitGroup(e){}visitGroupBackReference(e){}visitQuantifier(e){}},Ev=/\r?\n/gm,Cv=new Av,oN=class extends Vl{static{i(this,"TerminalRegExpVisitor")}constructor(){super(...arguments),this.isStarting=!0,this.endRegexpStack=[],this.multiline=!1}get endRegex(){return this.endRegexpStack.join("")}reset(e){this.multiline=!1,this.regex=e,this.startRegexp="",this.isStarting=!0,this.endRegexpStack=[]}visitGroup(e){e.quantifier&&(this.isStarting=!1,this.endRegexpStack=[])}visitCharacter(e){const t=String.fromCharCode(e.value);if(!this.multiline&&t===` +`&&(this.multiline=!0),e.quantifier)this.isStarting=!1,this.endRegexpStack=[];else{const r=ri(t);this.endRegexpStack.push(r),this.isStarting&&(this.startRegexp+=r)}}visitSet(e){if(!this.multiline){const t=this.regex.substring(e.loc.begin,e.loc.end),r=new RegExp(t);this.multiline=!!` +`.match(r)}if(e.quantifier)this.isStarting=!1,this.endRegexpStack=[];else{const t=this.regex.substring(e.loc.begin,e.loc.end);this.endRegexpStack.push(t),this.isStarting&&(this.startRegexp+=t)}}visitChildren(e){e.type==="Group"&&e.quantifier||super.visitChildren(e)}},_n=new oN;function _v(e){try{typeof e!="string"&&(e=e.source),e=`/${e}/`;const t=Cv.pattern(e),r=[];for(const n of t.value.value)_n.reset(e),_n.visit(n),r.push({start:_n.startRegexp,end:_n.endRegex});return r}catch{return[]}}i(_v,"getTerminalParts");function up(e){try{return typeof e=="string"&&(e=new RegExp(e)),e=e.toString(),_n.reset(e),_n.visit(Cv.pattern(e)),_n.multiline}catch{return!1}}i(up,"isMultilineComment");var bv=`\f +\r \v              \u2028\u2029  　\uFEFF`.split("");function ql(e){const t=typeof e=="string"?new RegExp(e):e;return bv.some(r=>t.test(r))}i(ql,"isWhitespace");function ri(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}i(ri,"escapeRegExp");function cp(e,t){const r=fp(e),n=t.match(r);return!!n&&n[0].length>0}i(cp,"partialMatches");function fp(e){typeof e=="string"&&(e=new RegExp(e));const t=e,r=e.source;let n=0;function a(){let s="",o;function l(c){s+=r.substr(n,c),n+=c}i(l,"appendRaw");function u(c){s+="(?:"+r.substr(n,c)+"|$)",n+=c}for(i(u,"appendOptional");n",n)-n+1);break;default:u(2);break}break;case"[":o=/\[(?:\\.|.)*?\]/g,o.lastIndex=n,o=o.exec(r)||[],u(o[0].length);break;case"|":case"^":case"$":case"*":case"+":case"?":l(1);break;case"{":o=/\{\d+,?\d*\}/g,o.lastIndex=n,o=o.exec(r),o?l(o[0].length):u(1);break;case"(":if(r[n+1]==="?")switch(r[n+2]){case":":s+="(?:",n+=3,s+=a()+"|$)";break;case"=":s+="(?=",n+=3,s+=a()+")";break;case"!":o=n,n+=3,a(),s+=r.substr(o,n-o);break;case"<":switch(r[n+3]){case"=":case"!":o=n,n+=4,a(),s+=r.substr(o,n-o);break;default:l(r.indexOf(">",n)-n+1),s+=a()+"|$)";break}break}else l(1),s+=a()+"|$)";break;case")":return++n,s;default:u(1);break}return s}return i(a,"process"),new RegExp(a(),e.flags)}i(fp,"partialRegExp");function dp(e){return e.rules.find(t=>it(t)&&t.entry)}i(dp,"getEntryRule");function pp(e){return e.rules.filter(t=>Nt(t)&&t.hidden)}i(pp,"getHiddenRules");function Hl(e,t){const r=new Set,n=dp(e);if(!n)return new Set(e.rules);const a=[n].concat(pp(e));for(const o of a)mp(o,r,t);const s=new Set;for(const o of e.rules)(r.has(o.name)||Nt(o)&&o.hidden)&&s.add(o);return s}i(Hl,"getAllReachableRules");function mp(e,t,r){t.add(e.name),Nr(e).forEach(n=>{if(Er(n)||r&&jl(n)){const a=n.rule.ref;a&&!t.has(a.name)&&mp(a,t,r)}})}i(mp,"ruleDfs");function Sv(e){const t=new Set;return Nr(e).forEach(r=>{Fn(r)&&(it(r.type.ref)&&t.add(r.type.ref),Fs(r.type.ref)&&it(r.type.ref.$container)&&t.add(r.type.ref.$container))}),t}i(Sv,"getAllRulesUsedForCrossReferences");function hp(e){if(e.terminal)return e.terminal;if(e.type.ref)return Zl(e.type.ref)?.terminal}i(hp,"getCrossReferenceTerminal");function yp(e){return e.hidden&&!ql(Bs(e))}i(yp,"isCommentTerminal");function gp(e,t){return!e||!t?[]:Xl(e,t,e.astNode,!0)}i(gp,"findNodesForProperty");function Yl(e,t,r){if(!e||!t)return;const n=Xl(e,t,e.astNode,!0);if(n.length!==0)return r!==void 0?r=Math.max(0,Math.min(r,n.length-1)):r=0,n[r]}i(Yl,"findNodeForProperty");function Xl(e,t,r,n){if(!n){const a=Mn(e.grammarSource,Rr);if(a&&a.feature===t)return[e]}return $r(e)&&e.astNode===r?e.content.flatMap(a=>Xl(a,t,r,!1)):[]}i(Xl,"findNodesForPropertyInternal");function wv(e,t){return e?Jl(e,t,e?.astNode):[]}i(wv,"findNodesForKeyword");function vp(e,t,r){if(!e)return;const n=Jl(e,t,e?.astNode);if(n.length!==0)return r!==void 0?r=Math.max(0,Math.min(r,n.length-1)):r=0,n[r]}i(vp,"findNodeForKeyword");function Jl(e,t,r){if(e.astNode!==r)return[];if(Ar(e.grammarSource)&&e.grammarSource.value===t)return[e];const n=Ha(e).iterator();let a;const s=[];do if(a=n.next(),!a.done){const o=a.value;o.astNode===r?Ar(o.grammarSource)&&o.grammarSource.value===t&&s.push(o):n.prune()}while(!a.done);return s}i(Jl,"findNodesForKeywordInternal");function Tp(e){const t=e.astNode;for(;t===e.container?.astNode;){const r=Mn(e.grammarSource,Rr);if(r)return r;e=e.container}}i(Tp,"findAssignment");function Zl(e){let t=e;return Fs(t)&&(jr(t.$container)?t=t.$container.$container:Gn(t.$container)?t=t.$container:qr(t.$container)),$p(e,t,new Map)}i(Zl,"findNameAssignment");function $p(e,t,r){function n(a,s){let o;return Mn(a,Rr)||(o=$p(s,s,r)),r.set(e,o),o}if(i(n,"go"),r.has(e))return r.get(e);r.set(e,void 0);for(const a of Nr(t)){if(Rr(a)&&a.feature.toLowerCase()==="name")return r.set(e,a),a;if(Er(a)&&it(a.rule.ref))return n(a,a.rule.ref);if(zl(a)&&a.typeRef?.ref)return n(a,a.typeRef.ref)}}i($p,"findNameAssignmentInternal");function Rp(e){const t=e.$container;if(zn(t)){const r=t.elements,n=r.indexOf(e);for(let a=n-1;a>=0;a--){const s=r[a];if(jr(s))return s;{const o=Nr(r[a]).find(jr);if(o)return o}}}if(Gl(t))return Rp(t)}i(Rp,"getActionAtElement");function Iv(e,t){return e==="?"||e==="*"||zn(t)&&!!t.guardCondition}i(Iv,"isOptionalCardinality");function Nv(e){return e==="*"||e==="+"}i(Nv,"isArrayCardinality");function Pv(e){return e==="+="}i(Pv,"isArrayOperator");function zs(e){return Ap(e,new Set)}i(zs,"isDataTypeRule");function Ap(e,t){if(t.has(e))return!0;t.add(e);for(const r of Nr(e))if(Er(r)){if(!r.rule.ref||it(r.rule.ref)&&!Ap(r.rule.ref,t)||qa(r.rule.ref))return!1}else{if(Rr(r))return!1;if(jr(r))return!1}return!!e.definition}i(Ap,"isDataTypeRuleInternal");function kv(e){return dl(e.type,new Set)}i(kv,"isDataType");function dl(e,t){if(t.has(e))return!0;if(t.add(e),Od(e))return!1;if(Ud(e))return!1;if(Hd(e))return e.types.every(r=>dl(r,t));if(zl(e)){if(e.primitiveType!==void 0)return!0;if(e.stringType!==void 0)return!0;if(e.typeRef!==void 0){const r=e.typeRef.ref;return Bl(r)?dl(r.type,t):!1}else return!1}else return!1}i(dl,"isDataTypeInternal");function js(e){if(!Nt(e)){if(e.inferredType)return e.inferredType.name;if(e.dataType)return e.dataType;if(e.returnType){const t=e.returnType.ref;if(t)return t.name}}}i(js,"getExplicitRuleType");function Pn(e){if(Gn(e))return it(e)&&zs(e)?e.name:js(e)??e.name;if(Fd(e)||Bl(e)||Wd(e))return e.name;if(jr(e)){const t=Ep(e);if(t)return t}else if(Fs(e))return e.name;throw new Error("Cannot get name of Unknown Type")}i(Pn,"getTypeName");function Ep(e){if(e.inferredType)return e.inferredType.name;if(e.type?.ref)return Pn(e.type.ref)}i(Ep,"getActionType");function Ov(e){return Nt(e)?e.type?.name??"string":it(e)&&zs(e)?e.name:js(e)??e.name}i(Ov,"getRuleTypeName");function Cp(e){return Nt(e)?e.type?.name??"string":js(e)??e.name}i(Cp,"getRuleType");function Bs(e){const t={s:!1,i:!1,u:!1},r=jn(e.definition,t),n=Object.entries(t).filter(([,a])=>a).map(([a])=>a).join("");return new RegExp(r,n)}i(Bs,"terminalRegex");var _p=/[\s\S]/.source;function jn(e,t){if(Vd(e))return Lv(e);if(qd(e))return Dv(e);if(Dd(e))return Gv(e);if(jl(e)){const r=e.rule.ref;if(!r)throw new Error("Missing rule reference.");return nr(jn(r.definition),{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized})}else{if(zd(e))return Mv(e);if(Yd(e))return xv(e);if(Kd(e)){const r=e.regex.lastIndexOf("/"),n=e.regex.substring(1,r),a=e.regex.substring(r+1);return t&&(t.i=a.includes("i"),t.s=a.includes("s"),t.u=a.includes("u")),nr(n,{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized,wrap:!1})}else{if(Xd(e))return nr(_p,{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized});throw new Error(`Invalid terminal element: ${e?.$type}, ${e?.$cstNode?.text}`)}}}i(jn,"abstractElementToRegex");function Lv(e){return nr(e.elements.map(t=>jn(t)).join("|"),{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized,wrap:!1})}i(Lv,"terminalAlternativesToRegex");function Dv(e){return nr(e.elements.map(t=>jn(t)).join(""),{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized,wrap:!1})}i(Dv,"terminalGroupToRegex");function xv(e){return nr(`${_p}*?${jn(e.terminal)}`,{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized})}i(xv,"untilTokenToRegex");function Mv(e){return nr(`(?!${jn(e.terminal)})${_p}*?`,{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized})}i(Mv,"negateTokenToRegex");function Gv(e){return e.right?nr(`[${ko(e.left)}-${ko(e.right)}]`,{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized,wrap:!1}):nr(ko(e.left),{cardinality:e.cardinality,lookahead:e.lookahead,parenthesized:e.parenthesized,wrap:!1})}i(Gv,"characterRangeToRegex");function ko(e){return ri(e.value)}i(ko,"keywordToRegex");function nr(e,t){return(t.parenthesized||t.lookahead||t.wrap!==!1)&&(e=`(${t.lookahead??(t.parenthesized?"":"?:")}${e})`),t.cardinality?`${e}${t.cardinality}`:e}i(nr,"withCardinality");function bp(e){const t=[],r=e.Grammar;for(const n of r.rules)Nt(n)&&yp(n)&&up(Bs(n))&&t.push(n.name);return{multilineCommentRules:t,nameRegexp:tp}}i(bp,"createGrammarConfig");var lN=typeof global=="object"&&global&&global.Object===Object&&global,Fv=lN,uN=typeof self=="object"&&self&&self.Object===Object&&self,cN=Fv||uN||Function("return this")(),ir=cN,fN=ir.Symbol,wt=fN,zv=Object.prototype,dN=zv.hasOwnProperty,pN=zv.toString,Oi=wt?wt.toStringTag:void 0;function jv(e){var t=dN.call(e,Oi),r=e[Oi];try{e[Oi]=void 0;var n=!0}catch{}var a=pN.call(e);return n&&(t?e[Oi]=r:delete e[Oi]),a}i(jv,"getRawTag");var mN=jv,hN=Object.prototype,yN=hN.toString;function Bv(e){return yN.call(e)}i(Bv,"objectToString");var gN=Bv,vN="[object Null]",TN="[object Undefined]",fh=wt?wt.toStringTag:void 0;function Uv(e){return e==null?e===void 0?TN:vN:fh&&fh in Object(e)?mN(e):gN(e)}i(Uv,"baseGetTag");var Hr=Uv;function Kv(e){return e!=null&&typeof e=="object"}i(Kv,"isObjectLike");var jt=Kv,$N="[object Symbol]";function Wv(e){return typeof e=="symbol"||jt(e)&&Hr(e)==$N}i(Wv,"isSymbol");var Ql=Wv;function Vv(e,t){for(var r=-1,n=e==null?0:e.length,a=Array(n);++r0){if(++t>=rP)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}i(uT,"shortOut");var iP=uT;function cT(e){return function(){return e}}i(cT,"constant");var sP=cT,oP=(function(){try{var e=Un(Object,"defineProperty");return e({},"",{}),e}catch{}})(),pl=oP,lP=pl?function(e,t){return pl(e,"toString",{configurable:!0,enumerable:!1,value:sP(t),writable:!0})}:Ws,uP=lP,cP=iP(uP),fP=cP;function fT(e,t){for(var r=-1,n=e==null?0:e.length;++r-1}i(vT,"arrayIncludes");var TT=vT,mP=9007199254740991,hP=/^(?:0|[1-9]\d*)$/;function $T(e,t){var r=typeof e;return t=t??mP,!!t&&(r=="number"||r!="symbol"&&hP.test(e))&&e>-1&&e%1==0&&e-1&&e%1==0&&e<=TP}i(ST,"isLength");var Pp=ST;function wT(e){return e!=null&&Pp(e.length)&&!Pr(e)}i(wT,"isArrayLike");var sr=wT;function IT(e,t,r){if(!It(r))return!1;var n=typeof t;return(n=="number"?sr(r)&&eu(t,r.length):n=="string"&&t in r)?Vs(r[t],e):!1}i(IT,"isIterateeCall");var ru=IT;function NT(e){return Np(function(t,r){var n=-1,a=r.length,s=a>1?r[a-1]:void 0,o=a>2?r[2]:void 0;for(s=e.length>3&&typeof s=="function"?(a--,s):void 0,o&&ru(r[0],r[1],o)&&(s=a<3?void 0:s,a=1),t=Object(t);++n-1}i(s$,"listCacheHas");var Mk=s$;function o$(e,t){var r=this.__data__,n=iu(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}i(o$,"listCacheSet");var Gk=o$;function Wn(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t0&&r(l)?t>1?xp(l,t-1,r,n,a):Dp(a,l):n||(a[a.length]=l)}return a}i(xp,"baseFlatten");var Mp=xp;function E$(e){var t=e==null?0:e.length;return t?Mp(e,1):[]}i(E$,"flatten");var Ft=E$,nO=UT(Object.getPrototypeOf,Object),C$=nO;function _$(e,t,r){var n=-1,a=e.length;t<0&&(t=-t>a?0:a+t),r=r>a?a:r,r<0&&(r+=a),a=t>r?0:r-t>>>0,t>>>=0;for(var s=Array(a);++nl))return!1;var c=s.get(e),f=s.get(t);if(c&&f)return c==t&&f==e;var d=-1,m=!0,g=r&q0?new jp:void 0;for(s.set(e,t),s.set(t,e);++d2?t[2]:void 0;for(a&&ru(t[0],t[1],a)&&(n=1);++r=zL&&(s=Bp,o=!1,t=new jp(t));e:for(;++a-1?a[s?t[o]:o]:void 0}}i(sA,"createFind");var VL=sA,qL=Math.max;function oA(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var a=r==null?0:Ks(r);return a<0&&(a=qL(n+a,0)),mT(e,or(t),a)}i(oA,"findIndex");var HL=oA,YL=VL(HL),Ja=YL;function lA(e){return e&&e.length?e[0]:void 0}i(lA,"head");var Bt=lA;function uA(e,t){var r=-1,n=sr(e)?Array(e.length):[];return Hn(e,function(a,s,o){n[++r]=t(a,s,o)}),n}i(uA,"baseMap");var XL=uA;function cA(e,t){var r=re(e)?Us:XL;return r(e,or(t))}i(cA,"map");var F=cA;function fA(e,t){return Mp(F(e,t),1)}i(fA,"flatMap");var St=fA,JL=Object.prototype,ZL=JL.hasOwnProperty,QL=ML(function(e,t,r){ZL.call(e,r)?e[r].push(t):Ip(e,r,[t])}),eD=QL,tD=Object.prototype,rD=tD.hasOwnProperty;function dA(e,t){return e!=null&&rD.call(e,t)}i(dA,"baseHas");var nD=dA;function pA(e,t){return e!=null&&PR(e,t,nD)}i(pA,"has");var B=pA,aD="[object String]";function mA(e){return typeof e=="string"||!re(e)&&jt(e)&&Hr(e)==aD}i(mA,"isString");var mt=mA;function hA(e,t){return Us(t,function(r){return e[r]})}i(hA,"baseValues");var iD=hA;function yA(e){return e==null?[]:iD(e,$t(e))}i(yA,"values");var Me=yA,sD=Math.max;function gA(e,t,r,n){e=sr(e)?e:Me(e),r=r&&!n?Ks(r):0;var a=e.length;return r<0&&(r=sD(a+r,0)),mt(e)?r<=a&&e.indexOf(t,r)>-1:!!a&&wp(e,t,r)>-1}i(gA,"includes");var ut=gA,oD=Math.max;function vA(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var a=r==null?0:Ks(r);return a<0&&(a=oD(n+a,0)),wp(e,t,a)}i(vA,"indexOf");var Uh=vA,lD="[object Map]",uD="[object Set]",cD=Object.prototype,fD=cD.hasOwnProperty;function TA(e){if(e==null)return!0;if(sr(e)&&(re(e)||typeof e=="string"||typeof e.splice=="function"||Rs(e)||kp(e)||nu(e)))return!e.length;var t=Xa(e);if(t==lD||t==uD)return!e.size;if(Hs(e))return!WT(e).length;for(var r in e)if(fD.call(e,r))return!1;return!0}i(TA,"isEmpty");var me=TA,dD="[object RegExp]";function $A(e){return jt(e)&&Hr(e)==dD}i($A,"baseIsRegExp");var pD=$A,Kh=Br&&Br.isRegExp,mD=Kh?Ys(Kh):pD,Cr=mD;function RA(e){return e===void 0}i(RA,"isUndefined");var _r=RA,hD="Expected a function";function AA(e){if(typeof e!="function")throw new TypeError(hD);return function(){var t=arguments;switch(t.length){case 0:return!e.call(this);case 1:return!e.call(this,t[0]);case 2:return!e.call(this,t[0],t[1]);case 3:return!e.call(this,t[0],t[1],t[2])}return!e.apply(this,t)}}i(AA,"negate");var yD=AA;function EA(e,t,r,n){if(!It(e))return e;t=cu(t,e);for(var a=-1,s=t.length,o=s-1,l=e;l!=null&&++a=CD){var c=t?null:ED(e);if(c)return Up(c);o=!1,a=Bp,u=new jp}else u=t?[]:l;e:for(;++n{t.accept(e)})}},st=class extends lr{static{i(this,"NonTerminal")}constructor(e){super([]),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}set definition(e){}get definition(){return this.referencedRule!==void 0?this.referencedRule.definition:[]}accept(e){e.visit(this)}},ni=class extends lr{static{i(this,"Rule")}constructor(e){super(e.definition),this.orgText="",Rt(this,Ut(e,t=>t!==void 0))}},ht=class extends lr{static{i(this,"Alternative")}constructor(e){super(e.definition),this.ignoreAmbiguities=!1,Rt(this,Ut(e,t=>t!==void 0))}},He=class extends lr{static{i(this,"Option")}constructor(e){super(e.definition),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}},Et=class extends lr{static{i(this,"RepetitionMandatory")}constructor(e){super(e.definition),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}},Ct=class extends lr{static{i(this,"RepetitionMandatoryWithSeparator")}constructor(e){super(e.definition),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}},_e=class extends lr{static{i(this,"Repetition")}constructor(e){super(e.definition),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}},yt=class extends lr{static{i(this,"RepetitionWithSeparator")}constructor(e){super(e.definition),this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}},gt=class extends lr{static{i(this,"Alternation")}get definition(){return this._definition}set definition(e){this._definition=e}constructor(e){super(e.definition),this.idx=1,this.ignoreAmbiguities=!1,this.hasPredicates=!1,Rt(this,Ut(e,t=>t!==void 0))}},ve=class{static{i(this,"Terminal")}constructor(e){this.idx=1,Rt(this,Ut(e,t=>t!==void 0))}accept(e){e.visit(this)}};function xA(e){return F(e,ms)}i(xA,"serializeGrammar");function ms(e){function t(r){return F(r,ms)}if(i(t,"convertDefinition"),e instanceof st){const r={type:"NonTerminal",name:e.nonTerminalName,idx:e.idx};return mt(e.label)&&(r.label=e.label),r}else{if(e instanceof ht)return{type:"Alternative",definition:t(e.definition)};if(e instanceof He)return{type:"Option",idx:e.idx,definition:t(e.definition)};if(e instanceof Et)return{type:"RepetitionMandatory",idx:e.idx,definition:t(e.definition)};if(e instanceof Ct)return{type:"RepetitionMandatoryWithSeparator",idx:e.idx,separator:ms(new ve({terminalType:e.separator})),definition:t(e.definition)};if(e instanceof yt)return{type:"RepetitionWithSeparator",idx:e.idx,separator:ms(new ve({terminalType:e.separator})),definition:t(e.definition)};if(e instanceof _e)return{type:"Repetition",idx:e.idx,definition:t(e.definition)};if(e instanceof gt)return{type:"Alternation",idx:e.idx,definition:t(e.definition)};if(e instanceof ve){const r={type:"Terminal",name:e.terminalType.name,label:LA(e.terminalType),idx:e.idx};mt(e.label)&&(r.terminalLabel=e.label);const n=e.terminalType.PATTERN;return e.terminalType.PATTERN&&(r.pattern=Cr(n)?n.source:n),r}else{if(e instanceof ni)return{type:"Rule",name:e.name,orgText:e.orgText,definition:t(e.definition)};throw Error("non exhaustive match")}}}i(ms,"serializeProduction");var ai=class{static{i(this,"GAstVisitor")}visit(e){const t=e;switch(t.constructor){case st:return this.visitNonTerminal(t);case ht:return this.visitAlternative(t);case He:return this.visitOption(t);case Et:return this.visitRepetitionMandatory(t);case Ct:return this.visitRepetitionMandatoryWithSeparator(t);case yt:return this.visitRepetitionWithSeparator(t);case _e:return this.visitRepetition(t);case gt:return this.visitAlternation(t);case ve:return this.visitTerminal(t);case ni:return this.visitRule(t);default:throw Error("non exhaustive match")}}visitNonTerminal(e){}visitAlternative(e){}visitOption(e){}visitRepetition(e){}visitRepetitionMandatory(e){}visitRepetitionMandatoryWithSeparator(e){}visitRepetitionWithSeparator(e){}visitAlternation(e){}visitTerminal(e){}visitRule(e){}};function MA(e){return e instanceof ht||e instanceof He||e instanceof _e||e instanceof Et||e instanceof Ct||e instanceof yt||e instanceof ve||e instanceof ni}i(MA,"isSequenceProd");function bs(e,t=[]){return e instanceof He||e instanceof _e||e instanceof yt?!0:e instanceof gt?PA(e.definition,n=>bs(n,t)):e instanceof st&&ut(t,e)?!1:e instanceof lr?(e instanceof st&&t.push(e),zt(e.definition,n=>bs(n,t))):!1}i(bs,"isOptionalProd");function GA(e){return e instanceof gt}i(GA,"isBranchingProd");function Dt(e){if(e instanceof st)return"SUBRULE";if(e instanceof He)return"OPTION";if(e instanceof gt)return"OR";if(e instanceof Et)return"AT_LEAST_ONE";if(e instanceof Ct)return"AT_LEAST_ONE_SEP";if(e instanceof yt)return"MANY_SEP";if(e instanceof _e)return"MANY";if(e instanceof ve)return"CONSUME";throw Error("non exhaustive match")}i(Dt,"getProductionDslName");var pu=class{static{i(this,"RestWalker")}walk(e,t=[]){K(e.definition,(r,n)=>{const a=qe(e.definition,n+1);if(r instanceof st)this.walkProdRef(r,a,t);else if(r instanceof ve)this.walkTerminal(r,a,t);else if(r instanceof ht)this.walkFlat(r,a,t);else if(r instanceof He)this.walkOption(r,a,t);else if(r instanceof Et)this.walkAtLeastOne(r,a,t);else if(r instanceof Ct)this.walkAtLeastOneSep(r,a,t);else if(r instanceof yt)this.walkManySep(r,a,t);else if(r instanceof _e)this.walkMany(r,a,t);else if(r instanceof gt)this.walkOr(r,a,t);else throw Error("non exhaustive match")})}walkTerminal(e,t,r){}walkProdRef(e,t,r){}walkFlat(e,t,r){const n=t.concat(r);this.walk(e,n)}walkOption(e,t,r){const n=t.concat(r);this.walk(e,n)}walkAtLeastOne(e,t,r){const n=[new He({definition:e.definition})].concat(t,r);this.walk(e,n)}walkAtLeastOneSep(e,t,r){const n=If(e,t,r);this.walk(e,n)}walkMany(e,t,r){const n=[new He({definition:e.definition})].concat(t,r);this.walk(e,n)}walkManySep(e,t,r){const n=If(e,t,r);this.walk(e,n)}walkOr(e,t,r){const n=t.concat(r);K(e.definition,a=>{const s=new ht({definition:[a]});this.walk(s,n)})}};function If(e,t,r){return[new He({definition:[new ve({terminalType:e.separator})].concat(e.definition)})].concat(t,r)}i(If,"restForRepetitionWithSeparator");function ii(e){if(e instanceof st)return ii(e.referencedRule);if(e instanceof ve)return jA(e);if(MA(e))return FA(e);if(GA(e))return zA(e);throw Error("non exhaustive match")}i(ii,"first");function FA(e){let t=[];const r=e.definition;let n=0,a=r.length>n,s,o=!0;for(;a&&o;)s=r[n],o=bs(s),t=t.concat(ii(s)),n=n+1,a=r.length>n;return Vp(t)}i(FA,"firstForSequence");function zA(e){const t=F(e.definition,r=>ii(r));return Vp(Ft(t))}i(zA,"firstForBranching");function jA(e){return[e.terminalType]}i(jA,"firstForTerminal");var BA="_~IN~_",bD=class extends pu{static{i(this,"ResyncFollowsWalker")}constructor(e){super(),this.topProd=e,this.follows={}}startWalking(){return this.walk(this.topProd),this.follows}walkTerminal(e,t,r){}walkProdRef(e,t,r){const n=KA(e.referencedRule,e.idx)+this.topProd.name,a=t.concat(r),s=new ht({definition:a}),o=ii(s);this.follows[n]=o}};function UA(e){const t={};return K(e,r=>{const n=new bD(r).startWalking();Rt(t,n)}),t}i(UA,"computeAllProdsFollows");function KA(e,t){return e.name+t+BA}i(KA,"buildBetweenProdsFollowPrefix");var Oo={},SD=new Av;function Zs(e){const t=e.toString();if(Oo.hasOwnProperty(t))return Oo[t];{const r=SD.pattern(t);return Oo[t]=r,r}}i(Zs,"getRegExpAst");function WA(){Oo={}}i(WA,"clearRegExpParserCache");var VA="Complement Sets are not supported for first char optimization",yl=`Unable to use "first char" lexer optimizations: +`;function qA(e,t=!1){try{const r=Zs(e);return gl(r.value,{},r.flags.ignoreCase)}catch(r){if(r.message===VA)t&&qp(`${yl} Unable to optimize: < ${e.toString()} > + Complement Sets cannot be automatically optimized. + This will disable the lexer's first char optimizations. + See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`);else{let n="";t&&(n=` + This will disable the lexer's first char optimizations. + See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.`),hl(`${yl} + Failed parsing: < ${e.toString()} > + Using the @chevrotain/regexp-to-ast library + Please open an issue at: https://github.com/chevrotain/chevrotain/issues`+n)}}return[]}i(qA,"getOptimizedStartCodesIndices");function gl(e,t,r){switch(e.type){case"Disjunction":for(let a=0;a{if(typeof u=="number")Ji(u,t,r);else{const c=u;if(r===!0)for(let f=c.from;f<=c.to;f++)Ji(f,t,r);else{for(let f=c.from;f<=c.to&&f=Qi){const f=c.from>=Qi?c.from:Qi,d=c.to,m=br(f),g=br(d);for(let v=m;v<=g;v++)t[v]=v}}}});break;case"Group":gl(o.value,t,r);break;default:throw Error("Non Exhaustive Match")}const l=o.quantifier!==void 0&&o.quantifier.atLeast===0;if(o.type==="Group"&&vl(o)===!1||o.type!=="Group"&&l===!1)break}break;default:throw Error("non exhaustive match!")}return Me(t)}i(gl,"firstCharOptimizedIndices");function Ji(e,t,r){const n=br(e);t[n]=n,r===!0&&HA(e,t)}i(Ji,"addOptimizedIdxToResult");function HA(e,t){const r=String.fromCharCode(e),n=r.toUpperCase();if(n!==r){const a=br(n.charCodeAt(0));t[a]=a}else{const a=r.toLowerCase();if(a!==r){const s=br(a.charCodeAt(0));t[s]=s}}}i(HA,"handleIgnoreCase");function Nf(e,t){return Ja(e.value,r=>{if(typeof r=="number")return ut(t,r);{const n=r;return Ja(t,a=>n.from<=a&&a<=n.to)!==void 0}})}i(Nf,"findCode");function vl(e){const t=e.quantifier;return t&&t.atLeast===0?!0:e.value?re(e.value)?zt(e.value,vl):vl(e.value):!1}i(vl,"isWholeOptional");var wD=class extends Vl{static{i(this,"CharCodeFinder")}constructor(e){super(),this.targetCharCodes=e,this.found=!1}visitChildren(e){if(this.found!==!0){switch(e.type){case"Lookahead":this.visitLookahead(e);return;case"NegativeLookahead":this.visitNegativeLookahead(e);return;case"Lookbehind":this.visitLookbehind(e);return;case"NegativeLookbehind":this.visitNegativeLookbehind(e);return}super.visitChildren(e)}}visitCharacter(e){ut(this.targetCharCodes,e.value)&&(this.found=!0)}visitSet(e){e.complement?Nf(e,this.targetCharCodes)===void 0&&(this.found=!0):Nf(e,this.targetCharCodes)!==void 0&&(this.found=!0)}};function mu(e,t){if(t instanceof RegExp){const r=Zs(t),n=new wD(e);return n.visit(r),n.found}else return Ja(t,r=>ut(e,r.charCodeAt(0)))!==void 0}i(mu,"canMatchCharCode");var On="PATTERN",Zi="defaultMode",so="modes";function YA(e,t){t=Wp(t,{debug:!1,safeMode:!1,positionTracking:"full",lineTerminatorCharacters:["\r",` +`],tracer:i((I,R)=>R(),"tracer")});const r=t.tracer;r("initCharCodeToOptimizedIndexMap",()=>{yE()});let n;r("Reject Lexer.NA",()=>{n=du(e,I=>I[On]===at.NA)});let a=!1,s;r("Transform Patterns",()=>{a=!1,s=F(n,I=>{const R=I[On];if(Cr(R)){const P=R.source;return P.length===1&&P!=="^"&&P!=="$"&&P!=="."&&!R.ignoreCase?P:P.length===2&&P[0]==="\\"&&!ut(["d","D","s","S","t","r","n","t","0","c","b","B","f","v","w","W"],P[1])?P[1]:Pf(R)}else{if(Pr(R))return a=!0,{exec:R};if(typeof R=="object")return a=!0,R;if(typeof R=="string"){if(R.length===1)return R;{const P=R.replace(/[\\^$.*+?()[\]{}|]/g,"\\$&"),z=new RegExp(P);return Pf(z)}}else throw Error("non exhaustive match")}})});let o,l,u,c,f;r("misc mapping",()=>{o=F(n,I=>I.tokenTypeIdx),l=F(n,I=>{const R=I.GROUP;if(R!==at.SKIPPED){if(mt(R))return R;if(_r(R))return!1;throw Error("non exhaustive match")}}),u=F(n,I=>{const R=I.LONGER_ALT;if(R)return re(R)?F(R,z=>Uh(n,z)):[Uh(n,R)]}),c=F(n,I=>I.PUSH_MODE),f=F(n,I=>B(I,"POP_MODE"))});let d;r("Line Terminator Handling",()=>{const I=Zp(t.lineTerminatorCharacters);d=F(n,R=>!1),t.positionTracking!=="onlyOffset"&&(d=F(n,R=>B(R,"LINE_BREAKS")?!!R.LINE_BREAKS:Jp(R,I)===!1&&mu(I,R.PATTERN)))});let m,g,v,_;r("Misc Mapping #2",()=>{m=F(n,Xp),g=F(s,mE),v=At(n,(I,R)=>{const P=R.GROUP;return mt(P)&&P!==at.SKIPPED&&(I[P]=[]),I},{}),_=F(s,(I,R)=>({pattern:s[R],longerAlt:u[R],canLineTerminator:d[R],isCustom:m[R],short:g[R],group:l[R],push:c[R],pop:f[R],tokenTypeIdx:o[R],tokenType:n[R]}))});let S=!0,w=[];return t.safeMode||r("First Char Optimization",()=>{w=At(n,(I,R,P)=>{if(typeof R.PATTERN=="string"){const z=R.PATTERN.charCodeAt(0),X=br(z);Lo(I,X,_[P])}else if(re(R.START_CHARS_HINT)){let z;K(R.START_CHARS_HINT,X=>{const Z=typeof X=="string"?X.charCodeAt(0):X,ce=br(Z);z!==ce&&(z=ce,Lo(I,ce,_[P]))})}else if(Cr(R.PATTERN))if(R.PATTERN.unicode)S=!1,t.ensureOptimizations&&hl(`${yl} Unable to analyze < ${R.PATTERN.toString()} > pattern. + The regexp unicode flag is not currently supported by the regexp-to-ast library. + This will disable the lexer's first char optimizations. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE`);else{const z=qA(R.PATTERN,t.ensureOptimizations);me(z)&&(S=!1),K(z,X=>{Lo(I,X,_[P])})}else t.ensureOptimizations&&hl(`${yl} TokenType: <${R.name}> is using a custom token pattern without providing parameter. + This will disable the lexer's first char optimizations. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE`),S=!1;return I},[])}),{emptyGroups:v,patternIdxToConfig:_,charCodeToPatternIdxToConfig:w,hasCustom:a,canBeOptimized:S}}i(YA,"analyzeTokenTypes");function XA(e,t){let r=[];const n=ZA(e);r=r.concat(n.errors);const a=QA(n.valid),s=a.valid;return r=r.concat(a.errors),r=r.concat(JA(s)),r=r.concat(iE(s)),r=r.concat(sE(s,t)),r=r.concat(oE(s)),r}i(XA,"validatePatterns");function JA(e){let t=[];const r=Pt(e,n=>Cr(n[On]));return t=t.concat(eE(r)),t=t.concat(rE(r)),t=t.concat(nE(r)),t=t.concat(aE(r)),t=t.concat(tE(r)),t}i(JA,"validateRegExpPattern");function ZA(e){const t=Pt(e,a=>!B(a,On)),r=F(t,a=>({message:"Token Type: ->"+a.name+"<- missing static 'PATTERN' property",type:be.MISSING_PATTERN,tokenTypes:[a]})),n=fu(e,t);return{errors:r,valid:n}}i(ZA,"findMissingPatterns");function QA(e){const t=Pt(e,a=>{const s=a[On];return!Cr(s)&&!Pr(s)&&!B(s,"exec")&&!mt(s)}),r=F(t,a=>({message:"Token Type: ->"+a.name+"<- static 'PATTERN' can only be a RegExp, a Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.",type:be.INVALID_PATTERN,tokenTypes:[a]})),n=fu(e,t);return{errors:r,valid:n}}i(QA,"findInvalidPatterns");var ID=/[^\\][$]/;function eE(e){class t extends Vl{static{i(this,"EndAnchorFinder")}constructor(){super(...arguments),this.found=!1}visitEndAnchor(s){this.found=!0}}const r=Pt(e,a=>{const s=a.PATTERN;try{const o=Zs(s),l=new t;return l.visit(o),l.found}catch{return ID.test(s.source)}});return F(r,a=>({message:`Unexpected RegExp Anchor Error: + Token Type: ->`+a.name+`<- static 'PATTERN' cannot contain end of input anchor '$' + See chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS for details.`,type:be.EOI_ANCHOR_FOUND,tokenTypes:[a]}))}i(eE,"findEndOfInputAnchor");function tE(e){const t=Pt(e,n=>n.PATTERN.test(""));return F(t,n=>({message:"Token Type: ->"+n.name+"<- static 'PATTERN' must not match an empty string",type:be.EMPTY_MATCH_PATTERN,tokenTypes:[n]}))}i(tE,"findEmptyMatchRegExps");var ND=/[^\\[][\^]|^\^/;function rE(e){class t extends Vl{static{i(this,"StartAnchorFinder")}constructor(){super(...arguments),this.found=!1}visitStartAnchor(s){this.found=!0}}const r=Pt(e,a=>{const s=a.PATTERN;try{const o=Zs(s),l=new t;return l.visit(o),l.found}catch{return ND.test(s.source)}});return F(r,a=>({message:`Unexpected RegExp Anchor Error: + Token Type: ->`+a.name+`<- static 'PATTERN' cannot contain start of input anchor '^' + See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS for details.`,type:be.SOI_ANCHOR_FOUND,tokenTypes:[a]}))}i(rE,"findStartOfInputAnchor");function nE(e){const t=Pt(e,n=>{const a=n[On];return a instanceof RegExp&&(a.multiline||a.global)});return F(t,n=>({message:"Token Type: ->"+n.name+"<- static 'PATTERN' may NOT contain global('g') or multiline('m')",type:be.UNSUPPORTED_FLAGS_FOUND,tokenTypes:[n]}))}i(nE,"findUnsupportedFlags");function aE(e){const t=[];let r=F(e,s=>At(e,(o,l)=>(s.PATTERN.source===l.PATTERN.source&&!ut(t,l)&&l.PATTERN!==at.NA&&(t.push(l),o.push(l)),o),[]));r=Js(r);const n=Pt(r,s=>s.length>1);return F(n,s=>{const o=F(s,u=>u.name);return{message:`The same RegExp pattern ->${Bt(s).PATTERN}<-has been used in all of the following Token Types: ${o.join(", ")} <-`,type:be.DUPLICATE_PATTERNS_FOUND,tokenTypes:s}})}i(aE,"findDuplicatePatterns");function iE(e){const t=Pt(e,n=>{if(!B(n,"GROUP"))return!1;const a=n.GROUP;return a!==at.SKIPPED&&a!==at.NA&&!mt(a)});return F(t,n=>({message:"Token Type: ->"+n.name+"<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",type:be.INVALID_GROUP_TYPE_FOUND,tokenTypes:[n]}))}i(iE,"findInvalidGroupType");function sE(e,t){const r=Pt(e,a=>a.PUSH_MODE!==void 0&&!ut(t,a.PUSH_MODE));return F(r,a=>({message:`Token Type: ->${a.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${a.PUSH_MODE}<-which does not exist`,type:be.PUSH_MODE_DOES_NOT_EXIST,tokenTypes:[a]}))}i(sE,"findModesThatDoNotExist");function oE(e){const t=[],r=At(e,(n,a,s)=>{const o=a.PATTERN;return o===at.NA||(mt(o)?n.push({str:o,idx:s,tokenType:a}):Cr(o)&&uE(o)&&n.push({str:o.source,idx:s,tokenType:a})),n},[]);return K(e,(n,a)=>{K(r,({str:s,idx:o,tokenType:l})=>{if(a${l.name}<- can never be matched. +Because it appears AFTER the Token Type ->${n.name}<-in the lexer's definition. +See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;t.push({message:u,type:be.UNREACHABLE_PATTERN,tokenTypes:[n,l]})}})}),t}i(oE,"findUnreachablePatterns");function lE(e,t){if(Cr(t)){if(cE(t))return!1;const r=t.exec(e);return r!==null&&r.index===0}else{if(Pr(t))return t(e,0,[],{});if(B(t,"exec"))return t.exec(e,0,[],{});if(typeof t=="string")return t===e;throw Error("non exhaustive match")}}i(lE,"tryToMatchStrToPattern");function uE(e){return Ja([".","\\","[","]","|","^","$","(",")","?","*","+","{"],r=>e.source.indexOf(r)!==-1)===void 0}i(uE,"noMetaChar");function cE(e){return/(\(\?=)|(\(\?!)|(\(\?<=)|(\(\? property in its definition +`,type:be.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE}),B(e,so)||n.push({message:"A MultiMode Lexer cannot be initialized without a <"+so+`> property in its definition +`,type:be.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY}),B(e,so)&&B(e,Zi)&&!B(e.modes,e.defaultMode)&&n.push({message:`A MultiMode Lexer cannot be initialized with a ${Zi}: <${e.defaultMode}>which does not exist +`,type:be.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST}),B(e,so)&&K(e.modes,(a,s)=>{K(a,(o,l)=>{if(_r(o))n.push({message:`A Lexer cannot be initialized using an undefined Token Type. Mode:<${s}> at index: <${l}> +`,type:be.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED});else if(B(o,"LONGER_ALT")){const u=re(o.LONGER_ALT)?o.LONGER_ALT:[o.LONGER_ALT];K(u,c=>{!_r(c)&&!ut(a,c)&&n.push({message:`A MultiMode Lexer cannot be initialized with a longer_alt <${c.name}> on token <${o.name}> outside of mode <${s}> +`,type:be.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE})})}})}),n}i(fE,"performRuntimeChecks");function dE(e,t,r){const n=[];let a=!1;const s=Js(Ft(Me(e.modes))),o=du(s,u=>u[On]===at.NA),l=Zp(r);return t&&K(o,u=>{const c=Jp(u,l);if(c!==!1){const d={message:hE(u,c),type:c.issue,tokenType:u};n.push(d)}else B(u,"LINE_BREAKS")?u.LINE_BREAKS===!0&&(a=!0):mu(l,u.PATTERN)&&(a=!0)}),t&&!a&&n.push({message:`Warning: No LINE_BREAKS Found. + This Lexer has been defined to track line and column information, + But none of the Token Types can be identified as matching a line terminator. + See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS + for details.`,type:be.NO_LINE_BREAKS_FLAGS}),n}i(dE,"performWarningRuntimeChecks");function pE(e){const t={},r=$t(e);return K(r,n=>{const a=e[n];if(re(a))t[n]=[];else throw Error("non exhaustive match")}),t}i(pE,"cloneEmptyGroups");function Xp(e){const t=e.PATTERN;if(Cr(t))return!1;if(Pr(t))return!0;if(B(t,"exec"))return!0;if(mt(t))return!1;throw Error("non exhaustive match")}i(Xp,"isCustomPattern");function mE(e){return mt(e)&&e.length===1?e.charCodeAt(0):!1}i(mE,"isShortPattern");var PD={test:i(function(e){const t=e.length;for(let r=this.lastIndex;r Token Type + Root cause: ${t.errMsg}. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR`;if(t.issue===be.CUSTOM_LINE_BREAK)return`Warning: A Custom Token Pattern should specify the option. + The problem is in the <${e.name}> Token Type + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK`;throw Error("non exhaustive match")}i(hE,"buildLineBreakIssueMessage");function Zp(e){return F(e,r=>mt(r)?r.charCodeAt(0):r)}i(Zp,"getCharCodes");function Lo(e,t,r){e[t]===void 0?e[t]=[r]:e[t].push(r)}i(Lo,"addToMapOfArrays");var Qi=256,Do=[];function br(e){return e255?255+~~(e/255):e}}i(yE,"initCharCodeToOptimizedIndexMap");function si(e,t){const r=e.tokenTypeIdx;return r===t.tokenTypeIdx?!0:t.isParent===!0&&t.categoryMatchesMap[r]===!0}i(si,"tokenStructuredMatcher");function Ss(e,t){return e.tokenTypeIdx===t.tokenTypeIdx}i(Ss,"tokenStructuredMatcherNoCategories");var Wh=1,gE={};function oi(e){const t=vE(e);TE(t),RE(t),$E(t),K(t,r=>{r.isParent=r.categoryMatches.length>0})}i(oi,"augmentTokenTypes");function vE(e){let t=Ye(e),r=e,n=!0;for(;n;){r=Js(Ft(F(r,s=>s.CATEGORIES)));const a=fu(r,t);t=t.concat(a),me(a)?n=!1:r=a}return t}i(vE,"expandCategories");function TE(e){K(e,t=>{em(t)||(gE[Wh]=t,t.tokenTypeIdx=Wh++),kf(t)&&!re(t.CATEGORIES)&&(t.CATEGORIES=[t.CATEGORIES]),kf(t)||(t.CATEGORIES=[]),AE(t)||(t.categoryMatches=[]),EE(t)||(t.categoryMatchesMap={})})}i(TE,"assignTokenDefaultProps");function $E(e){K(e,t=>{t.categoryMatches=[],K(t.categoryMatchesMap,(r,n)=>{t.categoryMatches.push(gE[n].tokenTypeIdx)})})}i($E,"assignCategoriesTokensProp");function RE(e){K(e,t=>{Qp([],t)})}i(RE,"assignCategoriesMapProp");function Qp(e,t){K(e,r=>{t.categoryMatchesMap[r.tokenTypeIdx]=!0}),K(t.CATEGORIES,r=>{const n=e.concat(t);ut(n,r)||Qp(n,r)})}i(Qp,"singleAssignCategoriesToksMap");function em(e){return B(e,"tokenTypeIdx")}i(em,"hasShortKeyProperty");function kf(e){return B(e,"CATEGORIES")}i(kf,"hasCategoriesProperty");function AE(e){return B(e,"categoryMatches")}i(AE,"hasExtendingTokensTypesProperty");function EE(e){return B(e,"categoryMatchesMap")}i(EE,"hasExtendingTokensTypesMapProperty");function CE(e){return B(e,"tokenTypeIdx")}i(CE,"isTokenType");var Of={buildUnableToPopLexerModeMessage(e){return`Unable to pop Lexer Mode after encountering Token ->${e.image}<- The Mode Stack is empty`},buildUnexpectedCharactersMessage(e,t,r,n,a,s){return`unexpected character: ->${e.charAt(t)}<- at offset: ${t}, skipped ${r} characters.`}},be;(function(e){e[e.MISSING_PATTERN=0]="MISSING_PATTERN",e[e.INVALID_PATTERN=1]="INVALID_PATTERN",e[e.EOI_ANCHOR_FOUND=2]="EOI_ANCHOR_FOUND",e[e.UNSUPPORTED_FLAGS_FOUND=3]="UNSUPPORTED_FLAGS_FOUND",e[e.DUPLICATE_PATTERNS_FOUND=4]="DUPLICATE_PATTERNS_FOUND",e[e.INVALID_GROUP_TYPE_FOUND=5]="INVALID_GROUP_TYPE_FOUND",e[e.PUSH_MODE_DOES_NOT_EXIST=6]="PUSH_MODE_DOES_NOT_EXIST",e[e.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE=7]="MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE",e[e.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY=8]="MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY",e[e.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST=9]="MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST",e[e.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED=10]="LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED",e[e.SOI_ANCHOR_FOUND=11]="SOI_ANCHOR_FOUND",e[e.EMPTY_MATCH_PATTERN=12]="EMPTY_MATCH_PATTERN",e[e.NO_LINE_BREAKS_FLAGS=13]="NO_LINE_BREAKS_FLAGS",e[e.UNREACHABLE_PATTERN=14]="UNREACHABLE_PATTERN",e[e.IDENTIFY_TERMINATOR=15]="IDENTIFY_TERMINATOR",e[e.CUSTOM_LINE_BREAK=16]="CUSTOM_LINE_BREAK",e[e.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE=17]="MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE"})(be||(be={}));var es={deferDefinitionErrorsHandling:!1,positionTracking:"full",lineTerminatorsPattern:/\n|\r\n?/g,lineTerminatorCharacters:[` +`,"\r"],ensureOptimizations:!1,safeMode:!1,errorMessageProvider:Of,traceInitPerf:!1,skipValidations:!1,recoveryEnabled:!0};Object.freeze(es);var at=class{static{i(this,"Lexer")}constructor(e,t=es){if(this.lexerDefinition=e,this.lexerDefinitionErrors=[],this.lexerDefinitionWarning=[],this.patternIdxToConfig={},this.charCodeToPatternIdxToConfig={},this.modes=[],this.emptyGroups={},this.trackStartLines=!0,this.trackEndLines=!0,this.hasCustom=!1,this.canModeBeOptimized={},this.TRACE_INIT=(n,a)=>{if(this.traceInitPerf===!0){this.traceInitIndent++;const s=new Array(this.traceInitIndent+1).join(" ");this.traceInitIndent <${n}>`);const{time:o,value:l}=Hp(a),u=o>10?console.warn:console.log;return this.traceInitIndent time: ${o}ms`),this.traceInitIndent--,l}else return a()},typeof t=="boolean")throw Error(`The second argument to the Lexer constructor is now an ILexerConfig Object. +a boolean 2nd argument is no longer supported`);this.config=Rt({},es,t);const r=this.config.traceInitPerf;r===!0?(this.traceInitMaxIdent=1/0,this.traceInitPerf=!0):typeof r=="number"&&(this.traceInitMaxIdent=r,this.traceInitPerf=!0),this.traceInitIndent=-1,this.TRACE_INIT("Lexer Constructor",()=>{let n,a=!0;this.TRACE_INIT("Lexer Config handling",()=>{if(this.config.lineTerminatorsPattern===es.lineTerminatorsPattern)this.config.lineTerminatorsPattern=PD;else if(this.config.lineTerminatorCharacters===es.lineTerminatorCharacters)throw Error(`Error: Missing property on the Lexer config. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS`);if(t.safeMode&&t.ensureOptimizations)throw Error('"safeMode" and "ensureOptimizations" flags are mutually exclusive.');this.trackStartLines=/full|onlyStart/i.test(this.config.positionTracking),this.trackEndLines=/full/i.test(this.config.positionTracking),re(e)?n={modes:{defaultMode:Ye(e)},defaultMode:Zi}:(a=!1,n=Ye(e))}),this.config.skipValidations===!1&&(this.TRACE_INIT("performRuntimeChecks",()=>{this.lexerDefinitionErrors=this.lexerDefinitionErrors.concat(fE(n,this.trackStartLines,this.config.lineTerminatorCharacters))}),this.TRACE_INIT("performWarningRuntimeChecks",()=>{this.lexerDefinitionWarning=this.lexerDefinitionWarning.concat(dE(n,this.trackStartLines,this.config.lineTerminatorCharacters))})),n.modes=n.modes?n.modes:{},K(n.modes,(o,l)=>{n.modes[l]=du(o,u=>_r(u))});const s=$t(n.modes);if(K(n.modes,(o,l)=>{this.TRACE_INIT(`Mode: <${l}> processing`,()=>{if(this.modes.push(l),this.config.skipValidations===!1&&this.TRACE_INIT("validatePatterns",()=>{this.lexerDefinitionErrors=this.lexerDefinitionErrors.concat(XA(o,s))}),me(this.lexerDefinitionErrors)){oi(o);let u;this.TRACE_INIT("analyzeTokenTypes",()=>{u=YA(o,{lineTerminatorCharacters:this.config.lineTerminatorCharacters,positionTracking:t.positionTracking,ensureOptimizations:t.ensureOptimizations,safeMode:t.safeMode,tracer:this.TRACE_INIT})}),this.patternIdxToConfig[l]=u.patternIdxToConfig,this.charCodeToPatternIdxToConfig[l]=u.charCodeToPatternIdxToConfig,this.emptyGroups=Rt({},this.emptyGroups,u.emptyGroups),this.hasCustom=u.hasCustom||this.hasCustom,this.canModeBeOptimized[l]=u.canBeOptimized}})}),this.defaultMode=n.defaultMode,!me(this.lexerDefinitionErrors)&&!this.config.deferDefinitionErrorsHandling){const l=F(this.lexerDefinitionErrors,u=>u.message).join(`----------------------- +`);throw new Error(`Errors detected in definition of Lexer: +`+l)}K(this.lexerDefinitionWarning,o=>{qp(o.message)}),this.TRACE_INIT("Choosing sub-methods implementations",()=>{if(a&&(this.handleModes=Fe),this.trackStartLines===!1&&(this.computeNewColumn=Ws),this.trackEndLines===!1&&(this.updateTokenEndLineColumnLocation=Fe),/full/i.test(this.config.positionTracking))this.createTokenInstance=this.createFullToken;else if(/onlyStart/i.test(this.config.positionTracking))this.createTokenInstance=this.createStartOnlyToken;else if(/onlyOffset/i.test(this.config.positionTracking))this.createTokenInstance=this.createOffsetOnlyToken;else throw Error(`Invalid config option: "${this.config.positionTracking}"`);this.hasCustom?(this.addToken=this.addTokenUsingPush,this.handlePayload=this.handlePayloadWithCustom):(this.addToken=this.addTokenUsingMemberAccess,this.handlePayload=this.handlePayloadNoCustom)}),this.TRACE_INIT("Failed Optimization Warnings",()=>{const o=At(this.canModeBeOptimized,(l,u,c)=>(u===!1&&l.push(c),l),[]);if(t.ensureOptimizations&&!me(o))throw Error(`Lexer Modes: < ${o.join(", ")} > cannot be optimized. + Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode. + Or inspect the console log for details on how to resolve these issues.`)}),this.TRACE_INIT("clearRegExpParserCache",()=>{WA()}),this.TRACE_INIT("toFastProperties",()=>{Yp(this)})})}tokenize(e,t=this.defaultMode){if(!me(this.lexerDefinitionErrors)){const n=F(this.lexerDefinitionErrors,a=>a.message).join(`----------------------- +`);throw new Error(`Unable to Tokenize because Errors detected in definition of Lexer: +`+n)}return this.tokenizeInternal(e,t)}tokenizeInternal(e,t){let r,n,a,s,o,l,u,c,f,d,m,g,v,_,S;const w=e,I=w.length;let R=0,P=0;const z=this.hasCustom?0:Math.floor(e.length/10),X=new Array(z),Z=[];let ce=this.trackStartLines?1:void 0,se=this.trackStartLines?1:void 0;const Se=pE(this.emptyGroups),k=this.trackStartLines,C=this.config.lineTerminatorsPattern;let y=0,E=[],T=[];const $=[],b=[];Object.freeze(b);let O=!1;const x=i(Y=>{if($.length===1&&Y.tokenType.PUSH_MODE===void 0){const V=this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(Y);Z.push({offset:Y.startOffset,line:Y.startLine,column:Y.startColumn,length:Y.image.length,message:V})}else{$.pop();const V=kn($);E=this.patternIdxToConfig[V],T=this.charCodeToPatternIdxToConfig[V],y=E.length;const Pe=this.canModeBeOptimized[V]&&this.config.safeMode===!1;T&&Pe?O=!0:O=!1}},"pop_mode");function D(Y){$.push(Y),T=this.charCodeToPatternIdxToConfig[Y],E=this.patternIdxToConfig[Y],y=E.length,y=E.length;const V=this.canModeBeOptimized[Y]&&this.config.safeMode===!1;T&&V?O=!0:O=!1}i(D,"push_mode"),D.call(this,t);let G;const W=this.config.recoveryEnabled;for(;Rl.length){l=s,f=s.length,u=c,G=ke;break}}}break}}if(f!==-1){if(d=G.group,d!==void 0&&(l=l!==null?l:e.substring(R,R+f),m=G.tokenTypeIdx,g=this.createTokenInstance(l,R,m,G.tokenType,ce,se,f),this.handlePayload(g,u),d===!1?P=this.addToken(X,P,g):Se[d].push(g)),k===!0&&G.canLineTerminator===!0){let oe=0,Le,De;C.lastIndex=0;do l=l!==null?l:e.substring(R,R+f),Le=C.test(l),Le===!0&&(De=C.lastIndex-1,oe++);while(Le===!0);oe!==0?(ce=ce+oe,se=f-De,this.updateTokenEndLineColumnLocation(g,d,De,oe,ce,se,f)):se=this.computeNewColumn(se,f)}else se=this.computeNewColumn(se,f);R=R+f,this.handleModes(G,x,D,g)}else{const oe=R,Le=ce,De=se;let ke=W===!1;for(;ke===!1&&R ${In(e)} <--`:`token of type --> ${e.name} <--`} but found --> '${t.image}' <--`},buildNotAllInputParsedMessage({firstRedundant:e,ruleName:t}){return"Redundant input, expecting EOF but found: "+e.image},buildNoViableAltMessage({expectedPathsPerAlt:e,actual:t,previous:r,customUserDescription:n,ruleName:a}){const s="Expecting: ",l=` +but found: '`+Bt(t).image+"'";if(n)return s+n+l;{const u=At(e,(m,g)=>m.concat(g),[]),c=F(u,m=>`[${F(m,g=>In(g)).join(", ")}]`),d=`one of these possible Token sequences: +${F(c,(m,g)=>` ${g+1}. ${m}`).join(` +`)}`;return s+d+l}},buildEarlyExitMessage({expectedIterationPaths:e,actual:t,customUserDescription:r,ruleName:n}){const a="Expecting: ",o=` +but found: '`+Bt(t).image+"'";if(r)return a+r+o;{const u=`expecting at least one iteration which starts with one of these possible Token sequences:: + <${F(e,c=>`[${F(c,f=>In(f)).join(",")}]`).join(" ,")}>`;return a+u+o}}};Object.freeze(Ga);var OD={buildRuleNotFoundError(e,t){return"Invalid grammar, reference to a rule which is not defined: ->"+t.nonTerminalName+`<- +inside top level rule: ->`+e.name+"<-"}},bn={buildDuplicateFoundError(e,t){function r(f){return f instanceof ve?f.terminalType.name:f instanceof st?f.nonTerminalName:""}i(r,"getExtraProductionArgument");const n=e.name,a=Bt(t),s=a.idx,o=Dt(a),l=r(a),u=s>0;let c=`->${o}${u?s:""}<- ${l?`with argument: ->${l}<-`:""} + appears more than once (${t.length} times) in the top level rule: ->${n}<-. + For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES + `;return c=c.replace(/[ \t]+/g," "),c=c.replace(/\s\s+/g,` +`),c},buildNamespaceConflictError(e){return`Namespace conflict found in grammar. +The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${e.name}>. +To resolve this make sure each Terminal and Non-Terminal names are unique +This is easy to accomplish by using the convention that Terminal names start with an uppercase letter +and Non-Terminal names start with a lower case letter.`},buildAlternationPrefixAmbiguityError(e){const t=F(e.prefixPath,a=>In(a)).join(", "),r=e.alternation.idx===0?"":e.alternation.idx;return`Ambiguous alternatives: <${e.ambiguityIndices.join(" ,")}> due to common lookahead prefix +in inside <${e.topLevelRule.name}> Rule, +<${t}> may appears as a prefix path in all these alternatives. +See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX +For Further details.`},buildAlternationAmbiguityError(e){const t=e.alternation.idx===0?"":e.alternation.idx,r=e.prefixPath.length===0;let n=`Ambiguous Alternatives Detected: <${e.ambiguityIndices.join(" ,")}> in inside <${e.topLevelRule.name}> Rule, +`;if(r)n+=`These alternatives are all empty (match no tokens), making them indistinguishable. +Only the last alternative may be empty. +`;else{const a=F(e.prefixPath,s=>In(s)).join(", ");n+=`<${a}> may appears as a prefix path in all these alternatives. +`}return n+=`See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES +For Further details.`,n},buildEmptyRepetitionError(e){let t=Dt(e.repetition);return e.repetition.idx!==0&&(t+=e.repetition.idx),`The repetition <${t}> within Rule <${e.topLevelRule.name}> can never consume any tokens. +This could lead to an infinite loop.`},buildTokenNameError(e){return"deprecated"},buildEmptyAlternationError(e){return`Ambiguous empty alternative: <${e.emptyChoiceIdx+1}> in inside <${e.topLevelRule.name}> Rule. +Only the last alternative may be an empty alternative.`},buildTooManyAlternativesError(e){return`An Alternation cannot have more than 256 alternatives: + inside <${e.topLevelRule.name}> Rule. + has ${e.alternation.definition.length+1} alternatives.`},buildLeftRecursionError(e){const t=e.topLevelRule.name,r=F(e.leftRecursionPath,s=>s.name),n=`${t} --> ${r.concat([t]).join(" --> ")}`;return`Left Recursion found in grammar. +rule: <${t}> can be invoked from itself (directly or indirectly) +without consuming any Tokens. The grammar path that causes this is: + ${n} + To fix this refactor your grammar to remove the left recursion. +see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`},buildInvalidRuleNameError(e){return"deprecated"},buildDuplicateRuleNameError(e){let t;return e.topLevelRule instanceof ni?t=e.topLevelRule.name:t=e.topLevelRule,`Duplicate definition, rule: ->${t}<- is already defined in the grammar: ->${e.grammarName}<-`}};function bE(e,t){const r=new LD(e,t);return r.resolveRefs(),r.errors}i(bE,"resolveGrammar");var LD=class extends ai{static{i(this,"GastRefResolverVisitor")}constructor(e,t){super(),this.nameToTopRule=e,this.errMsgProvider=t,this.errors=[]}resolveRefs(){K(Me(this.nameToTopRule),e=>{this.currTopLevel=e,e.accept(this)})}visitNonTerminal(e){const t=this.nameToTopRule[e.nonTerminalName];if(t)e.referencedRule=t;else{const r=this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel,e);this.errors.push({message:r,type:ot.UNRESOLVED_SUBRULE_REF,ruleName:this.currTopLevel.name,unresolvedRefName:e.nonTerminalName})}}},DD=class extends pu{static{i(this,"AbstractNextPossibleTokensWalker")}constructor(e,t){super(),this.topProd=e,this.path=t,this.possibleTokTypes=[],this.nextProductionName="",this.nextProductionOccurrence=0,this.found=!1,this.isAtEndOfPath=!1}startWalking(){if(this.found=!1,this.path.ruleStack[0]!==this.topProd.name)throw Error("The path does not start with the walker's top Rule!");return this.ruleStack=Ye(this.path.ruleStack).reverse(),this.occurrenceStack=Ye(this.path.occurrenceStack).reverse(),this.ruleStack.pop(),this.occurrenceStack.pop(),this.updateExpectedNext(),this.walk(this.topProd),this.possibleTokTypes}walk(e,t=[]){this.found||super.walk(e,t)}walkProdRef(e,t,r){if(e.referencedRule.name===this.nextProductionName&&e.idx===this.nextProductionOccurrence){const n=t.concat(r);this.updateExpectedNext(),this.walk(e.referencedRule,n)}}updateExpectedNext(){me(this.ruleStack)?(this.nextProductionName="",this.nextProductionOccurrence=0,this.isAtEndOfPath=!0):(this.nextProductionName=this.ruleStack.pop(),this.nextProductionOccurrence=this.occurrenceStack.pop())}},xD=class extends DD{static{i(this,"NextAfterTokenWalker")}constructor(e,t){super(e,t),this.path=t,this.nextTerminalName="",this.nextTerminalOccurrence=0,this.nextTerminalName=this.path.lastTok.name,this.nextTerminalOccurrence=this.path.lastTokOccurrence}walkTerminal(e,t,r){if(this.isAtEndOfPath&&e.terminalType.name===this.nextTerminalName&&e.idx===this.nextTerminalOccurrence&&!this.found){const n=t.concat(r),a=new ht({definition:n});this.possibleTokTypes=ii(a),this.found=!0}}},hu=class extends pu{static{i(this,"AbstractNextTerminalAfterProductionWalker")}constructor(e,t){super(),this.topRule=e,this.occurrence=t,this.result={token:void 0,occurrence:void 0,isEndOfRule:void 0}}startWalking(){return this.walk(this.topRule),this.result}},MD=class extends hu{static{i(this,"NextTerminalAfterManyWalker")}walkMany(e,t,r){if(e.idx===this.occurrence){const n=Bt(t.concat(r));this.result.isEndOfRule=n===void 0,n instanceof ve&&(this.result.token=n.terminalType,this.result.occurrence=n.idx)}else super.walkMany(e,t,r)}},ey=class extends hu{static{i(this,"NextTerminalAfterManySepWalker")}walkManySep(e,t,r){if(e.idx===this.occurrence){const n=Bt(t.concat(r));this.result.isEndOfRule=n===void 0,n instanceof ve&&(this.result.token=n.terminalType,this.result.occurrence=n.idx)}else super.walkManySep(e,t,r)}},GD=class extends hu{static{i(this,"NextTerminalAfterAtLeastOneWalker")}walkAtLeastOne(e,t,r){if(e.idx===this.occurrence){const n=Bt(t.concat(r));this.result.isEndOfRule=n===void 0,n instanceof ve&&(this.result.token=n.terminalType,this.result.occurrence=n.idx)}else super.walkAtLeastOne(e,t,r)}},ty=class extends hu{static{i(this,"NextTerminalAfterAtLeastOneSepWalker")}walkAtLeastOneSep(e,t,r){if(e.idx===this.occurrence){const n=Bt(t.concat(r));this.result.isEndOfRule=n===void 0,n instanceof ve&&(this.result.token=n.terminalType,this.result.occurrence=n.idx)}else super.walkAtLeastOneSep(e,t,r)}};function Tl(e,t,r=[]){r=Ye(r);let n=[],a=0;function s(l){return l.concat(qe(e,a+1))}i(s,"remainingPathWith");function o(l){const u=Tl(s(l),t,r);return n.concat(u)}for(i(o,"getAlternativesForProd");r.length{me(u.definition)===!1&&(n=o(u.definition))}),n;if(l instanceof ve)r.push(l.terminalType);else throw Error("non exhaustive match")}a++}return n.push({partialPath:r,suffixDef:qe(e,a)}),n}i(Tl,"possiblePathsFrom");function nm(e,t,r,n){const a="EXIT_NONE_TERMINAL",s=[a],o="EXIT_ALTERNATIVE";let l=!1;const u=t.length,c=u-n-1,f=[],d=[];for(d.push({idx:-1,def:e,ruleStack:[],occurrenceStack:[]});!me(d);){const m=d.pop();if(m===o){l&&kn(d).idx<=c&&d.pop();continue}const g=m.def,v=m.idx,_=m.ruleStack,S=m.occurrenceStack;if(me(g))continue;const w=g[0];if(w===a){const I={idx:v,def:qe(g),ruleStack:_s(_),occurrenceStack:_s(S)};d.push(I)}else if(w instanceof ve)if(v=0;I--){const R=w.definition[I],P={idx:v,def:R.definition.concat(qe(g)),ruleStack:_,occurrenceStack:S};d.push(P),d.push(o)}else if(w instanceof ht)d.push({idx:v,def:w.definition.concat(qe(g)),ruleStack:_,occurrenceStack:S});else if(w instanceof ni)d.push(SE(w,v,_,S));else throw Error("non exhaustive match")}return f}i(nm,"nextPossibleTokensAfter");function SE(e,t,r,n){const a=Ye(r);a.push(e.name);const s=Ye(n);return s.push(1),{idx:t,def:e.definition,ruleStack:a,occurrenceStack:s}}i(SE,"expandTopLevelRule");var Re;(function(e){e[e.OPTION=0]="OPTION",e[e.REPETITION=1]="REPETITION",e[e.REPETITION_MANDATORY=2]="REPETITION_MANDATORY",e[e.REPETITION_MANDATORY_WITH_SEPARATOR=3]="REPETITION_MANDATORY_WITH_SEPARATOR",e[e.REPETITION_WITH_SEPARATOR=4]="REPETITION_WITH_SEPARATOR",e[e.ALTERNATION=5]="ALTERNATION"})(Re||(Re={}));function yu(e){if(e instanceof He||e==="Option")return Re.OPTION;if(e instanceof _e||e==="Repetition")return Re.REPETITION;if(e instanceof Et||e==="RepetitionMandatory")return Re.REPETITION_MANDATORY;if(e instanceof Ct||e==="RepetitionMandatoryWithSeparator")return Re.REPETITION_MANDATORY_WITH_SEPARATOR;if(e instanceof yt||e==="RepetitionWithSeparator")return Re.REPETITION_WITH_SEPARATOR;if(e instanceof gt||e==="Alternation")return Re.ALTERNATION;throw Error("non exhaustive match")}i(yu,"getProdType");function Lf(e){const{occurrence:t,rule:r,prodType:n,maxLookahead:a}=e,s=yu(n);return s===Re.ALTERNATION?eo(t,r,a):to(t,r,s,a)}i(Lf,"getLookaheadPaths");function wE(e,t,r,n,a,s){const o=eo(e,t,r),l=im(o)?Ss:si;return s(o,n,l,a)}i(wE,"buildLookaheadFuncForOr");function IE(e,t,r,n,a,s){const o=to(e,t,a,r),l=im(o)?Ss:si;return s(o[0],l,n)}i(IE,"buildLookaheadFuncForOptionalProd");function NE(e,t,r,n){const a=e.length,s=zt(e,o=>zt(o,l=>l.length===1));if(t)return function(o){const l=F(o,u=>u.GATE);for(let u=0;uFt(u)),l=At(o,(u,c,f)=>(K(c,d=>{B(u,d.tokenTypeIdx)||(u[d.tokenTypeIdx]=f),K(d.categoryMatches,m=>{B(u,m)||(u[m]=f)})}),u),{});return function(){const u=this.LA(1);return l[u.tokenTypeIdx]}}else return function(){for(let o=0;os.length===1),a=e.length;if(n&&!r){const s=Ft(e);if(s.length===1&&me(s[0].categoryMatches)){const l=s[0].tokenTypeIdx;return function(){return this.LA(1).tokenTypeIdx===l}}else{const o=At(s,(l,u,c)=>(l[u.tokenTypeIdx]=!0,K(u.categoryMatches,f=>{l[f]=!0}),l),[]);return function(){const l=this.LA(1);return o[l.tokenTypeIdx]===!0}}}else return function(){e:for(let s=0;sTl([o],1)),n=Df(r.length),a=F(r,o=>{const l={};return K(o,u=>{const c=xo(u.partialPath);K(c,f=>{l[f]=!0})}),l});let s=r;for(let o=1;o<=t;o++){const l=s;s=Df(l.length);for(let u=0;u{const w=xo(S.partialPath);K(w,I=>{a[u][I]=!0})})}}}}return n}i(am,"lookAheadSequenceFromAlternatives");function eo(e,t,r,n){const a=new kE(e,Re.ALTERNATION,n);return t.accept(a),am(a.result,r)}i(eo,"getLookaheadPathsForOr");function to(e,t,r,n){const a=new kE(e,r);t.accept(a);const s=a.result,l=new FD(t,e,r).startWalking(),u=new ht({definition:s}),c=new ht({definition:l});return am([u,c],n)}i(to,"getLookaheadPathsForOptionalProd");function $l(e,t){e:for(let r=0;r{const a=t[n];return r===a||a.categoryMatchesMap[r.tokenTypeIdx]})}i(LE,"isStrictPrefixOfPath");function im(e){return zt(e,t=>zt(t,r=>zt(r,n=>me(n.categoryMatches))))}i(im,"areTokenCategoriesNotUsed");function DE(e){const t=e.lookaheadStrategy.validate({rules:e.rules,tokenTypes:e.tokenTypes,grammarName:e.grammarName});return F(t,r=>Object.assign({type:ot.CUSTOM_LOOKAHEAD_VALIDATION},r))}i(DE,"validateLookahead");function xE(e,t,r,n){const a=St(e,u=>ME(u,r)),s=qE(e,t,r),o=St(e,u=>UE(u,r)),l=St(e,u=>FE(u,e,n,r));return a.concat(s,o,l)}i(xE,"validateGrammar");function ME(e,t){const r=new zD;e.accept(r);const n=r.allProductions,a=eD(n,GE),s=Ut(a,l=>l.length>1);return F(Me(s),l=>{const u=Bt(l),c=t.buildDuplicateFoundError(e,l),f=Dt(u),d={message:c,type:ot.DUPLICATE_PRODUCTIONS,ruleName:e.name,dslName:f,occurrence:u.idx},m=sm(u);return m&&(d.parameter=m),d})}i(ME,"validateDuplicateProductions");function GE(e){return`${Dt(e)}_#_${e.idx}_#_${sm(e)}`}i(GE,"identifyProductionForDuplicates");function sm(e){return e instanceof ve?e.terminalType.name:e instanceof st?e.nonTerminalName:""}i(sm,"getExtraProductionArgument");var zD=class extends ai{static{i(this,"OccurrenceValidationCollector")}constructor(){super(...arguments),this.allProductions=[]}visitNonTerminal(e){this.allProductions.push(e)}visitOption(e){this.allProductions.push(e)}visitRepetitionWithSeparator(e){this.allProductions.push(e)}visitRepetitionMandatory(e){this.allProductions.push(e)}visitRepetitionMandatoryWithSeparator(e){this.allProductions.push(e)}visitRepetition(e){this.allProductions.push(e)}visitAlternation(e){this.allProductions.push(e)}visitTerminal(e){this.allProductions.push(e)}};function FE(e,t,r,n){const a=[];if(At(t,(o,l)=>l.name===e.name?o+1:o,0)>1){const o=n.buildDuplicateRuleNameError({topLevelRule:e,grammarName:r});a.push({message:o,type:ot.DUPLICATE_RULE_NAME,ruleName:e.name})}return a}i(FE,"validateRuleDoesNotAlreadyExist");function zE(e,t,r){const n=[];let a;return ut(t,e)||(a=`Invalid rule override, rule: ->${e}<- cannot be overridden in the grammar: ->${r}<-as it is not defined in any of the super grammars `,n.push({message:a,type:ot.INVALID_RULE_OVERRIDE,ruleName:e})),n}i(zE,"validateRuleIsOverridden");function om(e,t,r,n=[]){const a=[],s=hs(t.definition);if(me(s))return[];{const o=e.name;ut(s,e)&&a.push({message:r.buildLeftRecursionError({topLevelRule:e,leftRecursionPath:n}),type:ot.LEFT_RECURSION,ruleName:o});const u=fu(s,n.concat([e])),c=St(u,f=>{const d=Ye(n);return d.push(f),om(e,f,r,d)});return a.concat(c)}}i(om,"validateNoLeftRecursion");function hs(e){let t=[];if(me(e))return t;const r=Bt(e);if(r instanceof st)t.push(r.referencedRule);else if(r instanceof ht||r instanceof He||r instanceof Et||r instanceof Ct||r instanceof yt||r instanceof _e)t=t.concat(hs(r.definition));else if(r instanceof gt)t=Ft(F(r.definition,s=>hs(s.definition)));else if(!(r instanceof ve))throw Error("non exhaustive match");const n=bs(r),a=e.length>1;if(n&&a){const s=qe(e);return t.concat(hs(s))}else return t}i(hs,"getFirstNoneTerminal");var lm=class extends ai{static{i(this,"OrCollector")}constructor(){super(...arguments),this.alternations=[]}visitAlternation(e){this.alternations.push(e)}};function jE(e,t){const r=new lm;e.accept(r);const n=r.alternations;return St(n,s=>{const o=_s(s.definition);return St(o,(l,u)=>{const c=nm([l],[],si,1);return me(c)?[{message:t.buildEmptyAlternationError({topLevelRule:e,alternation:s,emptyChoiceIdx:u}),type:ot.NONE_LAST_EMPTY_ALT,ruleName:e.name,occurrence:s.idx,alternative:u+1}]:[]})})}i(jE,"validateEmptyOrAlternative");function BE(e,t,r){const n=new lm;e.accept(n);let a=n.alternations;return a=du(a,o=>o.ignoreAmbiguities===!0),St(a,o=>{const l=o.idx,u=o.maxLookahead||t,c=eo(l,e,u,o),f=WE(c,o,e,r),d=VE(c,o,e,r);return f.concat(d)})}i(BE,"validateAmbiguousAlternationAlternatives");var jD=class extends ai{static{i(this,"RepetitionCollector")}constructor(){super(...arguments),this.allProductions=[]}visitRepetitionWithSeparator(e){this.allProductions.push(e)}visitRepetitionMandatory(e){this.allProductions.push(e)}visitRepetitionMandatoryWithSeparator(e){this.allProductions.push(e)}visitRepetition(e){this.allProductions.push(e)}};function UE(e,t){const r=new lm;e.accept(r);const n=r.alternations;return St(n,s=>s.definition.length>255?[{message:t.buildTooManyAlternativesError({topLevelRule:e,alternation:s}),type:ot.TOO_MANY_ALTS,ruleName:e.name,occurrence:s.idx}]:[])}i(UE,"validateTooManyAlts");function KE(e,t,r){const n=[];return K(e,a=>{const s=new jD;a.accept(s);const o=s.allProductions;K(o,l=>{const u=yu(l),c=l.maxLookahead||t,f=l.idx,m=to(f,a,u,c)[0];if(me(Ft(m))){const g=r.buildEmptyRepetitionError({topLevelRule:a,repetition:l});n.push({message:g,type:ot.NO_NON_EMPTY_LOOKAHEAD,ruleName:a.name})}})}),n}i(KE,"validateSomeNonEmptyLookaheadPath");function WE(e,t,r,n){const a=[],s=At(e,(l,u,c)=>(t.definition[c].ignoreAmbiguities===!0||K(u,f=>{const d=[c];K(e,(m,g)=>{c!==g&&$l(m,f)&&t.definition[g].ignoreAmbiguities!==!0&&d.push(g)}),d.length>1&&!$l(a,f)&&(a.push(f),l.push({alts:d,path:f}))}),l),[]);return F(s,l=>{const u=F(l.alts,f=>f+1);return{message:n.buildAlternationAmbiguityError({topLevelRule:r,alternation:t,ambiguityIndices:u,prefixPath:l.path}),type:ot.AMBIGUOUS_ALTS,ruleName:r.name,occurrence:t.idx,alternatives:l.alts}})}i(WE,"checkAlternativesAmbiguities");function VE(e,t,r,n){const a=At(e,(o,l,u)=>{const c=F(l,f=>({idx:u,path:f}));return o.concat(c)},[]);return Js(St(a,o=>{if(t.definition[o.idx].ignoreAmbiguities===!0)return[];const u=o.idx,c=o.path,f=Pt(a,m=>t.definition[m.idx].ignoreAmbiguities!==!0&&m.idx{const g=[m.idx+1,u+1],v=t.idx===0?"":t.idx;return{message:n.buildAlternationPrefixAmbiguityError({topLevelRule:r,alternation:t,ambiguityIndices:g,prefixPath:m.path}),type:ot.AMBIGUOUS_PREFIX_ALTS,ruleName:r.name,occurrence:v,alternatives:g}})}))}i(VE,"checkPrefixAlternativesAmbiguities");function qE(e,t,r){const n=[],a=F(t,s=>s.name);return K(e,s=>{const o=s.name;if(ut(a,o)){const l=r.buildNamespaceConflictError(s);n.push({message:l,type:ot.CONFLICT_TOKENS_RULES_NAMESPACE,ruleName:o})}}),n}i(qE,"checkTerminalAndNoneTerminalsNameSpace");function HE(e){const t=Wp(e,{errMsgProvider:OD}),r={};return K(e.rules,n=>{r[n.name]=n}),bE(r,t.errMsgProvider)}i(HE,"resolveGrammar");function YE(e){return e=Wp(e,{errMsgProvider:bn}),xE(e.rules,e.tokenTypes,e.errMsgProvider,e.grammarName)}i(YE,"validateGrammar");var XE="MismatchedTokenException",JE="NoViableAltException",ZE="EarlyExitException",QE="NotAllInputParsedException",eC=[XE,JE,ZE,QE];Object.freeze(eC);function ws(e){return ut(eC,e.name)}i(ws,"isRecognitionException");var gu=class extends Error{static{i(this,"RecognitionException")}constructor(e,t){super(e),this.token=t,this.resyncedTokens=[],Object.setPrototypeOf(this,new.target.prototype),Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}},tC=class extends gu{static{i(this,"MismatchedTokenException")}constructor(e,t,r){super(e,t),this.previousToken=r,this.name=XE}},BD=class extends gu{static{i(this,"NoViableAltException")}constructor(e,t,r){super(e,t),this.previousToken=r,this.name=JE}},UD=class extends gu{static{i(this,"NotAllInputParsedException")}constructor(e,t){super(e,t),this.name=QE}},KD=class extends gu{static{i(this,"EarlyExitException")}constructor(e,t,r){super(e,t),this.previousToken=r,this.name=ZE}},Hu={},rC="InRuleRecoveryException",WD=class extends Error{static{i(this,"InRuleRecoveryException")}constructor(e){super(e),this.name=rC}},VD=class{static{i(this,"Recoverable")}initRecoverable(e){this.firstAfterRepMap={},this.resyncFollows={},this.recoveryEnabled=B(e,"recoveryEnabled")?e.recoveryEnabled:Sr.recoveryEnabled,this.recoveryEnabled&&(this.attemptInRepetitionRecovery=nC)}getTokenToInsert(e){const t=Qs(e,"",NaN,NaN,NaN,NaN,NaN,NaN);return t.isInsertedInRecovery=!0,t}canTokenTypeBeInsertedInRecovery(e){return!0}canTokenTypeBeDeletedInRecovery(e){return!0}tryInRepetitionRecovery(e,t,r,n){const a=this.findReSyncTokenType(),s=this.exportLexerState(),o=[];let l=!1;const u=this.LA(1);let c=this.LA(1);const f=i(()=>{const d=this.LA(0),m=this.errorMessageProvider.buildMismatchTokenMessage({expected:n,actual:u,previous:d,ruleName:this.getCurrRuleFullName()}),g=new tC(m,u,this.LA(0));g.resyncedTokens=_s(o),this.SAVE_ERROR(g)},"generateErrorMessage");for(;!l;)if(this.tokenMatcher(c,n)){f();return}else if(r.call(this)){f(),e.apply(this,t);return}else this.tokenMatcher(c,a)?l=!0:(c=this.SKIP_TOKEN(),this.addToResyncTokens(c,o));this.importLexerState(s)}shouldInRepetitionRecoveryBeTried(e,t,r){return!(r===!1||this.tokenMatcher(this.LA(1),e)||this.isBackTracking()||this.canPerformInRuleRecovery(e,this.getFollowsForInRuleRecovery(e,t)))}getFollowsForInRuleRecovery(e,t){const r=this.getCurrentGrammarPath(e,t);return this.getNextPossibleTokenTypes(r)}tryInRuleRecovery(e,t){if(this.canRecoverWithSingleTokenInsertion(e,t))return this.getTokenToInsert(e);if(this.canRecoverWithSingleTokenDeletion(e)){const r=this.SKIP_TOKEN();return this.consumeToken(),r}throw new WD("sad sad panda")}canPerformInRuleRecovery(e,t){return this.canRecoverWithSingleTokenInsertion(e,t)||this.canRecoverWithSingleTokenDeletion(e)}canRecoverWithSingleTokenInsertion(e,t){if(!this.canTokenTypeBeInsertedInRecovery(e)||me(t))return!1;const r=this.LA(1);return Ja(t,a=>this.tokenMatcher(r,a))!==void 0}canRecoverWithSingleTokenDeletion(e){return this.canTokenTypeBeDeletedInRecovery(e)?this.tokenMatcher(this.LA(2),e):!1}isInCurrentRuleReSyncSet(e){const t=this.getCurrFollowKey(),r=this.getFollowSetFromFollowKey(t);return ut(r,e)}findReSyncTokenType(){const e=this.flattenFollowSet();let t=this.LA(1),r=2;for(;;){const n=Ja(e,a=>rm(t,a));if(n!==void 0)return n;t=this.LA(r),r++}}getCurrFollowKey(){if(this.RULE_STACK.length===1)return Hu;const e=this.getLastExplicitRuleShortName(),t=this.getLastExplicitRuleOccurrenceIndex(),r=this.getPreviousExplicitRuleShortName();return{ruleName:this.shortRuleNameToFullName(e),idxInCallingRule:t,inRule:this.shortRuleNameToFullName(r)}}buildFullFollowKeyStack(){const e=this.RULE_STACK,t=this.RULE_OCCURRENCE_STACK;return F(e,(r,n)=>n===0?Hu:{ruleName:this.shortRuleNameToFullName(r),idxInCallingRule:t[n],inRule:this.shortRuleNameToFullName(e[n-1])})}flattenFollowSet(){const e=F(this.buildFullFollowKeyStack(),t=>this.getFollowSetFromFollowKey(t));return Ft(e)}getFollowSetFromFollowKey(e){if(e===Hu)return[Ur];const t=e.ruleName+e.idxInCallingRule+BA+e.inRule;return this.resyncFollows[t]}addToResyncTokens(e,t){return this.tokenMatcher(e,Ur)||t.push(e),t}reSyncTo(e){const t=[];let r=this.LA(1);for(;this.tokenMatcher(r,e)===!1;)r=this.SKIP_TOKEN(),this.addToResyncTokens(r,t);return _s(t)}attemptInRepetitionRecovery(e,t,r,n,a,s,o){}getCurrentGrammarPath(e,t){const r=this.getHumanReadableRuleStack(),n=Ye(this.RULE_OCCURRENCE_STACK);return{ruleStack:r,occurrenceStack:n,lastTok:e,lastTokOccurrence:t}}getHumanReadableRuleStack(){return F(this.RULE_STACK,e=>this.shortRuleNameToFullName(e))}};function nC(e,t,r,n,a,s,o){const l=this.getKeyForAutomaticLookahead(n,a);let u=this.firstAfterRepMap[l];if(u===void 0){const m=this.getCurrRuleFullName(),g=this.getGAstProductions()[m];u=new s(g,a).startWalking(),this.firstAfterRepMap[l]=u}let c=u.token,f=u.occurrence;const d=u.isEndOfRule;this.RULE_STACK.length===1&&d&&c===void 0&&(c=Ur,f=1),!(c===void 0||f===void 0)&&this.shouldInRepetitionRecoveryBeTried(c,f,o)&&this.tryInRepetitionRecovery(e,t,r,c)}i(nC,"attemptInRepetitionRecovery");var qD=4,Yr=8,aC=1<om(t,t,bn))}validateEmptyOrAlternatives(e){return St(e,t=>jE(t,bn))}validateAmbiguousAlternationAlternatives(e,t){return St(e,r=>BE(r,t,bn))}validateSomeNonEmptyLookaheadPath(e,t){return KE(e,t,bn)}buildLookaheadForAlternation(e){return wE(e.prodOccurrence,e.rule,e.maxLookahead,e.hasPredicates,e.dynamicTokensEnabled,NE)}buildLookaheadForOptional(e){return IE(e.prodOccurrence,e.rule,e.maxLookahead,e.dynamicTokensEnabled,yu(e.prodType),PE)}},HD=class{static{i(this,"LooksAhead")}initLooksAhead(e){this.dynamicTokensEnabled=B(e,"dynamicTokensEnabled")?e.dynamicTokensEnabled:Sr.dynamicTokensEnabled,this.maxLookahead=B(e,"maxLookahead")?e.maxLookahead:Sr.maxLookahead,this.lookaheadStrategy=B(e,"lookaheadStrategy")?e.lookaheadStrategy:new um({maxLookahead:this.maxLookahead}),this.lookAheadFuncsCache=new Map}preComputeLookaheadFunctions(e){K(e,t=>{this.TRACE_INIT(`${t.name} Rule Lookahead`,()=>{const{alternation:r,repetition:n,option:a,repetitionMandatory:s,repetitionMandatoryWithSeparator:o,repetitionWithSeparator:l}=sC(t);K(r,u=>{const c=u.idx===0?"":u.idx;this.TRACE_INIT(`${Dt(u)}${c}`,()=>{const f=this.lookaheadStrategy.buildLookaheadForAlternation({prodOccurrence:u.idx,rule:t,maxLookahead:u.maxLookahead||this.maxLookahead,hasPredicates:u.hasPredicates,dynamicTokensEnabled:this.dynamicTokensEnabled}),d=Go(this.fullRuleNameToShort[t.name],aC,u.idx);this.setLaFuncCache(d,f)})}),K(n,u=>{this.computeLookaheadFunc(t,u.idx,xf,"Repetition",u.maxLookahead,Dt(u))}),K(a,u=>{this.computeLookaheadFunc(t,u.idx,iC,"Option",u.maxLookahead,Dt(u))}),K(s,u=>{this.computeLookaheadFunc(t,u.idx,Mf,"RepetitionMandatory",u.maxLookahead,Dt(u))}),K(o,u=>{this.computeLookaheadFunc(t,u.idx,Mo,"RepetitionMandatoryWithSeparator",u.maxLookahead,Dt(u))}),K(l,u=>{this.computeLookaheadFunc(t,u.idx,Gf,"RepetitionWithSeparator",u.maxLookahead,Dt(u))})})})}computeLookaheadFunc(e,t,r,n,a,s){this.TRACE_INIT(`${s}${t===0?"":t}`,()=>{const o=this.lookaheadStrategy.buildLookaheadForOptional({prodOccurrence:t,rule:e,maxLookahead:a||this.maxLookahead,dynamicTokensEnabled:this.dynamicTokensEnabled,prodType:n}),l=Go(this.fullRuleNameToShort[e.name],r,t);this.setLaFuncCache(l,o)})}getKeyForAutomaticLookahead(e,t){const r=this.getLastExplicitRuleShortName();return Go(r,e,t)}getLaFuncFromCache(e){return this.lookAheadFuncsCache.get(e)}setLaFuncCache(e,t){this.lookAheadFuncsCache.set(e,t)}},YD=class extends ai{static{i(this,"DslMethodsCollectorVisitor")}constructor(){super(...arguments),this.dslMethods={option:[],alternation:[],repetition:[],repetitionWithSeparator:[],repetitionMandatory:[],repetitionMandatoryWithSeparator:[]}}reset(){this.dslMethods={option:[],alternation:[],repetition:[],repetitionWithSeparator:[],repetitionMandatory:[],repetitionMandatoryWithSeparator:[]}}visitOption(e){this.dslMethods.option.push(e)}visitRepetitionWithSeparator(e){this.dslMethods.repetitionWithSeparator.push(e)}visitRepetitionMandatory(e){this.dslMethods.repetitionMandatory.push(e)}visitRepetitionMandatoryWithSeparator(e){this.dslMethods.repetitionMandatoryWithSeparator.push(e)}visitRepetition(e){this.dslMethods.repetition.push(e)}visitAlternation(e){this.dslMethods.alternation.push(e)}},oo=new YD;function sC(e){oo.reset(),e.accept(oo);const t=oo.dslMethods;return oo.reset(),t}i(sC,"collectMethods");function Ff(e,t){isNaN(e.startOffset)===!0?(e.startOffset=t.startOffset,e.endOffset=t.endOffset):e.endOffseto.msg);throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>: + ${s.join(` + +`).replace(/\n/g,` + `)}`)}},"validateVisitor")};return r.prototype=n,r.prototype.constructor=r,r._RULE_NAMES=t,r}i(cC,"createBaseSemanticVisitorConstructor");function fC(e,t,r){const n=i(function(){},"derivedConstructor");cm(n,e+"BaseSemanticsWithDefaults");const a=Object.create(r.prototype);return K(t,s=>{a[s]=uC}),n.prototype=a,n.prototype.constructor=n,n}i(fC,"createBaseVisitorConstructorWithDefaults");var jf;(function(e){e[e.REDUNDANT_METHOD=0]="REDUNDANT_METHOD",e[e.MISSING_METHOD=1]="MISSING_METHOD"})(jf||(jf={}));function dC(e,t){return pC(e,t)}i(dC,"validateVisitor");function pC(e,t){const r=Pt(t,a=>Pr(e[a])===!1),n=F(r,a=>({msg:`Missing visitor method: <${a}> on ${e.constructor.name} CST Visitor.`,type:jf.MISSING_METHOD,methodName:a}));return Js(n)}i(pC,"validateMissingCstMethods");var JD=class{static{i(this,"TreeBuilder")}initTreeBuilder(e){if(this.CST_STACK=[],this.outputCst=e.outputCst,this.nodeLocationTracking=B(e,"nodeLocationTracking")?e.nodeLocationTracking:Sr.nodeLocationTracking,!this.outputCst)this.cstInvocationStateUpdate=Fe,this.cstFinallyStateUpdate=Fe,this.cstPostTerminal=Fe,this.cstPostNonTerminal=Fe,this.cstPostRule=Fe;else if(/full/i.test(this.nodeLocationTracking))this.recoveryEnabled?(this.setNodeLocationFromToken=zf,this.setNodeLocationFromNode=zf,this.cstPostRule=Fe,this.setInitialNodeLocation=this.setInitialNodeLocationFullRecovery):(this.setNodeLocationFromToken=Fe,this.setNodeLocationFromNode=Fe,this.cstPostRule=this.cstPostRuleFull,this.setInitialNodeLocation=this.setInitialNodeLocationFullRegular);else if(/onlyOffset/i.test(this.nodeLocationTracking))this.recoveryEnabled?(this.setNodeLocationFromToken=Ff,this.setNodeLocationFromNode=Ff,this.cstPostRule=Fe,this.setInitialNodeLocation=this.setInitialNodeLocationOnlyOffsetRecovery):(this.setNodeLocationFromToken=Fe,this.setNodeLocationFromNode=Fe,this.cstPostRule=this.cstPostRuleOnlyOffset,this.setInitialNodeLocation=this.setInitialNodeLocationOnlyOffsetRegular);else if(/none/i.test(this.nodeLocationTracking))this.setNodeLocationFromToken=Fe,this.setNodeLocationFromNode=Fe,this.cstPostRule=Fe,this.setInitialNodeLocation=Fe;else throw Error(`Invalid config option: "${e.nodeLocationTracking}"`)}setInitialNodeLocationOnlyOffsetRecovery(e){e.location={startOffset:NaN,endOffset:NaN}}setInitialNodeLocationOnlyOffsetRegular(e){e.location={startOffset:this.LA(1).startOffset,endOffset:NaN}}setInitialNodeLocationFullRecovery(e){e.location={startOffset:NaN,startLine:NaN,startColumn:NaN,endOffset:NaN,endLine:NaN,endColumn:NaN}}setInitialNodeLocationFullRegular(e){const t=this.LA(1);e.location={startOffset:t.startOffset,startLine:t.startLine,startColumn:t.startColumn,endOffset:NaN,endLine:NaN,endColumn:NaN}}cstInvocationStateUpdate(e){const t={name:e,children:Object.create(null)};this.setInitialNodeLocation(t),this.CST_STACK.push(t)}cstFinallyStateUpdate(){this.CST_STACK.pop()}cstPostRuleFull(e){const t=this.LA(0),r=e.location;r.startOffset<=t.startOffset?(r.endOffset=t.endOffset,r.endLine=t.endLine,r.endColumn=t.endColumn):(r.startOffset=NaN,r.startLine=NaN,r.startColumn=NaN)}cstPostRuleOnlyOffset(e){const t=this.LA(0),r=e.location;r.startOffset<=t.startOffset?r.endOffset=t.endOffset:r.startOffset=NaN}cstPostTerminal(e,t){const r=this.CST_STACK[this.CST_STACK.length-1];oC(r,t,e),this.setNodeLocationFromToken(r.location,t)}cstPostNonTerminal(e,t){const r=this.CST_STACK[this.CST_STACK.length-1];lC(r,t,e),this.setNodeLocationFromNode(r.location,e.location)}getBaseCstVisitorConstructor(){if(_r(this.baseCstVisitorConstructor)){const e=cC(this.className,$t(this.gastProductionsCache));return this.baseCstVisitorConstructor=e,e}return this.baseCstVisitorConstructor}getBaseCstVisitorConstructorWithDefaults(){if(_r(this.baseCstVisitorWithDefaultsConstructor)){const e=fC(this.className,$t(this.gastProductionsCache),this.getBaseCstVisitorConstructor());return this.baseCstVisitorWithDefaultsConstructor=e,e}return this.baseCstVisitorWithDefaultsConstructor}getLastExplicitRuleShortName(){const e=this.RULE_STACK;return e[e.length-1]}getPreviousExplicitRuleShortName(){const e=this.RULE_STACK;return e[e.length-2]}getLastExplicitRuleOccurrenceIndex(){const e=this.RULE_OCCURRENCE_STACK;return e[e.length-1]}},ZD=class{static{i(this,"LexerAdapter")}initLexerAdapter(){this.tokVector=[],this.tokVectorLength=0,this.currIdx=-1}set input(e){if(this.selfAnalysisDone!==!0)throw Error("Missing invocation at the end of the Parser's constructor.");this.reset(),this.tokVector=e,this.tokVectorLength=e.length}get input(){return this.tokVector}SKIP_TOKEN(){return this.currIdx<=this.tokVector.length-2?(this.consumeToken(),this.LA(1)):Rl}LA(e){const t=this.currIdx+e;return t<0||this.tokVectorLength<=t?Rl:this.tokVector[t]}consumeToken(){this.currIdx++}exportLexerState(){return this.currIdx}importLexerState(e){this.currIdx=e}resetLexerState(){this.currIdx=-1}moveToTerminatedState(){this.currIdx=this.tokVector.length-1}getLexerPosition(){return this.exportLexerState()}},QD=class{static{i(this,"RecognizerApi")}ACTION(e){return e.call(this)}consume(e,t,r){return this.consumeInternal(t,e,r)}subrule(e,t,r){return this.subruleInternal(t,e,r)}option(e,t){return this.optionInternal(t,e)}or(e,t){return this.orInternal(t,e)}many(e,t){return this.manyInternal(e,t)}atLeastOne(e,t){return this.atLeastOneInternal(e,t)}CONSUME(e,t){return this.consumeInternal(e,0,t)}CONSUME1(e,t){return this.consumeInternal(e,1,t)}CONSUME2(e,t){return this.consumeInternal(e,2,t)}CONSUME3(e,t){return this.consumeInternal(e,3,t)}CONSUME4(e,t){return this.consumeInternal(e,4,t)}CONSUME5(e,t){return this.consumeInternal(e,5,t)}CONSUME6(e,t){return this.consumeInternal(e,6,t)}CONSUME7(e,t){return this.consumeInternal(e,7,t)}CONSUME8(e,t){return this.consumeInternal(e,8,t)}CONSUME9(e,t){return this.consumeInternal(e,9,t)}SUBRULE(e,t){return this.subruleInternal(e,0,t)}SUBRULE1(e,t){return this.subruleInternal(e,1,t)}SUBRULE2(e,t){return this.subruleInternal(e,2,t)}SUBRULE3(e,t){return this.subruleInternal(e,3,t)}SUBRULE4(e,t){return this.subruleInternal(e,4,t)}SUBRULE5(e,t){return this.subruleInternal(e,5,t)}SUBRULE6(e,t){return this.subruleInternal(e,6,t)}SUBRULE7(e,t){return this.subruleInternal(e,7,t)}SUBRULE8(e,t){return this.subruleInternal(e,8,t)}SUBRULE9(e,t){return this.subruleInternal(e,9,t)}OPTION(e){return this.optionInternal(e,0)}OPTION1(e){return this.optionInternal(e,1)}OPTION2(e){return this.optionInternal(e,2)}OPTION3(e){return this.optionInternal(e,3)}OPTION4(e){return this.optionInternal(e,4)}OPTION5(e){return this.optionInternal(e,5)}OPTION6(e){return this.optionInternal(e,6)}OPTION7(e){return this.optionInternal(e,7)}OPTION8(e){return this.optionInternal(e,8)}OPTION9(e){return this.optionInternal(e,9)}OR(e){return this.orInternal(e,0)}OR1(e){return this.orInternal(e,1)}OR2(e){return this.orInternal(e,2)}OR3(e){return this.orInternal(e,3)}OR4(e){return this.orInternal(e,4)}OR5(e){return this.orInternal(e,5)}OR6(e){return this.orInternal(e,6)}OR7(e){return this.orInternal(e,7)}OR8(e){return this.orInternal(e,8)}OR9(e){return this.orInternal(e,9)}MANY(e){this.manyInternal(0,e)}MANY1(e){this.manyInternal(1,e)}MANY2(e){this.manyInternal(2,e)}MANY3(e){this.manyInternal(3,e)}MANY4(e){this.manyInternal(4,e)}MANY5(e){this.manyInternal(5,e)}MANY6(e){this.manyInternal(6,e)}MANY7(e){this.manyInternal(7,e)}MANY8(e){this.manyInternal(8,e)}MANY9(e){this.manyInternal(9,e)}MANY_SEP(e){this.manySepFirstInternal(0,e)}MANY_SEP1(e){this.manySepFirstInternal(1,e)}MANY_SEP2(e){this.manySepFirstInternal(2,e)}MANY_SEP3(e){this.manySepFirstInternal(3,e)}MANY_SEP4(e){this.manySepFirstInternal(4,e)}MANY_SEP5(e){this.manySepFirstInternal(5,e)}MANY_SEP6(e){this.manySepFirstInternal(6,e)}MANY_SEP7(e){this.manySepFirstInternal(7,e)}MANY_SEP8(e){this.manySepFirstInternal(8,e)}MANY_SEP9(e){this.manySepFirstInternal(9,e)}AT_LEAST_ONE(e){this.atLeastOneInternal(0,e)}AT_LEAST_ONE1(e){return this.atLeastOneInternal(1,e)}AT_LEAST_ONE2(e){this.atLeastOneInternal(2,e)}AT_LEAST_ONE3(e){this.atLeastOneInternal(3,e)}AT_LEAST_ONE4(e){this.atLeastOneInternal(4,e)}AT_LEAST_ONE5(e){this.atLeastOneInternal(5,e)}AT_LEAST_ONE6(e){this.atLeastOneInternal(6,e)}AT_LEAST_ONE7(e){this.atLeastOneInternal(7,e)}AT_LEAST_ONE8(e){this.atLeastOneInternal(8,e)}AT_LEAST_ONE9(e){this.atLeastOneInternal(9,e)}AT_LEAST_ONE_SEP(e){this.atLeastOneSepFirstInternal(0,e)}AT_LEAST_ONE_SEP1(e){this.atLeastOneSepFirstInternal(1,e)}AT_LEAST_ONE_SEP2(e){this.atLeastOneSepFirstInternal(2,e)}AT_LEAST_ONE_SEP3(e){this.atLeastOneSepFirstInternal(3,e)}AT_LEAST_ONE_SEP4(e){this.atLeastOneSepFirstInternal(4,e)}AT_LEAST_ONE_SEP5(e){this.atLeastOneSepFirstInternal(5,e)}AT_LEAST_ONE_SEP6(e){this.atLeastOneSepFirstInternal(6,e)}AT_LEAST_ONE_SEP7(e){this.atLeastOneSepFirstInternal(7,e)}AT_LEAST_ONE_SEP8(e){this.atLeastOneSepFirstInternal(8,e)}AT_LEAST_ONE_SEP9(e){this.atLeastOneSepFirstInternal(9,e)}RULE(e,t,r=Al){if(ut(this.definedRulesNames,e)){const s={message:bn.buildDuplicateRuleNameError({topLevelRule:e,grammarName:this.className}),type:ot.DUPLICATE_RULE_NAME,ruleName:e};this.definitionErrors.push(s)}this.definedRulesNames.push(e);const n=this.defineRule(e,t,r);return this[e]=n,n}OVERRIDE_RULE(e,t,r=Al){const n=zE(e,this.definedRulesNames,this.className);this.definitionErrors=this.definitionErrors.concat(n);const a=this.defineRule(e,t,r);return this[e]=a,a}BACKTRACK(e,t){return function(){this.isBackTrackingStack.push(1);const r=this.saveRecogState();try{return e.apply(this,t),!0}catch(n){if(ws(n))return!1;throw n}finally{this.reloadRecogState(r),this.isBackTrackingStack.pop()}}}getGAstProductions(){return this.gastProductionsCache}getSerializedGastProductions(){return xA(Me(this.gastProductionsCache))}},ex=class{static{i(this,"RecognizerEngine")}initRecognizerEngine(e,t){if(this.className=this.constructor.name,this.shortRuleNameToFull={},this.fullRuleNameToShort={},this.ruleShortNameIdx=256,this.tokenMatcher=Ss,this.subruleIdx=0,this.definedRulesNames=[],this.tokensMap={},this.isBackTrackingStack=[],this.RULE_STACK=[],this.RULE_OCCURRENCE_STACK=[],this.gastProductionsCache={},B(t,"serializedGrammar"))throw Error(`The Parser's configuration can no longer contain a property. + See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0 + For Further details.`);if(re(e)){if(me(e))throw Error(`A Token Vocabulary cannot be empty. + Note that the first argument for the parser constructor + is no longer a Token vector (since v4.0).`);if(typeof e[0].startOffset=="number")throw Error(`The Parser constructor no longer accepts a token vector as the first argument. + See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0 + For Further details.`)}if(re(e))this.tokensMap=At(e,(a,s)=>(a[s.name]=s,a),{});else if(B(e,"modes")&&zt(Ft(Me(e.modes)),CE)){const a=Ft(Me(e.modes)),s=Vp(a);this.tokensMap=At(s,(o,l)=>(o[l.name]=l,o),{})}else if(It(e))this.tokensMap=Ye(e);else throw new Error(" argument must be An Array of Token constructors, A dictionary of Token constructors or an IMultiModeLexerDefinition");this.tokensMap.EOF=Ur;const r=B(e,"modes")?Ft(Me(e.modes)):Me(e),n=zt(r,a=>me(a.categoryMatches));this.tokenMatcher=n?Ss:si,oi(Me(this.tokensMap))}defineRule(e,t,r){if(this.selfAnalysisDone)throw Error(`Grammar rule <${e}> may not be defined after the 'performSelfAnalysis' method has been called' +Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);const n=B(r,"resyncEnabled")?r.resyncEnabled:Al.resyncEnabled,a=B(r,"recoveryValueFunc")?r.recoveryValueFunc:Al.recoveryValueFunc,s=this.ruleShortNameIdx<s.call(this)&&o.call(this),"lookAheadFunc")}}else a=e;if(n.call(this)===!0)return a.call(this)}atLeastOneInternal(e,t){const r=this.getKeyForAutomaticLookahead(Mf,e);return this.atLeastOneInternalLogic(e,t,r)}atLeastOneInternalLogic(e,t,r){let n=this.getLaFuncFromCache(r),a;if(typeof t!="function"){a=t.DEF;const s=t.GATE;if(s!==void 0){const o=n;n=i(()=>s.call(this)&&o.call(this),"lookAheadFunc")}}else a=t;if(n.call(this)===!0){let s=this.doSingleRepetition(a);for(;n.call(this)===!0&&s===!0;)s=this.doSingleRepetition(a)}else throw this.raiseEarlyExitException(e,Re.REPETITION_MANDATORY,t.ERR_MSG);this.attemptInRepetitionRecovery(this.atLeastOneInternal,[e,t],n,Mf,e,GD)}atLeastOneSepFirstInternal(e,t){const r=this.getKeyForAutomaticLookahead(Mo,e);this.atLeastOneSepFirstInternalLogic(e,t,r)}atLeastOneSepFirstInternalLogic(e,t,r){const n=t.DEF,a=t.SEP;if(this.getLaFuncFromCache(r).call(this)===!0){n.call(this);const o=i(()=>this.tokenMatcher(this.LA(1),a),"separatorLookAheadFunc");for(;this.tokenMatcher(this.LA(1),a)===!0;)this.CONSUME(a),n.call(this);this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,[e,a,o,n,ty],o,Mo,e,ty)}else throw this.raiseEarlyExitException(e,Re.REPETITION_MANDATORY_WITH_SEPARATOR,t.ERR_MSG)}manyInternal(e,t){const r=this.getKeyForAutomaticLookahead(xf,e);return this.manyInternalLogic(e,t,r)}manyInternalLogic(e,t,r){let n=this.getLaFuncFromCache(r),a;if(typeof t!="function"){a=t.DEF;const o=t.GATE;if(o!==void 0){const l=n;n=i(()=>o.call(this)&&l.call(this),"lookaheadFunction")}}else a=t;let s=!0;for(;n.call(this)===!0&&s===!0;)s=this.doSingleRepetition(a);this.attemptInRepetitionRecovery(this.manyInternal,[e,t],n,xf,e,MD,s)}manySepFirstInternal(e,t){const r=this.getKeyForAutomaticLookahead(Gf,e);this.manySepFirstInternalLogic(e,t,r)}manySepFirstInternalLogic(e,t,r){const n=t.DEF,a=t.SEP;if(this.getLaFuncFromCache(r).call(this)===!0){n.call(this);const o=i(()=>this.tokenMatcher(this.LA(1),a),"separatorLookAheadFunc");for(;this.tokenMatcher(this.LA(1),a)===!0;)this.CONSUME(a),n.call(this);this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,[e,a,o,n,ey],o,Gf,e,ey)}}repetitionSepSecondInternal(e,t,r,n,a){for(;r();)this.CONSUME(t),n.call(this);this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal,[e,t,r,n,a],r,Mo,e,a)}doSingleRepetition(e){const t=this.getLexerPosition();return e.call(this),this.getLexerPosition()>t}orInternal(e,t){const r=this.getKeyForAutomaticLookahead(aC,t),n=re(e)?e:e.DEF,s=this.getLaFuncFromCache(r).call(this,n);if(s!==void 0)return n[s].ALT.call(this);this.raiseNoAltException(t,e.ERR_MSG)}ruleFinallyStateUpdate(){if(this.RULE_STACK.pop(),this.RULE_OCCURRENCE_STACK.pop(),this.cstFinallyStateUpdate(),this.RULE_STACK.length===0&&this.isAtEndOfInput()===!1){const e=this.LA(1),t=this.errorMessageProvider.buildNotAllInputParsedMessage({firstRedundant:e,ruleName:this.getCurrRuleFullName()});this.SAVE_ERROR(new UD(t,e))}}subruleInternal(e,t,r){let n;try{const a=r!==void 0?r.ARGS:void 0;return this.subruleIdx=t,n=e.apply(this,a),this.cstPostNonTerminal(n,r!==void 0&&r.LABEL!==void 0?r.LABEL:e.ruleName),n}catch(a){throw this.subruleInternalError(a,r,e.ruleName)}}subruleInternalError(e,t,r){throw ws(e)&&e.partialCstResult!==void 0&&(this.cstPostNonTerminal(e.partialCstResult,t!==void 0&&t.LABEL!==void 0?t.LABEL:r),delete e.partialCstResult),e}consumeInternal(e,t,r){let n;try{const a=this.LA(1);this.tokenMatcher(a,e)===!0?(this.consumeToken(),n=a):this.consumeInternalError(e,a,r)}catch(a){n=this.consumeInternalRecovery(e,t,a)}return this.cstPostTerminal(r!==void 0&&r.LABEL!==void 0?r.LABEL:e.name,n),n}consumeInternalError(e,t,r){let n;const a=this.LA(0);throw r!==void 0&&r.ERR_MSG?n=r.ERR_MSG:n=this.errorMessageProvider.buildMismatchTokenMessage({expected:e,actual:t,previous:a,ruleName:this.getCurrRuleFullName()}),this.SAVE_ERROR(new tC(n,t,a))}consumeInternalRecovery(e,t,r){if(this.recoveryEnabled&&r.name==="MismatchedTokenException"&&!this.isBackTracking()){const n=this.getFollowsForInRuleRecovery(e,t);try{return this.tryInRuleRecovery(e,n)}catch(a){throw a.name===rC?r:a}}else throw r}saveRecogState(){const e=this.errors,t=Ye(this.RULE_STACK);return{errors:e,lexerState:this.exportLexerState(),RULE_STACK:t,CST_STACK:this.CST_STACK}}reloadRecogState(e){this.errors=e.errors,this.importLexerState(e.lexerState),this.RULE_STACK=e.RULE_STACK}ruleInvocationStateUpdate(e,t,r){this.RULE_OCCURRENCE_STACK.push(r),this.RULE_STACK.push(e),this.cstInvocationStateUpdate(t)}isBackTracking(){return this.isBackTrackingStack.length!==0}getCurrRuleFullName(){const e=this.getLastExplicitRuleShortName();return this.shortRuleNameToFull[e]}shortRuleNameToFullName(e){return this.shortRuleNameToFull[e]}isAtEndOfInput(){return this.tokenMatcher(this.LA(1),Ur)}reset(){this.resetLexerState(),this.subruleIdx=0,this.isBackTrackingStack=[],this.errors=[],this.RULE_STACK=[],this.CST_STACK=[],this.RULE_OCCURRENCE_STACK=[]}},tx=class{static{i(this,"ErrorHandler")}initErrorHandler(e){this._errors=[],this.errorMessageProvider=B(e,"errorMessageProvider")?e.errorMessageProvider:Sr.errorMessageProvider}SAVE_ERROR(e){if(ws(e))return e.context={ruleStack:this.getHumanReadableRuleStack(),ruleOccurrenceStack:Ye(this.RULE_OCCURRENCE_STACK)},this._errors.push(e),e;throw Error("Trying to save an Error which is not a RecognitionException")}get errors(){return Ye(this._errors)}set errors(e){this._errors=e}raiseEarlyExitException(e,t,r){const n=this.getCurrRuleFullName(),a=this.getGAstProductions()[n],o=to(e,a,t,this.maxLookahead)[0],l=[];for(let c=1;c<=this.maxLookahead;c++)l.push(this.LA(c));const u=this.errorMessageProvider.buildEarlyExitMessage({expectedIterationPaths:o,actual:l,previous:this.LA(0),customUserDescription:r,ruleName:n});throw this.SAVE_ERROR(new KD(u,this.LA(1),this.LA(0)))}raiseNoAltException(e,t){const r=this.getCurrRuleFullName(),n=this.getGAstProductions()[r],a=eo(e,n,this.maxLookahead),s=[];for(let u=1;u<=this.maxLookahead;u++)s.push(this.LA(u));const o=this.LA(0),l=this.errorMessageProvider.buildNoViableAltMessage({expectedPathsPerAlt:a,actual:s,previous:o,customUserDescription:t,ruleName:this.getCurrRuleFullName()});throw this.SAVE_ERROR(new BD(l,this.LA(1),o))}},rx=class{static{i(this,"ContentAssist")}initContentAssist(){}computeContentAssist(e,t){const r=this.gastProductionsCache[e];if(_r(r))throw Error(`Rule ->${e}<- does not exist in this grammar.`);return nm([r],t,this.tokenMatcher,this.maxLookahead)}getNextPossibleTokenTypes(e){const t=Bt(e.ruleStack),n=this.getGAstProductions()[t];return new xD(n,e).startWalking()}},vu={description:"This Object indicates the Parser is during Recording Phase"};Object.freeze(vu);var ry=!0,ny=Math.pow(2,Yr)-1,mC=ja({name:"RECORDING_PHASE_TOKEN",pattern:at.NA});oi([mC]);var hC=Qs(mC,`This IToken indicates the Parser is in Recording Phase + See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details`,-1,-1,-1,-1,-1,-1);Object.freeze(hC);var nx={name:`This CSTNode indicates the Parser is in Recording Phase + See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details`,children:{}},ax=class{static{i(this,"GastRecorder")}initGastRecorder(e){this.recordingProdStack=[],this.RECORDING_PHASE=!1}enableRecording(){this.RECORDING_PHASE=!0,this.TRACE_INIT("Enable Recording",()=>{for(let e=0;e<10;e++){const t=e>0?e:"";this[`CONSUME${t}`]=function(r,n){return this.consumeInternalRecord(r,e,n)},this[`SUBRULE${t}`]=function(r,n){return this.subruleInternalRecord(r,e,n)},this[`OPTION${t}`]=function(r){return this.optionInternalRecord(r,e)},this[`OR${t}`]=function(r){return this.orInternalRecord(r,e)},this[`MANY${t}`]=function(r){this.manyInternalRecord(e,r)},this[`MANY_SEP${t}`]=function(r){this.manySepFirstInternalRecord(e,r)},this[`AT_LEAST_ONE${t}`]=function(r){this.atLeastOneInternalRecord(e,r)},this[`AT_LEAST_ONE_SEP${t}`]=function(r){this.atLeastOneSepFirstInternalRecord(e,r)}}this.consume=function(e,t,r){return this.consumeInternalRecord(t,e,r)},this.subrule=function(e,t,r){return this.subruleInternalRecord(t,e,r)},this.option=function(e,t){return this.optionInternalRecord(t,e)},this.or=function(e,t){return this.orInternalRecord(t,e)},this.many=function(e,t){this.manyInternalRecord(e,t)},this.atLeastOne=function(e,t){this.atLeastOneInternalRecord(e,t)},this.ACTION=this.ACTION_RECORD,this.BACKTRACK=this.BACKTRACK_RECORD,this.LA=this.LA_RECORD})}disableRecording(){this.RECORDING_PHASE=!1,this.TRACE_INIT("Deleting Recording methods",()=>{const e=this;for(let t=0;t<10;t++){const r=t>0?t:"";delete e[`CONSUME${r}`],delete e[`SUBRULE${r}`],delete e[`OPTION${r}`],delete e[`OR${r}`],delete e[`MANY${r}`],delete e[`MANY_SEP${r}`],delete e[`AT_LEAST_ONE${r}`],delete e[`AT_LEAST_ONE_SEP${r}`]}delete e.consume,delete e.subrule,delete e.option,delete e.or,delete e.many,delete e.atLeastOne,delete e.ACTION,delete e.BACKTRACK,delete e.LA})}ACTION_RECORD(e){}BACKTRACK_RECORD(e,t){return()=>!0}LA_RECORD(e){return Rl}topLevelRuleRecord(e,t){try{const r=new ni({definition:[],name:e});return r.name=e,this.recordingProdStack.push(r),t.call(this),this.recordingProdStack.pop(),r}catch(r){if(r.KNOWN_RECORDER_ERROR!==!0)try{r.message=r.message+` + This error was thrown during the "grammar recording phase" For more info see: + https://chevrotain.io/docs/guide/internals.html#grammar-recording`}catch{throw r}throw r}}optionInternalRecord(e,t){return Ra.call(this,He,e,t)}atLeastOneInternalRecord(e,t){Ra.call(this,Et,t,e)}atLeastOneSepFirstInternalRecord(e,t){Ra.call(this,Ct,t,e,ry)}manyInternalRecord(e,t){Ra.call(this,_e,t,e)}manySepFirstInternalRecord(e,t){Ra.call(this,yt,t,e,ry)}orInternalRecord(e,t){return yC.call(this,e,t)}subruleInternalRecord(e,t,r){if(Is(t),!e||B(e,"ruleName")===!1){const o=new Error(` argument is invalid expecting a Parser method reference but got: <${JSON.stringify(e)}> + inside top level rule: <${this.recordingProdStack[0].name}>`);throw o.KNOWN_RECORDER_ERROR=!0,o}const n=kn(this.recordingProdStack),a=e.ruleName,s=new st({idx:t,nonTerminalName:a,label:r?.LABEL,referencedRule:void 0});return n.definition.push(s),this.outputCst?nx:vu}consumeInternalRecord(e,t,r){if(Is(t),!em(e)){const s=new Error(` argument is invalid expecting a TokenType reference but got: <${JSON.stringify(e)}> + inside top level rule: <${this.recordingProdStack[0].name}>`);throw s.KNOWN_RECORDER_ERROR=!0,s}const n=kn(this.recordingProdStack),a=new ve({idx:t,terminalType:e,label:r?.LABEL});return n.definition.push(a),hC}};function Ra(e,t,r,n=!1){Is(r);const a=kn(this.recordingProdStack),s=Pr(t)?t:t.DEF,o=new e({definition:[],idx:r});return n&&(o.separator=t.SEP),B(t,"MAX_LOOKAHEAD")&&(o.maxLookahead=t.MAX_LOOKAHEAD),this.recordingProdStack.push(o),s.call(this),a.definition.push(o),this.recordingProdStack.pop(),vu}i(Ra,"recordProd");function yC(e,t){Is(t);const r=kn(this.recordingProdStack),n=re(e)===!1,a=n===!1?e:e.DEF,s=new gt({definition:[],idx:t,ignoreAmbiguities:n&&e.IGNORE_AMBIGUITIES===!0});B(e,"MAX_LOOKAHEAD")&&(s.maxLookahead=e.MAX_LOOKAHEAD);const o=PA(a,l=>Pr(l.GATE));return s.hasPredicates=o,r.definition.push(s),K(a,l=>{const u=new ht({definition:[]});s.definition.push(u),B(l,"IGNORE_AMBIGUITIES")?u.ignoreAmbiguities=l.IGNORE_AMBIGUITIES:B(l,"GATE")&&(u.ignoreAmbiguities=!0),this.recordingProdStack.push(u),l.ALT.call(this),this.recordingProdStack.pop()}),vu}i(yC,"recordOrProd");function Bf(e){return e===0?"":`${e}`}i(Bf,"getIdxSuffix");function Is(e){if(e<0||e>ny){const t=new Error(`Invalid DSL Method idx value: <${e}> + Idx value must be a none negative value smaller than ${ny+1}`);throw t.KNOWN_RECORDER_ERROR=!0,t}}i(Is,"assertMethodIdxIsValid");var ix=class{static{i(this,"PerformanceTracer")}initPerformanceTracer(e){if(B(e,"traceInitPerf")){const t=e.traceInitPerf,r=typeof t=="number";this.traceInitMaxIdent=r?t:1/0,this.traceInitPerf=r?t>0:t}else this.traceInitMaxIdent=0,this.traceInitPerf=Sr.traceInitPerf;this.traceInitIndent=-1}TRACE_INIT(e,t){if(this.traceInitPerf===!0){this.traceInitIndent++;const r=new Array(this.traceInitIndent+1).join(" ");this.traceInitIndent <${e}>`);const{time:n,value:a}=Hp(t),s=n>10?console.warn:console.log;return this.traceInitIndent time: ${n}ms`),this.traceInitIndent--,a}else return t()}};function gC(e,t){t.forEach(r=>{const n=r.prototype;Object.getOwnPropertyNames(n).forEach(a=>{if(a==="constructor")return;const s=Object.getOwnPropertyDescriptor(n,a);s&&(s.get||s.set)?Object.defineProperty(e.prototype,a,s):e.prototype[a]=r.prototype[a]})})}i(gC,"applyMixins");var Rl=Qs(Ur,"",NaN,NaN,NaN,NaN,NaN,NaN);Object.freeze(Rl);var Sr=Object.freeze({recoveryEnabled:!1,maxLookahead:3,dynamicTokensEnabled:!1,outputCst:!0,errorMessageProvider:Ga,nodeLocationTracking:"none",traceInitPerf:!1,skipValidations:!1}),Al=Object.freeze({recoveryValueFunc:i(()=>{},"recoveryValueFunc"),resyncEnabled:!0}),ot;(function(e){e[e.INVALID_RULE_NAME=0]="INVALID_RULE_NAME",e[e.DUPLICATE_RULE_NAME=1]="DUPLICATE_RULE_NAME",e[e.INVALID_RULE_OVERRIDE=2]="INVALID_RULE_OVERRIDE",e[e.DUPLICATE_PRODUCTIONS=3]="DUPLICATE_PRODUCTIONS",e[e.UNRESOLVED_SUBRULE_REF=4]="UNRESOLVED_SUBRULE_REF",e[e.LEFT_RECURSION=5]="LEFT_RECURSION",e[e.NONE_LAST_EMPTY_ALT=6]="NONE_LAST_EMPTY_ALT",e[e.AMBIGUOUS_ALTS=7]="AMBIGUOUS_ALTS",e[e.CONFLICT_TOKENS_RULES_NAMESPACE=8]="CONFLICT_TOKENS_RULES_NAMESPACE",e[e.INVALID_TOKEN_NAME=9]="INVALID_TOKEN_NAME",e[e.NO_NON_EMPTY_LOOKAHEAD=10]="NO_NON_EMPTY_LOOKAHEAD",e[e.AMBIGUOUS_PREFIX_ALTS=11]="AMBIGUOUS_PREFIX_ALTS",e[e.TOO_MANY_ALTS=12]="TOO_MANY_ALTS",e[e.CUSTOM_LOOKAHEAD_VALIDATION=13]="CUSTOM_LOOKAHEAD_VALIDATION"})(ot||(ot={}));function Uf(e=void 0){return function(){return e}}i(Uf,"EMPTY_ALT");var fm=class vC{static{i(this,"Parser")}static performSelfAnalysis(t){throw Error("The **static** `performSelfAnalysis` method has been deprecated. \nUse the **instance** method with the same name instead.")}performSelfAnalysis(){this.TRACE_INIT("performSelfAnalysis",()=>{let t;this.selfAnalysisDone=!0;const r=this.className;this.TRACE_INIT("toFastProps",()=>{Yp(this)}),this.TRACE_INIT("Grammar Recording",()=>{try{this.enableRecording(),K(this.definedRulesNames,a=>{const o=this[a].originalGrammarAction;let l;this.TRACE_INIT(`${a} Rule`,()=>{l=this.topLevelRuleRecord(a,o)}),this.gastProductionsCache[a]=l})}finally{this.disableRecording()}});let n=[];if(this.TRACE_INIT("Grammar Resolving",()=>{n=HE({rules:Me(this.gastProductionsCache)}),this.definitionErrors=this.definitionErrors.concat(n)}),this.TRACE_INIT("Grammar Validations",()=>{if(me(n)&&this.skipValidations===!1){const a=YE({rules:Me(this.gastProductionsCache),tokenTypes:Me(this.tokensMap),errMsgProvider:bn,grammarName:r}),s=DE({lookaheadStrategy:this.lookaheadStrategy,rules:Me(this.gastProductionsCache),tokenTypes:Me(this.tokensMap),grammarName:r});this.definitionErrors=this.definitionErrors.concat(a,s)}}),me(this.definitionErrors)&&(this.recoveryEnabled&&this.TRACE_INIT("computeAllProdsFollows",()=>{const a=UA(Me(this.gastProductionsCache));this.resyncFollows=a}),this.TRACE_INIT("ComputeLookaheadFunctions",()=>{var a,s;(s=(a=this.lookaheadStrategy).initialize)===null||s===void 0||s.call(a,{rules:Me(this.gastProductionsCache)}),this.preComputeLookaheadFunctions(Me(this.gastProductionsCache))})),!vC.DEFER_DEFINITION_ERRORS_HANDLING&&!me(this.definitionErrors))throw t=F(this.definitionErrors,a=>a.message),new Error(`Parser Definition Errors detected: + ${t.join(` +------------------------------- +`)}`)})}constructor(t,r){this.definitionErrors=[],this.selfAnalysisDone=!1;const n=this;if(n.initErrorHandler(r),n.initLexerAdapter(),n.initLooksAhead(r),n.initRecognizerEngine(t,r),n.initRecoverable(r),n.initTreeBuilder(r),n.initContentAssist(),n.initGastRecorder(r),n.initPerformanceTracer(r),B(r,"ignoredIssues"))throw new Error(`The IParserConfig property has been deprecated. + Please use the flag on the relevant DSL method instead. + See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES + For further details.`);this.skipValidations=B(r,"skipValidations")?r.skipValidations:Sr.skipValidations}};fm.DEFER_DEFINITION_ERRORS_HANDLING=!1;gC(fm,[VD,HD,JD,ZD,ex,QD,tx,rx,ax,ix]);var sx=class extends fm{static{i(this,"EmbeddedActionsParser")}constructor(e,t=Sr){const r=Ye(t);r.outputCst=!1,super(e,r)}};function TC(e,t){for(var r=-1,n=e==null?0:e.length,a=Array(n);++r-1}i(SC,"listCacheHas");var dx=SC;function wC(e,t){var r=this.__data__,n=Tu(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}i(wC,"listCacheSet");var px=wC;function Yn(e){var t=-1,r=e==null?0:e.length;for(this.clear();++tl))return!1;var c=s.get(e),f=s.get(t);if(c&&f)return c==t&&f==e;var d=-1,m=!0,g=r&TM?new o_:void 0;for(s.set(e,t),s.set(t,e);++d-1&&e%1==0&&e-1&&e%1==0&&e<=e1}i(N_,"isLength");var mm=N_,t1="[object Arguments]",r1="[object Array]",n1="[object Boolean]",a1="[object Date]",i1="[object Error]",s1="[object Function]",o1="[object Map]",l1="[object Number]",u1="[object Object]",c1="[object RegExp]",f1="[object Set]",d1="[object String]",p1="[object WeakMap]",m1="[object ArrayBuffer]",h1="[object DataView]",y1="[object Float32Array]",g1="[object Float64Array]",v1="[object Int8Array]",T1="[object Int16Array]",$1="[object Int32Array]",R1="[object Uint8Array]",A1="[object Uint8ClampedArray]",E1="[object Uint16Array]",C1="[object Uint32Array]",ge={};ge[y1]=ge[g1]=ge[v1]=ge[T1]=ge[$1]=ge[R1]=ge[A1]=ge[E1]=ge[C1]=!0;ge[t1]=ge[r1]=ge[m1]=ge[n1]=ge[h1]=ge[a1]=ge[i1]=ge[s1]=ge[o1]=ge[l1]=ge[u1]=ge[c1]=ge[f1]=ge[d1]=ge[p1]=!1;function P_(e){return Za(e)&&mm(e.length)&&!!ge[li(e)]}i(P_,"baseIsTypedArray");var _1=P_;function k_(e){return function(t){return e(t)}}i(k_,"baseUnary");var b1=k_,O_=typeof exports=="object"&&exports&&!exports.nodeType&&exports,ys=O_&&typeof module=="object"&&module&&!module.nodeType&&module,S1=ys&&ys.exports===O_,Ju=S1&&OC.process,w1=(function(){try{var e=ys&&ys.require&&ys.require("util").types;return e||Ju&&Ju.binding&&Ju.binding("util")}catch{}})(),py=w1,my=py&&py.isTypedArray,I1=my?b1(my):_1,hm=I1,N1=Object.prototype,P1=N1.hasOwnProperty;function L_(e,t){var r=lt(e),n=!r&&Eu(e),a=!r&&!n&&El(e),s=!r&&!n&&!a&&hm(e),o=r||n||a||s,l=o?UM(e.length,String):[],u=l.length;for(var c in e)(t||P1.call(e,c))&&!(o&&(c=="length"||a&&(c=="offset"||c=="parent")||s&&(c=="buffer"||c=="byteLength"||c=="byteOffset")||I_(c,u)))&&l.push(c);return l}i(L_,"arrayLikeKeys");var k1=L_,O1=Object.prototype;function D_(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||O1;return e===r}i(D_,"isPrototype");var x_=D_;function M_(e,t){return function(r){return e(t(r))}}i(M_,"overArg");var L1=M_,D1=L1(Object.keys,Object),x1=D1,M1=Object.prototype,G1=M1.hasOwnProperty;function G_(e){if(!x_(e))return x1(e);var t=[];for(var r in Object(e))G1.call(e,r)&&r!="constructor"&&t.push(r);return t}i(G_,"baseKeys");var F_=G_;function z_(e){return e!=null&&mm(e.length)&&!zC(e)}i(z_,"isArrayLike");var Cu=z_;function j_(e){return Cu(e)?k1(e):F_(e)}i(j_,"keys");var ym=j_;function B_(e){return MM(e,ym,BM)}i(B_,"getAllKeys");var hy=B_,F1=1,z1=Object.prototype,j1=z1.hasOwnProperty;function U_(e,t,r,n,a,s){var o=r&F1,l=hy(e),u=l.length,c=hy(t),f=c.length;if(u!=f&&!o)return!1;for(var d=u;d--;){var m=l[d];if(!(o?m in t:j1.call(t,m)))return!1}var g=s.get(e),v=s.get(t);if(g&&v)return g==t&&v==e;var _=!0;s.set(e,t),s.set(t,e);for(var S=o;++dCm(e,t,o));return ea(e,t,n,r,...a)}i(Db,"alternation");function xb(e,t,r){const n=Ge(e,t,r,{type:Kr});Or(e,n);const a=ea(e,t,n,r,Xr(e,t,r));return Mb(e,t,r,a)}i(xb,"option");function Xr(e,t,r){const n=GG(Tr(r.definition,a=>Cm(e,t,a)),a=>a!==void 0);return n.length===1?n[0]:n.length===0?void 0:Fb(e,n)}i(Xr,"block");function _m(e,t,r,n,a){const s=n.left,o=n.right,l=Ge(e,t,r,{type:UG});Or(e,l);const u=Ge(e,t,r,{type:Sb});return s.loopback=l,u.loopback=l,e.decisionMap[Ln(t,a?"RepetitionMandatoryWithSeparator":"RepetitionMandatory",r.idx)]=l,Ie(o,l),a===void 0?(Ie(l,s),Ie(l,u)):(Ie(l,u),Ie(l,a.left),Ie(a.right,s)),{left:s,right:u}}i(_m,"plus");function bm(e,t,r,n,a){const s=n.left,o=n.right,l=Ge(e,t,r,{type:BG});Or(e,l);const u=Ge(e,t,r,{type:Sb}),c=Ge(e,t,r,{type:jG});return l.loopback=c,u.loopback=c,Ie(l,s),Ie(l,u),Ie(o,c),a!==void 0?(Ie(c,u),Ie(c,a.left),Ie(a.right,s)):Ie(c,l),e.decisionMap[Ln(t,a?"RepetitionWithSeparator":"Repetition",r.idx)]=l,{left:l,right:u}}i(bm,"star");function Mb(e,t,r,n){const a=n.left,s=n.right;return Ie(a,s),e.decisionMap[Ln(t,"Option",r.idx)]=a,n}i(Mb,"optional");function Or(e,t){return e.decisionStates.push(t),t.decision=e.decisionStates.length-1,t.decision}i(Or,"defineDecisionState");function ea(e,t,r,n,...a){const s=Ge(e,t,n,{type:zG,start:r});r.end=s;for(const l of a)l!==void 0?(Ie(r,l.left),Ie(l.right,s)):Ie(r,s);const o={left:r,right:s};return e.decisionMap[Ln(t,Gb(n),n.idx)]=r,o}i(ea,"makeAlts");function Gb(e){if(e instanceof gt)return"Alternation";if(e instanceof He)return"Option";if(e instanceof _e)return"Repetition";if(e instanceof yt)return"RepetitionWithSeparator";if(e instanceof Et)return"RepetitionMandatory";if(e instanceof Ct)return"RepetitionMandatoryWithSeparator";throw new Error("Invalid production type encountered")}i(Gb,"getProdType");function Fb(e,t){const r=t.length;for(let s=0;se.alt)}get key(){let e="";for(const t in this.map)e+=t+":";return e}};function Sm(e,t=!0){return`${t?`a${e.alt}`:""}s${e.state.stateNumber}:${e.stack.map(r=>r.stateNumber.toString()).join("_")}`}i(Sm,"getATNConfigKey");function Ub(e,t,r){for(var n=-1,a=e.length;++n0&&r(l)?t>1?wm(l,t-1,r,n,a):g_(a,l):n||(a[a.length]=l)}return a}i(wm,"baseFlatten");var qb=wm;function Hb(e,t){return qb(Tr(e,t),1)}i(Hb,"flatMap");var HG=Hb;function Yb(e,t,r,n){for(var a=e.length,s=r+(n?1:-1);n?s--:++s-1}i(Qb,"arrayIncludes");var QG=Qb;function eS(e,t,r){for(var n=-1,a=e==null?0:e.length;++n=iF){var c=t?null:aF(e);if(c)return pm(c);o=!1,a=c_,u=new o_}else u=t?[]:l;e:for(;++n{const a=n.toString();let s=r[a];return s!==void 0||(s={atnStartState:e,decision:t,states:{}},r[a]=s),s}}i(dS,"createDFACache");var pS=class{static{i(this,"PredicateSet")}constructor(){this.predicates=[]}is(e){return e>=this.predicates.length||this.predicates[e]}set(e,t){this.predicates[e]=t}toString(){let e="";const t=this.predicates.length;for(let r=0;rconsole.log(r))}initialize(e){this.atn=Ib(e.rules),this.dfas=mS(this.atn)}validateAmbiguousAlternationAlternatives(){return[]}validateEmptyOrAlternatives(){return[]}buildLookaheadForAlternation(e){const{prodOccurrence:t,rule:r,hasPredicates:n,dynamicTokensEnabled:a}=e,s=this.dfas,o=this.logging,l=Ln(r,"Alternation",t),c=this.atn.decisionMap[l].decision,f=Tr(Lf({maxLookahead:1,occurrence:t,prodType:"Alternation",rule:r}),d=>Tr(d,m=>m[0]));if(Yf(f,!1)&&!a){const d=Sy(f,(m,g,v)=>(Zu(g,_=>{_&&(m[_.tokenTypeIdx]=v,Zu(_.categoryMatches,S=>{m[S]=v}))}),m),{});return n?function(m){var g;const v=this.LA(1),_=d[v.tokenTypeIdx];if(m!==void 0&&_!==void 0){const S=(g=m[_])===null||g===void 0?void 0:g.GATE;if(S!==void 0&&S.call(this)===!1)return}return _}:function(){const m=this.LA(1);return d[m.tokenTypeIdx]}}else return n?function(d){const m=new pS,g=d===void 0?0:d.length;for(let _=0;_Tr(d,m=>m[0]));if(Yf(f)&&f[0][0]&&!a){const d=f[0],m=lF(d);if(m.length===1&&hF(m[0].categoryMatches)){const v=m[0].tokenTypeIdx;return function(){return this.LA(1).tokenTypeIdx===v}}else{const g=Sy(m,(v,_)=>(_!==void 0&&(v[_.tokenTypeIdx]=!0,Zu(_.categoryMatches,S=>{v[S]=!0})),v),{});return function(){const v=this.LA(1);return g[v.tokenTypeIdx]===!0}}}return function(){const d=zo.call(this,s,c,wy,o);return typeof d=="object"?!1:d===0}}};function Yf(e,t=!0){const r=new Set;for(const n of e){const a=new Set;for(const s of n){if(s===void 0){if(t)break;return!1}const o=[s.tokenTypeIdx].concat(s.categoryMatches);for(const l of o)if(r.has(l)){if(!a.has(l))return!1}else r.add(l),a.add(l)}}return!0}i(Yf,"isLL1Sequence");function mS(e){const t=e.decisionStates.length,r=Array(t);for(let n=0;nIn(a)).join(", "),r=e.production.idx===0?"":e.production.idx;let n=`Ambiguous Alternatives Detected: <${e.ambiguityIndices.join(", ")}> in <${TS(e.production)}${r}> inside <${e.topLevelRule.name}> Rule, +<${t}> may appears as a prefix path in all these alternatives. +`;return n=n+`See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES +For Further details.`,n}i(vS,"buildAmbiguityError");function TS(e){if(e instanceof st)return"SUBRULE";if(e instanceof He)return"OPTION";if(e instanceof gt)return"OR";if(e instanceof Et)return"AT_LEAST_ONE";if(e instanceof Ct)return"AT_LEAST_ONE_SEP";if(e instanceof yt)return"MANY_SEP";if(e instanceof _e)return"MANY";if(e instanceof ve)return"CONSUME";throw Error("non exhaustive match")}i(TS,"getProductionDslName");function $S(e,t,r){const n=HG(t.configs.elements,s=>s.state.transitions),a=oF(n.filter(s=>s instanceof Am).map(s=>s.tokenType),s=>s.tokenTypeIdx);return{actualToken:r,possibleTokenTypes:a,tokenPath:e}}i($S,"buildAdaptivePredictError");function RS(e,t){return e.edges[t.tokenTypeIdx]}i(RS,"getExistingTargetState");function AS(e,t,r){const n=new Hf,a=[];for(const o of e.elements){if(r.is(o.alt)===!1)continue;if(o.state.type===ro){a.push(o);continue}const l=o.state.transitions.length;for(let u=0;u0&&!SS(s))for(const o of a)s.add(o);return s}i(AS,"computeReachSet");function ES(e,t){if(e instanceof Am&&rm(t,e.tokenType))return e.target}i(ES,"getReachableTarget");function CS(e,t){let r;for(const n of e.elements)if(t.is(n.alt)===!0){if(r===void 0)r=n.alt;else if(r!==n.alt)return}return r}i(CS,"getUniqueAlt");function Im(e){return{configs:e,edges:{},isAcceptState:!1,prediction:-1}}i(Im,"newDFAState");function Xf(e,t,r,n){return n=Nm(e,n),t.edges[r.tokenTypeIdx]=n,n}i(Xf,"addDFAEdge");function Nm(e,t){if(t===Cl)return t;const r=t.configs.key,n=e.states[r];return n!==void 0?n:(t.configs.finalize(),e.states[r]=t,t)}i(Nm,"addDFAState");function _S(e){const t=new Hf,r=e.transitions.length;for(let n=0;n0){const a=[...e.stack],o={state:a.pop(),alt:e.alt,stack:a};Os(o,t)}else t.add(e);return}r.epsilonOnlyTransitions||t.add(e);const n=r.transitions.length;for(let a=0;a1)return!0;return!1}i(PS,"hasConflictingAltSet");function kS(e){for(const t of Array.from(e.values()))if(Object.keys(t).length===1)return!0;return!1}i(kS,"hasStateAssociatedWithOneAlt");xs();var OS=class{static{i(this,"CstNodeBuilder")}constructor(){this.nodeStack=[]}get current(){return this.nodeStack[this.nodeStack.length-1]??this.rootNode}buildRootNode(e){return this.rootNode=new km(e),this.rootNode.root=this.rootNode,this.nodeStack=[this.rootNode],this.rootNode}buildCompositeNode(e){const t=new ku;return t.grammarSource=e,t.root=this.rootNode,this.current.content.push(t),this.nodeStack.push(t),t}buildLeafNode(e,t){const r=new _l(e.startOffset,e.image.length,$s(e),e.tokenType,!t);return r.grammarSource=t,r.root=this.rootNode,this.current.content.push(r),r}removeNode(e){const t=e.container;if(t){const r=t.content.indexOf(e);r>=0&&t.content.splice(r,1)}}addHiddenNodes(e){const t=[];for(const a of e){const s=new _l(a.startOffset,a.image.length,$s(a),a.tokenType,!0);s.root=this.rootNode,t.push(s)}let r=this.current,n=!1;if(r.content.length>0){r.content.push(...t);return}for(;r.container;){const a=r.container.content.indexOf(r);if(a>0){r.container.content.splice(a,0,...t),n=!0;break}r=r.container}n||this.rootNode.content.unshift(...t)}construct(e){const t=this.current;typeof e.$type=="string"&&!e.$infixName&&(this.current.astNode=e),e.$cstNode=t;const r=this.nodeStack.pop();r?.content.length===0&&this.removeNode(r)}},Pm=class{static{i(this,"AbstractCstNode")}get hidden(){return!1}get astNode(){const e=typeof this._astNode?.$type=="string"?this._astNode:this.container?.astNode;if(!e)throw new Error("This node has no associated AST element");return e}set astNode(e){this._astNode=e}get text(){return this.root.fullText.substring(this.offset,this.end)}},_l=class extends Pm{static{i(this,"LeafCstNodeImpl")}get offset(){return this._offset}get length(){return this._length}get end(){return this._offset+this._length}get hidden(){return this._hidden}get tokenType(){return this._tokenType}get range(){return this._range}constructor(e,t,r,n,a=!1){super(),this._hidden=a,this._offset=e,this._tokenType=n,this._length=t,this._range=r}},ku=class extends Pm{static{i(this,"CompositeCstNodeImpl")}constructor(){super(...arguments),this.content=new TF(this)}get offset(){return this.firstNonHiddenNode?.offset??0}get length(){return this.end-this.offset}get end(){return this.lastNonHiddenNode?.end??0}get range(){const e=this.firstNonHiddenNode,t=this.lastNonHiddenNode;if(e&&t){if(this._rangeCache===void 0){const{range:r}=e,{range:n}=t;this._rangeCache={start:r.start,end:n.end.line=0;e--){const t=this.content[e];if(!t.hidden)return t}return this.content[this.content.length-1]}},TF=class LS extends Array{static{i(this,"CstNodeContainer")}constructor(t){super(),this.parent=t,Object.setPrototypeOf(this,LS.prototype)}push(...t){return this.addParents(t),super.push(...t)}unshift(...t){return this.addParents(t),super.unshift(...t)}splice(t,r,...n){return this.addParents(n),super.splice(t,r,...n)}addParents(t){for(const r of t)r.container=this.parent}},km=class extends ku{static{i(this,"RootCstNodeImpl")}get text(){return this._text.substring(this.offset,this.end)}get fullText(){return this._text}constructor(e){super(),this._text="",this._text=e??""}},bl=Symbol("Datatype");function jo(e){return e.$type===bl}i(jo,"isDataTypeNode");var Iy="​",DS=i(e=>e.endsWith(Iy)?e:e+Iy,"withRuleSuffix"),Om=class{static{i(this,"AbstractLangiumParser")}constructor(e){this._unorderedGroups=new Map,this.allRules=new Map,this.lexer=e.parser.Lexer;const t=this.lexer.definition,r=e.LanguageMetaData.mode==="production";e.shared.profilers.LangiumProfiler?.isActive("parsing")?this.wrapper=new RF(t,{...e.parser.ParserConfig,skipValidations:r,errorMessageProvider:e.parser.ParserErrorMessageProvider},e.shared.profilers.LangiumProfiler.createTask("parsing",e.LanguageMetaData.languageId)):this.wrapper=new FS(t,{...e.parser.ParserConfig,skipValidations:r,errorMessageProvider:e.parser.ParserErrorMessageProvider})}alternatives(e,t){this.wrapper.wrapOr(e,t)}optional(e,t){this.wrapper.wrapOption(e,t)}many(e,t){this.wrapper.wrapMany(e,t)}atLeastOne(e,t){this.wrapper.wrapAtLeastOne(e,t)}getRule(e){return this.allRules.get(e)}isRecording(){return this.wrapper.IS_RECORDING}get unorderedGroups(){return this._unorderedGroups}getRuleStack(){return this.wrapper.RULE_STACK}finalize(){this.wrapper.wrapSelfAnalysis()}},xS=class extends Om{static{i(this,"LangiumParser")}get current(){return this.stack[this.stack.length-1]}constructor(e){super(e),this.nodeBuilder=new OS,this.stack=[],this.assignmentMap=new Map,this.operatorPrecedence=new Map,this.linker=e.references.Linker,this.converter=e.parser.ValueConverter,this.astReflection=e.shared.AstReflection}rule(e,t){const r=this.computeRuleType(e);let n;qa(e)&&(n=e.name,this.registerPrecedenceMap(e));const a=this.wrapper.DEFINE_RULE(DS(e.name),this.startImplementation(r,n,t).bind(this));return this.allRules.set(e.name,a),it(e)&&e.entry&&(this.mainRule=a),a}registerPrecedenceMap(e){const t=e.name,r=new Map;for(let n=0;n0&&(t=this.construct()),t===void 0)throw new Error("No result from parser");if(this.stack.length>0)throw new Error("Parser stack is not empty after parsing");return t}startImplementation(e,t,r){return n=>{const a=!this.isRecording()&&e!==void 0;if(a){const s={$type:e};this.stack.push(s),e===bl?s.value="":t!==void 0&&(s.$infixName=t)}return r(n),a?this.construct():void 0}}extractHiddenTokens(e){const t=this.lexerResult.hidden;if(!t.length)return[];const r=e.startOffset;for(let n=0;nr)return t.splice(0,n);return t.splice(0,t.length)}consume(e,t,r){const n=this.wrapper.wrapConsume(e,t);if(!this.isRecording()&&this.isValidToken(n)){const a=this.extractHiddenTokens(n);this.nodeBuilder.addHiddenNodes(a);const s=this.nodeBuilder.buildLeafNode(n,r),{assignment:o,crossRef:l}=this.getAssignment(r),u=this.current;if(o){const c=Ar(r)?n.image:this.converter.convert(n.image,s);this.assign(o.operator,o.feature,c,s,l)}else if(jo(u)){let c=n.image;Ar(r)||(c=this.converter.convert(c,s).toString()),u.value+=c}}}isValidToken(e){return!e.isInsertedInRecovery&&!isNaN(e.startOffset)&&typeof e.endOffset=="number"&&!isNaN(e.endOffset)}subrule(e,t,r,n,a){let s;!this.isRecording()&&!r&&(s=this.nodeBuilder.buildCompositeNode(n));let o;try{o=this.wrapper.wrapSubrule(e,t,a)}finally{this.isRecording()||(o===void 0&&!r&&(o=this.construct()),o!==void 0&&s&&s.length>0&&this.performSubruleAssignment(o,n,s))}}performSubruleAssignment(e,t,r){const{assignment:n,crossRef:a}=this.getAssignment(t);if(n)this.assign(n.operator,n.feature,e,r,a);else if(!n){const s=this.current;if(jo(s))s.value+=e.toString();else if(typeof e=="object"&&e){const l=this.assignWithoutOverride(e,s);this.stack.pop(),this.stack.push(l)}}}action(e,t){if(!this.isRecording()){let r=this.current;if(t.feature&&t.operator){r=this.construct(),this.nodeBuilder.removeNode(r.$cstNode),this.nodeBuilder.buildCompositeNode(t).content.push(r.$cstNode);const a={$type:e};this.stack.push(a),this.assign(t.operator,t.feature,r,r.$cstNode)}else r.$type=e}}construct(){if(this.isRecording())return;const e=this.stack.pop();return this.nodeBuilder.construct(e),"$infixName"in e?this.constructInfix(e,this.operatorPrecedence.get(e.$infixName)):jo(e)?this.converter.convert(e.value,e.$cstNode):(Pd(this.astReflection,e),e)}constructInfix(e,t){const r=e.parts;if(!Array.isArray(r)||r.length===0)return;const n=e.operators;if(!Array.isArray(n)||r.length<2)return r[0];let a=0,s=-1;for(let v=0;vs?(s=S.precedence,a=v):S.precedence===s&&(S.rightAssoc||(a=v))}const o=n.slice(0,a),l=n.slice(a+1),u=r.slice(0,a+1),c=r.slice(a+1),f={$infixName:e.$infixName,$type:e.$type,$cstNode:e.$cstNode,parts:u,operators:o},d={$infixName:e.$infixName,$type:e.$type,$cstNode:e.$cstNode,parts:c,operators:l},m=this.constructInfix(f,t),g=this.constructInfix(d,t);return{$type:e.$type,$cstNode:e.$cstNode,left:m,operator:n[a],right:g}}getAssignment(e){if(!this.assignmentMap.has(e)){const t=Mn(e,Rr);this.assignmentMap.set(e,{assignment:t,crossRef:t&&Fn(t.terminal)?t.terminal.isMulti?"multi":"single":void 0})}return this.assignmentMap.get(e)}assign(e,t,r,n,a){const s=this.current;let o;switch(a==="single"&&typeof r=="string"?o=this.linker.buildReference(s,t,n,r):a==="multi"&&typeof r=="string"?o=this.linker.buildMultiReference(s,t,n,r):o=r,e){case"=":{s[t]=o;break}case"?=":{s[t]=!0;break}case"+=":Array.isArray(s[t])||(s[t]=[]),s[t].push(o)}}assignWithoutOverride(e,t){for(const[n,a]of Object.entries(t)){const s=e[n];s===void 0?e[n]=a:Array.isArray(s)&&Array.isArray(a)&&(a.push(...s),e[n]=a)}const r=e.$cstNode;return r&&(r.astNode=void 0,e.$cstNode=void 0),e}get definitionErrors(){return this.wrapper.definitionErrors}},MS=class{static{i(this,"AbstractParserErrorMessageProvider")}buildMismatchTokenMessage(e){return Ga.buildMismatchTokenMessage(e)}buildNotAllInputParsedMessage(e){return Ga.buildNotAllInputParsedMessage(e)}buildNoViableAltMessage(e){return Ga.buildNoViableAltMessage(e)}buildEarlyExitMessage(e){return Ga.buildEarlyExitMessage(e)}},Lm=class extends MS{static{i(this,"LangiumParserErrorMessageProvider")}buildMismatchTokenMessage({expected:e,actual:t}){return`Expecting ${e.LABEL?"`"+e.LABEL+"`":e.name.endsWith(":KW")?`keyword '${e.name.substring(0,e.name.length-3)}'`:`token of type '${e.name}'`} but found \`${t.image}\`.`}buildNotAllInputParsedMessage({firstRedundant:e}){return`Expecting end of file but found \`${e.image}\`.`}},GS=class extends Om{static{i(this,"LangiumCompletionParser")}constructor(){super(...arguments),this.tokens=[],this.elementStack=[],this.lastElementStack=[],this.nextTokenIndex=0,this.stackSize=0}action(){}construct(){}parse(e){this.resetState();const t=this.lexer.tokenize(e,{mode:"partial"});return this.tokens=t.tokens,this.wrapper.input=[...this.tokens],this.mainRule.call(this.wrapper,{}),this.unorderedGroups.clear(),{tokens:this.tokens,elementStack:[...this.lastElementStack],tokenIndex:this.nextTokenIndex}}rule(e,t){const r=this.wrapper.DEFINE_RULE(DS(e.name),this.startImplementation(t).bind(this));return this.allRules.set(e.name,r),e.entry&&(this.mainRule=r),r}resetState(){this.elementStack=[],this.lastElementStack=[],this.nextTokenIndex=0,this.stackSize=0}startImplementation(e){return t=>{const r=this.keepStackSize();try{e(t)}finally{this.resetStackSize(r)}}}removeUnexpectedElements(){this.elementStack.splice(this.stackSize)}keepStackSize(){const e=this.elementStack.length;return this.stackSize=e,e}resetStackSize(e){this.removeUnexpectedElements(),this.stackSize=e}consume(e,t,r){this.wrapper.wrapConsume(e,t),this.isRecording()||(this.lastElementStack=[...this.elementStack,r],this.nextTokenIndex=this.currIdx+1)}subrule(e,t,r,n,a){this.before(n),this.wrapper.wrapSubrule(e,t,a),this.after(n)}before(e){this.isRecording()||this.elementStack.push(e)}after(e){if(!this.isRecording()){const t=this.elementStack.lastIndexOf(e);t>=0&&this.elementStack.splice(t)}}get currIdx(){return this.wrapper.currIdx}},$F={recoveryEnabled:!0,nodeLocationTracking:"full",skipValidations:!0,errorMessageProvider:new Lm},FS=class extends sx{static{i(this,"ChevrotainWrapper")}constructor(e,t){const r=t&&"maxLookahead"in t;super(e,{...$F,lookaheadStrategy:r?new um({maxLookahead:t.maxLookahead}):new vF({logging:t.skipValidations?()=>{}:void 0}),...t})}get IS_RECORDING(){return this.RECORDING_PHASE}DEFINE_RULE(e,t,r){return this.RULE(e,t,r)}wrapSelfAnalysis(){this.performSelfAnalysis()}wrapConsume(e,t){return this.consume(e,t,void 0)}wrapSubrule(e,t,r){return this.subrule(e,t,{ARGS:[r]})}wrapOr(e,t){this.or(e,t)}wrapOption(e,t){this.option(e,t)}wrapMany(e,t){this.many(e,t)}wrapAtLeastOne(e,t){this.atLeastOne(e,t)}rule(e){return e.call(this,{})}},RF=class extends FS{static{i(this,"ProfilerWrapper")}constructor(e,t,r){super(e,t),this.task=r}rule(e){this.task.start(),this.task.startSubTask(this.ruleName(e));try{return super.rule(e)}finally{this.task.stopSubTask(this.ruleName(e)),this.task.stop()}}ruleName(e){return e.ruleName}subrule(e,t,r){this.task.startSubTask(this.ruleName(t));try{return super.subrule(e,t,r)}finally{this.task.stopSubTask(this.ruleName(t))}}};function Ou(e,t,r){return zS({parser:t,tokens:r,ruleNames:new Map},e),t}i(Ou,"createParser");function zS(e,t){const r=Hl(t,!1),n=ue(t.rules).filter(it).filter(s=>r.has(s));for(const s of n){const o={...e,consume:1,optional:1,subrule:1,many:1,or:1};e.parser.rule(s,Wr(o,s.definition))}const a=ue(t.rules).filter(qa).filter(s=>r.has(s));for(const s of a)e.parser.rule(s,jS(e,s))}i(zS,"buildRules");function jS(e,t){const r=t.call.rule.ref;if(!r)throw new Error("Could not resolve reference to infix operator rule: "+t.call.rule.$refText);if(Nt(r))throw new Error("Cannot use terminal rule in infix expression");const n=t.operators.precedences.flatMap(g=>g.operators),a={$type:"Group",elements:[]},s={$container:a,$type:"Assignment",feature:"parts",operator:"+=",terminal:t.call},o={$container:a,$type:"Group",elements:[],cardinality:"*"};a.elements.push(s,o);const u={$container:o,$type:"Assignment",feature:"operators",operator:"+=",terminal:{$type:"Alternatives",elements:n}},c={...s,$container:o};o.elements.push(u,c);const d=n.map(g=>e.tokens[g.value]).map((g,v)=>({ALT:i(()=>e.parser.consume(v,g,u),"ALT")}));let m;return g=>{m??(m=Lu(e,r)),e.parser.subrule(0,m,!1,s,g),e.parser.many(0,{DEF:i(()=>{e.parser.alternatives(0,d),e.parser.subrule(1,m,!1,c,g)},"DEF")})}}i(jS,"buildInfixRule");function Wr(e,t,r=!1){let n;if(Ar(t))n=HS(e,t);else if(jr(t))n=BS(e,t);else if(Rr(t))n=Wr(e,t.terminal);else if(Fn(t))n=Dm(e,t);else if(Er(t))n=US(e,t);else if(Fl(t))n=WS(e,t);else if(Ul(t))n=VS(e,t);else if(zn(t))n=qS(e,t);else if(Gd(t)){const a=e.consume++;n=i(()=>e.parser.consume(a,Ur,t),"method")}else throw new Wl(t.$cstNode,`Unexpected element type: ${t.$type}`);return xm(e,r?void 0:Ls(t),n,t.cardinality)}i(Wr,"buildElement");function BS(e,t){const r=Pn(t);return()=>e.parser.action(r,t)}i(BS,"buildAction");function US(e,t){const r=t.rule.ref;if(Gn(r)){const n=e.subrule++,a=it(r)&&r.fragment,s=t.arguments.length>0?KS(r,t.arguments):()=>({});let o;return l=>{o??(o=Lu(e,r)),e.parser.subrule(n,o,a,t,s(l))}}else if(Nt(r)){const n=e.consume++,a=Sl(e,r.name);return()=>e.parser.consume(n,a,t)}else if(r)qr();else throw new Wl(t.$cstNode,`Undefined rule: ${t.rule.$refText}`)}i(US,"buildRuleCall");function KS(e,t){if(t.some(n=>n.calledByName)){const n=t.map(a=>({parameterName:a.parameter?.ref?.name,predicate:xt(a.value)}));return a=>{const s={};for(const{parameterName:o,predicate:l}of n)o&&(s[o]=l(a));return s}}else{const n=t.map(a=>xt(a.value));return a=>{const s={};for(let o=0;ot(n)||r(n)}else if(xd(e)){const t=xt(e.left),r=xt(e.right);return n=>t(n)&&r(n)}else if(jd(e)){const t=xt(e.value);return r=>!t(r)}else if(Bd(e)){const t=e.parameter.ref.name;return r=>r!==void 0&&r[t]===!0}else if(Ld(e)){const t=!!e.true;return()=>t}qr()}i(xt,"buildPredicate");function WS(e,t){if(t.elements.length===1)return Wr(e,t.elements[0]);{const r=[];for(const a of t.elements){const s={ALT:Wr(e,a,!0)},o=Ls(a);o&&(s.GATE=xt(o)),r.push(s)}const n=e.or++;return a=>e.parser.alternatives(n,r.map(s=>{const o={ALT:i(()=>s.ALT(a),"ALT")},l=s.GATE;return l&&(o.GATE=()=>l(a)),o}))}}i(WS,"buildAlternatives");function VS(e,t){if(t.elements.length===1)return Wr(e,t.elements[0]);const r=[];for(const l of t.elements){const u={ALT:Wr(e,l,!0)},c=Ls(l);c&&(u.GATE=xt(c)),r.push(u)}const n=e.or++,a=i((l,u)=>{const c=u.getRuleStack().join("-");return`uGroup_${l}_${c}`},"idFunc"),s=i(l=>e.parser.alternatives(n,r.map((u,c)=>{const f={ALT:i(()=>!0,"ALT")},d=e.parser;f.ALT=()=>{if(u.ALT(l),!d.isRecording()){const g=a(n,d);d.unorderedGroups.get(g)||d.unorderedGroups.set(g,[]);const v=d.unorderedGroups.get(g);typeof v?.[c]>"u"&&(v[c]=!0)}};const m=u.GATE;return m?f.GATE=()=>m(l):f.GATE=()=>!d.unorderedGroups.get(a(n,d))?.[c],f})),"alternatives"),o=xm(e,Ls(t),s,"*");return l=>{o(l),e.parser.isRecording()||e.parser.unorderedGroups.delete(a(n,e.parser))}}i(VS,"buildUnorderedGroup");function qS(e,t){const r=t.elements.map(n=>Wr(e,n));return n=>r.forEach(a=>a(n))}i(qS,"buildGroup");function Ls(e){if(zn(e))return e.guardCondition}i(Ls,"getGuardCondition");function Dm(e,t,r=t.terminal){if(r)if(Er(r)&&it(r.rule.ref)){const n=r.rule.ref,a=e.subrule++;let s;return o=>{s??(s=Lu(e,n)),e.parser.subrule(a,s,!1,t,o)}}else if(Er(r)&&Nt(r.rule.ref)){const n=e.consume++,a=Sl(e,r.rule.ref.name);return()=>e.parser.consume(n,a,t)}else if(Ar(r)){const n=e.consume++,a=Sl(e,r.value);return()=>e.parser.consume(n,a,t)}else throw new Error("Could not build cross reference parser");else{if(!t.type.ref)throw new Error("Could not resolve reference to type: "+t.type.$refText);const a=Zl(t.type.ref)?.terminal;if(!a)throw new Error("Could not find name assignment for type: "+Pn(t.type.ref));return Dm(e,t,a)}}i(Dm,"buildCrossReference");function HS(e,t){const r=e.consume++,n=e.tokens[t.value];if(!n)throw new Error("Could not find token for keyword: "+t.value);return()=>e.parser.consume(r,n,t)}i(HS,"buildKeyword");function xm(e,t,r,n){const a=t&&xt(t);if(!n)if(a){const s=e.or++;return o=>e.parser.alternatives(s,[{ALT:i(()=>r(o),"ALT"),GATE:i(()=>a(o),"GATE")},{ALT:Uf(),GATE:i(()=>!a(o),"GATE")}])}else return r;if(n==="*"){const s=e.many++;return o=>e.parser.many(s,{DEF:i(()=>r(o),"DEF"),GATE:a?()=>a(o):void 0})}else if(n==="+"){const s=e.many++;if(a){const o=e.or++;return l=>e.parser.alternatives(o,[{ALT:i(()=>e.parser.atLeastOne(s,{DEF:i(()=>r(l),"DEF")}),"ALT"),GATE:i(()=>a(l),"GATE")},{ALT:Uf(),GATE:i(()=>!a(l),"GATE")}])}else return o=>e.parser.atLeastOne(s,{DEF:i(()=>r(o),"DEF")})}else if(n==="?"){const s=e.optional++;return o=>e.parser.optional(s,{DEF:i(()=>r(o),"DEF"),GATE:a?()=>a(o):void 0})}else qr()}i(xm,"wrap");function Lu(e,t){const r=YS(e,t),n=e.parser.getRule(r);if(!n)throw new Error(`Rule "${r}" not found."`);return n}i(Lu,"getRule");function YS(e,t){if(Gn(t))return t.name;if(e.ruleNames.has(t))return e.ruleNames.get(t);{let r=t,n=r.$container,a=t.$type;for(;!it(n);)(zn(n)||Fl(n)||Ul(n))&&(a=n.elements.indexOf(r).toString()+":"+a),r=n,n=n.$container;return a=n.name+":"+a,e.ruleNames.set(t,a),a}}i(YS,"getRuleName");function Sl(e,t){const r=e.tokens[t];if(!r)throw new Error(`Token "${t}" not found."`);return r}i(Sl,"getToken");function Mm(e){const t=e.Grammar,r=e.parser.Lexer,n=new GS(e);return Ou(t,n,r.definition),n.finalize(),n}i(Mm,"createCompletionParser");function Gm(e){const t=Fm(e);return t.finalize(),t}i(Gm,"createLangiumParser");function Fm(e){const t=e.Grammar,r=e.parser.Lexer,n=new xS(e);return Ou(t,n,r.definition)}i(Fm,"prepareLangiumParser");var Du=class{static{i(this,"DefaultTokenBuilder")}constructor(){this.diagnostics=[]}buildTokens(e,t){const r=ue(Hl(e,!1)),n=this.buildTerminalTokens(r),a=this.buildKeywordTokens(r,n,t);return a.push(...n),a}flushLexingReport(e){return{diagnostics:this.popDiagnostics()}}popDiagnostics(){const e=[...this.diagnostics];return this.diagnostics=[],e}buildTerminalTokens(e){return e.filter(Nt).filter(t=>!t.fragment).map(t=>this.buildTerminalToken(t)).toArray()}buildTerminalToken(e){const t=Bs(e),r=this.requiresCustomPattern(t)?this.regexPatternFunction(t):t,n={name:e.name,PATTERN:r};return typeof r=="function"&&(n.LINE_BREAKS=!0),e.hidden&&(n.GROUP=ql(t)?at.SKIPPED:"hidden"),n}requiresCustomPattern(e){return!!(e.flags.includes("u")||e.flags.includes("s"))}regexPatternFunction(e){const t=new RegExp(e,e.flags+"y");return(r,n)=>(t.lastIndex=n,t.exec(r))}buildKeywordTokens(e,t,r){return e.filter(Gn).flatMap(n=>Nr(n).filter(Ar)).distinct(n=>n.value).toArray().sort((n,a)=>a.value.length-n.value.length).map(n=>this.buildKeywordToken(n,t,!!r?.caseInsensitive))}buildKeywordToken(e,t,r){const n=this.buildKeywordPattern(e,r),a={name:e.value,PATTERN:n,LONGER_ALT:this.findLongerAlt(e,t)};return typeof n=="function"&&(a.LINE_BREAKS=!0),a}buildKeywordPattern(e,t){return t?new RegExp(ri(e.value),"i"):e.value}findLongerAlt(e,t){return t.reduce((r,n)=>{const a=n?.PATTERN;return a?.source&&cp("^"+a.source+"$",e.value)&&r.push(n),r},[])}},zm=class{static{i(this,"DefaultValueConverter")}convert(e,t){let r=t.grammarSource;if(Fn(r)&&(r=hp(r)),Er(r)){const n=r.rule.ref;if(!n)throw new Error("This cst node was not parsed by a rule.");return this.runConverter(n,e,t)}return e}runConverter(e,t,r){switch(e.name.toUpperCase()){case"INT":return Zt.convertInt(t);case"STRING":return Zt.convertString(t);case"ID":return Zt.convertID(t)}switch(Cp(e)?.toLowerCase()){case"number":return Zt.convertNumber(t);case"boolean":return Zt.convertBoolean(t);case"bigint":return Zt.convertBigint(t);case"date":return Zt.convertDate(t);default:return t}}},Zt;(function(e){function t(c){let f="";for(let d=1;d{typeof setImmediate>"u"?setTimeout(e,0):setImmediate(e)})}i(xu,"delayNextTick");var Bo=0,XS=10;function Mu(){return Bo=performance.now(),new pe.CancellationTokenSource}i(Mu,"startCancelableOperation");function jm(e){XS=e}i(jm,"setInterruptionPeriod");var tr=Symbol("OperationCancelled");function ta(e){return e===tr}i(ta,"isOperationCancelled");async function ze(e){if(e===pe.CancellationToken.None)return;const t=performance.now();if(t-Bo>=XS&&(Bo=t,await xu(),Bo=performance.now()),e.isCancellationRequested)throw tr}i(ze,"interruptAndCheck");var wr=class{static{i(this,"Deferred")}constructor(){this.promise=new Promise((e,t)=>{this.resolve=r=>(e(r),this),this.reject=r=>(t(r),this)})}},Ny=class Jf{static{i(this,"FullTextDocument")}constructor(t,r,n,a){this._uri=t,this._languageId=r,this._version=n,this._content=a,this._lineOffsets=void 0}get uri(){return this._uri}get languageId(){return this._languageId}get version(){return this._version}getText(t){if(t){const r=this.offsetAt(t.start),n=this.offsetAt(t.end);return this._content.substring(r,n)}return this._content}update(t,r){for(const n of t)if(Jf.isIncremental(n)){const a=Um(n.range),s=this.offsetAt(a.start),o=this.offsetAt(a.end);this._content=this._content.substring(0,s)+n.text+this._content.substring(o,this._content.length);const l=Math.max(a.start.line,0),u=Math.max(a.end.line,0);let c=this._lineOffsets;const f=Zf(n.text,!1,s);if(u-l===f.length)for(let m=0,g=f.length;mt?a=o:n=o+1}const s=n-1;return t=this.ensureBeforeEOL(t,r[s]),{line:s,character:t-r[s]}}offsetAt(t){const r=this.getLineOffsets();if(t.line>=r.length)return this._content.length;if(t.line<0)return 0;const n=r[t.line];if(t.character<=0)return n;const a=t.line+1r&&Bm(this._content.charCodeAt(t-1));)t--;return t}get lineCount(){return this.getLineOffsets().length}static isIncremental(t){const r=t;return r!=null&&typeof r.text=="string"&&r.range!==void 0&&(r.rangeLength===void 0||typeof r.rangeLength=="number")}static isFull(t){const r=t;return r!=null&&typeof r.text=="string"&&r.range===void 0&&r.rangeLength===void 0}},wl;(function(e){function t(a,s,o,l){return new Ny(a,s,o,l)}i(t,"create"),e.create=t;function r(a,s,o){if(a instanceof Ny)return a.update(s,o),a;throw new Error("TextDocument.update: document must be created by TextDocument.create")}i(r,"update"),e.update=r;function n(a,s){const o=a.getText(),l=Il(s.map(JS),(f,d)=>{const m=f.range.start.line-d.range.start.line;return m===0?f.range.start.character-d.range.start.character:m});let u=0;const c=[];for(const f of l){const d=a.offsetAt(f.range.start);if(du&&c.push(o.substring(u,d)),f.newText.length&&c.push(f.newText),u=a.offsetAt(f.range.end)}return c.push(o.substr(u)),c.join("")}i(n,"applyEdits"),e.applyEdits=n})(wl||(wl={}));function Il(e,t){if(e.length<=1)return e;const r=e.length/2|0,n=e.slice(0,r),a=e.slice(r);Il(n,t),Il(a,t);let s=0,o=0,l=0;for(;sr.line||t.line===r.line&&t.character>r.character?{start:r,end:t}:e}i(Um,"getWellformedRange");function JS(e){const t=Um(e.range);return t!==e.range?{newText:e.newText,range:t}:e}i(JS,"getWellformedEdit");var ZS;(()=>{var e={975:k=>{function C(T){if(typeof T!="string")throw new TypeError("Path must be a string. Received "+JSON.stringify(T))}i(C,"e");function y(T,$){for(var b,O="",x=0,D=-1,G=0,W=0;W<=T.length;++W){if(W2){var Y=O.lastIndexOf("/");if(Y!==O.length-1){Y===-1?(O="",x=0):x=(O=O.slice(0,Y)).length-1-O.lastIndexOf("/"),D=W,G=0;continue}}else if(O.length===2||O.length===1){O="",x=0,D=W,G=0;continue}}$&&(O.length>0?O+="/..":O="..",x=2)}else O.length>0?O+="/"+T.slice(D+1,W):O=T.slice(D+1,W),x=W-D-1;D=W,G=0}else b===46&&G!==-1?++G:G=-1}return O}i(y,"r");var E={resolve:i(function(){for(var T,$="",b=!1,O=arguments.length-1;O>=-1&&!b;O--){var x;O>=0?x=arguments[O]:(T===void 0&&(T=process.cwd()),x=T),C(x),x.length!==0&&($=x+"/"+$,b=x.charCodeAt(0)===47)}return $=y($,!b),b?$.length>0?"/"+$:"/":$.length>0?$:"."},"resolve"),normalize:i(function(T){if(C(T),T.length===0)return".";var $=T.charCodeAt(0)===47,b=T.charCodeAt(T.length-1)===47;return(T=y(T,!$)).length!==0||$||(T="."),T.length>0&&b&&(T+="/"),$?"/"+T:T},"normalize"),isAbsolute:i(function(T){return C(T),T.length>0&&T.charCodeAt(0)===47},"isAbsolute"),join:i(function(){if(arguments.length===0)return".";for(var T,$=0;$0&&(T===void 0?T=b:T+="/"+b)}return T===void 0?".":E.normalize(T)},"join"),relative:i(function(T,$){if(C(T),C($),T===$||(T=E.resolve(T))===($=E.resolve($)))return"";for(var b=1;bW){if($.charCodeAt(D+V)===47)return $.slice(D+V+1);if(V===0)return $.slice(D+V)}else x>W&&(T.charCodeAt(b+V)===47?Y=V:V===0&&(Y=0));break}var Pe=T.charCodeAt(b+V);if(Pe!==$.charCodeAt(D+V))break;Pe===47&&(Y=V)}var oe="";for(V=b+Y+1;V<=O;++V)V!==O&&T.charCodeAt(V)!==47||(oe.length===0?oe+="..":oe+="/..");return oe.length>0?oe+$.slice(D+Y):(D+=Y,$.charCodeAt(D)===47&&++D,$.slice(D))},"relative"),_makeLong:i(function(T){return T},"_makeLong"),dirname:i(function(T){if(C(T),T.length===0)return".";for(var $=T.charCodeAt(0),b=$===47,O=-1,x=!0,D=T.length-1;D>=1;--D)if(($=T.charCodeAt(D))===47){if(!x){O=D;break}}else x=!1;return O===-1?b?"/":".":b&&O===1?"//":T.slice(0,O)},"dirname"),basename:i(function(T,$){if($!==void 0&&typeof $!="string")throw new TypeError('"ext" argument must be a string');C(T);var b,O=0,x=-1,D=!0;if($!==void 0&&$.length>0&&$.length<=T.length){if($.length===T.length&&$===T)return"";var G=$.length-1,W=-1;for(b=T.length-1;b>=0;--b){var Y=T.charCodeAt(b);if(Y===47){if(!D){O=b+1;break}}else W===-1&&(D=!1,W=b+1),G>=0&&(Y===$.charCodeAt(G)?--G==-1&&(x=b):(G=-1,x=W))}return O===x?x=W:x===-1&&(x=T.length),T.slice(O,x)}for(b=T.length-1;b>=0;--b)if(T.charCodeAt(b)===47){if(!D){O=b+1;break}}else x===-1&&(D=!1,x=b+1);return x===-1?"":T.slice(O,x)},"basename"),extname:i(function(T){C(T);for(var $=-1,b=0,O=-1,x=!0,D=0,G=T.length-1;G>=0;--G){var W=T.charCodeAt(G);if(W!==47)O===-1&&(x=!1,O=G+1),W===46?$===-1?$=G:D!==1&&(D=1):$!==-1&&(D=-1);else if(!x){b=G+1;break}}return $===-1||O===-1||D===0||D===1&&$===O-1&&$===b+1?"":T.slice($,O)},"extname"),format:i(function(T){if(T===null||typeof T!="object")throw new TypeError('The "pathObject" argument must be of type Object. Received type '+typeof T);return(function($,b){var O=b.dir||b.root,x=b.base||(b.name||"")+(b.ext||"");return O?O===b.root?O+x:O+"/"+x:x})(0,T)},"format"),parse:i(function(T){C(T);var $={root:"",dir:"",base:"",ext:"",name:""};if(T.length===0)return $;var b,O=T.charCodeAt(0),x=O===47;x?($.root="/",b=1):b=0;for(var D=-1,G=0,W=-1,Y=!0,V=T.length-1,Pe=0;V>=b;--V)if((O=T.charCodeAt(V))!==47)W===-1&&(Y=!1,W=V+1),O===46?D===-1?D=V:Pe!==1&&(Pe=1):D!==-1&&(Pe=-1);else if(!Y){G=V+1;break}return D===-1||W===-1||Pe===0||Pe===1&&D===W-1&&D===G+1?W!==-1&&($.base=$.name=G===0&&x?T.slice(1,W):T.slice(G,W)):(G===0&&x?($.name=T.slice(1,D),$.base=T.slice(1,W)):($.name=T.slice(G,D),$.base=T.slice(G,W)),$.ext=T.slice(D,W)),G>0?$.dir=T.slice(0,G-1):x&&($.dir="/"),$},"parse"),sep:"/",delimiter:":",win32:null,posix:null};E.posix=E,k.exports=E}},t={};function r(k){var C=t[k];if(C!==void 0)return C.exports;var y=t[k]={exports:{}};return e[k](y,y.exports,r),y.exports}i(r,"r"),r.d=(k,C)=>{for(var y in C)r.o(C,y)&&!r.o(k,y)&&Object.defineProperty(k,y,{enumerable:!0,get:C[y]})},r.o=(k,C)=>Object.prototype.hasOwnProperty.call(k,C),r.r=k=>{typeof Symbol<"u"&&Symbol.toStringTag&&Object.defineProperty(k,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(k,"__esModule",{value:!0})};var n={};let a;r.r(n),r.d(n,{URI:i(()=>m,"URI"),Utils:i(()=>Se,"Utils")}),typeof process=="object"?a=process.platform==="win32":typeof navigator=="object"&&(a=navigator.userAgent.indexOf("Windows")>=0);const s=/^\w[\w\d+.-]*$/,o=/^\//,l=/^\/\//;function u(k,C){if(!k.scheme&&C)throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${k.authority}", path: "${k.path}", query: "${k.query}", fragment: "${k.fragment}"}`);if(k.scheme&&!s.test(k.scheme))throw new Error("[UriError]: Scheme contains illegal characters.");if(k.path){if(k.authority){if(!o.test(k.path))throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character')}else if(l.test(k.path))throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")')}}i(u,"a");const c="",f="/",d=/^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;class m{static{i(this,"l")}static isUri(C){return C instanceof m||!!C&&typeof C.authority=="string"&&typeof C.fragment=="string"&&typeof C.path=="string"&&typeof C.query=="string"&&typeof C.scheme=="string"&&typeof C.fsPath=="string"&&typeof C.with=="function"&&typeof C.toString=="function"}scheme;authority;path;query;fragment;constructor(C,y,E,T,$,b=!1){typeof C=="object"?(this.scheme=C.scheme||c,this.authority=C.authority||c,this.path=C.path||c,this.query=C.query||c,this.fragment=C.fragment||c):(this.scheme=(function(O,x){return O||x?O:"file"})(C,b),this.authority=y||c,this.path=(function(O,x){switch(O){case"https":case"http":case"file":x?x[0]!==f&&(x=f+x):x=f}return x})(this.scheme,E||c),this.query=T||c,this.fragment=$||c,u(this,b))}get fsPath(){return I(this,!1)}with(C){if(!C)return this;let{scheme:y,authority:E,path:T,query:$,fragment:b}=C;return y===void 0?y=this.scheme:y===null&&(y=c),E===void 0?E=this.authority:E===null&&(E=c),T===void 0?T=this.path:T===null&&(T=c),$===void 0?$=this.query:$===null&&($=c),b===void 0?b=this.fragment:b===null&&(b=c),y===this.scheme&&E===this.authority&&T===this.path&&$===this.query&&b===this.fragment?this:new v(y,E,T,$,b)}static parse(C,y=!1){const E=d.exec(C);return E?new v(E[2]||c,X(E[4]||c),X(E[5]||c),X(E[7]||c),X(E[9]||c),y):new v(c,c,c,c,c)}static file(C){let y=c;if(a&&(C=C.replace(/\\/g,f)),C[0]===f&&C[1]===f){const E=C.indexOf(f,2);E===-1?(y=C.substring(2),C=f):(y=C.substring(2,E),C=C.substring(E)||f)}return new v("file",y,C,c,c)}static from(C){const y=new v(C.scheme,C.authority,C.path,C.query,C.fragment);return u(y,!0),y}toString(C=!1){return R(this,C)}toJSON(){return this}static revive(C){if(C){if(C instanceof m)return C;{const y=new v(C);return y._formatted=C.external,y._fsPath=C._sep===g?C.fsPath:null,y}}return C}}const g=a?1:void 0;class v extends m{static{i(this,"d")}_formatted=null;_fsPath=null;get fsPath(){return this._fsPath||(this._fsPath=I(this,!1)),this._fsPath}toString(C=!1){return C?R(this,!0):(this._formatted||(this._formatted=R(this,!1)),this._formatted)}toJSON(){const C={$mid:1};return this._fsPath&&(C.fsPath=this._fsPath,C._sep=g),this._formatted&&(C.external=this._formatted),this.path&&(C.path=this.path),this.scheme&&(C.scheme=this.scheme),this.authority&&(C.authority=this.authority),this.query&&(C.query=this.query),this.fragment&&(C.fragment=this.fragment),C}}const _={58:"%3A",47:"%2F",63:"%3F",35:"%23",91:"%5B",93:"%5D",64:"%40",33:"%21",36:"%24",38:"%26",39:"%27",40:"%28",41:"%29",42:"%2A",43:"%2B",44:"%2C",59:"%3B",61:"%3D",32:"%20"};function S(k,C,y){let E,T=-1;for(let $=0;$=97&&b<=122||b>=65&&b<=90||b>=48&&b<=57||b===45||b===46||b===95||b===126||C&&b===47||y&&b===91||y&&b===93||y&&b===58)T!==-1&&(E+=encodeURIComponent(k.substring(T,$)),T=-1),E!==void 0&&(E+=k.charAt($));else{E===void 0&&(E=k.substr(0,$));const O=_[b];O!==void 0?(T!==-1&&(E+=encodeURIComponent(k.substring(T,$)),T=-1),E+=O):T===-1&&(T=$)}}return T!==-1&&(E+=encodeURIComponent(k.substring(T))),E!==void 0?E:k}i(S,"m");function w(k){let C;for(let y=0;y1&&k.scheme==="file"?`//${k.authority}${k.path}`:k.path.charCodeAt(0)===47&&(k.path.charCodeAt(1)>=65&&k.path.charCodeAt(1)<=90||k.path.charCodeAt(1)>=97&&k.path.charCodeAt(1)<=122)&&k.path.charCodeAt(2)===58?C?k.path.substr(1):k.path[1].toLowerCase()+k.path.substr(2):k.path,a&&(y=y.replace(/\//g,"\\")),y}i(I,"v");function R(k,C){const y=C?w:S;let E="",{scheme:T,authority:$,path:b,query:O,fragment:x}=k;if(T&&(E+=T,E+=":"),($||T==="file")&&(E+=f,E+=f),$){let D=$.indexOf("@");if(D!==-1){const G=$.substr(0,D);$=$.substr(D+1),D=G.lastIndexOf(":"),D===-1?E+=y(G,!1,!1):(E+=y(G.substr(0,D),!1,!1),E+=":",E+=y(G.substr(D+1),!1,!0)),E+="@"}$=$.toLowerCase(),D=$.lastIndexOf(":"),D===-1?E+=y($,!1,!0):(E+=y($.substr(0,D),!1,!0),E+=$.substr(D))}if(b){if(b.length>=3&&b.charCodeAt(0)===47&&b.charCodeAt(2)===58){const D=b.charCodeAt(1);D>=65&&D<=90&&(b=`/${String.fromCharCode(D+32)}:${b.substr(3)}`)}else if(b.length>=2&&b.charCodeAt(1)===58){const D=b.charCodeAt(0);D>=65&&D<=90&&(b=`${String.fromCharCode(D+32)}:${b.substr(2)}`)}E+=y(b,!0,!1)}return O&&(E+="?",E+=y(O,!1,!1)),x&&(E+="#",E+=C?x:S(x,!1,!1)),E}i(R,"b");function P(k){try{return decodeURIComponent(k)}catch{return k.length>3?k.substr(0,3)+P(k.substr(3)):k}}i(P,"C");const z=/(%[0-9A-Za-z][0-9A-Za-z])+/g;function X(k){return k.match(z)?k.replace(z,(C=>P(C))):k}i(X,"w");var Z=r(975);const ce=Z.posix||Z,se="/";var Se;(function(k){k.joinPath=function(C,...y){return C.with({path:ce.join(C.path,...y)})},k.resolvePath=function(C,...y){let E=C.path,T=!1;E[0]!==se&&(E=se+E,T=!0);let $=ce.resolve(E,...y);return T&&$[0]===se&&!C.authority&&($=$.substring(1)),C.with({path:$})},k.dirname=function(C){if(C.path.length===0||C.path===se)return C;let y=ce.dirname(C.path);return y.length===1&&y.charCodeAt(0)===46&&(y=""),C.with({path:y})},k.basename=function(C){return ce.basename(C.path)},k.extname=function(C){return ce.extname(C.path)}})(Se||(Se={})),ZS=n})();var{URI:Tt,Utils:Di}=ZS,nt;(function(e){e.basename=Di.basename,e.dirname=Di.dirname,e.extname=Di.extname,e.joinPath=Di.joinPath,e.resolvePath=Di.resolvePath;const t=typeof process=="object"&&process?.platform==="win32";function r(o,l){return o?.toString()===l?.toString()}i(r,"equals"),e.equals=r;function n(o,l){const u=typeof o=="string"?Tt.parse(o).path:o.path,c=typeof l=="string"?Tt.parse(l).path:l.path,f=u.split("/").filter(_=>_.length>0),d=c.split("/").filter(_=>_.length>0);if(t){const _=/^[A-Z]:$/;if(f[0]&&_.test(f[0])&&(f[0]=f[0].toLowerCase()),d[0]&&_.test(d[0])&&(d[0]=d[0].toLowerCase()),f[0]!==d[0])return c.substring(1)}let m=0;for(;m({name:n.name,uri:nt.joinPath(Tt.parse(t),n.name).toString(),element:n.element})):[]}all(){return this.collectValues(this.root)}findAll(e){const t=this.getNode(nt.normalize(e),!1);return t?this.collectValues(t):[]}getNode(e,t){const r=e.split("/");e.charAt(e.length-1)==="/"&&r.pop();let n=this.root;for(const a of r){let s=n.children.get(a);if(!s)if(t)s={name:a,children:new Map,parent:n},n.children.set(a,s);else return;n=s}return n}collectValues(e){const t=[];e.element&&t.push(e.element);for(const r of e.children.values())t.push(...this.collectValues(r));return t}},J;(function(e){e[e.Changed=0]="Changed",e[e.Parsed=1]="Parsed",e[e.IndexedContent=2]="IndexedContent",e[e.ComputedScopes=3]="ComputedScopes",e[e.Linked=4]="Linked",e[e.IndexedReferences=5]="IndexedReferences",e[e.Validated=6]="Validated"})(J||(J={}));var QS=class{static{i(this,"DefaultLangiumDocumentFactory")}constructor(e){this.serviceRegistry=e.ServiceRegistry,this.textDocuments=e.workspace.TextDocuments,this.fileSystemProvider=e.workspace.FileSystemProvider}async fromUri(e,t=pe.CancellationToken.None){const r=await this.fileSystemProvider.readFile(e);return this.createAsync(e,r,t)}fromTextDocument(e,t,r){return t=t??Tt.parse(e.uri),pe.CancellationToken.is(r)?this.createAsync(t,e,r):this.create(t,e,r)}fromString(e,t,r){return pe.CancellationToken.is(r)?this.createAsync(t,e,r):this.create(t,e,r)}fromModel(e,t){return this.create(t,{$model:e})}create(e,t,r){if(typeof t=="string"){const n=this.parse(e,t,r);return this.createLangiumDocument(n,e,void 0,t)}else if("$model"in t){const n={value:t.$model,parserErrors:[],lexerErrors:[]};return this.createLangiumDocument(n,e)}else{const n=this.parse(e,t.getText(),r);return this.createLangiumDocument(n,e,t)}}async createAsync(e,t,r){if(typeof t=="string"){const n=await this.parseAsync(e,t,r);return this.createLangiumDocument(n,e,void 0,t)}else{const n=await this.parseAsync(e,t.getText(),r);return this.createLangiumDocument(n,e,t)}}createLangiumDocument(e,t,r,n){let a;if(r)a={parseResult:e,uri:t,state:J.Parsed,references:[],textDocument:r};else{const s=this.createTextDocumentGetter(t,n);a={parseResult:e,uri:t,state:J.Parsed,references:[],get textDocument(){return s()}}}return e.value.$document=a,a}async update(e,t){const r=e.parseResult.value.$cstNode?.root.fullText,n=this.textDocuments?.get(e.uri.toString()),a=n?n.getText():await this.fileSystemProvider.readFile(e.uri);if(n)Object.defineProperty(e,"textDocument",{value:n});else{const s=this.createTextDocumentGetter(e.uri,a);Object.defineProperty(e,"textDocument",{get:s})}return r!==a&&(e.parseResult=await this.parseAsync(e.uri,a,t),e.parseResult.value.$document=e),e.state=J.Parsed,e}parse(e,t,r){return this.serviceRegistry.getServices(e).parser.LangiumParser.parse(t,r)}parseAsync(e,t,r){return this.serviceRegistry.getServices(e).parser.AsyncParser.parse(t,r)}createTextDocumentGetter(e,t){const r=this.serviceRegistry;let n;return()=>n??(n=wl.create(e.toString(),r.getServices(e).LanguageMetaData.languageId,0,t??""))}},ew=class{static{i(this,"DefaultLangiumDocuments")}constructor(e){this.documentTrie=new Km,this.services=e,this.langiumDocumentFactory=e.workspace.LangiumDocumentFactory,this.documentBuilder=()=>e.workspace.DocumentBuilder}get all(){return ue(this.documentTrie.all())}addDocument(e){const t=e.uri.toString();if(this.documentTrie.has(t))throw new Error(`A document with the URI '${t}' is already present.`);this.documentTrie.insert(t,e)}getDocument(e){const t=e.toString();return this.documentTrie.find(t)}getDocuments(e){const t=e.toString();return this.documentTrie.findAll(t)}async getOrCreateDocument(e,t){let r=this.getDocument(e);return r||(r=await this.langiumDocumentFactory.fromUri(e,t),this.addDocument(r),r)}createDocument(e,t,r){if(r)return this.langiumDocumentFactory.fromString(t,e,r).then(n=>(this.addDocument(n),n));{const n=this.langiumDocumentFactory.fromString(t,e);return this.addDocument(n),n}}hasDocument(e){return this.documentTrie.has(e.toString())}invalidateDocument(e){const t=e.toString(),r=this.documentTrie.find(t);return r&&this.documentBuilder().resetToState(r,J.Changed),r}deleteDocument(e){const t=e.toString(),r=this.documentTrie.find(t);return r&&(r.state=J.Changed,this.documentTrie.delete(t)),r}deleteDocuments(e){const t=e.toString(),r=this.documentTrie.findAll(t);for(const n of r)n.state=J.Changed;return this.documentTrie.delete(t),r}},un=Symbol("RefResolving"),tw=class{static{i(this,"DefaultLinker")}constructor(e){this.reflection=e.shared.AstReflection,this.langiumDocuments=()=>e.shared.workspace.LangiumDocuments,this.scopeProvider=e.references.ScopeProvider,this.astNodeLocator=e.workspace.AstNodeLocator,this.profiler=e.shared.profilers.LangiumProfiler,this.languageId=e.LanguageMetaData.languageId}async link(e,t=pe.CancellationToken.None){if(this.profiler?.isActive("linking")){const r=this.profiler.createTask("linking",this.languageId);r.start();try{for(const n of Gt(e.parseResult.value))await ze(t),Va(n).forEach(a=>{const s=`${n.$type}:${a.property}`;r.startSubTask(s);try{this.doLink(a,e)}finally{r.stopSubTask(s)}})}finally{r.stop()}}else for(const r of Gt(e.parseResult.value))await ze(t),Va(r).forEach(n=>this.doLink(n,e))}doLink(e,t){const r=e.reference;if("_ref"in r&&r._ref===void 0){r._ref=un;try{const n=this.getCandidate(e);if(pn(n))r._ref=n;else{r._nodeDescription=n;const a=this.loadAstNode(n);r._ref=a??this.createLinkingError(e,n)}}catch(n){console.error(`An error occurred while resolving reference to '${r.$refText}':`,n);const a=n.message??String(n);r._ref={info:e,message:`An error occurred while resolving reference to '${r.$refText}': ${a}`}}t.references.push(r)}else if("_items"in r&&r._items===void 0){r._items=un;try{const n=this.getCandidates(e),a=[];if(pn(n))r._linkingError=n;else for(const s of n){const o=this.loadAstNode(s);o&&a.push({ref:o,$nodeDescription:s})}r._items=a}catch(n){r._linkingError={info:e,message:`An error occurred while resolving reference to '${r.$refText}': ${n}`},r._items=[]}t.references.push(r)}}unlink(e){for(const t of e.references)"_ref"in t?(t._ref=void 0,delete t._nodeDescription):"_items"in t&&(t._items=void 0,delete t._linkingError);e.references=[]}getCandidate(e){return this.scopeProvider.getScope(e).getElement(e.reference.$refText)??this.createLinkingError(e)}getCandidates(e){const r=this.scopeProvider.getScope(e).getElements(e.reference.$refText).distinct(n=>`${n.documentUri}#${n.path}`).toArray();return r.length>0?r:this.createLinkingError(e)}buildReference(e,t,r,n){const a=this,s={$refNode:r,$refText:n,_ref:void 0,get ref(){if(Oe(this._ref))return this._ref;if(wd(this._nodeDescription)){const o=a.loadAstNode(this._nodeDescription);this._ref=o??a.createLinkingError({reference:s,container:e,property:t},this._nodeDescription)}else if(this._ref===void 0){this._ref=un;const o=Fa(e).$document,l=a.getLinkedNode({reference:s,container:e,property:t});if(l.error&&o&&o.state0))return this._linkingError=a.createLinkingError({reference:s,container:e,property:t})}};return s}throwCyclicReferenceError(e,t,r){throw new Error(`Cyclic reference resolution detected: ${this.astNodeLocator.getAstNodePath(e)}/${t} (symbol '${r}')`)}getLinkedNode(e){try{const t=this.getCandidate(e);if(pn(t))return{error:t};const r=this.loadAstNode(t);return r?{node:r,descr:t}:{descr:t,error:this.createLinkingError(e,t)}}catch(t){console.error(`An error occurred while resolving reference to '${e.reference.$refText}':`,t);const r=t.message??String(t);return{error:{info:e,message:`An error occurred while resolving reference to '${e.reference.$refText}': ${r}`}}}}loadAstNode(e){if(e.node)return e.node;const t=this.langiumDocuments().getDocument(e.documentUri);if(t)return this.astNodeLocator.getAstNode(t.parseResult.value,e.path)}createLinkingError(e,t){const r=Fa(e.container).$document;r&&r.stateFn(t)&&t.isMulti)}findDeclarations(e){if(e){const t=Tp(e),r=e.astNode;if(t&&r){const n=r[t.feature];if(rt(n)||rr(n))return qo(n);if(Array.isArray(n)){for(const a of n)if((rt(a)||rr(a))&&a.$refNode&&a.$refNode.offset<=e.offset&&a.$refNode.end>=e.end)return qo(a)}}if(r){const n=this.nameProvider.getNameNode(r);if(n&&(n===e||Zd(e,n)))return this.getSelfNodes(r)}}return[]}getSelfNodes(e){if(this.hasMultiReference){const t=this.index.findAllReferences(e,this.nodeLocator.getAstNodePath(e)),r=this.getNodeFromReferenceDescription(t.head());if(r){for(const n of Va(r))if(rr(n.reference)&&n.reference.items.some(a=>a.ref===e))return n.reference.items.map(a=>a.ref)}return[e]}else return[e]}getNodeFromReferenceDescription(e){if(!e)return;const t=this.documents.getDocument(e.sourceUri);if(t)return this.nodeLocator.getAstNode(t.parseResult.value,e.sourcePath)}findDeclarationNodes(e){const t=this.findDeclarations(e),r=[];for(const n of t){const a=this.nameProvider.getNameNode(n)??n.$cstNode;a&&r.push(a)}return r}findReferences(e,t){const r=[];t.includeDeclaration&&r.push(...this.getSelfReferences(e));let n=this.index.findAllReferences(e,this.nodeLocator.getAstNodePath(e));return t.documentUri&&(n=n.filter(a=>nt.equals(a.sourceUri,t.documentUri))),r.push(...n),ue(r)}getSelfReferences(e){const t=this.getSelfNodes(e),r=[];for(const n of t){const a=this.nameProvider.getNameNode(n);if(a){const s=Mt(n),o=this.nodeLocator.getAstNodePath(n);r.push({sourceUri:s.uri,sourcePath:o,targetUri:s.uri,targetPath:o,segment:Ya(a),local:!0})}}return r}},Ir=class{static{i(this,"MultiMap")}constructor(e){if(this.map=new Map,e)for(const[t,r]of e)this.add(t,r)}get size(){return Ts.sum(ue(this.map.values()).map(e=>e.length))}clear(){this.map.clear()}delete(e,t){if(t===void 0)return this.map.delete(e);{const r=this.map.get(e);if(r){const n=r.indexOf(t);if(n>=0)return r.length===1?this.map.delete(e):r.splice(n,1),!0}return!1}}get(e){return this.map.get(e)??[]}getStream(e){const t=this.map.get(e);return t?ue(t):Ua}has(e,t){if(t===void 0)return this.map.has(e);{const r=this.map.get(e);return r?r.indexOf(t)>=0:!1}}add(e,t){return this.map.has(e)?this.map.get(e).push(t):this.map.set(e,[t]),this}addAll(e,t){return this.map.has(e)?this.map.get(e).push(...t):this.map.set(e,Array.from(t)),this}forEach(e){this.map.forEach((t,r)=>t.forEach(n=>e(n,r,this)))}[Symbol.iterator](){return this.entries().iterator()}entries(){return ue(this.map.entries()).flatMap(([e,t])=>t.map(r=>[e,r]))}keys(){return ue(this.map.keys())}values(){return ue(this.map.values()).flat()}entriesGroupedByKey(){return ue(this.map.entries())}},Nl=class{static{i(this,"BiMap")}get size(){return this.map.size}constructor(e){if(this.map=new Map,this.inverse=new Map,e)for(const[t,r]of e)this.set(t,r)}clear(){this.map.clear(),this.inverse.clear()}set(e,t){return this.map.set(e,t),this.inverse.set(t,e),this}get(e){return this.map.get(e)}getKey(e){return this.inverse.get(e)}delete(e){const t=this.map.get(e);return t!==void 0?(this.map.delete(e),this.inverse.delete(t),!0):!1}},aw=class{static{i(this,"DefaultScopeComputation")}constructor(e){this.nameProvider=e.references.NameProvider,this.descriptions=e.workspace.AstNodeDescriptionProvider}async collectExportedSymbols(e,t=pe.CancellationToken.None){return this.collectExportedSymbolsForNode(e.parseResult.value,e,void 0,t)}async collectExportedSymbolsForNode(e,t,r=Gs,n=pe.CancellationToken.None){const a=[];this.addExportedSymbol(e,a,t);for(const s of r(e))await ze(n),this.addExportedSymbol(s,a,t);return a}addExportedSymbol(e,t,r){const n=this.nameProvider.getName(e);n&&t.push(this.descriptions.createDescription(e,n,r))}async collectLocalSymbols(e,t=pe.CancellationToken.None){const r=e.parseResult.value,n=new Ir;for(const a of Nr(r))await ze(t),this.addLocalSymbol(a,e,n);return n}addLocalSymbol(e,t,r){const n=e.$container;if(n){const a=this.nameProvider.getName(e);a&&r.add(n,this.descriptions.createDescription(e,a,t))}}},Qf=class{static{i(this,"StreamScope")}constructor(e,t,r){this.elements=e,this.outerScope=t,this.caseInsensitive=r?.caseInsensitive??!1,this.concatOuterScope=r?.concatOuterScope??!0}getAllElements(){return this.outerScope?this.elements.concat(this.outerScope.getAllElements()):this.elements}getElement(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.caseInsensitive?this.elements.find(n=>n.name.toLowerCase()===t):this.elements.find(n=>n.name===e);if(r)return r;if(this.outerScope)return this.outerScope.getElement(e)}getElements(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.caseInsensitive?this.elements.filter(n=>n.name.toLowerCase()===t):this.elements.filter(n=>n.name===e);return(this.concatOuterScope||r.isEmpty())&&this.outerScope?r.concat(this.outerScope.getElements(e)):r}},AF=class{static{i(this,"MapScope")}constructor(e,t,r){this.elements=new Map,this.caseInsensitive=r?.caseInsensitive??!1,this.concatOuterScope=r?.concatOuterScope??!0;for(const n of e){const a=this.caseInsensitive?n.name.toLowerCase():n.name;this.elements.set(a,n)}this.outerScope=t}getElement(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.elements.get(t);if(r)return r;if(this.outerScope)return this.outerScope.getElement(e)}getElements(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.elements.get(t),n=r?[r]:[];return(this.concatOuterScope||n.length>0)&&this.outerScope?ue(n).concat(this.outerScope.getElements(e)):ue(n)}getAllElements(){let e=ue(this.elements.values());return this.outerScope&&(e=e.concat(this.outerScope.getAllElements())),e}},iw=class{static{i(this,"MultiMapScope")}constructor(e,t,r){this.elements=new Ir,this.caseInsensitive=r?.caseInsensitive??!1,this.concatOuterScope=r?.concatOuterScope??!0;for(const n of e){const a=this.caseInsensitive?n.name.toLowerCase():n.name;this.elements.add(a,n)}this.outerScope=t}getElement(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.elements.get(t)[0];if(r)return r;if(this.outerScope)return this.outerScope.getElement(e)}getElements(e){const t=this.caseInsensitive?e.toLowerCase():e,r=this.elements.get(t);return(this.concatOuterScope||r.length===0)&&this.outerScope?ue(r).concat(this.outerScope.getElements(e)):ue(r)}getAllElements(){let e=ue(this.elements.values());return this.outerScope&&(e=e.concat(this.outerScope.getAllElements())),e}},EF={getElement(){},getElements(){return Ua},getAllElements(){return Ua}},Gu=class{static{i(this,"DisposableCache")}constructor(){this.toDispose=[],this.isDisposed=!1}onDispose(e){this.toDispose.push(e)}dispose(){this.throwIfDisposed(),this.clear(),this.isDisposed=!0,this.toDispose.forEach(e=>e.dispose())}throwIfDisposed(){if(this.isDisposed)throw new Error("This cache has already been disposed")}},Vm=class extends Gu{static{i(this,"SimpleCache")}constructor(){super(...arguments),this.cache=new Map}has(e){return this.throwIfDisposed(),this.cache.has(e)}set(e,t){this.throwIfDisposed(),this.cache.set(e,t)}get(e,t){if(this.throwIfDisposed(),this.cache.has(e))return this.cache.get(e);if(t){const r=t();return this.cache.set(e,r),r}else return}delete(e){return this.throwIfDisposed(),this.cache.delete(e)}clear(){this.throwIfDisposed(),this.cache.clear()}},Fu=class extends Gu{static{i(this,"ContextCache")}constructor(e){super(),this.cache=new Map,this.converter=e??(t=>t)}has(e,t){return this.throwIfDisposed(),this.cacheForContext(e).has(t)}set(e,t,r){this.throwIfDisposed(),this.cacheForContext(e).set(t,r)}get(e,t,r){this.throwIfDisposed();const n=this.cacheForContext(e);if(n.has(t))return n.get(t);if(r){const a=r();return n.set(t,a),a}else return}delete(e,t){return this.throwIfDisposed(),this.cacheForContext(e).delete(t)}clear(e){if(this.throwIfDisposed(),e){const t=this.converter(e);this.cache.delete(t)}else this.cache.clear()}cacheForContext(e){const t=this.converter(e);let r=this.cache.get(t);return r||(r=new Map,this.cache.set(t,r)),r}},sw=class extends Fu{static{i(this,"DocumentCache")}constructor(e,t){super(r=>r.toString()),t?(this.toDispose.push(e.workspace.DocumentBuilder.onDocumentPhase(t,r=>{this.clear(r.uri.toString())})),this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((r,n)=>{for(const a of n)this.clear(a)}))):this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((r,n)=>{const a=r.concat(n);for(const s of a)this.clear(s)}))}},qm=class extends Vm{static{i(this,"WorkspaceCache")}constructor(e,t){super(),t?(this.toDispose.push(e.workspace.DocumentBuilder.onBuildPhase(t,()=>{this.clear()})),this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((r,n)=>{n.length>0&&this.clear()}))):this.toDispose.push(e.workspace.DocumentBuilder.onUpdate(()=>{this.clear()}))}},ow=class{static{i(this,"DefaultScopeProvider")}constructor(e){this.reflection=e.shared.AstReflection,this.nameProvider=e.references.NameProvider,this.descriptions=e.workspace.AstNodeDescriptionProvider,this.indexManager=e.shared.workspace.IndexManager,this.globalScopeCache=new qm(e.shared)}getScope(e){const t=[],r=this.reflection.getReferenceType(e),n=Mt(e.container).localSymbols;if(n){let s=e.container;do n.has(s)&&t.push(n.getStream(s).filter(o=>this.reflection.isSubtype(o.type,r))),s=s.$container;while(s)}let a=this.getGlobalScope(r,e);for(let s=t.length-1;s>=0;s--)a=this.createScope(t[s],a);return a}createScope(e,t,r){return new Qf(ue(e),t,r)}createScopeForNodes(e,t,r){const n=ue(e).map(a=>{const s=this.nameProvider.getName(a);if(s)return this.descriptions.createDescription(a,s)}).nonNullable();return new Qf(n,t,r)}getGlobalScope(e,t){return this.globalScopeCache.get(e,()=>new iw(this.indexManager.allElements(e)))}};function Hm(e){return typeof e.$comment=="string"}i(Hm,"isAstNodeWithComment");function ed(e){return typeof e=="object"&&!!e&&("$ref"in e||"$error"in e)}i(ed,"isIntermediateReference");var lw=class{static{i(this,"DefaultJsonSerializer")}constructor(e){this.ignoreProperties=new Set(["$container","$containerProperty","$containerIndex","$document","$cstNode"]),this.langiumDocuments=e.shared.workspace.LangiumDocuments,this.astNodeLocator=e.workspace.AstNodeLocator,this.nameProvider=e.references.NameProvider,this.commentProvider=e.documentation.CommentProvider}serialize(e,t){const r=t??{},n=t?.replacer,a=i((o,l)=>this.replacer(o,l,r),"defaultReplacer"),s=n?(o,l)=>n(o,l,a):a;try{return this.currentDocument=Mt(e),JSON.stringify(e,s,t?.space)}finally{this.currentDocument=void 0}}deserialize(e,t){const r=t??{},n=JSON.parse(e);return this.linkNode(n,n,r),n}replacer(e,t,{refText:r,sourceText:n,textRegions:a,comments:s,uriConverter:o}){if(!this.ignoreProperties.has(e))if(rt(t)){const l=t.ref,u=r?t.$refText:void 0;if(l){const c=Mt(l);let f="";this.currentDocument&&this.currentDocument!==c&&(o?f=o(c.uri,l):f=c.uri.toString());const d=this.astNodeLocator.getAstNodePath(l);return{$ref:`${f}#${d}`,$refText:u}}else return{$error:t.error?.message??"Could not resolve reference",$refText:u}}else if(rr(t)){const l=r?t.$refText:void 0,u=[];for(const c of t.items){const f=c.ref,d=Mt(c.ref);let m="";this.currentDocument&&this.currentDocument!==d&&(o?m=o(d.uri,f):m=d.uri.toString());const g=this.astNodeLocator.getAstNodePath(f);u.push(`${m}#${g}`)}return{$refs:u,$refText:l}}else if(Oe(t)){let l;if(a&&(l=this.addAstNodeRegionWithAssignmentsTo({...t}),(!e||t.$document)&&l?.$textRegion&&(l.$textRegion.documentURI=this.currentDocument?.uri.toString())),n&&!e&&(l??(l={...t}),l.$sourceText=t.$cstNode?.text),s){l??(l={...t});const u=this.commentProvider.getComment(t);u&&(l.$comment=u.replace(/\r/g,""))}return l??t}else return t}addAstNodeRegionWithAssignmentsTo(e){const t=i(r=>({offset:r.offset,end:r.end,length:r.length,range:r.range}),"createDocumentSegment");if(e.$cstNode){const r=e.$textRegion=t(e.$cstNode),n=r.assignments={};return Object.keys(e).filter(a=>!a.startsWith("$")).forEach(a=>{const s=gp(e.$cstNode,a).map(t);s.length!==0&&(n[a]=s)}),e}}linkNode(e,t,r,n,a,s){for(const[l,u]of Object.entries(e))if(Array.isArray(u))for(let c=0;c{await this.handleException(()=>e.call(t,r,n,a),"An error occurred during validation",n,r)}}async handleException(e,t,r,n){try{await e()}catch(a){if(ta(a))throw a;console.error(`${t}:`,a),a instanceof Error&&a.stack&&console.error(a.stack);const s=a instanceof Error?a.message:String(a);r("error",`${t}: ${s}`,{node:n})}}addEntry(e,t){if(e==="AstNode"){this.entries.add("AstNode",t);return}for(const r of this.reflection.getAllSubTypes(e))this.entries.add(r,t)}getChecks(e,t){let r=ue(this.entries.get(e)).concat(this.entries.get("AstNode"));return t&&(r=r.filter(n=>t.includes(n.category))),r.map(n=>n.check)}registerBeforeDocument(e,t=this){this.entriesBefore.push(this.wrapPreparationException(e,"An error occurred during set-up of the validation",t))}registerAfterDocument(e,t=this){this.entriesAfter.push(this.wrapPreparationException(e,"An error occurred during tear-down of the validation",t))}wrapPreparationException(e,t,r){return async(n,a,s,o)=>{await this.handleException(()=>e.call(r,n,a,s,o),t,a,n)}}get checksBefore(){return this.entriesBefore}get checksAfter(){return this.entriesAfter}getAllValidationCategories(e){return this.knownCategories}},fw=Object.freeze({validateNode:!0,validateChildren:!0}),dw=class{static{i(this,"DefaultDocumentValidator")}constructor(e){this.validationRegistry=e.validation.ValidationRegistry,this.metadata=e.LanguageMetaData,this.profiler=e.shared.profilers.LangiumProfiler,this.languageId=e.LanguageMetaData.languageId}async validateDocument(e,t={},r=pe.CancellationToken.None){const n=e.parseResult,a=[];if(await ze(r),(!t.categories||t.categories.includes("built-in"))&&(this.processLexingErrors(n,a,t),t.stopAfterLexingErrors&&a.some(s=>s.data?.code===bt.LexingError)||(this.processParsingErrors(n,a,t),t.stopAfterParsingErrors&&a.some(s=>s.data?.code===bt.ParsingError))||(this.processLinkingErrors(e,a,t),t.stopAfterLinkingErrors&&a.some(s=>s.data?.code===bt.LinkingError))))return a;try{a.push(...await this.validateAst(n.value,t,r))}catch(s){if(ta(s))throw s;console.error("An error occurred during validation:",s)}return await ze(r),a}processLexingErrors(e,t,r){const n=[...e.lexerErrors,...e.lexerReport?.diagnostics??[]];for(const a of n){const s=a.severity??"error",o={severity:gs(s),range:{start:{line:a.line-1,character:a.column-1},end:{line:a.line-1,character:a.column+a.length-1}},message:a.message,data:Xm(s),source:this.getSource()};t.push(o)}}processParsingErrors(e,t,r){for(const n of e.parserErrors){let a;if(isNaN(n.token.startOffset)){if("previousToken"in n){const s=n.previousToken;if(isNaN(s.startOffset)){const o={line:0,character:0};a={start:o,end:o}}else{const o={line:s.endLine-1,character:s.endColumn};a={start:o,end:o}}}}else a=$s(n.token);if(a){const s={severity:gs("error"),range:a,message:n.message,data:Sn(bt.ParsingError),source:this.getSource()};t.push(s)}}}processLinkingErrors(e,t,r){for(const n of e.references){const a=n.error;if(a){const s={node:a.info.container,range:n.$refNode?.range,property:a.info.property,index:a.info.index,data:{code:bt.LinkingError,containerType:a.info.container.$type,property:a.info.property,refText:a.info.reference.$refText}};t.push(this.toDiagnostic("error",a.message,s))}}}async validateAst(e,t,r=pe.CancellationToken.None){const n=[],a=i((s,o,l)=>{n.push(this.toDiagnostic(s,o,l))},"acceptor");return await this.validateAstBefore(e,t,a,r),await this.validateAstNodes(e,t,a,r),await this.validateAstAfter(e,t,a,r),n}async validateAstBefore(e,t,r,n=pe.CancellationToken.None){const a=this.validationRegistry.checksBefore;for(const s of a)await ze(n),await s(e,r,t.categories??[],n)}async validateAstNodes(e,t,r,n=pe.CancellationToken.None){if(this.profiler?.isActive("validating")){const a=this.profiler.createTask("validating",this.languageId);a.start();try{const s=Gt(e).iterator();for(const o of s){a.startSubTask(o.$type);const l=this.validateSingleNodeOptions(o,t);if(l.validateNode)try{const u=this.validationRegistry.getChecks(o.$type,t.categories);for(const c of u)await c(o,r,n)}finally{a.stopSubTask(o.$type)}l.validateChildren||s.prune()}}finally{a.stop()}}else{const a=Gt(e).iterator();for(const s of a){await ze(n);const o=this.validateSingleNodeOptions(s,t);if(o.validateNode){const l=this.validationRegistry.getChecks(s.$type,t.categories);for(const u of l)await u(s,r,n)}o.validateChildren||a.prune()}}}validateSingleNodeOptions(e,t){return fw}async validateAstAfter(e,t,r,n=pe.CancellationToken.None){const a=this.validationRegistry.checksAfter;for(const s of a)await ze(n),await s(e,r,t.categories??[],n)}toDiagnostic(e,t,r){return{message:t,range:Ym(r),severity:gs(e),code:r.code,codeDescription:r.codeDescription,tags:r.tags,relatedInformation:r.relatedInformation,data:r.data,source:this.getSource()}}getSource(){return this.metadata.languageId}};function Ym(e){if(e.range)return e.range;let t;return typeof e.property=="string"?t=Yl(e.node.$cstNode,e.property,e.index):typeof e.keyword=="string"&&(t=vp(e.node.$cstNode,e.keyword,e.index)),t??(t=e.node.$cstNode),t?t.range:{start:{line:0,character:0},end:{line:0,character:0}}}i(Ym,"getDiagnosticRange");function gs(e){switch(e){case"error":return 1;case"warning":return 2;case"info":return 3;case"hint":return 4;default:throw new Error("Invalid diagnostic severity: "+e)}}i(gs,"toDiagnosticSeverity");function Xm(e){switch(e){case"error":return Sn(bt.LexingError);case"warning":return Sn(bt.LexingWarning);case"info":return Sn(bt.LexingInfo);case"hint":return Sn(bt.LexingHint);default:throw new Error("Invalid diagnostic severity: "+e)}}i(Xm,"toDiagnosticData");var bt;(function(e){e.LexingError="lexing-error",e.LexingWarning="lexing-warning",e.LexingInfo="lexing-info",e.LexingHint="lexing-hint",e.ParsingError="parsing-error",e.LinkingError="linking-error"})(bt||(bt={}));var pw=class{static{i(this,"DefaultAstNodeDescriptionProvider")}constructor(e){this.astNodeLocator=e.workspace.AstNodeLocator,this.nameProvider=e.references.NameProvider}createDescription(e,t,r){const n=r??Mt(e);t??(t=this.nameProvider.getName(e));const a=this.astNodeLocator.getAstNodePath(e);if(!t)throw new Error(`Node at path ${a} has no name.`);let s;const o=i(()=>s??(s=Ya(this.nameProvider.getNameNode(e)??e.$cstNode)),"nameSegmentGetter");return{node:e,name:t,get nameSegment(){return o()},selectionSegment:Ya(e.$cstNode),type:e.$type,documentUri:n.uri,path:a}}},mw=class{static{i(this,"DefaultReferenceDescriptionProvider")}constructor(e){this.nodeLocator=e.workspace.AstNodeLocator}async createDescriptions(e,t=pe.CancellationToken.None){const r=[],n=e.parseResult.value;for(const a of Gt(n))await ze(t),Va(a).forEach(s=>{s.reference.error||r.push(...this.createInfoDescriptions(s))});return r}createInfoDescriptions(e){const t=e.reference;if(t.error||!t.$refNode)return[];let r=[];rt(t)&&t.$nodeDescription?r=[t.$nodeDescription]:rr(t)&&(r=t.items.map(l=>l.$nodeDescription).filter(l=>l!==void 0));const n=Mt(e.container).uri,a=this.nodeLocator.getAstNodePath(e.container),s=[],o=Ya(t.$refNode);for(const l of r)s.push({sourceUri:n,sourcePath:a,targetUri:l.documentUri,targetPath:l.path,segment:o,local:nt.equals(l.documentUri,n)});return s}},hw=class{static{i(this,"DefaultAstNodeLocator")}constructor(){this.segmentSeparator="/",this.indexSeparator="@"}getAstNodePath(e){if(e.$container){const t=this.getAstNodePath(e.$container),r=this.getPathSegment(e);return t+this.segmentSeparator+r}return""}getPathSegment({$containerProperty:e,$containerIndex:t}){if(!e)throw new Error("Missing '$containerProperty' in AST node.");return t!==void 0?e+this.indexSeparator+t:e}getAstNode(e,t){return t.split(this.segmentSeparator).reduce((n,a)=>{if(!n||a.length===0)return n;const s=a.indexOf(this.indexSeparator);if(s>0){const o=a.substring(0,s),l=parseInt(a.substring(s+1));return n[o]?.[l]}return n[a]},e)}},zu={};Ll(zu,Cd(ei()));var yw=class{static{i(this,"DefaultConfigurationProvider")}constructor(e){this._ready=new wr,this.onConfigurationSectionUpdateEmitter=new zu.Emitter,this.settings={},this.workspaceConfig=!1,this.serviceRegistry=e.ServiceRegistry}get ready(){return this._ready.promise}initialize(e){this.workspaceConfig=e.capabilities.workspace?.configuration??!1}async initialized(e){if(this.workspaceConfig){if(e.register){const t=this.serviceRegistry.all;e.register({section:t.map(r=>this.toSectionName(r.LanguageMetaData.languageId))})}if(e.fetchConfiguration){const t=this.serviceRegistry.all.map(n=>({section:this.toSectionName(n.LanguageMetaData.languageId)})),r=await e.fetchConfiguration(t);t.forEach((n,a)=>{this.updateSectionConfiguration(n.section,r[a])})}}this._ready.resolve()}updateConfiguration(e){typeof e.settings!="object"||e.settings===null||Object.entries(e.settings).forEach(([t,r])=>{this.updateSectionConfiguration(t,r),this.onConfigurationSectionUpdateEmitter.fire({section:t,configuration:r})})}updateSectionConfiguration(e,t){this.settings[e]=t}async getConfiguration(e,t){await this.ready;const r=this.toSectionName(e);if(this.settings[r])return this.settings[r][t]}toSectionName(e){return`${e}`}get onConfigurationSectionUpdate(){return this.onConfigurationSectionUpdateEmitter.event}},uo=Cd(nN()),Nn;(function(e){function t(r){return{dispose:i(async()=>await r(),"dispose")}}i(t,"create"),e.create=t})(Nn||(Nn={}));var gw=class{static{i(this,"DefaultDocumentBuilder")}constructor(e){this.updateBuildOptions={validation:{categories:["built-in","fast"]}},this.updateListeners=[],this.buildPhaseListeners=new Ir,this.documentPhaseListeners=new Ir,this.buildState=new Map,this.documentBuildWaiters=new Map,this.currentState=J.Changed,this.langiumDocuments=e.workspace.LangiumDocuments,this.langiumDocumentFactory=e.workspace.LangiumDocumentFactory,this.textDocuments=e.workspace.TextDocuments,this.indexManager=e.workspace.IndexManager,this.fileSystemProvider=e.workspace.FileSystemProvider,this.workspaceManager=()=>e.workspace.WorkspaceManager,this.serviceRegistry=e.ServiceRegistry}async build(e,t={},r=pe.CancellationToken.None){for(const n of e){const a=n.uri.toString();if(n.state===J.Validated){if(typeof t.validation=="boolean"&&t.validation)this.resetToState(n,J.IndexedReferences);else if(typeof t.validation=="object"){const s=this.findMissingValidationCategories(n,t);s.length>0&&(this.buildState.set(a,{completed:!1,options:{validation:{categories:s}},result:this.buildState.get(a)?.result}),n.state=J.IndexedReferences)}}else this.buildState.delete(a)}this.currentState=J.Changed,await this.emitUpdate(e.map(n=>n.uri),[]),await this.buildDocuments(e,t,r)}async update(e,t,r=pe.CancellationToken.None){this.currentState=J.Changed;const n=[];for(const l of t){const u=this.langiumDocuments.deleteDocuments(l);for(const c of u)n.push(c.uri),this.cleanUpDeleted(c)}const a=(await Promise.all(e.map(l=>this.findChangedUris(l)))).flat();for(const l of a){let u=this.langiumDocuments.getDocument(l);u===void 0&&(u=this.langiumDocumentFactory.fromModel({$type:"INVALID"},l),u.state=J.Changed,this.langiumDocuments.addDocument(u)),this.resetToState(u,J.Changed)}const s=ue(a).concat(n).map(l=>l.toString()).toSet();this.langiumDocuments.all.filter(l=>!s.has(l.uri.toString())&&this.shouldRelink(l,s)).forEach(l=>this.resetToState(l,J.ComputedScopes)),await this.emitUpdate(a,n),await ze(r);const o=this.sortDocuments(this.langiumDocuments.all.filter(l=>l.state=1}findMissingValidationCategories(e,t){const r=this.buildState.get(e.uri.toString()),n=this.serviceRegistry.getServices(e.uri).validation.ValidationRegistry.getAllValidationCategories(e),a=r?.result?.validationChecks?new Set(r?.result?.validationChecks):r?.completed?n:new Set,s=t===void 0||t.validation===!0?n:typeof t.validation=="object"?t.validation.categories??n:[];return ue(s).filter(o=>!a.has(o)).toArray()}async findChangedUris(e){if(this.langiumDocuments.getDocument(e)??this.textDocuments?.get(e))return[e];try{const r=await this.fileSystemProvider.stat(e);if(r.isDirectory)return await this.workspaceManager().searchFolder(e);if(this.workspaceManager().shouldIncludeEntry(r))return[e]}catch{}return[]}async emitUpdate(e,t){await Promise.all(this.updateListeners.map(r=>r(e,t)))}sortDocuments(e){let t=0,r=e.length-1;for(;t=0&&!this.hasTextDocument(e[r]);)r--;tr.error!==void 0)?!0:this.indexManager.isAffected(e,t)}onUpdate(e){return this.updateListeners.push(e),Nn.create(()=>{const t=this.updateListeners.indexOf(e);t>=0&&this.updateListeners.splice(t,1)})}resetToState(e,t){switch(t){case J.Changed:case J.Parsed:this.indexManager.removeContent(e.uri);case J.IndexedContent:e.localSymbols=void 0;case J.ComputedScopes:this.serviceRegistry.getServices(e.uri).references.Linker.unlink(e);case J.Linked:this.indexManager.removeReferences(e.uri);case J.IndexedReferences:e.diagnostics=void 0,this.buildState.delete(e.uri.toString());case J.Validated:}e.state>t&&(e.state=t)}cleanUpDeleted(e){this.buildState.delete(e.uri.toString()),this.indexManager.remove(e.uri),e.state=J.Changed}async buildDocuments(e,t,r){this.prepareBuild(e,t),await this.runCancelable(e,J.Parsed,r,s=>this.langiumDocumentFactory.update(s,r)),await this.runCancelable(e,J.IndexedContent,r,s=>this.indexManager.updateContent(s,r)),await this.runCancelable(e,J.ComputedScopes,r,async s=>{const o=this.serviceRegistry.getServices(s.uri).references.ScopeComputation;s.localSymbols=await o.collectLocalSymbols(s,r)});const n=e.filter(s=>this.shouldLink(s));await this.runCancelable(n,J.Linked,r,s=>this.serviceRegistry.getServices(s.uri).references.Linker.link(s,r)),await this.runCancelable(n,J.IndexedReferences,r,s=>this.indexManager.updateReferences(s,r));const a=e.filter(s=>this.shouldValidate(s)?!0:(this.markAsCompleted(s),!1));await this.runCancelable(a,J.Validated,r,async s=>{await this.validate(s,r),this.markAsCompleted(s)})}markAsCompleted(e){const t=this.buildState.get(e.uri.toString());t&&(t.completed=!0)}prepareBuild(e,t){for(const r of e){const n=r.uri.toString(),a=this.buildState.get(n);(!a||a.completed)&&this.buildState.set(n,{completed:!1,options:t,result:a?.result})}}async runCancelable(e,t,r,n){for(const s of e)s.states.state===t);await this.notifyBuildPhase(a,t,r),this.currentState=t}onBuildPhase(e,t){return this.buildPhaseListeners.add(e,t),Nn.create(()=>{this.buildPhaseListeners.delete(e,t)})}onDocumentPhase(e,t){return this.documentPhaseListeners.add(e,t),Nn.create(()=>{this.documentPhaseListeners.delete(e,t)})}waitUntil(e,t,r){let n;return t&&"path"in t?n=t:r=t,r??(r=pe.CancellationToken.None),n?this.awaitDocumentState(e,n,r):this.awaitBuilderState(e,r)}awaitDocumentState(e,t,r){const n=this.langiumDocuments.getDocument(t);if(n){if(n.state>=e)return Promise.resolve(t);if(r.isCancellationRequested)return Promise.reject(tr);if(this.currentState>=e&&e>n.state)return Promise.reject(new uo.ResponseError(uo.LSPErrorCodes.RequestFailed,`Document state of ${t.toString()} is ${J[n.state]}, requiring ${J[e]}, but workspace state is already ${J[this.currentState]}. Returning undefined.`))}else return Promise.reject(new uo.ResponseError(uo.LSPErrorCodes.ServerCancelled,`No document found for URI: ${t.toString()}`));return new Promise((a,s)=>{const o=this.onDocumentPhase(e,u=>{nt.equals(u.uri,t)&&(o.dispose(),l.dispose(),a(u.uri))}),l=r.onCancellationRequested(()=>{o.dispose(),l.dispose(),s(tr)})})}awaitBuilderState(e,t){return this.currentState>=e?Promise.resolve():t.isCancellationRequested?Promise.reject(tr):new Promise((r,n)=>{const a=this.onBuildPhase(e,()=>{a.dispose(),s.dispose(),r()}),s=t.onCancellationRequested(()=>{a.dispose(),s.dispose(),n(tr)})})}async notifyDocumentPhase(e,t,r){const a=this.documentPhaseListeners.get(t).slice();for(const s of a)try{await ze(r),await s(e,r)}catch(o){if(!ta(o))throw o}}async notifyBuildPhase(e,t,r){if(e.length===0)return;const a=this.buildPhaseListeners.get(t).slice();for(const s of a)await ze(r),await s(e,r)}shouldLink(e){return this.getBuildOptions(e).eagerLinking??!0}shouldValidate(e){return!!this.getBuildOptions(e).validation}async validate(e,t){const r=this.serviceRegistry.getServices(e.uri).validation.DocumentValidator,n=this.getBuildOptions(e),a=typeof n.validation=="object"?{...n.validation}:{};a.categories=this.findMissingValidationCategories(e,n);const s=await r.validateDocument(e,a,t);e.diagnostics?e.diagnostics.push(...s):e.diagnostics=s;const o=this.buildState.get(e.uri.toString());o&&(o.result??(o.result={}),o.result.validationChecks?o.result.validationChecks=ue(o.result.validationChecks).concat(a.categories).distinct().toArray():o.result.validationChecks=[...a.categories])}getBuildOptions(e){return this.buildState.get(e.uri.toString())?.options??{}}},vw=class{static{i(this,"DefaultIndexManager")}constructor(e){this.symbolIndex=new Map,this.symbolByTypeIndex=new Fu,this.referenceIndex=new Map,this.documents=e.workspace.LangiumDocuments,this.serviceRegistry=e.ServiceRegistry,this.astReflection=e.AstReflection}findAllReferences(e,t){const r=Mt(e).uri,n=[];return this.referenceIndex.forEach(a=>{a.forEach(s=>{nt.equals(s.targetUri,r)&&s.targetPath===t&&n.push(s)})}),ue(n)}allElements(e,t){let r=ue(this.symbolIndex.keys());return t&&(r=r.filter(n=>!t||t.has(n))),r.map(n=>this.getFileDescriptions(n,e)).flat()}getFileDescriptions(e,t){return t?this.symbolByTypeIndex.get(e,t,()=>(this.symbolIndex.get(e)??[]).filter(a=>this.astReflection.isSubtype(a.type,t))):this.symbolIndex.get(e)??[]}remove(e){this.removeContent(e),this.removeReferences(e)}removeContent(e){const t=e.toString();this.symbolIndex.delete(t),this.symbolByTypeIndex.clear(t)}removeReferences(e){const t=e.toString();this.referenceIndex.delete(t)}async updateContent(e,t=pe.CancellationToken.None){const n=await this.serviceRegistry.getServices(e.uri).references.ScopeComputation.collectExportedSymbols(e,t),a=e.uri.toString();this.symbolIndex.set(a,n),this.symbolByTypeIndex.clear(a)}async updateReferences(e,t=pe.CancellationToken.None){const n=await this.serviceRegistry.getServices(e.uri).workspace.ReferenceDescriptionProvider.createDescriptions(e,t);this.referenceIndex.set(e.uri.toString(),n)}isAffected(e,t){const r=this.referenceIndex.get(e.uri.toString());return r?r.some(n=>!n.local&&t.has(n.targetUri.toString())):!1}},Tw=class{static{i(this,"DefaultWorkspaceManager")}constructor(e){this.initialBuildOptions={},this._ready=new wr,this.serviceRegistry=e.ServiceRegistry,this.langiumDocuments=e.workspace.LangiumDocuments,this.documentBuilder=e.workspace.DocumentBuilder,this.fileSystemProvider=e.workspace.FileSystemProvider,this.mutex=e.workspace.WorkspaceLock}get ready(){return this._ready.promise}get workspaceFolders(){return this.folders}initialize(e){this.folders=e.workspaceFolders??void 0}initialized(e){return this.mutex.write(t=>this.initializeWorkspace(this.folders??[],t))}async initializeWorkspace(e,t=pe.CancellationToken.None){const r=await this.performStartup(e);await ze(t),await this.documentBuilder.build(r,this.initialBuildOptions,t)}async performStartup(e){const t=[],r=i(s=>{t.push(s),this.langiumDocuments.hasDocument(s.uri)||this.langiumDocuments.addDocument(s)},"collector");await this.loadAdditionalDocuments(e,r);const n=[];await Promise.all(e.map(s=>this.getRootFolder(s)).map(async s=>this.traverseFolder(s,n)));const a=ue(n).distinct(s=>s.toString()).filter(s=>!this.langiumDocuments.hasDocument(s));return await this.loadWorkspaceDocuments(a,r),this._ready.resolve(),t}async loadWorkspaceDocuments(e,t){await Promise.all(e.map(async r=>{const n=await this.langiumDocuments.getOrCreateDocument(r);t(n)}))}loadAdditionalDocuments(e,t){return Promise.resolve()}getRootFolder(e){return Tt.parse(e.uri)}async traverseFolder(e,t){try{const r=await this.fileSystemProvider.readDirectory(e);await Promise.all(r.map(async n=>{this.shouldIncludeEntry(n)&&(n.isDirectory?await this.traverseFolder(n.uri,t):n.isFile&&t.push(n.uri))}))}catch(r){console.error("Failure to read directory content of "+e.toString(!0),r)}}async searchFolder(e){const t=[];return await this.traverseFolder(e,t),t}shouldIncludeEntry(e){const t=nt.basename(e.uri);return t.startsWith(".")?!1:e.isDirectory?t!=="node_modules"&&t!=="out":e.isFile?this.serviceRegistry.hasServices(e.uri):!1}},$w=class{static{i(this,"DefaultLexerErrorMessageProvider")}buildUnexpectedCharactersMessage(e,t,r,n,a){return Of.buildUnexpectedCharactersMessage(e,t,r,n,a)}buildUnableToPopLexerModeMessage(e){return Of.buildUnableToPopLexerModeMessage(e)}},Jm={mode:"full"},Zm=class{static{i(this,"DefaultLexer")}constructor(e){this.errorMessageProvider=e.parser.LexerErrorMessageProvider,this.tokenBuilder=e.parser.TokenBuilder;const t=this.tokenBuilder.buildTokens(e.Grammar,{caseInsensitive:e.LanguageMetaData.caseInsensitive});this.tokenTypes=this.toTokenTypeDictionary(t);const r=kl(t)?Object.values(t):t,n=e.LanguageMetaData.mode==="production";this.chevrotainLexer=new at(r,{positionTracking:"full",skipValidations:n,errorMessageProvider:this.errorMessageProvider})}get definition(){return this.tokenTypes}tokenize(e,t=Jm){const r=this.chevrotainLexer.tokenize(e);return{tokens:r.tokens,errors:r.errors,hidden:r.groups.hidden??[],report:this.tokenBuilder.flushLexingReport?.(e)}}toTokenTypeDictionary(e){if(kl(e))return e;const t=Bu(e)?Object.values(e.modes).flat():e,r={};return t.forEach(n=>r[n.name]=n),r}};function ju(e){return Array.isArray(e)&&(e.length===0||"name"in e[0])}i(ju,"isTokenTypeArray");function Bu(e){return e&&"modes"in e&&"defaultMode"in e}i(Bu,"isIMultiModeLexerDefinition");function kl(e){return!ju(e)&&!Bu(e)}i(kl,"isTokenTypeDictionary");xs();function Qm(e,t,r){let n,a;typeof e=="string"?(a=t,n=r):(a=e.range.start,n=t),a||(a=ie.create(0,0));const s=th(e),o=Uu(n),l=Rw({lines:s,position:a,options:o});return Cw({index:0,tokens:l,position:a})}i(Qm,"parseJSDoc");function eh(e,t){const r=Uu(t),n=th(e);if(n.length===0)return!1;const a=n[0],s=n[n.length-1],o=r.start,l=r.end;return!!o?.exec(a)&&!!l?.exec(s)}i(eh,"isJSDoc");function th(e){let t="";return typeof e=="string"?t=e:t=e.text,t.split(Ev)}i(th,"getLines");var Py=/\s*(@([\p{L}][\p{L}\p{N}]*)?)/uy,CF=/\{(@[\p{L}][\p{L}\p{N}]*)(\s*)([^\r\n}]+)?\}/gu;function Rw(e){const t=[];let r=e.position.line,n=e.position.character;for(let a=0;a=l.length){if(t.length>0){const f=ie.create(r,n);t.push({type:"break",content:"",range:Q.create(f,f)})}}else{Py.lastIndex=u;const f=Py.exec(l);if(f){const d=f[0],m=f[1],g=ie.create(r,n+u),v=ie.create(r,n+u+d.length);t.push({type:"tag",content:m,range:Q.create(g,v)}),u+=d.length,u=Ol(l,u)}if(u0&&t[t.length-1].type==="break"?t.slice(0,-1):t}i(Rw,"tokenize");function Aw(e,t,r,n){const a=[];if(e.length===0){const s=ie.create(r,n),o=ie.create(r,n+t.length);a.push({type:"text",content:t,range:Q.create(s,o)})}else{let s=0;for(const l of e){const u=l.index,c=t.substring(s,u);c.length>0&&a.push({type:"text",content:t.substring(s,u),range:Q.create(ie.create(r,s+n),ie.create(r,u+n))});let f=c.length+1;const d=l[1];if(a.push({type:"inline-tag",content:d,range:Q.create(ie.create(r,s+f+n),ie.create(r,s+f+d.length+n))}),f+=d.length,l.length===4){f+=l[2].length;const m=l[3];a.push({type:"text",content:m,range:Q.create(ie.create(r,s+f+n),ie.create(r,s+f+m.length+n))})}else a.push({type:"text",content:"",range:Q.create(ie.create(r,s+f+n),ie.create(r,s+f+n))});s=u+l[0].length}const o=t.substring(s);o.length>0&&a.push({type:"text",content:o,range:Q.create(ie.create(r,s+n),ie.create(r,s+n+o.length))})}return a}i(Aw,"buildInlineTokens");var _F=/\S/,bF=/\s*$/;function Ol(e,t){const r=e.substring(t).match(_F);return r?t+r.index:e.length}i(Ol,"skipWhitespace");function Ew(e){const t=e.match(bF);if(t&&typeof t.index=="number")return t.index}i(Ew,"lastCharacter");function Cw(e){const t=ie.create(e.position.line,e.position.character);if(e.tokens.length===0)return new ky([],Q.create(t,t));const r=[];for(;e.indext.name===e)}getTags(e){return this.getAllTags().filter(t=>t.name===e)}getAllTags(){return this.elements.filter(e=>"name"in e)}toString(){let e="";for(const t of this.elements)if(e.length===0)e=t.toString();else{const r=t.toString();e+=rd(e)+r}return e.trim()}toMarkdown(e){let t="";for(const r of this.elements)if(t.length===0)t=r.toMarkdown(e);else{const n=r.toMarkdown(e);t+=rd(t)+n}return t.trim()}},Qu=class{static{i(this,"JSDocTagImpl")}constructor(e,t,r,n){this.name=e,this.content=t,this.inline=r,this.range=n}toString(){let e=`@${this.name}`;const t=this.content.toString();return this.content.inlines.length===1?e=`${e} ${t}`:this.content.inlines.length>1&&(e=`${e} +${t}`),this.inline?`{${e}}`:e}toMarkdown(e){return e?.renderTag?.(this)??this.toMarkdownDefault(e)}toMarkdownDefault(e){const t=this.content.toMarkdown(e);if(this.inline){const a=ww(this.name,t,e??{});if(typeof a=="string")return a}let r="";e?.tag==="italic"||e?.tag===void 0?r="*":e?.tag==="bold"?r="**":e?.tag==="bold-italic"&&(r="***");let n=`${r}@${this.name}${r}`;return this.content.inlines.length===1?n=`${n} — ${t}`:this.content.inlines.length>1&&(n=`${n} +${t}`),this.inline?`{${n}}`:n}};function ww(e,t,r){if(e==="linkplain"||e==="linkcode"||e==="link"){const n=t.indexOf(" ");let a=t;if(n>0){const o=Ol(t,n);a=t.substring(o),t=t.substring(0,n)}return(e==="linkcode"||e==="link"&&r.link==="code")&&(a=`\`${a}\``),r.renderLink?.(t,a)??Iw(t,a)}}i(ww,"renderInlineTag");function Iw(e,t){try{return Tt.parse(e,!0),`[${t}](${e})`}catch{return e}}i(Iw,"renderLinkDefault");var td=class{static{i(this,"JSDocTextImpl")}constructor(e,t){this.inlines=e,this.range=t}toString(){let e="";for(let t=0;tr.range.start.line&&(e+=` +`)}return e}toMarkdown(e){let t="";for(let r=0;rn.range.start.line&&(t+=` +`)}return t}},Nw=class{static{i(this,"JSDocLineImpl")}constructor(e,t){this.text=e,this.range=t}toString(){return this.text}toMarkdown(){return this.text}};function rd(e){return e.endsWith(` +`)?` +`:` + +`}i(rd,"fillNewlines");var Pw=class{static{i(this,"JSDocDocumentationProvider")}constructor(e){this.indexManager=e.shared.workspace.IndexManager,this.commentProvider=e.documentation.CommentProvider}getDocumentation(e){const t=this.commentProvider.getComment(e);if(t&&eh(t))return Qm(t).toMarkdown({renderLink:i((n,a)=>this.documentationLinkRenderer(e,n,a),"renderLink"),renderTag:i(n=>this.documentationTagRenderer(e,n),"renderTag")})}documentationLinkRenderer(e,t,r){const n=this.findNameInLocalSymbols(e,t)??this.findNameInGlobalScope(e,t);if(n&&n.nameSegment){const a=n.nameSegment.range.start.line+1,s=n.nameSegment.range.start.character+1,o=n.documentUri.with({fragment:`L${a},${s}`});return`[${r}](${o.toString()})`}else return}documentationTagRenderer(e,t){}findNameInLocalSymbols(e,t){const n=Mt(e).localSymbols;if(!n)return;let a=e;do{const o=n.getStream(a).find(l=>l.name===t);if(o)return o;a=a.$container}while(a)}findNameInGlobalScope(e,t){return this.indexManager.allElements().find(n=>n.name===t)}},kw=class{static{i(this,"DefaultCommentProvider")}constructor(e){this.grammarConfig=()=>e.parser.GrammarConfig}getComment(e){return Hm(e)?e.$comment:rp(e.$cstNode,this.grammarConfig().multilineCommentRules)?.text}},Ow=class{static{i(this,"DefaultAsyncParser")}constructor(e){this.syncParser=e.parser.LangiumParser}parse(e,t){return Promise.resolve(this.syncParser.parse(e))}},SF=class{static{i(this,"AbstractThreadedAsyncParser")}constructor(e){this.threadCount=8,this.terminationDelay=200,this.workerPool=[],this.queue=[],this.hydrator=e.serializer.Hydrator}initializeWorkers(){for(;this.workerPool.length{if(this.queue.length>0){const t=this.queue.shift();t&&(e.lock(),t.resolve(e))}}),this.workerPool.push(e)}}async parse(e,t){const r=await this.acquireParserWorker(t),n=new wr;let a;const s=t.onCancellationRequested(()=>{a=setTimeout(()=>{this.terminateWorker(r)},this.terminationDelay)});return r.parse(e).then(o=>{const l=this.hydrator.hydrate(o);n.resolve(l)}).catch(o=>{n.reject(o)}).finally(()=>{s.dispose(),clearTimeout(a)}),n.promise}terminateWorker(e){e.terminate();const t=this.workerPool.indexOf(e);t>=0&&this.workerPool.splice(t,1)}async acquireParserWorker(e){this.initializeWorkers();for(const r of this.workerPool)if(r.ready)return r.lock(),r;const t=new wr;return e.onCancellationRequested(()=>{const r=this.queue.indexOf(t);r>=0&&this.queue.splice(r,1),t.reject(tr)}),this.queue.push(t),t.promise}},wF=class{static{i(this,"ParserWorker")}get ready(){return this._ready}get onReady(){return this.onReadyEmitter.event}constructor(e,t,r,n){this.onReadyEmitter=new zu.Emitter,this.deferred=new wr,this._ready=!0,this._parsing=!1,this.sendMessage=e,this._terminate=n,t(a=>{const s=a;this.deferred.resolve(s),this.unlock()}),r(a=>{this.deferred.reject(a),this.unlock()})}terminate(){this.deferred.reject(tr),this._terminate()}lock(){this._ready=!1}unlock(){this._parsing=!1,this._ready=!0,this.onReadyEmitter.fire()}parse(e){if(this._parsing)throw new Error("Parser worker is busy");return this._parsing=!0,this.deferred=new wr,this.sendMessage(e),this.deferred.promise}},Lw=class{static{i(this,"DefaultWorkspaceLock")}constructor(){this.previousTokenSource=new pe.CancellationTokenSource,this.writeQueue=[],this.readQueue=[],this.done=!0}write(e){this.cancelWrite();const t=Mu();return this.previousTokenSource=t,this.enqueue(this.writeQueue,e,t.token)}read(e){return this.enqueue(this.readQueue,e)}enqueue(e,t,r=pe.CancellationToken.None){const n=new wr,a={action:t,deferred:n,cancellationToken:r};return e.push(a),this.performNextOperation(),n.promise}async performNextOperation(){if(!this.done)return;const e=[];if(this.writeQueue.length>0)e.push(this.writeQueue.shift());else if(this.readQueue.length>0)e.push(...this.readQueue.splice(0,this.readQueue.length));else return;this.done=!1,await Promise.all(e.map(async({action:t,deferred:r,cancellationToken:n})=>{try{const a=await Promise.resolve().then(()=>t(n));r.resolve(a)}catch(a){ta(a)?r.resolve(void 0):r.reject(a)}})),this.done=!0,this.performNextOperation()}cancelWrite(){this.previousTokenSource.cancel()}},Dw=class{static{i(this,"DefaultHydrator")}constructor(e){this.grammarElementIdMap=new Nl,this.tokenTypeIdMap=new Nl,this.grammar=e.Grammar,this.lexer=e.parser.Lexer,this.linker=e.references.Linker}dehydrate(e){return{lexerErrors:e.lexerErrors,lexerReport:e.lexerReport?this.dehydrateLexerReport(e.lexerReport):void 0,parserErrors:e.parserErrors.map(t=>({...t,message:t.message})),value:this.dehydrateAstNode(e.value,this.createDehyrationContext(e.value))}}dehydrateLexerReport(e){return e}createDehyrationContext(e){const t=new Map,r=new Map;for(const n of Gt(e))t.set(n,{});if(e.$cstNode)for(const n of Ha(e.$cstNode))r.set(n,{});return{astNodes:t,cstNodes:r}}dehydrateAstNode(e,t){const r=t.astNodes.get(e);r.$type=e.$type,r.$containerIndex=e.$containerIndex,r.$containerProperty=e.$containerProperty,e.$cstNode!==void 0&&(r.$cstNode=this.dehydrateCstNode(e.$cstNode,t));for(const[n,a]of Object.entries(e))if(!n.startsWith("$"))if(Array.isArray(a)){const s=[];r[n]=s;for(const o of a)Oe(o)?s.push(this.dehydrateAstNode(o,t)):rt(o)?s.push(this.dehydrateReference(o,t)):s.push(o)}else Oe(a)?r[n]=this.dehydrateAstNode(a,t):rt(a)?r[n]=this.dehydrateReference(a,t):a!==void 0&&(r[n]=a);return r}dehydrateReference(e,t){const r={};return r.$refText=e.$refText,e.$refNode&&(r.$refNode=t.cstNodes.get(e.$refNode)),r}dehydrateCstNode(e,t){const r=t.cstNodes.get(e);return Ml(e)?r.fullText=e.fullText:r.grammarSource=this.getGrammarElementId(e.grammarSource),r.hidden=e.hidden,r.astNode=t.astNodes.get(e.astNode),$r(e)?r.content=e.content.map(n=>this.dehydrateCstNode(n,t)):xn(e)&&(r.tokenType=e.tokenType.name,r.offset=e.offset,r.length=e.length,r.startLine=e.range.start.line,r.startColumn=e.range.start.character,r.endLine=e.range.end.line,r.endColumn=e.range.end.character),r}hydrate(e){const t=e.value,r=this.createHydrationContext(t);return"$cstNode"in t&&this.hydrateCstNode(t.$cstNode,r),{lexerErrors:e.lexerErrors,lexerReport:e.lexerReport,parserErrors:e.parserErrors,value:this.hydrateAstNode(t,r)}}createHydrationContext(e){const t=new Map,r=new Map;for(const a of Gt(e))t.set(a,{});let n;if(e.$cstNode)for(const a of Ha(e.$cstNode)){let s;"fullText"in a?(s=new km(a.fullText),n=s):"content"in a?s=new ku:"tokenType"in a&&(s=this.hydrateCstLeafNode(a)),s&&(r.set(a,s),s.root=n)}return{astNodes:t,cstNodes:r}}hydrateAstNode(e,t){const r=t.astNodes.get(e);r.$type=e.$type,r.$containerIndex=e.$containerIndex,r.$containerProperty=e.$containerProperty,e.$cstNode&&(r.$cstNode=t.cstNodes.get(e.$cstNode));for(const[n,a]of Object.entries(e))if(!n.startsWith("$"))if(Array.isArray(a)){const s=[];r[n]=s;for(const o of a)Oe(o)?s.push(this.setParent(this.hydrateAstNode(o,t),r)):rt(o)?s.push(this.hydrateReference(o,r,n,t)):s.push(o)}else Oe(a)?r[n]=this.setParent(this.hydrateAstNode(a,t),r):rt(a)?r[n]=this.hydrateReference(a,r,n,t):a!==void 0&&(r[n]=a);return r}setParent(e,t){return e.$container=t,e}hydrateReference(e,t,r,n){return this.linker.buildReference(t,r,n.cstNodes.get(e.$refNode),e.$refText)}hydrateCstNode(e,t,r=0){const n=t.cstNodes.get(e);if(typeof e.grammarSource=="number"&&(n.grammarSource=this.getGrammarElement(e.grammarSource)),n.astNode=t.astNodes.get(e.astNode),$r(n))for(const a of e.content){const s=this.hydrateCstNode(a,t,r++);n.content.push(s)}return n}hydrateCstLeafNode(e){const t=this.getTokenType(e.tokenType),r=e.offset,n=e.length,a=e.startLine,s=e.startColumn,o=e.endLine,l=e.endColumn,u=e.hidden;return new _l(r,n,{start:{line:a,character:s},end:{line:o,character:l}},t,u)}getTokenType(e){return this.lexer.definition[e]}getGrammarElementId(e){if(e)return this.grammarElementIdMap.size===0&&this.createGrammarElementIdMap(),this.grammarElementIdMap.get(e)}getGrammarElement(e){return this.grammarElementIdMap.size===0&&this.createGrammarElementIdMap(),this.grammarElementIdMap.getKey(e)}createGrammarElementIdMap(){let e=0;for(const t of Gt(this.grammar))Gl(t)&&this.grammarElementIdMap.set(t,e++)}};function je(e){return{documentation:{CommentProvider:i(t=>new kw(t),"CommentProvider"),DocumentationProvider:i(t=>new Pw(t),"DocumentationProvider")},parser:{AsyncParser:i(t=>new Ow(t),"AsyncParser"),GrammarConfig:i(t=>bp(t),"GrammarConfig"),LangiumParser:i(t=>Gm(t),"LangiumParser"),CompletionParser:i(t=>Mm(t),"CompletionParser"),ValueConverter:i(()=>new zm,"ValueConverter"),TokenBuilder:i(()=>new Du,"TokenBuilder"),Lexer:i(t=>new Zm(t),"Lexer"),ParserErrorMessageProvider:i(()=>new Lm,"ParserErrorMessageProvider"),LexerErrorMessageProvider:i(()=>new $w,"LexerErrorMessageProvider")},workspace:{AstNodeLocator:i(()=>new hw,"AstNodeLocator"),AstNodeDescriptionProvider:i(t=>new pw(t),"AstNodeDescriptionProvider"),ReferenceDescriptionProvider:i(t=>new mw(t),"ReferenceDescriptionProvider")},references:{Linker:i(t=>new tw(t),"Linker"),NameProvider:i(()=>new rw,"NameProvider"),ScopeProvider:i(t=>new ow(t),"ScopeProvider"),ScopeComputation:i(t=>new aw(t),"ScopeComputation"),References:i(t=>new nw(t),"References")},serializer:{Hydrator:i(t=>new Dw(t),"Hydrator"),JsonSerializer:i(t=>new lw(t),"JsonSerializer")},validation:{DocumentValidator:i(t=>new dw(t),"DocumentValidator"),ValidationRegistry:i(t=>new cw(t),"ValidationRegistry")},shared:i(()=>e.shared,"shared")}}i(je,"createDefaultCoreModule");function Be(e){return{ServiceRegistry:i(t=>new uw(t),"ServiceRegistry"),workspace:{LangiumDocuments:i(t=>new ew(t),"LangiumDocuments"),LangiumDocumentFactory:i(t=>new QS(t),"LangiumDocumentFactory"),DocumentBuilder:i(t=>new gw(t),"DocumentBuilder"),IndexManager:i(t=>new vw(t),"IndexManager"),WorkspaceManager:i(t=>new Tw(t),"WorkspaceManager"),FileSystemProvider:i(t=>e.fileSystemProvider(t),"FileSystemProvider"),WorkspaceLock:i(()=>new Lw,"WorkspaceLock"),ConfigurationProvider:i(t=>new yw(t),"ConfigurationProvider")},profilers:{}}}i(Be,"createDefaultSharedCoreModule");var nd;(function(e){e.merge=(t,r)=>Qa(Qa({},t),r)})(nd||(nd={}));function ee(e,t,r,n,a,s,o,l,u){const c=[e,t,r,n,a,s,o,l,u].reduce(Qa,{});return sh(c)}i(ee,"inject");var xw=Symbol("isProxy");function ih(e){if(e&&e[xw])for(const t of Object.values(e))ih(t);return e}i(ih,"eagerLoad");function sh(e,t){const r=new Proxy({},{deleteProperty:i(()=>!1,"deleteProperty"),set:i(()=>{throw new Error("Cannot set property on injected service container")},"set"),get:i((n,a)=>a===xw?!0:ad(n,a,e,t||r),"get"),getOwnPropertyDescriptor:i((n,a)=>(ad(n,a,e,t||r),Object.getOwnPropertyDescriptor(n,a)),"getOwnPropertyDescriptor"),has:i((n,a)=>a in e,"has"),ownKeys:i(()=>[...Object.getOwnPropertyNames(e)],"ownKeys")});return r}i(sh,"_inject");var Oy=Symbol();function ad(e,t,r,n){if(t in e){if(e[t]instanceof Error)throw new Error("Construction failure. Please make sure that your dependencies are constructable. Cause: "+e[t]);if(e[t]===Oy)throw new Error('Cycle detected. Please make "'+String(t)+'" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');return e[t]}else if(t in r){const a=r[t];e[t]=Oy;try{e[t]=typeof a=="function"?a(n):sh(a,n)}catch(s){throw e[t]=s instanceof Error?s:void 0,s}return e[t]}else return}i(ad,"_resolve");function Qa(e,t){if(t){for(const[r,n]of Object.entries(t))if(n!=null)if(typeof n=="object"){const a=e[r];typeof a=="object"&&a!==null?e[r]=Qa(a,n):e[r]=Qa({},n)}else e[r]=n}return e}i(Qa,"_merge");var id={indentTokenName:"INDENT",dedentTokenName:"DEDENT",whitespaceTokenName:"WS",ignoreIndentationDelimiters:[]},wn;(function(e){e.REGULAR="indentation-sensitive",e.IGNORE_INDENTATION="ignore-indentation"})(wn||(wn={}));var Mw=class extends Du{static{i(this,"IndentationAwareTokenBuilder")}constructor(e=id){super(),this.indentationStack=[0],this.whitespaceRegExp=/[ \t]+/y,this.options={...id,...e},this.indentTokenType=ja({name:this.options.indentTokenName,pattern:this.indentMatcher.bind(this),line_breaks:!1}),this.dedentTokenType=ja({name:this.options.dedentTokenName,pattern:this.dedentMatcher.bind(this),line_breaks:!1})}buildTokens(e,t){const r=super.buildTokens(e,t);if(!ju(r))throw new Error("Invalid tokens built by default builder");const{indentTokenName:n,dedentTokenName:a,whitespaceTokenName:s,ignoreIndentationDelimiters:o}=this.options;let l,u,c;const f=[];for(const d of r){for(const[m,g]of o)d.name===m?d.PUSH_MODE=wn.IGNORE_INDENTATION:d.name===g&&(d.POP_MODE=!0);d.name===a?l=d:d.name===n?u=d:d.name===s?c=d:f.push(d)}if(!l||!u||!c)throw new Error("Some indentation/whitespace tokens not found!");return o.length>0?{modes:{[wn.REGULAR]:[l,u,...f,c],[wn.IGNORE_INDENTATION]:[...f,c]},defaultMode:wn.REGULAR}:[l,u,c,...f]}flushLexingReport(e){return{...super.flushLexingReport(e),remainingDedents:this.flushRemainingDedents(e)}}isStartOfLine(e,t){return t===0||`\r +`.includes(e[t-1])}matchWhitespace(e,t,r,n){this.whitespaceRegExp.lastIndex=t;const a=this.whitespaceRegExp.exec(e);return{currIndentLevel:a?.[0].length??0,prevIndentLevel:this.indentationStack.at(-1),match:a}}createIndentationTokenInstance(e,t,r,n){const a=this.getLineNumber(t,n);return Qs(e,r,n,n+r.length,a,a,1,r.length)}getLineNumber(e,t){return e.substring(0,t).split(/\r\n|\r|\n/).length}indentMatcher(e,t,r,n){if(!this.isStartOfLine(e,t))return null;const{currIndentLevel:a,prevIndentLevel:s,match:o}=this.matchWhitespace(e,t,r,n);return a<=s?null:(this.indentationStack.push(a),o)}dedentMatcher(e,t,r,n){if(!this.isStartOfLine(e,t))return null;const{currIndentLevel:a,prevIndentLevel:s,match:o}=this.matchWhitespace(e,t,r,n);if(a>=s)return null;const l=this.indentationStack.lastIndexOf(a);if(l===-1)return this.diagnostics.push({severity:"error",message:`Invalid dedent level ${a} at offset: ${t}. Current indentation stack: ${this.indentationStack}`,offset:t,length:o?.[0]?.length??0,line:this.getLineNumber(e,t),column:1}),null;const u=this.indentationStack.length-l-1,c=e.substring(0,t).match(/[\r\n]+$/)?.[0].length??1;for(let f=0;f1;)t.push(this.createIndentationTokenInstance(this.dedentTokenType,e,"",e.length)),this.indentationStack.pop();return this.indentationStack=[0],t}},IF=class extends Zm{static{i(this,"IndentationAwareLexer")}constructor(e){if(super(e),e.parser.TokenBuilder instanceof Mw)this.indentationTokenBuilder=e.parser.TokenBuilder;else throw new Error("IndentationAwareLexer requires an accompanying IndentationAwareTokenBuilder")}tokenize(e,t=Jm){const r=super.tokenize(e),n=r.report;t?.mode==="full"&&r.tokens.push(...n.remainingDedents),n.remainingDedents=[];const{indentTokenType:a,dedentTokenType:s}=this.indentationTokenBuilder,o=a.tokenTypeIdx,l=s.tokenTypeIdx,u=[],c=r.tokens.length-1;for(let f=0;f=0&&u.push(r.tokens[c]),r.tokens=u,r}},oh={};Vr(oh,{AstUtils:()=>Nd,BiMap:()=>Nl,Cancellation:()=>pe,ContextCache:()=>Fu,CstUtils:()=>Sd,DONE_RESULT:()=>tt,Deferred:()=>wr,Disposable:()=>Nn,DisposableCache:()=>Gu,DocumentCache:()=>sw,EMPTY_STREAM:()=>Ua,ErrorWithLocation:()=>Wl,GrammarUtils:()=>sp,MultiMap:()=>Ir,OperationCancelled:()=>tr,Reduction:()=>Ts,RegExpUtils:()=>lp,SimpleCache:()=>Vm,StreamImpl:()=>er,TreeStreamImpl:()=>Ka,URI:()=>Tt,UriTrie:()=>Km,UriUtils:()=>nt,WorkspaceCache:()=>qm,assertCondition:()=>op,assertUnreachable:()=>qr,delayNextTick:()=>xu,interruptAndCheck:()=>ze,isOperationCancelled:()=>ta,loadGrammarFromJson:()=>Ue,setInterruptionPeriod:()=>jm,startCancelableOperation:()=>Mu,stream:()=>ue});Ll(oh,zu);var Gw=class{static{i(this,"EmptyFileSystemProvider")}stat(e){throw new Error("No file system is available.")}statSync(e){throw new Error("No file system is available.")}async exists(){return!1}existsSync(){return!1}readBinary(){throw new Error("No file system is available.")}readBinarySync(){throw new Error("No file system is available.")}readFile(){throw new Error("No file system is available.")}readFileSync(){throw new Error("No file system is available.")}async readDirectory(){return[]}readDirectorySync(){return[]}},Xe={fileSystemProvider:i(()=>new Gw,"fileSystemProvider")},NF={Grammar:i(()=>{},"Grammar"),LanguageMetaData:i(()=>({caseInsensitive:!1,fileExtensions:[".langium"],languageId:"langium"}),"LanguageMetaData")},PF={AstReflection:i(()=>new Jd,"AstReflection")};function Fw(){const e=ee(Be(Xe),PF),t=ee(je({shared:e}),NF);return e.ServiceRegistry.register(t),t}i(Fw,"createMinimalGrammarServices");function Ue(e){const t=Fw(),r=t.serializer.JsonSerializer.deserialize(e);return t.shared.workspace.LangiumDocumentFactory.fromModel(r,Tt.parse(`memory:/${r.name??"grammar"}.langium`)),r}i(Ue,"loadGrammarFromJson");Ll(Hg,oh);var kF=class{static{i(this,"DefaultLangiumProfiler")}constructor(e){this.activeCategories=new Set,this.allCategories=new Set(["validating","parsing","linking"]),this.activeCategories=e??new Set(this.allCategories),this.records=new Ir}isActive(e){return this.activeCategories.has(e)}start(...e){e?e.forEach(t=>this.activeCategories.add(t)):this.activeCategories=new Set(this.allCategories)}stop(...e){e?e.forEach(t=>this.activeCategories.delete(t)):this.activeCategories.clear()}createTask(e,t){if(!this.isActive(e))throw new Error(`Category "${e}" is not active.`);return console.log(`Creating profiling task for '${e}.${t}'.`),new zw(r=>this.records.add(e,this.dumpRecord(e,r)),t)}dumpRecord(e,t){console.info(`Task ${e}.${t.identifier} executed in ${t.duration.toFixed(2)}ms and ended at ${t.date.toISOString()}`);const r=[];for(const s of t.entries.keys()){const o=t.entries.get(s),l=o.reduce((u,c)=>u+c);r.push({name:`${t.identifier}.${s}`,count:o.length,duration:l})}const n=t.duration-r.map(s=>s.duration).reduce((s,o)=>s+o,0);r.push({name:t.identifier,count:1,duration:n}),r.sort((s,o)=>o.duration-s.duration);function a(s){return Math.round(100*s)/100}return i(a,"Round"),console.table(r.map(s=>({Element:s.name,Count:s.count,"Self %":a(100*s.duration/t.duration),"Time (ms)":a(s.duration)}))),t}getRecords(...e){return e.length===0?this.records.values():this.records.entries().filter(t=>e.some(r=>r===t[0])).flatMap(t=>t[1])}},zw=class{static{i(this,"ProfilingTask")}constructor(e,t){this.stack=[],this.entries=new Ir,this.addRecord=e,this.identifier=t}start(){if(this.startTime!==void 0)throw new Error(`Task "${this.identifier}" is already started.`);this.startTime=performance.now()}stop(){if(this.startTime===void 0)throw new Error(`Task "${this.identifier}" was not started.`);if(this.stack.length!==0)throw new Error(`Task "${this.identifier}" cannot be stopped before sub-task(s): ${this.stack.map(t=>t.id).join(", ")}.`);const e={identifier:this.identifier,date:new Date,duration:performance.now()-this.startTime,entries:this.entries};this.addRecord(e),this.startTime=void 0,this.entries.clear()}startSubTask(e){this.stack.push({id:e,start:performance.now(),content:0})}stopSubTask(e){const t=this.stack.pop();if(!t)throw new Error(`Task "${this.identifier}.${e}" was not started.`);if(t.id!==e)throw new Error(`Sub-Task "${t.id}" is not already stopped.`);const r=performance.now()-t.start;this.stack.at(-1)!==void 0&&(this.stack[this.stack.length-1].content+=r);const n=r-t.content;this.entries.add(e,n)}},sd;(e=>{e.Terminals={ARROW_DIRECTION:/L|R|T|B/,ARROW_GROUP:/\{group\}/,ARROW_INTO:/<|>/,ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,ID:/[\w]([-\w]*\w)?/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,ARCH_ICON:/\([\w-:]+\)/,ARCH_TITLE:/\[(?:"([^"\\]|\\.)*"|'([^'\\]|\\.)*'|[^\[\]\r\n]+)\]/}})(sd||(sd={}));var od;(e=>{e.Terminals={DOMAIN_NAME:/complex|complicated|clear|chaotic|confusion/,ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})(od||(od={}));var ld;(e=>{e.Terminals={EM_ID:/[_a-zA-Z][\w_]*/,EM_FID:/\d{1,3}/,EM_DATA_INLINE:/\{(.*)\}|"(.*)"|'(.*)'/,EM_DATA_BLOCK:/\{[\t ]*\r?\n(?:[\S\s]*?\r?\n)?\}(?:\r?\n|(?!\S))/,EM_ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,EM_ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,EM_TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,EM_WS:/\s+/,EM_YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,EM_DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,EM_SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,EM_ML_COMMENT:/\/\*[\s\S]*?\*\//,EM_SL_COMMENT:/\/\/[^\n\r]*/}})(ld||(ld={}));var ud;(e=>{e.Terminals={ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,INT:/0|[1-9][0-9]*(?!\.)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,REFERENCE:/\w([-\./\w]*[-\w])?/}})(ud||(ud={}));var cd;(e=>{e.Terminals={ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})(cd||(cd={}));var fd;(e=>{e.Terminals={ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,INT:/0|[1-9][0-9]*(?!\.)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})(fd||(fd={}));var dd;(e=>{e.Terminals={NUMBER_PIE:/(?:-?[0-9]+\.[0-9]+(?!\.))|(?:-?(0|[1-9][0-9]*)(?!\.))/,ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})(dd||(dd={}));var pd;(e=>{e.Terminals={GRATICULE:/circle|polygon/,BOOLEAN:/true|false/,ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,NUMBER:/(?:[0-9]+\.[0-9]+(?!\.))|(?:0|[1-9][0-9]*(?!\.))/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,ID:/[\w]([-\w]*\w)?/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})(pd||(pd={}));var md;(e=>{e.Terminals={TITLE:/title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,ACC_TITLE:/accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,ACC_DESCR:/accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ABNF_RULENAME:/[A-Za-z][A-Za-z0-9-]*/,ABNF_STRING:/"[^"]*"/,ABNF_NUMVAL:/%[xXdDbB][0-9A-Fa-f]+(?:-[0-9A-Fa-f]+|\.[0-9A-Fa-f]+)*/,ABNF_REPEAT:/[0-9]*\*[0-9]*/,ABNF_EXACT_REPEAT:/[0-9]+/,ABNF_WHITESPACE:/[\t \r\n]+/,ABNF_YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,ABNF_DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,ABNF_SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,ABNF_COMMENT:/;[^\n\r]*/}})(md||(md={}));var hd;(e=>{e.Terminals={TITLE:/title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,ACC_TITLE:/accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,ACC_DESCR:/accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,EBNF_ID:/[A-Z_a-z][\w-]*/,EBNF_STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,EBNF_SPECIAL_SEQUENCE:/\?(?=[^?;]*[^?\s;][^?;]*\?)[^?;]*\?/,EBNF_WHITESPACE:/[\t \r\n]+/,EBNF_YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,EBNF_DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,EBNF_SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,EBNF_BLOCK_COMMENT:/\/\*[\s\S]*?\*\//,EBNF_ISO_COMMENT:/\(\*[\s\S]*?\*\)/}})(hd||(hd={}));var yd;(e=>{e.Terminals={TITLE:/title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,ACC_TITLE:/accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,ACC_DESCR:/accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,RR_ID:/[A-Z_a-z][\w-]*/,RR_STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,RR_WHITESPACE:/[\t \r\n]+/,RR_YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,RR_DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,RR_SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,RR_BLOCK_COMMENT:/\/\*[\s\S]*?\*\//}})(yd||(yd={}));var gd;(e=>{e.Terminals={TITLE:/title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,ACC_TITLE:/accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,ACC_DESCR:/accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,PEG_ID:/[A-Z_a-z][\w-]*/,PEG_STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,PEG_WHITESPACE:/[\t \r\n]+/,PEG_YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,PEG_DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,PEG_SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/,PEG_LINE_COMMENT:/#[^\n\r]*/}})(gd||(gd={}));var vd;(e=>{e.Terminals={ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,TREEMAP_KEYWORD:/treemap-beta|treemap/,CLASS_DEF:/classDef\s+([a-zA-Z_][a-zA-Z0-9_]+)(?:\s+([^;\r\n]*))?(?:;)?/,STYLE_SEPARATOR:/:::/,SEPARATOR:/:/,COMMA:/,/,INDENTATION:/[ \t]{1,}/,WS:/[ \t]+/,ML_COMMENT:/\%\%[^\n]*/,NL:/\r?\n/,ID2:/[a-zA-Z_][a-zA-Z0-9_]*/,NUMBER2:/[0-9_\.\,]+/,STRING2:/"[^"]*"|'[^']*'/}})(vd||(vd={}));var Td;(e=>{e.Terminals={ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,CLASS_ANNOTATION:/[ \t]+:::[ \t]*[A-Za-z_][\w-]*/,ICON_ANNOTATION:/[ \t]+icon\([\w-]*(?::[\w-]+)?\)/,DESC_ANNOTATION:/[ \t]+##[^\n\r]*/,INDENTATION:/[ \t]{1,}/,QUOTED_NAME:/"[^"]*"|'[^']*'/,WS:/[ \t]+/,ML_COMMENT:/\%\%[^\n]*/,NL:/\r?\n/,BARE_NAME:/(?!:::|icon\(|##)[^ \t\n\r"'](?:(?![ \t]+:::[ \t]*[A-Za-z_]|[ \t]+icon\(|[ \t]+##)[^\n\r])*/}})(Td||(Td={}));var $d;(e=>{e.Terminals={WARDLEY_NUMBER:/[0-9]+\.[0-9]+/,ARROW:/->/,LINK_PORT:/\+<>|\+>|\+|-\.->|>|\+'[^']*'<>|\+'[^']*'<|\+'[^']*'>/,LINK_LABEL:/;[^\n\r]+/,STRATEGY:/build|buy|outsource|market/,KW_WARDLEY:/wardley-beta/,KW_SIZE:/size/,KW_EVOLUTION:/evolution/,KW_ANCHOR:/anchor/,KW_COMPONENT:/component/,KW_LABEL:/label/,KW_INERTIA:/inertia/,KW_EVOLVE:/evolve/,KW_PIPELINE:/pipeline/,KW_NOTE:/note/,KW_ANNOTATIONS:/annotations/,KW_ANNOTATION:/annotation/,KW_ACCELERATOR:/accelerator/,KW_DEACCELERATOR:/deaccelerator/,NAME_WITH_SPACES:/(?!title\s|accTitle|accDescr)[A-Za-z](?:[A-Za-z0-9_()&]|-(?!>))*(?:[ \t]+[A-Za-z(](?:[A-Za-z0-9_()&]|-(?!>))*)*/,WS:/[ \t]+/,ACC_DESCR:/[\t ]*accDescr(?:[\t ]*:([^\n\r]*?(?=%%)|[^\n\r]*)|\s*{([^}]*)})/,ACC_TITLE:/[\t ]*accTitle[\t ]*:(?:[^\n\r]*?(?=%%)|[^\n\r]*)/,TITLE:/[\t ]*title(?:[\t ][^\n\r]*?(?=%%)|[\t ][^\n\r]*|)/,INT:/0|[1-9][0-9]*(?!\.)/,STRING:/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,ID:/[\w]([-\w]*\w)?/,NEWLINE:/\r?\n/,WHITESPACE:/[\t ]+/,YAML:/---[\t ]*\r?\n(?:[\S\s]*?\r?\n)?---(?:\r?\n|(?!\S))/,DIRECTIVE:/[\t ]*%%{[\S\s]*?}%%(?:\r?\n|(?!\S))/,SINGLE_LINE_COMMENT:/[\t ]*%%[^\n\r]*/}})($d||($d={}));({...sd.Terminals,...od.Terminals,...ld.Terminals,...ud.Terminals,...cd.Terminals,...fd.Terminals,...dd.Terminals,...pd.Terminals,...md.Terminals,...hd.Terminals,...yd.Terminals,...gd.Terminals,...Td.Terminals,...vd.Terminals,...$d.Terminals});var Ly={$type:"AbnfAlternation",alternatives:"alternatives"},Dy={$type:"AbnfConcatenation",elements:"elements"},ec={$type:"AbnfElement",primary:"primary",repeat:"repeat"},xy={$type:"AbnfGroup",element:"element"},My={$type:"AbnfNumVal",value:"value"},Gy={$type:"AbnfOptionalGroup",element:"element"},ca={$type:"AbnfPrimary"},tc={$type:"AbnfRule",definition:"definition",name:"name"},Fy={$type:"AbnfRuleName",name:"name"},zy={$type:"AbnfStringLiteral",value:"value"},co={$type:"Accelerator",name:"name",x:"x",y:"y"},rc={$type:"Alignment",direction:"direction",members:"members"},fo={$type:"Anchor",evolution:"evolution",name:"name",visibility:"visibility"},xi={$type:"Annotation",number:"number",text:"text",x:"x",y:"y"},nc={$type:"Annotations",x:"x",y:"y"},Xt={$type:"Architecture",accDescr:"accDescr",accTitle:"accTitle",alignments:"alignments",edges:"edges",groups:"groups",junctions:"junctions",services:"services",title:"title"};function OF(e){return Ne.isInstance(e,Xt.$type)}i(OF,"isArchitecture");var po={$type:"Axis",label:"label",name:"name"},Ko={$type:"Branch",name:"name",order:"order"};function LF(e){return Ne.isInstance(e,Ko.$type)}i(LF,"isBranch");var jy={$type:"Checkout",branch:"branch"},mo={$type:"CherryPicking",id:"id",parent:"parent",tags:"tags"},ac={$type:"ClassDefStatement",className:"className",styleText:"styleText"},Aa={$type:"Commit",id:"id",message:"message",tags:"tags",type:"type"};function DF(e){return Ne.isInstance(e,Aa.$type)}i(DF,"isCommit");var ho={$type:"Common",accDescr:"accDescr",accTitle:"accTitle",title:"title"},Zr={$type:"Component",decorator:"decorator",evolution:"evolution",inertia:"inertia",label:"label",name:"name",visibility:"visibility"},yo={$type:"Curve",entries:"entries",label:"label",name:"name"},cn={$type:"Cynefin",accDescr:"accDescr",accTitle:"accTitle",domains:"domains",title:"title",transitions:"transitions"};function xF(e){return Ne.isInstance(e,cn.$type)}i(xF,"isCynefin");var go={$type:"Deaccelerator",name:"name",x:"x",y:"y"},By={$type:"Decorator",strategy:"strategy"},fa={$type:"Direction",accDescr:"accDescr",accTitle:"accTitle",dir:"dir",statements:"statements",title:"title"},Wo={$type:"DomainBlock",domain:"domain",items:"items"};function MF(e){return Ne.isInstance(e,Wo.$type)}i(MF,"isDomainBlock");var Rd={$type:"DomainItem",label:"label"};function GF(e){return Ne.isInstance(e,Rd.$type)}i(GF,"isDomainItem");var Uy={$type:"EbnfChoice",alternatives:"alternatives"},Ky={$type:"EbnfExceptionPostfix",except:"except"},Wy={$type:"EbnfGroup",element:"element"},Vy={$type:"EbnfNonTerminal",name:"name"},qy={$type:"EbnfOneOrMorePostfix",operator:"operator"},Hy={$type:"EbnfOptional",element:"element"},Yy={$type:"EbnfOptionalPostfix",operator:"operator"},Mi={$type:"EbnfPostfix"},Qr={$type:"EbnfPrimary"},Xy={$type:"EbnfRepetition",element:"element"},ic={$type:"EbnfRule",definition:"definition",name:"name"},Jy={$type:"EbnfSequence",elements:"elements"},Zy={$type:"EbnfSpecial",text:"text"},sc={$type:"EbnfTerm",base:"base",postfixes:"postfixes"},Qy={$type:"EbnfTerminal",value:"value"},eg={$type:"EbnfZeroOrMorePostfix",operator:"operator"},Ht={$type:"Edge",lhsDir:"lhsDir",lhsGroup:"lhsGroup",lhsId:"lhsId",lhsInto:"lhsInto",rhsDir:"rhsDir",rhsGroup:"rhsGroup",rhsId:"rhsId",rhsInto:"rhsInto",title:"title"},da={$type:"EmDataEntity",dataBlockValue:"dataBlockValue",dataType:"dataType",name:"name"},en={$type:"EmFrame"},Gi={$type:"EmGwt",givenStatements:"givenStatements",sourceFrame:"sourceFrame",thenStatements:"thenStatements",whenStatements:"whenStatements"},tg={$type:"EmGwtStatement",entityIdentifier:"entityIdentifier"},oc={$type:"EmModelEntity",name:"name"};function FF(e){return e==="rmo"||e==="readmodel"||e==="ui"||e==="cmd"||e==="command"||e==="evt"||e==="event"||e==="pcr"||e==="processor"}i(FF,"isEmModelEntityType");var vo={$type:"EmNoteEntity",dataBlockValue:"dataBlockValue",dataType:"dataType",sourceFrame:"sourceFrame"},yr={$type:"EmResetFrame",dataInlineValue:"dataInlineValue",dataReference:"dataReference",dataType:"dataType",entityIdentifier:"entityIdentifier",modelEntityType:"modelEntityType",name:"name",sourceFrames:"sourceFrames"};function zF(e){return Ne.isInstance(e,yr.$type)}i(zF,"isEmResetFrame");var Dr={$type:"EmTimeFrame",dataInlineValue:"dataInlineValue",dataReference:"dataReference",dataType:"dataType",entityIdentifier:"entityIdentifier",modelEntityType:"modelEntityType",name:"name",sourceFrames:"sourceFrames"},lc={$type:"Entry",axis:"axis",value:"value"},dr={$type:"EventModel",accDescr:"accDescr",accTitle:"accTitle",dataEntities:"dataEntities",frames:"frames",gwtEntities:"gwtEntities",modelEntities:"modelEntities",noteEntities:"noteEntities",title:"title"},rg={$type:"Evolution",stages:"stages"},To={$type:"EvolutionStage",boundary:"boundary",name:"name",secondName:"secondName"},uc={$type:"Evolve",component:"component",target:"target"},fn={$type:"GitGraph",accDescr:"accDescr",accTitle:"accTitle",statements:"statements",title:"title"};function jF(e){return Ne.isInstance(e,fn.$type)}i(jF,"isGitGraph");var Fi={$type:"Group",icon:"icon",id:"id",in:"in",title:"title"},ts={$type:"Info",accDescr:"accDescr",accTitle:"accTitle",title:"title"};function BF(e){return Ne.isInstance(e,ts.$type)}i(BF,"isInfo");var zi={$type:"Item",classSelector:"classSelector",name:"name"},cc={$type:"Junction",id:"id",in:"in"},ji={$type:"Label",negX:"negX",negY:"negY",offsetX:"offsetX",offsetY:"offsetY"},$o={$type:"Leaf",classSelector:"classSelector",name:"name",value:"value"},tn={$type:"Link",arrow:"arrow",from:"from",fromPort:"fromPort",linkLabel:"linkLabel",to:"to",toPort:"toPort"},Ea={$type:"Merge",branch:"branch",id:"id",tags:"tags",type:"type"};function UF(e){return Ne.isInstance(e,Ea.$type)}i(UF,"isMerge");var Ro={$type:"Note",evolution:"evolution",text:"text",visibility:"visibility"},fc={$type:"Option",name:"name",value:"value"},Ca={$type:"Packet",accDescr:"accDescr",accTitle:"accTitle",blocks:"blocks",title:"title"};function KF(e){return Ne.isInstance(e,Ca.$type)}i(KF,"isPacket");var _a={$type:"PacketBlock",bits:"bits",end:"end",label:"label",start:"start"};function WF(e){return Ne.isInstance(e,_a.$type)}i(WF,"isPacketBlock");var ng={$type:"PegAny",dot:"dot"},ag={$type:"PegGroup",element:"element"},ig={$type:"PegIdentifier",name:"name"},sg={$type:"PegLiteral",value:"value"},og={$type:"PegOrderedChoice",alternatives:"alternatives"},dc={$type:"PegPrefix",operator:"operator",suffix:"suffix"},Bi={$type:"PegPrimary"},pc={$type:"PegRule",definition:"definition",name:"name"},lg={$type:"PegSequence",elements:"elements"},mc={$type:"PegSuffix",operator:"operator",primary:"primary"},dn={$type:"Pie",accDescr:"accDescr",accTitle:"accTitle",sections:"sections",showData:"showData",title:"title"};function VF(e){return Ne.isInstance(e,dn.$type)}i(VF,"isPie");var Vo={$type:"PieSection",label:"label",value:"value"};function qF(e){return Ne.isInstance(e,Vo.$type)}i(qF,"isPieSection");var hc={$type:"Pipeline",components:"components",parent:"parent"},Ao={$type:"PipelineComponent",evolution:"evolution",label:"label",name:"name"},rn={$type:"Radar",accDescr:"accDescr",accTitle:"accTitle",axes:"axes",curves:"curves",options:"options",title:"title"},ba={$type:"Railroad",accDescr:"accDescr",accTitle:"accTitle",rules:"rules",title:"title"};function HF(e){return Ne.isInstance(e,ba.$type)}i(HF,"isRailroad");var Sa={$type:"RailroadAbnf",accDescr:"accDescr",accTitle:"accTitle",rules:"rules",title:"title"};function YF(e){return Ne.isInstance(e,Sa.$type)}i(YF,"isRailroadAbnf");var ug={$type:"RailroadChoiceExpr",alternatives:"alternatives"},wa={$type:"RailroadEbnf",accDescr:"accDescr",accTitle:"accTitle",rules:"rules",title:"title"};function XF(e){return Ne.isInstance(e,wa.$type)}i(XF,"isRailroadEbnf");var pr={$type:"RailroadExpression"},cg={$type:"RailroadNonTerminalExpr",name:"name"},fg={$type:"RailroadOneOrMoreExpr",element:"element"},dg={$type:"RailroadOptionalExpr",element:"element"},Ia={$type:"RailroadPeg",accDescr:"accDescr",accTitle:"accTitle",rules:"rules",title:"title"};function JF(e){return Ne.isInstance(e,Ia.$type)}i(JF,"isRailroadPeg");var yc={$type:"RailroadRule",definition:"definition",name:"name"},pg={$type:"RailroadSequenceExpr",elements:"elements"},mg={$type:"RailroadSpecialExpr",text:"text"},hg={$type:"RailroadTerminalExpr",value:"value"},yg={$type:"RailroadZeroOrMoreExpr",element:"element"},gc={$type:"Section",classSelector:"classSelector",name:"name"},pa={$type:"Service",icon:"icon",iconText:"iconText",id:"id",in:"in",title:"title"},vc={$type:"Size",height:"height",width:"width"},ma={$type:"Statement"},rs={$type:"Transition",from:"from",label:"label",to:"to"};function ZF(e){return Ne.isInstance(e,rs.$type)}i(ZF,"isTransition");var Na={$type:"Treemap",accDescr:"accDescr",accTitle:"accTitle",title:"title",TreemapRows:"TreemapRows"};function QF(e){return Ne.isInstance(e,Na.$type)}i(QF,"isTreemap");var Tc={$type:"TreemapRow",indent:"indent",item:"item"},ha={$type:"TreeNode",classAnnotation:"classAnnotation",descAnnotation:"descAnnotation",iconAnnotation:"iconAnnotation",indent:"indent",name:"name"},Ui={$type:"TreeView",accDescr:"accDescr",accTitle:"accTitle",nodes:"nodes",title:"title"},We={$type:"Wardley",accDescr:"accDescr",accelerators:"accelerators",accTitle:"accTitle",anchors:"anchors",annotation:"annotation",annotations:"annotations",components:"components",deaccelerators:"deaccelerators",evolution:"evolution",evolves:"evolves",links:"links",notes:"notes",pipelines:"pipelines",size:"size",title:"title"};function ez(e){return Ne.isInstance(e,We.$type)}i(ez,"isWardley");var jw=class extends Id{constructor(){super(...arguments),this.types={AbnfAlternation:{name:Ly.$type,properties:{alternatives:{name:Ly.alternatives,defaultValue:[]}},superTypes:[]},AbnfConcatenation:{name:Dy.$type,properties:{elements:{name:Dy.elements,defaultValue:[]}},superTypes:[]},AbnfElement:{name:ec.$type,properties:{primary:{name:ec.primary},repeat:{name:ec.repeat}},superTypes:[]},AbnfGroup:{name:xy.$type,properties:{element:{name:xy.element}},superTypes:[ca.$type]},AbnfNumVal:{name:My.$type,properties:{value:{name:My.value}},superTypes:[ca.$type]},AbnfOptionalGroup:{name:Gy.$type,properties:{element:{name:Gy.element}},superTypes:[ca.$type]},AbnfPrimary:{name:ca.$type,properties:{},superTypes:[]},AbnfRule:{name:tc.$type,properties:{definition:{name:tc.definition},name:{name:tc.name}},superTypes:[]},AbnfRuleName:{name:Fy.$type,properties:{name:{name:Fy.name}},superTypes:[ca.$type]},AbnfStringLiteral:{name:zy.$type,properties:{value:{name:zy.value}},superTypes:[ca.$type]},Accelerator:{name:co.$type,properties:{name:{name:co.name},x:{name:co.x},y:{name:co.y}},superTypes:[]},Alignment:{name:rc.$type,properties:{direction:{name:rc.direction},members:{name:rc.members,defaultValue:[]}},superTypes:[]},Anchor:{name:fo.$type,properties:{evolution:{name:fo.evolution},name:{name:fo.name},visibility:{name:fo.visibility}},superTypes:[]},Annotation:{name:xi.$type,properties:{number:{name:xi.number},text:{name:xi.text},x:{name:xi.x},y:{name:xi.y}},superTypes:[]},Annotations:{name:nc.$type,properties:{x:{name:nc.x},y:{name:nc.y}},superTypes:[]},Architecture:{name:Xt.$type,properties:{accDescr:{name:Xt.accDescr},accTitle:{name:Xt.accTitle},alignments:{name:Xt.alignments,defaultValue:[]},edges:{name:Xt.edges,defaultValue:[]},groups:{name:Xt.groups,defaultValue:[]},junctions:{name:Xt.junctions,defaultValue:[]},services:{name:Xt.services,defaultValue:[]},title:{name:Xt.title}},superTypes:[]},Axis:{name:po.$type,properties:{label:{name:po.label},name:{name:po.name}},superTypes:[]},Branch:{name:Ko.$type,properties:{name:{name:Ko.name},order:{name:Ko.order}},superTypes:[ma.$type]},Checkout:{name:jy.$type,properties:{branch:{name:jy.branch}},superTypes:[ma.$type]},CherryPicking:{name:mo.$type,properties:{id:{name:mo.id},parent:{name:mo.parent},tags:{name:mo.tags,defaultValue:[]}},superTypes:[ma.$type]},ClassDefStatement:{name:ac.$type,properties:{className:{name:ac.className},styleText:{name:ac.styleText}},superTypes:[]},Commit:{name:Aa.$type,properties:{id:{name:Aa.id},message:{name:Aa.message},tags:{name:Aa.tags,defaultValue:[]},type:{name:Aa.type}},superTypes:[ma.$type]},Common:{name:ho.$type,properties:{accDescr:{name:ho.accDescr},accTitle:{name:ho.accTitle},title:{name:ho.title}},superTypes:[]},Component:{name:Zr.$type,properties:{decorator:{name:Zr.decorator},evolution:{name:Zr.evolution},inertia:{name:Zr.inertia,defaultValue:!1},label:{name:Zr.label},name:{name:Zr.name},visibility:{name:Zr.visibility}},superTypes:[]},Curve:{name:yo.$type,properties:{entries:{name:yo.entries,defaultValue:[]},label:{name:yo.label},name:{name:yo.name}},superTypes:[]},Cynefin:{name:cn.$type,properties:{accDescr:{name:cn.accDescr},accTitle:{name:cn.accTitle},domains:{name:cn.domains,defaultValue:[]},title:{name:cn.title},transitions:{name:cn.transitions,defaultValue:[]}},superTypes:[]},Deaccelerator:{name:go.$type,properties:{name:{name:go.name},x:{name:go.x},y:{name:go.y}},superTypes:[]},Decorator:{name:By.$type,properties:{strategy:{name:By.strategy}},superTypes:[]},Direction:{name:fa.$type,properties:{accDescr:{name:fa.accDescr},accTitle:{name:fa.accTitle},dir:{name:fa.dir},statements:{name:fa.statements,defaultValue:[]},title:{name:fa.title}},superTypes:[fn.$type]},DomainBlock:{name:Wo.$type,properties:{domain:{name:Wo.domain},items:{name:Wo.items,defaultValue:[]}},superTypes:[]},DomainItem:{name:Rd.$type,properties:{label:{name:Rd.label}},superTypes:[]},EbnfChoice:{name:Uy.$type,properties:{alternatives:{name:Uy.alternatives,defaultValue:[]}},superTypes:[]},EbnfExceptionPostfix:{name:Ky.$type,properties:{except:{name:Ky.except}},superTypes:[Mi.$type]},EbnfGroup:{name:Wy.$type,properties:{element:{name:Wy.element}},superTypes:[Qr.$type]},EbnfNonTerminal:{name:Vy.$type,properties:{name:{name:Vy.name}},superTypes:[Qr.$type]},EbnfOneOrMorePostfix:{name:qy.$type,properties:{operator:{name:qy.operator}},superTypes:[Mi.$type]},EbnfOptional:{name:Hy.$type,properties:{element:{name:Hy.element}},superTypes:[Qr.$type]},EbnfOptionalPostfix:{name:Yy.$type,properties:{operator:{name:Yy.operator}},superTypes:[Mi.$type]},EbnfPostfix:{name:Mi.$type,properties:{},superTypes:[]},EbnfPrimary:{name:Qr.$type,properties:{},superTypes:[]},EbnfRepetition:{name:Xy.$type,properties:{element:{name:Xy.element}},superTypes:[Qr.$type]},EbnfRule:{name:ic.$type,properties:{definition:{name:ic.definition},name:{name:ic.name}},superTypes:[]},EbnfSequence:{name:Jy.$type,properties:{elements:{name:Jy.elements,defaultValue:[]}},superTypes:[]},EbnfSpecial:{name:Zy.$type,properties:{text:{name:Zy.text}},superTypes:[Qr.$type]},EbnfTerm:{name:sc.$type,properties:{base:{name:sc.base},postfixes:{name:sc.postfixes,defaultValue:[]}},superTypes:[]},EbnfTerminal:{name:Qy.$type,properties:{value:{name:Qy.value}},superTypes:[Qr.$type]},EbnfZeroOrMorePostfix:{name:eg.$type,properties:{operator:{name:eg.operator}},superTypes:[Mi.$type]},Edge:{name:Ht.$type,properties:{lhsDir:{name:Ht.lhsDir},lhsGroup:{name:Ht.lhsGroup,defaultValue:!1},lhsId:{name:Ht.lhsId},lhsInto:{name:Ht.lhsInto,defaultValue:!1},rhsDir:{name:Ht.rhsDir},rhsGroup:{name:Ht.rhsGroup,defaultValue:!1},rhsId:{name:Ht.rhsId},rhsInto:{name:Ht.rhsInto,defaultValue:!1},title:{name:Ht.title}},superTypes:[]},EmDataEntity:{name:da.$type,properties:{dataBlockValue:{name:da.dataBlockValue},dataType:{name:da.dataType},name:{name:da.name}},superTypes:[]},EmFrame:{name:en.$type,properties:{},superTypes:[]},EmGwt:{name:Gi.$type,properties:{givenStatements:{name:Gi.givenStatements,defaultValue:[]},sourceFrame:{name:Gi.sourceFrame,referenceType:en.$type},thenStatements:{name:Gi.thenStatements,defaultValue:[]},whenStatements:{name:Gi.whenStatements,defaultValue:[]}},superTypes:[]},EmGwtStatement:{name:tg.$type,properties:{entityIdentifier:{name:tg.entityIdentifier,referenceType:oc.$type}},superTypes:[]},EmModelEntity:{name:oc.$type,properties:{name:{name:oc.name}},superTypes:[]},EmNoteEntity:{name:vo.$type,properties:{dataBlockValue:{name:vo.dataBlockValue},dataType:{name:vo.dataType},sourceFrame:{name:vo.sourceFrame,referenceType:en.$type}},superTypes:[]},EmResetFrame:{name:yr.$type,properties:{dataInlineValue:{name:yr.dataInlineValue},dataReference:{name:yr.dataReference,referenceType:da.$type},dataType:{name:yr.dataType},entityIdentifier:{name:yr.entityIdentifier},modelEntityType:{name:yr.modelEntityType},name:{name:yr.name},sourceFrames:{name:yr.sourceFrames,defaultValue:[],referenceType:en.$type}},superTypes:[en.$type]},EmTimeFrame:{name:Dr.$type,properties:{dataInlineValue:{name:Dr.dataInlineValue},dataReference:{name:Dr.dataReference,referenceType:da.$type},dataType:{name:Dr.dataType},entityIdentifier:{name:Dr.entityIdentifier},modelEntityType:{name:Dr.modelEntityType},name:{name:Dr.name},sourceFrames:{name:Dr.sourceFrames,defaultValue:[],referenceType:en.$type}},superTypes:[en.$type]},Entry:{name:lc.$type,properties:{axis:{name:lc.axis,referenceType:po.$type},value:{name:lc.value}},superTypes:[]},EventModel:{name:dr.$type,properties:{accDescr:{name:dr.accDescr},accTitle:{name:dr.accTitle},dataEntities:{name:dr.dataEntities,defaultValue:[]},frames:{name:dr.frames,defaultValue:[]},gwtEntities:{name:dr.gwtEntities,defaultValue:[]},modelEntities:{name:dr.modelEntities,defaultValue:[]},noteEntities:{name:dr.noteEntities,defaultValue:[]},title:{name:dr.title}},superTypes:[]},Evolution:{name:rg.$type,properties:{stages:{name:rg.stages,defaultValue:[]}},superTypes:[]},EvolutionStage:{name:To.$type,properties:{boundary:{name:To.boundary},name:{name:To.name},secondName:{name:To.secondName}},superTypes:[]},Evolve:{name:uc.$type,properties:{component:{name:uc.component},target:{name:uc.target}},superTypes:[]},GitGraph:{name:fn.$type,properties:{accDescr:{name:fn.accDescr},accTitle:{name:fn.accTitle},statements:{name:fn.statements,defaultValue:[]},title:{name:fn.title}},superTypes:[]},Group:{name:Fi.$type,properties:{icon:{name:Fi.icon},id:{name:Fi.id},in:{name:Fi.in},title:{name:Fi.title}},superTypes:[]},Info:{name:ts.$type,properties:{accDescr:{name:ts.accDescr},accTitle:{name:ts.accTitle},title:{name:ts.title}},superTypes:[]},Item:{name:zi.$type,properties:{classSelector:{name:zi.classSelector},name:{name:zi.name}},superTypes:[]},Junction:{name:cc.$type,properties:{id:{name:cc.id},in:{name:cc.in}},superTypes:[]},Label:{name:ji.$type,properties:{negX:{name:ji.negX,defaultValue:!1},negY:{name:ji.negY,defaultValue:!1},offsetX:{name:ji.offsetX},offsetY:{name:ji.offsetY}},superTypes:[]},Leaf:{name:$o.$type,properties:{classSelector:{name:$o.classSelector},name:{name:$o.name},value:{name:$o.value}},superTypes:[zi.$type]},Link:{name:tn.$type,properties:{arrow:{name:tn.arrow},from:{name:tn.from},fromPort:{name:tn.fromPort},linkLabel:{name:tn.linkLabel},to:{name:tn.to},toPort:{name:tn.toPort}},superTypes:[]},Merge:{name:Ea.$type,properties:{branch:{name:Ea.branch},id:{name:Ea.id},tags:{name:Ea.tags,defaultValue:[]},type:{name:Ea.type}},superTypes:[ma.$type]},Note:{name:Ro.$type,properties:{evolution:{name:Ro.evolution},text:{name:Ro.text},visibility:{name:Ro.visibility}},superTypes:[]},Option:{name:fc.$type,properties:{name:{name:fc.name},value:{name:fc.value,defaultValue:!1}},superTypes:[]},Packet:{name:Ca.$type,properties:{accDescr:{name:Ca.accDescr},accTitle:{name:Ca.accTitle},blocks:{name:Ca.blocks,defaultValue:[]},title:{name:Ca.title}},superTypes:[]},PacketBlock:{name:_a.$type,properties:{bits:{name:_a.bits},end:{name:_a.end},label:{name:_a.label},start:{name:_a.start}},superTypes:[]},PegAny:{name:ng.$type,properties:{dot:{name:ng.dot}},superTypes:[Bi.$type]},PegGroup:{name:ag.$type,properties:{element:{name:ag.element}},superTypes:[Bi.$type]},PegIdentifier:{name:ig.$type,properties:{name:{name:ig.name}},superTypes:[Bi.$type]},PegLiteral:{name:sg.$type,properties:{value:{name:sg.value}},superTypes:[Bi.$type]},PegOrderedChoice:{name:og.$type,properties:{alternatives:{name:og.alternatives,defaultValue:[]}},superTypes:[]},PegPrefix:{name:dc.$type,properties:{operator:{name:dc.operator},suffix:{name:dc.suffix}},superTypes:[]},PegPrimary:{name:Bi.$type,properties:{},superTypes:[]},PegRule:{name:pc.$type,properties:{definition:{name:pc.definition},name:{name:pc.name}},superTypes:[]},PegSequence:{name:lg.$type,properties:{elements:{name:lg.elements,defaultValue:[]}},superTypes:[]},PegSuffix:{name:mc.$type,properties:{operator:{name:mc.operator},primary:{name:mc.primary}},superTypes:[]},Pie:{name:dn.$type,properties:{accDescr:{name:dn.accDescr},accTitle:{name:dn.accTitle},sections:{name:dn.sections,defaultValue:[]},showData:{name:dn.showData,defaultValue:!1},title:{name:dn.title}},superTypes:[]},PieSection:{name:Vo.$type,properties:{label:{name:Vo.label},value:{name:Vo.value}},superTypes:[]},Pipeline:{name:hc.$type,properties:{components:{name:hc.components,defaultValue:[]},parent:{name:hc.parent}},superTypes:[]},PipelineComponent:{name:Ao.$type,properties:{evolution:{name:Ao.evolution},label:{name:Ao.label},name:{name:Ao.name}},superTypes:[]},Radar:{name:rn.$type,properties:{accDescr:{name:rn.accDescr},accTitle:{name:rn.accTitle},axes:{name:rn.axes,defaultValue:[]},curves:{name:rn.curves,defaultValue:[]},options:{name:rn.options,defaultValue:[]},title:{name:rn.title}},superTypes:[]},Railroad:{name:ba.$type,properties:{accDescr:{name:ba.accDescr},accTitle:{name:ba.accTitle},rules:{name:ba.rules,defaultValue:[]},title:{name:ba.title}},superTypes:[]},RailroadAbnf:{name:Sa.$type,properties:{accDescr:{name:Sa.accDescr},accTitle:{name:Sa.accTitle},rules:{name:Sa.rules,defaultValue:[]},title:{name:Sa.title}},superTypes:[]},RailroadChoiceExpr:{name:ug.$type,properties:{alternatives:{name:ug.alternatives,defaultValue:[]}},superTypes:[pr.$type]},RailroadEbnf:{name:wa.$type,properties:{accDescr:{name:wa.accDescr},accTitle:{name:wa.accTitle},rules:{name:wa.rules,defaultValue:[]},title:{name:wa.title}},superTypes:[]},RailroadExpression:{name:pr.$type,properties:{},superTypes:[]},RailroadNonTerminalExpr:{name:cg.$type,properties:{name:{name:cg.name}},superTypes:[pr.$type]},RailroadOneOrMoreExpr:{name:fg.$type,properties:{element:{name:fg.element}},superTypes:[pr.$type]},RailroadOptionalExpr:{name:dg.$type,properties:{element:{name:dg.element}},superTypes:[pr.$type]},RailroadPeg:{name:Ia.$type,properties:{accDescr:{name:Ia.accDescr},accTitle:{name:Ia.accTitle},rules:{name:Ia.rules,defaultValue:[]},title:{name:Ia.title}},superTypes:[]},RailroadRule:{name:yc.$type,properties:{definition:{name:yc.definition},name:{name:yc.name}},superTypes:[]},RailroadSequenceExpr:{name:pg.$type,properties:{elements:{name:pg.elements,defaultValue:[]}},superTypes:[pr.$type]},RailroadSpecialExpr:{name:mg.$type,properties:{text:{name:mg.text}},superTypes:[pr.$type]},RailroadTerminalExpr:{name:hg.$type,properties:{value:{name:hg.value}},superTypes:[pr.$type]},RailroadZeroOrMoreExpr:{name:yg.$type,properties:{element:{name:yg.element}},superTypes:[pr.$type]},Section:{name:gc.$type,properties:{classSelector:{name:gc.classSelector},name:{name:gc.name}},superTypes:[zi.$type]},Service:{name:pa.$type,properties:{icon:{name:pa.icon},iconText:{name:pa.iconText},id:{name:pa.id},in:{name:pa.in},title:{name:pa.title}},superTypes:[]},Size:{name:vc.$type,properties:{height:{name:vc.height},width:{name:vc.width}},superTypes:[]},Statement:{name:ma.$type,properties:{},superTypes:[]},Transition:{name:rs.$type,properties:{from:{name:rs.from},label:{name:rs.label},to:{name:rs.to}},superTypes:[]},TreeNode:{name:ha.$type,properties:{classAnnotation:{name:ha.classAnnotation},descAnnotation:{name:ha.descAnnotation},iconAnnotation:{name:ha.iconAnnotation},indent:{name:ha.indent},name:{name:ha.name}},superTypes:[]},TreeView:{name:Ui.$type,properties:{accDescr:{name:Ui.accDescr},accTitle:{name:Ui.accTitle},nodes:{name:Ui.nodes,defaultValue:[]},title:{name:Ui.title}},superTypes:[]},Treemap:{name:Na.$type,properties:{accDescr:{name:Na.accDescr},accTitle:{name:Na.accTitle},title:{name:Na.title},TreemapRows:{name:Na.TreemapRows,defaultValue:[]}},superTypes:[]},TreemapRow:{name:Tc.$type,properties:{indent:{name:Tc.indent},item:{name:Tc.item}},superTypes:[]},Wardley:{name:We.$type,properties:{accDescr:{name:We.accDescr},accelerators:{name:We.accelerators,defaultValue:[]},accTitle:{name:We.accTitle},anchors:{name:We.anchors,defaultValue:[]},annotation:{name:We.annotation,defaultValue:[]},annotations:{name:We.annotations,defaultValue:[]},components:{name:We.components,defaultValue:[]},deaccelerators:{name:We.deaccelerators,defaultValue:[]},evolution:{name:We.evolution},evolves:{name:We.evolves,defaultValue:[]},links:{name:We.links,defaultValue:[]},notes:{name:We.notes,defaultValue:[]},pipelines:{name:We.pipelines,defaultValue:[]},size:{name:We.size},title:{name:We.title}},superTypes:[]}}}static{i(this,"MermaidAstReflection")}},Ne=new jw,gg,tz=i(()=>gg??(gg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"ArchitectureGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Architecture","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"architecture-beta"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"groups","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"services","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"junctions","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Assignment","feature":"edges","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"alignments","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]},"entry":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"LeftPort","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"lhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}]},"entry":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"RightPort","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"rhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Keyword","value":":"}]},"entry":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"Arrow","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]},{"$type":"Assignment","feature":"lhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"--"},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@30"},"arguments":[]}},{"$type":"Keyword","value":"-"}]}]},{"$type":"Assignment","feature":"rhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}]},"entry":false,"parameters":[]},{"$type":"ParserRule","name":"Group","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"group"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@30"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Service","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"service"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"iconText","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]}}],"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@30"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Junction","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"junction"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Edge","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"lhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Assignment","feature":"lhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Assignment","feature":"rhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Assignment","feature":"rhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Alignment","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"align"},{"$type":"Assignment","feature":"direction","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"row"},{"$type":"Keyword","value":"column"}]}},{"$type":"Assignment","feature":"members","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Assignment","feature":"members","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]},"cardinality":"+"},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"ARROW_DIRECTION","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"L"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"R"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"T"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"B"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_GROUP","definition":{"$type":"RegexToken","regex":"/\\\\{group\\\\}/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_INTO","definition":{"$type":"RegexToken","regex":"/<|>/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@19"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@20"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","name":"ARCH_ICON","definition":{"$type":"RegexToken","regex":"/\\\\([\\\\w-:]+\\\\)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_TITLE","definition":{"$type":"RegexToken","regex":"/\\\\[(?:\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'|[^\\\\[\\\\]\\\\r\\\\n]+)\\\\]/","parenthesized":false},"fragment":false,"hidden":false}],"interfaces":[],"types":[]}`)),"ArchitectureGrammarGrammar"),vg,rz=i(()=>vg??(vg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"CynefinGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Cynefin","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"cynefin-beta"},{"$type":"Keyword","value":"cynefin-beta:"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"Assignment","feature":"domains","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"transitions","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"DomainBlock","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"domain","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Assignment","feature":"items","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"*"}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"DomainItem","definition":{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Transition","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"from","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Keyword","value":"-->"},{"$type":"Assignment","feature":"to","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"DOMAIN_NAME","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"complex"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"complicated"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"clear"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"chaotic"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"confusion"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@11"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@12"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[],"types":[]}`)),"CynefinGrammarGrammar"),Tg,nz=i(()=>Tg??(Tg=Ue('{"$type":"Grammar","isDeclared":true,"name":"EventModeling","interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"rules":[{"$type":"ParserRule","entry":true,"name":"EventModel","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"eventmodeling"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Assignment","feature":"modelEntities","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Assignment","feature":"frames","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"dataEntities","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Assignment","feature":"noteEntities","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Assignment","feature":"gwtEntities","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmModelEntityType","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"rmo"},{"$type":"Keyword","value":"readmodel"},{"$type":"Keyword","value":"ui"},{"$type":"Keyword","value":"cmd"},{"$type":"Keyword","value":"command"},{"$type":"Keyword","value":"evt"},{"$type":"Keyword","value":"event"},{"$type":"Keyword","value":"pcr"},{"$type":"Keyword","value":"processor"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmDataType","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"json"},{"$type":"Keyword","value":"jsobj"},{"$type":"Keyword","value":"figma"},{"$type":"Keyword","value":"salt"},{"$type":"Keyword","value":"uri"},{"$type":"Keyword","value":"md"},{"$type":"Keyword","value":"html"},{"$type":"Keyword","value":"text"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"EmDataInline","definition":{"$type":"Group","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"`"},{"$type":"Assignment","feature":"dataType","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Keyword","value":"`"}],"cardinality":"?"},{"$type":"Assignment","feature":"dataInlineValue","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},"entry":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"EmDataBlock","definition":{"$type":"Group","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"`"},{"$type":"Assignment","feature":"dataType","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Keyword","value":"`"}],"cardinality":"?"},{"$type":"Assignment","feature":"dataBlockValue","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}}]},"entry":false,"parameters":[]},{"$type":"ParserRule","name":"QualifiedName","dataType":"string","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},{"$type":"Group","elements":[{"$type":"Keyword","value":"."},{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmTimeFrame","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"tf"},{"$type":"Keyword","value":"timeframe"}]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Assignment","feature":"modelEntityType","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"entityIdentifier","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"->>"},{"$type":"Assignment","feature":"sourceFrames","operator":"+=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@8"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}}],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"[["},{"$type":"Assignment","feature":"dataReference","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@10"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}},{"$type":"Keyword","value":"]]"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmResetFrame","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"rf"},{"$type":"Keyword","value":"resetframe"}]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Assignment","feature":"modelEntityType","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"entityIdentifier","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"->>"},{"$type":"Assignment","feature":"sourceFrames","operator":"+=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@8"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}}],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"[["},{"$type":"Assignment","feature":"dataReference","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@10"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}},{"$type":"Keyword","value":"]]"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmFrame","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmModelEntity","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"entity"},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmDataEntity","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"data"},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmNoteEntity","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"note"},{"$type":"Assignment","feature":"sourceFrame","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@8"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmGwt","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"gwt"},{"$type":"Assignment","feature":"sourceFrame","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@8"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}},{"$type":"Keyword","value":"given"},{"$type":"Assignment","feature":"givenStatements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"+"},{"$type":"Group","elements":[{"$type":"Keyword","value":"when"},{"$type":"Assignment","feature":"whenStatements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"+"}],"cardinality":"?"},{"$type":"Keyword","value":"then"},{"$type":"Assignment","feature":"thenStatements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"+"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EmGwtStatement","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]},{"$type":"Assignment","feature":"entityIdentifier","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@9"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EM_EID","dataType":"string","definition":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EM_FI","dataType":"string","definition":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"EM_ID","definition":{"$type":"RegexToken","regex":"/[_a-zA-Z][\\\\w_]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_FID","definition":{"$type":"RegexToken","regex":"/\\\\d{1,3}/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_DATA_INLINE","definition":{"$type":"RegexToken","regex":"/\\\\{(.*)\\\\}|\\"(.*)\\"|\'(.*)\'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_DATA_BLOCK","definition":{"$type":"RegexToken","regex":"/\\\\{[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?\\\\}(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EM_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"EM_WS","definition":{"$type":"RegexToken","regex":"/\\\\s+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EM_YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EM_DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EM_SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EM_ML_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EM_SL_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\/\\\\/[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"imports":[],"types":[]}')),"EventModelingGrammar"),$g,az=i(()=>$g??($g=Ue(`{"$type":"Grammar","isDeclared":true,"name":"GitGraphGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"GitGraph","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Keyword","value":":"}]},{"$type":"Keyword","value":"gitGraph:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]},{"$type":"Keyword","value":":"}]}]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]},{"$type":"Assignment","feature":"statements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Direction","definition":{"$type":"Assignment","feature":"dir","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"LR"},{"$type":"Keyword","value":"TB"},{"$type":"Keyword","value":"BT"}]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Commit","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"commit"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"msg:","cardinality":"?"},{"$type":"Assignment","feature":"message","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Branch","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"branch"},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"order:"},{"$type":"Assignment","feature":"order","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Merge","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"merge"},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Checkout","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"checkout"},{"$type":"Keyword","value":"switch"}]},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"CherryPicking","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"cherry-pick"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"parent:"},{"$type":"Assignment","feature":"parent","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@14"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@15"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","name":"REFERENCE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\\\w([-\\\\./\\\\w]*[-\\\\w])?/","parenthesized":false},"fragment":false,"hidden":false}],"interfaces":[],"types":[]}`)),"GitGraphGrammarGrammar"),Rg,iz=i(()=>Rg??(Rg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"InfoGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Info","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"info"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"showInfo"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"?"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@7"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[],"types":[]}`)),"InfoGrammarGrammar"),Ag,sz=i(()=>Ag??(Ag=Ue(`{"$type":"Grammar","isDeclared":true,"name":"PacketGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Packet","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"packet"},{"$type":"Keyword","value":"packet-beta"}]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"Assignment","feature":"blocks","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PacketBlock","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"start","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"end","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}],"cardinality":"?"}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"+"},{"$type":"Assignment","feature":"bits","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]}]},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@9"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[],"types":[]}`)),"PacketGrammarGrammar"),Eg,oz=i(()=>Eg??(Eg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"PieGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Pie","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"pie"},{"$type":"Assignment","feature":"showData","operator":"?=","terminal":{"$type":"Keyword","value":"showData"},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"Assignment","feature":"sections","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PieSection","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"FLOAT_PIE","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/-?[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT_PIE","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/-?(0|[1-9][0-9]*)(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER_PIE","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@2"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@3"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@11"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@12"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[],"types":[]}`)),"PieGrammarGrammar"),Cg,lz=i(()=>Cg??(Cg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"RadarGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Radar","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":"radar-beta:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":":"}]}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]},{"$type":"Group","elements":[{"$type":"Keyword","value":"axis"},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"curve"},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"Label","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"entry":false,"parameters":[]},{"$type":"ParserRule","name":"Axis","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Curve","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"?"},{"$type":"Keyword","value":"{"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Keyword","value":"}"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"Entries","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"}]}]},"entry":false,"parameters":[]},{"$type":"ParserRule","name":"DetailedEntry","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"axis","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@2"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},"deprecatedSyntax":false,"isMulti":false}},{"$type":"Keyword","value":":","cardinality":"?"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"NumberEntry","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Option","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"showLegend"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"ticks"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"max"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"min"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"graticule"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}}]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"GRATICULE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"circle"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"polygon"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@15"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@16"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[{"$type":"Interface","name":"Entry","attributes":[{"$type":"TypeAttribute","name":"axis","isOptional":true,"type":{"$type":"ReferenceType","referenceType":{"$type":"SimpleType","typeRef":{"$ref":"#/rules@2"}},"isMulti":false}},{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"number"},"isOptional":false}],"superTypes":[]}],"types":[]}`)),"RadarGrammarGrammar"),_g,uz=i(()=>_g??(_g=Ue('{"$type":"Grammar","isDeclared":true,"name":"RailroadAbnfGrammar","rules":[{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ABNF_RULENAME","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[A-Za-z][A-Za-z0-9-]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ABNF_STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ABNF_NUMVAL","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/%[xXdDbB][0-9A-Fa-f]+(?:-[0-9A-Fa-f]+|\\\\.[0-9A-Fa-f]+)*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ABNF_REPEAT","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[0-9]*\\\\*[0-9]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ABNF_EXACT_REPEAT","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[0-9]+/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"ABNF_WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t \\\\r\\\\n]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ABNF_YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ABNF_DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ABNF_SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ABNF_COMMENT","definition":{"$type":"RegexToken","regex":"/;[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"ParserRule","entry":true,"name":"RailroadAbnf","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"railroad-abnf-beta"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"},{"$type":"Assignment","feature":"rules","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfRule","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Keyword","value":"="},{"$type":"Assignment","feature":"definition","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Keyword","value":";"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfAlternation","returnType":{"$ref":"#/interfaces@2"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"/"},{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfConcatenation","returnType":{"$ref":"#/interfaces@3"},"definition":{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]},"cardinality":"+"},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfElement","returnType":{"$ref":"#/interfaces@4"},"definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"repeat","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"repeat","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}],"cardinality":"?"},{"$type":"Assignment","feature":"primary","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfPrimary","returnType":{"$ref":"#/interfaces@5"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfStringLiteral","returnType":{"$ref":"#/interfaces@6"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfNumVal","returnType":{"$ref":"#/interfaces@7"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfRuleName","returnType":{"$ref":"#/interfaces@8"},"definition":{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfGroup","returnType":{"$ref":"#/interfaces@9"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"AbnfOptionalGroup","returnType":{"$ref":"#/interfaces@10"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"entry":false,"fragment":false,"parameters":[]}],"interfaces":[{"$type":"Interface","name":"RailroadAbnf","attributes":[{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"rules","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@1"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"AbnfRule","attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"definition","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"AbnfAlternation","attributes":[{"$type":"TypeAttribute","name":"alternatives","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@3"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"AbnfConcatenation","attributes":[{"$type":"TypeAttribute","name":"elements","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@4"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"AbnfElement","attributes":[{"$type":"TypeAttribute","name":"repeat","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"primary","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@5"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"AbnfPrimary","attributes":[],"superTypes":[]},{"$type":"Interface","name":"AbnfStringLiteral","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"AbnfNumVal","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"AbnfRuleName","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"AbnfGroup","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"AbnfOptionalGroup","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]}],"imports":[],"types":[]}')),"RailroadAbnfGrammarGrammar"),bg,cz=i(()=>bg??(bg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"RailroadEbnfGrammar","rules":[{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EBNF_ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[A-Z_a-z][\\\\w-]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EBNF_STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"EBNF_SPECIAL_SEQUENCE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\\\?(?=[^?;]*[^?\\\\s;][^?;]*\\\\?)[^?;]*\\\\?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t \\\\r\\\\n]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_BLOCK_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"EBNF_ISO_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\(\\\\*[\\\\s\\\\S]*?\\\\*\\\\)/","parenthesized":false},"fragment":false},{"$type":"ParserRule","entry":true,"name":"RailroadEbnf","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"railroad-ebnf-beta"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"},{"$type":"Assignment","feature":"rules","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfRule","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"="},{"$type":"Keyword","value":"::="}]},{"$type":"Assignment","feature":"definition","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Keyword","value":";"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfChoice","returnType":{"$ref":"#/interfaces@2"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"|"},{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfSequence","returnType":{"$ref":"#/interfaces@3"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":",","cardinality":"?"},{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfTerm","returnType":{"$ref":"#/interfaces@4"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"base","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},{"$type":"Assignment","feature":"postfixes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfPrimary","returnType":{"$ref":"#/interfaces@5"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfTerminal","returnType":{"$ref":"#/interfaces@7"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfNonTerminal","returnType":{"$ref":"#/interfaces@8"},"definition":{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfSpecial","returnType":{"$ref":"#/interfaces@9"},"definition":{"$type":"Assignment","feature":"text","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfGroup","returnType":{"$ref":"#/interfaces@10"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfOptional","returnType":{"$ref":"#/interfaces@11"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfRepetition","returnType":{"$ref":"#/interfaces@12"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"{"},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Keyword","value":"}"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfPostfix","returnType":{"$ref":"#/interfaces@6"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@25"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@26"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@27"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@28"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfOptionalPostfix","returnType":{"$ref":"#/interfaces@13"},"definition":{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"?"}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfZeroOrMorePostfix","returnType":{"$ref":"#/interfaces@14"},"definition":{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"*"}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfOneOrMorePostfix","returnType":{"$ref":"#/interfaces@15"},"definition":{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"+"}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EbnfExceptionPostfix","returnType":{"$ref":"#/interfaces@16"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"except","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},"entry":false,"fragment":false,"parameters":[]}],"interfaces":[{"$type":"Interface","name":"RailroadEbnf","attributes":[{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"rules","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@1"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"EbnfRule","attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"definition","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"EbnfChoice","attributes":[{"$type":"TypeAttribute","name":"alternatives","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@3"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"EbnfSequence","attributes":[{"$type":"TypeAttribute","name":"elements","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@4"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"EbnfTerm","attributes":[{"$type":"TypeAttribute","name":"base","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@5"}},"isOptional":false},{"$type":"TypeAttribute","name":"postfixes","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@6"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"EbnfPrimary","attributes":[],"superTypes":[]},{"$type":"Interface","name":"EbnfPostfix","attributes":[],"superTypes":[]},{"$type":"Interface","name":"EbnfTerminal","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfNonTerminal","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfSpecial","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"text","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfGroup","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"EbnfOptional","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"EbnfRepetition","superTypes":[{"$ref":"#/interfaces@5"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"EbnfOptionalPostfix","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"operator","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfZeroOrMorePostfix","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"operator","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfOneOrMorePostfix","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"operator","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"EbnfExceptionPostfix","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"except","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@5"}},"isOptional":false}]}],"imports":[],"types":[]}`)),"RailroadEbnfGrammarGrammar"),Sg,fz=i(()=>Sg??(Sg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"RailroadGrammar","rules":[{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"RR_ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[A-Z_a-z][\\\\w-]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"RR_STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"RR_WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t \\\\r\\\\n]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"RR_YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"RR_DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"RR_SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"RR_BLOCK_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//","parenthesized":false},"fragment":false},{"$type":"ParserRule","entry":true,"name":"Railroad","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"railroad-beta"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"},{"$type":"Assignment","feature":"rules","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadRule","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Keyword","value":"="},{"$type":"Assignment","feature":"definition","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":";"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadExpression","returnType":{"$ref":"#/interfaces@2"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadSequenceExpr","returnType":{"$ref":"#/interfaces@3"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"sequence"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}}],"cardinality":"*"},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadChoiceExpr","returnType":{"$ref":"#/interfaces@4"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"choice"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}}],"cardinality":"*"},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadOptionalExpr","returnType":{"$ref":"#/interfaces@5"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"optional"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadOneOrMoreExpr","returnType":{"$ref":"#/interfaces@6"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"oneOrMore"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadZeroOrMoreExpr","returnType":{"$ref":"#/interfaces@7"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"zeroOrMore"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadTerminalExpr","returnType":{"$ref":"#/interfaces@8"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"terminal"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadNonTerminalExpr","returnType":{"$ref":"#/interfaces@9"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"nonterminal"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"RailroadSpecialExpr","returnType":{"$ref":"#/interfaces@10"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"special"},{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"text","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]}],"interfaces":[{"$type":"Interface","name":"Railroad","attributes":[{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"rules","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@1"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"RailroadRule","attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"definition","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"RailroadExpression","attributes":[],"superTypes":[]},{"$type":"Interface","name":"RailroadSequenceExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"elements","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}}},"isOptional":false}]},{"$type":"Interface","name":"RailroadChoiceExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"alternatives","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}}},"isOptional":false}]},{"$type":"Interface","name":"RailroadOptionalExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"RailroadOneOrMoreExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"RailroadZeroOrMoreExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"RailroadTerminalExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"RailroadNonTerminalExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"RailroadSpecialExpr","superTypes":[{"$ref":"#/interfaces@2"}],"attributes":[{"$type":"TypeAttribute","name":"text","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]}],"imports":[],"types":[]}`)),"RailroadGrammarGrammar"),wg,dz=i(()=>wg??(wg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"RailroadPegGrammar","rules":[{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"PEG_ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[A-Z_a-z][\\\\w-]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"PEG_STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"PEG_WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t \\\\r\\\\n]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"PEG_YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"PEG_DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"PEG_SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"PEG_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/#[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false},{"$type":"ParserRule","entry":true,"name":"RailroadPeg","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"railroad-peg-beta"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"},{"$type":"Assignment","feature":"rules","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegRule","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Keyword","value":"<-"},{"$type":"Assignment","feature":"definition","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":";"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegOrderedChoice","returnType":{"$ref":"#/interfaces@2"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"/"},{"$type":"Assignment","feature":"alternatives","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegSequence","returnType":{"$ref":"#/interfaces@3"},"definition":{"$type":"Assignment","feature":"elements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"cardinality":"+"},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegPrefix","returnType":{"$ref":"#/interfaces@4"},"definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"&"}},{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"!"}}],"cardinality":"?"},{"$type":"Assignment","feature":"suffix","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegSuffix","returnType":{"$ref":"#/interfaces@5"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"primary","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"?"}},{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"*"}},{"$type":"Assignment","feature":"operator","operator":"=","terminal":{"$type":"Keyword","value":"+"}}],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegPrimary","returnType":{"$ref":"#/interfaces@6"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegLiteral","returnType":{"$ref":"#/interfaces@7"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegIdentifier","returnType":{"$ref":"#/interfaces@8"},"definition":{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegGroup","returnType":{"$ref":"#/interfaces@9"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"element","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PegAny","returnType":{"$ref":"#/interfaces@10"},"definition":{"$type":"Assignment","feature":"dot","operator":"=","terminal":{"$type":"Keyword","value":"."}},"entry":false,"fragment":false,"parameters":[]}],"interfaces":[{"$type":"Interface","name":"RailroadPeg","attributes":[{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"rules","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@1"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"PegRule","attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"definition","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"PegOrderedChoice","attributes":[{"$type":"TypeAttribute","name":"alternatives","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@3"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"PegSequence","attributes":[{"$type":"TypeAttribute","name":"elements","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@4"}}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"PegPrefix","attributes":[{"$type":"TypeAttribute","name":"operator","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"suffix","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@5"}},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"PegSuffix","attributes":[{"$type":"TypeAttribute","name":"primary","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@6"}},"isOptional":false},{"$type":"TypeAttribute","name":"operator","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]},{"$type":"Interface","name":"PegPrimary","attributes":[],"superTypes":[]},{"$type":"Interface","name":"PegLiteral","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"PegIdentifier","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]},{"$type":"Interface","name":"PegGroup","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"element","type":{"$type":"SimpleType","typeRef":{"$ref":"#/interfaces@2"}},"isOptional":false}]},{"$type":"Interface","name":"PegAny","superTypes":[{"$ref":"#/interfaces@6"}],"attributes":[{"$type":"TypeAttribute","name":"dot","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}]}],"imports":[],"types":[]}`)),"RailroadPegGrammarGrammar"),Ig,pz=i(()=>Ig??(Ig=Ue(`{"$type":"Grammar","isDeclared":true,"name":"TreemapGrammar","rules":[{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","entry":true,"name":"Treemap","returnType":{"$ref":"#/interfaces@4"},"definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]},{"$type":"Assignment","feature":"TreemapRows","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"TREEMAP_KEYWORD","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"treemap-beta"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"treemap"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"CLASS_DEF","definition":{"$type":"RegexToken","regex":"/classDef\\\\s+([a-zA-Z_][a-zA-Z0-9_]+)(?:\\\\s+([^;\\\\r\\\\n]*))?(?:;)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STYLE_SEPARATOR","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":":::"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"SEPARATOR","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":":"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"COMMA","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":","},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INDENTATION","definition":{"$type":"RegexToken","regex":"/[ \\\\t]{1,}/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WS","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ML_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\%\\\\%[^\\\\n]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"NL","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false},{"$type":"ParserRule","name":"TreemapRow","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"indent","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"item","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"ClassDef","dataType":"string","definition":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Item","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Section","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]},{"$type":"Assignment","feature":"classSelector","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Leaf","returnType":{"$ref":"#/interfaces@2"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[],"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[],"cardinality":"?"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]},{"$type":"Assignment","feature":"classSelector","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"ID2","definition":{"$type":"RegexToken","regex":"/[a-zA-Z_][a-zA-Z0-9_]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER2","definition":{"$type":"RegexToken","regex":"/[0-9_\\\\.\\\\,]+/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"MyNumber","dataType":"number","definition":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"STRING2","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"|'[^']*'/","parenthesized":false},"fragment":false,"hidden":false}],"interfaces":[{"$type":"Interface","name":"Item","attributes":[{"$type":"TypeAttribute","name":"name","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"classSelector","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]},{"$type":"Interface","name":"Section","superTypes":[{"$ref":"#/interfaces@0"}],"attributes":[]},{"$type":"Interface","name":"Leaf","superTypes":[{"$ref":"#/interfaces@0"}],"attributes":[{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"number"},"isOptional":false}]},{"$type":"Interface","name":"ClassDefStatement","attributes":[{"$type":"TypeAttribute","name":"className","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false},{"$type":"TypeAttribute","name":"styleText","type":{"$type":"SimpleType","primitiveType":"string"},"isOptional":false}],"superTypes":[]},{"$type":"Interface","name":"Treemap","attributes":[{"$type":"TypeAttribute","name":"TreemapRows","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/rules@15"}}},"isOptional":false},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"imports":[],"types":[],"$comment":"/**\\n * Treemap grammar for Langium\\n * Converted from mindmap grammar\\n *\\n * The ML_COMMENT and NL hidden terminals handle whitespace, comments, and newlines\\n * before the treemap keyword, allowing for empty lines and comments before the\\n * treemap declaration.\\n */"}`)),"TreemapGrammarGrammar"),Ng,mz=i(()=>Ng??(Ng=Ue(`{"$type":"Grammar","isDeclared":true,"name":"TreeViewGrammar","rules":[{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","entry":true,"name":"TreeView","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"treeView-beta"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[],"cardinality":"?"},{"$type":"Assignment","feature":"nodes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"CLASS_ANNOTATION","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+:::[ \\\\t]*[A-Za-z_][\\\\w-]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ICON_ANNOTATION","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+icon\\\\([\\\\w-]*(?::[\\\\w-]+)?\\\\)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"DESC_ANNOTATION","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+##[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INDENTATION","definition":{"$type":"RegexToken","regex":"/[ \\\\t]{1,}/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"QUOTED_NAME","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"|'[^']*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WS","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"ML_COMMENT","definition":{"$type":"RegexToken","regex":"/\\\\%\\\\%[^\\\\n]*/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"NL","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","name":"BARE_NAME","definition":{"$type":"RegexToken","regex":"/(?!:::|icon\\\\(|##)[^ \\\\t\\\\n\\\\r\\"'](?:(?![ \\\\t]+:::[ \\\\t]*[A-Za-z_]|[ \\\\t]+icon\\\\(|[ \\\\t]+##)[^\\\\n\\\\r])*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"ParserRule","name":"TreeNode","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"indent","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}}]},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"classAnnotation","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"iconAnnotation","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"descAnnotation","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}],"cardinality":"*"}]},"entry":false,"fragment":false,"parameters":[]}],"interfaces":[{"$type":"Interface","name":"TreeView","attributes":[{"$type":"TypeAttribute","name":"nodes","type":{"$type":"ArrayType","elementType":{"$type":"SimpleType","typeRef":{"$ref":"#/rules@14"}}},"isOptional":false},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"imports":[],"types":[],"$comment":"/**\\n * TreeView grammar for Langium\\n *\\n * Supports both quoted labels (\\"my file\\") and bare labels (index.js).\\n * Annotations (:::class, icon(), ## description) are parsed directly into\\n * AST fields by the grammar. Value conversion for stripping quotes, extracting\\n * class names, icon names, and description text happens in valueConverter.ts.\\n *\\n * The ML_COMMENT and NL hidden terminals handle whitespace, comments, and newlines\\n * before the treeView keyword, allowing for empty lines and comments before the\\n * treeView declaration.\\n */"}`)),"TreeViewGrammarGrammar"),Pg,hz=i(()=>Pg??(Pg=Ue(`{"$type":"Grammar","isDeclared":true,"name":"WardleyGrammar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Wardley","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@52"},"arguments":[],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@25"},"arguments":[]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@52"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@42"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"*"}]},"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"size","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Assignment","feature":"evolution","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Assignment","feature":"anchors","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"components","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"links","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Assignment","feature":"evolves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Assignment","feature":"pipelines","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Assignment","feature":"notes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Assignment","feature":"annotations","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}},{"$type":"Assignment","feature":"annotation","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Assignment","feature":"accelerators","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},{"$type":"Assignment","feature":"deaccelerators","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},"entry":false,"parameters":[]},{"$type":"ParserRule","name":"Size","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@26"},"arguments":[]},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"width","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"height","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Evolution","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@27"},"arguments":[]},{"$type":"Assignment","feature":"stages","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]},{"$type":"Assignment","feature":"stages","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}}],"cardinality":"+"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"EvolutionStage","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"@"},{"$type":"Assignment","feature":"boundary","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}}],"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"/"},{"$type":"Assignment","feature":"secondName","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}}],"cardinality":"?"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Anchor","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@28"},"arguments":[]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"visibility","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"evolution","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Component","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"visibility","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"evolution","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"decorator","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"inertia","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@31"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"inertia","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@31"},"arguments":[]}},{"$type":"Keyword","value":")"}]}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Label","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@30"},"arguments":[]},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"negX","operator":"?=","terminal":{"$type":"Keyword","value":"-"},"cardinality":"?"},{"$type":"Assignment","feature":"offsetX","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"negY","operator":"?=","terminal":{"$type":"Keyword","value":"-"},"cardinality":"?"},{"$type":"Assignment","feature":"offsetY","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Decorator","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"("},{"$type":"Assignment","feature":"strategy","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]}},{"$type":"Keyword","value":")"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Link","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"from","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Assignment","feature":"fromPort","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"arrow","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]},"cardinality":"?"},{"$type":"Assignment","feature":"to","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Assignment","feature":"toPort","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"linkLabel","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Evolve","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@32"},"arguments":[]},{"$type":"Assignment","feature":"component","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Assignment","feature":"target","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Pipeline","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@33"},"arguments":[]},{"$type":"Assignment","feature":"parent","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"{"},{"$type":"RuleCall","rule":{"$ref":"#/rules@52"},"arguments":[],"cardinality":"+"},{"$type":"Assignment","feature":"components","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]},"cardinality":"+"},{"$type":"Keyword","value":"}"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"PipelineComponent","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"evolution","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Note","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@34"},"arguments":[]},{"$type":"Assignment","feature":"text","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"visibility","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"evolution","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Annotations","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@35"},"arguments":[]},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"x","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"y","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Annotation","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@36"},"arguments":[]},{"$type":"Assignment","feature":"number","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"x","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"y","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"Assignment","feature":"text","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"CoordinateValue","dataType":"number","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@48"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Accelerator","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@37"},"arguments":[]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"x","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"y","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","name":"Deaccelerator","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@38"},"arguments":[]},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@50"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@51"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@39"},"arguments":[]}]}},{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"x","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"y","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Keyword","value":"]"},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"TerminalRule","name":"WARDLEY_NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"->"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"LINK_PORT","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"+<>"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"+>"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"+<"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"LINK_ARROW","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"-->"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"-.->"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":">"},"parenthesized":false}],"parenthesized":false},{"$type":"RegexToken","regex":"/\\\\+'[^']*'<>/","parenthesized":false}],"parenthesized":false},{"$type":"RegexToken","regex":"/\\\\+'[^']*'/","parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"LINK_LABEL","definition":{"$type":"RegexToken","regex":"/;[^\\\\n\\\\r]+/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRATEGY","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"build"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"buy"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"outsource"},"parenthesized":false}],"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"market"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_WARDLEY","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"wardley-beta"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_SIZE","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"size"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_EVOLUTION","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"evolution"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_ANCHOR","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"anchor"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_COMPONENT","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"component"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_LABEL","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"label"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_INERTIA","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"inertia"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_EVOLVE","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"evolve"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_PIPELINE","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"pipeline"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_NOTE","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"note"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_ANNOTATIONS","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"annotations"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_ANNOTATION","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"annotation"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_ACCELERATOR","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"accelerator"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"KW_DEACCELERATOR","definition":{"$type":"CharacterRange","left":{"$type":"Keyword","value":"deaccelerator"},"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NAME_WITH_SPACES","definition":{"$type":"RegexToken","regex":"/(?!title\\\\s|accTitle|accDescr)[A-Za-z](?:[A-Za-z0-9_()&]|-(?!>))*(?:[ \\\\t]+[A-Za-z(](?:[A-Za-z0-9_()&]|-(?!>))*)*/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WS","definition":{"$type":"RegexToken","regex":"/[ \\\\t]+/","parenthesized":false},"fragment":false},{"$type":"ParserRule","name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@52"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"entry":false,"fragment":false,"parameters":[]},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@44"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@45"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@46"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@41"},"arguments":[]}],"cardinality":"+"},"entry":false,"parameters":[]},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"},"parenthesized":false},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@47"},"parenthesized":false},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@48"},"parenthesized":false}],"parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/","parenthesized":false},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/","parenthesized":false},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/","parenthesized":false},"fragment":false}],"interfaces":[],"types":[]}`)),"WardleyGrammarGrammar"),yz={languageId:"architecture",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},gz={languageId:"cynefin",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},vz={languageId:"eventmodeling",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Tz={languageId:"gitGraph",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},$z={languageId:"info",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Rz={languageId:"packet",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Az={languageId:"pie",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Ez={languageId:"radar",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Cz={languageId:"railroadAbnf",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},_z={languageId:"railroadEbnf",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},bz={languageId:"railroad",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Sz={languageId:"railroadPeg",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},wz={languageId:"treemap",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Iz={languageId:"treeView",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},Nz={languageId:"wardley",fileExtensions:[".mmd",".mermaid"],caseInsensitive:!1,mode:"production"},ct={AstReflection:i(()=>new jw,"AstReflection")},Pz={Grammar:i(()=>tz(),"Grammar"),LanguageMetaData:i(()=>yz,"LanguageMetaData"),parser:{}},kz={Grammar:i(()=>rz(),"Grammar"),LanguageMetaData:i(()=>gz,"LanguageMetaData"),parser:{}},Oz={Grammar:i(()=>nz(),"Grammar"),LanguageMetaData:i(()=>vz,"LanguageMetaData"),parser:{}},Lz={Grammar:i(()=>az(),"Grammar"),LanguageMetaData:i(()=>Tz,"LanguageMetaData"),parser:{}},Dz={Grammar:i(()=>iz(),"Grammar"),LanguageMetaData:i(()=>$z,"LanguageMetaData"),parser:{}},xz={Grammar:i(()=>sz(),"Grammar"),LanguageMetaData:i(()=>Rz,"LanguageMetaData"),parser:{}},Mz={Grammar:i(()=>oz(),"Grammar"),LanguageMetaData:i(()=>Az,"LanguageMetaData"),parser:{}},Gz={Grammar:i(()=>lz(),"Grammar"),LanguageMetaData:i(()=>Ez,"LanguageMetaData"),parser:{}},Fz={Grammar:i(()=>uz(),"Grammar"),LanguageMetaData:i(()=>Cz,"LanguageMetaData"),parser:{}},zz={Grammar:i(()=>cz(),"Grammar"),LanguageMetaData:i(()=>_z,"LanguageMetaData"),parser:{}},jz={Grammar:i(()=>fz(),"Grammar"),LanguageMetaData:i(()=>bz,"LanguageMetaData"),parser:{}},Bz={Grammar:i(()=>dz(),"Grammar"),LanguageMetaData:i(()=>Sz,"LanguageMetaData"),parser:{}},Uz={Grammar:i(()=>pz(),"Grammar"),LanguageMetaData:i(()=>wz,"LanguageMetaData"),parser:{}},Kz={Grammar:i(()=>mz(),"Grammar"),LanguageMetaData:i(()=>Iz,"LanguageMetaData"),parser:{}},Wz={Grammar:i(()=>hz(),"Grammar"),LanguageMetaData:i(()=>Nz,"LanguageMetaData"),parser:{}},Vz=/accDescr(?:[\t ]*:([^\n\r]*)|\s*{([^}]*)})/,qz=/accTitle[\t ]*:([^\n\r]*)/,Hz=/title([\t ][^\n\r]*|)/,Yz={ACC_DESCR:Vz,ACC_TITLE:qz,TITLE:Hz},ur=class extends zm{static{i(this,"AbstractMermaidValueConverter")}runConverter(e,t,r){let n=this.runCommonConverter(e,t,r);return n===void 0&&(n=this.runCustomConverter(e,t,r)),n===void 0?super.runConverter(e,t,r):n}runCommonConverter(e,t,r){const n=Yz[e.name];if(n===void 0)return;const a=n.exec(t);if(a!==null){if(a[1]!==void 0)return a[1].trim().replace(/[\t ]{2,}/gm," ");if(a[2]!==void 0)return a[2].replace(/^\s*/gm,"").replace(/\s+$/gm,"").replace(/[\t ]{2,}/gm," ").replace(/[\n\r]{2,}/gm,` +`)}}},ci=class extends ur{static{i(this,"CommonValueConverter")}runCustomConverter(e,t,r){}},ft=class extends Du{static{i(this,"AbstractMermaidTokenBuilder")}constructor(e){super(),this.keywords=new Set(e)}buildKeywordTokens(e,t,r){const n=super.buildKeywordTokens(e,t,r);return n.forEach(a=>{this.keywords.has(a.name)&&a.PATTERN!==void 0&&(a.PATTERN=new RegExp(a.PATTERN.toString()+"(?:(?=%%)|(?!\\S))"))}),n}};(class extends ft{static{i(this,"CommonTokenBuilder")}});/*! Bundled license information: + +lodash-es/lodash.js: + (** + * @license + * Lodash (Custom Build) + * Build: `lodash modularize exports="es" -o ./` + * Copyright OpenJS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + *) +*/var Xz=class extends ft{static{i(this,"RadarTokenBuilder")}constructor(){super(["radar-beta"])}},Bw={parser:{TokenBuilder:i(()=>new Xz,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")}};function Uw(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Gz,Bw);return t.ServiceRegistry.register(r),{shared:t,Radar:r}}i(Uw,"createRadarServices");var Jz=class extends ft{static{i(this,"RailroadTokenBuilder")}constructor(){super(["railroad-beta"])}},kg=i(e=>{const t=e.slice(1,-1);let r="";for(let n=0;nnew Jz,"TokenBuilder"),ValueConverter:i(()=>new Zz,"ValueConverter")}};function Ww(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),jz,Kw);return t.ServiceRegistry.register(r),{shared:t,Railroad:r}}i(Ww,"createRailroadServices");var Qz=class extends ft{static{i(this,"RailroadEbnfTokenBuilder")}constructor(){super(["railroad-ebnf-beta"])}},Og=i(e=>{const t=e.slice(1,-1);let r="";for(let n=0;nnew Qz,"TokenBuilder"),ValueConverter:i(()=>new ej,"ValueConverter")}};function qw(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),zz,Vw);return t.ServiceRegistry.register(r),{shared:t,RailroadEbnf:r}}i(qw,"createRailroadEbnfServices");var tj=class extends ft{static{i(this,"RailroadAbnfTokenBuilder")}constructor(){super(["railroad-abnf-beta"])}},rj=class extends ur{static{i(this,"RailroadAbnfValueConverter")}runConverter(e,t,r){const n=super.runConverter(e,t,r);if(e.name==="TITLE"&&typeof n=="string"){const a=n.trim();if(a.startsWith('"')&&a.endsWith('"')||a.startsWith("'")&&a.endsWith("'"))return a.slice(1,-1)}return n}runCustomConverter(e,t,r){if(e.name==="ABNF_STRING")return t.slice(1,-1)}},Hw={parser:{TokenBuilder:i(()=>new tj,"TokenBuilder"),ValueConverter:i(()=>new rj,"ValueConverter")}};function Yw(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Fz,Hw);return t.ServiceRegistry.register(r),{shared:t,RailroadAbnf:r}}i(Yw,"createRailroadAbnfServices");var nj=class extends ft{static{i(this,"RailroadPegTokenBuilder")}constructor(){super(["railroad-peg-beta"])}},Lg=i(e=>{const t=e.slice(1,-1);let r="";for(let n=0;nnew nj,"TokenBuilder"),ValueConverter:i(()=>new aj,"ValueConverter")}};function Jw(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Bz,Xw);return t.ServiceRegistry.register(r),{shared:t,RailroadPeg:r}}i(Jw,"createRailroadPegServices");var ij=class extends ft{static{i(this,"TreemapTokenBuilder")}constructor(){super(["treemap"])}},sj=/classDef\s+([A-Z_a-z]\w+)(?:\s+([^\n\r;]*))?;?/,oj=class extends ur{static{i(this,"TreemapValueConverter")}runCustomConverter(e,t,r){if(e.name==="NUMBER2")return parseFloat(t.replace(/,/g,""));if(e.name==="SEPARATOR")return t.substring(1,t.length-1);if(e.name==="STRING2")return t.substring(1,t.length-1);if(e.name==="INDENTATION")return t.length;if(e.name==="ClassDef"){if(typeof t!="string")return t;const n=sj.exec(t);if(n)return{$type:"ClassDefStatement",className:n[1],styleText:n[2]||void 0}}}};function Zw(e){const t=e.validation.TreemapValidator,r=e.validation.ValidationRegistry;if(r){const n={Treemap:t.checkSingleRoot.bind(t)};r.register(n,t)}}i(Zw,"registerValidationChecks");var lj=class{static{i(this,"TreemapValidator")}checkSingleRoot(e,t){let r;for(const n of e.TreemapRows)n.item&&(r===void 0&&n.indent===void 0?r=0:n.indent===void 0?t("error","Multiple root nodes are not allowed in a treemap.",{node:n,property:"item"}):r!==void 0&&r>=parseInt(n.indent,10)&&t("error","Multiple root nodes are not allowed in a treemap.",{node:n,property:"item"}))}},Qw={parser:{TokenBuilder:i(()=>new ij,"TokenBuilder"),ValueConverter:i(()=>new oj,"ValueConverter")},validation:{TreemapValidator:i(()=>new lj,"TreemapValidator")}};function eI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Uz,Qw);return t.ServiceRegistry.register(r),Zw(r),{shared:t,Treemap:r}}i(eI,"createTreemapServices");var uj=class extends ur{static{i(this,"WardleyValueConverter")}runCustomConverter(e,t,r){if(e.name.toUpperCase()==="LINK_LABEL")return t.substring(1).trim()}},tI={parser:{ValueConverter:i(()=>new uj,"ValueConverter")}};function rI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Wz,tI);return t.ServiceRegistry.register(r),{shared:t,Wardley:r}}i(rI,"createWardleyServices");var cj=class extends ft{static{i(this,"CynefinTokenBuilder")}constructor(){super(["cynefin-beta"])}},nI={parser:{TokenBuilder:i(()=>new cj,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")}};function aI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),kz,nI);return t.ServiceRegistry.register(r),{shared:t,Cynefin:r}}i(aI,"createCynefinServices");var fj=class extends ft{static{i(this,"GitGraphTokenBuilder")}constructor(){super(["gitGraph"])}},iI={parser:{TokenBuilder:i(()=>new fj,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")}};function sI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Lz,iI);return t.ServiceRegistry.register(r),{shared:t,GitGraph:r}}i(sI,"createGitGraphServices");var dj=class extends ft{static{i(this,"InfoTokenBuilder")}constructor(){super(["info","showInfo"])}},oI={parser:{TokenBuilder:i(()=>new dj,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")}};function lI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Dz,oI);return t.ServiceRegistry.register(r),{shared:t,Info:r}}i(lI,"createInfoServices");var pj=class extends ft{static{i(this,"PacketTokenBuilder")}constructor(){super(["packet"])}},uI={parser:{TokenBuilder:i(()=>new pj,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")}};function cI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),xz,uI);return t.ServiceRegistry.register(r),{shared:t,Packet:r}}i(cI,"createPacketServices");var mj=class extends ft{static{i(this,"PieTokenBuilder")}constructor(){super(["pie","showData"])}},hj=class extends ur{static{i(this,"PieValueConverter")}runCustomConverter(e,t,r){if(e.name==="PIE_SECTION_LABEL")return t.replace(/"/g,"").trim()}},fI={parser:{TokenBuilder:i(()=>new mj,"TokenBuilder"),ValueConverter:i(()=>new hj,"ValueConverter")}};function dI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Mz,fI);return t.ServiceRegistry.register(r),{shared:t,Pie:r}}i(dI,"createPieServices");var yj=class extends ur{static{i(this,"TreeViewValueConverter")}runCustomConverter(e,t,r){if(e.name==="INDENTATION")return t?.length||0;if(e.name==="QUOTED_NAME")return t.substring(1,t.length-1);if(e.name==="BARE_NAME")return t.replace(/[\t ]+$/,"");if(e.name==="CLASS_ANNOTATION")return t.trim().substring(3).trim();if(e.name==="ICON_ANNOTATION"){const n=t.trim();return n.substring(5,n.length-1)}if(e.name==="DESC_ANNOTATION")return t.trim().substring(2).trim()}},gj=class extends ft{static{i(this,"TreeViewTokenBuilder")}constructor(){super(["treeView-beta"])}},pI={parser:{TokenBuilder:i(()=>new gj,"TokenBuilder"),ValueConverter:i(()=>new yj,"ValueConverter")}};function mI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Kz,pI);return t.ServiceRegistry.register(r),{shared:t,TreeView:r}}i(mI,"createTreeViewServices");var vj=class extends ft{static{i(this,"ArchitectureTokenBuilder")}constructor(){super(["architecture"])}},Tj=class extends ur{static{i(this,"ArchitectureValueConverter")}runCustomConverter(e,t,r){if(e.name==="ARCH_ICON")return t.replace(/[()]/g,"").trim();if(e.name==="ARCH_TEXT_ICON")return t.replace(/["()]/g,"");if(e.name==="ARCH_TITLE"){let n=t.replace(/^\[|]$/g,"").trim();return(n.startsWith('"')&&n.endsWith('"')||n.startsWith("'")&&n.endsWith("'"))&&(n=n.slice(1,-1),n=n.replace(/\\"/g,'"').replace(/\\'/g,"'")),n.trim()}}},hI={parser:{TokenBuilder:i(()=>new vj,"TokenBuilder"),ValueConverter:i(()=>new Tj,"ValueConverter")}};function yI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Pz,hI);return t.ServiceRegistry.register(r),{shared:t,Architecture:r}}i(yI,"createArchitectureServices");var $j=class extends ft{static{i(this,"EventModelingTokenBuilder")}constructor(){super(["eventmodeling"])}},Dg=new Set(["cmd","command"]),xg=new Set(["evt","event"]),$c=new Set(["rmo","readmodel"]),Mg=new Set(["pcr","processor"]),Gg=new Set(["ui"]);function gI(e){const t=e.validation.EventModelingValidator,r=e.validation.ValidationRegistry;if(r){const n={EmTimeFrame:t.checkSourceFrameTypes.bind(t),EmResetFrame:t.checkSourceFrameTypes.bind(t)};r.register(n,t)}}i(gI,"registerValidationChecks");var Rj=class{static{i(this,"EventModelingValidator")}checkSourceFrameTypes(e,t){e.sourceFrames.length!==0&&(Dg.has(e.modelEntityType)?this.validateSources(e,new Set([...Gg,...Mg]),"command","ui or processor",t):xg.has(e.modelEntityType)?this.validateSources(e,Dg,"event","command",t):$c.has(e.modelEntityType)?this.validateSources(e,xg,"read model","event",t):Mg.has(e.modelEntityType)?this.validateSources(e,$c,"processor","read model",t):Gg.has(e.modelEntityType)&&this.validateSources(e,$c,"ui","read model",t))}validateSources(e,t,r,n,a){for(const s of e.sourceFrames){const o=s.ref;o!==void 0&&!t.has(o.modelEntityType)&&a("error",`A ${r} can only receive input from a ${n}, not from '${o.modelEntityType}'.`,{node:e,property:"sourceFrames"})}}},vI={parser:{TokenBuilder:i(()=>new $j,"TokenBuilder"),ValueConverter:i(()=>new ci,"ValueConverter")},validation:{EventModelingValidator:i(()=>new Rj,"EventModelingValidator")}};function TI(e=Xe){const t=ee(Be(e),ct),r=ee(je({shared:t}),Oz,vI);return t.ServiceRegistry.register(r),gI(r),{shared:t,EventModel:r}}i(TI,"createEventModelingServices");var Ve={},Aj={info:i(async()=>{const{createInfoServices:e}=await et(async()=>{const{createInfoServices:r}=await Promise.resolve().then(()=>_j);return{createInfoServices:r}},void 0),t=e().Info.parser.LangiumParser;Ve.info=t},"info"),packet:i(async()=>{const{createPacketServices:e}=await et(async()=>{const{createPacketServices:r}=await Promise.resolve().then(()=>bj);return{createPacketServices:r}},void 0),t=e().Packet.parser.LangiumParser;Ve.packet=t},"packet"),pie:i(async()=>{const{createPieServices:e}=await et(async()=>{const{createPieServices:r}=await Promise.resolve().then(()=>Sj);return{createPieServices:r}},void 0),t=e().Pie.parser.LangiumParser;Ve.pie=t},"pie"),treeView:i(async()=>{const{createTreeViewServices:e}=await et(async()=>{const{createTreeViewServices:r}=await Promise.resolve().then(()=>wj);return{createTreeViewServices:r}},void 0),t=e().TreeView.parser.LangiumParser;Ve.treeView=t},"treeView"),architecture:i(async()=>{const{createArchitectureServices:e}=await et(async()=>{const{createArchitectureServices:r}=await Promise.resolve().then(()=>Ij);return{createArchitectureServices:r}},void 0),t=e().Architecture.parser.LangiumParser;Ve.architecture=t},"architecture"),gitGraph:i(async()=>{const{createGitGraphServices:e}=await et(async()=>{const{createGitGraphServices:r}=await Promise.resolve().then(()=>Nj);return{createGitGraphServices:r}},void 0),t=e().GitGraph.parser.LangiumParser;Ve.gitGraph=t},"gitGraph"),eventmodeling:i(async()=>{const{createEventModelingServices:e}=await et(async()=>{const{createEventModelingServices:r}=await Promise.resolve().then(()=>Pj);return{createEventModelingServices:r}},void 0),t=e().EventModel.parser.LangiumParser;Ve.eventmodeling=t},"eventmodeling"),radar:i(async()=>{const{createRadarServices:e}=await et(async()=>{const{createRadarServices:r}=await Promise.resolve().then(()=>kj);return{createRadarServices:r}},void 0),t=e().Radar.parser.LangiumParser;Ve.radar=t},"radar"),railroad:i(async()=>{const{createRailroadServices:e}=await et(async()=>{const{createRailroadServices:r}=await Promise.resolve().then(()=>Oj);return{createRailroadServices:r}},void 0),t=e().Railroad.parser.LangiumParser;Ve.railroad=t},"railroad"),railroadEbnf:i(async()=>{const{createRailroadEbnfServices:e}=await et(async()=>{const{createRailroadEbnfServices:r}=await Promise.resolve().then(()=>Lj);return{createRailroadEbnfServices:r}},void 0),t=e().RailroadEbnf.parser.LangiumParser;Ve.railroadEbnf=t},"railroadEbnf"),railroadAbnf:i(async()=>{const{createRailroadAbnfServices:e}=await et(async()=>{const{createRailroadAbnfServices:r}=await Promise.resolve().then(()=>Dj);return{createRailroadAbnfServices:r}},void 0),t=e().RailroadAbnf.parser.LangiumParser;Ve.railroadAbnf=t},"railroadAbnf"),railroadPeg:i(async()=>{const{createRailroadPegServices:e}=await et(async()=>{const{createRailroadPegServices:r}=await Promise.resolve().then(()=>xj);return{createRailroadPegServices:r}},void 0),t=e().RailroadPeg.parser.LangiumParser;Ve.railroadPeg=t},"railroadPeg"),treemap:i(async()=>{const{createTreemapServices:e}=await et(async()=>{const{createTreemapServices:r}=await Promise.resolve().then(()=>Mj);return{createTreemapServices:r}},void 0),t=e().Treemap.parser.LangiumParser;Ve.treemap=t},"treemap"),wardley:i(async()=>{const{createWardleyServices:e}=await et(async()=>{const{createWardleyServices:r}=await Promise.resolve().then(()=>Gj);return{createWardleyServices:r}},void 0),t=e().Wardley.parser.LangiumParser;Ve.wardley=t},"wardley"),cynefin:i(async()=>{const{createCynefinServices:e}=await et(async()=>{const{createCynefinServices:r}=await Promise.resolve().then(()=>Fj);return{createCynefinServices:r}},void 0),t=e().Cynefin.parser.LangiumParser;Ve.cynefin=t},"cynefin")};async function Ej(e,t){const r=Aj[e];if(!r)throw new Error(`Unknown diagram type: ${e}`);Ve[e]||await r();const a=Ve[e].parse(t);if(a.lexerErrors.length>0||a.parserErrors.length>0)throw new Cj(a);return a.value}i(Ej,"parse");var Cj=class extends Error{constructor(e){const t=e.lexerErrors.map(n=>{const a=n.line!==void 0&&!isNaN(n.line)?n.line:"?",s=n.column!==void 0&&!isNaN(n.column)?n.column:"?";return`Lexer error on line ${a}, column ${s}: ${n.message}`}).join(` +`),r=e.parserErrors.map(n=>{const a=n.token.startLine!==void 0&&!isNaN(n.token.startLine)?n.token.startLine:"?",s=n.token.startColumn!==void 0&&!isNaN(n.token.startColumn)?n.token.startColumn:"?";return`Parse error on line ${a}, column ${s}: ${n.message}`}).join(` +`);super(`Parsing failed: ${t} ${r}`),this.result=e}static{i(this,"MermaidParseError")}};const _j=Object.freeze(Object.defineProperty({__proto__:null,InfoModule:oI,createInfoServices:lI},Symbol.toStringTag,{value:"Module"})),bj=Object.freeze(Object.defineProperty({__proto__:null,PacketModule:uI,createPacketServices:cI},Symbol.toStringTag,{value:"Module"})),Sj=Object.freeze(Object.defineProperty({__proto__:null,PieModule:fI,createPieServices:dI},Symbol.toStringTag,{value:"Module"})),wj=Object.freeze(Object.defineProperty({__proto__:null,TreeViewModule:pI,createTreeViewServices:mI},Symbol.toStringTag,{value:"Module"})),Ij=Object.freeze(Object.defineProperty({__proto__:null,ArchitectureModule:hI,createArchitectureServices:yI},Symbol.toStringTag,{value:"Module"})),Nj=Object.freeze(Object.defineProperty({__proto__:null,GitGraphModule:iI,createGitGraphServices:sI},Symbol.toStringTag,{value:"Module"})),Pj=Object.freeze(Object.defineProperty({__proto__:null,EventModelingModule:vI,createEventModelingServices:TI},Symbol.toStringTag,{value:"Module"})),kj=Object.freeze(Object.defineProperty({__proto__:null,RadarModule:Bw,createRadarServices:Uw},Symbol.toStringTag,{value:"Module"})),Oj=Object.freeze(Object.defineProperty({__proto__:null,RailroadModule:Kw,createRailroadServices:Ww},Symbol.toStringTag,{value:"Module"})),Lj=Object.freeze(Object.defineProperty({__proto__:null,RailroadEbnfModule:Vw,createRailroadEbnfServices:qw},Symbol.toStringTag,{value:"Module"})),Dj=Object.freeze(Object.defineProperty({__proto__:null,RailroadAbnfModule:Hw,createRailroadAbnfServices:Yw},Symbol.toStringTag,{value:"Module"})),xj=Object.freeze(Object.defineProperty({__proto__:null,RailroadPegModule:Xw,createRailroadPegServices:Jw},Symbol.toStringTag,{value:"Module"})),Mj=Object.freeze(Object.defineProperty({__proto__:null,TreemapModule:Qw,createTreemapServices:eI},Symbol.toStringTag,{value:"Module"})),Gj=Object.freeze(Object.defineProperty({__proto__:null,WardleyModule:tI,createWardleyServices:rI},Symbol.toStringTag,{value:"Module"})),Fj=Object.freeze(Object.defineProperty({__proto__:null,CynefinModule:nI,createCynefinServices:aI},Symbol.toStringTag,{value:"Module"}));export{Cj as M,qw as a,Yw as b,Ww as c,Jw as d,zF as i,Ej as p}; diff --git a/packages/tempo/public/v4/assets/chunks/cynefinDiagram-5FMLGOSQ.Ebp3fBAZ.js b/packages/tempo/public/v4/assets/chunks/cynefinDiagram-5FMLGOSQ.Ebp3fBAZ.js new file mode 100644 index 00000000..0765f44e --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/cynefinDiagram-5FMLGOSQ.Ebp3fBAZ.js @@ -0,0 +1,62 @@ +import{p as xt}from"./chunk-JWPE2WC7.5yopTNlD.js";import{s as gt,g as $t,q as bt,p as wt,a as Ct,b as vt,_ as s,l as Y,G as Dt,d as kt,r as At,D as U,A as Q,E as Tt,X as ot}from"../app.CbekdYod.js";import{p as Bt}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var rt=s(()=>({domains:new Map,transitions:[]}),"createDefaultData"),G=rt(),St=s(()=>G.domains,"getDomains"),Mt=s(()=>G.transitions,"getTransitions"),zt=s(t=>{if(t)for(const e of t){const n=e.domain,a=(e.items??[]).map(c=>({label:c.label}));G.domains.set(n,{name:n,items:a})}},"setDomains"),Lt=s(t=>{t&&(G.transitions=t.filter(e=>e.from===e.to?(Y.warn(`Cynefin: self-loop transition on domain "${e.from}" is not meaningful and will be skipped.`),!1):!0).map(e=>({from:e.from,to:e.to,label:e.label||void 0})))},"setTransitions"),Nt=s(()=>U({...Tt.cynefin,...Q().cynefin}),"getConfig"),Pt=s(()=>{At(),G=rt()},"clear"),X={getDomains:St,getTransitions:Mt,setDomains:zt,setTransitions:Lt,getConfig:Nt,clear:Pt,setAccTitle:vt,getAccTitle:Ct,setDiagramTitle:wt,getDiagramTitle:bt,getAccDescription:$t,setAccDescription:gt},It=s(t=>{xt(t,X),X.setDomains(t.domains),X.setTransitions(t.transitions)},"populate"),Wt={parse:s(async t=>{const e=await Bt("cynefin",t);Y.debug(e),It(e)},"parse")};function V(t){let e=t+1831565813|0;return e=Math.imul(e^e>>>15,e|1),e^=e+Math.imul(e^e>>>7,e|61),((e^e>>>14)>>>0)/4294967296}s(V,"seededRandom");function st(t){let e=0;for(let n=0;n{const n=t/2,a=e/2;return{complex:{cx:n/2,cy:a/2,x:0,y:0,w:n,h:a},complicated:{cx:n+n/2,cy:a/2,x:n,y:0,w:n,h:a},chaotic:{cx:n/2,cy:a+a/2,x:0,y:a,w:n,h:a},clear:{cx:n+n/2,cy:a+a/2,x:n,y:a,w:n,h:a},confusion:{cx:n,cy:a,x:n*.7,y:a*.7,w:n*.6,h:a*.6}}},"getDomainLayouts"),_t=s(()=>{const t=ot(),e=Q();return U(t,e.themeVariables).cynefin},"getCynefinDomainColors"),q=3,Et=s((t,e,n,a)=>{const c=a.db,m=c.getDomains(),v=c.getTransitions(),W=c.getDiagramTitle(),d=c.getAccTitle(),D=c.getAccDescription(),o=c.getConfig(),p=_t();Y.debug("Rendering Cynefin diagram");const i=o.width,f=o.height,b=o.padding,h=o.showDomainDescriptions,R=o.boundaryAmplitude,_=i+b*2,E=f+b*2,z={complex:p.complexBg,complicated:p.complicatedBg,clear:p.clearBg,chaotic:p.chaoticBg,confusion:p.confusionBg},k=Dt(e);kt(k,E,_,o.useMaxWidth??!0),k.attr("viewBox",`0 0 ${_} ${E}`),d&&k.append("title").text(d),D&&k.append("desc").text(D);const A=k.append("g").attr("transform",`translate(${b}, ${b})`),F=Rt(i,f),Z=it(o.seed,e),mt=A.append("g").attr("class","cynefin-backgrounds"),O=["complex","complicated","chaotic","clear"];for(const l of O){const r=F[l];mt.append("rect").attr("class","cynefinDomain").attr("x",r.x).attr("y",r.y).attr("width",r.w).attr("height",r.h).attr("fill",z[l]).attr("fill-opacity",.4).attr("stroke","none")}const j=A.append("g").attr("class","cynefin-boundaries");j.append("path").attr("class","cynefinBoundary").attr("d",ct(i,f,Z,R)).attr("fill","none"),j.append("path").attr("class","cynefinBoundary").attr("d",lt(i,f,Z+100,R)).attr("fill","none"),j.append("path").attr("class","cynefinCliff").attr("d",dt(i,f)).attr("fill","none");const pt=i*.15,yt=f*.15;A.append("path").attr("class","cynefinConfusion").attr("d",ft(i/2,f/2,pt,yt)).attr("fill",z.confusion).attr("fill-opacity",.5);const J=A.append("g").attr("class","cynefin-labels");for(const l of O){const r=F[l];J.append("text").attr("class","cynefinDomainLabel").attr("x",r.cx).attr("y",h?r.cy-30:r.cy).attr("text-anchor","middle").attr("dominant-baseline","middle").text(l.charAt(0).toUpperCase()+l.slice(1))}if(J.append("text").attr("class","cynefinDomainLabel").attr("x",i/2).attr("y",h?f/2-10:f/2).attr("text-anchor","middle").attr("dominant-baseline","middle").text("Confusion"),h){const l=A.append("g").attr("class","cynefin-subtitles");for(const r of O){const u=F[r],y=at[r];l.append("text").attr("class","cynefinSubtitle").attr("x",u.cx).attr("y",u.cy-10).attr("text-anchor","middle").attr("dominant-baseline","middle").text(y.model),l.append("text").attr("class","cynefinSubtitle").attr("x",u.cx).attr("y",u.cy+5).attr("text-anchor","middle").attr("dominant-baseline","middle").text(y.practice)}l.append("text").attr("class","cynefinSubtitle").attr("x",i/2).attr("y",f/2+8).attr("text-anchor","middle").attr("dominant-baseline","middle").text(at.confusion.practice)}const K=A.append("g").attr("class","cynefin-items"),T=26,tt=10,ut=["complex","complicated","chaotic","clear","confusion"];for(const l of ut){const r=m.get(l);if(!r||r.items.length===0)continue;const u=F[l],y=l==="confusion";let L=r.items,N=0;y&&r.items.length>q&&(N=r.items.length-q,L=r.items.slice(0,q));let B;if(y){const g=h?22:14;B=u.cy+g}else B=u.cy+(h?25:15);if([...L].forEach((g,S)=>{const w=B+S*(T+4),M=K.append("g"),P=M.append("text").attr("class","cynefinItemText").attr("x",0).attr("y",T/2).attr("text-anchor","middle").attr("dominant-baseline","central").text(g.label);let $=g.label.length*7;const x=P.node();if(x&&typeof x.getBBox=="function"){const H=x.getBBox();H.width>0&&($=H.width)}const C=$+tt*2,I=u.cx-C/2;M.attr("transform",`translate(${I}, ${w})`),M.insert("rect","text").attr("class","cynefinItem").attr("x",0).attr("y",0).attr("width",C).attr("height",T).attr("rx",4).attr("ry",4).attr("fill",z[l]).attr("fill-opacity",.95),P.attr("x",C/2).attr("y",T/2)}),N>0){const g=B+L.length*(T+4),S=`+${N} more`,w=K.append("g"),M=w.append("text").attr("class","cynefinItemText").attr("x",0).attr("y",T/2).attr("text-anchor","middle").attr("dominant-baseline","central").text(S);let P=S.length*7;const $=M.node();if($&&typeof $.getBBox=="function"){const I=$.getBBox();I.width>0&&(P=I.width)}const x=P+tt*2,C=u.cx-x/2;w.attr("transform",`translate(${C}, ${g})`),w.insert("rect","text").attr("class","cynefinItemOverflow").attr("x",0).attr("y",0).attr("width",x).attr("height",T).attr("rx",4).attr("ry",4).attr("fill",z[l]).attr("fill-opacity",.6),M.attr("x",x/2).attr("y",T/2)}}if(v.length>0){const l=k.select("defs").empty()?k.append("defs"):k.select("defs"),r=`cynefin-arrow-${e}`;l.append("marker").attr("id",r).attr("viewBox","0 0 10 10").attr("refX",9).attr("refY",5).attr("markerWidth",6).attr("markerHeight",6).attr("orient","auto-start-reverse").append("path").attr("d","M 0 0 L 10 5 L 0 10 z").attr("class","cynefinArrowHead");const u=A.append("g").attr("class","cynefin-arrows");v.forEach(y=>{const L=F[y.from],N=F[y.to];if(!L||!N)return;if(y.from===y.to){Y.warn(`Cynefin renderer: skipping self-loop on domain "${y.from}"`);return}const B=L.cx,g=L.cy,S=N.cx,w=N.cy,M=(B+S)/2,P=(g+w)/2,$=S-B,x=w-g,C=Math.sqrt($*$+x*x),I=C*.15,H=-x/C,ht=$/C,et=M+H*I,nt=P+ht*I;u.append("path").attr("class","cynefinArrowLine").attr("d",`M${B},${g} Q${et},${nt} ${S},${w}`).attr("fill","none").attr("marker-end",`url(#${r})`),y.label&&u.append("text").attr("class","cynefinArrowLabel").attr("x",et).attr("y",nt-6).attr("text-anchor","middle").attr("dominant-baseline","auto").text(y.label)})}W&&A.append("text").attr("class","cynefinTitle").attr("x",i/2).attr("y",-b/2).attr("text-anchor","middle").attr("dominant-baseline","middle").text(W)},"draw"),Ft={draw:Et},Vt=s(()=>{const t=ot(),e=Q();return U(t,e.themeVariables).cynefin},"getCynefinTheme"),Gt=s(()=>{const t=Vt();return` + .cynefinDomain { + stroke: none; + } + .cynefinDomainLabel { + font-size: ${t.domainFontSize}px; + font-weight: bold; + fill: ${t.labelColor}; + } + .cynefinSubtitle { + font-size: ${t.itemFontSize-1}px; + fill: ${t.textColor}; + font-style: italic; + } + .cynefinItem { + fill-opacity: 0.95; + stroke: ${t.boundaryColor}; + stroke-width: 1; + } + .cynefinItemText { + font-size: ${t.itemFontSize}px; + fill: ${t.textColor}; + } + .cynefinItemOverflow { + fill-opacity: 0.6; + stroke: ${t.boundaryColor}; + stroke-width: 1; + stroke-dasharray: 3 2; + } + .cynefinBoundary { + stroke: ${t.boundaryColor}; + stroke-width: ${t.boundaryWidth}; + stroke-dasharray: 6 3; + } + .cynefinCliff { + stroke: ${t.cliffColor}; + stroke-width: ${t.cliffWidth}; + } + .cynefinConfusion { + stroke: ${t.boundaryColor}; + stroke-width: 1.5; + stroke-dasharray: 4 2; + } + .cynefinArrowLine { + stroke: ${t.arrowColor}; + stroke-width: ${t.arrowWidth}; + fill: none; + } + .cynefinArrowHead { + fill: ${t.arrowColor}; + stroke: none; + } + .cynefinArrowLabel { + font-size: ${t.itemFontSize-1}px; + fill: ${t.textColor}; + } + .cynefinTitle { + font-size: ${t.domainFontSize+2}px; + font-weight: bold; + fill: ${t.labelColor}; + } + `},"styles"),Ht=Gt,Ut={parser:Wt,db:X,renderer:Ft,styles:Ht};export{Ut as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/cytoscape.esm.DdbNXSXN.js b/packages/tempo/public/v4/assets/chunks/cytoscape.esm.DdbNXSXN.js new file mode 100644 index 00000000..45f8083e --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/cytoscape.esm.DdbNXSXN.js @@ -0,0 +1,331 @@ +function Ds(r,e){(e==null||e>r.length)&&(e=r.length);for(var t=0,a=Array(e);t=r.length?{done:!0}:{done:!1,value:r[a++]}},e:function(u){throw u},f:n}}throw new TypeError(`Invalid attempt to iterate non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var i,s=!0,o=!1;return{s:function(){t=t.call(r)},n:function(){var u=t.next();return s=u.done,u},e:function(u){o=!0,i=u},f:function(){try{s||t.return==null||t.return()}finally{if(o)throw i}}}}function Ql(r,e,t){return(e=Jl(e))in r?Object.defineProperty(r,e,{value:t,enumerable:!0,configurable:!0,writable:!0}):r[e]=t,r}function ic(r){if(typeof Symbol<"u"&&r[Symbol.iterator]!=null||r["@@iterator"]!=null)return Array.from(r)}function sc(r,e){var t=r==null?null:typeof Symbol<"u"&&r[Symbol.iterator]||r["@@iterator"];if(t!=null){var a,n,i,s,o=[],u=!0,l=!1;try{if(i=(t=t.call(r)).next,e===0){if(Object(t)!==t)return;u=!1}else for(;!(u=(a=i.call(t)).done)&&(o.push(a.value),o.length!==e);u=!0);}catch(v){l=!0,n=v}finally{try{if(!u&&t.return!=null&&(s=t.return(),Object(s)!==s))return}finally{if(l)throw n}}return o}}function oc(){throw new TypeError(`Invalid attempt to destructure non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function uc(){throw new TypeError(`Invalid attempt to spread non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Xe(r,e){return tc(r)||sc(r,e)||Ks(r,e)||oc()}function yn(r){return ac(r)||ic(r)||Ks(r)||uc()}function lc(r,e){if(typeof r!="object"||!r)return r;var t=r[Symbol.toPrimitive];if(t!==void 0){var a=t.call(r,e);if(typeof a!="object")return a;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(r)}function Jl(r){var e=lc(r,"string");return typeof e=="symbol"?e:e+""}function je(r){"@babel/helpers - typeof";return je=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(e){return typeof e}:function(e){return e&&typeof Symbol=="function"&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},je(r)}function Ks(r,e){if(r){if(typeof r=="string")return Ds(r,e);var t={}.toString.call(r).slice(8,-1);return t==="Object"&&r.constructor&&(t=r.constructor.name),t==="Map"||t==="Set"?Array.from(r):t==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?Ds(r,e):void 0}}var Qe=typeof window>"u"?null:window,Co=Qe?Qe.navigator:null;Qe&&Qe.document;var vc=je(""),jl=je({}),fc=je(function(){}),cc=typeof HTMLElement>"u"?"undefined":je(HTMLElement),La=function(e){return e&&e.instanceString&&He(e.instanceString)?e.instanceString():null},he=function(e){return e!=null&&je(e)==vc},He=function(e){return e!=null&&je(e)===fc},Fe=function(e){return!Tr(e)&&(Array.isArray?Array.isArray(e):e!=null&&e instanceof Array)},Me=function(e){return e!=null&&je(e)===jl&&!Fe(e)&&e.constructor===Object},dc=function(e){return e!=null&&je(e)===jl},ae=function(e){return e!=null&&je(e)===je(1)&&!isNaN(e)},ev=function(e){return ae(e)&&Math.floor(e)===e},mn=function(e){if(cc!=="undefined")return e!=null&&e instanceof HTMLElement},Tr=function(e){return Ia(e)||rv(e)},Ia=function(e){return La(e)==="collection"&&e._private.single},rv=function(e){return La(e)==="collection"&&!e._private.single},Xs=function(e){return La(e)==="core"},tv=function(e){return La(e)==="stylesheet"},hc=function(e){return La(e)==="event"},st=function(e){return e==null?!0:!!(e===""||e.match(/^\s+$/))},gc=function(e){return typeof HTMLElement>"u"?!1:e instanceof HTMLElement},pc=function(e){return Me(e)&&ae(e.x1)&&ae(e.x2)&&ae(e.y1)&&ae(e.y2)},yc=function(e){return dc(e)&&He(e.then)},mc=function(){return Co&&Co.userAgent.match(/msie|trident|edge/i)},Yt=function(e,t){t||(t=function(){if(arguments.length===1)return arguments[0];if(arguments.length===0)return"undefined";for(var i=[],s=0;st?1:0},Sc=function(e,t){return-1*nv(e,t)},me=Object.assign!=null?Object.assign.bind(Object):function(r){for(var e=arguments,t=1;t1&&(g-=1),g<1/6?d+(y-d)*6*g:g<1/2?y:g<2/3?d+(y-d)*(2/3-g)*6:d}var f=new RegExp("^"+xc+"$").exec(e);if(f){if(a=parseInt(f[1]),a<0?a=(360- -1*a%360)%360:a>360&&(a=a%360),a/=360,n=parseFloat(f[2]),n<0||n>100||(n=n/100,i=parseFloat(f[3]),i<0||i>100)||(i=i/100,s=f[4],s!==void 0&&(s=parseFloat(s),s<0||s>1)))return;if(n===0)o=u=l=Math.round(i*255);else{var c=i<.5?i*(1+n):i+n-i*n,h=2*i-c;o=Math.round(255*v(h,c,a+1/3)),u=Math.round(255*v(h,c,a)),l=Math.round(255*v(h,c,a-1/3))}t=[o,u,l,s]}return t},Bc=function(e){var t,a=new RegExp("^"+bc+"$").exec(e);if(a){t=[];for(var n=[],i=1;i<=3;i++){var s=a[i];if(s[s.length-1]==="%"&&(n[i]=!0),s=parseFloat(s),n[i]&&(s=s/100*255),s<0||s>255)return;t.push(Math.floor(s))}var o=n[1]||n[2]||n[3],u=n[1]&&n[2]&&n[3];if(o&&!u)return;var l=a[4];if(l!==void 0){if(l=parseFloat(l),l<0||l>1)return;t.push(l)}}return t},Pc=function(e){return Ac[e.toLowerCase()]},iv=function(e){return(Fe(e)?e:null)||Pc(e)||kc(e)||Bc(e)||Dc(e)},Ac={transparent:[0,0,0,0],aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],grey:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},sv=function(e){for(var t=e.map,a=e.keys,n=a.length,i=0;i=u||R<0||m&&L>=c}function T(){var A=e();if(x(A))return k(A);d=setTimeout(T,C(A))}function k(A){return d=void 0,b&&v?w(A):(v=f=void 0,h)}function B(){d!==void 0&&clearTimeout(d),g=0,v=y=f=d=void 0}function D(){return d===void 0?h:k(e())}function P(){var A=e(),R=x(A);if(v=arguments,f=this,y=A,R){if(d===void 0)return E(y);if(m)return clearTimeout(d),d=setTimeout(T,u),w(y)}return d===void 0&&(d=setTimeout(T,u)),h}return P.cancel=B,P.flush=D,P}return vi=s,vi}var qc=Vc(),Fa=Oa(qc),fi=Qe?Qe.performance:null,lv=fi&&fi.now?function(){return fi.now()}:function(){return Date.now()},_c=(function(){if(Qe){if(Qe.requestAnimationFrame)return function(r){Qe.requestAnimationFrame(r)};if(Qe.mozRequestAnimationFrame)return function(r){Qe.mozRequestAnimationFrame(r)};if(Qe.webkitRequestAnimationFrame)return function(r){Qe.webkitRequestAnimationFrame(r)};if(Qe.msRequestAnimationFrame)return function(r){Qe.msRequestAnimationFrame(r)}}return function(r){r&&setTimeout(function(){r(lv())},1e3/60)}})(),bn=function(e){return _c(e)},Kr=lv,Et=9261,vv=65599,_t=5381,fv=function(e){for(var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Et,a=t,n;n=e.next(),!n.done;)a=a*vv+n.value|0;return a},Ca=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Et;return t*vv+e|0},Ta=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:_t;return(t<<5)+t+e|0},Gc=function(e,t){return e*2097152+t},Jr=function(e){return e[0]*2097152+e[1]},Ka=function(e,t){return[Ca(e[0],t[0]),Ta(e[1],t[1])]},Vo=function(e,t){var a={value:0,done:!1},n=0,i=e.length,s={next:function(){return n=0;n--)e[n]===t&&e.splice(n,1)},js=function(e){e.splice(0,e.length)},Jc=function(e,t){for(var a=0;a"u"?"undefined":je(Set))!==ed?Set:rd,Ln=function(e,t){var a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0;if(e===void 0||t===void 0||!Xs(e)){Ge("An element must have a core reference and parameters set");return}var n=t.group;if(n==null&&(t.data&&t.data.source!=null&&t.data.target!=null?n="edges":n="nodes"),n!=="nodes"&&n!=="edges"){Ge("An element must be of type `nodes` or `edges`; you specified `"+n+"`");return}this.length=1,this[0]=this;var i=this._private={cy:e,single:!0,data:t.data||{},position:t.position||{x:0,y:0},autoWidth:void 0,autoHeight:void 0,autoPadding:void 0,compoundBoundsClean:!1,listeners:[],group:n,style:{},rstyle:{},styleCxts:[],styleKeys:{},removed:!0,selected:!!t.selected,selectable:t.selectable===void 0?!0:!!t.selectable,locked:!!t.locked,grabbed:!1,grabbable:t.grabbable===void 0?!0:!!t.grabbable,pannable:t.pannable===void 0?n==="edges":!!t.pannable,active:!1,classes:new ra,animation:{current:[],queue:[]},rscratch:{},scratch:t.scratch||{},edges:[],children:[],parent:t.parent&&t.parent.isNode()?t.parent:null,traversalCache:{},backgrounding:!1,bbCache:null,bbCacheShift:{x:0,y:0},bodyBounds:null,overlayBounds:null,labelBounds:{all:null,source:null,target:null,main:null},arrowBounds:{source:null,target:null,"mid-source":null,"mid-target":null}};if(i.position.x==null&&(i.position.x=0),i.position.y==null&&(i.position.y=0),t.renderedPosition){var s=t.renderedPosition,o=e.pan(),u=e.zoom();i.position={x:(s.x-o.x)/u,y:(s.y-o.y)/u}}var l=[];Fe(t.classes)?l=t.classes:he(t.classes)&&(l=t.classes.split(/\s+/));for(var v=0,f=l.length;vm?1:0},v=function(p,m,b,w,E){var C;if(b==null&&(b=0),E==null&&(E=a),b<0)throw new Error("lo must be non-negative");for(w==null&&(w=p.length);bB;0<=B?k++:k--)T.push(k);return T}).apply(this).reverse(),x=[],w=0,E=C.length;wD;0<=D?++T:--T)P.push(s(p,b));return P},y=function(p,m,b,w){var E,C,x;for(w==null&&(w=a),E=p[b];b>m;){if(x=b-1>>1,C=p[x],w(E,C)<0){p[b]=C,b=x;continue}break}return p[b]=E},g=function(p,m,b){var w,E,C,x,T;for(b==null&&(b=a),E=p.length,T=m,C=p[m],w=2*m+1;w0;){var C=m.pop(),x=g(C),T=C.id();if(c[T]=x,x!==1/0)for(var k=C.neighborhood().intersect(d),B=0;B0)for(N.unshift(M);f[_];){var z=f[_];N.unshift(z.edge),N.unshift(z.node),F=z.node,_=F.id()}return o.spawn(N)}}}},ud={kruskal:function(e){e=e||function(b){return 1};for(var t=this.byGroup(),a=t.nodes,n=t.edges,i=a.length,s=new Array(i),o=a,u=function(w){for(var E=0;E0;){if(E(),x++,w===v){for(var T=[],k=i,B=v,D=p[B];T.unshift(k),D!=null&&T.unshift(D),k=g[B],k!=null;)B=k.id(),D=p[B];return{found:!0,distance:f[w],path:this.spawn(T),steps:x}}h[w]=!0;for(var P=b._private.edges,A=0;AD&&(d[B]=D,m[B]=k,b[B]=E),!i){var P=k*v+T;!i&&d[P]>D&&(d[P]=D,m[P]=T,b[P]=E)}}}for(var A=0;A1&&arguments[1]!==void 0?arguments[1]:s,se=b(ye),de=[],ge=se;;){if(ge==null)return t.spawn();var Ee=m(ge),be=Ee.edge,Te=Ee.pred;if(de.unshift(ge[0]),ge.same(pe)&&de.length>0)break;be!=null&&de.unshift(be),ge=Te}return u.spawn(de)},C=0;C=0;v--){var f=l[v],c=f[1],h=f[2];(t[c]===o&&t[h]===u||t[c]===u&&t[h]===o)&&l.splice(v,1)}for(var d=0;dn;){var i=Math.floor(Math.random()*t.length);t=pd(i,e,t),a--}return t},yd={kargerStein:function(){var e=this,t=this.byGroup(),a=t.nodes,n=t.edges;n.unmergeBy(function(N){return N.isLoop()});var i=a.length,s=n.length,o=Math.ceil(Math.pow(Math.log(i)/Math.LN2,2)),u=Math.floor(i/gd);if(i<2){Ge("At least 2 nodes are required for Karger-Stein algorithm");return}for(var l=[],v=0;v1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:e.length,n=1/0,i=t;i1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:e.length,n=-1/0,i=t;i1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:e.length,n=0,i=0,s=t;s1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:e.length,n=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0,i=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0,s=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!0;n?e=e.slice(t,a):(a0&&e.splice(0,t));for(var o=0,u=e.length-1;u>=0;u--){var l=e[u];s?isFinite(l)||(e[u]=-1/0,o++):e.splice(u,1)}i&&e.sort(function(c,h){return c-h});var v=e.length,f=Math.floor(v/2);return v%2!==0?e[f+1+o]:(e[f-1+o]+e[f+o])/2},mv=function(e,t){return t===0?e:mv(t,e%t)},Cd=function(e){for(var t=e[0],a=0;a0&&(t=mv(t,e[a]));else return 0;return t},Td=function(e){return Math.PI*e/180},Xa=function(e,t){return Math.atan2(t,e)-Math.PI/2},eo=Math.log2||function(r){return Math.log(r)/Math.log(2)},ro=function(e){return e>0?1:e<0?-1:0},kt=function(e,t){return Math.sqrt(wt(e,t))},wt=function(e,t){var a=t.x-e.x,n=t.y-e.y;return a*a+n*n},Sd=function(e){for(var t=e.length,a=0,n=0;n=e.x1&&e.y2>=e.y1)return{x1:e.x1,y1:e.y1,x2:e.x2,y2:e.y2,w:e.x2-e.x1,h:e.y2-e.y1};if(e.w!=null&&e.h!=null&&e.w>=0&&e.h>=0)return{x1:e.x1,y1:e.y1,x2:e.x1+e.w,y2:e.y1+e.h,w:e.w,h:e.h}}},Dd=function(e){return{x1:e.x1,x2:e.x2,w:e.w,y1:e.y1,y2:e.y2,h:e.h}},Bd=function(e){e.x1=1/0,e.y1=1/0,e.x2=-1/0,e.y2=-1/0,e.w=0,e.h=0},Pd=function(e,t){e.x1=Math.min(e.x1,t.x1),e.x2=Math.max(e.x2,t.x2),e.w=e.x2-e.x1,e.y1=Math.min(e.y1,t.y1),e.y2=Math.max(e.y2,t.y2),e.h=e.y2-e.y1},bv=function(e,t,a){e.x1=Math.min(e.x1,t),e.x2=Math.max(e.x2,t),e.w=e.x2-e.x1,e.y1=Math.min(e.y1,a),e.y2=Math.max(e.y2,a),e.h=e.y2-e.y1},on=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;return e.x1-=t,e.x2+=t,e.y1-=t,e.y2+=t,e.w=e.x2-e.x1,e.h=e.y2-e.y1,e},un=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[0],a,n,i,s;if(t.length===1)a=n=i=s=t[0];else if(t.length===2)a=i=t[0],s=n=t[1];else if(t.length===4){var o=Xe(t,4);a=o[0],n=o[1],i=o[2],s=o[3]}return e.x1-=s,e.x2+=n,e.y1-=a,e.y2+=i,e.w=e.x2-e.x1,e.h=e.y2-e.y1,e},$o=function(e,t){e.x1=t.x1,e.y1=t.y1,e.x2=t.x2,e.y2=t.y2,e.w=e.x2-e.x1,e.h=e.y2-e.y1},to=function(e,t){return!(e.x1>t.x2||t.x1>e.x2||e.x2t.y2||t.y1>e.y2)},tt=function(e,t,a){return e.x1<=t&&t<=e.x2&&e.y1<=a&&a<=e.y2},Uo=function(e,t){return tt(e,t.x,t.y)},wv=function(e,t){return tt(e,t.x1,t.y1)&&tt(e,t.x2,t.y2)},Ad=(hi=Math.hypot)!==null&&hi!==void 0?hi:function(r,e){return Math.sqrt(r*r+e*e)};function Rd(r,e){if(r.length<3)throw new Error("Need at least 3 vertices");var t=function(T,k){return{x:T.x+k.x,y:T.y+k.y}},a=function(T,k){return{x:T.x-k.x,y:T.y-k.y}},n=function(T,k){return{x:T.x*k,y:T.y*k}},i=function(T,k){return T.x*k.y-T.y*k.x},s=function(T){var k=Ad(T.x,T.y);return k===0?{x:0,y:0}:{x:T.x/k,y:T.y/k}},o=function(T){for(var k=0,B=0;B7&&arguments[7]!==void 0?arguments[7]:"auto",l=u==="auto"?ut(i,s):u,v=i/2,f=s/2;l=Math.min(l,v,f);var c=l!==v,h=l!==f,d;if(c){var y=a-v+l-o,g=n-f-o,p=a+v-l+o,m=g;if(d=at(e,t,a,n,y,g,p,m,!1),d.length>0)return d}if(h){var b=a+v+o,w=n-f+l-o,E=b,C=n+f-l+o;if(d=at(e,t,a,n,b,w,E,C,!1),d.length>0)return d}if(c){var x=a-v+l-o,T=n+f+o,k=a+v-l+o,B=T;if(d=at(e,t,a,n,x,T,k,B,!1),d.length>0)return d}if(h){var D=a-v-o,P=n-f+l-o,A=D,R=n+f-l+o;if(d=at(e,t,a,n,D,P,A,R,!1),d.length>0)return d}var L;{var I=a-v+l,M=n-f+l;if(L=ya(e,t,a,n,I,M,l+o),L.length>0&&L[0]<=I&&L[1]<=M)return[L[0],L[1]]}{var N=a+v-l,F=n-f+l;if(L=ya(e,t,a,n,N,F,l+o),L.length>0&&L[0]>=N&&L[1]<=F)return[L[0],L[1]]}{var _=a+v-l,z=n+f-l;if(L=ya(e,t,a,n,_,z,l+o),L.length>0&&L[0]>=_&&L[1]>=z)return[L[0],L[1]]}{var q=a-v+l,Z=n+f-l;if(L=ya(e,t,a,n,q,Z,l+o),L.length>0&&L[0]<=q&&L[1]>=Z)return[L[0],L[1]]}return[]},Ld=function(e,t,a,n,i,s,o){var u=o,l=Math.min(a,i),v=Math.max(a,i),f=Math.min(n,s),c=Math.max(n,s);return l-u<=e&&e<=v+u&&f-u<=t&&t<=c+u},Id=function(e,t,a,n,i,s,o,u,l){var v={x1:Math.min(a,o,i)-l,x2:Math.max(a,o,i)+l,y1:Math.min(n,u,s)-l,y2:Math.max(n,u,s)+l};return!(ev.x2||tv.y2)},Od=function(e,t,a,n){a-=n;var i=t*t-4*e*a;if(i<0)return[];var s=Math.sqrt(i),o=2*e,u=(-t+s)/o,l=(-t-s)/o;return[u,l]},Nd=function(e,t,a,n,i){var s=1e-5;e===0&&(e=s),t/=e,a/=e,n/=e;var o,u,l,v,f,c,h,d;if(u=(3*a-t*t)/9,l=-(27*n)+t*(9*a-2*(t*t)),l/=54,o=u*u*u+l*l,i[1]=0,h=t/3,o>0){f=l+Math.sqrt(o),f=f<0?-Math.pow(-f,1/3):Math.pow(f,1/3),c=l-Math.sqrt(o),c=c<0?-Math.pow(-c,1/3):Math.pow(c,1/3),i[0]=-h+f+c,h+=(f+c)/2,i[4]=i[2]=-h,h=Math.sqrt(3)*(-c+f)/2,i[3]=h,i[5]=-h;return}if(i[5]=i[3]=0,o===0){d=l<0?-Math.pow(-l,1/3):Math.pow(l,1/3),i[0]=-h+2*d,i[4]=i[2]=-(d+h);return}u=-u,v=u*u*u,v=Math.acos(l/Math.sqrt(v)),d=2*Math.sqrt(u),i[0]=-h+d*Math.cos(v/3),i[2]=-h+d*Math.cos((v+2*Math.PI)/3),i[4]=-h+d*Math.cos((v+4*Math.PI)/3)},zd=function(e,t,a,n,i,s,o,u){var l=1*a*a-4*a*i+2*a*o+4*i*i-4*i*o+o*o+n*n-4*n*s+2*n*u+4*s*s-4*s*u+u*u,v=9*a*i-3*a*a-3*a*o-6*i*i+3*i*o+9*n*s-3*n*n-3*n*u-6*s*s+3*s*u,f=3*a*a-6*a*i+a*o-a*e+2*i*i+2*i*e-o*e+3*n*n-6*n*s+n*u-n*t+2*s*s+2*s*t-u*t,c=1*a*i-a*a+a*e-i*e+n*s-n*n+n*t-s*t,h=[];Nd(l,v,f,c,h);for(var d=1e-7,y=[],g=0;g<6;g+=2)Math.abs(h[g+1])=0&&h[g]<=1&&y.push(h[g]);y.push(1),y.push(0);for(var p=-1,m,b,w,E=0;E=0?wl?(e-i)*(e-i)+(t-s)*(t-s):v-c},Er=function(e,t,a){for(var n,i,s,o,u,l=0,v=0;v=e&&e>=s||n<=e&&e<=s)u=(e-n)/(s-n)*(o-i)+i,u>t&&l++;else continue;return l%2!==0},Xr=function(e,t,a,n,i,s,o,u,l){var v=new Array(a.length),f;u[0]!=null?(f=Math.atan(u[1]/u[0]),u[0]<0?f=f+Math.PI/2:f=-f-Math.PI/2):f=u;for(var c=Math.cos(-f),h=Math.sin(-f),d=0;d0){var g=En(v,-l);y=xn(g)}else y=v;return Er(e,t,y)},Vd=function(e,t,a,n,i,s,o,u){for(var l=new Array(a.length*2),v=0;v=0&&g<=1&&m.push(g),p>=0&&p<=1&&m.push(p),m.length===0)return[];var b=m[0]*u[0]+e,w=m[0]*u[1]+t;if(m.length>1){if(m[0]==m[1])return[b,w];var E=m[1]*u[0]+e,C=m[1]*u[1]+t;return[b,w,E,C]}else return[b,w]},gi=function(e,t,a){return t<=e&&e<=a||a<=e&&e<=t?e:e<=t&&t<=a||a<=t&&t<=e?t:a},at=function(e,t,a,n,i,s,o,u,l){var v=e-i,f=a-e,c=o-i,h=t-s,d=n-t,y=u-s,g=c*h-y*v,p=f*h-d*v,m=y*f-c*d;if(m!==0){var b=g/m,w=p/m,E=.001,C=0-E,x=1+E;return C<=b&&b<=x&&C<=w&&w<=x?[e+b*f,t+b*d]:l?[e+b*f,t+b*d]:[]}else return g===0||p===0?gi(e,a,o)===o?[o,u]:gi(e,a,i)===i?[i,s]:gi(i,o,a)===a?[a,n]:[]:[]},_d=function(e,t,a,n,i){var s=[],o=n/2,u=i/2,l=t,v=a;s.push({x:l+o*e[0],y:v+u*e[1]});for(var f=1;f0){var y=En(f,-u);h=xn(y)}else h=f}else h=a;for(var g,p,m,b,w=0;w2){for(var d=[v[0],v[1]],y=Math.pow(d[0]-e,2)+Math.pow(d[1]-t,2),g=1;gv&&(v=w)},get:function(b){return l[b]}},c=0;c0?L=R.edgesTo(A)[0]:L=A.edgesTo(R)[0];var I=n(L);A=A.id(),x[A]>x[D]+I&&(x[A]=x[D]+I,T.nodes.indexOf(A)<0?T.push(A):T.updateItem(A),C[A]=0,E[A]=[]),x[A]==x[D]+I&&(C[A]=C[A]+C[D],E[A].push(D))}else for(var M=0;M0;){for(var z=w.pop(),q=0;q0&&o.push(a[u]);o.length!==0&&i.push(n.collection(o))}return i},th=function(e,t){for(var a=0;a5&&arguments[5]!==void 0?arguments[5]:ih,o=n,u,l,v=0;v=2?va(e,t,a,0,Qo,sh):va(e,t,a,0,Zo)},squaredEuclidean:function(e,t,a){return va(e,t,a,0,Qo)},manhattan:function(e,t,a){return va(e,t,a,0,Zo)},max:function(e,t,a){return va(e,t,a,-1/0,oh)}};Zt["squared-euclidean"]=Zt.squaredEuclidean;Zt.squaredeuclidean=Zt.squaredEuclidean;function On(r,e,t,a,n,i){var s;return He(r)?s=r:s=Zt[r]||Zt.euclidean,e===0&&He(r)?s(n,i):s(e,t,a,n,i)}var uh=lr({k:2,m:2,sensitivityThreshold:1e-4,distance:"euclidean",maxIterations:10,attributes:[],testMode:!1,testCentroids:null}),no=function(e){return uh(e)},Cn=function(e,t,a,n,i){var s=i!=="kMedoids",o=s?function(f){return a[f]}:function(f){return n[f](a)},u=function(c){return n[c](t)},l=a,v=t;return On(e,n.length,o,u,l,v)},yi=function(e,t,a){for(var n=a.length,i=new Array(n),s=new Array(n),o=new Array(t),u=null,l=0;la)return!1}return!0},fh=function(e,t,a){for(var n=0;no&&(o=t[l][v],u=v);i[u].push(e[l])}for(var f=0;f=i.threshold||i.mode==="dendrogram"&&e.length===1)return!1;var d=t[s],y=t[n[s]],g;i.mode==="dendrogram"?g={left:d,right:y,key:d.key}:g={value:d.value.concat(y.value),key:d.key},e[d.index]=g,e.splice(y.index,1),t[d.key]=g;for(var p=0;pa[y.key][m.key]&&(u=a[y.key][m.key])):i.linkage==="max"?(u=a[d.key][m.key],a[d.key][m.key]0&&n.push(i);return n},au=function(e,t,a){for(var n=[],i=0;io&&(s=l,o=t[i*e+l])}s>0&&n.push(s)}for(var v=0;vl&&(u=v,l=f)}a[i]=s[u]}return n=au(e,t,a),n},nu=function(e){for(var t=this.cy(),a=this.nodes(),n=Ch(e),i={},s=0;s=D?(P=D,D=R,A=L):R>P&&(P=R);for(var I=0;I0?1:0;x[k%n.minIterations*o+q]=Z,z+=Z}if(z>0&&(k>=n.minIterations-1||k==n.maxIterations-1)){for(var Q=0,X=0;X1||C>1)&&(o=!0),f[b]=[],m.outgoers().forEach(function(T){T.isEdge()&&f[b].push(T.id())})}else c[b]=[void 0,m.target().id()]}):s.forEach(function(m){var b=m.id();if(m.isNode()){var w=m.degree(!0);w%2&&(u?l?o=!0:l=b:u=b),f[b]=[],m.connectedEdges().forEach(function(E){return f[b].push(E.id())})}else c[b]=[m.source().id(),m.target().id()]});var h={found:!1,trail:void 0};if(o)return h;if(l&&u)if(i){if(v&&l!=v)return h;v=l}else{if(v&&l!=v&&u!=v)return h;v||(v=l)}else v||(v=s[0].id());var d=function(b){for(var w=b,E=[b],C,x,T;f[w].length;)C=f[w].shift(),x=c[C][0],T=c[C][1],w!=T?(f[T]=f[T].filter(function(k){return k!=C}),w=T):!i&&w!=x&&(f[x]=f[x].filter(function(k){return k!=C}),w=x),E.unshift(C),E.unshift(w);return E},y=[],g=[];for(g=d(v);g.length!=1;)f[g[0]].length==0?(y.unshift(s.getElementById(g.shift())),y.unshift(s.getElementById(g.shift()))):g=d(g.shift()).concat(g);y.unshift(s.getElementById(g.shift()));for(var p in f)if(f[p].length)return h;return h.found=!0,h.trail=this.spawn(y,!0),h}},Za=function(){var e=this,t={},a=0,n=0,i=[],s=[],o={},u=function(c,h){for(var d=s.length-1,y=[],g=e.spawn();s[d].x!=c||s[d].y!=h;)y.push(s.pop().edge),d--;y.push(s.pop().edge),y.forEach(function(p){var m=p.connectedNodes().intersection(e);g.merge(p),m.forEach(function(b){var w=b.id(),E=b.connectedEdges().intersection(e);g.merge(b),t[w].cutVertex?g.merge(E.filter(function(C){return C.isLoop()})):g.merge(E)})}),i.push(g)},l=function(c,h,d){c===d&&(n+=1),t[h]={id:a,low:a++,cutVertex:!1};var y=e.getElementById(h).connectedEdges().intersection(e);if(y.size()===0)i.push(e.spawn(e.getElementById(h)));else{var g,p,m,b;y.forEach(function(w){g=w.source().id(),p=w.target().id(),m=g===h?p:g,m!==d&&(b=w.id(),o[b]||(o[b]=!0,s.push({x:h,y:m,edge:w})),m in t?t[h].low=Math.min(t[h].low,t[m].id):(l(c,m,h),t[h].low=Math.min(t[h].low,t[m].low),t[h].id<=t[m].low&&(t[h].cutVertex=!0,u(h,m))))})}};e.forEach(function(f){if(f.isNode()){var c=f.id();c in t||(n=0,l(c,c),t[c].cutVertex=n>1)}});var v=Object.keys(t).filter(function(f){return t[f].cutVertex}).map(function(f){return e.getElementById(f)});return{cut:e.spawn(v),components:i}},Rh={hopcroftTarjanBiconnected:Za,htbc:Za,htb:Za,hopcroftTarjanBiconnectedComponents:Za},Qa=function(){var e=this,t={},a=0,n=[],i=[],s=e.spawn(e),o=function(l){i.push(l),t[l]={index:a,low:a++,explored:!1};var v=e.getElementById(l).connectedEdges().intersection(e);if(v.forEach(function(y){var g=y.target().id();g!==l&&(g in t||o(g),t[g].explored||(t[l].low=Math.min(t[l].low,t[g].low)))}),t[l].index===t[l].low){for(var f=e.spawn();;){var c=i.pop();if(f.merge(e.getElementById(c)),t[c].low=t[l].index,t[c].explored=!0,c===l)break}var h=f.edgesWith(f),d=f.merge(h);n.push(d),s=s.difference(d)}};return e.forEach(function(u){if(u.isNode()){var l=u.id();l in t||o(l)}}),{cut:s,components:n}},Mh={tarjanStronglyConnected:Qa,tsc:Qa,tscc:Qa,tarjanStronglyConnectedComponents:Qa},Bv={};[Sa,od,ud,vd,cd,hd,yd,$d,Ut,Kt,As,nh,yh,xh,Bh,Ah,Rh,Mh].forEach(function(r){me(Bv,r)});/*! +Embeddable Minimum Strictly-Compliant Promises/A+ 1.1.1 Thenable +Copyright (c) 2013-2014 Ralf S. Engelschall (http://engelschall.com) +Licensed under The MIT License (http://opensource.org/licenses/MIT) +*/var Pv=0,Av=1,Rv=2,Nr=function(e){if(!(this instanceof Nr))return new Nr(e);this.id="Thenable/1.0.7",this.state=Pv,this.fulfillValue=void 0,this.rejectReason=void 0,this.onFulfilled=[],this.onRejected=[],this.proxy={then:this.then.bind(this)},typeof e=="function"&&e.call(this,this.fulfill.bind(this),this.reject.bind(this))};Nr.prototype={fulfill:function(e){return iu(this,Av,"fulfillValue",e)},reject:function(e){return iu(this,Rv,"rejectReason",e)},then:function(e,t){var a=this,n=new Nr;return a.onFulfilled.push(ou(e,n,"fulfill")),a.onRejected.push(ou(t,n,"reject")),Mv(a),n.proxy}};var iu=function(e,t,a,n){return e.state===Pv&&(e.state=t,e[a]=n,Mv(e)),e},Mv=function(e){e.state===Av?su(e,"onFulfilled",e.fulfillValue):e.state===Rv&&su(e,"onRejected",e.rejectReason)},su=function(e,t,a){if(e[t].length!==0){var n=e[t];e[t]=[];var i=function(){for(var o=0;o0}},clearQueue:function(){return function(){var t=this,a=t.length!==void 0,n=a?t:[t],i=this._private.cy||this;if(!i.styleEnabled())return this;for(var s=0;s-1}return Vi=e,Vi}var qi,Au;function Qh(){if(Au)return qi;Au=1;var r=Fn();function e(t,a){var n=this.__data__,i=r(n,t);return i<0?(++this.size,n.push([t,a])):n[i][1]=a,this}return qi=e,qi}var _i,Ru;function Jh(){if(Ru)return _i;Ru=1;var r=Kh(),e=Xh(),t=Yh(),a=Zh(),n=Qh();function i(s){var o=-1,u=s==null?0:s.length;for(this.clear();++o-1&&a%1==0&&a0&&this.spawn(n).updateStyle().emit("class"),t},addClass:function(e){return this.toggleClass(e,!0)},hasClass:function(e){var t=this[0];return t!=null&&t._private.classes.has(e)},toggleClass:function(e,t){Fe(e)||(e=e.match(/\S+/g)||[]);for(var a=this,n=t===void 0,i=[],s=0,o=a.length;s0&&this.spawn(i).updateStyle().emit("class"),a},removeClass:function(e){return this.toggleClass(e,!1)},flashClass:function(e,t){var a=this;if(t==null)t=250;else if(t===0)return a;return a.addClass(e),setTimeout(function(){a.removeClass(e)},t),a}};ln.className=ln.classNames=ln.classes;var Re={metaChar:"[\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\]\\^\\`\\{\\|\\}\\~]",comparatorOp:"=|\\!=|>|>=|<|<=|\\$=|\\^=|\\*=",boolOp:"\\?|\\!|\\^",string:`"(?:\\\\"|[^"])*"|'(?:\\\\'|[^'])*'`,number:Je,meta:"degree|indegree|outdegree",separator:"\\s*,\\s*",descendant:"\\s+",child:"\\s+>\\s+",subject:"\\$",group:"node|edge|\\*",directedEdge:"\\s+->\\s+",undirectedEdge:"\\s+<->\\s+"};Re.variable="(?:[\\w-.]|(?:\\\\"+Re.metaChar+"))+";Re.className="(?:[\\w-]|(?:\\\\"+Re.metaChar+"))+";Re.value=Re.string+"|"+Re.number;Re.id=Re.variable;(function(){var r,e,t;for(r=Re.comparatorOp.split("|"),t=0;t=0)&&e!=="="&&(Re.comparatorOp+="|\\!"+e)})();var ze=function(){return{checks:[]}},le={GROUP:0,COLLECTION:1,FILTER:2,DATA_COMPARE:3,DATA_EXIST:4,DATA_BOOL:5,META_COMPARE:6,STATE:7,ID:8,CLASS:9,UNDIRECTED_EDGE:10,DIRECTED_EDGE:11,NODE_SOURCE:12,NODE_TARGET:13,NODE_NEIGHBOR:14,CHILD:15,DESCENDANT:16,PARENT:17,ANCESTOR:18,COMPOUND_SPLIT:19,TRUE:20},Is=[{selector:":selected",matches:function(e){return e.selected()}},{selector:":unselected",matches:function(e){return!e.selected()}},{selector:":selectable",matches:function(e){return e.selectable()}},{selector:":unselectable",matches:function(e){return!e.selectable()}},{selector:":locked",matches:function(e){return e.locked()}},{selector:":unlocked",matches:function(e){return!e.locked()}},{selector:":visible",matches:function(e){return e.visible()}},{selector:":hidden",matches:function(e){return!e.visible()}},{selector:":transparent",matches:function(e){return e.transparent()}},{selector:":grabbed",matches:function(e){return e.grabbed()}},{selector:":free",matches:function(e){return!e.grabbed()}},{selector:":removed",matches:function(e){return e.removed()}},{selector:":inside",matches:function(e){return!e.removed()}},{selector:":grabbable",matches:function(e){return e.grabbable()}},{selector:":ungrabbable",matches:function(e){return!e.grabbable()}},{selector:":animated",matches:function(e){return e.animated()}},{selector:":unanimated",matches:function(e){return!e.animated()}},{selector:":parent",matches:function(e){return e.isParent()}},{selector:":childless",matches:function(e){return e.isChildless()}},{selector:":child",matches:function(e){return e.isChild()}},{selector:":orphan",matches:function(e){return e.isOrphan()}},{selector:":nonorphan",matches:function(e){return e.isChild()}},{selector:":compound",matches:function(e){return e.isNode()?e.isParent():e.source().isParent()||e.target().isParent()}},{selector:":loop",matches:function(e){return e.isLoop()}},{selector:":simple",matches:function(e){return e.isSimple()}},{selector:":active",matches:function(e){return e.active()}},{selector:":inactive",matches:function(e){return!e.active()}},{selector:":backgrounding",matches:function(e){return e.backgrounding()}},{selector:":nonbackgrounding",matches:function(e){return!e.backgrounding()}}].sort(function(r,e){return Sc(r.selector,e.selector)}),Pg=(function(){for(var r={},e,t=0;t0&&v.edgeCount>0)return Ne("The selector `"+e+"` is invalid because it uses both a compound selector and an edge selector"),!1;if(v.edgeCount>1)return Ne("The selector `"+e+"` is invalid because it uses multiple edge selectors"),!1;v.edgeCount===1&&Ne("The selector `"+e+"` is deprecated. Edge selectors do not take effect on changes to source and target nodes after an edge is added, for performance reasons. Use a class or data selector on edges instead, updating the class or data of an edge when your app detects a change in source or target nodes.")}return!0},Og=function(){if(this.toStringCache!=null)return this.toStringCache;for(var e=function(v){return v??""},t=function(v){return he(v)?'"'+v+'"':e(v)},a=function(v){return" "+v+" "},n=function(v,f){var c=v.type,h=v.value;switch(c){case le.GROUP:{var d=e(h);return d.substring(0,d.length-1)}case le.DATA_COMPARE:{var y=v.field,g=v.operator;return"["+y+a(e(g))+t(h)+"]"}case le.DATA_BOOL:{var p=v.operator,m=v.field;return"["+e(p)+m+"]"}case le.DATA_EXIST:{var b=v.field;return"["+b+"]"}case le.META_COMPARE:{var w=v.operator,E=v.field;return"[["+E+a(e(w))+t(h)+"]]"}case le.STATE:return h;case le.ID:return"#"+h;case le.CLASS:return"."+h;case le.PARENT:case le.CHILD:return i(v.parent,f)+a(">")+i(v.child,f);case le.ANCESTOR:case le.DESCENDANT:return i(v.ancestor,f)+" "+i(v.descendant,f);case le.COMPOUND_SPLIT:{var C=i(v.left,f),x=i(v.subject,f),T=i(v.right,f);return C+(C.length>0?" ":"")+x+T}case le.TRUE:return""}},i=function(v,f){return v.checks.reduce(function(c,h,d){return c+(f===v&&d===0?"$":"")+n(h,f)},"")},s="",o=0;o1&&o=0&&(t=t.replace("!",""),f=!0),t.indexOf("@")>=0&&(t=t.replace("@",""),v=!0),(i||o||v)&&(u=!i&&!s?"":""+e,l=""+a),v&&(e=u=u.toLowerCase(),a=l=l.toLowerCase()),t){case"*=":n=u.indexOf(l)>=0;break;case"$=":n=u.indexOf(l,u.length-l.length)>=0;break;case"^=":n=u.indexOf(l)===0;break;case"=":n=e===a;break;case">":c=!0,n=e>a;break;case">=":c=!0,n=e>=a;break;case"<":c=!0,n=e0;){var v=n.shift();e(v),i.add(v.id()),o&&a(n,i,v)}return r}function qv(r,e,t){if(t.isParent())for(var a=t._private.children,n=0;n1&&arguments[1]!==void 0?arguments[1]:!0;return uo(this,r,e,qv)};function _v(r,e,t){if(t.isChild()){var a=t._private.parent;e.has(a.id())||r.push(a)}}Qt.forEachUp=function(r){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return uo(this,r,e,_v)};function Hg(r,e,t){_v(r,e,t),qv(r,e,t)}Qt.forEachUpAndDown=function(r){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return uo(this,r,e,Hg)};Qt.ancestors=Qt.parents;var Ba,Gv;Ba=Gv={data:Oe.data({field:"data",bindingEvent:"data",allowBinding:!0,allowSetting:!0,settingEvent:"data",settingTriggersEvent:!0,triggerFnName:"trigger",allowGetting:!0,immutableKeys:{id:!0,source:!0,target:!0,parent:!0},updateStyle:!0}),removeData:Oe.removeData({field:"data",event:"data",triggerFnName:"trigger",triggerEvent:!0,immutableKeys:{id:!0,source:!0,target:!0,parent:!0},updateStyle:!0}),scratch:Oe.data({field:"scratch",bindingEvent:"scratch",allowBinding:!0,allowSetting:!0,settingEvent:"scratch",settingTriggersEvent:!0,triggerFnName:"trigger",allowGetting:!0,updateStyle:!0}),removeScratch:Oe.removeData({field:"scratch",event:"scratch",triggerFnName:"trigger",triggerEvent:!0,updateStyle:!0}),rscratch:Oe.data({field:"rscratch",allowBinding:!1,allowSetting:!0,settingTriggersEvent:!1,allowGetting:!0}),removeRscratch:Oe.removeData({field:"rscratch",triggerEvent:!1}),id:function(){var e=this[0];if(e)return e._private.data.id}};Ba.attr=Ba.data;Ba.removeAttr=Ba.removeData;var Wg=Gv,qn={};function gs(r){return function(e){var t=this;if(e===void 0&&(e=!0),t.length!==0)if(t.isNode()&&!t.removed()){for(var a=0,n=t[0],i=n._private.edges,s=0;se}),minIndegree:It("indegree",function(r,e){return re}),minOutdegree:It("outdegree",function(r,e){return re})});me(qn,{totalDegree:function(e){for(var t=0,a=this.nodes(),n=0;n0,c=f;f&&(v=v[0]);var h=c?v.position():{x:0,y:0};t!==void 0?l.position(e,t+h[e]):i!==void 0&&l.position({x:i.x+h.x,y:i.y+h.y})}else{var d=a.position(),y=o?a.parent():null,g=y&&y.length>0,p=g;g&&(y=y[0]);var m=p?y.position():{x:0,y:0};return i={x:d.x-m.x,y:d.y-m.y},e===void 0?i:i[e]}else if(!s)return;return this}};Or.modelPosition=Or.point=Or.position;Or.modelPositions=Or.points=Or.positions;Or.renderedPoint=Or.renderedPosition;Or.relativePoint=Or.relativePosition;var $g=Hv,Jt=function(e){switch(e){case"left":case"right-inside":return"left";case"right":case"left-inside":return"right";default:return"center"}},jt=function(e){switch(e){case"top":case"bottom-inside":return"top";case"bottom":case"top-inside":return"bottom";default:return"center"}},Ug=function(e){switch(e){case"left":return"right";case"right":return"left";case"left-inside":return"left";case"right-inside":return"right";default:return"center"}},Xt,ht;Xt=ht={};ht.renderedBoundingBox=function(r){var e=this.boundingBox(r),t=this.cy(),a=t.zoom(),n=t.pan(),i=e.x1*a+n.x,s=e.x2*a+n.x,o=e.y1*a+n.y,u=e.y2*a+n.y;return{x1:i,x2:s,y1:o,y2:u,w:s-i,h:u-o}};ht.dirtyCompoundBoundsCache=function(){var r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,e=this.cy();return!e.styleEnabled()||!e.hasCompoundNodes()?this:(this.forEachUp(function(t){if(t.isParent()){var a=t._private;a.compoundBoundsClean=!1,a.bbCache=null,r||t.emitAndNotify("bounds")}}),this)};ht.updateCompoundBounds=function(){var r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,e=this.cy();if(!e.styleEnabled()||!e.hasCompoundNodes())return this;if(!r&&e.batching())return this;function t(s){if(!s.isParent())return;var o=s._private,u=s.children(),l=s.pstyle("compound-sizing-wrt-labels").value==="include",v={width:{val:s.pstyle("min-width").pfValue,left:s.pstyle("min-width-bias-left"),right:s.pstyle("min-width-bias-right")},height:{val:s.pstyle("min-height").pfValue,top:s.pstyle("min-height-bias-top"),bottom:s.pstyle("min-height-bias-bottom")}},f=u.boundingBox({includeLabels:l,includeOverlays:!1,useCache:!1}),c=o.position;(f.w===0||f.h===0)&&(f={w:s.pstyle("width").pfValue,h:s.pstyle("height").pfValue},f.x1=c.x-f.w/2,f.x2=c.x+f.w/2,f.y1=c.y-f.h/2,f.y2=c.y+f.h/2);function h(k,B,D){var P=0,A=0,R=B+D;return k>0&&R>0&&(P=B/R*k,A=D/R*k),{biasDiff:P,biasComplementDiff:A}}function d(k,B,D,P){if(D.units==="%")switch(P){case"width":return k>0?D.pfValue*k:0;case"height":return B>0?D.pfValue*B:0;case"average":return k>0&&B>0?D.pfValue*(k+B)/2:0;case"min":return k>0&&B>0?k>B?D.pfValue*B:D.pfValue*k:0;case"max":return k>0&&B>0?k>B?D.pfValue*k:D.pfValue*B:0;default:return 0}else return D.units==="px"?D.pfValue:0}var y=v.width.left.value;v.width.left.units==="px"&&v.width.val>0&&(y=y*100/v.width.val);var g=v.width.right.value;v.width.right.units==="px"&&v.width.val>0&&(g=g*100/v.width.val);var p=v.height.top.value;v.height.top.units==="px"&&v.height.val>0&&(p=p*100/v.height.val);var m=v.height.bottom.value;v.height.bottom.units==="px"&&v.height.val>0&&(m=m*100/v.height.val);var b=h(v.width.val-f.w,y,g),w=b.biasDiff,E=b.biasComplementDiff,C=h(v.height.val-f.h,p,m),x=C.biasDiff,T=C.biasComplementDiff;o.autoPadding=d(f.w,f.h,s.pstyle("padding"),s.pstyle("padding-relative-to").value),o.autoWidth=Math.max(f.w,v.width.val),c.x=(-w+f.x1+f.x2+E)/2,o.autoHeight=Math.max(f.h,v.height.val),c.y=(-x+f.y1+f.y2+T)/2}for(var a=0;ae.x2?n:e.x2,e.y1=ae.y2?i:e.y2,e.w=e.x2-e.x1,e.h=e.y2-e.y1)},et=function(e,t){return t==null?e:Ir(e,t.x1,t.y1,t.x2,t.y2)},fa=function(e,t,a){return pr(e,t,a)},Ja=function(e,t,a){if(!t.cy().headless()){var n=t._private,i=n.rstyle,s=i.arrowWidth/2,o=t.pstyle(a+"-arrow-shape").value,u,l;if(o!=="none"){a==="source"?(u=i.srcX,l=i.srcY):a==="target"?(u=i.tgtX,l=i.tgtY):(u=i.midX,l=i.midY);var v=n.arrowBounds=n.arrowBounds||{},f=v[a]=v[a]||{};f.x1=u-s,f.y1=l-s,f.x2=u+s,f.y2=l+s,f.w=f.x2-f.x1,f.h=f.y2-f.y1,on(f,1),Ir(e,f.x1,f.y1,f.x2,f.y2)}}},ps=function(e,t,a){if(!t.cy().headless()){var n;a?n=a+"-":n="";var i=t._private,s=i.rstyle,o=t.pstyle(n+"label").strValue;if(o){var u=t.pstyle("text-halign"),l=t.pstyle("text-valign"),v=fa(s,"labelWidth",a),f=fa(s,"labelHeight",a),c=fa(s,"labelX",a),h=fa(s,"labelY",a),d=t.pstyle(n+"text-margin-x").pfValue,y=t.pstyle(n+"text-margin-y").pfValue,g=t.isEdge(),p=t.pstyle(n+"text-rotation"),m=t.pstyle("text-outline-width").pfValue,b=t.pstyle("text-border-width").pfValue,w=b/2,E=t.pstyle("text-background-padding").pfValue,C=2,x=f,T=v,k=T/2,B=x/2,D,P,A,R;if(g)D=c-k,P=c+k,A=h-B,R=h+B;else{switch(Jt(u.value)){case"left":D=c-T,P=c;break;case"center":D=c-k,P=c+k;break;case"right":D=c,P=c+T;break}switch(jt(l.value)){case"top":A=h-x,R=h;break;case"center":A=h-B,R=h+B;break;case"bottom":A=h,R=h+x;break}}var L=d-Math.max(m,w)-E-C,I=d+Math.max(m,w)+E+C,M=y-Math.max(m,w)-E-C,N=y+Math.max(m,w)+E+C;D+=L,P+=I,A+=M,R+=N;var F=a||"main",_=i.labelBounds,z=_[F]=_[F]||{};z.x1=D,z.y1=A,z.x2=P,z.y2=R,z.w=P-D,z.h=R-A,z.leftPad=L,z.rightPad=I,z.topPad=M,z.botPad=N;var q=g&&p.strValue==="autorotate",Z=p.pfValue!=null&&p.pfValue!==0;if(q||Z){var Q=q?fa(i.rstyle,"labelAngle",a):p.pfValue,X=Math.cos(Q),J=Math.sin(Q),j=(D+P)/2,ne=(A+R)/2;if(!g){switch(Jt(u.value)){case"left":j=P;break;case"right":j=D;break}switch(jt(l.value)){case"top":ne=R;break;case"bottom":ne=A;break}}var Y=function(we,ye){return we=we-j,ye=ye-ne,{x:we*X-ye*J+j,y:we*J+ye*X+ne}},V=Y(D,A),H=Y(D,R),$=Y(P,A),K=Y(P,R);D=Math.min(V.x,H.x,$.x,K.x),P=Math.max(V.x,H.x,$.x,K.x),A=Math.min(V.y,H.y,$.y,K.y),R=Math.max(V.y,H.y,$.y,K.y)}var te=F+"Rot",ve=_[te]=_[te]||{};ve.x1=D,ve.y1=A,ve.x2=P,ve.y2=R,ve.w=P-D,ve.h=R-A,Ir(e,D,A,P,R),Ir(i.labelBounds.all,D,A,P,R)}return e}},sl=function(e,t){if(!t.cy().headless()){var a=t.pstyle("outline-opacity").value,n=t.pstyle("outline-width").value,i=t.pstyle("outline-offset").value,s=n+i;$v(e,t,a,s,"outside",s/2)}},$v=function(e,t,a,n,i,s){if(!(a===0||n<=0||i==="inside")){var o=t.cy(),u=o.renderer(),l=u.nodeShapes[u.getNodeShape(t)];if(l){var v=t.position(),f=v.x,c=v.y,h=t.width(),d=t.height();if(l.hasMiterBounds){i==="center"&&(n/=2);var y=l.miterBounds(f,c,h,d,n);et(e,y)}else s!=null&&s>0&&un(e,[s,s,s,s])}}},Kg=function(e,t){if(!t.cy().headless()){var a=t.pstyle("border-opacity").value,n=t.pstyle("border-width").pfValue,i=t.pstyle("border-position").value;$v(e,t,a,n,i)}},Xg=function(e,t){var a=e._private.cy,n=a.styleEnabled(),i=a.headless(),s=yr(),o=e._private,u=e.isNode(),l=e.isEdge(),v,f,c,h,d,y,g=o.rstyle,p=u&&n?e.pstyle("bounds-expansion").pfValue:[0],m=function(De){return De.pstyle("display").value!=="none"},b=!n||m(e)&&(!l||m(e.source())&&m(e.target()));if(b){var w=0,E=0;n&&t.includeOverlays&&(w=e.pstyle("overlay-opacity").value,w!==0&&(E=e.pstyle("overlay-padding").value));var C=0,x=0;n&&t.includeUnderlays&&(C=e.pstyle("underlay-opacity").value,C!==0&&(x=e.pstyle("underlay-padding").value));var T=Math.max(E,x),k=0,B=0;if(n&&(k=e.pstyle("width").pfValue,B=k/2),u&&t.includeNodes){var D=e.position();d=D.x,y=D.y;var P=e.outerWidth(),A=P/2,R=e.outerHeight(),L=R/2;v=d-A,f=d+A,c=y-L,h=y+L,Ir(s,v,c,f,h),n&&sl(s,e),n&&t.includeOutlines&&!i&&sl(s,e),n&&Kg(s,e)}else if(l&&t.includeEdges)if(n&&!i){var I=e.pstyle("curve-style").strValue;if(v=Math.min(g.srcX,g.midX,g.tgtX),f=Math.max(g.srcX,g.midX,g.tgtX),c=Math.min(g.srcY,g.midY,g.tgtY),h=Math.max(g.srcY,g.midY,g.tgtY),v-=B,f+=B,c-=B,h+=B,Ir(s,v,c,f,h),I==="haystack"){var M=g.haystackPts;if(M&&M.length===2){if(v=M[0].x,c=M[0].y,f=M[1].x,h=M[1].y,v>f){var N=v;v=f,f=N}if(c>h){var F=c;c=h,h=F}Ir(s,v-B,c-B,f+B,h+B)}}else if(I==="bezier"||I==="unbundled-bezier"||rt(I,"segments")||rt(I,"taxi")){var _;switch(I){case"bezier":case"unbundled-bezier":_=g.bezierPts;break;case"segments":case"taxi":case"round-segments":case"round-taxi":_=g.linePts;break}if(_!=null)for(var z=0;z<_.length;z++){var q=_[z];v=q.x-B,f=q.x+B,c=q.y-B,h=q.y+B,Ir(s,v,c,f,h)}}}else{var Z=e.source(),Q=Z.position(),X=e.target(),J=X.position();if(v=Q.x,f=J.x,c=Q.y,h=J.y,v>f){var j=v;v=f,f=j}if(c>h){var ne=c;c=h,h=ne}v-=B,f+=B,c-=B,h+=B,Ir(s,v,c,f,h)}if(n&&t.includeEdges&&l&&(Ja(s,e,"mid-source"),Ja(s,e,"mid-target"),Ja(s,e,"source"),Ja(s,e,"target")),n){var Y=e.pstyle("ghost").value==="yes";if(Y){var V=e.pstyle("ghost-offset-x").pfValue,H=e.pstyle("ghost-offset-y").pfValue;Ir(s,s.x1+V,s.y1+H,s.x2+V,s.y2+H)}}var $=o.bodyBounds=o.bodyBounds||{};$o($,s),un($,p),on($,1),n&&(v=s.x1,f=s.x2,c=s.y1,h=s.y2,Ir(s,v-T,c-T,f+T,h+T));var K=o.overlayBounds=o.overlayBounds||{};$o(K,s),un(K,p),on(K,1);var te=o.labelBounds=o.labelBounds||{};te.all!=null?Bd(te.all):te.all=yr(),n&&t.includeLabels&&(t.includeMainLabels&&ps(s,e,null),l&&(t.includeSourceLabels&&ps(s,e,"source"),t.includeTargetLabels&&ps(s,e,"target")))}return s.x1=Br(s.x1),s.y1=Br(s.y1),s.x2=Br(s.x2),s.y2=Br(s.y2),s.w=Br(s.x2-s.x1),s.h=Br(s.y2-s.y1),s.w>0&&s.h>0&&b&&(un(s,p),on(s,1)),s},Uv=function(e){var t=0,a=function(s){return(s?1:0)<0&&arguments[0]!==void 0?arguments[0]:lp,e=arguments.length>1?arguments[1]:void 0,t=0;t=0;o--)s(o);return this};ft.removeAllListeners=function(){return this.removeListener("*")};ft.emit=ft.trigger=function(r,e,t){var a=this.listeners,n=a.length;return this.emitting++,Fe(e)||(e=[e]),vp(this,function(i,s){t!=null&&(a=[{event:s.event,type:s.type,namespace:s.namespace,callback:t}],n=a.length);for(var o=function(){var v=a[u];if(v.type===s.type&&(!v.namespace||v.namespace===s.namespace||v.namespace===up)&&i.eventMatches(i.context,v,s)){var f=[s];e!=null&&Jc(f,e),i.beforeEmit(i.context,v,s),v.conf&&v.conf.one&&(i.listeners=i.listeners.filter(function(d){return d!==v}));var c=i.callbackContext(i.context,v,s),h=v.callback.apply(c,f);i.afterEmit(i.context,v,s),h===!1&&(s.stopPropagation(),s.preventDefault())}},u=0;u1&&!s){var o=this.length-1,u=this[o],l=u._private.data.id;this[o]=void 0,this[e]=u,i.set(l,{ele:u,index:e})}return this.length--,this},unmergeOne:function(e){e=e[0];var t=this._private,a=e._private.data.id,n=t.map,i=n.get(a);if(!i)return this;var s=i.index;return this.unmergeAt(s),this},unmerge:function(e){var t=this._private.cy;if(!e)return this;if(e&&he(e)){var a=e;e=t.mutableElements().filter(a)}for(var n=0;n=0;t--){var a=this[t];e(a)&&this.unmergeAt(t)}return this},map:function(e,t){for(var a=[],n=this,i=0;ia&&(a=u,n=o)}return{value:a,ele:n}},min:function(e,t){for(var a=1/0,n,i=this,s=0;s=0&&i"u"?"undefined":je(Symbol))!=e&&je(Symbol.iterator)!=e;t&&(Tn[Symbol.iterator]=function(){var a=this,n={value:void 0,done:!1},i=0,s=this.length;return Ql({next:function(){return i1&&arguments[1]!==void 0?arguments[1]:!0,a=this[0],n=a.cy();if(n.styleEnabled()&&a){a._private.styleDirty&&(a._private.styleDirty=!1,n.style().apply(a));var i=a._private.style[e];return i??(t?n.style().getDefaultProperty(e):null)}},numericStyle:function(e){var t=this[0];if(t.cy().styleEnabled()&&t){var a=t.pstyle(e);return a.pfValue!==void 0?a.pfValue:a.value}},numericStyleUnits:function(e){var t=this[0];if(t.cy().styleEnabled()&&t)return t.pstyle(e).units},renderedStyle:function(e){var t=this.cy();if(!t.styleEnabled())return this;var a=this[0];if(a)return t.style().getRenderedStyle(a,e)},style:function(e,t){var a=this.cy();if(!a.styleEnabled())return this;var n=!1,i=a.style();if(Me(e)){var s=e;i.applyBypass(this,s,n),this.emitAndNotify("style")}else if(he(e))if(t===void 0){var o=this[0];return o?i.getStylePropertyValue(o,e):void 0}else i.applyBypass(this,e,t,n),this.emitAndNotify("style");else if(e===void 0){var u=this[0];return u?i.getRawStyle(u):void 0}return this},removeStyle:function(e){var t=this.cy();if(!t.styleEnabled())return this;var a=!1,n=t.style(),i=this;if(e===void 0)for(var s=0;s0&&e.push(v[0]),e.push(o[0])}return this.spawn(e,!0).filter(r)},"neighborhood"),closedNeighborhood:function(e){return this.neighborhood().add(this).filter(e)},openNeighborhood:function(e){return this.neighborhood(e)}});cr.neighbourhood=cr.neighborhood;cr.closedNeighbourhood=cr.closedNeighborhood;cr.openNeighbourhood=cr.openNeighborhood;me(cr,{source:Pr(function(e){var t=this[0],a;return t&&(a=t._private.source||t.cy().collection()),a&&e?a.filter(e):a},"source"),target:Pr(function(e){var t=this[0],a;return t&&(a=t._private.target||t.cy().collection()),a&&e?a.filter(e):a},"target"),sources:yl({attr:"source"}),targets:yl({attr:"target"})});function yl(r){return function(t){for(var a=[],n=0;n0);return s},component:function(){var e=this[0];return e.cy().mutableElements().components(e)[0]}});cr.componentsOf=cr.components;var ur=function(e,t){var a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,n=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(e===void 0){Ge("A collection must have a reference to the core");return}var i=new Ur,s=!1;if(!t)t=[];else if(t.length>0&&Me(t[0])&&!Ia(t[0])){s=!0;for(var o=[],u=new ra,l=0,v=t.length;l0&&arguments[0]!==void 0?arguments[0]:!0,e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0,t=this,a=t.cy(),n=a._private,i=[],s=[],o,u=0,l=t.length;u0){for(var F=o.length===t.length?t:new ur(a,o),_=0;_0&&arguments[0]!==void 0?arguments[0]:!0,e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0,t=this,a=[],n={},i=t._private.cy;function s(R){for(var L=R._private.edges,I=0;I0&&(r?D.emitAndNotify("remove"):e&&D.emit("remove"));for(var P=0;P0?P=R:D=R;while(Math.abs(A)>s&&++L=i?m(B,L):I===0?L:w(B,D,D+l)}var C=!1;function x(){C=!0,(r!==e||t!==a)&&b()}var T=function(D){return C||x(),r===e&&t===a?D:D===0?0:D===1?1:g(E(D),e,a)};T.getControlPoints=function(){return[{x:r,y:e},{x:t,y:a}]};var k="generateBezier("+[r,e,t,a]+")";return T.toString=function(){return k},T}/*! Runge-Kutta spring physics function generator. Adapted from Framer.js, copyright Koen Bok. MIT License: http://en.wikipedia.org/wiki/MIT_License */var xp=(function(){function r(a){return-a.tension*a.x-a.friction*a.v}function e(a,n,i){var s={x:a.x+i.dx*n,v:a.v+i.dv*n,tension:a.tension,friction:a.friction};return{dx:s.v,dv:r(s)}}function t(a,n){var i={dx:a.v,dv:r(a)},s=e(a,n*.5,i),o=e(a,n*.5,s),u=e(a,n,o),l=1/6*(i.dx+2*(s.dx+o.dx)+u.dx),v=1/6*(i.dv+2*(s.dv+o.dv)+u.dv);return a.x=a.x+l*n,a.v=a.v+v*n,a}return function a(n,i,s){var o={x:-1,v:0,tension:null,friction:null},u=[0],l=0,v=1/1e4,f=16/1e3,c,h,d;for(n=parseFloat(n)||500,i=parseFloat(i)||20,s=s||null,o.tension=n,o.friction=i,c=s!==null,c?(l=a(n,i),h=l/s*f):h=f;d=t(d||o,h),u.push(1+d.x),l+=16,Math.abs(d.x)>v&&Math.abs(d.v)>v;);return c?function(y){return u[y*(u.length-1)|0]}:l}})(),Ve=function(e,t,a,n){var i=wp(e,t,a,n);return function(s,o,u){return s+(o-s)*i(u)}},fn={linear:function(e,t,a){return e+(t-e)*a},ease:Ve(.25,.1,.25,1),"ease-in":Ve(.42,0,1,1),"ease-out":Ve(0,0,.58,1),"ease-in-out":Ve(.42,0,.58,1),"ease-in-sine":Ve(.47,0,.745,.715),"ease-out-sine":Ve(.39,.575,.565,1),"ease-in-out-sine":Ve(.445,.05,.55,.95),"ease-in-quad":Ve(.55,.085,.68,.53),"ease-out-quad":Ve(.25,.46,.45,.94),"ease-in-out-quad":Ve(.455,.03,.515,.955),"ease-in-cubic":Ve(.55,.055,.675,.19),"ease-out-cubic":Ve(.215,.61,.355,1),"ease-in-out-cubic":Ve(.645,.045,.355,1),"ease-in-quart":Ve(.895,.03,.685,.22),"ease-out-quart":Ve(.165,.84,.44,1),"ease-in-out-quart":Ve(.77,0,.175,1),"ease-in-quint":Ve(.755,.05,.855,.06),"ease-out-quint":Ve(.23,1,.32,1),"ease-in-out-quint":Ve(.86,0,.07,1),"ease-in-expo":Ve(.95,.05,.795,.035),"ease-out-expo":Ve(.19,1,.22,1),"ease-in-out-expo":Ve(1,0,0,1),"ease-in-circ":Ve(.6,.04,.98,.335),"ease-out-circ":Ve(.075,.82,.165,1),"ease-in-out-circ":Ve(.785,.135,.15,.86),spring:function(e,t,a){if(a===0)return fn.linear;var n=xp(e,t,a);return function(i,s,o){return i+(s-i)*n(o)}},"cubic-bezier":Ve};function wl(r,e,t,a,n){if(a===1||e===t)return t;var i=n(e,t,a);return r==null||((r.roundValue||r.color)&&(i=Math.round(i)),r.min!==void 0&&(i=Math.max(i,r.min)),r.max!==void 0&&(i=Math.min(i,r.max))),i}function xl(r,e){return r.pfValue!=null||r.value!=null?r.pfValue!=null&&(e==null||e.type.units!=="%")?r.pfValue:r.value:r}function Ot(r,e,t,a,n){var i=n!=null?n.type:null;t<0?t=0:t>1&&(t=1);var s=xl(r,n),o=xl(e,n);if(ae(s)&&ae(o))return wl(i,s,o,t,a);if(Fe(s)&&Fe(o)){for(var u=[],l=0;l0?(h==="spring"&&d.push(s.duration),s.easingImpl=fn[h].apply(null,d)):s.easingImpl=fn[h]}var y=s.easingImpl,g;if(s.duration===0?g=1:g=(t-u)/s.duration,s.applying&&(g=s.progress),g<0?g=0:g>1&&(g=1),s.delay==null){var p=s.startPosition,m=s.position;if(m&&n&&!r.locked()){var b={};da(p.x,m.x)&&(b.x=Ot(p.x,m.x,g,y)),da(p.y,m.y)&&(b.y=Ot(p.y,m.y,g,y)),r.position(b)}var w=s.startPan,E=s.pan,C=i.pan,x=E!=null&&a;x&&(da(w.x,E.x)&&(C.x=Ot(w.x,E.x,g,y)),da(w.y,E.y)&&(C.y=Ot(w.y,E.y,g,y)),r.emit("pan"));var T=s.startZoom,k=s.zoom,B=k!=null&&a;B&&(da(T,k)&&(i.zoom=ka(i.minZoom,Ot(T,k,g,y),i.maxZoom)),r.emit("zoom")),(x||B)&&r.emit("viewport");var D=s.style;if(D&&D.length>0&&n){for(var P=0;P=0;x--){var T=C[x];T()}C.splice(0,C.length)},m=h.length-1;m>=0;m--){var b=h[m],w=b._private;if(w.stopped){h.splice(m,1),w.hooked=!1,w.playing=!1,w.started=!1,p(w.frames);continue}!w.playing&&!w.applying||(w.playing&&w.applying&&(w.applying=!1),w.started||Cp(v,b,r),Ep(v,b,r,f),w.applying&&(w.applying=!1),p(w.frames),w.step!=null&&w.step(r),b.completed()&&(h.splice(m,1),w.hooked=!1,w.playing=!1,w.started=!1,p(w.completes)),y=!0)}return!f&&h.length===0&&d.length===0&&a.push(v),y}for(var i=!1,s=0;s0?e.notify("draw",t):e.notify("draw")),t.unmerge(a),e.emit("step")}var Tp={animate:Oe.animate(),animation:Oe.animation(),animated:Oe.animated(),clearQueue:Oe.clearQueue(),delay:Oe.delay(),delayAnimation:Oe.delayAnimation(),stop:Oe.stop(),addToAnimationPool:function(e){var t=this;t.styleEnabled()&&t._private.aniEles.merge(e)},stopAnimationLoop:function(){this._private.animationsRunning=!1},startAnimationLoop:function(){var e=this;if(e._private.animationsRunning=!0,!e.styleEnabled())return;function t(){e._private.animationsRunning&&bn(function(i){El(i,e),t()})}var a=e.renderer();a&&a.beforeRender?a.beforeRender(function(i,s){El(s,e)},a.beforeRenderPriorities.animations):t()}},Sp={qualifierCompare:function(e,t){return e==null||t==null?e==null&&t==null:e.sameText(t)},eventMatches:function(e,t,a){var n=t.qualifier;return n!=null?e!==a.target&&Ia(a.target)&&n.matches(a.target):!0},addEventFields:function(e,t){t.cy=e,t.target=e},callbackContext:function(e,t,a){return t.qualifier!=null?a.target:e}},rn=function(e){return he(e)?new lt(e):e},af={createEmitter:function(){var e=this._private;return e.emitter||(e.emitter=new _n(Sp,this)),this},emitter:function(){return this._private.emitter},on:function(e,t,a){return this.emitter().on(e,rn(t),a),this},removeListener:function(e,t,a){return this.emitter().removeListener(e,rn(t),a),this},removeAllListeners:function(){return this.emitter().removeAllListeners(),this},one:function(e,t,a){return this.emitter().one(e,rn(t),a),this},once:function(e,t,a){return this.emitter().one(e,rn(t),a),this},emit:function(e,t){return this.emitter().emit(e,t),this},emitAndNotify:function(e,t){return this.emit(e),this.notify(e,t),this}};Oe.eventAliasesOn(af);var Ns={png:function(e){var t=this._private.renderer;return e=e||{},t.png(e)},jpg:function(e){var t=this._private.renderer;return e=e||{},e.bg=e.bg||"#fff",t.jpg(e)}};Ns.jpeg=Ns.jpg;var cn={layout:function(e){var t=this;if(e==null){Ge("Layout options must be specified to make a layout");return}if(e.name==null){Ge("A `name` must be specified to make a layout");return}var a=e.name,n=t.extension("layout",a);if(n==null){Ge("No such layout `"+a+"` found. Did you forget to import it and `cytoscape.use()` it?");return}var i;he(e.eles)?i=t.$(e.eles):i=e.eles!=null?e.eles:t.$();var s=new n(me({},e,{cy:t,eles:i}));return s}};cn.createLayout=cn.makeLayout=cn.layout;var kp={notify:function(e,t){var a=this._private;if(this.batching()){a.batchNotifications=a.batchNotifications||{};var n=a.batchNotifications[e]=a.batchNotifications[e]||this.collection();t!=null&&n.merge(t);return}if(a.notificationsEnabled){var i=this.renderer();this.destroyed()||!i||i.notify(e,t)}},notifications:function(e){var t=this._private;return e===void 0?t.notificationsEnabled:(t.notificationsEnabled=!!e,this)},noNotifications:function(e){this.notifications(!1),e(),this.notifications(!0)},batching:function(){return this._private.batchCount>0},startBatch:function(){var e=this._private;return e.batchCount==null&&(e.batchCount=0),e.batchCount===0&&(e.batchStyleEles=this.collection(),e.batchNotifications={}),e.batchCount++,this},endBatch:function(){var e=this._private;if(e.batchCount===0)return this;if(e.batchCount--,e.batchCount===0){e.batchStyleEles.updateStyle();var t=this.renderer();Object.keys(e.batchNotifications).forEach(function(a){var n=e.batchNotifications[a];n.empty()?t.notify(a):t.notify(a,n)})}return this},batch:function(e){return this.startBatch(),e(),this.endBatch(),this},batchData:function(e){var t=this;return this.batch(function(){for(var a=Object.keys(e),n=0;n0;)t.removeChild(t.childNodes[0]);e._private.renderer=null,e.mutableElements().forEach(function(a){var n=a._private;n.rscratch={},n.rstyle={},n.animation.current=[],n.animation.queue=[]})},onRender:function(e){return this.on("render",e)},offRender:function(e){return this.off("render",e)}};zs.invalidateDimensions=zs.resize;var dn={collection:function(e,t){return he(e)?this.$(e):Tr(e)?e.collection():Fe(e)?(t||(t={}),new ur(this,e,t.unique,t.removed)):new ur(this)},nodes:function(e){var t=this.$(function(a){return a.isNode()});return e?t.filter(e):t},edges:function(e){var t=this.$(function(a){return a.isEdge()});return e?t.filter(e):t},$:function(e){var t=this._private.elements;return e?t.filter(e):t.spawnSelf()},mutableElements:function(){return this._private.elements}};dn.elements=dn.filter=dn.$;var sr={},wa="t",Bp="f";sr.apply=function(r){for(var e=this,t=e._private,a=t.cy,n=a.collection(),i=0;i0;if(c||f&&h){var d=void 0;c&&h||c?d=l.properties:h&&(d=l.mappedProperties);for(var y=0;y1&&(w=1),o.color){var C=a.valueMin[0],x=a.valueMax[0],T=a.valueMin[1],k=a.valueMax[1],B=a.valueMin[2],D=a.valueMax[2],P=a.valueMin[3]==null?1:a.valueMin[3],A=a.valueMax[3]==null?1:a.valueMax[3],R=[Math.round(C+(x-C)*w),Math.round(T+(k-T)*w),Math.round(B+(D-B)*w),Math.round(P+(A-P)*w)];i={bypass:a.bypass,name:a.name,value:R,strValue:"rgb("+R[0]+", "+R[1]+", "+R[2]+")"}}else if(o.number){var L=a.valueMin+(a.valueMax-a.valueMin)*w;i=this.parse(a.name,L,a.bypass,c)}else return!1;if(!i)return y(),!1;i.mapping=a,a=i;break}case s.data:{for(var I=a.field.split("."),M=f.data,N=0;N0&&i>0){for(var o={},u=!1,l=0;l0?r.delayAnimation(s).play().promise().then(b):b()}).then(function(){return r.animation({style:o,duration:i,easing:r.pstyle("transition-timing-function").value,queue:!1}).play().promise()}).then(function(){t.removeBypasses(r,n),r.emitAndNotify("style"),a.transitioning=!1})}else a.transitioning&&(this.removeBypasses(r,n),r.emitAndNotify("style"),a.transitioning=!1)};sr.checkTrigger=function(r,e,t,a,n,i){var s=this.properties[e],o=n(s);r.removed()||o!=null&&o(t,a,r)&&i(s)};sr.checkZOrderTrigger=function(r,e,t,a){var n=this;this.checkTrigger(r,e,t,a,function(i){return i.triggersZOrder},function(){n._private.cy.notify("zorder",r)})};sr.checkBoundsTrigger=function(r,e,t,a){this.checkTrigger(r,e,t,a,function(n){return n.triggersBounds},function(n){r.dirtyCompoundBoundsCache(),r.dirtyBoundingBoxCache()})};sr.checkConnectedEdgesBoundsTrigger=function(r,e,t,a){this.checkTrigger(r,e,t,a,function(n){return n.triggersBoundsOfConnectedEdges},function(n){r.connectedEdges().forEach(function(i){i.dirtyBoundingBoxCache()})})};sr.checkParallelEdgesBoundsTrigger=function(r,e,t,a){this.checkTrigger(r,e,t,a,function(n){return n.triggersBoundsOfParallelEdges},function(n){r.parallelEdges().forEach(function(i){i.dirtyBoundingBoxCache()})})};sr.checkTriggers=function(r,e,t,a){r.dirtyStyleCache(),this.checkZOrderTrigger(r,e,t,a),this.checkBoundsTrigger(r,e,t,a),this.checkConnectedEdgesBoundsTrigger(r,e,t,a),this.checkParallelEdgesBoundsTrigger(r,e,t,a)};var _a={};_a.applyBypass=function(r,e,t,a){var n=this,i=[],s=!0;if(e==="*"||e==="**"){if(t!==void 0)for(var o=0;on.length?a=a.substr(n.length):a=""}function u(){i.length>s.length?i=i.substr(s.length):i=""}for(;;){var l=a.match(/^\s*$/);if(l)break;var v=a.match(/^\s*((?:.|\s)+?)\s*\{((?:.|\s)+?)\}/);if(!v){Ne("Halting stylesheet parsing: String stylesheet contains more to parse but no selector and block found in: "+a);break}n=v[0];var f=v[1];if(f!=="core"){var c=new lt(f);if(c.invalid){Ne("Skipping parsing of block: Invalid selector found in string stylesheet: "+f),o();continue}}var h=v[2],d=!1;i=h;for(var y=[];;){var g=i.match(/^\s*$/);if(g)break;var p=i.match(/^\s*(.+?)\s*:\s*(.+?)(?:\s*;|\s*$)/);if(!p){Ne("Skipping parsing of block: Invalid formatting of style property and value definitions found in:"+h),d=!0;break}s=p[0];var m=p[1],b=p[2],w=e.properties[m];if(!w){Ne("Skipping property: Invalid property name in: "+s),u();continue}var E=t.parse(m,b);if(!E){Ne("Skipping property: Invalid property definition in: "+s),u();continue}y.push({name:m,val:b}),u()}if(d){o();break}t.selector(f);for(var C=0;C=7&&e[0]==="d"&&(v=new RegExp(o.data.regex).exec(e))){if(t)return!1;var c=o.data;return{name:r,value:v,strValue:""+e,mapped:c,field:v[1],bypass:t}}else if(e.length>=10&&e[0]==="m"&&(f=new RegExp(o.mapData.regex).exec(e))){if(t||l.multiple)return!1;var h=o.mapData;if(!(l.color||l.number))return!1;var d=this.parse(r,f[4]);if(!d||d.mapped)return!1;var y=this.parse(r,f[5]);if(!y||y.mapped)return!1;if(d.pfValue===y.pfValue||d.strValue===y.strValue)return Ne("`"+r+": "+e+"` is not a valid mapper because the output range is zero; converting to `"+r+": "+d.strValue+"`"),this.parse(r,d.strValue);if(l.color){var g=d.value,p=y.value,m=g[0]===p[0]&&g[1]===p[1]&&g[2]===p[2]&&(g[3]===p[3]||(g[3]==null||g[3]===1)&&(p[3]==null||p[3]===1));if(m)return!1}return{name:r,value:f,strValue:""+e,mapped:h,field:f[1],fieldMin:parseFloat(f[2]),fieldMax:parseFloat(f[3]),valueMin:d.value,valueMax:y.value,bypass:t}}}if(l.multiple&&a!=="multiple"){var b;if(u?b=e.split(/\s+/):Fe(e)?b=e:b=[e],l.evenMultiple&&b.length%2!==0)return null;for(var w=[],E=[],C=[],x="",T=!1,k=0;k0?" ":"")+B.strValue}return l.validate&&!l.validate(w,E)?null:l.singleEnum&&T?w.length===1&&he(w[0])?{name:r,value:w[0],strValue:w[0],bypass:t}:null:{name:r,value:w,pfValue:C,strValue:x,bypass:t,units:E}}var D=function(){for(var Y=0;Yl.max||l.strictMax&&e===l.max))return null;var I={name:r,value:e,strValue:""+e+(P||""),units:P,bypass:t};return l.unitless||P!=="px"&&P!=="em"?I.pfValue=e:I.pfValue=P==="px"||!P?e:this.getEmSizeInPixels()*e,(P==="ms"||P==="s")&&(I.pfValue=P==="ms"?e:1e3*e),(P==="deg"||P==="rad")&&(I.pfValue=P==="rad"?e:Td(e)),P==="%"&&(I.pfValue=e/100),I}else if(l.propList){var M=[],N=""+e;if(N!=="none"){for(var F=N.split(/\s*,\s*|\s+/),_=0;_0&&o>0&&!isNaN(a.w)&&!isNaN(a.h)&&a.w>0&&a.h>0){u=Math.min((s-2*t)/a.w,(o-2*t)/a.h),u=u>this._private.maxZoom?this._private.maxZoom:u,u=u=a.minZoom&&(a.maxZoom=t),this},minZoom:function(e){return e===void 0?this._private.minZoom:this.zoomRange({min:e})},maxZoom:function(e){return e===void 0?this._private.maxZoom:this.zoomRange({max:e})},getZoomedViewport:function(e){var t=this._private,a=t.pan,n=t.zoom,i,s,o=!1;if(t.zoomingEnabled||(o=!0),ae(e)?s=e:Me(e)&&(s=e.level,e.position!=null?i=In(e.position,n,a):e.renderedPosition!=null&&(i=e.renderedPosition),i!=null&&!t.panningEnabled&&(o=!0)),s=s>t.maxZoom?t.maxZoom:s,s=st.maxZoom||!t.zoomingEnabled?s=!0:(t.zoom=u,i.push("zoom"))}if(n&&(!s||!e.cancelOnFailedZoom)&&t.panningEnabled){var l=e.pan;ae(l.x)&&(t.pan.x=l.x,o=!1),ae(l.y)&&(t.pan.y=l.y,o=!1),o||i.push("pan")}return i.length>0&&(i.push("viewport"),this.emit(i.join(" ")),this.notify("viewport")),this},center:function(e){var t=this.getCenterPan(e);return t&&(this._private.pan=t,this.emit("pan viewport"),this.notify("viewport")),this},getCenterPan:function(e,t){if(this._private.panningEnabled){if(he(e)){var a=e;e=this.mutableElements().filter(a)}else Tr(e)||(e=this.mutableElements());if(e.length!==0){var n=e.boundingBox(),i=this.width(),s=this.height();t=t===void 0?this._private.zoom:t;var o={x:(i-t*(n.x1+n.x2))/2,y:(s-t*(n.y1+n.y2))/2};return o}}},reset:function(){return!this._private.panningEnabled||!this._private.zoomingEnabled?this:(this.viewport({pan:{x:0,y:0},zoom:1}),this)},invalidateSize:function(){this._private.sizeCache=null},size:function(){var e=this._private,t=e.container,a=this;return e.sizeCache=e.sizeCache||(t?(function(){var n=a.window().getComputedStyle(t),i=function(o){return parseFloat(n.getPropertyValue(o))};return{width:t.clientWidth-i("padding-left")-i("padding-right"),height:t.clientHeight-i("padding-top")-i("padding-bottom")}})():{width:1,height:1})},width:function(){return this.size().width},height:function(){return this.size().height},extent:function(){var e=this._private.pan,t=this._private.zoom,a=this.renderedExtent(),n={x1:(a.x1-e.x)/t,x2:(a.x2-e.x)/t,y1:(a.y1-e.y)/t,y2:(a.y2-e.y)/t};return n.w=n.x2-n.x1,n.h=n.y2-n.y1,n},renderedExtent:function(){var e=this.width(),t=this.height();return{x1:0,y1:0,x2:e,y2:t,w:e,h:t}},multiClickDebounceTime:function(e){if(e)this._private.multiClickDebounceTime=e;else return this._private.multiClickDebounceTime;return this}};Bt.centre=Bt.center;Bt.autolockNodes=Bt.autolock;Bt.autoungrabifyNodes=Bt.autoungrabify;var Aa={data:Oe.data({field:"data",bindingEvent:"data",allowBinding:!0,allowSetting:!0,settingEvent:"data",settingTriggersEvent:!0,triggerFnName:"trigger",allowGetting:!0,updateStyle:!0}),removeData:Oe.removeData({field:"data",event:"data",triggerFnName:"trigger",triggerEvent:!0,updateStyle:!0}),scratch:Oe.data({field:"scratch",bindingEvent:"scratch",allowBinding:!0,allowSetting:!0,settingEvent:"scratch",settingTriggersEvent:!0,triggerFnName:"trigger",allowGetting:!0,updateStyle:!0}),removeScratch:Oe.removeData({field:"scratch",event:"scratch",triggerFnName:"trigger",triggerEvent:!0,updateStyle:!0})};Aa.attr=Aa.data;Aa.removeAttr=Aa.removeData;var Ra=function(e){var t=this;e=me({},e);var a=e.container;a&&!mn(a)&&mn(a[0])&&(a=a[0]);var n=a?a._cyreg:null;n=n||{},n&&n.cy&&(n.cy.destroy(),n={});var i=n.readies=n.readies||[];a&&(a._cyreg=n),n.cy=t;var s=Qe!==void 0&&a!==void 0&&!e.headless,o=e;o.layout=me({name:s?"grid":"null"},o.layout),o.renderer=me({name:s?"canvas":"null"},o.renderer);var u=function(d,y,g){return y!==void 0?y:g!==void 0?g:d},l=this._private={container:a,ready:!1,options:o,elements:new ur(this),listeners:[],aniEles:new ur(this),data:o.data||{},scratch:{},layout:null,renderer:null,destroyed:!1,notificationsEnabled:!0,minZoom:1e-50,maxZoom:1e50,zoomingEnabled:u(!0,o.zoomingEnabled),userZoomingEnabled:u(!0,o.userZoomingEnabled),panningEnabled:u(!0,o.panningEnabled),userPanningEnabled:u(!0,o.userPanningEnabled),boxSelectionEnabled:u(!0,o.boxSelectionEnabled),autolock:u(!1,o.autolock,o.autolockNodes),autoungrabify:u(!1,o.autoungrabify,o.autoungrabifyNodes),autounselectify:u(!1,o.autounselectify),styleEnabled:o.styleEnabled===void 0?s:o.styleEnabled,zoom:ae(o.zoom)?o.zoom:1,pan:{x:Me(o.pan)&&ae(o.pan.x)?o.pan.x:0,y:Me(o.pan)&&ae(o.pan.y)?o.pan.y:0},animation:{current:[],queue:[]},hasCompoundNodes:!1,multiClickDebounceTime:u(250,o.multiClickDebounceTime)};this.createEmitter(),this.selectionType(o.selectionType),this.zoomRange({min:o.minZoom,max:o.maxZoom});var v=function(d,y){var g=d.some(yc);if(g)return ta.all(d).then(y);y(d)};l.styleEnabled&&t.setStyle([]);var f=me({},o,o.renderer);t.initRenderer(f);var c=function(d,y,g){t.notifications(!1);var p=t.mutableElements();p.length>0&&p.remove(),d!=null&&(Me(d)||Fe(d))&&t.add(d),t.one("layoutready",function(b){t.notifications(!0),t.emit(b),t.one("load",y),t.emitAndNotify("load")}).one("layoutstop",function(){t.one("done",g),t.emit("done")});var m=me({},t._private.options.layout);m.eles=t.elements(),t.layout(m).run()};v([o.style,o.elements],function(h){var d=h[0],y=h[1];l.styleEnabled&&t.style().append(d),c(y,function(){t.startAnimationLoop(),l.ready=!0,He(o.ready)&&t.on("ready",o.ready);for(var g=0;g0,o=!!r.boundingBox,u=yr(o?r.boundingBox:structuredClone(e.extent())),l;if(Tr(r.roots))l=r.roots;else if(Fe(r.roots)){for(var v=[],f=0;f0;){var R=A(),L=k(R,D);if(L)R.outgoers().filter(function(pe){return pe.isNode()&&t.has(pe)}).forEach(P);else if(L===null){Ne("Detected double maximal shift for node `"+R.id()+"`. Bailing maximal adjustment due to cycle. Use `options.maximal: true` only on DAGs.");break}}}var I=0;if(r.avoidOverlap)for(var M=0;M0&&p[0].length<=3?be/2:0),Be=2*Math.PI/p[ge].length*Ee;return ge===0&&p[0].length===1&&(Te=1),{x:$.x+Te*Math.cos(Be),y:$.y+Te*Math.sin(Be)}}else{var Ae=p[ge].length,Le=Math.max(Ae===1?0:o?(u.w-r.padding*2-K.w)/((r.grid?ve:Ae)-1):(u.w-r.padding*2-K.w)/((r.grid?ve:Ae)+1),I),ee={x:$.x+(Ee+1-(Ae+1)/2)*Le,y:$.y+(ge+1-(X+1)/2)*te};return ee}},we={downward:0,leftward:90,upward:180,rightward:-90};Object.keys(we).indexOf(r.direction)===-1&&Ge("Invalid direction '".concat(r.direction,"' specified for breadthfirst layout. Valid values are: ").concat(Object.keys(we).join(", ")));var ye=function(se){return Uc(De(se),u,we[r.direction])};return t.nodes().layoutPositions(this,r,ye),this};var Lp={fit:!0,padding:30,boundingBox:void 0,avoidOverlap:!0,nodeDimensionsIncludeLabels:!1,spacingFactor:void 0,radius:void 0,startAngle:3/2*Math.PI,sweep:void 0,clockwise:!0,sort:void 0,animate:!1,animationDuration:500,animationEasing:void 0,animateFilter:function(e,t){return!0},ready:void 0,stop:void 0,transform:function(e,t){return t}};function sf(r){this.options=me({},Lp,r)}sf.prototype.run=function(){var r=this.options,e=r,t=r.cy,a=e.eles,n=e.counterclockwise!==void 0?!e.counterclockwise:e.clockwise,i=a.nodes().not(":parent");e.sort&&(i=i.sort(e.sort));for(var s=yr(e.boundingBox?e.boundingBox:{x1:0,y1:0,w:t.width(),h:t.height()}),o={x:s.x1+s.w/2,y:s.y1+s.h/2},u=e.sweep===void 0?2*Math.PI-2*Math.PI/i.length:e.sweep,l=u/Math.max(1,i.length-1),v,f=0,c=0;c1&&e.avoidOverlap){f*=1.75;var p=Math.cos(l)-Math.cos(0),m=Math.sin(l)-Math.sin(0),b=Math.sqrt(f*f/(p*p+m*m));v=Math.max(b,v)}var w=function(C,x){var T=e.startAngle+x*l*(n?1:-1),k=v*Math.cos(T),B=v*Math.sin(T),D={x:o.x+k,y:o.y+B};return D};return a.nodes().layoutPositions(this,e,w),this};var Ip={fit:!0,padding:30,startAngle:3/2*Math.PI,sweep:void 0,clockwise:!0,equidistant:!1,minNodeSpacing:10,boundingBox:void 0,avoidOverlap:!0,nodeDimensionsIncludeLabels:!1,height:void 0,width:void 0,spacingFactor:void 0,concentric:function(e){return e.degree()},levelWidth:function(e){return e.maxDegree()/4},animate:!1,animationDuration:500,animationEasing:void 0,animateFilter:function(e,t){return!0},ready:void 0,stop:void 0,transform:function(e,t){return t}};function of(r){this.options=me({},Ip,r)}of.prototype.run=function(){for(var r=this.options,e=r,t=e.counterclockwise!==void 0?!e.counterclockwise:e.clockwise,a=r.cy,n=e.eles,i=n.nodes().not(":parent"),s=yr(e.boundingBox?e.boundingBox:{x1:0,y1:0,w:a.width(),h:a.height()}),o={x:s.x1+s.w/2,y:s.y1+s.h/2},u=[],l=0,v=0;v0){var E=Math.abs(m[0].value-w.value);E>=g&&(m=[],p.push(m))}m.push(w)}var C=l+e.minNodeSpacing;if(!e.avoidOverlap){var x=p.length>0&&p[0].length>1,T=Math.min(s.w,s.h)/2-C,k=T/(p.length+x?1:0);C=Math.min(C,k)}for(var B=0,D=0;D1&&e.avoidOverlap){var L=Math.cos(R)-Math.cos(0),I=Math.sin(R)-Math.sin(0),M=Math.sqrt(C*C/(L*L+I*I));B=Math.max(M,B)}P.r=B,B+=C}if(e.equidistant){for(var N=0,F=0,_=0;_=r.numIter||(_p(a,r),a.temperature=a.temperature*r.coolingFactor,a.temperature=r.animationThreshold&&i(),bn(v)}};v()}else{for(;l;)l=s(u),u++;Sl(a,r),o()}return this};Un.prototype.stop=function(){return this.stopped=!0,this.thread&&this.thread.stop(),this.emit("layoutstop"),this};Un.prototype.destroy=function(){return this.thread&&this.thread.stop(),this};var Np=function(e,t,a){for(var n=a.eles.edges(),i=a.eles.nodes(),s=yr(a.boundingBox?a.boundingBox:{x1:0,y1:0,w:e.width(),h:e.height()}),o={isCompound:e.hasCompoundNodes(),layoutNodes:[],idToIndex:{},nodeSize:i.size(),graphSet:[],indexToGraph:[],layoutEdges:[],edgeSize:n.size(),temperature:a.initialTemp,clientWidth:s.w,clientHeight:s.h,boundingBox:s},u=a.eles.components(),l={},v=0;v0){o.graphSet.push(T);for(var v=0;vn.count?0:n.graph},uf=function(e,t,a,n){var i=n.graphSet[a];if(-10)var f=n.nodeOverlap*v,c=Math.sqrt(o*o+u*u),h=f*o/c,d=f*u/c;else var y=kn(e,o,u),g=kn(t,-1*o,-1*u),p=g.x-y.x,m=g.y-y.y,b=p*p+m*m,c=Math.sqrt(b),f=(e.nodeRepulsion+t.nodeRepulsion)/b,h=f*p/c,d=f*m/c;e.isLocked||(e.offsetX-=h,e.offsetY-=d),t.isLocked||(t.offsetX+=h,t.offsetY+=d)}},Wp=function(e,t,a,n){if(a>0)var i=e.maxX-t.minX;else var i=t.maxX-e.minX;if(n>0)var s=e.maxY-t.minY;else var s=t.maxY-e.minY;return i>=0&&s>=0?Math.sqrt(i*i+s*s):0},kn=function(e,t,a){var n=e.positionX,i=e.positionY,s=e.height||1,o=e.width||1,u=a/t,l=s/o,v={};return t===0&&0a?(v.x=n,v.y=i+s/2,v):0t&&-1*l<=u&&u<=l?(v.x=n-o/2,v.y=i-o*a/2/t,v):0=l)?(v.x=n+s*t/2/a,v.y=i+s/2,v):(0>a&&(u<=-1*l||u>=l)&&(v.x=n-s*t/2/a,v.y=i-s/2),v)},$p=function(e,t){for(var a=0;aa){var g=t.gravity*h/y,p=t.gravity*d/y;c.offsetX+=g,c.offsetY+=p}}}}},Kp=function(e,t){var a=[],n=0,i=-1;for(a.push.apply(a,e.graphSet[0]),i+=e.graphSet[0].length;n<=i;){var s=a[n++],o=e.idToIndex[s],u=e.layoutNodes[o],l=u.children;if(0a)var i={x:a*e/n,y:a*t/n};else var i={x:e,y:t};return i},vf=function(e,t){var a=e.parentId;if(a!=null){var n=t.layoutNodes[t.idToIndex[a]],i=!1;if((n.maxX==null||e.maxX+n.padRight>n.maxX)&&(n.maxX=e.maxX+n.padRight,i=!0),(n.minX==null||e.minX-n.padLeftn.maxY)&&(n.maxY=e.maxY+n.padBottom,i=!0),(n.minY==null||e.minY-n.padTopp&&(d+=g+t.componentSpacing,h=0,y=0,g=0)}}},Zp={fit:!0,padding:30,boundingBox:void 0,avoidOverlap:!0,avoidOverlapPadding:10,nodeDimensionsIncludeLabels:!1,spacingFactor:void 0,condense:!1,rows:void 0,cols:void 0,position:function(e){},sort:void 0,animate:!1,animationDuration:500,animationEasing:void 0,animateFilter:function(e,t){return!0},ready:void 0,stop:void 0,transform:function(e,t){return t}};function ff(r){this.options=me({},Zp,r)}ff.prototype.run=function(){var r=this.options,e=r,t=r.cy,a=e.eles,n=a.nodes().not(":parent");e.sort&&(n=n.sort(e.sort));var i=yr(e.boundingBox?e.boundingBox:{x1:0,y1:0,w:t.width(),h:t.height()});if(i.h===0||i.w===0)a.nodes().layoutPositions(this,e,function(Z){return{x:i.x1,y:i.y1}});else{var s=n.size(),o=Math.sqrt(s*i.h/i.w),u=Math.round(o),l=Math.round(i.w/i.h*o),v=function(Q){if(Q==null)return Math.min(u,l);var X=Math.min(u,l);X==u?u=Q:l=Q},f=function(Q){if(Q==null)return Math.max(u,l);var X=Math.max(u,l);X==u?u=Q:l=Q},c=e.rows,h=e.cols!=null?e.cols:e.columns;if(c!=null&&h!=null)u=c,l=h;else if(c!=null&&h==null)u=c,l=Math.ceil(s/u);else if(c==null&&h!=null)l=h,u=Math.ceil(s/l);else if(l*u>s){var d=v(),y=f();(d-1)*y>=s?v(d-1):(y-1)*d>=s&&f(y-1)}else for(;l*u=s?f(p+1):v(g+1)}var m=i.w/l,b=i.h/u;if(e.condense&&(m=0,b=0),e.avoidOverlap)for(var w=0;w=l&&(L=0,R++)},M={},N=0;N(L=Fd(r,e,I[M],I[M+1],I[M+2],I[M+3])))return g(x,L),!0}else if(k.edgeType==="bezier"||k.edgeType==="multibezier"||k.edgeType==="self"||k.edgeType==="compound"){for(var I=k.allpts,M=0;M+5(L=zd(r,e,I[M],I[M+1],I[M+2],I[M+3],I[M+4],I[M+5])))return g(x,L),!0}for(var N=N||T.source,F=F||T.target,_=n.getArrowWidth(B,D),z=[{name:"source",x:k.arrowStartX,y:k.arrowStartY,angle:k.srcArrowAngle},{name:"target",x:k.arrowEndX,y:k.arrowEndY,angle:k.tgtArrowAngle},{name:"mid-source",x:k.midX,y:k.midY,angle:k.midsrcArrowAngle},{name:"mid-target",x:k.midX,y:k.midY,angle:k.midtgtArrowAngle}],M=0;M0&&(p(N),p(F))}function b(x,T,k){return pr(x,T,k)}function w(x,T){var k=x._private,B=c,D;T?D=T+"-":D="",x.boundingBox();var P=k.labelBounds[T||"main"],A=x.pstyle(D+"label").value,R=x.pstyle("text-events").strValue==="yes";if(!(!R||!A)){var L=b(k.rscratch,"labelX",T),I=b(k.rscratch,"labelY",T),M=b(k.rscratch,"labelAngle",T),N=x.pstyle(D+"text-margin-x").pfValue,F=x.pstyle(D+"text-margin-y").pfValue,_=P.x1-B-N,z=P.x2+B-N,q=P.y1-B-F,Z=P.y2+B-F;if(M){var Q=Math.cos(M),X=Math.sin(M),J=function(K,te){return K=K-L,te=te-I,{x:K*Q-te*X+L,y:K*X+te*Q+I}},j=J(_,q),ne=J(_,Z),Y=J(z,q),V=J(z,Z),H=[j.x+N,j.y+F,Y.x+N,Y.y+F,V.x+N,V.y+F,ne.x+N,ne.y+F];if(Er(r,e,H))return g(x),!0}else if(tt(P,r,e))return g(x),!0}}for(var E=s.length-1;E>=0;E--){var C=s[E];C.isNode()?p(C)||w(C):m(C)||w(C)||w(C,"source")||w(C,"target")}return o};At.getAllInBox=function(r,e,t,a){var n=this.getCachedZSortedEles().interactive,i=this.cy.zoom(),s=2/i,o=[],u=Math.min(r,t),l=Math.max(r,t),v=Math.min(e,a),f=Math.max(e,a);r=u,t=l,e=v,a=f;var c=yr({x1:r,y1:e,x2:t,y2:a}),h=[{x:c.x1,y:c.y1},{x:c.x2,y:c.y1},{x:c.x2,y:c.y2},{x:c.x1,y:c.y2}],d=[[h[0],h[1]],[h[1],h[2]],[h[2],h[3]],[h[3],h[0]]];function y(K,te,ve){return pr(K,te,ve)}function g(K,te){var ve=K._private,De=s,we="";K.boundingBox();var ye=ve.labelBounds.main;if(!ye)return null;var pe=y(ve.rscratch,"labelX",te),se=y(ve.rscratch,"labelY",te),de=y(ve.rscratch,"labelAngle",te),ge=K.pstyle(we+"text-margin-x").pfValue,Ee=K.pstyle(we+"text-margin-y").pfValue,be=ye.x1-De-ge,Te=ye.x2+De-ge,Be=ye.y1-De-Ee,Ae=ye.y2+De-Ee;if(de){var Le=Math.cos(de),ee=Math.sin(de),S=function(W,G){return W=W-pe,G=G-se,{x:W*Le-G*ee+pe,y:W*ee+G*Le+se}};return[S(be,Be),S(Te,Be),S(Te,Ae),S(be,Ae)]}else return[{x:be,y:Be},{x:Te,y:Be},{x:Te,y:Ae},{x:be,y:Ae}]}function p(K,te,ve,De){function we(ye,pe,se){return(se.y-ye.y)*(pe.x-ye.x)>(pe.y-ye.y)*(se.x-ye.x)}return we(K,ve,De)!==we(te,ve,De)&&we(K,te,ve)!==we(K,te,De)}for(var m=0;m0?-(Math.PI-e.ang):Math.PI+e.ang},ty=function(e,t,a,n,i){if(e!==Al?Rl(t,e,Vr):ry(Dr,Vr),Rl(t,a,Dr),Bl=Vr.nx*Dr.ny-Vr.ny*Dr.nx,Pl=Vr.nx*Dr.nx-Vr.ny*-Dr.ny,$r=Math.asin(Math.max(-1,Math.min(1,Bl))),Math.abs($r)<1e-6){Fs=t.x,Vs=t.y,xt=zt=0;return}Ct=1,hn=!1,Pl<0?$r<0?$r=Math.PI+$r:($r=Math.PI-$r,Ct=-1,hn=!0):$r>0&&(Ct=-1,hn=!0),t.radius!==void 0?zt=t.radius:zt=n,mt=$r/2,tn=Math.min(Vr.len/2,Dr.len/2),i?(zr=Math.abs(Math.cos(mt)*zt/Math.sin(mt)),zr>tn?(zr=tn,xt=Math.abs(zr*Math.sin(mt)/Math.cos(mt))):xt=zt):(zr=Math.min(tn,zt),xt=Math.abs(zr*Math.sin(mt)/Math.cos(mt))),qs=t.x+Dr.nx*zr,_s=t.y+Dr.ny*zr,Fs=qs-Dr.ny*xt*Ct,Vs=_s+Dr.nx*xt*Ct,gf=t.x+Vr.nx*zr,pf=t.y+Vr.ny*zr,Al=t};function yf(r,e){e.radius===0?r.lineTo(e.cx,e.cy):r.arc(e.cx,e.cy,e.radius,e.startAngle,e.endAngle,e.counterClockwise)}function go(r,e,t,a){var n=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0;return a===0||e.radius===0?{cx:e.x,cy:e.y,radius:0,startX:e.x,startY:e.y,stopX:e.x,stopY:e.y,startAngle:void 0,endAngle:void 0,counterClockwise:void 0}:(ty(r,e,t,a,n),{cx:Fs,cy:Vs,radius:xt,startX:gf,startY:pf,stopX:qs,stopY:_s,startAngle:Vr.ang+Math.PI/2*Ct,endAngle:Dr.ang-Math.PI/2*Ct,counterClockwise:hn})}var Ma=.01,ay=Math.sqrt(2*Ma),hr={};hr.findMidptPtsEtc=function(r,e){var t=e.posPts,a=e.intersectionPts,n=e.vectorNormInverse,i,s=r.pstyle("source-endpoint"),o=r.pstyle("target-endpoint"),u=s.units!=null&&o.units!=null,l=function(E,C,x,T){var k=T-C,B=x-E,D=Math.sqrt(B*B+k*k);return{x:-k/D,y:B/D}},v=r.pstyle("edge-distances").value;switch(v){case"node-position":i=t;break;case"intersection":i=a;break;case"endpoints":{if(u){var f=this.manualEndptToPx(r.source()[0],s),c=Xe(f,2),h=c[0],d=c[1],y=this.manualEndptToPx(r.target()[0],o),g=Xe(y,2),p=g[0],m=g[1],b={x1:h,y1:d,x2:p,y2:m};n=l(h,d,p,m),i=b}else Ne("Edge ".concat(r.id()," has edge-distances:endpoints specified without manual endpoints specified via source-endpoint and target-endpoint. Falling back on edge-distances:intersection (default).")),i=a;break}}return{midptPts:i,vectorNormInverse:n}};hr.findHaystackPoints=function(r){for(var e=0;e0?Math.max(G-U,0):Math.min(G+U,0)},A=P(B,T),R=P(D,k),L=!1;m===l?p=Math.abs(A)>Math.abs(R)?n:a:m===u||m===o?(p=a,L=!0):(m===i||m===s)&&(p=n,L=!0);var I=p===a,M=I?R:A,N=I?D:B,F=ro(N),_=!1;!(L&&(w||C))&&(m===o&&N<0||m===u&&N>0||m===i&&N>0||m===s&&N<0)&&(F*=-1,M=F*Math.abs(M),_=!0);var z;if(w){var q=E<0?1+E:E;z=q*M}else{var Z=E<0?M:0;z=Z+E*F}var Q=function(G){return Math.abs(G)=Math.abs(M)},X=Q(z),J=Q(Math.abs(M)-Math.abs(z)),j=X||J;if(j&&!_)if(I){var ne=Math.abs(N)<=c/2,Y=Math.abs(B)<=h/2;if(ne){var V=(v.x1+v.x2)/2,H=v.y1,$=v.y2;t.segpts=[V,H,V,$]}else if(Y){var K=(v.y1+v.y2)/2,te=v.x1,ve=v.x2;t.segpts=[te,K,ve,K]}else t.segpts=[v.x1,v.y2]}else{var De=Math.abs(N)<=f/2,we=Math.abs(D)<=d/2;if(De){var ye=(v.y1+v.y2)/2,pe=v.x1,se=v.x2;t.segpts=[pe,ye,se,ye]}else if(we){var de=(v.x1+v.x2)/2,ge=v.y1,Ee=v.y2;t.segpts=[de,ge,de,Ee]}else t.segpts=[v.x2,v.y1]}else if(I){var be=v.y1+z+(g?c/2*F:0),Te=v.x1,Be=v.x2;t.segpts=[Te,be,Be,be]}else{var Ae=v.x1+z+(g?f/2*F:0),Le=v.y1,ee=v.y2;t.segpts=[Ae,Le,Ae,ee]}if(t.isRound){var S=r.pstyle("taxi-radius").value,O=r.pstyle("radius-type").value[0]==="arc-radius";t.radii=new Array(t.segpts.length/2).fill(S),t.isArcRadius=new Array(t.segpts.length/2).fill(O)}};hr.tryToCorrectInvalidPoints=function(r,e){var t=r._private.rscratch;if(t.edgeType==="bezier"){var a=e.srcPos,n=e.tgtPos,i=e.srcW,s=e.srcH,o=e.tgtW,u=e.tgtH,l=e.srcShape,v=e.tgtShape,f=e.srcCornerRadius,c=e.tgtCornerRadius,h=e.srcRs,d=e.tgtRs,y=!ae(t.startX)||!ae(t.startY),g=!ae(t.arrowStartX)||!ae(t.arrowStartY),p=!ae(t.endX)||!ae(t.endY),m=!ae(t.arrowEndX)||!ae(t.arrowEndY),b=3,w=this.getArrowWidth(r.pstyle("width").pfValue,r.pstyle("arrow-scale").value)*this.arrowShapeWidth,E=b*w,C=kt({x:t.ctrlpts[0],y:t.ctrlpts[1]},{x:t.startX,y:t.startY}),x=CN.poolIndex()){var F=M;M=N,N=F}var _=A.srcPos=M.position(),z=A.tgtPos=N.position(),q=A.srcW=M.outerWidth(),Z=A.srcH=M.outerHeight(),Q=A.tgtW=N.outerWidth(),X=A.tgtH=N.outerHeight(),J=A.srcShape=t.nodeShapes[e.getNodeShape(M)],j=A.tgtShape=t.nodeShapes[e.getNodeShape(N)],ne=A.srcCornerRadius=M.pstyle("corner-radius").value==="auto"?"auto":M.pstyle("corner-radius").pfValue,Y=A.tgtCornerRadius=N.pstyle("corner-radius").value==="auto"?"auto":N.pstyle("corner-radius").pfValue,V=A.tgtRs=N._private.rscratch,H=A.srcRs=M._private.rscratch;A.dirCounts={north:0,west:0,south:0,east:0,northwest:0,southwest:0,northeast:0,southeast:0};for(var $=0;$=ay||(Be=Math.sqrt(Math.max(Te*Te,Ma)+Math.max(be*be,Ma)));var Ae=A.vector={x:Te,y:be},Le=A.vectorNorm={x:Ae.x/Be,y:Ae.y/Be},ee={x:-Le.y,y:Le.x};A.nodesOverlap=!ae(Be)||j.checkPoint(ye[0],ye[1],0,Q,X,z.x,z.y,Y,V)||J.checkPoint(se[0],se[1],0,q,Z,_.x,_.y,ne,H),A.vectorNormInverse=ee,R={nodesOverlap:A.nodesOverlap,dirCounts:A.dirCounts,calculatedIntersection:!0,hasBezier:A.hasBezier,hasUnbundled:A.hasUnbundled,eles:A.eles,srcPos:z,srcRs:V,tgtPos:_,tgtRs:H,srcW:Q,srcH:X,tgtW:q,tgtH:Z,srcIntn:de,tgtIntn:pe,srcShape:j,tgtShape:J,posPts:{x1:Ee.x2,y1:Ee.y2,x2:Ee.x1,y2:Ee.y1},intersectionPts:{x1:ge.x2,y1:ge.y2,x2:ge.x1,y2:ge.y1},vector:{x:-Ae.x,y:-Ae.y},vectorNorm:{x:-Le.x,y:-Le.y},vectorNormInverse:{x:-ee.x,y:-ee.y}}}var S=we?R:A;te.nodesOverlap=S.nodesOverlap,te.srcIntn=S.srcIntn,te.tgtIntn=S.tgtIntn,te.isRound=ve.startsWith("round"),n&&(M.isParent()||M.isChild()||N.isParent()||N.isChild())&&(M.parents().anySame(N)||N.parents().anySame(M)||M.same(N)&&M.isParent())?e.findCompoundLoopPoints(K,S,$,De):M===N?e.findLoopPoints(K,S,$,De):ve.endsWith("segments")?e.findSegmentsPoints(K,S):ve.endsWith("taxi")?e.findTaxiPoints(K,S):ve==="straight"||!De&&A.eles.length%2===1&&$===Math.floor(A.eles.length/2)?e.findStraightEdgePoints(K):e.findBezierPoints(K,S,$,De,we),e.findEndpoints(K),e.tryToCorrectInvalidPoints(K,S),e.checkForInvalidEdgeWarning(K),e.storeAllpts(K),e.storeEdgeProjections(K),e.calculateArrowAngles(K),e.recalculateEdgeLabelProjections(K),e.calculateLabelAngles(K)}},x=0;x0){var ye=l,pe=wt(ye,Gt(s)),se=wt(ye,Gt(we)),de=pe;if(se2){var ge=wt(ye,{x:we[2],y:we[3]});ge0){var ue=v,re=wt(ue,Gt(s)),oe=wt(ue,Gt(U)),ie=re;if(oe2){var fe=wt(ue,{x:U[2],y:U[3]});fe=d||x){g={cp:w,segment:C};break}}if(g)break}var T=g.cp,k=g.segment,B=(d-p)/k.length,D=k.t1-k.t0,P=h?k.t0+D*B:k.t1-D*B;P=ka(0,P,1),e=$t(T.p0,T.p1,T.p2,P),c=iy(T.p0,T.p1,T.p2,P);break}case"straight":case"segments":case"haystack":{for(var A=0,R,L,I,M,N=a.allpts.length,F=0;F+3=d));F+=2);var _=d-L,z=_/R;z=ka(0,z,1),e=kd(I,M,z),c=wf(I,M);break}}s("labelX",f,e.x),s("labelY",f,e.y),s("labelAutoAngle",f,c)}};l("source"),l("target"),this.applyLabelDimensions(r)}};Hr.applyLabelDimensions=function(r){this.applyPrefixedLabelDimensions(r),r.isEdge()&&(this.applyPrefixedLabelDimensions(r,"source"),this.applyPrefixedLabelDimensions(r,"target"))};Hr.applyPrefixedLabelDimensions=function(r,e){var t=r._private,a=this.getLabelText(r,e),n=St(a,r._private.labelDimsKey);if(pr(t.rscratch,"prefixedLabelDimsKey",e)!==n){qr(t.rscratch,"prefixedLabelDimsKey",e,n);var i=this.calculateLabelDimensions(r,a),s=r.pstyle("line-height").pfValue,o=r.pstyle("font-size").pfValue,u=r.pstyle("text-wrap").strValue,l=pr(t.rscratch,"labelWrapCachedLines",e)||[],v=u!=="wrap"?1:Math.max(l.length,1),f=o*s,c=i.width,h=i.height+(v-1)*(s-1)*o;qr(t.rstyle,"labelWidth",e,c),qr(t.rscratch,"labelWidth",e,c),qr(t.rstyle,"labelHeight",e,h),qr(t.rscratch,"labelHeight",e,h),qr(t.rscratch,"labelLineHeight",e,f),qr(t.rscratch,"labelActualDescent",e,i.labelActualDescent)}};Hr.getLabelText=function(r,e){var t=r._private,a=e?e+"-":"",n=r.pstyle(a+"label").strValue,i=r.pstyle("text-transform").value,s=function(Z,Q){return Q?(qr(t.rscratch,Z,e,Q),Q):pr(t.rscratch,Z,e)};if(!n)return"";i=="none"||(i=="uppercase"?n=n.toUpperCase():i=="lowercase"&&(n=n.toLowerCase()));var o=r.pstyle("text-wrap").value;if(o==="wrap"){var u=s("labelKey");if(u!=null&&s("labelWrapKey")===u)return s("labelWrapCachedText");for(var l="​",v=n.split(` +`),f=r.pstyle("text-max-width").pfValue,c=r.pstyle("text-overflow-wrap").value,h=c==="anywhere",d=[],y=/[\s\u200b]+|$/g,g=0;gf){var E=p.matchAll(y),C="",x=0,T=Cr(E),k;try{for(T.s();!(k=T.n()).done;){var B=k.value,D=B[0],P=p.substring(x,B.index);x=B.index+D.length;var A=C.length===0?P:C+P+D,R=this.calculateLabelDimensions(r,A),L=R.width;L<=f?C+=P+D:(C&&d.push(C),C=P+D)}}catch(q){T.e(q)}finally{T.f()}C.match(/^[\s\u200b]+$/)||d.push(C)}else d.push(p)}s("labelWrapCachedLines",d),n=s("labelWrapCachedText",d.join(` +`)),s("labelWrapKey",u)}else if(o==="ellipsis"){var I=r.pstyle("text-max-width").pfValue,M="",N="…",F=!1;if(this.calculateLabelDimensions(r,n).widthI)break;M+=n[_],_===n.length-1&&(F=!0)}return F||(M+=N),M}return n};Hr.getLabelJustification=function(r){var e=r.pstyle("text-justification").strValue,t=r.pstyle("text-halign").strValue;return e==="auto"?r.isNode()?Ug(t):"center":e};Hr.calculateLabelDimensions=function(r,e){var t=this,a=t.cy.window(),n=a.document,i=0,s=r.pstyle("font-style").strValue,o=r.pstyle("font-size").pfValue,u=r.pstyle("font-family").strValue,l=r.pstyle("font-weight").strValue,v=r.pstyle("text-metrics").strValue||"font",f=this.labelCalcCanvas,c=this.labelCalcCanvasContext;if(!f){f=this.labelCalcCanvas=n.createElement("canvas"),c=this.labelCalcCanvasContext=f.getContext("2d");var h=f.style;h.position="absolute",h.left="-9999px",h.top="-9999px",h.zIndex="-1",h.visibility="hidden",h.pointerEvents="none"}c.font="".concat(s," ").concat(l," ").concat(o,"px ").concat(u);for(var d=0,y=0,g=e.split(` +`),p=g.length,m=0,b=0,w=0;w1&&arguments[1]!==void 0?arguments[1]:!0;if(e.merge(s),o)for(var u=0;u=r.desktopTapThreshold2}var fr=i(S);rr&&(r.hoverData.tapholdCancelled=!0);var Ar=function(){var kr=r.hoverData.dragDelta=r.hoverData.dragDelta||[];kr.length===0?(kr.push(ke[0]),kr.push(ke[1])):(kr[0]+=ke[0],kr[1]+=ke[1])};W=!0,n(Ce,["mousemove","vmousemove","tapdrag"],S,{x:re[0],y:re[1]});var $e=function(kr){return{originalEvent:S,type:kr,position:{x:re[0],y:re[1]}}},Sr=function(){r.data.bgActivePosistion=void 0,r.hoverData.selecting||G.emit($e("boxstart")),fe[4]=1,r.hoverData.selecting=!0,r.redrawHint("select",!0),r.redraw()};if(r.hoverData.which===3){if(rr){var Rr=$e("cxtdrag");ce?ce.emit(Rr):G.emit(Rr),r.hoverData.cxtDragged=!0,(!r.hoverData.cxtOver||Ce!==r.hoverData.cxtOver)&&(r.hoverData.cxtOver&&r.hoverData.cxtOver.emit($e("cxtdragout")),r.hoverData.cxtOver=Ce,Ce&&Ce.emit($e("cxtdragover")))}}else if(r.hoverData.dragging){if(W=!0,G.panningEnabled()&&G.userPanningEnabled()){var Qr;if(r.hoverData.justStartedPan){var Mt=r.hoverData.mdownPos;Qr={x:(re[0]-Mt[0])*U,y:(re[1]-Mt[1])*U},r.hoverData.justStartedPan=!1}else Qr={x:ke[0]*U,y:ke[1]*U};G.panBy(Qr),G.emit($e("dragpan")),r.hoverData.dragged=!0}re=r.projectIntoViewport(S.clientX,S.clientY)}else if(fe[4]==1&&(ce==null||ce.pannable())){if(rr){if(!r.hoverData.dragging&&G.boxSelectionEnabled()&&(fr||!G.panningEnabled()||!G.userPanningEnabled()))Sr();else if(!r.hoverData.selecting&&G.panningEnabled()&&G.userPanningEnabled()){var yt=s(ce,r.hoverData.downs);yt&&(r.hoverData.dragging=!0,r.hoverData.justStartedPan=!0,fe[4]=0,r.data.bgActivePosistion=Gt(oe),r.redrawHint("select",!0),r.redraw())}ce&&ce.pannable()&&ce.active()&&ce.unactivate()}}else{if(ce&&ce.pannable()&&ce.active()&&ce.unactivate(),(!ce||!ce.grabbed())&&Ce!=xe&&(xe&&n(xe,["mouseout","tapdragout"],S,{x:re[0],y:re[1]}),Ce&&n(Ce,["mouseover","tapdragover"],S,{x:re[0],y:re[1]}),r.hoverData.last=Ce),ce)if(rr){if(G.boxSelectionEnabled()&&fr)ce&&ce.grabbed()&&(y(Pe),ce.emit($e("freeon")),Pe.emit($e("free")),r.dragData.didDrag&&(ce.emit($e("dragfreeon")),Pe.emit($e("dragfree")))),Sr();else if(ce&&ce.grabbed()&&r.nodeIsDraggable(ce)){var wr=!r.dragData.didDrag;wr&&r.redrawHint("eles",!0),r.dragData.didDrag=!0,r.hoverData.draggingEles||h(Pe,{inDragLayer:!0});var ar={x:0,y:0};if(ae(ke[0])&&ae(ke[1])&&(ar.x+=ke[0],ar.y+=ke[1],wr)){var xr=r.hoverData.dragDelta;xr&&ae(xr[0])&&ae(xr[1])&&(ar.x+=xr[0],ar.y+=xr[1])}r.hoverData.draggingEles=!0,Pe.silentShift(ar).emit($e("position")).emit($e("drag")),r.redrawHint("drag",!0),r.redraw()}}else Ar();W=!0}if(fe[2]=re[0],fe[3]=re[1],W)return S.stopPropagation&&S.stopPropagation(),S.preventDefault&&S.preventDefault(),!1}},!1);var B,D,P;r.registerBinding(e,"mouseup",function(S){if(!(r.hoverData.which===1&&S.which!==1&&r.hoverData.capture)){var O=r.hoverData.capture;if(O){r.hoverData.capture=!1;var W=r.cy,G=r.projectIntoViewport(S.clientX,S.clientY),U=r.selection,ue=r.findNearestElement(G[0],G[1],!0,!1),re=r.dragData.possibleDragElements,oe=r.hoverData.down,ie=i(S);r.data.bgActivePosistion&&(r.redrawHint("select",!0),r.redraw()),r.hoverData.tapholdCancelled=!0,r.data.bgActivePosistion=void 0,oe&&oe.unactivate();var fe=function(tr){return{originalEvent:S,type:tr,position:{x:G[0],y:G[1]}}};if(r.hoverData.which===3){var Ce=fe("cxttapend");if(oe?oe.emit(Ce):W.emit(Ce),!r.hoverData.cxtDragged){var xe=fe("cxttap");oe?oe.emit(xe):W.emit(xe)}r.hoverData.cxtDragged=!1,r.hoverData.which=null}else if(r.hoverData.which===1){if(n(ue,["mouseup","tapend","vmouseup"],S,{x:G[0],y:G[1]}),!r.dragData.didDrag&&!r.hoverData.dragged&&!r.hoverData.selecting&&!r.hoverData.isOverThresholdDrag&&(n(oe,["click","tap","vclick"],S,{x:G[0],y:G[1]}),D=!1,S.timeStamp-P<=W.multiClickDebounceTime()?(B&&clearTimeout(B),D=!0,P=null,n(oe,["dblclick","dbltap","vdblclick"],S,{x:G[0],y:G[1]})):(B=setTimeout(function(){D||n(oe,["oneclick","onetap","voneclick"],S,{x:G[0],y:G[1]})},W.multiClickDebounceTime()),P=S.timeStamp)),oe==null&&!r.dragData.didDrag&&!r.hoverData.selecting&&!r.hoverData.dragged&&!i(S)&&(W.$(t).unselect(["tapunselect"]),re.length>0&&r.redrawHint("eles",!0),r.dragData.possibleDragElements=re=W.collection()),ue==oe&&!r.dragData.didDrag&&!r.hoverData.selecting&&ue!=null&&ue._private.selectable&&(r.hoverData.dragging||(W.selectionType()==="additive"||ie?ue.selected()?ue.unselect(["tapunselect"]):ue.select(["tapselect"]):ie||(W.$(t).unmerge(ue).unselect(["tapunselect"]),ue.select(["tapselect"]))),r.redrawHint("eles",!0)),r.hoverData.selecting){var ce=W.collection(r.getAllInBox(U[0],U[1],U[2],U[3]));r.redrawHint("select",!0),ce.length>0&&r.redrawHint("eles",!0),W.emit(fe("boxend"));var ke=function(tr){return tr.selectable()&&!tr.selected()};W.selectionType()==="additive"||ie||W.$(t).unmerge(ce).unselect(),ce.emit(fe("box")).stdFilter(ke).select().emit(fe("boxselect")),r.redraw()}if(r.hoverData.dragging&&(r.hoverData.dragging=!1,r.redrawHint("select",!0),r.redrawHint("eles",!0),r.redraw()),!U[4]){r.redrawHint("drag",!0),r.redrawHint("eles",!0);var Pe=oe&&oe.grabbed();y(re),Pe&&(oe.emit(fe("freeon")),re.emit(fe("free")),r.dragData.didDrag&&(oe.emit(fe("dragfreeon")),re.emit(fe("dragfree"))))}}U[4]=0,r.hoverData.down=null,r.hoverData.cxtStarted=!1,r.hoverData.draggingEles=!1,r.hoverData.selecting=!1,r.hoverData.isOverThresholdDrag=!1,r.dragData.didDrag=!1,r.hoverData.dragged=!1,r.hoverData.dragDelta=[],r.hoverData.mdownPos=null,r.hoverData.mdownGPos=null,r.hoverData.which=null}}},!1);var A=[],R=4,L,I=1e5,M=function(S){for(var O=Math.abs(S[0]),W=1;W=R){L=!1;var G=A;if(G[0]>=5){var U;M(G)?U=G[0]:U=Cd(G),U>1&&(L=!0,I=U)}}else A.push(Math.abs(W)),O=!0;else L&&(I=Math.min(Math.abs(W),I));if(!r.scrollingPage){var ue=r.cy,re=ue.zoom(),oe=ue.pan(),ie=r.projectIntoViewport(S.clientX,S.clientY),fe=[ie[0]*re+oe.x,ie[1]*re+oe.y];if(r.hoverData.draggingEles||r.hoverData.dragging||r.hoverData.cxtStarted||x()){S.preventDefault();return}if(ue.panningEnabled()&&ue.userPanningEnabled()&&ue.zoomingEnabled()&&ue.userZoomingEnabled()){S.preventDefault(),r.data.wheelZooming=!0,clearTimeout(r.data.wheelTimeout),r.data.wheelTimeout=setTimeout(function(){r.data.wheelZooming=!1,r.redrawHint("eles",!0),r.redraw()},150);var Ce;O&&Math.abs(W)>5&&(W=ro(W)*5),Ce=W/-250,L&&(Ce/=I,Ce*=3),Ce=Ce*r.wheelSensitivity;var xe=S.deltaMode===1;xe&&(Ce*=33);var ce=ue.zoom()*Math.pow(10,Ce);S.type==="gesturechange"&&(ce=r.gestureStartZoom*S.scale),ue.zoom({level:ce,renderedPosition:{x:fe[0],y:fe[1]}}),ue.emit({type:S.type==="gesturechange"?"pinchzoom":"scrollzoom",originalEvent:S,position:{x:ie[0],y:ie[1]}})}}}};r.registerBinding(r.container,"wheel",N,!0),r.registerBinding(e,"scroll",function(S){r.scrollingPage=!0,clearTimeout(r.scrollingPageTimeout),r.scrollingPageTimeout=setTimeout(function(){r.scrollingPage=!1},250)},!0),r.registerBinding(r.container,"gesturestart",function(S){r.gestureStartZoom=r.cy.zoom(),r.hasTouchStarted||S.preventDefault()},!0),r.registerBinding(r.container,"gesturechange",function(ee){r.hasTouchStarted||N(ee)},!0),r.registerBinding(r.container,"mouseout",function(S){var O=r.projectIntoViewport(S.clientX,S.clientY);r.cy.emit({originalEvent:S,type:"mouseout",position:{x:O[0],y:O[1]}})},!1),r.registerBinding(r.container,"mouseover",function(S){var O=r.projectIntoViewport(S.clientX,S.clientY);r.cy.emit({originalEvent:S,type:"mouseover",position:{x:O[0],y:O[1]}})},!1);var F,_,z,q,Z,Q,X,J,j,ne,Y,V,H,$=function(S,O,W,G){return Math.sqrt((W-S)*(W-S)+(G-O)*(G-O))},K=function(S,O,W,G){return(W-S)*(W-S)+(G-O)*(G-O)},te;r.registerBinding(r.container,"touchstart",te=function(S){if(r.hasTouchStarted=!0,!!T(S)){p(),r.touchData.capture=!0,r.data.bgActivePosistion=void 0;var O=r.cy,W=r.touchData.now,G=r.touchData.earlier;if(S.touches[0]){var U=r.projectIntoViewport(S.touches[0].clientX,S.touches[0].clientY);W[0]=U[0],W[1]=U[1]}if(S.touches[1]){var U=r.projectIntoViewport(S.touches[1].clientX,S.touches[1].clientY);W[2]=U[0],W[3]=U[1]}if(S.touches[2]){var U=r.projectIntoViewport(S.touches[2].clientX,S.touches[2].clientY);W[4]=U[0],W[5]=U[1]}var ue=function(fr){return{originalEvent:S,type:fr,position:{x:W[0],y:W[1]}}};if(S.touches[1]){r.touchData.singleTouchMoved=!0,y(r.dragData.touchDragEles);var re=r.findContainerClientCoords();j=re[0],ne=re[1],Y=re[2],V=re[3],F=S.touches[0].clientX-j,_=S.touches[0].clientY-ne,z=S.touches[1].clientX-j,q=S.touches[1].clientY-ne,H=0<=F&&F<=Y&&0<=z&&z<=Y&&0<=_&&_<=V&&0<=q&&q<=V;var oe=O.pan(),ie=O.zoom();Z=$(F,_,z,q),Q=K(F,_,z,q),X=[(F+z)/2,(_+q)/2],J=[(X[0]-oe.x)/ie,(X[1]-oe.y)/ie];var fe=200,Ce=fe*fe;if(Q=1){for(var br=r.touchData.startPosition=[null,null,null,null,null,null],Ye=0;Ye=r.touchTapThreshold2}if(O&&r.touchData.cxt){S.preventDefault();var Ye=S.touches[0].clientX-j,Ze=S.touches[0].clientY-ne,We=S.touches[1].clientX-j,fr=S.touches[1].clientY-ne,Ar=K(Ye,Ze,We,fr),$e=Ar/Q,Sr=150,Rr=Sr*Sr,Qr=1.5,Mt=Qr*Qr;if($e>=Mt||Ar>=Rr){r.touchData.cxt=!1,r.data.bgActivePosistion=void 0,r.redrawHint("select",!0);var yt=ie("cxttapend");r.touchData.start?(r.touchData.start.unactivate().emit(yt),r.touchData.start=null):G.emit(yt)}}if(O&&r.touchData.cxt){var yt=ie("cxtdrag");r.data.bgActivePosistion=void 0,r.redrawHint("select",!0),r.touchData.start?r.touchData.start.emit(yt):G.emit(yt),r.touchData.start&&(r.touchData.start._private.grabbed=!1),r.touchData.cxtDragged=!0;var wr=r.findNearestElement(U[0],U[1],!0,!0);(!r.touchData.cxtOver||wr!==r.touchData.cxtOver)&&(r.touchData.cxtOver&&r.touchData.cxtOver.emit(ie("cxtdragout")),r.touchData.cxtOver=wr,wr&&wr.emit(ie("cxtdragover")))}else if(O&&S.touches[2]&&G.boxSelectionEnabled())S.preventDefault(),r.data.bgActivePosistion=void 0,this.lastThreeTouch=+new Date,r.touchData.selecting||G.emit(ie("boxstart")),r.touchData.selecting=!0,r.touchData.didSelect=!0,W[4]=1,!W||W.length===0||W[0]===void 0?(W[0]=(U[0]+U[2]+U[4])/3,W[1]=(U[1]+U[3]+U[5])/3,W[2]=(U[0]+U[2]+U[4])/3+1,W[3]=(U[1]+U[3]+U[5])/3+1):(W[2]=(U[0]+U[2]+U[4])/3,W[3]=(U[1]+U[3]+U[5])/3),r.redrawHint("select",!0),r.redraw();else if(O&&S.touches[1]&&!r.touchData.didSelect&&G.zoomingEnabled()&&G.panningEnabled()&&G.userZoomingEnabled()&&G.userPanningEnabled()){S.preventDefault(),r.data.bgActivePosistion=void 0,r.redrawHint("select",!0);var ar=r.dragData.touchDragEles;if(ar){r.redrawHint("drag",!0);for(var xr=0;xr0&&!r.hoverData.draggingEles&&!r.swipePanning&&r.data.bgActivePosistion!=null&&(r.data.bgActivePosistion=void 0,r.redrawHint("select",!0),r.redraw())}},!1);var De;r.registerBinding(e,"touchcancel",De=function(S){var O=r.touchData.start;r.touchData.capture=!1,O&&O.unactivate()});var we,ye,pe,se;if(r.registerBinding(e,"touchend",we=function(S){var O=r.touchData.start,W=r.touchData.capture;if(W)S.touches.length===0&&(r.touchData.capture=!1),S.preventDefault();else return;var G=r.selection;r.swipePanning=!1,r.hoverData.draggingEles=!1;var U=r.cy,ue=U.zoom(),re=r.touchData.now,oe=r.touchData.earlier;if(S.touches[0]){var ie=r.projectIntoViewport(S.touches[0].clientX,S.touches[0].clientY);re[0]=ie[0],re[1]=ie[1]}if(S.touches[1]){var ie=r.projectIntoViewport(S.touches[1].clientX,S.touches[1].clientY);re[2]=ie[0],re[3]=ie[1]}if(S.touches[2]){var ie=r.projectIntoViewport(S.touches[2].clientX,S.touches[2].clientY);re[4]=ie[0],re[5]=ie[1]}var fe=function(Rr){return{originalEvent:S,type:Rr,position:{x:re[0],y:re[1]}}};O&&O.unactivate();var Ce;if(r.touchData.cxt){if(Ce=fe("cxttapend"),O?O.emit(Ce):U.emit(Ce),!r.touchData.cxtDragged){var xe=fe("cxttap");O?O.emit(xe):U.emit(xe)}r.touchData.start&&(r.touchData.start._private.grabbed=!1),r.touchData.cxt=!1,r.touchData.start=null,r.redraw();return}if(!S.touches[2]&&U.boxSelectionEnabled()&&r.touchData.selecting){r.touchData.selecting=!1;var ce=U.collection(r.getAllInBox(G[0],G[1],G[2],G[3]));G[0]=void 0,G[1]=void 0,G[2]=void 0,G[3]=void 0,G[4]=0,r.redrawHint("select",!0),U.emit(fe("boxend"));var ke=function(Rr){return Rr.selectable()&&!Rr.selected()};ce.emit(fe("box")).stdFilter(ke).select().emit(fe("boxselect")),ce.nonempty()&&r.redrawHint("eles",!0),r.redraw()}if(O?.unactivate(),S.touches[2])r.data.bgActivePosistion=void 0,r.redrawHint("select",!0);else if(!S.touches[1]){if(!S.touches[0]){if(!S.touches[0]){r.data.bgActivePosistion=void 0,r.redrawHint("select",!0);var Pe=r.dragData.touchDragEles;if(O!=null){var rr=O._private.grabbed;y(Pe),r.redrawHint("drag",!0),r.redrawHint("eles",!0),rr&&(O.emit(fe("freeon")),Pe.emit(fe("free")),r.dragData.didDrag&&(O.emit(fe("dragfreeon")),Pe.emit(fe("dragfree")))),n(O,["touchend","tapend","vmouseup","tapdragout"],S,{x:re[0],y:re[1]}),O.unactivate(),r.touchData.start=null}else{var tr=r.findNearestElement(re[0],re[1],!0,!0);n(tr,["touchend","tapend","vmouseup","tapdragout"],S,{x:re[0],y:re[1]})}var br=r.touchData.startPosition[0]-re[0],Ye=br*br,Ze=r.touchData.startPosition[1]-re[1],We=Ze*Ze,fr=Ye+We,Ar=fr*ue*ue;r.touchData.singleTouchMoved||(O||U.$(":selected").unselect(["tapunselect"]),n(O,["tap","vclick"],S,{x:re[0],y:re[1]}),ye=!1,S.timeStamp-se<=U.multiClickDebounceTime()?(pe&&clearTimeout(pe),ye=!0,se=null,n(O,["dbltap","vdblclick"],S,{x:re[0],y:re[1]})):(pe=setTimeout(function(){ye||n(O,["onetap","voneclick"],S,{x:re[0],y:re[1]})},U.multiClickDebounceTime()),se=S.timeStamp)),O!=null&&!r.dragData.didDrag&&O._private.selectable&&Ar"u"){var de=[],ge=function(S){return{clientX:S.clientX,clientY:S.clientY,force:1,identifier:S.pointerId,pageX:S.pageX,pageY:S.pageY,radiusX:S.width/2,radiusY:S.height/2,screenX:S.screenX,screenY:S.screenY,target:S.target}},Ee=function(S){return{event:S,touch:ge(S)}},be=function(S){de.push(Ee(S))},Te=function(S){for(var O=0;O0)return q[0]}return null},d=Object.keys(c),y=0;y0?h:xv(i,s,e,t,a,n,o,u)},checkPoint:function(e,t,a,n,i,s,o,u){u=u==="auto"?ut(n,i):u;var l=2*u;if(Xr(e,t,this.points,s,o,n,i-l,[0,-1],a)||Xr(e,t,this.points,s,o,n-l,i,[0,-1],a))return!0;var v=n/2+2*a,f=i/2+2*a,c=[s-v,o-f,s-v,o,s+v,o,s+v,o-f];return!!(Er(e,t,c)||Tt(e,t,l,l,s+n/2-u,o+i/2-u,a)||Tt(e,t,l,l,s-n/2+u,o+i/2-u,a))}}};Yr.registerNodeShapes=function(){var r=this.nodeShapes={},e=this;this.generateEllipse(),this.generatePolygon("triangle",gr(3,0)),this.generateRoundPolygon("round-triangle",gr(3,0)),this.generatePolygon("rectangle",gr(4,0)),r.square=r.rectangle,this.generateRoundRectangle(),this.generateCutRectangle(),this.generateBarrel(),this.generateBottomRoundrectangle();{var t=[0,1,1,0,0,-1,-1,0];this.generatePolygon("diamond",t),this.generateRoundPolygon("round-diamond",t)}this.generatePolygon("pentagon",gr(5,0)),this.generateRoundPolygon("round-pentagon",gr(5,0)),this.generatePolygon("hexagon",gr(6,0)),this.generateRoundPolygon("round-hexagon",gr(6,0)),this.generatePolygon("heptagon",gr(7,0)),this.generateRoundPolygon("round-heptagon",gr(7,0)),this.generatePolygon("octagon",gr(8,0)),this.generateRoundPolygon("round-octagon",gr(8,0));var a=new Array(20);{var n=Bs(5,0),i=Bs(5,Math.PI/5),s=.5*(3-Math.sqrt(5));s*=1.57;for(var o=0;o=e.deqFastCost*w)break}else if(l){if(m>=e.deqCost*h||m>=e.deqAvgCost*c)break}else if(b>=e.deqNoDrawCost*bs)break;var E=e.deq(a,g,y);if(E.length>0)for(var C=0;C0&&(e.onDeqd(a,d),!l&&e.shouldRedraw(a,d,g,y)&&i())},o=e.priority||Js;n.beforeRender(s,o(a))}}}},ly=(function(){function r(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:wn;ct(this,r),this.idsByKey=new Ur,this.keyForId=new Ur,this.cachesByLvl=new Ur,this.lvls=[],this.getKey=e,this.doesEleInvalidateKey=t}return dt(r,[{key:"getIdsFor",value:function(t){t==null&&Ge("Can not get id list for null key");var a=this.idsByKey,n=this.idsByKey.get(t);return n||(n=new ra,a.set(t,n)),n}},{key:"addIdForKey",value:function(t,a){t!=null&&this.getIdsFor(t).add(a)}},{key:"deleteIdForKey",value:function(t,a){t!=null&&this.getIdsFor(t).delete(a)}},{key:"getNumberOfIdsForKey",value:function(t){return t==null?0:this.getIdsFor(t).size}},{key:"updateKeyMappingFor",value:function(t){var a=t.id(),n=this.keyForId.get(a),i=this.getKey(t);this.deleteIdForKey(n,a),this.addIdForKey(i,a),this.keyForId.set(a,i)}},{key:"deleteKeyMappingFor",value:function(t){var a=t.id(),n=this.keyForId.get(a);this.deleteIdForKey(n,a),this.keyForId.delete(a)}},{key:"keyHasChangedFor",value:function(t){var a=t.id(),n=this.keyForId.get(a),i=this.getKey(t);return n!==i}},{key:"isInvalid",value:function(t){return this.keyHasChangedFor(t)||this.doesEleInvalidateKey(t)}},{key:"getCachesAt",value:function(t){var a=this.cachesByLvl,n=this.lvls,i=a.get(t);return i||(i=new Ur,a.set(t,i),n.push(t)),i}},{key:"getCache",value:function(t,a){return this.getCachesAt(a).get(t)}},{key:"get",value:function(t,a){var n=this.getKey(t),i=this.getCache(n,a);return i!=null&&this.updateKeyMappingFor(t),i}},{key:"getForCachedKey",value:function(t,a){var n=this.keyForId.get(t.id()),i=this.getCache(n,a);return i}},{key:"hasCache",value:function(t,a){return this.getCachesAt(a).has(t)}},{key:"has",value:function(t,a){var n=this.getKey(t);return this.hasCache(n,a)}},{key:"setCache",value:function(t,a,n){n.key=t,this.getCachesAt(a).set(t,n)}},{key:"set",value:function(t,a,n){var i=this.getKey(t);this.setCache(i,a,n),this.updateKeyMappingFor(t)}},{key:"deleteCache",value:function(t,a){this.getCachesAt(a).delete(t)}},{key:"delete",value:function(t,a){var n=this.getKey(t);this.deleteCache(n,a)}},{key:"invalidateKey",value:function(t){var a=this;this.lvls.forEach(function(n){return a.deleteCache(t,n)})}},{key:"invalidate",value:function(t){var a=t.id(),n=this.keyForId.get(a);this.deleteKeyMappingFor(t);var i=this.doesEleInvalidateKey(t);return i&&this.invalidateKey(n),i||this.getNumberOfIdsForKey(n)===0}}])})(),Ol=25,an=50,gn=-4,Gs=3,Df=7.99,vy=8,fy=1024,cy=1024,dy=1024,hy=.2,gy=.8,py=10,yy=.15,my=.1,by=.9,wy=.9,xy=100,Ey=1,Wt={dequeue:"dequeue",downscale:"downscale",highQuality:"highQuality"},Cy=lr({getKey:null,doesEleInvalidateKey:wn,drawElement:null,getBoundingBox:null,getRotationPoint:null,getRotationOffset:null,isVisible:dv,allowEdgeTxrCaching:!0,allowParentTxrCaching:!0}),ba=function(e,t){var a=this;a.renderer=e,a.onDequeues=[];var n=Cy(t);me(a,n),a.lookup=new ly(n.getKey,n.doesEleInvalidateKey),a.setupDequeueing()},er=ba.prototype;er.reasons=Wt;er.getTextureQueue=function(r){var e=this;return e.eleImgCaches=e.eleImgCaches||{},e.eleImgCaches[r]=e.eleImgCaches[r]||[]};er.getRetiredTextureQueue=function(r){var e=this,t=e.eleImgCaches.retired=e.eleImgCaches.retired||{},a=t[r]=t[r]||[];return a};er.getElementQueue=function(){var r=this,e=r.eleCacheQueue=r.eleCacheQueue||new Va(function(t,a){return a.reqs-t.reqs});return e};er.getElementKeyToQueue=function(){var r=this,e=r.eleKeyToCacheQueue=r.eleKeyToCacheQueue||{};return e};er.getElement=function(r,e,t,a,n){var i=this,s=this.renderer,o=s.cy.zoom(),u=this.lookup;if(!e||e.w===0||e.h===0||isNaN(e.w)||isNaN(e.h)||!r.visible()||r.removed()||!i.allowEdgeTxrCaching&&r.isEdge()||!i.allowParentTxrCaching&&r.isParent())return null;if(a==null&&(a=Math.ceil(eo(o*t))),a=Df||a>Gs)return null;var l=Math.pow(2,a),v=e.h*l,f=e.w*l,c=s.eleTextBiggerThanMin(r,l);if(!this.isVisible(r,c))return null;var h=u.get(r,a);if(h&&h.invalidated&&(h.invalidated=!1,h.texture.invalidatedWidth-=h.width),h)return h;var d;if(v<=Ol?d=Ol:v<=an?d=an:d=Math.ceil(v/an)*an,v>dy||f>cy)return null;var y=i.getTextureQueue(d),g=y[y.length-2],p=function(){return i.recycleTexture(d,f)||i.addTexture(d,f)};g||(g=y[y.length-1]),g||(g=p()),g.width-g.usedWidtha;D--)k=i.getElement(r,e,t,D,Wt.downscale);B()}else return i.queueElement(r,C.level-1),C;else{var P;if(!b&&!w&&!E)for(var A=a-1;A>=gn;A--){var R=u.get(r,A);if(R){P=R;break}}if(m(P))return i.queueElement(r,a),P;g.context.translate(g.usedWidth,0),g.context.scale(l,l),this.drawElement(g.context,r,e,c,!1),g.context.scale(1/l,1/l),g.context.translate(-g.usedWidth,0)}return h={x:g.usedWidth,texture:g,level:a,scale:l,width:f,height:v,scaledLabelShown:c},g.usedWidth+=Math.ceil(f+vy),g.eleCaches.push(h),u.set(r,a,h),i.checkTextureFullness(g),h};er.invalidateElements=function(r){for(var e=0;e=hy*r.width&&this.retireTexture(r)};er.checkTextureFullness=function(r){var e=this,t=e.getTextureQueue(r.height);r.usedWidth/r.width>gy&&r.fullnessChecks>=py?ot(t,r):r.fullnessChecks++};er.retireTexture=function(r){var e=this,t=r.height,a=e.getTextureQueue(t),n=this.lookup;ot(a,r),r.retired=!0;for(var i=r.eleCaches,s=0;s=e)return s.retired=!1,s.usedWidth=0,s.invalidatedWidth=0,s.fullnessChecks=0,js(s.eleCaches),s.context.setTransform(1,0,0,1,0,0),s.context.clearRect(0,0,s.width,s.height),ot(n,s),a.push(s),s}};er.queueElement=function(r,e){var t=this,a=t.getElementQueue(),n=t.getElementKeyToQueue(),i=this.getKey(r),s=n[i];if(s)s.level=Math.max(s.level,e),s.eles.merge(r),s.reqs++,a.updateItem(s);else{var o={eles:r.spawn().merge(r),level:e,reqs:1,key:i};a.push(o),n[i]=o}};er.dequeue=function(r){for(var e=this,t=e.getElementQueue(),a=e.getElementKeyToQueue(),n=[],i=e.lookup,s=0;s0;s++){var o=t.pop(),u=o.key,l=o.eles[0],v=i.hasCache(l,o.level);if(a[u]=null,v)continue;n.push(o);var f=e.getBoundingBox(l);e.getElement(l,f,r,o.level,Wt.dequeue)}return n};er.removeFromQueue=function(r){var e=this,t=e.getElementQueue(),a=e.getElementKeyToQueue(),n=this.getKey(r),i=a[n];i!=null&&(i.eles.length===1?(i.reqs=Qs,t.updateItem(i),t.pop(),a[n]=null):i.eles.unmerge(r))};er.onDequeue=function(r){this.onDequeues.push(r)};er.offDequeue=function(r){ot(this.onDequeues,r)};er.setupDequeueing=kf.setupDequeueing({deqRedrawThreshold:xy,deqCost:yy,deqAvgCost:my,deqNoDrawCost:by,deqFastCost:wy,deq:function(e,t,a){return e.dequeue(t,a)},onDeqd:function(e,t){for(var a=0;a=Sy||t>Bn)return null}a.validateLayersElesOrdering(t,r);var u=a.layersByLevel,l=Math.pow(2,t),v=u[t]=u[t]||[],f,c=a.levelIsComplete(t,r),h,d=function(){var B=function(L){if(a.validateLayersElesOrdering(L,r),a.levelIsComplete(L,r))return h=u[L],!0},D=function(L){if(!h)for(var I=t+L;xa<=I&&I<=Bn&&!B(I);I+=L);};D(1),D(-1);for(var P=v.length-1;P>=0;P--){var A=v[P];A.invalid&&ot(v,A)}};if(!c)d();else return v;var y=function(){if(!f){f=yr();for(var B=0;Bzl||A>zl)return null;var R=P*A;if(R>Ly)return null;var L=a.makeLayer(f,t);if(D!=null){var I=v.indexOf(D)+1;v.splice(I,0,L)}else(B.insert===void 0||B.insert)&&v.unshift(L);return L};if(a.skipping&&!o)return null;for(var p=null,m=r.length/Ty,b=!o,w=0;w=m||!wv(p.bb,E.boundingBox()))&&(p=g({insert:!0,after:p}),!p))return null;h||b?a.queueLayer(p,E):a.drawEleInLayer(p,E,t,e),p.eles.push(E),x[t]=p}return h||(b?null:v)};vr.getEleLevelForLayerLevel=function(r,e){return r};vr.drawEleInLayer=function(r,e,t,a){var n=this,i=this.renderer,s=r.context,o=e.boundingBox();o.w===0||o.h===0||!e.visible()||(t=n.getEleLevelForLayerLevel(t,a),i.setImgSmoothing(s,!1),i.drawCachedElement(s,e,null,null,t,Iy),i.setImgSmoothing(s,!0))};vr.levelIsComplete=function(r,e){var t=this,a=t.layersByLevel[r];if(!a||a.length===0)return!1;for(var n=0,i=0;i0||s.invalid)return!1;n+=s.eles.length}return n===e.length};vr.validateLayersElesOrdering=function(r,e){var t=this.layersByLevel[r];if(t)for(var a=0;a0){e=!0;break}}return e};vr.invalidateElements=function(r){var e=this;r.length!==0&&(e.lastInvalidationTime=Kr(),!(r.length===0||!e.haveLayers())&&e.updateElementsInLayers(r,function(a,n,i){e.invalidateLayer(a)}))};vr.invalidateLayer=function(r){if(this.lastInvalidationTime=Kr(),!r.invalid){var e=r.level,t=r.eles,a=this.layersByLevel[e];ot(a,r),r.elesQueue=[],r.invalid=!0,r.replacement&&(r.replacement.invalid=!0);for(var n=0;n3&&arguments[3]!==void 0?arguments[3]:!0,n=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0,i=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!0,s=this,o=e._private.rscratch;if(!(i&&!e.visible())&&!(o.badLine||o.allpts==null||isNaN(o.allpts[0]))){var u;t&&(u=t,r.translate(-u.x1,-u.y1));var l=i?e.pstyle("opacity").value:1,v=i?e.pstyle("line-opacity").value:1,f=e.pstyle("curve-style").value,c=e.pstyle("line-style").value,h=e.pstyle("width").pfValue,d=e.pstyle("line-cap").value,y=e.pstyle("line-outline-width").value,g=e.pstyle("line-outline-color").value,p=l*v,m=l*v,b=function(){var L=arguments.length>0&&arguments[0]!==void 0?arguments[0]:p;f==="straight-triangle"?(s.eleStrokeStyle(r,e,L),s.drawEdgeTrianglePath(e,r,o.allpts)):(r.lineWidth=h,r.lineCap=d,s.eleStrokeStyle(r,e,L),s.drawEdgePath(e,r,o.allpts,c),r.lineCap="butt")},w=function(){var L=arguments.length>0&&arguments[0]!==void 0?arguments[0]:p;if(r.lineWidth=h+y,r.lineCap=d,y>0)s.colorStrokeStyle(r,g[0],g[1],g[2],L);else{r.lineCap="butt";return}f==="straight-triangle"?s.drawEdgeTrianglePath(e,r,o.allpts):(s.drawEdgePath(e,r,o.allpts,c),r.lineCap="butt")},E=function(){n&&s.drawEdgeOverlay(r,e)},C=function(){n&&s.drawEdgeUnderlay(r,e)},x=function(){var L=arguments.length>0&&arguments[0]!==void 0?arguments[0]:m;s.drawArrowheads(r,e,L)},T=function(){s.drawElementText(r,e,null,a)};r.lineJoin="round";var k=e.pstyle("ghost").value==="yes";if(k){var B=e.pstyle("ghost-offset-x").pfValue,D=e.pstyle("ghost-offset-y").pfValue,P=e.pstyle("ghost-opacity").value,A=p*P;r.translate(B,D),b(A),x(A),r.translate(-B,-D)}else w();C(),b(),x(),E(),T(),t&&r.translate(u.x1,u.y1)}};var Af=function(e){if(!["overlay","underlay"].includes(e))throw new Error("Invalid state");return function(t,a){if(a.visible()){var n=a.pstyle("".concat(e,"-opacity")).value;if(n!==0){var i=this,s=i.usePaths(),o=a._private.rscratch,u=a.pstyle("".concat(e,"-padding")).pfValue,l=2*u,v=a.pstyle("".concat(e,"-color")).value;t.lineWidth=l,o.edgeType==="self"&&!s?t.lineCap="butt":t.lineCap="round",i.colorStrokeStyle(t,v[0],v[1],v[2],n),i.drawEdgePath(a,t,o.allpts,"solid")}}}};Zr.drawEdgeOverlay=Af("overlay");Zr.drawEdgeUnderlay=Af("underlay");Zr.drawEdgePath=function(r,e,t,a){var n=r._private.rscratch,i=e,s,o=!1,u=this.usePaths(),l=r.pstyle("line-dash-pattern").pfValue,v=r.pstyle("line-dash-offset").pfValue;if(u){var f=t.join("$"),c=n.pathCacheKey&&n.pathCacheKey===f;c?(s=e=n.pathCache,o=!0):(s=e=new Path2D,n.pathCacheKey=f,n.pathCache=s)}if(i.setLineDash)switch(a){case"dotted":i.setLineDash([1,1]);break;case"dashed":i.setLineDash(l),i.lineDashOffset=v;break;case"solid":i.setLineDash([]);break}if(!o&&!n.badLine)switch(e.beginPath&&e.beginPath(),e.moveTo(t[0],t[1]),n.edgeType){case"bezier":case"self":case"compound":case"multibezier":for(var h=2;h+35&&arguments[5]!==void 0?arguments[5]:!0,s=this;if(a==null){if(i&&!s.eleTextBiggerThanMin(e))return}else if(a===!1)return;if(e.isNode()){var o=e.pstyle("label");if(!o||!o.value)return;var u=s.getLabelJustification(e),l=e.pstyle("text-metrics").strValue==="glyph";r.textAlign=u,r.textBaseline=l?"alphabetic":"bottom"}else{var v=e.element()._private.rscratch.badLine,f=e.pstyle("label"),c=e.pstyle("source-label"),h=e.pstyle("target-label");if(v||(!f||!f.value)&&(!c||!c.value)&&(!h||!h.value))return;r.textAlign="center",r.textBaseline="bottom"}var d=!t,y;t&&(y=t,r.translate(-y.x1,-y.y1)),n==null?(s.drawText(r,e,null,d,i),e.isEdge()&&(s.drawText(r,e,"source",d,i),s.drawText(r,e,"target",d,i))):s.drawText(r,e,n,d,i),t&&r.translate(y.x1,y.y1)};Rt.getFontCache=function(r){var e;this.fontCaches=this.fontCaches||[];for(var t=0;t2&&arguments[2]!==void 0?arguments[2]:!0,a=e.pstyle("font-style").strValue,n=e.pstyle("font-size").pfValue+"px",i=e.pstyle("font-family").strValue,s=e.pstyle("font-weight").strValue,o=t?e.effectiveOpacity()*e.pstyle("text-opacity").value:1,u=e.pstyle("text-outline-opacity").value*o,l=e.pstyle("color").value,v=e.pstyle("text-outline-color").value;r.font=a+" "+s+" "+n+" "+i,r.lineJoin="round",this.colorFillStyle(r,l[0],l[1],l[2],o),this.colorStrokeStyle(r,v[0],v[1],v[2],u)};function $y(r,e,t,a,n){var i=Math.min(a,n),s=i/2,o=e+a/2,u=t+n/2;r.beginPath(),r.arc(o,u,s,0,Math.PI*2),r.closePath()}function _l(r,e,t,a,n){var i=arguments.length>5&&arguments[5]!==void 0?arguments[5]:5,s=Math.min(i,a/2,n/2);r.beginPath(),r.moveTo(e+s,t),r.lineTo(e+a-s,t),r.quadraticCurveTo(e+a,t,e+a,t+s),r.lineTo(e+a,t+n-s),r.quadraticCurveTo(e+a,t+n,e+a-s,t+n),r.lineTo(e+s,t+n),r.quadraticCurveTo(e,t+n,e,t+n-s),r.lineTo(e,t+s),r.quadraticCurveTo(e,t,e+s,t),r.closePath()}Rt.getTextAngle=function(r,e){var t,a=r._private,n=a.rscratch,i=e?e+"-":"",s=r.pstyle(i+"text-rotation");if(s.strValue==="autorotate"){var o=pr(n,"labelAngle",e);t=r.isEdge()?o:0}else s.strValue==="none"?t=0:t=s.pfValue;return t};Rt.drawText=function(r,e,t){var a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0,n=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0,i=e._private,s=i.rscratch,o=n?e.effectiveOpacity():1;if(!(n&&(o===0||e.pstyle("text-opacity").value===0))){t==="main"&&(t=null);var u=pr(s,"labelX",t),l=pr(s,"labelY",t),v,f,c=this.getLabelText(e,t);if(c!=null&&c!==""&&!isNaN(u)&&!isNaN(l)){this.setupTextStyle(r,e,n);var h=t?t+"-":"",d=pr(s,"labelWidth",t),y=pr(s,"labelHeight",t),g=pr(s,"labelActualDescent",t),p=e.pstyle(h+"text-margin-x").pfValue,m=e.pstyle(h+"text-margin-y").pfValue,b=e.isEdge(),w=e.pstyle("text-halign").value,E=e.pstyle("text-valign").value;b&&(w="center",E="center"),u+=p,l+=m;var C;a?C=this.getTextAngle(e,t):C=0,C!==0&&(v=u,f=l,r.translate(v,f),r.rotate(C),u=0,l=0);var x=Jt(w),T=jt(E);switch(T){case"top":break;case"center":l+=y/2;break;case"bottom":l+=y;break}var k=e.pstyle("text-background-opacity").value,B=e.pstyle("text-border-opacity").value,D=e.pstyle("text-border-width").pfValue,P=e.pstyle("text-background-padding").pfValue,A=e.pstyle("text-background-shape").strValue,R=A==="round-rectangle"||A==="roundrectangle",L=A==="circle",I=2;if(k>0||D>0&&B>0){var M=r.fillStyle,N=r.strokeStyle,F=r.lineWidth,_=e.pstyle("text-background-color").value,z=e.pstyle("text-border-color").value,q=e.pstyle("text-border-style").value,Z=k>0,Q=D>0&&B>0,X=u-P;switch(x){case"left":X-=d;break;case"center":X-=d/2;break}var J=l-y-P,j=d+2*P,ne=y+2*P;if(Z&&(r.fillStyle="rgba(".concat(_[0],",").concat(_[1],",").concat(_[2],",").concat(k*o,")")),Q&&(r.strokeStyle="rgba(".concat(z[0],",").concat(z[1],",").concat(z[2],",").concat(B*o,")"),r.lineWidth=D,r.setLineDash))switch(q){case"dotted":r.setLineDash([1,1]);break;case"dashed":r.setLineDash([4,2]);break;case"double":r.lineWidth=D/4,r.setLineDash([]);break;default:r.setLineDash([]);break}if(R?(r.beginPath(),_l(r,X,J,j,ne,I)):L?(r.beginPath(),$y(r,X,J,j,ne)):(r.beginPath(),r.rect(X,J,j,ne)),Z&&r.fill(),Q&&r.stroke(),Q&&q==="double"){var Y=D/2;r.beginPath(),R?_l(r,X+Y,J+Y,j-2*Y,ne-2*Y,I):r.rect(X+Y,J+Y,j-2*Y,ne-2*Y),r.stroke()}r.fillStyle=M,r.strokeStyle=N,r.lineWidth=F,r.setLineDash&&r.setLineDash([])}var V=2*e.pstyle("text-outline-width").pfValue;if(V>0&&(r.lineWidth=V),l-=g,e.pstyle("text-wrap").value==="wrap"){var H=pr(s,"labelWrapCachedLines",t),$=pr(s,"labelLineHeight",t),K=d/2,te=this.getLabelJustification(e);switch(te==="auto"||(x==="left"?te==="left"?u+=-d:te==="center"&&(u+=-K):x==="center"?te==="left"?u+=-K:te==="right"&&(u+=K):x==="right"&&(te==="center"?u+=K:te==="right"&&(u+=d))),T){case"top":l-=(H.length-1)*$;break;case"center":case"bottom":l-=(H.length-1)*$;break}for(var ve=0;ve0&&r.strokeText(H[ve],u,l),r.fillText(H[ve],u,l),l+=$}else V>0&&r.strokeText(c,u,l),r.fillText(c,u,l);C!==0&&(r.rotate(-C),r.translate(-v,-f))}}};var gt={};gt.drawNode=function(r,e,t){var a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0,n=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0,i=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!0,s=this,o,u,l=e._private,v=l.rscratch,f=e.position();if(!(!ae(f.x)||!ae(f.y))&&!(i&&!e.visible())){var c=i?e.effectiveOpacity():1,h=s.usePaths(),d,y=!1,g=e.padding();o=e.width()+2*g,u=e.height()+2*g;var p;t&&(p=t,r.translate(-p.x1,-p.y1));for(var m=e.pstyle("background-image"),b=m.value,w=new Array(b.length),E=new Array(b.length),C=0,x=0;x0&&arguments[0]!==void 0?arguments[0]:A;s.eleFillStyle(r,e,O)},Y=function(){var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:z;s.colorStrokeStyle(r,R[0],R[1],R[2],O)},V=function(){var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:X;s.colorStrokeStyle(r,Z[0],Z[1],Z[2],O)},H=function(O,W,G,U){var ue=s.nodePathCache=s.nodePathCache||[],re=cv(G==="polygon"?G+","+U.join(","):G,""+W,""+O,""+j),oe=ue[re],ie,fe=!1;return oe!=null?(ie=oe,fe=!0,v.pathCache=ie):(ie=new Path2D,ue[re]=v.pathCache=ie),{path:ie,cacheHit:fe}},$=e.pstyle("shape").strValue,K=e.pstyle("shape-polygon-points").pfValue;if(h){r.translate(f.x,f.y);var te=H(o,u,$,K);d=te.path,y=te.cacheHit}var ve=function(){if(!y){var O=f;h&&(O={x:0,y:0}),s.nodeShapes[s.getNodeShape(e)].draw(d||r,O.x,O.y,o,u,j,v)}h?r.fill(d):r.fill()},De=function(){for(var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:c,W=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0,G=l.backgrounding,U=0,ue=0;ue0&&arguments[0]!==void 0?arguments[0]:!1,W=arguments.length>1&&arguments[1]!==void 0?arguments[1]:c;s.hasPie(e)&&(s.drawPie(r,e,W),O&&(h||s.nodeShapes[s.getNodeShape(e)].draw(r,f.x,f.y,o,u,j,v)))},ye=function(){var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1,W=arguments.length>1&&arguments[1]!==void 0?arguments[1]:c;s.hasStripe(e)&&(r.save(),h?r.clip(v.pathCache):(s.nodeShapes[s.getNodeShape(e)].draw(r,f.x,f.y,o,u,j,v),r.clip()),s.drawStripe(r,e,W),r.restore(),O&&(h||s.nodeShapes[s.getNodeShape(e)].draw(r,f.x,f.y,o,u,j,v)))},pe=function(){var O=arguments.length>0&&arguments[0]!==void 0?arguments[0]:c,W=(D>0?D:-D)*O,G=D>0?0:255;D!==0&&(s.colorFillStyle(r,G,G,G,W),h?r.fill(d):r.fill())},se=function(){if(P>0){if(r.lineWidth=P,r.lineCap=M,r.lineJoin=I,r.setLineDash)switch(L){case"dotted":r.setLineDash([1,1]);break;case"dashed":r.setLineDash(F),r.lineDashOffset=_;break;case"solid":case"double":r.setLineDash([]);break}if(N!=="center"){if(r.save(),r.lineWidth*=2,N==="inside")h?r.clip(d):r.clip();else{var O=new Path2D;O.rect(-o/2-P,-u/2-P,o+2*P,u+2*P),O.addPath(d),r.clip(O,"evenodd")}h?r.stroke(d):r.stroke(),r.restore()}else h?r.stroke(d):r.stroke();if(L==="double"){r.lineWidth=P/3;var W=r.globalCompositeOperation;r.globalCompositeOperation="destination-out",h?r.stroke(d):r.stroke(),r.globalCompositeOperation=W}r.setLineDash&&r.setLineDash([])}},de=function(){if(q>0){if(r.lineWidth=q,r.lineCap="butt",r.setLineDash)switch(Q){case"dotted":r.setLineDash([1,1]);break;case"dashed":r.setLineDash([4,2]);break;case"solid":case"double":r.setLineDash([]);break}var O=f;h&&(O={x:0,y:0});var W=s.getNodeShape(e),G=P;N==="inside"&&(G=0),N==="outside"&&(G*=2);var U=(o+G+(q+J))/o,ue=(u+G+(q+J))/u,re=o*U,oe=u*ue,ie=s.nodeShapes[W].points,fe;if(h){var Ce=H(re,oe,W,ie);fe=Ce.path}if(W==="ellipse")s.drawEllipsePath(fe||r,O.x,O.y,re,oe);else if(["round-diamond","round-heptagon","round-hexagon","round-octagon","round-pentagon","round-polygon","round-triangle","round-tag"].includes(W)){var xe=0,ce=0,ke=0;W==="round-diamond"?xe=(G+J+q)*1.4:W==="round-heptagon"?(xe=(G+J+q)*1.075,ke=-(G/2+J+q)/35):W==="round-hexagon"?xe=(G+J+q)*1.12:W==="round-pentagon"?(xe=(G+J+q)*1.13,ke=-(G/2+J+q)/15):W==="round-tag"?(xe=(G+J+q)*1.12,ce=(G/2+q+J)*.07):W==="round-triangle"&&(xe=(G+J+q)*(Math.PI/2),ke=-(G+J/2+q)/Math.PI),xe!==0&&(U=(o+xe)/o,re=o*U,["round-hexagon","round-tag"].includes(W)||(ue=(u+xe)/u,oe=u*ue)),j=j==="auto"?Cv(re,oe):j;for(var Pe=re/2,rr=oe/2,tr=j+(G+q+J)/2,br=new Array(ie.length/2),Ye=new Array(ie.length/2),Ze=0;Ze0){if(n=n||a.position(),i==null||s==null){var h=a.padding();i=a.width()+2*h,s=a.height()+2*h}o.colorFillStyle(t,v[0],v[1],v[2],l),o.nodeShapes[f].draw(t,n.x,n.y,i+u*2,s+u*2,c),t.fill()}}}};gt.drawNodeOverlay=Rf("overlay");gt.drawNodeUnderlay=Rf("underlay");gt.hasPie=function(r){return r=r[0],r._private.hasPie};gt.hasStripe=function(r){return r=r[0],r._private.hasStripe};gt.drawPie=function(r,e,t,a){e=e[0],a=a||e.position();var n=e.cy().style(),i=e.pstyle("pie-size"),s=e.pstyle("pie-hole"),o=e.pstyle("pie-start-angle").pfValue,u=a.x,l=a.y,v=e.width(),f=e.height(),c=Math.min(v,f)/2,h,d=0,y=this.usePaths();if(y&&(u=0,l=0),i.units==="%"?c=c*i.pfValue:i.pfValue!==void 0&&(c=i.pfValue/2),s.units==="%"?h=c*s.pfValue:s.pfValue!==void 0&&(h=s.pfValue/2),!(h>=c))for(var g=1;g<=n.pieBackgroundN;g++){var p=e.pstyle("pie-"+g+"-background-size").value,m=e.pstyle("pie-"+g+"-background-color").value,b=e.pstyle("pie-"+g+"-background-opacity").value*t,w=p/100;w+d>1&&(w=1-d);var E=1.5*Math.PI+2*Math.PI*d;E+=o;var C=2*Math.PI*w,x=E+C;p===0||d>=1||d+w>1||(h===0?(r.beginPath(),r.moveTo(u,l),r.arc(u,l,c,E,x),r.closePath()):(r.beginPath(),r.arc(u,l,c,E,x),r.arc(u,l,h,x,E,!0),r.closePath()),this.colorFillStyle(r,m[0],m[1],m[2],b),r.fill(),d+=w)}};gt.drawStripe=function(r,e,t,a){e=e[0],a=a||e.position();var n=e.cy().style(),i=a.x,s=a.y,o=e.width(),u=e.height(),l=0,v=this.usePaths();r.save();var f=e.pstyle("stripe-direction").value,c=e.pstyle("stripe-size");switch(f){case"vertical":break;case"righward":r.rotate(-Math.PI/2);break}var h=o,d=u;c.units==="%"?(h=h*c.pfValue,d=d*c.pfValue):c.pfValue!==void 0&&(h=c.pfValue,d=c.pfValue),v&&(i=0,s=0),s-=h/2,i-=d/2;for(var y=1;y<=n.stripeBackgroundN;y++){var g=e.pstyle("stripe-"+y+"-background-size").value,p=e.pstyle("stripe-"+y+"-background-color").value,m=e.pstyle("stripe-"+y+"-background-opacity").value*t,b=g/100;b+l>1&&(b=1-l),!(g===0||l>=1||l+b>1)&&(r.beginPath(),r.rect(i,s+d*l,h,d*b),r.closePath(),this.colorFillStyle(r,p[0],p[1],p[2],m),r.fill(),l+=b)}r.restore()};var mr={},Uy=100;mr.getPixelRatio=function(){var r=this.data.contexts[0];if(this.forcedPixelRatio!=null)return this.forcedPixelRatio;var e=this.cy.window(),t=r.backingStorePixelRatio||r.webkitBackingStorePixelRatio||r.mozBackingStorePixelRatio||r.msBackingStorePixelRatio||r.oBackingStorePixelRatio||r.backingStorePixelRatio||1;return(e.devicePixelRatio||1)/t};mr.paintCache=function(r){for(var e=this.paintCaches=this.paintCaches||[],t=!0,a,n=0;ne.minMbLowQualFrames&&(e.motionBlurPxRatio=e.mbPxRBlurry)),e.clearingMotionBlur&&(e.motionBlurPxRatio=1),e.textureDrawLastFrame&&!f&&(v[e.NODE]=!0,v[e.SELECT_BOX]=!0);var m=t.style(),b=t.zoom(),w=s!==void 0?s:b,E=t.pan(),C={x:E.x,y:E.y},x={zoom:b,pan:{x:E.x,y:E.y}},T=e.prevViewport,k=T===void 0||x.zoom!==T.zoom||x.pan.x!==T.pan.x||x.pan.y!==T.pan.y;!k&&!(y&&!d)&&(e.motionBlurPxRatio=1),o&&(C=o),w*=u,C.x*=u,C.y*=u;var B=e.getCachedZSortedEles();function D(Y,V,H,$,K){var te=Y.globalCompositeOperation;Y.globalCompositeOperation="destination-out",e.colorFillStyle(Y,255,255,255,e.motionBlurTransparency),Y.fillRect(V,H,$,K),Y.globalCompositeOperation=te}function P(Y,V){var H,$,K,te;!e.clearingMotionBlur&&(Y===l.bufferContexts[e.MOTIONBLUR_BUFFER_NODE]||Y===l.bufferContexts[e.MOTIONBLUR_BUFFER_DRAG])?(H={x:E.x*h,y:E.y*h},$=b*h,K=e.canvasWidth*h,te=e.canvasHeight*h):(H=C,$=w,K=e.canvasWidth,te=e.canvasHeight),Y.setTransform(1,0,0,1,0,0),V==="motionBlur"?D(Y,0,0,K,te):!a&&(V===void 0||V)&&Y.clearRect(0,0,K,te),n||(Y.translate(H.x,H.y),Y.scale($,$)),o&&Y.translate(o.x,o.y),s&&Y.scale(s,s)}if(f||(e.textureDrawLastFrame=!1),f){if(e.textureDrawLastFrame=!0,!e.textureCache){e.textureCache={},e.textureCache.bb=t.mutableElements().boundingBox(),e.textureCache.texture=e.data.bufferCanvases[e.TEXTURE_BUFFER];var A=e.data.bufferContexts[e.TEXTURE_BUFFER];A.setTransform(1,0,0,1,0,0),A.clearRect(0,0,e.canvasWidth*e.textureMult,e.canvasHeight*e.textureMult),e.render({forcedContext:A,drawOnlyNodeLayer:!0,forcedPxRatio:u*e.textureMult});var x=e.textureCache.viewport={zoom:t.zoom(),pan:t.pan(),width:e.canvasWidth,height:e.canvasHeight};x.mpan={x:(0-x.pan.x)/x.zoom,y:(0-x.pan.y)/x.zoom}}v[e.DRAG]=!1,v[e.NODE]=!1;var R=l.contexts[e.NODE],L=e.textureCache.texture,x=e.textureCache.viewport;R.setTransform(1,0,0,1,0,0),c?D(R,0,0,x.width,x.height):R.clearRect(0,0,x.width,x.height);var I=m.core("outside-texture-bg-color").value,M=m.core("outside-texture-bg-opacity").value;e.colorFillStyle(R,I[0],I[1],I[2],M),R.fillRect(0,0,x.width,x.height);var b=t.zoom();P(R,!1),R.clearRect(x.mpan.x,x.mpan.y,x.width/x.zoom/u,x.height/x.zoom/u),R.drawImage(L,x.mpan.x,x.mpan.y,x.width/x.zoom/u,x.height/x.zoom/u)}else e.textureOnViewport&&!a&&(e.textureCache=null);var N=t.extent(),F=e.pinching||e.hoverData.dragging||e.swipePanning||e.data.wheelZooming||e.hoverData.draggingEles||e.cy.animated(),_=e.hideEdgesOnViewport&&F,z=[];if(z[e.NODE]=!v[e.NODE]&&c&&!e.clearedForMotionBlur[e.NODE]||e.clearingMotionBlur,z[e.NODE]&&(e.clearedForMotionBlur[e.NODE]=!0),z[e.DRAG]=!v[e.DRAG]&&c&&!e.clearedForMotionBlur[e.DRAG]||e.clearingMotionBlur,z[e.DRAG]&&(e.clearedForMotionBlur[e.DRAG]=!0),v[e.NODE]||n||i||z[e.NODE]){var q=c&&!z[e.NODE]&&h!==1,R=a||(q?e.data.bufferContexts[e.MOTIONBLUR_BUFFER_NODE]:l.contexts[e.NODE]),Z=c&&!q?"motionBlur":void 0;P(R,Z),_?e.drawCachedNodes(R,B.nondrag,u,N):e.drawLayeredElements(R,B.nondrag,u,N),e.debug&&e.drawDebugPoints(R,B.nondrag),!n&&!c&&(v[e.NODE]=!1)}if(!i&&(v[e.DRAG]||n||z[e.DRAG])){var q=c&&!z[e.DRAG]&&h!==1,R=a||(q?e.data.bufferContexts[e.MOTIONBLUR_BUFFER_DRAG]:l.contexts[e.DRAG]);P(R,c&&!q?"motionBlur":void 0),_?e.drawCachedNodes(R,B.drag,u,N):e.drawCachedElements(R,B.drag,u,N),e.debug&&e.drawDebugPoints(R,B.drag),!n&&!c&&(v[e.DRAG]=!1)}if(this.drawSelectionRectangle(r,P),c&&h!==1){var Q=l.contexts[e.NODE],X=e.data.bufferCanvases[e.MOTIONBLUR_BUFFER_NODE],J=l.contexts[e.DRAG],j=e.data.bufferCanvases[e.MOTIONBLUR_BUFFER_DRAG],ne=function(V,H,$){V.setTransform(1,0,0,1,0,0),$||!p?V.clearRect(0,0,e.canvasWidth,e.canvasHeight):D(V,0,0,e.canvasWidth,e.canvasHeight);var K=h;V.drawImage(H,0,0,e.canvasWidth*K,e.canvasHeight*K,0,0,e.canvasWidth,e.canvasHeight)};(v[e.NODE]||z[e.NODE])&&(ne(Q,X,z[e.NODE]),v[e.NODE]=!1),(v[e.DRAG]||z[e.DRAG])&&(ne(J,j,z[e.DRAG]),v[e.DRAG]=!1)}e.prevViewport=x,e.clearingMotionBlur&&(e.clearingMotionBlur=!1,e.motionBlurCleared=!0,e.motionBlur=!0),c&&(e.motionBlurTimeout=setTimeout(function(){e.motionBlurTimeout=null,e.clearedForMotionBlur[e.NODE]=!1,e.clearedForMotionBlur[e.DRAG]=!1,e.motionBlur=!1,e.clearingMotionBlur=!f,e.mbFrames=0,v[e.NODE]=!0,v[e.DRAG]=!0,e.redraw()},Uy)),a||t.emit("render")};var ha;mr.drawSelectionRectangle=function(r,e){var t=this,a=t.cy,n=t.data,i=a.style(),s=r.drawOnlyNodeLayer,o=r.drawAllLayers,u=n.canvasNeedsRedraw,l=r.forcedContext;if(t.showFps||!s&&u[t.SELECT_BOX]&&!o){var v=l||n.contexts[t.SELECT_BOX];if(e(v),t.selection[4]==1&&(t.hoverData.selecting||t.touchData.selecting)){var f=t.cy.zoom(),c=i.core("selection-box-border-width").value/f;v.lineWidth=c,v.fillStyle="rgba("+i.core("selection-box-color").value[0]+","+i.core("selection-box-color").value[1]+","+i.core("selection-box-color").value[2]+","+i.core("selection-box-opacity").value+")",v.fillRect(t.selection[0],t.selection[1],t.selection[2]-t.selection[0],t.selection[3]-t.selection[1]),c>0&&(v.strokeStyle="rgba("+i.core("selection-box-border-color").value[0]+","+i.core("selection-box-border-color").value[1]+","+i.core("selection-box-border-color").value[2]+","+i.core("selection-box-opacity").value+")",v.strokeRect(t.selection[0],t.selection[1],t.selection[2]-t.selection[0],t.selection[3]-t.selection[1]))}if(n.bgActivePosistion&&!t.hoverData.selecting){var f=t.cy.zoom(),h=n.bgActivePosistion;v.fillStyle="rgba("+i.core("active-bg-color").value[0]+","+i.core("active-bg-color").value[1]+","+i.core("active-bg-color").value[2]+","+i.core("active-bg-opacity").value+")",v.beginPath(),v.arc(h.x,h.y,i.core("active-bg-size").pfValue/f,0,2*Math.PI),v.fill()}var d=t.lastRedrawTime;if(t.showFps&&d){d=Math.round(d);var y=Math.round(1e3/d),g="1 frame = "+d+" ms = "+y+" fps";if(v.setTransform(1,0,0,1,0,0),v.fillStyle="rgba(255, 0, 0, 0.75)",v.strokeStyle="rgba(255, 0, 0, 0.75)",v.font="30px Arial",!ha){var p=v.measureText(g);ha=p.actualBoundingBoxAscent}v.fillText(g,0,ha);var m=60;v.strokeRect(0,ha+10,250,20),v.fillRect(0,ha+10,250*Math.min(y/m,1),20)}o||(u[t.SELECT_BOX]=!1)}};function Gl(r,e,t){var a=r.createShader(e);if(r.shaderSource(a,t),r.compileShader(a),!r.getShaderParameter(a,r.COMPILE_STATUS))throw new Error(r.getShaderInfoLog(a));return a}function Ky(r,e,t){var a=Gl(r,r.VERTEX_SHADER,e),n=Gl(r,r.FRAGMENT_SHADER,t),i=r.createProgram();if(r.attachShader(i,a),r.attachShader(i,n),r.linkProgram(i),!r.getProgramParameter(i,r.LINK_STATUS))throw new Error("Could not initialize shaders");return i}function Xy(r,e,t){t===void 0&&(t=e);var a=r.makeOffscreenCanvas(e,t),n=a.context=a.getContext("2d");return a.clear=function(){return n.clearRect(0,0,a.width,a.height)},a.clear(),a}function mo(r){var e=r.pixelRatio,t=r.cy.zoom(),a=r.cy.pan();return{zoom:t*e,pan:{x:a.x*e,y:a.y*e}}}function Yy(r){var e=r.pixelRatio,t=r.cy.zoom();return t*e}function Zy(r,e,t,a,n){var i=a*t+e.x,s=n*t+e.y;return s=Math.round(r.canvasHeight-s),[i,s]}function Qy(r,e){return e.picking?!0:r.pstyle("background-fill").value!=="solid"||r.pstyle("background-image").strValue!=="none"?!1:r.pstyle("border-width").value===0||r.pstyle("border-opacity").value===0?!0:r.pstyle("border-style").value==="solid"}function Jy(r,e){if(r.length!==e.length)return!1;for(var t=0;t>0&255)/255,t[1]=(r>>8&255)/255,t[2]=(r>>16&255)/255,t[3]=(r>>24&255)/255,t}function jy(r){return r[0]+(r[1]<<8)+(r[2]<<16)+(r[3]<<24)}function em(r,e){var t=r.createTexture();return t.buffer=function(a){r.bindTexture(r.TEXTURE_2D,t),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.LINEAR),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.LINEAR_MIPMAP_NEAREST),r.pixelStorei(r.UNPACK_PREMULTIPLY_ALPHA_WEBGL,!0),r.texImage2D(r.TEXTURE_2D,0,r.RGBA,r.RGBA,r.UNSIGNED_BYTE,a),r.generateMipmap(r.TEXTURE_2D),r.bindTexture(r.TEXTURE_2D,null)},t.deleteTexture=function(){r.deleteTexture(t)},t}function Mf(r,e){switch(e){case"float":return[1,r.FLOAT,4];case"vec2":return[2,r.FLOAT,4];case"vec3":return[3,r.FLOAT,4];case"vec4":return[4,r.FLOAT,4];case"int":return[1,r.INT,4];case"ivec2":return[2,r.INT,4]}}function Lf(r,e,t){switch(e){case r.FLOAT:return new Float32Array(t);case r.INT:return new Int32Array(t)}}function rm(r,e,t,a,n,i){switch(e){case r.FLOAT:return new Float32Array(t.buffer,i*a,n);case r.INT:return new Int32Array(t.buffer,i*a,n)}}function tm(r,e,t,a){var n=Mf(r,e),i=Xe(n,2),s=i[0],o=i[1],u=Lf(r,o,a),l=r.createBuffer();return r.bindBuffer(r.ARRAY_BUFFER,l),r.bufferData(r.ARRAY_BUFFER,u,r.STATIC_DRAW),o===r.FLOAT?r.vertexAttribPointer(t,s,o,!1,0,0):o===r.INT&&r.vertexAttribIPointer(t,s,o,0,0),r.enableVertexAttribArray(t),r.bindBuffer(r.ARRAY_BUFFER,null),l}function Fr(r,e,t,a){var n=Mf(r,t),i=Xe(n,3),s=i[0],o=i[1],u=i[2],l=Lf(r,o,e*s),v=s*u,f=r.createBuffer();r.bindBuffer(r.ARRAY_BUFFER,f),r.bufferData(r.ARRAY_BUFFER,e*v,r.DYNAMIC_DRAW),r.enableVertexAttribArray(a),o===r.FLOAT?r.vertexAttribPointer(a,s,o,!1,v,0):o===r.INT&&r.vertexAttribIPointer(a,s,o,v,0),r.vertexAttribDivisor(a,1),r.bindBuffer(r.ARRAY_BUFFER,null);for(var c=new Array(e),h=0;hs&&(o=s/a,u=a*o,l=n*o),{scale:o,texW:u,texH:l}}},{key:"draw",value:function(t,a,n){var i=this;if(this.locked)throw new Error("can't draw, atlas is locked");var s=this.texSize,o=this.texRows,u=this.texHeight,l=this.getScale(a),v=l.scale,f=l.texW,c=l.texH,h=function(b,w){if(n&&w){var E=w.context,C=b.x,x=b.row,T=C,k=u*x;E.save(),E.translate(T,k),E.scale(v,v),n(E,a),E.restore()}},d=[null,null],y=function(){h(i.freePointer,i.canvas),d[0]={x:i.freePointer.x,y:i.freePointer.row*u,w:f,h:c},d[1]={x:i.freePointer.x+f,y:i.freePointer.row*u,w:0,h:c},i.freePointer.x+=f,i.freePointer.x==s&&(i.freePointer.x=0,i.freePointer.row++)},g=function(){var b=i.scratch,w=i.canvas;b.clear(),h({x:0,row:0},b);var E=s-i.freePointer.x,C=f-E,x=u;{var T=i.freePointer.x,k=i.freePointer.row*u,B=E;w.context.drawImage(b,0,0,B,x,T,k,B,x),d[0]={x:T,y:k,w:B,h:c}}{var D=E,P=(i.freePointer.row+1)*u,A=C;w&&w.context.drawImage(b,D,0,A,x,0,P,A,x),d[1]={x:0,y:P,w:A,h:c}}i.freePointer.x=C,i.freePointer.row++},p=function(){i.freePointer.x=0,i.freePointer.row++};if(this.freePointer.x+f<=s)y();else{if(this.freePointer.row>=o-1)return!1;this.freePointer.x===s?(p(),y()):this.enableWrapping?g():(p(),y())}return this.keyToLocation.set(t,d),this.needsBuffer=!0,d}},{key:"getOffsets",value:function(t){return this.keyToLocation.get(t)}},{key:"isEmpty",value:function(){return this.freePointer.x===0&&this.freePointer.row===0}},{key:"canFit",value:function(t){if(this.locked)return!1;var a=this.texSize,n=this.texRows,i=this.getScale(t),s=i.texW;return this.freePointer.x+s>a?this.freePointer.row1&&arguments[1]!==void 0?arguments[1]:{},i=n.forceRedraw,s=i===void 0?!1:i,o=n.filterEle,u=o===void 0?function(){return!0}:o,l=n.filterType,v=l===void 0?function(){return!0}:l,f=!1,c=!1,h=Cr(t),d;try{for(h.s();!(d=h.n()).done;){var y=d.value;if(u(y)){var g=Cr(this.renderTypes.values()),p;try{var m=function(){var w=p.value,E=w.type;if(v(E)){var C=a.collections.get(w.collection),x=w.getKey(y),T=Array.isArray(x)?x:[x];if(s)T.forEach(function(P){return C.markKeyForGC(P)}),c=!0;else{var k=w.getID?w.getID(y):y.id(),B=a._key(E,k),D=a.typeAndIdToKey.get(B);D!==void 0&&!Jy(T,D)&&(f=!0,a.typeAndIdToKey.delete(B),D.forEach(function(P){return C.markKeyForGC(P)}))}}};for(g.s();!(p=g.n()).done;)m()}catch(b){g.e(b)}finally{g.f()}}}}catch(b){h.e(b)}finally{h.f()}return c&&(this.gc(),f=!1),f}},{key:"gc",value:function(){var t=Cr(this.collections.values()),a;try{for(t.s();!(a=t.n()).done;){var n=a.value;n.gc()}}catch(i){t.e(i)}finally{t.f()}}},{key:"getOrCreateAtlas",value:function(t,a,n,i){var s=this.renderTypes.get(a),o=this.collections.get(s.collection),u=!1,l=o.draw(i,n,function(c){s.drawClipped?(c.save(),c.beginPath(),c.rect(0,0,n.w,n.h),c.clip(),s.drawElement(c,t,n,!0,!0),c.restore()):s.drawElement(c,t,n,!0,!0),u=!0});if(u){var v=s.getID?s.getID(t):t.id(),f=this._key(a,v);this.typeAndIdToKey.has(f)?this.typeAndIdToKey.get(f).push(i):this.typeAndIdToKey.set(f,[i])}return l}},{key:"getAtlasInfo",value:function(t,a){var n=this,i=this.renderTypes.get(a),s=i.getKey(t),o=Array.isArray(s)?s:[s];return o.map(function(u){var l=i.getBoundingBox(t,u),v=n.getOrCreateAtlas(t,a,l,u),f=v.getOffsets(u),c=Xe(f,2),h=c[0],d=c[1];return{atlas:v,tex:h,tex1:h,tex2:d,bb:l}})}},{key:"getDebugInfo",value:function(){var t=[],a=Cr(this.collections),n;try{for(a.s();!(n=a.n()).done;){var i=Xe(n.value,2),s=i[0],o=i[1],u=o.getCounts(),l=u.keyCount,v=u.atlasCount;t.push({type:s,keyCount:l,atlasCount:v})}}catch(f){a.e(f)}finally{a.f()}return t}}])})(),fm=(function(){function r(e){ct(this,r),this.globalOptions=e,this.atlasSize=e.webglTexSize,this.maxAtlasesPerBatch=e.webglTexPerBatch,this.batchAtlases=[]}return dt(r,[{key:"getMaxAtlasesPerBatch",value:function(){return this.maxAtlasesPerBatch}},{key:"getAtlasSize",value:function(){return this.atlasSize}},{key:"getIndexArray",value:function(){return Array.from({length:this.maxAtlasesPerBatch},function(t,a){return a})}},{key:"startBatch",value:function(){this.batchAtlases=[]}},{key:"getAtlasCount",value:function(){return this.batchAtlases.length}},{key:"getAtlases",value:function(){return this.batchAtlases}},{key:"canAddToCurrentBatch",value:function(t){return this.batchAtlases.length===this.maxAtlasesPerBatch?this.batchAtlases.includes(t):!0}},{key:"getAtlasIndexForBatch",value:function(t){var a=this.batchAtlases.indexOf(t);if(a<0){if(this.batchAtlases.length===this.maxAtlasesPerBatch)throw new Error("cannot add more atlases to batch");this.batchAtlases.push(t),a=this.batchAtlases.length-1}return a}}])})(),cm=` + float circleSD(vec2 p, float r) { + return distance(vec2(0), p) - r; // signed distance + } +`,dm=` + float rectangleSD(vec2 p, vec2 b) { + vec2 d = abs(p)-b; + return distance(vec2(0),max(d,0.0)) + min(max(d.x,d.y),0.0); + } +`,hm=` + float roundRectangleSD(vec2 p, vec2 b, vec4 cr) { + cr.xy = (p.x > 0.0) ? cr.xy : cr.zw; + cr.x = (p.y > 0.0) ? cr.x : cr.y; + vec2 q = abs(p) - b + cr.x; + return min(max(q.x, q.y), 0.0) + distance(vec2(0), max(q, 0.0)) - cr.x; + } +`,gm=` + float ellipseSD(vec2 p, vec2 ab) { + p = abs( p ); // symmetry + + // find root with Newton solver + vec2 q = ab*(p-ab); + float w = (q.x1.0) ? d : -d; + } +`,Ea={SCREEN:{name:"screen",screen:!0},PICKING:{name:"picking",picking:!0}},Pn={IGNORE:1,USE_BB:2},Es=0,Ul=1,Kl=2,Cs=3,Vt=4,nn=5,ga=6,pa=7,pm=(function(){function r(e,t,a){ct(this,r),this.r=e,this.gl=t,this.maxInstances=a.webglBatchSize,this.atlasSize=a.webglTexSize,this.bgColor=a.bgColor,this.debug=a.webglDebug,this.batchDebugInfo=[],a.enableWrapping=!0,a.createTextureCanvas=Xy,this.atlasManager=new vm(e,a),this.batchManager=new fm(a),this.simpleShapeOptions=new Map,this.program=this._createShaderProgram(Ea.SCREEN),this.pickingProgram=this._createShaderProgram(Ea.PICKING),this.vao=this._createVAO()}return dt(r,[{key:"addAtlasCollection",value:function(t,a){this.atlasManager.addAtlasCollection(t,a)}},{key:"addTextureAtlasRenderType",value:function(t,a){this.atlasManager.addRenderType(t,a)}},{key:"addSimpleShapeRenderType",value:function(t,a){this.simpleShapeOptions.set(t,a)}},{key:"invalidate",value:function(t){var a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=a.type,i=this.atlasManager;return n?i.invalidate(t,{filterType:function(o){return o===n},forceRedraw:!0}):i.invalidate(t)}},{key:"gc",value:function(){this.atlasManager.gc()}},{key:"_createShaderProgram",value:function(t){var a=this.gl,n=`#version 300 es + precision highp float; + + uniform mat3 uPanZoomMatrix; + uniform int uAtlasSize; + + // instanced + in vec2 aPosition; // a vertex from the unit square + + in mat3 aTransform; // used to transform verticies, eg into a bounding box + in int aVertType; // the type of thing we are rendering + + // the z-index that is output when using picking mode + in vec4 aIndex; + + // For textures + in int aAtlasId; // which shader unit/atlas to use + in vec4 aTex; // x/y/w/h of texture in atlas + + // for edges + in vec4 aPointAPointB; + in vec4 aPointCPointD; + in vec2 aLineWidth; // also used for node border width + + // simple shapes + in vec4 aCornerRadius; // for round-rectangle [top-right, bottom-right, top-left, bottom-left] + in vec4 aColor; // also used for edges + in vec4 aBorderColor; // aLineWidth is used for border width + + // output values passed to the fragment shader + out vec2 vTexCoord; + out vec4 vColor; + out vec2 vPosition; + // flat values are not interpolated + flat out int vAtlasId; + flat out int vVertType; + flat out vec2 vTopRight; + flat out vec2 vBotLeft; + flat out vec4 vCornerRadius; + flat out vec4 vBorderColor; + flat out vec2 vBorderWidth; + flat out vec4 vIndex; + + void main(void) { + int vid = gl_VertexID; + vec2 position = aPosition; // TODO make this a vec3, simplifies some code below + + if(aVertType == `.concat(Es,`) { + float texX = aTex.x; // texture coordinates + float texY = aTex.y; + float texW = aTex.z; + float texH = aTex.w; + + if(vid == 1 || vid == 2 || vid == 4) { + texX += texW; + } + if(vid == 2 || vid == 4 || vid == 5) { + texY += texH; + } + + float d = float(uAtlasSize); + vTexCoord = vec2(texX / d, texY / d); // tex coords must be between 0 and 1 + + gl_Position = vec4(uPanZoomMatrix * aTransform * vec3(position, 1.0), 1.0); + } + else if(aVertType == `).concat(Vt," || aVertType == ").concat(pa,` + || aVertType == `).concat(nn," || aVertType == ").concat(ga,`) { // simple shapes + + // the bounding box is needed by the fragment shader + vBotLeft = (aTransform * vec3(0, 0, 1)).xy; // flat + vTopRight = (aTransform * vec3(1, 1, 1)).xy; // flat + vPosition = (aTransform * vec3(position, 1)).xy; // will be interpolated + + // calculations are done in the fragment shader, just pass these along + vColor = aColor; + vCornerRadius = aCornerRadius; + vBorderColor = aBorderColor; + vBorderWidth = aLineWidth; + + gl_Position = vec4(uPanZoomMatrix * aTransform * vec3(position, 1.0), 1.0); + } + else if(aVertType == `).concat(Ul,`) { + vec2 source = aPointAPointB.xy; + vec2 target = aPointAPointB.zw; + + // adjust the geometry so that the line is centered on the edge + position.y = position.y - 0.5; + + // stretch the unit square into a long skinny rectangle + vec2 xBasis = target - source; + vec2 yBasis = normalize(vec2(-xBasis.y, xBasis.x)); + vec2 point = source + xBasis * position.x + yBasis * aLineWidth[0] * position.y; + + gl_Position = vec4(uPanZoomMatrix * vec3(point, 1.0), 1.0); + vColor = aColor; + } + else if(aVertType == `).concat(Kl,`) { + vec2 pointA = aPointAPointB.xy; + vec2 pointB = aPointAPointB.zw; + vec2 pointC = aPointCPointD.xy; + vec2 pointD = aPointCPointD.zw; + + // adjust the geometry so that the line is centered on the edge + position.y = position.y - 0.5; + + vec2 p0, p1, p2, pos; + if(position.x == 0.0) { // The left side of the unit square + p0 = pointA; + p1 = pointB; + p2 = pointC; + pos = position; + } else { // The right side of the unit square, use same approach but flip the geometry upside down + p0 = pointD; + p1 = pointC; + p2 = pointB; + pos = vec2(0.0, -position.y); + } + + vec2 p01 = p1 - p0; + vec2 p12 = p2 - p1; + vec2 p21 = p1 - p2; + + // Find the normal vector. + vec2 tangent = normalize(normalize(p12) + normalize(p01)); + vec2 normal = vec2(-tangent.y, tangent.x); + + // Find the vector perpendicular to p0 -> p1. + vec2 p01Norm = normalize(vec2(-p01.y, p01.x)); + + // Determine the bend direction. + float sigma = sign(dot(p01 + p21, normal)); + float width = aLineWidth[0]; + + if(sign(pos.y) == -sigma) { + // This is an intersecting vertex. Adjust the position so that there's no overlap. + vec2 point = 0.5 * width * normal * -sigma / dot(normal, p01Norm); + gl_Position = vec4(uPanZoomMatrix * vec3(p1 + point, 1.0), 1.0); + } else { + // This is a non-intersecting vertex. Treat it like a mitre join. + vec2 point = 0.5 * width * normal * sigma * dot(normal, p01Norm); + gl_Position = vec4(uPanZoomMatrix * vec3(p1 + point, 1.0), 1.0); + } + + vColor = aColor; + } + else if(aVertType == `).concat(Cs,` && vid < 3) { + // massage the first triangle into an edge arrow + if(vid == 0) + position = vec2(-0.15, -0.3); + if(vid == 1) + position = vec2( 0.0, 0.0); + if(vid == 2) + position = vec2( 0.15, -0.3); + + gl_Position = vec4(uPanZoomMatrix * aTransform * vec3(position, 1.0), 1.0); + vColor = aColor; + } + else { + gl_Position = vec4(2.0, 0.0, 0.0, 1.0); // discard vertex by putting it outside webgl clip space + } + + vAtlasId = aAtlasId; + vVertType = aVertType; + vIndex = aIndex; + } + `),i=this.batchManager.getIndexArray(),s=`#version 300 es + precision highp float; + + // declare texture unit for each texture atlas in the batch + `.concat(i.map(function(l){return"uniform sampler2D uTexture".concat(l,";")}).join(` + `),` + + uniform vec4 uBGColor; + uniform float uZoom; + + in vec2 vTexCoord; + in vec4 vColor; + in vec2 vPosition; // model coordinates + + flat in int vAtlasId; + flat in vec4 vIndex; + flat in int vVertType; + flat in vec2 vTopRight; + flat in vec2 vBotLeft; + flat in vec4 vCornerRadius; + flat in vec4 vBorderColor; + flat in vec2 vBorderWidth; + + out vec4 outColor; + + `).concat(cm,` + `).concat(dm,` + `).concat(hm,` + `).concat(gm,` + + vec4 blend(vec4 top, vec4 bot) { // blend colors with premultiplied alpha + return vec4( + top.rgb + (bot.rgb * (1.0 - top.a)), + top.a + (bot.a * (1.0 - top.a)) + ); + } + + vec4 distInterp(vec4 cA, vec4 cB, float d) { // interpolate color using Signed Distance + // scale to the zoom level so that borders don't look blurry when zoomed in + // note 1.5 is an aribitrary value chosen because it looks good + return mix(cA, cB, 1.0 - smoothstep(0.0, 1.5 / uZoom, abs(d))); + } + + void main(void) { + if(vVertType == `).concat(Es,`) { + // look up the texel from the texture unit + `).concat(i.map(function(l){return"if(vAtlasId == ".concat(l,") outColor = texture(uTexture").concat(l,", vTexCoord);")}).join(` + else `),` + } + else if(vVertType == `).concat(Cs,`) { + // mimics how canvas renderer uses context.globalCompositeOperation = 'destination-out'; + outColor = blend(vColor, uBGColor); + outColor.a = 1.0; // make opaque, masks out line under arrow + } + else if(vVertType == `).concat(Vt,` && vBorderWidth == vec2(0.0)) { // simple rectangle with no border + outColor = vColor; // unit square is already transformed to the rectangle, nothing else needs to be done + } + else if(vVertType == `).concat(Vt," || vVertType == ").concat(pa,` + || vVertType == `).concat(nn," || vVertType == ").concat(ga,`) { // use SDF + + float outerBorder = vBorderWidth[0]; + float innerBorder = vBorderWidth[1]; + float borderPadding = outerBorder * 2.0; + float w = vTopRight.x - vBotLeft.x - borderPadding; + float h = vTopRight.y - vBotLeft.y - borderPadding; + vec2 b = vec2(w/2.0, h/2.0); // half width, half height + vec2 p = vPosition - vec2(vTopRight.x - b[0] - outerBorder, vTopRight.y - b[1] - outerBorder); // translate to center + + float d; // signed distance + if(vVertType == `).concat(Vt,`) { + d = rectangleSD(p, b); + } else if(vVertType == `).concat(pa,` && w == h) { + d = circleSD(p, b.x); // faster than ellipse + } else if(vVertType == `).concat(pa,`) { + d = ellipseSD(p, b); + } else { + d = roundRectangleSD(p, b, vCornerRadius.wzyx); + } + + // use the distance to interpolate a color to smooth the edges of the shape, doesn't need multisampling + // we must smooth colors inwards, because we can't change pixels outside the shape's bounding box + if(d > 0.0) { + if(d > outerBorder) { + discard; + } else { + outColor = distInterp(vBorderColor, vec4(0), d - outerBorder); + } + } else { + if(d > innerBorder) { + vec4 outerColor = outerBorder == 0.0 ? vec4(0) : vBorderColor; + vec4 innerBorderColor = blend(vBorderColor, vColor); + outColor = distInterp(innerBorderColor, outerColor, d); + } + else { + vec4 outerColor; + if(innerBorder == 0.0 && outerBorder == 0.0) { + outerColor = vec4(0); + } else if(innerBorder == 0.0) { + outerColor = vBorderColor; + } else { + outerColor = blend(vBorderColor, vColor); + } + outColor = distInterp(vColor, outerColor, d - innerBorder); + } + } + } + else { + outColor = vColor; + } + + `).concat(t.picking?`if(outColor.a == 0.0) discard; + else outColor = vIndex;`:"",` + } + `),o=Ky(a,n,s);o.aPosition=a.getAttribLocation(o,"aPosition"),o.aIndex=a.getAttribLocation(o,"aIndex"),o.aVertType=a.getAttribLocation(o,"aVertType"),o.aTransform=a.getAttribLocation(o,"aTransform"),o.aAtlasId=a.getAttribLocation(o,"aAtlasId"),o.aTex=a.getAttribLocation(o,"aTex"),o.aPointAPointB=a.getAttribLocation(o,"aPointAPointB"),o.aPointCPointD=a.getAttribLocation(o,"aPointCPointD"),o.aLineWidth=a.getAttribLocation(o,"aLineWidth"),o.aColor=a.getAttribLocation(o,"aColor"),o.aCornerRadius=a.getAttribLocation(o,"aCornerRadius"),o.aBorderColor=a.getAttribLocation(o,"aBorderColor"),o.uPanZoomMatrix=a.getUniformLocation(o,"uPanZoomMatrix"),o.uAtlasSize=a.getUniformLocation(o,"uAtlasSize"),o.uBGColor=a.getUniformLocation(o,"uBGColor"),o.uZoom=a.getUniformLocation(o,"uZoom"),o.uTextures=[];for(var u=0;u1&&arguments[1]!==void 0?arguments[1]:Ea.SCREEN;this.panZoomMatrix=t,this.renderTarget=a,this.batchDebugInfo=[],this.wrappedCount=0,this.simpleCount=0,this.startBatch()}},{key:"startBatch",value:function(){this.instanceCount=0,this.batchManager.startBatch()}},{key:"endFrame",value:function(){this.endBatch()}},{key:"_isVisible",value:function(t,a){return t.visible()?a&&a.isVisible?a.isVisible(t):!0:!1}},{key:"drawTexture",value:function(t,a,n){var i=this.atlasManager,s=this.batchManager,o=i.getRenderTypeOpts(n);if(this._isVisible(t,o)&&!(t.isEdge()&&!this._isValidEdge(t))){if(this.renderTarget.picking&&o.getTexPickingMode){var u=o.getTexPickingMode(t);if(u===Pn.IGNORE)return;if(u==Pn.USE_BB){this.drawPickingRectangle(t,a,n);return}}var l=i.getAtlasInfo(t,n),v=Cr(l),f;try{for(v.s();!(f=v.n()).done;){var c=f.value,h=c.atlas,d=c.tex1,y=c.tex2;s.canAddToCurrentBatch(h)||this.endBatch();for(var g=s.getAtlasIndexForBatch(h),p=0,m=[[d,!0],[y,!1]];p=this.maxInstances&&this.endBatch()}}}}catch(D){v.e(D)}finally{v.f()}}}},{key:"setTransformMatrix",value:function(t,a,n,i){var s=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0,o=0;if(n.shapeProps&&n.shapeProps.padding&&(o=t.pstyle(n.shapeProps.padding).pfValue),i){var u=i.bb,l=i.tex1,v=i.tex2,f=l.w/(l.w+v.w);s||(f=1-f);var c=this._getAdjustedBB(u,o,s,f);this._applyTransformMatrix(a,c,n,t)}else{var h=n.getBoundingBox(t),d=this._getAdjustedBB(h,o,!0,1);this._applyTransformMatrix(a,d,n,t)}}},{key:"_applyTransformMatrix",value:function(t,a,n,i){var s,o;Wl(t);var u=n.getRotation?n.getRotation(i):0;if(u!==0){var l=n.getRotationPoint(i),v=l.x,f=l.y;pn(t,t,[v,f]),$l(t,t,u);var c=n.getRotationOffset(i);s=c.x+(a.xOffset||0),o=c.y+(a.yOffset||0)}else s=a.x1,o=a.y1;pn(t,t,[s,o]),Hs(t,t,[a.w,a.h])}},{key:"_getAdjustedBB",value:function(t,a,n,i){var s=t.x1,o=t.y1,u=t.w,l=t.h,v=t.yOffset;a&&(s-=a,o-=a,u+=2*a,l+=2*a);var f=0,c=u*i;return n&&i<1?u=c:!n&&i<1&&(f=u-c,s+=f,u=c),{x1:s,y1:o,w:u,h:l,xOffset:f,yOffset:v}}},{key:"drawPickingRectangle",value:function(t,a,n){var i=this.atlasManager.getRenderTypeOpts(n),s=this.instanceCount;this.vertTypeBuffer.getView(s)[0]=Vt;var o=this.indexBuffer.getView(s);Ft(a,o);var u=this.colorBuffer.getView(s);bt([0,0,0],1,u);var l=this.transformBuffer.getMatrixView(s);this.setTransformMatrix(t,l,i),this.simpleCount++,this.instanceCount++,this.instanceCount>=this.maxInstances&&this.endBatch()}},{key:"drawNode",value:function(t,a,n){var i=this.simpleShapeOptions.get(n);if(this._isVisible(t,i)){var s=i.shapeProps,o=this._getVertTypeForShape(t,s.shape);if(o===void 0||i.isSimple&&!i.isSimple(t,this.renderTarget)){this.drawTexture(t,a,n);return}var u=this.instanceCount;if(this.vertTypeBuffer.getView(u)[0]=o,o===nn||o===ga){var l=i.getBoundingBox(t),v=this._getCornerRadius(t,s.radius,l),f=this.cornerRadiusBuffer.getView(u);f[0]=v,f[1]=v,f[2]=v,f[3]=v,o===ga&&(f[0]=0,f[2]=0)}var c=this.indexBuffer.getView(u);Ft(a,c);var h=this.renderTarget.picking?1:n==="node-body"?t.effectiveOpacity():1,d=this.renderTarget.picking?1:t.pstyle(s.opacity).value*h,y=t.pstyle(s.color).value,g=this.colorBuffer.getView(u);bt(y,d,g);var p=this.lineWidthBuffer.getView(u);if(p[0]=0,p[1]=0,s.border){var m=t.pstyle("border-width").value;if(m>0){var b=t.pstyle("border-color").value,w=h*t.pstyle("border-opacity").value,E=this.borderColorBuffer.getView(u);bt(b,w,E);var C=t.pstyle("border-position").value;if(C==="inside")p[0]=0,p[1]=-m;else if(C==="outside")p[0]=m,p[1]=0;else{var x=m/2;p[0]=x,p[1]=-x}}}var T=this.transformBuffer.getMatrixView(u);this.setTransformMatrix(t,T,i),this.simpleCount++,this.instanceCount++,this.instanceCount>=this.maxInstances&&this.endBatch()}}},{key:"_getVertTypeForShape",value:function(t,a){var n=t.pstyle(a).value;switch(n){case"rectangle":return Vt;case"ellipse":return pa;case"roundrectangle":case"round-rectangle":return nn;case"bottom-round-rectangle":return ga;default:return}}},{key:"_getCornerRadius",value:function(t,a,n){var i=n.w,s=n.h;if(t.pstyle(a).value==="auto")return ut(i,s);var o=t.pstyle(a).pfValue,u=i/2,l=s/2;return Math.min(o,l,u)}},{key:"drawEdgeArrow",value:function(t,a,n){if(t.visible()){var i=t._private.rscratch,s,o,u;if(n==="source"?(s=i.arrowStartX,o=i.arrowStartY,u=i.srcArrowAngle):(s=i.arrowEndX,o=i.arrowEndY,u=i.tgtArrowAngle),!(isNaN(s)||s==null||isNaN(o)||o==null||isNaN(u)||u==null)){var l=t.pstyle(n+"-arrow-shape").value;if(l!=="none"){var v=t.pstyle(n+"-arrow-color").value,f=t.pstyle("opacity").value,c=t.pstyle("line-opacity").value,h=f*c,d=t.pstyle("width").pfValue,y=t.pstyle("arrow-scale").value,g=this.r.getArrowWidth(d,y),p=this.instanceCount,m=this.transformBuffer.getMatrixView(p);Wl(m),pn(m,m,[s,o]),Hs(m,m,[g,g]),$l(m,m,u),this.vertTypeBuffer.getView(p)[0]=Cs;var b=this.indexBuffer.getView(p);Ft(a,b);var w=this.colorBuffer.getView(p);bt(v,h,w),this.instanceCount++,this.instanceCount>=this.maxInstances&&this.endBatch()}}}}},{key:"drawEdgeLine",value:function(t,a){if(t.visible()){var n=this._getEdgePoints(t);if(n){var i=t.pstyle("opacity").value,s=t.pstyle("line-opacity").value,o=t.pstyle("width").pfValue,u=t.pstyle("line-color").value,l=i*s;if(n.length/2+this.instanceCount>this.maxInstances&&this.endBatch(),n.length==4){var v=this.instanceCount;this.vertTypeBuffer.getView(v)[0]=Ul;var f=this.indexBuffer.getView(v);Ft(a,f);var c=this.colorBuffer.getView(v);bt(u,l,c);var h=this.lineWidthBuffer.getView(v);h[0]=o;var d=this.pointAPointBBuffer.getView(v);d[0]=n[0],d[1]=n[1],d[2]=n[2],d[3]=n[3],this.instanceCount++,this.instanceCount>=this.maxInstances&&this.endBatch()}else for(var y=0;y=this.maxInstances&&this.endBatch()}}}}},{key:"_isValidEdge",value:function(t){var a=t._private.rscratch;return!(a.badLine||a.allpts==null||isNaN(a.allpts[0]))}},{key:"_getEdgePoints",value:function(t){var a=t._private.rscratch;if(this._isValidEdge(t)){var n=a.allpts;if(n.length==4)return n;var i=this._getNumSegments(t);return this._getCurveSegmentPoints(n,i)}}},{key:"_getNumSegments",value:function(t){var a=15;return Math.min(Math.max(a,5),this.maxInstances)}},{key:"_getCurveSegmentPoints",value:function(t,a){if(t.length==4)return t;for(var n=Array((a+1)*2),i=0;i<=a;i++)if(i==0)n[0]=t[0],n[1]=t[1];else if(i==a)n[i*2]=t[t.length-2],n[i*2+1]=t[t.length-1];else{var s=i/a;this._setCurvePoint(t,s,n,i*2)}return n}},{key:"_setCurvePoint",value:function(t,a,n,i){if(t.length<=2)n[i]=t[0],n[i+1]=t[1];else{for(var s=Array(t.length-2),o=0;o0}},o=function(f){var c=f.pstyle("text-events").strValue==="yes";return c?Pn.USE_BB:Pn.IGNORE},u=function(f){var c=f.position(),h=c.x,d=c.y,y=f.outerWidth(),g=f.outerHeight();return{w:y,h:g,x1:h-y/2,y1:d-g/2}};t.drawing.addAtlasCollection("node",{texRows:r.webglTexRowsNodes}),t.drawing.addAtlasCollection("label",{texRows:r.webglTexRows}),t.drawing.addTextureAtlasRenderType("node-body",{collection:"node",getKey:e.getStyleKey,getBoundingBox:e.getElementBox,drawElement:e.drawElement}),t.drawing.addSimpleShapeRenderType("node-body",{getBoundingBox:u,isSimple:Qy,shapeProps:{shape:"shape",color:"background-color",opacity:"background-opacity",radius:"corner-radius",border:!0}}),t.drawing.addSimpleShapeRenderType("node-overlay",{getBoundingBox:u,isVisible:s("overlay"),shapeProps:{shape:"overlay-shape",color:"overlay-color",opacity:"overlay-opacity",padding:"overlay-padding",radius:"overlay-corner-radius"}}),t.drawing.addSimpleShapeRenderType("node-underlay",{getBoundingBox:u,isVisible:s("underlay"),shapeProps:{shape:"underlay-shape",color:"underlay-color",opacity:"underlay-opacity",padding:"underlay-padding",radius:"underlay-corner-radius"}}),t.drawing.addTextureAtlasRenderType("label",{collection:"label",getTexPickingMode:o,getKey:Ts(e.getLabelKey,null),getBoundingBox:Ss(e.getLabelBox,null),drawClipped:!0,drawElement:e.drawLabel,getRotation:n(null),getRotationPoint:e.getLabelRotationPoint,getRotationOffset:e.getLabelRotationOffset,isVisible:i("label")}),t.drawing.addTextureAtlasRenderType("edge-source-label",{collection:"label",getTexPickingMode:o,getKey:Ts(e.getSourceLabelKey,"source"),getBoundingBox:Ss(e.getSourceLabelBox,"source"),drawClipped:!0,drawElement:e.drawSourceLabel,getRotation:n("source"),getRotationPoint:e.getSourceLabelRotationPoint,getRotationOffset:e.getSourceLabelRotationOffset,isVisible:i("source-label")}),t.drawing.addTextureAtlasRenderType("edge-target-label",{collection:"label",getTexPickingMode:o,getKey:Ts(e.getTargetLabelKey,"target"),getBoundingBox:Ss(e.getTargetLabelBox,"target"),drawClipped:!0,drawElement:e.drawTargetLabel,getRotation:n("target"),getRotationPoint:e.getTargetLabelRotationPoint,getRotationOffset:e.getTargetLabelRotationOffset,isVisible:i("target-label")});var l=Fa(function(){console.log("garbage collect flag set"),t.data.gc=!0},1e4);t.onUpdateEleCalcs(function(v,f){var c=!1;f&&f.length>0&&(c|=t.drawing.invalidate(f)),c&&l()}),mm(t)};function ym(r){var e=r.cy.container(),t=e&&e.style&&e.style.backgroundColor||"white";return iv(t)}function Of(r,e){var t=r._private.rscratch;return pr(t,"labelWrapCachedLines",e)||[]}var Ts=function(e,t){return function(a){var n=e(a),i=Of(a,t);return i.length>1?i.map(function(s,o){return"".concat(n,"_").concat(o)}):n}},Ss=function(e,t){return function(a,n){var i=e(a);if(typeof n=="string"){var s=n.indexOf("_");if(s>0){var o=Number(n.substring(s+1)),u=Of(a,t),l=i.h/u.length,v=l*o,f=i.y1+v;return{x1:i.x1,w:i.w,y1:f,h:l,yOffset:v}}}return i}};function mm(r){{var e=r.render;r.render=function(i){i=i||{};var s=r.cy;r.webgl&&(s.zoom()>Df?(bm(r),e.call(r,i)):(wm(r),zf(r,i,Ea.SCREEN)))}}{var t=r.matchCanvasSize;r.matchCanvasSize=function(i){t.call(r,i),r.pickingFrameBuffer.setFramebufferAttachmentSizes(r.canvasWidth,r.canvasHeight),r.pickingFrameBuffer.needsDraw=!0}}r.findNearestElements=function(i,s,o,u){return km(r,i,s)};{var a=r.invalidateCachedZSortedEles;r.invalidateCachedZSortedEles=function(){a.call(r),r.pickingFrameBuffer.needsDraw=!0}}{var n=r.notify;r.notify=function(i,s){n.call(r,i,s),i==="viewport"||i==="bounds"?r.pickingFrameBuffer.needsDraw=!0:i==="background"&&r.drawing.invalidate(s,{type:"node-body"})}}}function bm(r){var e=r.data.contexts[r.WEBGL];e.clear(e.COLOR_BUFFER_BIT|e.DEPTH_BUFFER_BIT)}function wm(r){var e=function(a){a.save(),a.setTransform(1,0,0,1,0,0),a.clearRect(0,0,r.canvasWidth,r.canvasHeight),a.restore()};e(r.data.contexts[r.NODE]),e(r.data.contexts[r.DRAG])}function xm(r){var e=r.canvasWidth,t=r.canvasHeight,a=mo(r),n=a.pan,i=a.zoom,s=xs();pn(s,s,[n.x,n.y]),Hs(s,s,[i,i]);var o=xs();sm(o,e,t);var u=xs();return im(u,o,s),u}function Nf(r,e){var t=r.canvasWidth,a=r.canvasHeight,n=mo(r),i=n.pan,s=n.zoom;e.setTransform(1,0,0,1,0,0),e.clearRect(0,0,t,a),e.translate(i.x,i.y),e.scale(s,s)}function Em(r,e){r.drawSelectionRectangle(e,function(t){return Nf(r,t)})}function Cm(r){var e=r.data.contexts[r.NODE];e.save(),Nf(r,e),e.strokeStyle="rgba(0, 0, 0, 0.3)",e.beginPath(),e.moveTo(-1e3,0),e.lineTo(1e3,0),e.stroke(),e.beginPath(),e.moveTo(0,-1e3),e.lineTo(0,1e3),e.stroke(),e.restore()}function Tm(r){var e=function(n,i,s){for(var o=n.atlasManager.getAtlasCollection(i),u=r.data.contexts[r.NODE],l=o.atlases,v=0;v=0&&w.add(x)}return w}function km(r,e,t){var a=Sm(r,e,t),n=r.getCachedZSortedEles(),i,s,o=Cr(a),u;try{for(o.s();!(u=o.n()).done;){var l=u.value,v=n[l];if(!i&&v.isNode()&&(i=v),!s&&v.isEdge()&&(s=v),i&&s)break}}catch(f){o.e(f)}finally{o.f()}return[i,s].filter(Boolean)}function ks(r,e,t){var a=r.drawing;e+=1,t.isNode()?(a.drawNode(t,e,"node-underlay"),a.drawNode(t,e,"node-body"),a.drawTexture(t,e,"label"),a.drawNode(t,e,"node-overlay")):(a.drawEdgeLine(t,e),a.drawEdgeArrow(t,e,"source"),a.drawEdgeArrow(t,e,"target"),a.drawTexture(t,e,"label"),a.drawTexture(t,e,"edge-source-label"),a.drawTexture(t,e,"edge-target-label"))}function zf(r,e,t){var a;r.webglDebug&&(a=performance.now());var n=r.drawing,i=0;if(t.screen&&r.data.canvasNeedsRedraw[r.SELECT_BOX]&&Em(r,e),r.data.canvasNeedsRedraw[r.NODE]||t.picking){var s=r.data.contexts[r.WEBGL];t.screen?(s.clearColor(0,0,0,0),s.enable(s.BLEND),s.blendFunc(s.ONE,s.ONE_MINUS_SRC_ALPHA)):s.disable(s.BLEND),s.clear(s.COLOR_BUFFER_BIT|s.DEPTH_BUFFER_BIT),s.viewport(0,0,s.canvas.width,s.canvas.height);var o=xm(r),u=r.getCachedZSortedEles();if(i=u.length,n.startFrame(o,t),t.screen){for(var l=0;l0&&s>0){h.clearRect(0,0,i,s),h.globalCompositeOperation="source-over";var d=this.getCachedZSortedEles();if(r.full)h.translate(-a.x1*l,-a.y1*l),h.scale(l,l),this.drawElements(h,d),h.scale(1/l,1/l),h.translate(a.x1*l,a.y1*l);else{var y=e.pan(),g={x:y.x*l,y:y.y*l};l*=e.zoom(),h.translate(g.x,g.y),h.scale(l,l),this.drawElements(h,d),h.scale(1/l,1/l),h.translate(-g.x,-g.y)}r.bg&&(h.globalCompositeOperation="destination-over",h.fillStyle=r.bg,h.rect(0,0,i,s),h.fill())}return c};function Dm(r,e){for(var t=atob(r),a=new ArrayBuffer(t.length),n=new Uint8Array(a),i=0;i"u"?"undefined":je(OffscreenCanvas))!=="undefined")t=new OffscreenCanvas(r,e);else{var a=this.cy.window(),n=a.document;t=n.createElement("canvas"),t.width=r,t.height=e}return t};[Pf,Wr,Zr,yo,Rt,gt,mr,If,pt,Wa,qf].forEach(function(r){me(Se,r)});var Am=[{name:"null",impl:hf},{name:"base",impl:Sf},{name:"canvas",impl:Bm}],Rm=[{type:"layout",extensions:ey},{type:"renderer",extensions:Am}],Gf={},Hf={};function Wf(r,e,t){var a=t,n=function(T){Ne("Can not register `"+e+"` for `"+r+"` since `"+T+"` already exists in the prototype and can not be overridden")};if(r==="core"){if(Ra.prototype[e])return n(e);Ra.prototype[e]=t}else if(r==="collection"){if(ur.prototype[e])return n(e);ur.prototype[e]=t}else if(r==="layout"){for(var i=function(T){this.options=T,t.call(this,T),Me(this._private)||(this._private={}),this._private.cy=T.cy,this._private.listeners=[],this.createEmitter()},s=i.prototype=Object.create(t.prototype),o=[],u=0;uMath.max(e,Math.min(r,t)),"clamp"),P=m((t="TB")=>{switch(t){case"BT":return"bottom";case"LR":return"right";case"RL":return"left";default:return"top"}},"getDefaultSelfLoopSide"),U=m(t=>t==="flowchart"||t==="flowchart-v2"||t==="stateDiagram"||t==="er"||t==="classDiagram","shouldMergeSelfLoopSegments"),K=["x","y","width","height","labelBBox","intersect","calcIntersect","diff","clusterNode"],Q=m((t,e,r,d,a)=>{const f=[],h=new Set;if(r.forEach(({start:i,end:o})=>{i!==d&&h.add(i),o!==d&&h.add(o)}),h.forEach(i=>{const o=t.node(i);typeof o?.x=="number"&&typeof o?.y=="number"&&f.push(o)}),f.length===0&&r.forEach(({edge:i})=>{(i.points??[]).forEach(o=>{typeof o?.x=="number"&&typeof o?.y=="number"&&f.push(o)})}),f.length===0)return P(a);const c=f.reduce((i,o)=>({x:i.x+o.x/f.length,y:i.y+o.y/f.length}),{x:0,y:0}),l=c.x-e.x,s=c.y-e.y;return Math.abs(l)>Math.abs(s)?l>0?"right":"left":Math.abs(s)>0?s>0?"bottom":"top":P(a)},"getSelfLoopSide"),V=m((t,e="top",r=0,d=0)=>{const a=t.x,f=t.y-r,h=t.width/2,c=t.height/2,l=Math.max(36,Math.min(100,t.width*.8)),s=C(Math.max(d,t.width*.35),36,l),i=C(Math.min(t.width,t.height)*.45,24,48);switch(e){case"bottom":{const o=f+c;return[{x:a-s/2,y:o},{x:a-s/2,y:o+i},{x:a+s/2,y:o+i},{x:a+s/2,y:o}]}case"right":{const o=a+h;return[{x:o,y:f-s/2},{x:o+i,y:f-s/2},{x:o+i,y:f+s/2},{x:o,y:f+s/2}]}case"left":{const o=a-h;return[{x:o,y:f-s/2},{x:o-i,y:f-s/2},{x:o-i,y:f+s/2},{x:o,y:f+s/2}]}default:{const o=f-c;return[{x:a-s/2,y:o},{x:a-s/2,y:o-i},{x:a+s/2,y:o-i},{x:a+s/2,y:o}]}}},"getSelfLoopPoints"),Z=m((t,e,r="top",d=0,a={})=>{const h=t.x,c=t.y-d,l=a.width??0,s=a.height??0;switch(r){case"bottom":return{x:h,y:Math.max(...e.map(i=>i.y))+s/2+4};case"right":return{x:Math.max(...e.map(i=>i.x))+l/2+4,y:c};case"left":return{x:Math.min(...e.map(i=>i.x))-l/2-4,y:c};default:return{x:h,y:Math.min(...e.map(i=>i.y))-s/2-4}}},"getSelfLoopLabelPosition"),B=m((t,e=0,{mergeSelfLoops:r=!0}={})=>{const d=new Map,a=[],f=t.graph()?.rankdir;return t.edges().forEach(h=>{const c=t.edge(h);if(r&&c.selfLoop){const l=c.selfLoop.id;d.has(l)||d.set(l,[]),d.get(l).push({edge:c,start:h.v,end:h.w})}else a.push({edge:c,start:h.v,end:h.w})}),d.forEach(h=>{if(h.length!==3){h.forEach(u=>a.push(u));return}h.sort((u,E)=>u.edge.selfLoop.order-E.edge.selfLoop.order);const[c,l,s]=h,i=c.edge.originalEdge??l.edge.originalEdge??s.edge.originalEdge??l.edge,o=t.node(i.start);if(!o){h.forEach(u=>a.push(u));return}const n={width:l.edge.width,height:l.edge.height},L=Q(t,o,h,i.start,f),w=V(o,L,e,n.width??0),y=Z(o,w,L,e,n),g={...l.edge,...i,id:i.id,points:w,start:i.start,end:i.end,x:y.x,y:y.y,width:n.width,height:n.height,labelStyle:l.edge.labelStyle,fromCluster:c.edge.fromCluster??l.edge.fromCluster??s.edge.fromCluster,toCluster:c.edge.toCluster??l.edge.toCluster??s.edge.toCluster};delete g.selfLoop,delete g.originalEdge,a.push({edge:g,start:g.start,end:g.end})}),a},"getEdgesToRender"),I=m(async({element:t,graph:e,diagramType:r,id:d,parentCluster:a,siteConfig:f})=>{const h=e.graph().rankdir;p.trace("Dir in recursive render - dir:",h);const{clusters:c,edgePaths:l,edgeLabels:s,nodes:i,rootGroups:o}=_(t,{edgePathsClass:"edgePaths"});e.nodes()?p.info("Recursive render XXX",e.nodes()):p.info("No nodes found for",e),e.edges().length>0&&p.info("Recursive edges",e.edge(e.edges()[0]));const n=U(r);await Promise.all(e.nodes().map(async function(y){const g=e.node(y);if(a!==void 0){const u=JSON.parse(JSON.stringify(a.clusterData));p.trace(`Setting data for parent cluster XXX + Node.id = `,y,` + data=`,u.height,` +Parent cluster`,a.height),e.setNode(a.id,u),e.parent(y)||(p.trace("Setting parent",y,a.id),e.setParent(y,a.id,u))}if(p.info("(Insert) Node XXX"+y+": "+JSON.stringify(e.node(y))),g?.clusterNode){p.info("Cluster identified XBX",y,g.width,e.node(y));const{ranksep:u,nodesep:E}=e.graph();g.graph.setGraph({...g.graph.graph(),ranksep:u+25,nodesep:E});const S=await oe({element:i,graph:g.graph,diagramType:r,id:d,parentCluster:e.node(y),siteConfig:f}),N=S.elem;z(g,N),g.diff=S.diff||0,p.info("New compound node after recursive render XAX",y,"width",g.width,"height",g.height),H(N,g)}else e.children(y).length>0?(p.trace("Cluster - the non recursive path XBX",y,g.id,g,g.width,"Graph:",e),p.trace(D(g.id,e)),b.set(g.id,{id:D(g.id,e),node:g})):(p.trace("Node - the non recursive path XAX",y,i,e.node(y),h),await J(i,e.node(y),{config:f,dir:h}))})),await m(async()=>{const y=e.edges().map(async function(g){const u=e.edge(g.v,g.w,g.name);if(p.info("Edge "+g.v+" -> "+g.w+": "+JSON.stringify(g)),p.info("Edge "+g.v+" -> "+g.w+": ",g," ",JSON.stringify(e.edge(g))),p.info("Fix",b,"ids:",g.v,g.w,"Translating: ",b.get(g.v),b.get(g.w)),n&&u.selfLoop){if(u.selfLoop.order!==1)return;const E={...u.originalEdge,...u,id:u.selfLoop.id,startLabelLeft:u.originalEdge?.startLabelLeft??u.startLabelLeft,startLabelRight:u.originalEdge?.startLabelRight??u.startLabelRight,endLabelLeft:u.originalEdge?.endLabelLeft??u.endLabelLeft,endLabelRight:u.originalEdge?.endLabelRight??u.endLabelRight};await X(s,E),u.width=E.width,u.height=E.height,u.labelStyle=E.labelStyle;return}await X(s,u)});await Promise.all(y)},"processEdges")();const{subGraphTitleTotalMargin:w}=T(f);return{elem:o,graph:e,groups:{clusters:c,edgePaths:l,edgeLabels:s,nodes:i,rootGroups:o},diagramType:r,id:d,mergeSelfLoops:n,subGraphTitleTotalMargin:w}},"measureDagreGraph"),M=m(t=>{p.info("############################################# XXX"),p.info("### Layout ### XXX"),p.info("############################################# XXX"),W(t)},"runDagreGraphLayout"),$=m((t,e,r)=>{const d=t.node(e);if(!d)return;const a={...d};return d?.clusterNode?a.y=(d.y??0)+r:t.children(e).length>0?a.height=(d.height??0)+r:a.y=(d.y??0)+r/2,a},"normalizeDagreNode"),v=m((t,e)=>{K.forEach(r=>{e[r]!==void 0&&(t[r]=e[r])})},"applyDagreNodeLayout"),ee=m((t,e,r,d)=>({...t,start:t.start??e,end:t.end??r,points:(t.points??[]).map(a=>({...a,y:typeof a.y=="number"?a.y+d:a.y}))}),"normalizeDagreEdge"),te=m((t,e)=>{const{graph:r,mergeSelfLoops:d,subGraphTitleTotalMargin:a=0}=e,f=new Map(t.nodes.map(c=>[c.id,c]));x(r).forEach(c=>{const l=$(r,c,a);if(!l)return;v(r.node(c),l);const s=f.get(c);s&&v(s,l)});const h=a/2;return t.edges=B(r,h,{mergeSelfLoops:d}).map(({edge:c,start:l,end:s})=>ee(c,l,s,h)),t},"applyDagreLayoutResult"),re=m(async({elem:t,graph:e,groups:{clusters:r,edgePaths:d},diagramType:a,id:f,mergeSelfLoops:h,subGraphTitleTotalMargin:c})=>{let l=0;await Promise.all(x(e).map(async function(o){const n=e.node(o);if(p.info("Position XBX => "+o+": ("+n.x,","+n.y,") width: ",n.width," height: ",n.height),n?.clusterNode)n.y+=c,p.info("A tainted cluster node XBX1",o,n.id,n.width,n.height,n.x,n.y,e.parent(o)),b.get(n.id).node=n,R(n);else if(e.children(o).length>0){p.info("A pure cluster node XBX1",o,n.id,n.x,n.y,n.width,n.height,e.parent(o)),n.height+=c,e.node(n.parentId);const L=n?.padding/2||0,w=n?.labelBBox?.height||0,y=w-L||0;p.debug("OffsetY",y,"labelHeight",w,"halfPadding",L),await F(r,n),b.get(n.id).node=n}else{const L=e.node(n.parentId);n.y+=c/2,p.info("A regular node XBX1 - using the padding",n.id,"parent",n.parentId,n.width,n.height,n.x,n.y,"offsetY",n.offsetY,"parent",L,L?.offsetY,n),R(n)}}));const s=c/2;return B(e,s,{mergeSelfLoops:h}).forEach(function({edge:o,start:n,end:L}){p.info("Edge "+n+" -> "+L+": "+JSON.stringify(o),o),o.points.forEach(u=>u.y+=s);const w=e.node(n),y=e.node(L),g=j(d,o,b,a,w,y,f);q(o,g)}),e.nodes().forEach(function(o){const n=e.node(o);p.info(o,n.type,n.diff),n.isGroup&&(l=n.diff)}),p.warn("Returning from recursive render XAX",t,l),{elem:t,diff:l}},"paintDagreLayoutCore"),oe=m(async t=>{const e=await I(t);return M(e.graph),await re(e)},"renderDagreSubgraph"),G=m(t=>{const e=new O({multigraph:!0,compound:!0}).setGraph({rankdir:t.direction,nodesep:t.config?.nodeSpacing||t.nodeSpacing||t.config?.flowchart?.nodeSpacing,ranksep:t.config?.rankSpacing||t.rankSpacing||t.config?.flowchart?.rankSpacing,marginx:8,marginy:8}).setDefaultEdgeLabel(function(){return{}});return t.nodes.forEach(r=>{e.setNode(r.id,{...r}),r.parentId&&e.setParent(r.id,r.parentId)}),p.debug("Edges:",t.edges),t.edges.forEach(r=>{if(r.start===r.end){const d=r.start,a=d+"---"+d+"---1",f=d+"---"+d+"---2",h=e.node(d);e.setNode(a,{domId:a,id:a,parentId:h.parentId,labelStyle:"",label:"",padding:0,shape:"labelRect",style:"",width:10,height:10}),e.setParent(a,h.parentId),e.setNode(f,{domId:f,id:f,parentId:h.parentId,labelStyle:"",padding:0,shape:"labelRect",label:"",style:"",width:10,height:10}),e.setParent(f,h.parentId);const c=structuredClone(r),l=structuredClone(r),s=structuredClone(r),i=structuredClone(r);l.originalEdge=c,l.selfLoop={id:c.id,order:0},s.originalEdge=c,s.selfLoop={id:c.id,order:1},i.originalEdge=c,i.selfLoop={id:c.id,order:2},l.label="",l.arrowTypeEnd="none",l.endLabelLeft="",l.endLabelRight="",l.startLabelLeft="",l.id=d+"-cyclic-special-1",s.startLabelRight="",s.startLabelLeft="",s.endLabelLeft="",s.endLabelRight="",s.arrowTypeStart="none",s.arrowTypeEnd="none",s.id=d+"-cyclic-special-mid",i.label="",i.startLabelRight="",i.startLabelLeft="",i.arrowTypeStart="none",h.isGroup&&(l.fromCluster=d,i.toCluster=d),i.id=d+"-cyclic-special-2",i.arrowTypeStart="none",e.setEdge(d,a,l,d+"-cyclic-special-0"),e.setEdge(a,f,s,d+"-cyclic-special-1"),e.setEdge(f,d,i,d+"-cyclic-special-2")}else e.setEdge(r.start,r.end,{...r},r.id)}),A(e),{graph:e}},"prepareLayoutForDagre"),ae=m(async(t,{element:e,preparedLayout:r})=>{const d=r??G(t),a=k(),f=await I({element:e,graph:d.graph,diagramType:t.type,id:t.diagramId,parentCluster:void 0,siteConfig:a});return d.measuredLayout=f,f},"measureDagreLayout"),ne=m((t,e)=>{const r=e.preparedLayout?.measuredLayout;if(!r)throw new Error("runDagreLayoutCore requires measureDagreLayout to run first");return M(r.graph),te(t,r),r},"runDagreLayoutCore"),se=m((t,{measure:e})=>x(e.graph).map(r=>e.graph.node(r)).filter(Boolean),"getDagrePaintNodes"),ie=m((t,e,{measure:r})=>t?r.graph.node(t):void 0,"getDagreEdgeNode"),fe=Y({prepareLayout:G,measureLayout:ae,runLayoutCore:ne,paintOptions:{clusterDb:b,getNodes:se,getEdgeNode:ie,skipNode:m((t,{measure:e})=>!e.graph.hasNode(t.id),"skipNode"),isCluster:m((t,{measure:e})=>e.graph.hasNode(t.id)&&(e.graph.children(t.id)??[]).length>0,"isCluster")}});export{te as applyDagreLayoutResult,B as getEdgesToRender,ae as measureDagreLayout,G as prepareLayoutForDagre,fe as render,ne as runDagreLayoutCore}; diff --git a/packages/tempo/public/v4/assets/chunks/defaultLocale.DX6XiGOO.js b/packages/tempo/public/v4/assets/chunks/defaultLocale.DX6XiGOO.js new file mode 100644 index 00000000..f001d161 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/defaultLocale.DX6XiGOO.js @@ -0,0 +1 @@ +function J(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)}function j(n,t){if(!isFinite(n)||n===0)return null;var e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"),i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function K(n){return n=j(Math.abs(n)),n?n[1]:NaN}function Q(n,t){return function(e,i){for(var o=e.length,a=[],c=0,h=n[0],M=0;o>0&&h>0&&(M+h+1>i&&(h=Math.max(1,i-M)),a.push(e.substring(o-=h,o+h)),!((M+=h+1)>i));)h=n[c=(c+1)%n.length];return a.reverse().join(t)}}function V(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}var W=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function $(n){if(!(t=W.exec(n)))throw new Error("invalid format: "+n);var t;return new L({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}$.prototype=L.prototype;function L(n){this.fill=n.fill===void 0?" ":n.fill+"",this.align=n.align===void 0?">":n.align+"",this.sign=n.sign===void 0?"-":n.sign+"",this.symbol=n.symbol===void 0?"":n.symbol+"",this.zero=!!n.zero,this.width=n.width===void 0?void 0:+n.width,this.comma=!!n.comma,this.precision=n.precision===void 0?void 0:+n.precision,this.trim=!!n.trim,this.type=n.type===void 0?"":n.type+""}L.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function _(n){n:for(var t=n.length,e=1,i=-1,o;e0&&(i=0);break}return i>0?n.slice(0,i)+n.slice(o+1):n}var N;function v(n,t){var e=j(n,t);if(!e)return N=void 0,n.toPrecision(t);var i=e[0],o=e[1],a=o-(N=Math.max(-8,Math.min(8,Math.floor(o/3)))*3)+1,c=i.length;return a===c?i:a>c?i+new Array(a-c+1).join("0"):a>0?i.slice(0,a)+"."+i.slice(a):"0."+new Array(1-a).join("0")+j(n,Math.max(0,t+a-1))[0]}function X(n,t){var e=j(n,t);if(!e)return n+"";var i=e[0],o=e[1];return o<0?"0."+new Array(-o).join("0")+i:i.length>o+1?i.slice(0,o+1)+"."+i.slice(o+1):i+new Array(o-i.length+2).join("0")}const O={"%":(n,t)=>(n*100).toFixed(t),b:n=>Math.round(n).toString(2),c:n=>n+"",d:J,e:(n,t)=>n.toExponential(t),f:(n,t)=>n.toFixed(t),g:(n,t)=>n.toPrecision(t),o:n=>Math.round(n).toString(8),p:(n,t)=>X(n*100,t),r:X,s:v,X:n=>Math.round(n).toString(16).toUpperCase(),x:n=>Math.round(n).toString(16)};function R(n){return n}var U=Array.prototype.map,Y=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function nn(n){var t=n.grouping===void 0||n.thousands===void 0?R:Q(U.call(n.grouping,Number),n.thousands+""),e=n.currency===void 0?"":n.currency[0]+"",i=n.currency===void 0?"":n.currency[1]+"",o=n.decimal===void 0?".":n.decimal+"",a=n.numerals===void 0?R:V(U.call(n.numerals,String)),c=n.percent===void 0?"%":n.percent+"",h=n.minus===void 0?"−":n.minus+"",M=n.nan===void 0?"NaN":n.nan+"";function T(f,g){f=$(f);var b=f.fill,p=f.align,m=f.sign,w=f.symbol,S=f.zero,E=f.width,F=f.comma,y=f.precision,C=f.trim,d=f.type;d==="n"?(F=!0,d="g"):O[d]||(y===void 0&&(y=12),C=!0,d="g"),(S||b==="0"&&p==="=")&&(S=!0,b="0",p="=");var q=(g&&g.prefix!==void 0?g.prefix:"")+(w==="$"?e:w==="#"&&/[boxX]/.test(d)?"0"+d.toLowerCase():""),B=(w==="$"?i:/[%p]/.test(d)?c:"")+(g&&g.suffix!==void 0?g.suffix:""),D=O[d],H=/[defgprs%]/.test(d);y=y===void 0?6:/[gprs]/.test(d)?Math.max(1,Math.min(21,y)):Math.max(0,Math.min(20,y));function G(r){var l=q,u=B,x,I,k;if(d==="c")u=D(r)+u,r="";else{r=+r;var P=r<0||1/r<0;if(r=isNaN(r)?M:D(Math.abs(r),y),C&&(r=_(r)),P&&+r==0&&m!=="+"&&(P=!1),l=(P?m==="("?m:h:m==="-"||m==="("?"":m)+l,u=(d==="s"&&!isNaN(r)&&N!==void 0?Y[8+N/3]:"")+u+(P&&m==="("?")":""),H){for(x=-1,I=r.length;++xk||k>57){u=(k===46?o+r.slice(x+1):r.slice(x))+u,r=r.slice(0,x);break}}}F&&!S&&(r=t(r,1/0));var z=l.length+r.length+u.length,s=z>1)+l+r+u+s.slice(z);break;default:r=s+l+r+u;break}return a(r)}return G.toString=function(){return f+""},G}function Z(f,g){var b=Math.max(-8,Math.min(8,Math.floor(K(g)/3)))*3,p=Math.pow(10,-b),m=T((f=$(f),f.type="f",f),{suffix:Y[8+b/3]});return function(w){return m(p*w)}}return{format:T,formatPrefix:Z}}var A,tn,rn;en({thousands:",",grouping:[3],currency:["$",""]});function en(n){return A=nn(n),tn=A.format,rn=A.formatPrefix,A}export{rn as a,tn as b,K as e,$ as f}; diff --git a/packages/tempo/public/v4/assets/chunks/diagram-S7CK7UJ4.BFoB1FMC.js b/packages/tempo/public/v4/assets/chunks/diagram-S7CK7UJ4.BFoB1FMC.js new file mode 100644 index 00000000..dc08cc93 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/diagram-S7CK7UJ4.BFoB1FMC.js @@ -0,0 +1,30 @@ +import{I as X}from"./chunk-2Q5K7J3B.3yPGAHkH.js";import{p as z}from"./chunk-JWPE2WC7.5yopTNlD.js";import{p as O,b as G,s as Y,q as P,g as F,a as q,_ as g,D as N,l as A,G as Z,d as U,A as E,r as j,i as J,ak as K,E as Q,al as ee}from"../app.CbekdYod.js";import{p as te}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var D=/[─━│┃└┗├┣]/,L=/[└┗├┣]/,ne=/[─━]/,k=/^[\s│┃]+$/,T=/^\s*(title[\t ]|accTitle[\t ]*:|accDescr[\t ]*[:{])/,V=/^\s*%%/,re=" ";function _(n){return n.some(t=>D.test(t))}g(_,"isBoxDrawingFormat");function M(n){for(const t of n){const e=L.exec(t);if(e?.index&&e.index>0)return e.index}return 4}g(M,"inferSegmentWidth");function S(n,t){return n.replace(/\bline\s+(\d+)\b/gi,(e,r)=>{const s=parseInt(r,10),i=t.get(s);return i?`line ${i}`:e})}g(S,"remapErrorLines");function R(n){const t=n.split(` +`),e=new Map;let r=-1;for(const[p,c]of t.entries())if(c.trim()==="treeView-beta"){r=p;break}if(r===-1)return{text:n,lineMap:e};const s=[];for(let p=r+1;p({cnt:1,stack:[{id:0,level:-1,name:"/",nodeType:"directory",children:[]}]})),ie=g(()=>{x.reset(),j()},"clear"),oe=g(()=>x.records.stack[0],"getRoot"),se=g(()=>x.records.cnt,"getCount"),ae=Q.treeView,ce=g(()=>N(ae,E().treeView),"getConfig"),le=g((n,t,e,r,s,i)=>{for(;n<=x.records.stack[x.records.stack.length-1].level;)x.records.stack.pop();const o={id:x.records.cnt++,level:n,name:t,nodeType:e,icon:s,cssClass:r,description:i,children:[]};x.records.stack[x.records.stack.length-1].children.push(o),x.records.stack.push(o)},"addNode"),de={clear:ie,addNode:le,getRoot:oe,getCount:se,getConfig:ce,getAccTitle:q,getAccDescription:F,getDiagramTitle:P,setAccDescription:Y,setAccTitle:G,setDiagramTitle:O},I=de,he=g(n=>{z(n,I);for(const t of n.nodes){const e=typeof t.indent=="number"?t.indent:0;let r=t.name;const s=r.endsWith("/");s&&(r=r.slice(0,-1));const i=s?"directory":"file",o=t.classAnnotation||void 0,a=t.iconAnnotation,p=a!==void 0?a||"none":void 0,c=t.descAnnotation||void 0,d=c?J(c,E()):void 0;I.addNode(e,r,i,o,p,d)}},"populate"),pe={parse:g(async n=>{const{text:t,lineMap:e}=R(n);try{const r=await te("treeView",t);A.debug(r),he(r)}catch(r){throw e.size>0&&r instanceof Error&&(r.message=S(r.message,e)),r}},"parse")},b={prefix:"mermaid-treeview",height:24,width:24,icons:{folder:{body:''},file:{body:''}}};function H(n,t){const e=t?.filenameIcons?.[n];if(e)return e;const r=n.lastIndexOf(".");if(r>0){const s=n.substring(r).toLowerCase(),i=t?.extensionIcons;return i?.[s]??i?.[s.slice(1)]}}g(H,"detectIcon");function C(n,t){return n.includes(":")?n:n in b.icons||!t?`${b.prefix}:${n}`:`${t}:${n}`}g(C,"qualifyIcon");function B(n,t){if(n.icon!=="none"){if(n.icon)return C(n.icon,t.defaultIconPack);if(t.showIcons){if(n.nodeType==="file"){const e=H(n.name,t);if(e==="none")return;if(e)return C(e,t.defaultIconPack)}return`${b.prefix}:${n.nodeType==="directory"?"folder":"file"}`}}}g(B,"getNodeIcon");ee([{name:b.prefix,icons:b}]);var y=14,ge=4,fe=16,ue=g(async(n,t)=>{const e=[],r=g(i=>{const o=B(i,t);o&&e.push({icon:o,node:i}),i.children.forEach(r)},"collect");r(n);const s=await Promise.all(e.map(async({icon:i,node:o})=>({id:o.id,svg:await K(i,{height:y,width:y})})));return new Map(s.map(({id:i,svg:o})=>[i,o]))},"resolveNodeIcons"),we=g((n,t,e,r,s,i)=>{const o=r.append("g");let a="treeView-node-label";e.nodeType==="directory"&&(a+=" treeView-node-dir"),e.cssClass&&(a+=` ${e.cssClass}`);const p=y+ge,c=B(e,s),d=c!==void 0;c&&o.append("g").attr("class","treeView-node-icon").attr("transform",`translate(${n+s.paddingX}, ${t+s.paddingY})`).html(i.get(e.id)??"");const h=o.append("text").text(e.name).attr("dominant-baseline","middle").attr("class",a),{height:l,width:w}=h.node().getBBox(),f=l+s.paddingY*2,m=n+s.paddingX+(d?p:0);h.attr("x",m),h.attr("y",t+f/2);const u=m+w,v=w+s.paddingX*2+(d?p:0);return e.BBox={x:n,y:t,width:v,height:f},e.cssClass?.split(/\s+/).includes("highlight")&&o.insert("rect",":first-child").attr("x",n).attr("y",t+1).attr("width",0).attr("height",f-2).attr("rx",3).attr("class","treeView-highlight-bg"),{node:e,nodeGroup:o,labelRightEdge:u,centerY:t+f/2}},"positionLabel"),$=g((n,t,e,r,s,i)=>n.append("line").attr("x1",t).attr("y1",e).attr("x2",r).attr("y2",s).attr("stroke-width",i).attr("class","treeView-node-line"),"positionLine"),me=g((n,t,e,r)=>{let s=0,i=0;const o=[],a=g((d,h,l,w)=>{const f=w*(l.rowIndent+l.paddingX),m=we(f,s,h,d,l,r);o.push(m);const{height:u,width:v}=h.BBox;$(d,f-l.rowIndent,s+u/2,f,s+u/2,l.lineThickness),i=Math.max(i,f+v),s+=u},"drawNode"),p=g((d,h=0)=>{a(n,d,e,h),d.children.forEach(m=>{p(m,h+1)});const{x:l,y:w,height:f}=d.BBox;if(d.children.length){const{y:m,height:u}=d.children[d.children.length-1].BBox;$(n,l+e.paddingX,w+f,l+e.paddingX,m+u/2+e.lineThickness/2,e.lineThickness)}},"processNode");p(t);const c=o.filter(d=>d.node.description);if(c.length>0){const h=Math.max(...o.map(l=>l.labelRightEdge))+fe;for(const l of c){const f=l.nodeGroup.append("text").text(l.node.description).attr("dominant-baseline","middle").attr("class","treeView-node-description").attr("x",h).attr("y",l.centerY).node().getBBox();i=Math.max(i,h+f.width+e.paddingX)}}for(const d of o)if(d.node.cssClass?.split(/\s+/).includes("highlight")){const h=d.nodeGroup.select(".treeView-highlight-bg");if(!h.empty()){const l=i-d.node.BBox.x+8;h.attr("width",l),i=Math.max(i,d.node.BBox.x+l+2)}}return{totalHeight:s,totalWidth:i}},"drawTree"),xe=g(async(n,t,e,r)=>{A.debug(`Rendering treeView diagram +`+n);const s=r.db,i=s.getRoot(),o=s.getConfig(),a=Z(t),p=a.append("g");p.attr("class","tree-view");const c=await ue(i,o),{totalHeight:d,totalWidth:h}=me(p,i,o,c);a.attr("viewBox",`-${o.lineThickness/2} 0 ${h} ${d}`),U(a,d,h,o.useMaxWidth)},"draw"),ve={draw:xe},be=ve,Ie={labelFontSize:"16px",labelColor:"black",lineColor:"black",iconColor:"#546e7a",descriptionColor:"#6a9955",highlightBg:"rgba(255, 193, 7, 0.15)",highlightStroke:"#ffc107"},Ce=g(({treeView:n})=>{const{labelFontSize:t,labelColor:e,lineColor:r,iconColor:s,descriptionColor:i,highlightBg:o,highlightStroke:a}=N(Ie,n);return` + .treeView-node-label { + font-size: ${t}; + fill: ${e}; + white-space: pre; + } + .treeView-node-dir { + font-weight: bold; + } + .treeView-node-line { + stroke: ${r}; + } + .treeView-node-icon { + color: ${s}; + } + .treeView-node-description { + font-size: ${t}; + fill: ${i}; + font-style: italic; + white-space: pre; + } + .treeView-highlight-bg { + fill: ${o}; + stroke: ${a}; + stroke-width: 1; + } + `},"styles"),ye=Ce,Ae={db:I,renderer:be,parser:pe,styles:ye};export{Ae as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/diagram-UQ7AKVKN.gzh-btDB.js b/packages/tempo/public/v4/assets/chunks/diagram-UQ7AKVKN.gzh-btDB.js new file mode 100644 index 00000000..63c06d4d --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/diagram-UQ7AKVKN.gzh-btDB.js @@ -0,0 +1,41 @@ +import{p as I}from"./chunk-JWPE2WC7.5yopTNlD.js";import{s as _,g as E,q as D,p as F,a as G,b as P,_ as c,G as z,r as B,D as w,A as C,E as W,l as b,X as V,d as H}from"../app.CbekdYod.js";import{p as X}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var x={showLegend:!0,ticks:5,max:null,min:0,graticule:"circle"},y=32,A={axes:[],curves:[],options:x},m=structuredClone(A),j=W.radar,U=c(()=>w({...j,...C().radar}),"getConfig"),M=c(()=>m.axes,"getAxes"),q=c(()=>m.curves,"getCurves"),K=c(()=>m.options,"getOptions"),N=c(a=>{m.axes=a.map(t=>({name:t.name,label:t.label??t.name}))},"setAxes"),Y=c(a=>{m.curves=a.map(t=>({name:t.name,label:t.label??t.name,entries:Z(t.entries)}))},"setCurves"),Z=c(a=>{if(a[0].axis==null)return a.map(e=>e.value);const t=M();if(t.length===0)throw new Error("Axes must be populated before curves for reference entries");return t.map(e=>{const r=a.find(s=>s.axis?.$refText===e.name);if(r===void 0)throw new Error("Missing entry for axis "+e.label);return r.value})},"computeCurveEntries"),J=c(a=>{const t=a.reduce((e,r)=>(e[r.name]=r,e),{});m.options={showLegend:t.showLegend?.value??x.showLegend,ticks:t.ticks?.value??x.ticks,max:t.max?.value??x.max,min:t.min?.value??x.min,graticule:t.graticule?.value??x.graticule},m.options.ticks>y&&(b.warn(`Radar diagram ticks (${m.options.ticks}) exceeds maximum allowed (${y}). Using ${y} instead.`),m.options.ticks=y)},"setOptions"),Q=c(()=>{B(),m=structuredClone(A)},"clear"),$={getAxes:M,getCurves:q,getOptions:K,setAxes:N,setCurves:Y,setOptions:J,getConfig:U,clear:Q,setAccTitle:P,getAccTitle:G,setDiagramTitle:F,getDiagramTitle:D,getAccDescription:E,setAccDescription:_},tt=c(a=>{I(a,$);const{axes:t,curves:e,options:r}=a;$.setAxes(t),$.setCurves(e),$.setOptions(r)},"populate"),et={parse:c(async a=>{const t=await X("radar",a);b.debug(t),tt(t)},"parse")},at=c((a,t,e,r)=>{const s=r.db,i=s.getAxes(),l=s.getCurves(),n=s.getOptions(),o=s.getConfig(),d=s.getDiagramTitle(),p=z(t),u=rt(p,o),g=n.max??Math.max(...l.map(f=>Math.max(...f.entries))),h=n.min,v=Math.min(o.width,o.height)/2;st(u,i,v,n.ticks,n.graticule),nt(u,i,v,o),L(u,i,l,h,g,n.graticule,o),k(u,l,n.showLegend,o),u.append("text").attr("class","radarTitle").text(d).attr("x",0).attr("y",-o.height/2-o.marginTop)},"draw"),rt=c((a,t)=>{const e=t.width+t.marginLeft+t.marginRight,r=t.height+t.marginTop+t.marginBottom,s={x:t.marginLeft+t.width/2,y:t.marginTop+t.height/2};return H(a,r,e,t.useMaxWidth??!0),a.attr("viewBox",`0 0 ${e} ${r}`).attr("overflow","visible"),a.append("g").attr("transform",`translate(${s.x}, ${s.y})`)},"drawFrame"),st=c((a,t,e,r,s)=>{if(s==="circle")for(let i=0;i{const u=2*p*Math.PI/i-Math.PI/2,g=n*Math.cos(u),h=n*Math.sin(u);return`${g},${h}`}).join(" ");a.append("polygon").attr("points",o).attr("class","radarGraticule")}}},"drawGraticule"),nt=c((a,t,e,r)=>{const s=t.length;for(let i=0;i.01?"start":o<-.01?"end":"middle",u=d>.01?"hanging":d<-.01?"auto":"central",g=4;a.append("text").text(l).attr("x",e*r.axisLabelFactor*o+g*o).attr("y",e*r.axisLabelFactor*d+g*d).attr("text-anchor",p).attr("dominant-baseline",u).attr("class","radarAxisLabel")}},"drawAxes");function L(a,t,e,r,s,i,l){const n=t.length,o=Math.min(l.width,l.height)/2;e.forEach((d,p)=>{if(d.entries.length!==n)return;const u=d.entries.map((g,h)=>{const v=2*Math.PI*h/n-Math.PI/2,f=T(g,r,s,o),O=f*Math.cos(v),R=f*Math.sin(v);return{x:O,y:R}});i==="circle"?a.append("path").attr("d",S(u,l.curveTension)).attr("class",`radarCurve-${p}`):i==="polygon"&&a.append("polygon").attr("points",u.map(g=>`${g.x},${g.y}`).join(" ")).attr("class",`radarCurve-${p}`)})}c(L,"drawCurves");function T(a,t,e,r){const s=Math.min(Math.max(a,t),e);return r*(s-t)/(e-t)}c(T,"relativeRadius");function S(a,t){const e=a.length;let r=`M${a[0].x},${a[0].y}`;for(let s=0;s{const d=a.append("g").attr("transform",`translate(${s}, ${i+o*l})`);d.append("rect").attr("width",12).attr("height",12).attr("class",`radarLegendBox-${o}`),d.append("text").attr("x",16).attr("y",0).attr("class","radarLegendText").text(n.label)})}c(k,"drawLegend");var ot={draw:at},it=c((a,t)=>{let e="";for(let r=0;r{const t=V(),e=C(),r=w(t,e.themeVariables),s=w(r.radar,a);return{themeVariables:r,radarOptions:s}},"buildRadarStyleOptions"),ct=c(({radar:a}={})=>{const{themeVariables:t,radarOptions:e}=lt(a);return` + .radarTitle { + font-size: ${t.fontSize}; + color: ${t.titleColor}; + dominant-baseline: hanging; + text-anchor: middle; + } + .radarAxisLine { + stroke: ${e.axisColor}; + stroke-width: ${e.axisStrokeWidth}; + } + .radarAxisLabel { + font-size: ${e.axisLabelFontSize}px; + color: ${e.axisColor}; + } + .radarGraticule { + fill: ${e.graticuleColor}; + fill-opacity: ${e.graticuleOpacity}; + stroke: ${e.graticuleColor}; + stroke-width: ${e.graticuleStrokeWidth}; + } + .radarLegendText { + text-anchor: start; + font-size: ${e.legendFontSize}px; + dominant-baseline: hanging; + } + ${it(t,e)} + `},"styles"),xt={parser:et,db:$,renderer:ot,styles:ct};export{xt as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/diagram-VSXAHHWV.BOdI9TU8.js b/packages/tempo/public/v4/assets/chunks/diagram-VSXAHHWV.BOdI9TU8.js new file mode 100644 index 00000000..29969efd --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/diagram-VSXAHHWV.BOdI9TU8.js @@ -0,0 +1,3 @@ +import{p as re}from"./chunk-JWPE2WC7.5yopTNlD.js";import{q as oe,p as se,s as de,g as le,a as ce,b as me,_ as o,l as g,c as D,j as ue,B as xe,r as fe,D as ge,A as M,E as he,i as y,w as P,am as pe}from"../app.CbekdYod.js";import{p as be,i as ve}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var T="position frame",$="frame positioned",S="position relation",N="relation positioned",we=o(function(e){g.debug("options str",e)},"setOptions"),ye=o(function(){return{}},"getOptions"),Pe=o(function(){C(),fe()},"clear");function C(){B={}}o(C,"reset");var Se=he.eventmodeling,ke=o(()=>ge({...Se,...M().eventmodeling}),"getConfig"),B={};function O(){let e=Fe;const{ast:n}=B,t=E();if(!n)throw new Error("No data for EventModel");return n.frames.forEach((i,a)=>{const r=G(i,n.dataEntities,t);e=v(e,{$kind:T,index:a,frame:i,textProps:r});let d;K(i)?(g.debug("source frame",i.sourceFrames),d=n.frames.filter(l=>i.sourceFrames.some(c=>c.$refText===l.name)),d.forEach(l=>{e=v(e,{$kind:S,index:a,frame:i,sourceFrame:l})})):e=v(e,{$kind:S,index:a,frame:i})}),e={...e,sortedSwimlanesArray:A(e.swimlanes)},e}o(O,"getState");function I(e){B.ast=e}o(I,"setAst");var s={swimlaneMinHeight:70,swimlanePadding:15,swimlaneGap:10,boxPadding:10,boxOverlap:90,boxDefaultY:0,boxMinWidth:80,boxMaxWidth:450,boxMinHeight:80,boxMaxHeight:750,contentStartX:250,textMaxWidth:430,boxTextFontWeight:"bold",boxTextPadding:10,swimlaneTextFontWeight:"bold",labelUiAutomation:"UI/Automation",labelUiAutomationPrefix:"UI/A: ",labelCommandReadModel:"Command/Read Model",labelCommandReadModelPrefix:"C/RM: ",labelEvents:"Events",labelEventsPrefix:"Stream: "};function E(){return s}o(E,"getDiagramProps");var Fe={boxes:[],swimlanes:{},relations:[],maxR:0,sortedSwimlanesArray:[]};function W(e){const n=e.split(".");if(n.length===2)return n[0]}o(W,"extractNamespace");function H(e){const n=e.split(".");return n.length===2?n[1]:e}o(H,"extractName");function U(e,n){if(!(!n||n.length===0))return Object.values(e).find(t=>t.namespace===n)}o(U,"findSwimlaneByNamespace");function b(e,n,t){return Math.max(n,...Object.keys(e).filter(i=>{const a=Number.parseInt(i);return a>n&&aNumber.parseInt(i)))+1}o(b,"findNextAvailableIndex");function _(e,n){const t=W(e.entityIdentifier),i=U(n,t);switch(e.modelEntityType){case"ui":case"pcr":case"processor":return i?{index:i.index,label:i.namespace||s.labelUiAutomation}:t?{index:b(n,0,100),label:s.labelUiAutomationPrefix+t}:{index:0,label:s.labelUiAutomation};case"rmo":case"readmodel":case"cmd":case"command":return i?{index:i.index,label:i.namespace||s.labelCommandReadModel}:t?{index:b(n,100,200),label:s.labelCommandReadModelPrefix+t}:{index:100,label:s.labelCommandReadModel};default:return i?{index:i.index,label:i.namespace||s.labelEvents}:t?{index:b(n,200,300),label:s.labelEventsPrefix+t}:{index:200,label:s.labelEvents}}}o(_,"calculateSwimlaneProps");function L(e){const{themeVariables:n}=M();switch(e.modelEntityType){case"ui":return{fill:n.emUiFill??"white",stroke:n.emUiStroke??"#dbdada"};case"pcr":case"processor":return{fill:n.emProcessorFill??"#edb3f6",stroke:n.emProcessorStroke??"#b88cbf"};case"rmo":case"readmodel":return{fill:n.emReadModelFill??"#d3f1a2",stroke:n.emReadModelStroke??"#a3b732"};case"cmd":case"command":return{fill:n.emCommandFill??"#bcd6fe",stroke:n.emCommandStroke??"#679ac3"};case"evt":case"event":return{fill:n.emEventFill??"#ffb778",stroke:n.emEventStroke??"#c19a0f"};default:return{fill:"red",stroke:"black"}}}o(L,"calculateEntityVisualProps");function G(e,n,t){const i=M(),a=y(H(e.entityIdentifier)??"",i);let r;const d={fontSize:16,fontWeight:700,fontFamily:'"trebuchet ms", verdana, arial, sans-serif',joinWith:"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "};let c=`${P(a,t.textMaxWidth,d)}`;if(e.dataInlineValue&&(r=e.dataInlineValue,r=r.substring(r.indexOf("{")+1),r=r.substring(0,r.lastIndexOf("}")-1),r=y(r,i),r=P(r,t.textMaxWidth,d),r=r.replaceAll(" "," ")),e.dataReference){const p=n.find(w=>w.name===e.dataReference?.$refText);p&&(r=p.dataBlockValue,r=r.substring(r.indexOf(`{ +`)+2),r=r.substring(0,r.lastIndexOf("}")-1),r=y(r,i),r=P(r,t.textMaxWidth,d),r=r.replaceAll(" "," "),r+="
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ")}const m=r!==void 0;m&&(c+=`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ${r}`);const x={fontSize:d.fontSize,fontWeight:d.fontWeight,fontFamily:d.fontFamily},u=pe(c,x),h=m?u.width/3:u.width,f={content:c,width:h,height:u.height};return g.debug(`[${e.name}] ${e.entityIdentifier} text`,f),f}o(G,"calculateTextProps");function V(e,n){const t=n,i=L(t.frame),a={width:t.textProps.width+2*s.boxTextPadding,height:t.textProps.height+2*s.boxTextPadding};return[{$kind:$,frame:t.frame,index:t.index,visual:i,dimension:a,textProps:t.textProps}]}o(V,"decidePositionFrame");function X(e,n,t){return n===void 0?s.contentStartX:n.index===e.index&&e.r?e.r+s.boxPadding:t===void 0?s.contentStartX:t.r-s.boxOverlap+s.boxPadding}o(X,"calculateX");function j(e,n){const t=[...e.map(i=>i.r),n];return Math.max(...t)}o(j,"calculateMaxRight");function A(e){return Object.values(e).sort((n,t)=>n.index-t.index)}o(A,"sortedSwimlanesArray");function Y(e,n){const t=n,i=_(t.frame,e.swimlanes);let a;i.index in e.swimlanes?a=e.swimlanes[i.index]:a={index:i.index,label:i.label,r:0,y:i.index*s.swimlaneMinHeight+s.swimlaneGap,height:s.swimlaneMinHeight,maxHeight:s.swimlaneMinHeight};const r=e.boxes.length>0?e.boxes[e.boxes.length-1]:void 0,d=e.previousSwimlaneNumber!==void 0?e.swimlanes[e.previousSwimlaneNumber]:void 0,l={width:Math.max(s.boxMinWidth,Math.min(s.boxMaxWidth,t.dimension.width))+2*s.boxPadding,height:Math.max(s.boxMinHeight,Math.min(s.boxMaxHeight,t.dimension.height))+2*s.boxPadding},c=X(a,d,r),m=c+l.width+s.boxPadding,x=j(Object.values(e.swimlanes),m);a.r=c+l.width,a.maxHeight=Math.max(a.maxHeight,l.height),a.height=Math.max(s.swimlaneMinHeight,a.maxHeight)+2*s.swimlanePadding;const u={x:c,y:s.swimlanePadding+a.y,r:m,dimension:l,leftSibling:!1,swimlane:a,visual:t.visual,text:t.textProps.content,frame:t.frame,index:t.index},h={...e,boxes:[...e.boxes,u],swimlanes:{...e.swimlanes,[`${a.index}`]:a},previousSwimlaneNumber:i.index,previousFrame:t.frame,maxR:x},f=A(h.swimlanes);f.length>0&&(f[0].y=0);for(let p=1;p0}o(K,"hasSourceFrame");function k(e,n){if(n!=null)return e.find(t=>t.frame.name===n.name)}o(k,"findBoxByFrame");function q(e,n,t){if(!(t<0))for(let i=t;i>=0;i--){const a=e[i];if(a.swimlane.index!==n)return a}}o(q,"findBoxByLineIndex");function J(e,n){const t=n;if(ve(t.frame)||z(t.index,t.frame))return[];const i=k(e.boxes,t.frame);if(i===void 0)throw new Error(`Target box not found for frame ${t.frame.name}`);let a;return t.sourceFrame?a=k(e.boxes,t.sourceFrame):a=q(e.boxes,i.swimlane.index,t.index-1),a===void 0?[]:[{$kind:N,frame:t.frame,index:t.index,sourceBox:a,targetBox:i}]}o(J,"decidePositionRelation");function Q(e,n){const t=n,i={visual:{fill:"none",stroke:"#000"},source:{x:t.sourceBox.x,y:t.sourceBox.y},target:{x:t.targetBox.x,y:t.targetBox.y},sourceBox:t.sourceBox,targetBox:t.targetBox};return{...e,relations:[...e.relations,i]}}o(Q,"evolveRelationPositioned");var Me={[T]:V,[S]:J},Be={[$]:Y,[N]:Q};function Z(e,n){const t=Me[n.$kind];if(t==null)return[];const i=t(e,n);return g.debug("decided events",i),i}o(Z,"decide");function ee(e,n){const t=n.reduce((i,a)=>{const r=Be[a.$kind];return r==null?i:r(i,a)},e);return g.debug("evolve events",{state:e,newState:t,events:n}),t}o(ee,"evolve");function v(e,n){const t=Z(e,n);return ee(e,t)}o(v,"dispatch");var F={getConfig:ke,setOptions:we,getOptions:ye,clear:Pe,setAccTitle:me,getAccTitle:ce,getAccDescription:le,setAccDescription:de,setDiagramTitle:se,getDiagramTitle:oe,setAst:I,getDiagramProps:E,getState:O},Ee={parse:o(async e=>{const n=await be("eventmodeling",e);g.debug(n),F.setAst(n),re(n,F)},"parse")},Ae=D(),Re=Ae?.eventmodeling;function te(e,n){return t=>{const i=t.swimlane.y+n.swimlanePadding,a=e.append("g").attr("class","em-box");a.append("rect").attr("x",t.x).attr("y",i).attr("rx","3").attr("width",t.dimension.width).attr("height",t.dimension.height).attr("stroke",t.visual.stroke).attr("fill",t.visual.fill),a.append("foreignObject").attr("x",t.x+n.boxPadding).attr("y",i+10).attr("width",t.dimension.width-2*n.boxPadding).attr("height",t.dimension.height-2*n.boxPadding).append("xhtml:div").style("display","table").style("height","100%").style("width","100%").append("span").style("display","table-cell").style("text-align","center").style("vertical-align","middle").html(t.text)}}o(te,"renderD3Box");function ne(e,n){return e>n}o(ne,"dirUpwards");function ie(e,n,t,i){return a=>{const r=a.sourceBox.swimlane.y+n.swimlanePadding,d=a.targetBox.swimlane.y+n.swimlanePadding,l=ne(r,d),c=a.sourceBox.x+a.sourceBox.dimension.width*2/3,m=a.targetBox.x+a.targetBox.dimension.width/3;let x,u;g.debug(`rendering relation up=${l} for `,{sourceBox:a.sourceBox,targetBox:a.targetBox}),l?(x=r,u=d+a.targetBox.dimension.height):(x=r+a.sourceBox.dimension.height,u=d);const h=i.emRelationStroke??a.visual.stroke;e.append("path").attr("class","em-relation").attr("fill",a.visual.fill).attr("stroke",h).attr("stroke-width","1").attr("marker-end",`url(#${t})`).attr("d",`M${c} ${x} L${m} ${u}`)}}o(ie,"renderD3Relation");function ae(e,n,t,i){return a=>{const r=e.append("g").attr("class","em-swimlane"),d=i.emSwimlaneBackgroundOdd??"rgb(250,250,250)",l=i.emSwimlaneBackgroundStroke??"rgb(240,240,240)";r.append("rect").attr("x",0).attr("y",a.y).attr("rx","3").attr("width",n+t.swimlanePadding).attr("height",a.height).attr("fill",d).attr("stroke",l),r.append("text").attr("font-weight",t.swimlaneTextFontWeight).attr("x",30).attr("y",a.y+30).text(a.label)}}o(ae,"renderD3Swimlane");var De=o(function(e,n,t,i){if(g.debug("in eventmodeling renderer",e+` +`,"id:",n,t),!Re)throw new Error("EventModeling config not found");const a=i.db,{themeVariables:r,eventmodeling:d}=D(),l=ue(`[id="${n}"]`),c=a.getDiagramProps(),m=a.getState(),x=`em-arrowhead-${n}`,u=r.emArrowhead??"#000000";m.sortedSwimlanesArray.forEach(ae(l,m.maxR,c,r)),m.boxes.forEach(te(l,c)),m.relations.forEach(ie(l,c,x,r)),l.append("defs").append("marker").attr("id",x).attr("markerWidth","10").attr("markerHeight","7").attr("refX","10").attr("refY","3.5").attr("orient","auto").append("polygon").attr("points","0 0, 10 3.5, 0 7").attr("fill",u),xe(void 0,l,d?.padding??30,d?.useMaxWidth)},"draw"),Te={draw:De},$e=o(e=>"","getStyles"),Ne=$e,Ue={parser:Ee,db:F,renderer:Te,styles:Ne};export{Ue as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/diagram-VX7I27RA.CLNxhO1L.js b/packages/tempo/public/v4/assets/chunks/diagram-VX7I27RA.CLNxhO1L.js new file mode 100644 index 00000000..5faebb7c --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/diagram-VX7I27RA.CLNxhO1L.js @@ -0,0 +1,24 @@ +import{p as me}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as w,X as ge,A as te,D as Q,G as ye,d as Se,l as ee,bf as B,j as Y,b as ve,a as xe,p as be,q as we,g as Ce,s as Te,E as Le,bg as $e,r as Ae}from"../app.CbekdYod.js";import{s as Fe}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{p as Ne}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import{b as I}from"./defaultLocale.DX6XiGOO.js";import{o as K}from"./ordinal.BYWQX77i.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./init.Gi6I4Gst.js";function Me(e){var a=0,n=e.children,l=n&&n.length;if(!l)a=1;else for(;--l>=0;)a+=n[l].value;e.value=a}function _e(){return this.eachAfter(Me)}function ke(e,a){let n=-1;for(const l of this)e.call(a,l,++n,this);return this}function ze(e,a){for(var n=this,l=[n],r,o,h=-1;n=l.pop();)if(e.call(a,n,++h,this),r=n.children)for(o=r.length-1;o>=0;--o)l.push(r[o]);return this}function Ve(e,a){for(var n=this,l=[n],r=[],o,h,d,g=-1;n=l.pop();)if(r.push(n),o=n.children)for(h=0,d=o.length;h=0;)n+=l[r].value;a.value=n})}function Be(e){return this.eachBefore(function(a){a.children&&a.children.sort(e)})}function Ee(e){for(var a=this,n=Re(a,e),l=[a];a!==n;)a=a.parent,l.push(a);for(var r=l.length;e!==n;)l.splice(r,0,e),e=e.parent;return l}function Re(e,a){if(e===a)return e;var n=e.ancestors(),l=a.ancestors(),r=null;for(e=n.pop(),a=l.pop();e===a;)r=e,e=n.pop(),a=l.pop();return r}function We(){for(var e=this,a=[e];e=e.parent;)a.push(e);return a}function He(){return Array.from(this)}function Ie(){var e=[];return this.eachBefore(function(a){a.children||e.push(a)}),e}function Oe(){var e=this,a=[];return e.each(function(n){n!==e&&a.push({source:n.parent,target:n})}),a}function*Ge(){var e=this,a,n=[e],l,r,o;do for(a=n.reverse(),n=[];e=a.pop();)if(yield e,l=e.children)for(r=0,o=l.length;r=0;--d)r.push(o=h[d]=new U(h[d])),o.parent=l,o.depth=l.depth+1;return n.eachBefore(Ue)}function qe(){return ae(this).eachBefore(Ye)}function Xe(e){return e.children}function je(e){return Array.isArray(e)?e[1]:null}function Ye(e){e.data.value!==void 0&&(e.value=e.data.value),e.data=e.data.data}function Ue(e){var a=0;do e.height=a;while((e=e.parent)&&e.height<++a)}function U(e){this.data=e,this.depth=this.height=0,this.parent=null}U.prototype=ae.prototype={constructor:U,count:_e,each:ke,eachAfter:Ve,eachBefore:ze,find:De,sum:Pe,sort:Be,path:Ee,ancestors:We,descendants:He,leaves:Ie,links:Oe,copy:qe,[Symbol.iterator]:Ge};function Ze(e){if(typeof e!="function")throw new Error;return e}function O(){return 0}function G(e){return function(){return e}}function Je(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}function Ke(e,a,n,l,r){for(var o=e.children,h,d=-1,g=o.length,c=e.value&&(l-a)/e.value;++dN&&(N=c),M=u*u*R,$=Math.max(N/M,M/y),$>V){u-=c;break}V=$}h.push(g={value:u,dice:x1?l:1)},n})(et);function nt(){var e=at,a=!1,n=1,l=1,r=[0],o=O,h=O,d=O,g=O,c=O;function p(s){return s.x0=s.y0=0,s.x1=n,s.y1=l,s.eachBefore(b),r=[0],a&&s.eachBefore(Je),s}function b(s){var x=r[s.depth],S=s.x0+x,v=s.y0+x,u=s.x1-x,y=s.y1-x;u{$e(r)&&(n?.textStyles?n.textStyles.push(r):n.textStyles=[r]),n?.styles?n.styles.push(r):n.styles=[r]}),this.classes.set(e,n)}getClasses(){return this.classes}getStylesForClass(e){return this.classes.get(e)?.styles??[]}clear(){Ae(),this.nodes=[],this.levels=new Map,this.outerNodes=[],this.classes=new Map,this.root=void 0}};function oe(e){if(!e.length)return[];const a=[],n=[];return e.forEach(l=>{const r={name:l.name,children:l.type==="Leaf"?void 0:[]};for(r.classSelector=l?.classSelector,l?.cssCompiledStyles&&(r.cssCompiledStyles=l.cssCompiledStyles),l.type==="Leaf"&&l.value!==void 0&&(r.value=l.value);n.length>0&&n[n.length-1].level>=l.level;)n.pop();if(n.length===0)a.push(r);else{const o=n[n.length-1].node;o.children?o.children.push(r):o.children=[r]}l.type!=="Leaf"&&n.push({node:r,level:l.level})}),a}w(oe,"buildHierarchy");var lt=w((e,a)=>{me(e,a);const n=[];for(const o of e.TreemapRows??[])o.$type==="ClassDefStatement"&&a.addClass(o.className??"",o.styleText??"");for(const o of e.TreemapRows??[]){const h=o.item;if(!h)continue;const d=o.indent?parseInt(o.indent):0,g=rt(h),c=h.classSelector?a.getStylesForClass(h.classSelector):[],p=c.length>0?c:void 0,b={level:d,name:g,type:h.$type,value:h.value,classSelector:h.classSelector,cssCompiledStyles:p};n.push(b)}const l=oe(n),r=w((o,h)=>{for(const d of o)a.addNode(d,h),d.children&&d.children.length>0&&r(d.children,h+1)},"addNodesRecursively");r(l,0)},"populate"),rt=w(e=>e.name?String(e.name):"","getItemName"),ce={parser:{yy:void 0},parse:w(async e=>{try{const n=await Ne("treemap",e);ee.debug("Treemap AST:",n);const l=ce.parser?.yy;if(!(l instanceof ie))throw new Error("parser.parser?.yy was not a TreemapDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");lt(n,l)}catch(a){throw ee.error("Error parsing treemap:",a),a}},"parse")},st=10,E=10,q=25,it=w((e,a,n,l)=>{const r=l.db,o=r.getConfig(),h=o.padding??st,d=r.getDiagramTitle(),g=r.getRoot(),{themeVariables:c}=te();if(!g)return;const p=d?30:0,b=ye(a),s=o.nodeWidth?o.nodeWidth*E:960,x=o.nodeHeight?o.nodeHeight*E:500,S=s,v=x+p;b.attr("viewBox",`0 0 ${S} ${v}`),Se(b,v,S,o.useMaxWidth);let u;try{const t=o.valueFormat||",";if(t==="$0,0")u=w(i=>"$"+I(",")(i),"valueFormat");else if(t.startsWith("$")&&t.includes(",")){const i=/\.\d+/.exec(t),f=i?i[0]:"";u=w(C=>"$"+I(","+f)(C),"valueFormat")}else if(t.startsWith("$")){const i=t.substring(1);u=w(f=>"$"+I(i||"")(f),"valueFormat")}else u=I(t)}catch(t){ee.error("Error creating format function:",t),u=I(",")}const y=K().range(["transparent",c.cScale0,c.cScale1,c.cScale2,c.cScale3,c.cScale4,c.cScale5,c.cScale6,c.cScale7,c.cScale8,c.cScale9,c.cScale10,c.cScale11]),N=K().range(["transparent",c.cScalePeer0,c.cScalePeer1,c.cScalePeer2,c.cScalePeer3,c.cScalePeer4,c.cScalePeer5,c.cScalePeer6,c.cScalePeer7,c.cScalePeer8,c.cScalePeer9,c.cScalePeer10,c.cScalePeer11]),$=K().range([c.cScaleLabel0,c.cScaleLabel1,c.cScaleLabel2,c.cScaleLabel3,c.cScaleLabel4,c.cScaleLabel5,c.cScaleLabel6,c.cScaleLabel7,c.cScaleLabel8,c.cScaleLabel9,c.cScaleLabel10,c.cScaleLabel11]);d&&b.append("text").attr("x",S/2).attr("y",p/2).attr("class","treemapTitle").attr("text-anchor","middle").attr("dominant-baseline","middle").text(d);const V=b.append("g").attr("transform",`translate(0, ${p})`).attr("class","treemapContainer"),R=ae(g).sum(t=>t.value??0).sort((t,i)=>(i.value??0)-(t.value??0)),ne=nt().size([s,x]).paddingTop(t=>t.children&&t.children.length>0?q+E:0).paddingInner(h).paddingLeft(t=>t.children&&t.children.length>0?E:0).paddingRight(t=>t.children&&t.children.length>0?E:0).paddingBottom(t=>t.children&&t.children.length>0?E:0).round(!0)(R),he=ne.descendants().filter(t=>t.children&&t.children.length>0),W=V.selectAll(".treemapSection").data(he).enter().append("g").attr("class","treemapSection").attr("transform",t=>`translate(${t.x0},${t.y0})`);W.append("rect").attr("width",t=>t.x1-t.x0).attr("height",q).attr("class","treemapSectionHeader").attr("fill","none").attr("fill-opacity",.6).attr("stroke-width",.6).attr("style",t=>t.depth===0?"display: none;":""),W.append("clipPath").attr("id",(t,i)=>`clip-section-${a}-${i}`).append("rect").attr("width",t=>Math.max(0,t.x1-t.x0-12)).attr("height",q),W.append("rect").attr("width",t=>t.x1-t.x0).attr("height",t=>t.y1-t.y0).attr("class",(t,i)=>`treemapSection section${i}`).attr("fill",t=>y(t.data.name)).attr("fill-opacity",.6).attr("stroke",t=>N(t.data.name)).attr("stroke-width",2).attr("stroke-opacity",.4).attr("style",t=>{if(t.depth===0)return"display: none;";const i=B({cssCompiledStyles:t.data.cssCompiledStyles});return i.nodeStyles+";"+i.borderStyles.join(";")}),W.append("text").attr("class","treemapSectionLabel").attr("x",6).attr("y",q/2).attr("dominant-baseline","middle").text(t=>t.depth===0?"":t.data.name).attr("font-weight","bold").attr("clip-path",(t,i)=>`url(#clip-section-${a}-${i})`).attr("style",t=>{if(t.depth===0)return"display: none;";const i="dominant-baseline: middle; font-size: 12px; fill:"+$(t.data.name)+"; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;",f=B({cssCompiledStyles:t.data.cssCompiledStyles});return i+f.labelStyles.replace("color:","fill:")}).each(function(t){if(t.depth===0)return;const i=Y(this),f=t.data.name;i.text(f);const C=t.x1-t.x0,L=6;let T;o.showValues!==!1&&t.value?T=C-10-30-10-L:T=C-L-6;const m=Math.max(15,T),_=i.node();if(_.getComputedTextLength()>m){let z=f;for(;z.length>0;){if(z=f.substring(0,z.length-1),z.length===0){i.text("..."),_.getComputedTextLength()>m&&i.text("");break}if(i.text(z+"..."),_.getComputedTextLength()<=m)break}}}),o.showValues!==!1&&W.append("text").attr("class","treemapSectionValue").attr("x",t=>t.x1-t.x0-10).attr("y",q/2).attr("text-anchor","end").attr("dominant-baseline","middle").text(t=>t.value?u(t.value):"").attr("font-style","italic").attr("style",t=>{if(t.depth===0)return"display: none;";const i="text-anchor: end; dominant-baseline: middle; font-size: 10px; fill:"+$(t.data.name)+"; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;",f=B({cssCompiledStyles:t.data.cssCompiledStyles});return i+f.labelStyles.replace("color:","fill:")});const le=ne.leaves(),A=le.length>20,de=A?16:38,X=A?14:28,D=A?4:8,H=A?4:6,Z=A?2:4,re=A?8:10,J=A?1:2,j=V.selectAll(".treemapLeafGroup").data(le).enter().append("g").attr("class",(t,i)=>`treemapNode treemapLeafGroup leaf${i}${t.data.classSelector?` ${t.data.classSelector}`:""}x`).attr("transform",t=>`translate(${t.x0},${t.y0})`);j.append("rect").attr("width",t=>t.x1-t.x0).attr("height",t=>t.y1-t.y0).attr("class","treemapLeaf").attr("fill",t=>t.parent?y(t.parent.data.name):y(t.data.name)).attr("style",t=>B({cssCompiledStyles:t.data.cssCompiledStyles}).nodeStyles).attr("fill-opacity",.3).attr("stroke",t=>t.parent?y(t.parent.data.name):y(t.data.name)).attr("stroke-width",3),j.append("clipPath").attr("id",(t,i)=>`clip-${a}-${i}`).append("rect").attr("width",t=>Math.max(0,t.x1-t.x0-4)).attr("height",t=>Math.max(0,t.y1-t.y0-4)),j.append("text").attr("class","treemapLabel").attr("x",t=>(t.x1-t.x0)/2).attr("y",t=>(t.y1-t.y0)/2).attr("style",t=>{const i=`text-anchor: middle; dominant-baseline: middle; font-size: ${de}px;fill:`+$(t.data.name)+";",f=B({cssCompiledStyles:t.data.cssCompiledStyles});return i+f.labelStyles.replace("color:","fill:")}).attr("clip-path",(t,i)=>`url(#clip-${a}-${i})`).text(t=>t.data.name).each(function(t){const i=Y(this),f=t.x1-t.x0,C=t.y1-t.y0,L=i.node(),T=f-2*Z,P=C-2*Z;if(TT&&m>D;)m--,i.style("font-size",`${m}px`);let F=Math.max(H,Math.min(X,Math.round(m*_))),k=m+J+F;for(;k>P&&m>D&&(m--,F=Math.max(H,Math.min(X,Math.round(m*_))),!(FT||m(i.x1-i.x0)/2).attr("y",function(i){return(i.y1-i.y0)/2}).attr("style",i=>{const f=`text-anchor: middle; dominant-baseline: hanging; font-size: ${X}px;fill:`+$(i.data.name)+";",C=B({cssCompiledStyles:i.data.cssCompiledStyles});return f+C.labelStyles.replace("color:","fill:")}).attr("clip-path",(i,f)=>`url(#clip-${a}-${f})`).text(i=>i.value?u(i.value):"").each(function(i){const f=Y(this),C=this.parentNode;if(!C){f.style("display","none");return}const L=Y(C).select(".treemapLabel");if(L.empty()||L.style("display")==="none"){f.style("display","none");return}const T=parseFloat(L.style("font-size")),m=Math.max(H,Math.min(X,Math.round(T*.6)));f.style("font-size",`${m}px`);const F=(i.y1-i.y0)/2+T/2+J;f.attr("y",F);const k=i.x1-i.x0,se=i.y1-i.y0-4,fe=k-2*Z;f.node().getComputedTextLength()>fe||F+m>se||m{const a=ge(),n=te(),l=Q(a,n.themeVariables),r=Q(ht,e),o=r.titleColor??l.titleColor,h=r.labelColor??l.textColor,d=r.valueColor??l.textColor;return` + .treemapNode.section { + stroke: ${r.sectionStrokeColor}; + stroke-width: ${r.sectionStrokeWidth}; + fill: ${r.sectionFillColor}; + } + .treemapNode.leaf { + stroke: ${r.leafStrokeColor}; + stroke-width: ${r.leafStrokeWidth}; + fill: ${r.leafFillColor}; + } + .treemapLabel { + fill: ${h}; + font-size: ${r.labelFontSize}; + } + .treemapValue { + fill: ${d}; + font-size: ${r.valueFontSize}; + } + .treemapTitle { + fill: ${o}; + font-size: ${r.titleFontSize}; + } + `},"getStyles"),pt=dt,Ct={parser:ce,get db(){return new ie},renderer:ct,styles:pt};export{Ct as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/diagram-Z3DM3KII.CIAlmXh0.js b/packages/tempo/public/v4/assets/chunks/diagram-Z3DM3KII.CIAlmXh0.js new file mode 100644 index 00000000..b5b2b7b0 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/diagram-Z3DM3KII.CIAlmXh0.js @@ -0,0 +1,24 @@ +import{p as $}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as b,D as u,G as B,d as C,l as m,b as S,a as D,p as T,q as E,g as P,s as z,A,E as F,r as W}from"../app.CbekdYod.js";import{p as _}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var N=F.packet,w=class{constructor(){this.packet=[],this.setAccTitle=S,this.getAccTitle=D,this.setDiagramTitle=T,this.getDiagramTitle=E,this.getAccDescription=P,this.setAccDescription=z}static{b(this,"PacketDB")}getConfig(){const t=u({...N,...A().packet});return t.showBits&&(t.paddingY+=10),t}getPacket(){return this.packet}pushWord(t){t.length>0&&this.packet.push(t)}clear(){W(),this.packet=[]}},L=1e4,M=b((t,e)=>{$(t,e);let r=-1,s=[],n=1;const{bitsPerRow:l}=e.getConfig();for(let{start:a,end:i,bits:d,label:c}of t.blocks){if(a!==void 0&&i!==void 0&&i{if(t.start===void 0)throw new Error("start should have been set during first phase");if(t.end===void 0)throw new Error("end should have been set during first phase");if(t.start>t.end)throw new Error(`Block start ${t.start} is greater than block end ${t.end}.`);if(t.end+1<=e*r)return[t,void 0];const s=e*r-1,n=e*r;return[{start:t.start,end:s,label:t.label,bits:s-t.start},{start:n,end:t.end,label:t.label,bits:t.end-n}]},"getNextFittingBlock"),v={parser:{yy:void 0},parse:b(async t=>{const e=await _("packet",t),r=v.parser?.yy;if(!(r instanceof w))throw new Error("parser.parser?.yy was not a PacketDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");m.debug(e),M(e,r)},"parse")},G=b((t,e,r,s)=>{const n=s.db,l=n.getConfig(),{rowHeight:a,paddingY:i,bitWidth:d,bitsPerRow:c}=l,p=n.getPacket(),o=n.getDiagramTitle(),h=a+i,g=h*(p.length+1)-(o?0:a),k=d*c+2,f=B(e);f.attr("viewBox",`0 0 ${k} ${g}`),C(f,g,k,l.useMaxWidth);for(const[x,y]of p.entries())I(f,y,x,l);f.append("text").text(o).attr("x",k/2).attr("y",g-h/2).attr("dominant-baseline","middle").attr("text-anchor","middle").attr("class","packetTitle")},"draw"),I=b((t,e,r,{rowHeight:s,paddingX:n,paddingY:l,bitWidth:a,bitsPerRow:i,showBits:d})=>{const c=t.append("g"),p=r*(s+l)+l;for(const o of e){const h=o.start%i*a+1,g=(o.end-o.start+1)*a-n;if(c.append("rect").attr("x",h).attr("y",p).attr("width",g).attr("height",s).attr("class","packetBlock"),c.append("text").attr("x",h+g/2).attr("y",p+s/2).attr("class","packetLabel").attr("dominant-baseline","middle").attr("text-anchor","middle").text(o.label),!d)continue;const k=o.end===o.start,f=p-2;c.append("text").attr("x",h+(k?g/2:0)).attr("y",f).attr("class","packetByte start").attr("dominant-baseline","auto").attr("text-anchor",k?"middle":"start").text(o.start),k||c.append("text").attr("x",h+g).attr("y",f).attr("class","packetByte end").attr("dominant-baseline","auto").attr("text-anchor","end").text(o.end)}},"drawWord"),O={draw:G},j={byteFontSize:"10px",startByteColor:"black",endByteColor:"black",labelColor:"black",labelFontSize:"12px",titleColor:"black",titleFontSize:"14px",blockStrokeColor:"black",blockStrokeWidth:"1",blockFillColor:"#efefef"},q=b(({packet:t}={})=>{const e=u(j,t);return` + .packetByte { + font-size: ${e.byteFontSize}; + } + .packetByte.start { + fill: ${e.startByteColor}; + } + .packetByte.end { + fill: ${e.endByteColor}; + } + .packetLabel { + fill: ${e.labelColor}; + font-size: ${e.labelFontSize}; + } + .packetTitle { + fill: ${e.titleColor}; + font-size: ${e.titleFontSize}; + } + .packetBlock { + stroke: ${e.blockStrokeColor}; + stroke-width: ${e.blockStrokeWidth}; + fill: ${e.blockFillColor}; + } + `},"styles"),J={parser:v,get db(){return new w},renderer:O,styles:q};export{J as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/ebnfDiagram-PWID7BFC.Dni2gpVx.js b/packages/tempo/public/v4/assets/chunks/ebnfDiagram-PWID7BFC.Dni2gpVx.js new file mode 100644 index 00000000..9d4ce2e7 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/ebnfDiagram-PWID7BFC.Dni2gpVx.js @@ -0,0 +1 @@ +import{g as l,r as m,d as n}from"./chunk-SVP7TREG.tNKCi1Yy.js";import{p}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as t,l as o}from"../app.CbekdYod.js";import{M as u,a as f}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var c=f().RailroadEbnf.parser.LangiumParser,s=t(e=>{const r=e.alternatives.map(E);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformChoice"),E=t(e=>{const r=e.elements.map(d);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformSequence"),i=t(e=>{switch(e.$type){case"EbnfTerminal":return{type:"terminal",value:e.value};case"EbnfNonTerminal":return{type:"nonterminal",name:e.name};case"EbnfSpecial":return{type:"special",text:e.text};case"EbnfGroup":return s(e.element);case"EbnfOptional":return{type:"optional",element:s(e.element)};case"EbnfRepetition":return{type:"repetition",element:s(e.element),min:0,max:1/0};default:throw new Error(`Unsupported EBNF primary node: ${e.$type}`)}},"transformPrimary"),b=t((e,r)=>{switch(r.$type){case"EbnfOptionalPostfix":return{type:"optional",element:e};case"EbnfZeroOrMorePostfix":return{type:"repetition",element:e,min:0,max:1/0};case"EbnfOneOrMorePostfix":return{type:"repetition",element:e,min:1,max:1/0};case"EbnfExceptionPostfix":return{type:"sequence",elements:[e,{type:"terminal",value:"-"},i(r.except)]};default:throw new Error(`Unsupported EBNF postfix node: ${r.$type}`)}},"transformPostfix"),d=t(e=>e.postfixes.reduce((r,a)=>b(r,a),i(e.base)),"transformTerm"),y=t(e=>({name:e.name,definition:s(e.definition)}),"transformRule"),v=t(e=>{p(e,n),e.title&&n.setTitle(e.title),e.rules.map(r=>n.addRule(y(r)))},"populateDb"),g={parse:t(e=>{n.clear(),o.debug("[EBNF Parser] Starting Langium parse");const r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new u(r);const a=r.value;o.debug("[EBNF Parser] Parsed rules:",a.rules.length),v(a),o.debug("[EBNF Parser] Parse complete")},"parse"),parser:{yy:n}},S={parser:g,db:n,renderer:m,styles:l};export{S as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/erDiagram-RLTQ6QDP.BA9x2mfr.js b/packages/tempo/public/v4/assets/chunks/erDiagram-RLTQ6QDP.BA9x2mfr.js new file mode 100644 index 00000000..3484df1a --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/erDiagram-RLTQ6QDP.BA9x2mfr.js @@ -0,0 +1,99 @@ +import{g as zt}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as Ut}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as p,b as Kt,a as Zt,s as jt,g as qt,p as Wt,q as Ht,c as $,l as M,k as Qt,r as Xt,t as Jt,u as $t,v as te,x as ee,y as se,j as ie,z as re}from"../app.CbekdYod.js";import{c as ne}from"./channel.DScgq80D.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var Tt=(function(){var e=p(function(V,n,o,h){for(o=o||{},h=V.length;h--;o[V[h]]=n);return o},"o"),a=[6,9,21,23,25,27,34,37,38,39,40,41,43,46,47,51,53,54,55],u=[2,2],r=[1,7],c=[1,9],b=[1,10],k=[1,11],f=[1,12],S=[1,30],d=[1,23],g=[1,24],x=[1,25],B=[1,26],Y=[1,27],m=[1,19],A=[1,28],U=[1,29],N=[1,20],I=[1,18],R=[1,21],v=[1,22],Ot=[2,6],l=[6,9,21,23,25,27,33,34,37,38,39,40,41,43,46,47,51,53,54,55],dt=[1,36],pt=[1,37],ft=[1,38],bt=[1,39],gt=[1,40],K=[6,9,12,14,16,19,20,21,23,25,27,33,34,37,38,39,40,41,43,46,47,50,51,53,54,55,69,70,71,72,73],D=[1,46],L=[1,47],Z=[1,57],j=[43,51,53,54,55,74,75],q=[1,70],W=[1,68],w=[1,65],H=[1,69],Q=[1,71],tt=[6,9,12,16,21,23,25,27,33,34,37,38,39,40,41,43,44,45,46,47,51,52,53,54,55,69,70,71,72,73],et=[1,78],st=[1,77],it=[1,76],xt=[69,70,71,72,73],Nt=[1,91],Ct=[6,9,45,50],P=[6,9,12,44,45,50,51,52],rt=[1,101],nt=[1,100],at=[1,99],X=[18,61],At=[1,110],It=[1,109],Rt=[20,43,51,53,54,55],yt=[18,61,64,66],_t={trace:p(function(){},"trace"),yy:{},symbols_:{error:2,start:3,ER_DIAGRAM:4,document:5,EOF:6,line:7,statement:8,NEWLINE:9,entityName:10,relSpec:11,COLON:12,role:13,STYLE_SEPARATOR:14,idList:15,BLOCK_START:16,attributes:17,BLOCK_STOP:18,SQS:19,SQE:20,title:21,title_value:22,acc_title:23,acc_title_value:24,acc_descr:25,acc_descr_value:26,acc_descr_multiline_value:27,direction:28,classDefStatement:29,classStatement:30,styleStatement:31,subgraphHeader:32,END:33,SUBGRAPH:34,separator:35,subgraphTitle:36,direction_tb:37,direction_bt:38,direction_rl:39,direction_lr:40,CLASSDEF:41,stylesOpt:42,UNICODE_TEXT:43,STYLE_TEXT:44,COMMA:45,CLASS:46,STYLE:47,style:48,styleComponent:49,SEMI:50,NUM:51,BRKT:52,ENTITY_NAME:53,DECIMAL_NUM:54,ENTITY_ONE:55,attribute:56,attributeType:57,attributeName:58,attributeKeyTypeList:59,attributeComment:60,ATTRIBUTE_WORD:61,"?":62,attributeKeyType:63,",":64,ATTRIBUTE_KEY:65,COMMENT:66,cardinality:67,relType:68,ZERO_OR_ONE:69,ZERO_OR_MORE:70,ONE_OR_MORE:71,ONLY_ONE:72,MD_PARENT:73,NON_IDENTIFYING:74,IDENTIFYING:75,WORD:76,$accept:0,$end:1},terminals_:{2:"error",4:"ER_DIAGRAM",6:"EOF",9:"NEWLINE",12:"COLON",14:"STYLE_SEPARATOR",16:"BLOCK_START",18:"BLOCK_STOP",19:"SQS",20:"SQE",21:"title",22:"title_value",23:"acc_title",24:"acc_title_value",25:"acc_descr",26:"acc_descr_value",27:"acc_descr_multiline_value",33:"END",34:"SUBGRAPH",37:"direction_tb",38:"direction_bt",39:"direction_rl",40:"direction_lr",41:"CLASSDEF",43:"UNICODE_TEXT",44:"STYLE_TEXT",45:"COMMA",46:"CLASS",47:"STYLE",50:"SEMI",51:"NUM",52:"BRKT",53:"ENTITY_NAME",54:"DECIMAL_NUM",55:"ENTITY_ONE",61:"ATTRIBUTE_WORD",62:"?",64:",",65:"ATTRIBUTE_KEY",66:"COMMENT",69:"ZERO_OR_ONE",70:"ZERO_OR_MORE",71:"ONE_OR_MORE",72:"ONLY_ONE",73:"MD_PARENT",74:"NON_IDENTIFYING",75:"IDENTIFYING",76:"WORD"},productions_:[0,[3,3],[5,0],[5,2],[7,1],[7,1],[7,1],[8,5],[8,9],[8,7],[8,7],[8,4],[8,6],[8,3],[8,5],[8,1],[8,3],[8,7],[8,9],[8,6],[8,8],[8,4],[8,6],[8,2],[8,2],[8,2],[8,1],[8,1],[8,1],[8,1],[8,1],[8,3],[32,3],[32,6],[36,1],[36,2],[28,1],[28,1],[28,1],[28,1],[29,4],[15,1],[15,1],[15,3],[15,3],[30,3],[31,4],[42,1],[42,3],[48,1],[48,2],[35,1],[35,1],[35,1],[49,1],[49,1],[49,1],[49,1],[10,1],[10,1],[10,1],[10,1],[10,1],[17,1],[17,2],[56,2],[56,3],[56,3],[56,4],[57,1],[57,2],[58,1],[59,1],[59,3],[63,1],[60,1],[11,3],[67,1],[67,1],[67,1],[67,1],[67,1],[68,1],[68,1],[13,1],[13,1],[13,1]],performAction:p(function(n,o,h,i,y,t,J){var s=t.length-1;switch(y){case 1:break;case 2:this.$=[];break;case 3:this.$=t[s-1].concat(t[s]);break;case 4:this.$=t[s];break;case 5:case 6:this.$=[];break;case 7:i.addEntity(t[s-4]),i.addEntity(t[s-2]),i.addRelationship(t[s-4],t[s],t[s-2],t[s-3]),this.$=[t[s-4],t[s-2]];break;case 8:i.addEntity(t[s-8]),i.addEntity(t[s-4]),i.addRelationship(t[s-8],t[s],t[s-4],t[s-5]),i.setClass([t[s-8]],t[s-6]),i.setClass([t[s-4]],t[s-2]),this.$=[t[s-8],t[s-4]];break;case 9:i.addEntity(t[s-6]),i.addEntity(t[s-2]),i.addRelationship(t[s-6],t[s],t[s-2],t[s-3]),i.setClass([t[s-6]],t[s-4]),this.$=[t[s-6],t[s-2]];break;case 10:i.addEntity(t[s-6]),i.addEntity(t[s-4]),i.addRelationship(t[s-6],t[s],t[s-4],t[s-5]),i.setClass([t[s-4]],t[s-2]),this.$=[t[s-6],t[s-4]];break;case 11:i.addEntity(t[s-3]),i.addAttributes(t[s-3],t[s-1]),this.$=[t[s-3]];break;case 12:i.addEntity(t[s-5]),i.addAttributes(t[s-5],t[s-1]),i.setClass([t[s-5]],t[s-3]),this.$=[t[s-5]];break;case 13:i.addEntity(t[s-2]),this.$=[t[s-2]];break;case 14:i.addEntity(t[s-4]),i.setClass([t[s-4]],t[s-2]),this.$=[t[s-4]];break;case 15:i.addEntity(t[s]),this.$=[t[s]];break;case 16:i.addEntity(t[s-2]),i.setClass([t[s-2]],t[s]),this.$=[t[s-2]];break;case 17:i.addEntity(t[s-6],t[s-4]),i.addAttributes(t[s-6],t[s-1]),this.$=[t[s-6]];break;case 18:i.addEntity(t[s-8],t[s-6]),i.addAttributes(t[s-8],t[s-1]),i.setClass([t[s-8]],t[s-3]),this.$=[t[s-8]];break;case 19:i.addEntity(t[s-5],t[s-3]),this.$=[t[s-5]];break;case 20:i.addEntity(t[s-7],t[s-5]),i.setClass([t[s-7]],t[s-2]),this.$=[t[s-7]];break;case 21:i.addEntity(t[s-3],t[s-1]);break;case 22:i.addEntity(t[s-5],t[s-3]),i.setClass([t[s-5]],t[s]);break;case 23:case 24:this.$=t[s].trim(),i.setAccTitle(this.$);break;case 25:case 26:this.$=t[s].trim(),i.setAccDescription(this.$);break;case 27:i.subgraphDepth?this.$=t[s]:(i.setDirection(t[s].value),this.$=[]);break;case 31:i.subgraphDepth=(i.subgraphDepth||1)-1,this.$=i.addSubGraph({text:t[s-2].id},t[s-1],{text:t[s-2].text});break;case 32:i.subgraphDepth=(i.subgraphDepth||0)+1,this.$={id:t[s-1],text:t[s-1]};break;case 33:i.subgraphDepth=(i.subgraphDepth||0)+1,this.$={id:t[s-4],text:t[s-2]};break;case 34:case 59:case 60:case 61:case 62:case 86:this.$=t[s];break;case 35:this.$=t[s-1]+" "+t[s];break;case 36:this.$={stmt:"dir",value:"TB"};break;case 37:this.$={stmt:"dir",value:"BT"};break;case 38:this.$={stmt:"dir",value:"RL"};break;case 39:this.$={stmt:"dir",value:"LR"};break;case 40:this.$=t[s-3],i.addClass(t[s-2],t[s-1]);break;case 41:case 42:case 63:case 72:this.$=[t[s]];break;case 43:case 44:this.$=t[s-2].concat([t[s]]);break;case 45:this.$=t[s-2],i.setClass(t[s-1],t[s]);break;case 46:this.$=t[s-3],i.addCssStyles(t[s-2],t[s-1]);break;case 47:this.$=[t[s]];break;case 48:t[s-2].push(t[s]),this.$=t[s-2];break;case 50:this.$=t[s-1]+t[s];break;case 58:case 84:case 85:this.$=t[s].replace(/"/g,"");break;case 64:t[s].push(t[s-1]),this.$=t[s];break;case 65:this.$={type:t[s-1],name:t[s]};break;case 66:this.$={type:t[s-2],name:t[s-1],keys:t[s]};break;case 67:this.$={type:t[s-2],name:t[s-1],comment:t[s]};break;case 68:this.$={type:t[s-3],name:t[s-2],keys:t[s-1],comment:t[s]};break;case 69:case 71:case 74:this.$=t[s];break;case 70:this.$=t[s-1]+t[s];break;case 73:t[s-2].push(t[s]),this.$=t[s-2];break;case 75:this.$=t[s].replace(/"/g,"");break;case 76:this.$={cardA:t[s],relType:t[s-1],cardB:t[s-2]};break;case 77:this.$=i.Cardinality.ZERO_OR_ONE;break;case 78:this.$=i.Cardinality.ZERO_OR_MORE;break;case 79:this.$=i.Cardinality.ONE_OR_MORE;break;case 80:this.$=i.Cardinality.ONLY_ONE;break;case 81:this.$=i.Cardinality.MD_PARENT;break;case 82:this.$=i.Identification.NON_IDENTIFYING;break;case 83:this.$=i.Identification.IDENTIFYING;break}},"anonymous"),table:[{3:1,4:[1,2]},{1:[3]},e(a,u,{5:3}),{6:[1,4],7:5,8:6,9:r,10:8,21:c,23:b,25:k,27:f,28:13,29:14,30:15,31:16,32:17,34:S,37:d,38:g,39:x,40:B,41:Y,43:m,46:A,47:U,51:N,53:I,54:R,55:v},e(a,Ot,{1:[2,1]}),e(l,[2,3]),e(l,[2,4]),e(l,[2,5]),e(l,[2,15],{11:31,67:35,14:[1,32],16:[1,33],19:[1,34],69:dt,70:pt,71:ft,72:bt,73:gt}),{22:[1,41]},{24:[1,42]},{26:[1,43]},e(l,[2,26]),e(l,[2,27]),e(l,[2,28]),e(l,[2,29]),e(l,[2,30]),e(l,u,{5:44}),e(K,[2,58]),e(K,[2,59]),e(K,[2,60]),e(K,[2,61]),e(K,[2,62]),e(l,[2,36]),e(l,[2,37]),e(l,[2,38]),e(l,[2,39]),{15:45,43:D,44:L},{15:48,43:D,44:L},{15:49,43:D,44:L},{10:50,43:m,51:N,53:I,54:R,55:v},{10:51,43:m,51:N,53:I,54:R,55:v},{15:52,43:D,44:L},{17:53,18:[1,54],56:55,57:56,61:Z},{10:58,43:m,51:N,53:I,54:R,55:v},{68:59,74:[1,60],75:[1,61]},e(j,[2,77]),e(j,[2,78]),e(j,[2,79]),e(j,[2,80]),e(j,[2,81]),e(l,[2,23]),e(l,[2,24]),e(l,[2,25]),{6:[1,63],7:5,8:6,9:r,10:8,21:c,23:b,25:k,27:f,28:13,29:14,30:15,31:16,32:17,33:[1,62],34:S,37:d,38:g,39:x,40:B,41:Y,43:m,46:A,47:U,51:N,53:I,54:R,55:v},{12:q,42:64,44:W,45:w,48:66,49:67,51:H,52:Q},e(tt,[2,41]),e(tt,[2,42]),{15:72,43:D,44:L,45:w},{12:q,42:73,44:W,45:w,48:66,49:67,51:H,52:Q},{6:et,9:st,19:[1,75],35:74,50:it},{12:[1,79],14:[1,80]},e(l,[2,16],{67:35,11:81,16:[1,82],45:w,69:dt,70:pt,71:ft,72:bt,73:gt}),{18:[1,83]},e(l,[2,13]),{17:84,18:[2,63],56:55,57:56,61:Z},{58:85,61:[1,86]},{61:[2,69],62:[1,87]},{20:[1,88]},{67:89,69:dt,70:pt,71:ft,72:bt,73:gt},e(xt,[2,82]),e(xt,[2,83]),e(l,[2,31]),e(l,Ot),{6:et,9:st,35:90,45:Nt,50:it},{43:[1,92],44:[1,93]},e(Ct,[2,47],{49:94,12:q,44:W,51:H,52:Q}),e(P,[2,49]),e(P,[2,54]),e(P,[2,55]),e(P,[2,56]),e(P,[2,57]),e(l,[2,45],{45:w}),{6:et,9:st,35:95,45:Nt,50:it},e(l,[2,32]),{10:97,36:96,43:m,51:N,53:I,54:R,55:v},e(l,[2,51]),e(l,[2,52]),e(l,[2,53]),{13:98,43:rt,53:nt,76:at},{15:102,43:D,44:L},{10:103,43:m,51:N,53:I,54:R,55:v},{17:104,18:[1,105],56:55,57:56,61:Z},e(l,[2,11]),{18:[2,64]},e(X,[2,65],{59:106,60:107,63:108,65:At,66:It}),e([18,61,65,66],[2,71]),{61:[2,70]},e(l,[2,21],{14:[1,112],16:[1,111]}),e([43,51,53,54,55],[2,76]),e(l,[2,40]),{12:q,44:W,48:113,49:67,51:H,52:Q},e(tt,[2,43]),e(tt,[2,44]),e(P,[2,50]),e(l,[2,46]),{10:115,20:[1,114],43:m,51:N,53:I,54:R,55:v},e(Rt,[2,34]),e(l,[2,7]),e(l,[2,84]),e(l,[2,85]),e(l,[2,86]),{12:[1,116],45:w},{12:[1,118],14:[1,117]},{18:[1,119]},e(l,[2,14]),e(X,[2,66],{60:120,64:[1,121],66:It}),e(X,[2,67]),e(yt,[2,72]),e(X,[2,75]),e(yt,[2,74]),{17:122,18:[1,123],56:55,57:56,61:Z},{15:124,43:D,44:L},e(Ct,[2,48],{49:94,12:q,44:W,51:H,52:Q}),{6:et,9:st,35:125,50:it},e(Rt,[2,35]),{13:126,43:rt,53:nt,76:at},{15:127,43:D,44:L},{13:128,43:rt,53:nt,76:at},e(l,[2,12]),e(X,[2,68]),{63:129,65:At},{18:[1,130]},e(l,[2,19]),e(l,[2,22],{16:[1,131],45:w}),e(l,[2,33]),e(l,[2,10]),{12:[1,132],45:w},e(l,[2,9]),e(yt,[2,73]),e(l,[2,17]),{17:133,18:[1,134],56:55,57:56,61:Z},{13:135,43:rt,53:nt,76:at},{18:[1,136]},e(l,[2,20]),e(l,[2,8]),e(l,[2,18])],defaultActions:{84:[2,64],87:[2,70]},parseError:p(function(n,o){if(o.recoverable)this.trace(n);else{var h=new Error(n);throw h.hash=o,h}},"parseError"),parse:p(function(n){var o=this,h=[0],i=[],y=[null],t=[],J=this.table,s="",ct=0,vt=0,Gt=2,Dt=1,Ft=t.slice.call(arguments,1),_=Object.create(this.lexer),G={yy:{}};for(var kt in this.yy)Object.prototype.hasOwnProperty.call(this.yy,kt)&&(G.yy[kt]=this.yy[kt]);_.setInput(n,G.yy),G.yy.lexer=_,G.yy.parser=this,typeof _.yylloc>"u"&&(_.yylloc={});var mt=_.yylloc;t.push(mt);var Yt=_.options&&_.options.ranges;typeof G.yy.parseError=="function"?this.parseError=G.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function Pt(T){h.length=h.length-2*T,y.length=y.length-T,t.length=t.length-T}p(Pt,"popStack");function Lt(){var T;return T=i.pop()||_.lex()||Dt,typeof T!="number"&&(T instanceof Array&&(i=T,T=i.pop()),T=o.symbols_[T]||T),T}p(Lt,"lex");for(var E,F,O,Et,z={},lt,C,wt,ht;;){if(F=h[h.length-1],this.defaultActions[F]?O=this.defaultActions[F]:((E===null||typeof E>"u")&&(E=Lt()),O=J[F]&&J[F][E]),typeof O>"u"||!O.length||!O[0]){var St="";ht=[];for(lt in J[F])this.terminals_[lt]&<>Gt&&ht.push("'"+this.terminals_[lt]+"'");_.showPosition?St="Parse error on line "+(ct+1)+`: +`+_.showPosition()+` +Expecting `+ht.join(", ")+", got '"+(this.terminals_[E]||E)+"'":St="Parse error on line "+(ct+1)+": Unexpected "+(E==Dt?"end of input":"'"+(this.terminals_[E]||E)+"'"),this.parseError(St,{text:_.match,token:this.terminals_[E]||E,line:_.yylineno,loc:mt,expected:ht})}if(O[0]instanceof Array&&O.length>1)throw new Error("Parse Error: multiple actions possible at state: "+F+", token: "+E);switch(O[0]){case 1:h.push(E),y.push(_.yytext),t.push(_.yylloc),h.push(O[1]),E=null,vt=_.yyleng,s=_.yytext,ct=_.yylineno,mt=_.yylloc;break;case 2:if(C=this.productions_[O[1]][1],z.$=y[y.length-C],z._$={first_line:t[t.length-(C||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(C||1)].first_column,last_column:t[t.length-1].last_column},Yt&&(z._$.range=[t[t.length-(C||1)].range[0],t[t.length-1].range[1]]),Et=this.performAction.apply(z,[s,vt,ct,G.yy,O[1],y,t].concat(Ft)),typeof Et<"u")return Et;C&&(h=h.slice(0,-1*C*2),y=y.slice(0,-1*C),t=t.slice(0,-1*C)),h.push(this.productions_[O[1]][0]),y.push(z.$),t.push(z._$),wt=J[h[h.length-2]][h[h.length-1]],h.push(wt);break;case 3:return!0}}return!0},"parse")},Bt=(function(){var V={EOF:1,parseError:p(function(o,h){if(this.yy.parser)this.yy.parser.parseError(o,h);else throw new Error(o)},"parseError"),setInput:p(function(n,o){return this.yy=o||this.yy||{},this._input=n,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:p(function(){var n=this._input[0];this.yytext+=n,this.yyleng++,this.offset++,this.match+=n,this.matched+=n;var o=n.match(/(?:\r\n?|\n).*/g);return o?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),n},"input"),unput:p(function(n){var o=n.length,h=n.split(/(?:\r\n?|\n)/g);this._input=n+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-o),this.offset-=o;var i=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),h.length-1&&(this.yylineno-=h.length-1);var y=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:h?(h.length===i.length?this.yylloc.first_column:0)+i[i.length-h.length].length-h[0].length:this.yylloc.first_column-o},this.options.ranges&&(this.yylloc.range=[y[0],y[0]+this.yyleng-o]),this.yyleng=this.yytext.length,this},"unput"),more:p(function(){return this._more=!0,this},"more"),reject:p(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:p(function(n){this.unput(this.match.slice(n))},"less"),pastInput:p(function(){var n=this.matched.substr(0,this.matched.length-this.match.length);return(n.length>20?"...":"")+n.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:p(function(){var n=this.match;return n.length<20&&(n+=this._input.substr(0,20-n.length)),(n.substr(0,20)+(n.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:p(function(){var n=this.pastInput(),o=new Array(n.length+1).join("-");return n+this.upcomingInput()+` +`+o+"^"},"showPosition"),test_match:p(function(n,o){var h,i,y;if(this.options.backtrack_lexer&&(y={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(y.yylloc.range=this.yylloc.range.slice(0))),i=n[0].match(/(?:\r\n?|\n).*/g),i&&(this.yylineno+=i.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:i?i[i.length-1].length-i[i.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+n[0].length},this.yytext+=n[0],this.match+=n[0],this.matches=n,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(n[0].length),this.matched+=n[0],h=this.performAction.call(this,this.yy,this,o,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),h)return h;if(this._backtrack){for(var t in y)this[t]=y[t];return!1}return!1},"test_match"),next:p(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var n,o,h,i;this._more||(this.yytext="",this.match="");for(var y=this._currentRules(),t=0;to[0].length)){if(o=h,i=t,this.options.backtrack_lexer){if(n=this.test_match(h,y[t]),n!==!1)return n;if(this._backtrack){o=!1;continue}else return!1}else if(!this.options.flex)break}return o?(n=this.test_match(o,y[i]),n!==!1?n:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:p(function(){var o=this.next();return o||this.lex()},"lex"),begin:p(function(o){this.conditionStack.push(o)},"begin"),popState:p(function(){var o=this.conditionStack.length-1;return o>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:p(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:p(function(o){return o=this.conditionStack.length-1-Math.abs(o||0),o>=0?this.conditionStack[o]:"INITIAL"},"topState"),pushState:p(function(o){this.begin(o)},"pushState"),stateStackSize:p(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:p(function(o,h,i,y){switch(i){case 0:return this.begin("acc_title"),23;case 1:return this.popState(),"acc_title_value";case 2:return this.begin("acc_descr"),25;case 3:return this.popState(),"acc_descr_value";case 4:this.begin("acc_descr_multiline");break;case 5:this.popState();break;case 6:return"acc_descr_multiline_value";case 7:return 37;case 8:return 38;case 9:return 39;case 10:return 40;case 11:break;case 12:return 9;case 13:return 53;case 14:return 76;case 15:return 4;case 16:return this.begin("block"),16;case 17:return 52;case 18:return 52;case 19:return 45;case 20:return 14;case 21:return 12;case 22:break;case 23:return 65;case 24:return 61;case 25:return 61;case 26:this.begin("block_bq");break;case 27:return 61;case 28:this.popState();break;case 29:return 66;case 30:break;case 31:return this.popState(),18;case 32:return h.yytext[0];case 33:return 19;case 34:return 20;case 35:return this.begin("style"),47;case 36:return this.popState(),9;case 37:break;case 38:return 12;case 39:return 45;case 40:return 52;case 41:return this.begin("style"),41;case 42:return 46;case 43:return 34;case 44:return 33;case 45:return 69;case 46:return 71;case 47:return 71;case 48:return 71;case 49:return 69;case 50:return 69;case 51:return 70;case 52:return 70;case 53:return 70;case 54:return 70;case 55:return 70;case 56:return 71;case 57:return 70;case 58:return 71;case 59:return 72;case 60:return 72;case 61:return 54;case 62:return 72;case 63:return 72;case 64:return 72;case 65:return 55;case 66:return 51;case 67:return 72;case 68:return 69;case 69:return 70;case 70:return 71;case 71:return 73;case 72:return 74;case 73:return 75;case 74:return 75;case 75:return 74;case 76:return 74;case 77:return 74;case 78:return 44;case 79:return 50;case 80:return 43;case 81:return h.yytext[0];case 82:return 6}},"anonymous"),rules:[/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:.*direction\s+TB[^\n]*)/i,/^(?:.*direction\s+BT[^\n]*)/i,/^(?:.*direction\s+RL[^\n]*)/i,/^(?:.*direction\s+LR[^\n]*)/i,/^(?:[ \t\r]+)/i,/^(?:[\n]+)/i,/^(?:"[^"%\r\n\v\b\\]+")/i,/^(?:"[^"]*")/i,/^(?:erDiagram\b)/i,/^(?:\{)/i,/^(?:#)/i,/^(?:#)/i,/^(?:,)/i,/^(?::::)/i,/^(?::)/i,/^(?:\s+)/i,/^(?:\b((?:PK)|(?:FK)|(?:UK))\b)/i,/^(?:([^\s]*)[~].*[~]([^\s]*))/i,/^(?:([\*A-Za-z_\u00C0-\uFFFF][A-Za-z0-9\-\_\[\]\(\)\.,\u00C0-\uFFFF\*]*))/i,/^(?:[`])/i,/^(?:[^`]+)/i,/^(?:[`])/i,/^(?:"[^"]*")/i,/^(?:[\n]+)/i,/^(?:\})/i,/^(?:.)/i,/^(?:\[)/i,/^(?:\])/i,/^(?:style\b)/i,/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?::)/i,/^(?:,)/i,/^(?:#)/i,/^(?:classDef\b)/i,/^(?:class\b)/i,/^(?:subgraph\b)/i,/^(?:end\b\s*)/i,/^(?:one or zero\b)/i,/^(?:one or more\b)/i,/^(?:one or many\b)/i,/^(?:1\+)/i,/^(?:\|o\b)/i,/^(?:zero or one\b)/i,/^(?:zero or more\b)/i,/^(?:zero or many\b)/i,/^(?:0\+)/i,/^(?:\}o\b)/i,/^(?:many\(0\))/i,/^(?:many\(1\))/i,/^(?:many\b)/i,/^(?:\}\|)/i,/^(?:one\b)/i,/^(?:only one\b)/i,/^(?:[0-9]+\.[0-9]+)/i,/^(?:1(?=\s+[A-Za-z_"']))/i,/^(?:1(?=\s+[0-9]))/i,/^(?:1(?=(--|\.\.|\.-|-\.)))/i,/^(?:1\b)/i,/^(?:[0-9]+)/i,/^(?:\|\|)/i,/^(?:o\|)/i,/^(?:o\{)/i,/^(?:\|\{)/i,/^(?:u(?=[\.\-\|]))/i,/^(?:\.\.)/i,/^(?:--)/i,/^(?:to\b)/i,/^(?:optionally to\b)/i,/^(?:\.-)/i,/^(?:-\.)/i,/^(?:([^\x00-\x7F]|\w|-|\*)+)/i,/^(?:;)/i,/^(?:([^\x00-\x7F]|\w|-|\*|\.)+)/i,/^(?:.)/i,/^(?:$)/i],conditions:{style:{rules:[36,37,38,39,40,78,79],inclusive:!1},acc_descr_multiline:{rules:[5,6],inclusive:!1},acc_descr:{rules:[3],inclusive:!1},acc_title:{rules:[1],inclusive:!1},block_bq:{rules:[27,28],inclusive:!1},block:{rules:[22,23,24,25,26,29,30,31,32],inclusive:!1},INITIAL:{rules:[0,2,4,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,33,34,35,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,80,81,82],inclusive:!0}}};return V})();_t.lexer=Bt;function ot(){this.yy={}}return p(ot,"Parser"),ot.prototype=_t,_t.Parser=ot,new ot})();Tt.parser=Tt;var ae=Tt,oe=class{constructor(){this.entities=new Map,this.relationships=[],this.classes=new Map,this.subgraphDepth=0,this.subGraphs=[],this.subGraphLookup=new Map,this.subCount=0,this.direction="TB",this.Cardinality={ZERO_OR_ONE:"ZERO_OR_ONE",ZERO_OR_MORE:"ZERO_OR_MORE",ONE_OR_MORE:"ONE_OR_MORE",ONLY_ONE:"ONLY_ONE",MD_PARENT:"MD_PARENT"},this.Identification={NON_IDENTIFYING:"NON_IDENTIFYING",IDENTIFYING:"IDENTIFYING"},this.setAccTitle=Kt,this.getAccTitle=Zt,this.setAccDescription=jt,this.getAccDescription=qt,this.setDiagramTitle=Wt,this.getDiagramTitle=Ht,this.getConfig=p(()=>$().er,"getConfig"),this.clear(),this.addEntity=this.addEntity.bind(this),this.addAttributes=this.addAttributes.bind(this),this.addRelationship=this.addRelationship.bind(this),this.setDirection=this.setDirection.bind(this),this.addCssStyles=this.addCssStyles.bind(this),this.addClass=this.addClass.bind(this),this.setClass=this.setClass.bind(this),this.setAccTitle=this.setAccTitle.bind(this),this.setAccDescription=this.setAccDescription.bind(this),this.addSubGraph=this.addSubGraph.bind(this)}static{p(this,"ErDB")}addEntity(e,a=""){return this.entities.has(e)?!this.entities.get(e)?.alias&&a&&(this.entities.get(e).alias=a,M.info(`Add alias '${a}' to entity '${e}'`)):(this.entities.set(e,{id:`entity-${e}-${this.entities.size}`,label:e,attributes:[],alias:a,shape:"erBox",look:$().look??"default",cssClasses:"default",cssStyles:[],labelType:"markdown"}),M.info("Added new entity :",e)),this.entities.get(e)}getEntity(e){return this.entities.get(e)}getEntities(){return this.entities}getClasses(){return this.classes}addAttributes(e,a){const u=this.addEntity(e);let r;for(r=a.length-1;r>=0;r--)a[r].keys||(a[r].keys=[]),a[r].comment||(a[r].comment=""),u.attributes.push(a[r]),M.debug("Added attribute ",a[r].name)}addRelationship(e,a,u,r){let c;if(this.subGraphLookup.has(e))c=e;else{const f=this.addEntity(e);if(!f)return;c=f.id}let b;if(this.subGraphLookup.has(u))b=u;else{const f=this.addEntity(u);if(!f)return;b=f.id}const k={entityA:c,roleA:a,entityB:b,relSpec:r};this.relationships.push(k),M.debug("Added new relationship :",k)}getRelationships(){return this.relationships}getDirection(){return this.direction}setDirection(e){this.direction=e}getCompiledStyles(e){let a=[];for(const u of e){const r=this.classes.get(u);r?.styles&&(a=[...a,...r.styles??[]].map(c=>c.trim())),r?.textStyles&&(a=[...a,...r.textStyles??[]].map(c=>c.trim()))}return a}addCssStyles(e,a){for(const u of e){const r=this.entities.get(u),c=this.subGraphLookup.get(u);if(a){if(r)for(const b of a)r.cssStyles.push(b);if(c){c.cssStyles||(c.cssStyles=[]);for(const b of a)c.cssStyles.push(b)}}}}addClass(e,a){e.forEach(u=>{let r=this.classes.get(u);r===void 0&&(r={id:u,styles:[],textStyles:[]},this.classes.set(u,r)),a&&a.forEach(function(c){if(/color/.exec(c)){const b=c.replace("fill","bgFill");r.textStyles.push(b)}r.styles.push(c)})})}addSubGraph(e,a,u){let r=e.text.trim(),c=u.text;const k=p(g=>{const x=new Set;let B;return{nodeList:g.filter(m=>{if(m?.stmt)return m.stmt==="dir"&&(B=m.value),!1;if(typeof m!="string")return!1;const A=m.trim();return!A||x.has(A)?!1:(x.add(A),!0)}),dir:B}},"uniq")(a.flat()),f=k.nodeList,S=k.dir;r=r??"subGraph"+this.subCount,c=c||"",c=this.sanitizeText(c),this.subCount=this.subCount+1;const d={id:r,nodes:f,title:c.trim(),classes:[],cssStyles:[],dir:S,labelType:this.sanitizeNodeLabelType(u?.type)};return M.info("Adding",d.id,d.nodes,d.dir),d.nodes=this.makeUniq(d,this.subGraphs).nodes,this.subGraphs.push(d),this.subGraphLookup.set(r,d),r}getSubGraphs(){return this.subGraphs}setClass(e,a){for(const u of e){const r=this.entities.get(u);if(r)for(const b of a)r.cssClasses+=" "+b;const c=this.subGraphLookup.get(u);if(c)for(const b of a)c.classes.push(b)}}subgraphNodeCache(e){const a=new Set;for(const u of e)for(const r of u.nodes)a.add(r);return a}makeUniq(e,a){const u=this.subgraphNodeCache(a),r=[];return e.nodes.forEach((c,b)=>{u.has(c)?M.warn(`Entity '${c}' already belongs to another subgraph and will be ignored`):r.push(e.nodes[b])}),{nodes:r}}sanitizeText(e){return Qt.sanitizeText(e,$())}sanitizeNodeLabelType(e){switch(e){case"markdown":case"string":case"text":return e;default:return"markdown"}}clear(){this.entities=new Map,this.classes=new Map,this.relationships=[],this.subGraphs=[],this.subGraphLookup=new Map,this.subCount=0,this.subgraphDepth=0,Xt()}getData(){const e=[],a=[],u=$(),r=this.getSubGraphs(),c=new Map,b=new Map;for(let d=r.length-1;d>=0;d--){const g=r[d];g.nodes.length>0&&b.set(g.id,!0);for(const x of g.nodes)c.set(x,g.id)}for(let d=r.length-1;d>=0;d--){const g=r[d];e.push({id:g.id,label:g.title,labelStyle:"",labelType:g.labelType,parentId:c.get(g.id),padding:8,cssCompiledStyles:this.getCompiledStyles(g.classes),cssStyles:g.cssStyles,cssClasses:g.classes.join(" "),shape:"rect",dir:g.dir,isGroup:!0,look:u.look})}const k=new Set(r.map(d=>d.id));let f=0;for(const d of this.entities.keys()){if(k.has(d))continue;const g=this.entities.get(d);g&&(g.cssCompiledStyles=this.getCompiledStyles(g.cssClasses.split(" ")),g.colorIndex=f++,e.push({...g,parentId:c.get(d),isGroup:!1}))}let S=0;for(const d of this.relationships){const g={id:Jt(d.entityA,d.entityB,{prefix:"id",counter:S++}),type:"normal",curve:"basis",start:d.entityA,end:d.entityB,label:d.roleA,labelpos:"c",thickness:"normal",classes:"relationshipLine",arrowTypeStart:d.relSpec.cardB.toLowerCase(),arrowTypeEnd:d.relSpec.cardA.toLowerCase(),pattern:d.relSpec.relType=="IDENTIFYING"?"solid":"dashed",look:u.look,labelType:"markdown"};a.push(g)}return{nodes:e,edges:a,other:{},config:u,direction:this.direction}}},Mt={};te(Mt,{draw:()=>ce});var ce=p(async function(e,a,u,r){M.info("REF0:"),M.info("Drawing er diagram (unified)",a);const{securityLevel:c,er:b,layout:k}=$(),f=r.db.getData(),S=zt(a,c);f.type=r.type,f.layoutAlgorithm=ee(k),f.config.flowchart.nodeSpacing=b?.nodeSpacing||140,f.config.flowchart.rankSpacing=b?.rankSpacing||80,f.direction=r.db.getDirection();const{config:d}=f,{look:g}=d;g==="neo"?f.markers=["only_one_neo","zero_or_one_neo","one_or_more_neo","zero_or_more_neo"]:f.markers=["only_one","zero_or_one","one_or_more","zero_or_more"],f.diagramId=a,await se(f,S),f.layoutAlgorithm==="elk"&&S.select(".edges").lower();const x=S.selectAll('[id*="-background"]');Array.from(x).length>0&&x.each(function(){const Y=ie(this),A=Y.attr("id").replace("-background",""),U=S.select(`#${CSS.escape(A)}`);if(!U.empty()){const N=U.attr("transform");Y.attr("transform",N)}});const B=8;re.insertTitle(S,"erDiagramTitleText",b?.titleTopMargin??25,r.db.getDiagramTitle()),Ut(S,B,"erDiagram",b?.useMaxWidth??!0)},"draw"),Vt=p((e,a)=>{const u=ne,r=u(e,"r"),c=u(e,"g"),b=u(e,"b");return $t(r,c,b,a)},"fade"),ut=new Set(["redux-color","redux-dark-color"]),le=p(e=>{const{theme:a,look:u,bkgColorArray:r,borderColorArray:c}=e;if(!ut.has(a))return"";const b=r?.length>0;let k="";for(let f=0;f{const{look:a,theme:u,erEdgeLabelBackground:r,strokeWidth:c}=e;return` + ${le(e)} + .entityBox { + fill: ${e.mainBkg}; + stroke: ${e.nodeBorder}; + } + + .relationshipLabelBox { + fill: ${e.tertiaryColor}; + opacity: 0.7; + background-color: ${e.tertiaryColor}; + rect { + opacity: 0.5; + } + } + + .labelBkg { + background-color: ${ut.has(u)&&r?r:Vt(e.tertiaryColor,.5)}; + } + + .edgeLabel { + background-color: ${ut.has(u)&&r?r:e.edgeLabelBackground}; + } + .edgeLabel .label rect { + fill: ${ut.has(u)&&r?r:e.edgeLabelBackground}; + } + .edgeLabel .label text { + fill: ${e.textColor}; + } + + .edgeLabel .label { + fill: ${e.nodeBorder}; + font-size: 14px; + } + + .label { + font-family: ${e.fontFamily}; + color: ${e.nodeTextColor||e.textColor}; + } + + .edge-pattern-dashed { + stroke-dasharray: 8,8; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon + { + fill: ${e.mainBkg}; + stroke: ${e.nodeBorder}; + stroke-width: ${a==="neo"?c:"1px"}; + } + + .relationshipLine { + stroke: ${e.lineColor}; + stroke-width: ${a==="neo"?c:"1px"}; + fill: none; + } + + .marker { + fill: none !important; + stroke: ${e.lineColor} !important; + stroke-width: 1; + } + [data-look=neo].labelBkg { + background-color: ${Vt(e.tertiaryColor,.5)}; + } + + .cluster rect { + fill: ${e.clusterBkg??e.mainBkg}; + stroke: ${e.clusterBorder??e.nodeBorder}; + stroke-width: 1px; + } + + .cluster text { + fill: ${e.titleColor??e.textColor}; + } + + .cluster-label text { + fill: ${e.titleColor??e.textColor}; + } +`},"getStyles"),ue=he,_e={parser:ae,get db(){return new oe},renderer:Mt,styles:ue};export{_e as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/flowDiagram-HODETNUW.ClPsWLK6.js b/packages/tempo/public/v4/assets/chunks/flowDiagram-HODETNUW.ClPsWLK6.js new file mode 100644 index 00000000..eee0200d --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/flowDiagram-HODETNUW.ClPsWLK6.js @@ -0,0 +1,168 @@ +import{g as qt}from"./chunk-5VM5RSS4.-zPOtr2J.js";import{g as Xt}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as Qt}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as k,b4 as Zt,Y as Ot,l as J,c as Ae,x as Jt,y as $t,z as it,b as e1,s as t1,p as s1,a as i1,g as r1,q as a1,k as n1,Z as u1,$ as o1,cc as l1,t as tt,j as st,a6 as c1,r as h1,b9 as d1,u as p1}from"../app.CbekdYod.js";import{f as f1}from"./chunk-F27PBJKO.CcniKEe6.js";import{c as g1}from"./channel.DScgq80D.js";var b1="flowchart-",A1=class{constructor(){this.vertexCounter=0,this.config=Ae(),this.diagramId="",this.vertices=new Map,this.edges=[],this.classes=new Map,this.subGraphs=[],this.subGraphLookup=new Map,this.tooltips=new Map,this.subCount=0,this.firstGraphFlag=!0,this.secCount=-1,this.posCrossRef=[],this.funs=[],this.setAccTitle=e1,this.setAccDescription=t1,this.setDiagramTitle=s1,this.getAccTitle=i1,this.getAccDescription=r1,this.getDiagramTitle=a1,this.funs.push(this.setupToolTips.bind(this)),this.addVertex=this.addVertex.bind(this),this.firstGraph=this.firstGraph.bind(this),this.setDirection=this.setDirection.bind(this),this.addSubGraph=this.addSubGraph.bind(this),this.addLink=this.addLink.bind(this),this.setLink=this.setLink.bind(this),this.updateLink=this.updateLink.bind(this),this.addClass=this.addClass.bind(this),this.setClass=this.setClass.bind(this),this.destructLink=this.destructLink.bind(this),this.setClickEvent=this.setClickEvent.bind(this),this.setTooltip=this.setTooltip.bind(this),this.updateLinkInterpolate=this.updateLinkInterpolate.bind(this),this.setClickFun=this.setClickFun.bind(this),this.bindFunctions=this.bindFunctions.bind(this),this.lex={firstGraph:this.firstGraph.bind(this)},this.clear(),this.setGen("gen-2")}static{k(this,"FlowDB")}sanitizeText(e){return n1.sanitizeText(e,this.config)}sanitizeNodeLabelType(e){switch(e){case"markdown":case"string":case"text":return e;default:return"markdown"}}setDiagramId(e){this.diagramId=e}lookUpDomId(e){for(const i of this.vertices.values())if(i.id===e)return this.diagramId?`${this.diagramId}-${i.domId}`:i.domId;return this.diagramId?`${this.diagramId}-${e}`:e}addVertex(e,i,r,a,u,f,l={},b){if(!e||e.trim().length===0)return;let h;if(b!==void 0){let o;b.includes(` +`)?o=b+` +`:o=`{ +`+b+` +}`,h=u1(o,{schema:o1})}const _=this.subGraphLookup.get(e);if(_&&h){_.metadata={..._.metadata,...h};return}const y=this.edges.find(o=>o.id===e);if(y){const o=h;o?.animate!==void 0&&(y.animate=o.animate),o?.animation!==void 0&&(y.animation=o.animation),o?.curve!==void 0&&(y.interpolate=o.curve);return}let L,A=this.vertices.get(e);if(A===void 0&&(i===void 0&&r===void 0&&a!==void 0&&a!==null&&J.warn(`Style applied to unknown node "${e}". This may indicate a typo. The node will be created automatically.`),A={id:e,labelType:"text",domId:b1+e+"-"+this.vertexCounter,styles:[],classes:[]},this.vertices.set(e,A)),this.vertexCounter++,i!==void 0?(this.config=Ae(),L=this.sanitizeText(i.text.trim()),A.labelType=i.type,L.startsWith('"')&&L.endsWith('"')&&(L=L.substring(1,L.length-1)),A.text=L):A.text===void 0&&(A.text=e),r!==void 0&&(A.type=r),a?.forEach(o=>{A.styles.push(o)}),u?.forEach(o=>{A.classes.push(o)}),f!==void 0&&(A.dir=f),A.props===void 0?A.props=l:l!==void 0&&Object.assign(A.props,l),h!==void 0){if(h.shape){if(h.shape!==h.shape.toLowerCase()||h.shape.includes("_"))throw new Error(`No such shape: ${h.shape}. Shape names should be lowercase.`);if(!l1(h.shape))throw new Error(`No such shape: ${h.shape}.`);A.type=h?.shape}h?.label&&(A.text=h?.label,A.labelType=this.sanitizeNodeLabelType(h?.labelType)),h?.icon&&(A.icon=h?.icon,!h.label?.trim()&&A.text===e&&(A.text="")),h?.form&&(A.form=h?.form),h?.pos&&(A.pos=h?.pos),h?.img&&(A.img=h?.img,!h.label?.trim()&&A.text===e&&(A.text="")),h?.constraint&&(A.constraint=h.constraint),h.w&&(A.assetWidth=Number(h.w)),h.h&&(A.assetHeight=Number(h.h))}}addSingleLink(e,i,r,a){const l={start:e,end:i,type:void 0,text:"",labelType:"text",classes:[],isUserDefinedId:!1,interpolate:this.edges.defaultInterpolate};J.info("abc78 Got edge...",l);const b=r.text;if(b!==void 0&&(l.text=this.sanitizeText(b.text.trim()),l.text.startsWith('"')&&l.text.endsWith('"')&&(l.text=l.text.substring(1,l.text.length-1)),l.labelType=this.sanitizeNodeLabelType(b.type)),r!==void 0&&(l.type=r.type,l.stroke=r.stroke,l.length=r.length>10?10:r.length),a&&!this.edges.some(h=>h.id===a))l.id=a,l.isUserDefinedId=!0;else{const h=this.edges.filter(_=>_.start===l.start&&_.end===l.end);h.length===0?l.id=tt(l.start,l.end,{counter:0,prefix:"L"}):l.id=tt(l.start,l.end,{counter:h.length+1,prefix:"L"})}if(this.edges.length<(this.config.maxEdges??500))J.info("Pushing edge..."),this.edges.push(l);else throw new Error(`Edge limit exceeded. ${this.edges.length} edges found, but the limit is ${this.config.maxEdges}. + +Initialize mermaid with maxEdges set to a higher number to allow more edges. +You cannot set this config via configuration inside the diagram as it is a secure config. +You have to call mermaid.initialize.`)}isLinkData(e){return e!==null&&typeof e=="object"&&"id"in e&&typeof e.id=="string"}addLink(e,i,r){const a=this.isLinkData(r)?r.id.replace("@",""):void 0;J.info("addLink",e,i,a);for(const u of e)for(const f of i){const l=u===e[e.length-1],b=f===i[0];l&&b?this.addSingleLink(u,f,r,a):this.addSingleLink(u,f,r,void 0)}}updateLinkInterpolate(e,i){e.forEach(r=>{r==="default"?this.edges.defaultInterpolate=i:this.edges[r].interpolate=i})}updateLink(e,i){e.forEach(r=>{if(typeof r=="number"&&r>=this.edges.length)throw new Error(`The index ${r} for linkStyle is out of bounds. Valid indices for linkStyle are between 0 and ${this.edges.length-1}. (Help: Ensure that the index is within the range of existing edges.)`);r==="default"?this.edges.defaultStyle=i:(this.edges[r].style=i,(this.edges[r]?.style?.length??0)>0&&!this.edges[r]?.style?.some(a=>a?.startsWith("fill"))&&this.edges[r]?.style?.push("fill:none"))})}addClass(e,i){const r=i.join().replace(/\\,/g,"§§§").replace(/,/g,";").replace(/§§§/g,",").split(";");e.split(",").forEach(a=>{let u=this.classes.get(a);u===void 0&&(u={id:a,styles:[],textStyles:[]},this.classes.set(a,u)),r?.forEach(f=>{if(/color/.exec(f)){const l=f.replace("fill","bgFill");u.textStyles.push(l)}u.styles.push(f)})})}setDirection(e){this.direction=e.trim(),/.*/.exec(this.direction)&&(this.direction="LR"),/.*v/.exec(this.direction)&&(this.direction="TB"),this.direction==="TD"&&(this.direction="TB")}setClass(e,i){for(const r of e.split(",")){const a=this.vertices.get(r);a&&a.classes.push(i);const u=this.edges.find(l=>l.id===r);u&&u.classes.push(i);const f=this.subGraphLookup.get(r);f&&f.classes.push(i)}}setTooltip(e,i){if(i!==void 0){i=this.sanitizeText(i);for(const r of e.split(","))this.tooltips.set(this.version==="gen-1"?this.lookUpDomId(r):r,i)}}setClickFun(e,i,r){if(Ae().securityLevel!=="loose"||i===void 0)return;let a=[];if(typeof r=="string"){a=r.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);for(let f=0;f{const f=this.lookUpDomId(e),l=document.querySelector(`[id="${f}"]`);l!==null&&l.addEventListener("click",()=>{it.runFunc(i,...a)},!1)}))}setLink(e,i,r){e.split(",").forEach(a=>{const u=this.vertices.get(a);u!==void 0&&(u.link=it.formatUrl(i,this.config),u.linkTarget=r)}),this.setClass(e,"clickable")}getTooltip(e){return this.tooltips.get(e)}setClickEvent(e,i,r){e.split(",").forEach(a=>{this.setClickFun(a,i,r)}),this.setClass(e,"clickable")}bindFunctions(e){this.funs.forEach(i=>{i(e)})}getDirection(){return this.direction?.trim()}getVertices(){return this.vertices}getEdges(){return this.edges}getClasses(){return this.classes}setupToolTips(e){const i=f1();st(e).select("svg").selectAll("g.node").on("mouseover",u=>{const f=st(u.currentTarget),l=f.attr("title");if(l===null)return;const b=u.currentTarget?.getBoundingClientRect();i.transition().duration(200).style("opacity",".9"),i.text(f.attr("title")).style("left",window.scrollX+b.left+(b.right-b.left)/2+"px").style("top",window.scrollY+b.bottom+"px"),i.html(c1.sanitize(l)),f.classed("hover",!0)}).on("mouseout",u=>{i.transition().duration(500).style("opacity",0),st(u.currentTarget).classed("hover",!1)})}clear(e="gen-2"){this.vertices=new Map,this.classes=new Map,this.edges=[],this.funs=[this.setupToolTips.bind(this)],this.diagramId="",this.subGraphs=[],this.subGraphLookup=new Map,this.subCount=0,this.tooltips=new Map,this.firstGraphFlag=!0,this.version=e,this.config=Ae(),h1()}setGen(e){this.version=e||"gen-2"}defaultStyle(){return"fill:#ffa;stroke: #f66; stroke-width: 3px; stroke-dasharray: 5, 5;fill:#ffa;stroke: #666;"}addSubGraph(e,i,r){let a=e.text.trim(),u=r.text;e===r&&/\s/.exec(r.text)&&(a=void 0);const l=k(L=>{const A={boolean:{},number:{},string:{}},o=[];let c;return{nodeList:L.filter(function(B){const Q=typeof B;return B.stmt&&B.stmt==="dir"?(c=B.value,!1):B.trim()===""?!1:Q in A?A[Q].hasOwnProperty(B)?!1:A[Q][B]=!0:o.includes(B)?!1:o.push(B)}),dir:c}},"uniq")(i.flat()),b=l.nodeList;let h=l.dir;const _=Ae().flowchart??{};if(h=h??(_.inheritDir?this.getDirection()??Ae().direction??void 0:void 0),this.version==="gen-1")for(let L=0;L2e3)return{result:!1,count:0};if(this.posCrossRef[this.secCount]=i,this.subGraphs[i].id===e)return{result:!0,count:0};let a=0,u=1;for(;a=0){const l=this.indexNodes2(e,f);if(l.result)return{result:!0,count:u+l.count};u=u+l.count}a=a+1}return{result:!1,count:u}}getDepthFirstPos(e){return this.posCrossRef[e]}indexNodes(){this.secCount=-1,this.subGraphs.length>0&&this.indexNodes2("none",this.subGraphs.length-1)}getSubGraphs(){return this.subGraphs}firstGraph(){return this.firstGraphFlag?(this.firstGraphFlag=!1,!0):!1}destructStartLink(e){let i=e.trim(),r="arrow_open";switch(i[0]){case"<":r="arrow_point",i=i.slice(1);break;case"x":r="arrow_cross",i=i.slice(1);break;case"o":r="arrow_circle",i=i.slice(1);break}let a="normal";return i.includes("=")&&(a="thick"),i.includes(".")&&(a="dotted"),{type:r,stroke:a}}countChar(e,i){const r=i.length;let a=0;for(let u=0;u":a="arrow_point",i.startsWith("<")&&(a="double_"+a,r=r.slice(1));break;case"o":a="arrow_circle",i.startsWith("o")&&(a="double_"+a,r=r.slice(1));break}let u="normal",f=r.length-1;r.startsWith("=")&&(u="thick"),r.startsWith("~")&&(u="invisible");const l=this.countChar(".",r);return l&&(u="dotted",f=l),{type:a,stroke:u,length:f}}destructLink(e,i){const r=this.destructEndLink(e);let a;if(i){if(a=this.destructStartLink(i),a.stroke!==r.stroke)return{type:"INVALID",stroke:"INVALID"};if(a.type==="arrow_open")a.type=r.type;else{if(a.type!==r.type)return{type:"INVALID",stroke:"INVALID"};a.type="double_"+a.type}return a.type==="double_arrow"&&(a.type="double_arrow_point"),a.length=r.length,a}return r}exists(e,i){for(const r of e)if(r.nodes.includes(i))return!0;return!1}makeUniq(e,i){const r=[];return e.nodes.forEach((a,u)=>{this.exists(i,a)||r.push(e.nodes[u])}),{nodes:r}}getTypeFromVertex(e){if(e.img)return"imageSquare";if(e.icon)return e.form==="circle"?"iconCircle":e.form==="square"?"iconSquare":e.form==="rounded"?"iconRounded":"icon";switch(e.type){case"square":case void 0:return"squareRect";case"round":return"roundedRect";case"ellipse":return"ellipse";default:return e.type}}findNode(e,i){return e.find(r=>r.id===i)}destructEdgeType(e){let i="none",r="arrow_point";switch(e){case"arrow_point":case"arrow_circle":case"arrow_cross":r=e;break;case"double_arrow_point":case"double_arrow_circle":case"double_arrow_cross":i=e.replace("double_",""),r=i;break}return{arrowTypeStart:i,arrowTypeEnd:r}}addNodeFromVertex(e,i,r,a,u,f){const l=r.get(e.id),b=a.get(e.id)??!1,h=this.findNode(i,e.id);if(h)h.cssStyles=e.styles,h.cssCompiledStyles=this.getCompiledStyles(e.classes),h.cssClasses=e.classes.join(" ");else{const _={id:e.id,label:e.text,labelType:e.labelType,labelStyle:"",parentId:l,padding:u.flowchart?.padding||8,cssStyles:e.styles,cssCompiledStyles:this.getCompiledStyles(["default","node",...e.classes]),cssClasses:"default "+e.classes.join(" "),dir:e.dir,domId:e.domId,look:f,link:e.link,linkTarget:e.linkTarget,tooltip:this.getTooltip(e.id),icon:e.icon,pos:e.pos,img:e.img,assetWidth:e.assetWidth,assetHeight:e.assetHeight,constraint:e.constraint};b?i.push({..._,isGroup:!0,shape:"rect"}):i.push({..._,isGroup:!1,shape:this.getTypeFromVertex(e)})}}getCompiledStyles(e){let i=[];for(const r of e){const a=this.classes.get(r);a?.styles&&(i=[...i,...a.styles??[]].map(u=>u.trim())),a?.textStyles&&(i=[...i,...a.textStyles??[]].map(u=>u.trim()))}return i}getData(){const e=Ae(),i=[],r=[],a=this.getSubGraphs(),u=new Map,f=new Map,l=new Map;for(const o of a)for(const c of o.nodes)this.subGraphLookup.has(c)&&l.set(c,o.id);const b=k(o=>this.subGraphLookup.get(o)?.metadata?.view==="collapsed","isCollapsed"),h=k(o=>{let c;const S=new Set;let B=o;for(;B!==void 0&&!S.has(B);)S.add(B),b(B)&&(c=B),B=l.get(B);return c},"outermostCollapsed"),_=new Set,y=new Map;for(const o of a){const c=h(o.id);if(c!==void 0){o.id!==c&&(_.add(o.id),y.set(o.id,c));for(const S of o.nodes)S!==c&&(_.add(S),y.set(S,c))}}for(let o=a.length-1;o>=0;o--){const c=a[o];if(!_.has(c.id)){c.nodes.length>0&&f.set(c.id,!0);for(const S of c.nodes)u.set(S,c.id)}}for(let o=a.length-1;o>=0;o--){const c=a[o];_.has(c.id)||(c.metadata?.view==="collapsed"?i.push({id:c.id,label:c.title,labelStyle:"",labelType:c.labelType,parentId:u.get(c.id),padding:8,cssCompiledStyles:this.getCompiledStyles(c.classes),cssClasses:c.classes.join(" "),shape:"collapsedGroup",dir:c.dir,isGroup:!1,look:e.look}):i.push({id:c.id,label:c.title,labelStyle:"",labelType:c.labelType,parentId:u.get(c.id),padding:8,cssCompiledStyles:this.getCompiledStyles(c.classes),cssClasses:c.classes.join(" "),shape:"rect",dir:c.dir,isGroup:!0,look:e.look}))}this.getVertices().forEach(o=>{_.has(o.id)||this.addNodeFromVertex(o,i,u,f,e,e.look||"classic")});const A=this.getEdges();return A.forEach((o,c)=>{const{arrowTypeStart:S,arrowTypeEnd:B}=this.destructEdgeType(o.type),Q=[...A.defaultStyle??[]],de=y.get(o.start)??o.start,pe=y.get(o.end)??o.end;if(de===pe&&(y.has(o.start)||y.has(o.end)))return;o.style&&Q.push(...o.style);const De={id:tt(de,pe,{counter:c,prefix:"L"},o.id),isUserDefinedId:o.isUserDefinedId,start:de,end:pe,type:o.type??"normal",label:o.text,labelType:o.labelType,labelpos:"c",thickness:o.stroke,minlen:o.length,classes:o?.stroke==="invisible"?"":"edge-thickness-normal edge-pattern-solid flowchart-link",arrowTypeStart:o?.stroke==="invisible"||o?.type==="arrow_open"?"none":S,arrowTypeEnd:o?.stroke==="invisible"||o?.type==="arrow_open"?"none":B,arrowheadStyle:"fill: #333",cssCompiledStyles:this.getCompiledStyles(o.classes),labelStyle:Q,style:Q,pattern:o.stroke,look:e.look,animate:o.animate,animation:o.animation,curve:o.interpolate||this.edges.defaultInterpolate||e.flowchart?.curve};r.push(De)}),{nodes:i,edges:r,other:{},config:e}}defaultConfig(){return d1.flowchart}},k1=k(function(e,i){return i.db.getClasses()},"getClasses"),m1=k(async function(e,i,r,a){J.info("REF0:"),J.info("Drawing state diagram (v2)",i);const{securityLevel:u,flowchart:f,layout:l}=Ae();a.db.setDiagramId(i),J.debug("Before getData: ");const b=a.db.getData();J.debug("Data: ",b);const h=Xt(i,u),_=a.db.getDirection();b.type=a.type,b.layoutAlgorithm=Jt(l),b.layoutAlgorithm==="dagre"&&l==="elk"&&J.warn("flowchart-elk was moved to an external package in Mermaid v11. Please refer [release notes](https://github.com/mermaid-js/mermaid/releases/tag/v11.0.0) for more details. This diagram will be rendered using `dagre` layout as a fallback."),b.direction=_,b.nodeSpacing=f?.nodeSpacing||50,b.rankSpacing=f?.rankSpacing||50,b.markers=["point","circle","cross"],b.diagramId=i,J.debug("REF1:",b),await $t(b,h);const y=b.config.flowchart?.diagramPadding??8;it.insertTitle(h,"flowchartTitleText",f?.titleTopMargin||0,a.db.getDiagramTitle()),Qt(h,y,"flowchart",f?.useMaxWidth||!1)},"draw"),C1={getClasses:k1,draw:m1},rt=(function(){var e=k(function(be,d,p,g){for(p=p||{},g=be.length;g--;p[be[g]]=d);return p},"o"),i=[1,4],r=[1,3],a=[1,5],u=[1,8,9,10,11,27,34,36,38,44,60,84,85,86,87,88,89,102,105,106,109,111,114,115,116,121,122,123,124,125],f=[2,2],l=[1,13],b=[1,14],h=[1,15],_=[1,16],y=[1,23],L=[1,25],A=[1,26],o=[1,27],c=[1,50],S=[1,49],B=[1,29],Q=[1,30],de=[1,31],pe=[1,32],De=[1,33],I=[1,45],w=[1,47],R=[1,43],N=[1,48],G=[1,44],P=[1,51],O=[1,46],M=[1,52],U=[1,53],Oe=[1,34],Me=[1,35],Ue=[1,36],ze=[1,37],We=[1,38],fe=[1,58],E=[1,8,9,10,11,27,32,34,36,38,44,60,84,85,86,87,88,89,102,105,106,109,111,114,115,116,121,122,123,124,125],ee=[1,62],te=[1,61],se=[1,63],Te=[8,9,11,75,77,78],at=[1,79],Se=[1,92],Ee=[1,97],ye=[1,96],xe=[1,93],Fe=[1,89],_e=[1,95],Be=[1,91],ve=[1,98],Le=[1,94],Ve=[1,99],Ie=[1,90],ke=[8,9,10,11,40,75,77,78],W=[8,9,10,11,40,46,75,77,78],H=[8,9,10,11,29,40,44,46,48,50,52,54,56,58,60,63,65,67,68,70,75,77,78,89,102,105,106,109,111,114,115,116],nt=[8,9,11,44,60,75,77,78,89,102,105,106,109,111,114,115,116],we=[44,60,89,102,105,106,109,111,114,115,116],ut=[1,122],ot=[1,123],je=[1,125],Ke=[1,124],lt=[44,60,62,74,89,102,105,106,109,111,114,115,116],ct=[1,134],ht=[1,148],dt=[1,149],pt=[1,150],ft=[1,151],gt=[1,136],bt=[1,138],At=[1,142],kt=[1,143],mt=[1,144],Ct=[1,145],Dt=[1,146],Tt=[1,147],St=[1,152],Et=[1,153],yt=[1,132],xt=[1,133],Ft=[1,140],_t=[1,135],Bt=[1,139],vt=[1,137],Xe=[8,9,10,11,27,32,34,36,38,44,60,84,85,86,87,88,89,102,105,106,109,111,114,115,116,121,122,123,124,125],Lt=[1,155],Vt=[1,157],v=[8,9,11],q=[8,9,10,11,14,44,60,89,105,106,109,111,114,115,116],m=[1,177],j=[1,173],K=[1,174],C=[1,178],D=[1,175],T=[1,176],Re=[77,116,119],x=[8,9,10,11,12,14,27,29,32,44,60,75,84,85,86,87,88,89,90,105,109,111,114,115,116],It=[10,106],ge=[31,49,51,53,55,57,62,64,66,67,69,71,116,117,118],ie=[1,248],re=[1,246],ae=[1,250],ne=[1,244],ue=[1,245],oe=[1,247],le=[1,249],ce=[1,251],Ne=[1,269],wt=[8,9,11,106],$=[8,9,10,11,60,84,105,106,109,110,111,112],Qe={trace:k(function(){},"trace"),yy:{},symbols_:{error:2,start:3,graphConfig:4,document:5,line:6,statement:7,SEMI:8,NEWLINE:9,SPACE:10,EOF:11,GRAPH:12,NODIR:13,DIR:14,FirstStmtSeparator:15,ending:16,endToken:17,spaceList:18,spaceListNewline:19,vertexStatement:20,separator:21,styleStatement:22,linkStyleStatement:23,classDefStatement:24,classStatement:25,clickStatement:26,subgraph:27,textNoTags:28,SQS:29,text:30,SQE:31,end:32,direction:33,acc_title:34,acc_title_value:35,acc_descr:36,acc_descr_value:37,acc_descr_multiline_value:38,shapeData:39,SHAPE_DATA:40,link:41,node:42,styledVertex:43,AMP:44,vertex:45,STYLE_SEPARATOR:46,idString:47,DOUBLECIRCLESTART:48,DOUBLECIRCLEEND:49,PS:50,PE:51,"(-":52,"-)":53,STADIUMSTART:54,STADIUMEND:55,SUBROUTINESTART:56,SUBROUTINEEND:57,VERTEX_WITH_PROPS_START:58,"NODE_STRING[field]":59,COLON:60,"NODE_STRING[value]":61,PIPE:62,CYLINDERSTART:63,CYLINDEREND:64,DIAMOND_START:65,DIAMOND_STOP:66,TAGEND:67,TRAPSTART:68,TRAPEND:69,INVTRAPSTART:70,INVTRAPEND:71,linkStatement:72,arrowText:73,TESTSTR:74,START_LINK:75,edgeText:76,LINK:77,LINK_ID:78,edgeTextToken:79,STR:80,MD_STR:81,textToken:82,keywords:83,STYLE:84,LINKSTYLE:85,CLASSDEF:86,CLASS:87,CLICK:88,DOWN:89,UP:90,textNoTagsToken:91,stylesOpt:92,"idString[vertex]":93,"idString[class]":94,CALLBACKNAME:95,CALLBACKARGS:96,HREF:97,LINK_TARGET:98,"STR[link]":99,"STR[tooltip]":100,alphaNum:101,DEFAULT:102,numList:103,INTERPOLATE:104,NUM:105,COMMA:106,style:107,styleComponent:108,NODE_STRING:109,UNIT:110,BRKT:111,PCT:112,idStringToken:113,MINUS:114,MULT:115,UNICODE_TEXT:116,TEXT:117,TAGSTART:118,EDGE_TEXT:119,alphaNumToken:120,direction_tb:121,direction_bt:122,direction_rl:123,direction_lr:124,direction_td:125,$accept:0,$end:1},terminals_:{2:"error",8:"SEMI",9:"NEWLINE",10:"SPACE",11:"EOF",12:"GRAPH",13:"NODIR",14:"DIR",27:"subgraph",29:"SQS",31:"SQE",32:"end",34:"acc_title",35:"acc_title_value",36:"acc_descr",37:"acc_descr_value",38:"acc_descr_multiline_value",40:"SHAPE_DATA",44:"AMP",46:"STYLE_SEPARATOR",48:"DOUBLECIRCLESTART",49:"DOUBLECIRCLEEND",50:"PS",51:"PE",52:"(-",53:"-)",54:"STADIUMSTART",55:"STADIUMEND",56:"SUBROUTINESTART",57:"SUBROUTINEEND",58:"VERTEX_WITH_PROPS_START",59:"NODE_STRING[field]",60:"COLON",61:"NODE_STRING[value]",62:"PIPE",63:"CYLINDERSTART",64:"CYLINDEREND",65:"DIAMOND_START",66:"DIAMOND_STOP",67:"TAGEND",68:"TRAPSTART",69:"TRAPEND",70:"INVTRAPSTART",71:"INVTRAPEND",74:"TESTSTR",75:"START_LINK",77:"LINK",78:"LINK_ID",80:"STR",81:"MD_STR",84:"STYLE",85:"LINKSTYLE",86:"CLASSDEF",87:"CLASS",88:"CLICK",89:"DOWN",90:"UP",93:"idString[vertex]",94:"idString[class]",95:"CALLBACKNAME",96:"CALLBACKARGS",97:"HREF",98:"LINK_TARGET",99:"STR[link]",100:"STR[tooltip]",102:"DEFAULT",104:"INTERPOLATE",105:"NUM",106:"COMMA",109:"NODE_STRING",110:"UNIT",111:"BRKT",112:"PCT",114:"MINUS",115:"MULT",116:"UNICODE_TEXT",117:"TEXT",118:"TAGSTART",119:"EDGE_TEXT",121:"direction_tb",122:"direction_bt",123:"direction_rl",124:"direction_lr",125:"direction_td"},productions_:[0,[3,2],[5,0],[5,2],[6,1],[6,1],[6,1],[6,1],[6,1],[4,2],[4,2],[4,2],[4,3],[16,2],[16,1],[17,1],[17,1],[17,1],[15,1],[15,1],[15,2],[19,2],[19,2],[19,1],[19,1],[18,2],[18,1],[7,2],[7,2],[7,2],[7,2],[7,2],[7,2],[7,9],[7,6],[7,4],[7,1],[7,2],[7,2],[7,1],[21,1],[21,1],[21,1],[39,2],[39,1],[20,4],[20,3],[20,4],[20,2],[20,2],[20,1],[42,1],[42,6],[42,5],[43,1],[43,3],[45,4],[45,4],[45,6],[45,4],[45,4],[45,4],[45,8],[45,4],[45,4],[45,4],[45,6],[45,4],[45,4],[45,4],[45,4],[45,4],[45,1],[41,2],[41,3],[41,3],[41,1],[41,3],[41,4],[76,1],[76,2],[76,1],[76,1],[72,1],[72,2],[73,3],[30,1],[30,2],[30,1],[30,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[83,1],[28,1],[28,2],[28,1],[28,1],[24,5],[25,5],[26,2],[26,4],[26,3],[26,5],[26,3],[26,5],[26,5],[26,7],[26,2],[26,4],[26,2],[26,4],[26,4],[26,6],[22,5],[23,5],[23,5],[23,9],[23,9],[23,7],[23,7],[103,1],[103,3],[92,1],[92,3],[107,1],[107,2],[108,1],[108,1],[108,1],[108,1],[108,1],[108,1],[108,1],[108,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[113,1],[82,1],[82,1],[82,1],[82,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[91,1],[79,1],[79,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[120,1],[47,1],[47,2],[101,1],[101,2],[33,1],[33,1],[33,1],[33,1],[33,1]],performAction:k(function(d,p,g,n,F,t,Pe){var s=t.length-1;switch(F){case 2:this.$=[];break;case 3:(!Array.isArray(t[s])||t[s].length>0)&&t[s-1].push(t[s]),this.$=t[s-1];break;case 4:case 183:this.$=t[s];break;case 11:n.setDirection("TB"),this.$="TB";break;case 12:n.setDirection(t[s-1]),this.$=t[s-1];break;case 27:this.$=t[s-1].nodes;break;case 28:case 29:case 30:case 31:case 32:this.$=[];break;case 33:this.$=n.addSubGraph(t[s-6],t[s-1],t[s-4]);break;case 34:this.$=n.addSubGraph(t[s-3],t[s-1],t[s-3]);break;case 35:this.$=n.addSubGraph(void 0,t[s-1],void 0);break;case 37:this.$=t[s].trim(),n.setAccTitle(this.$);break;case 38:case 39:this.$=t[s].trim(),n.setAccDescription(this.$);break;case 43:this.$=t[s-1]+t[s];break;case 44:this.$=t[s];break;case 45:n.addVertex(t[s-1][t[s-1].length-1],void 0,void 0,void 0,void 0,void 0,void 0,t[s]),n.addLink(t[s-3].stmt,t[s-1],t[s-2]),this.$={stmt:t[s-1],nodes:t[s-1].concat(t[s-3].nodes)};break;case 46:n.addLink(t[s-2].stmt,t[s],t[s-1]),this.$={stmt:t[s],nodes:t[s].concat(t[s-2].nodes)};break;case 47:n.addLink(t[s-3].stmt,t[s-1],t[s-2]),this.$={stmt:t[s-1],nodes:t[s-1].concat(t[s-3].nodes)};break;case 48:this.$={stmt:t[s-1],nodes:t[s-1]};break;case 49:n.addVertex(t[s-1][t[s-1].length-1],void 0,void 0,void 0,void 0,void 0,void 0,t[s]),this.$={stmt:t[s-1],nodes:t[s-1],shapeData:t[s]};break;case 50:this.$={stmt:t[s],nodes:t[s]};break;case 51:this.$=[t[s]];break;case 52:n.addVertex(t[s-5][t[s-5].length-1],void 0,void 0,void 0,void 0,void 0,void 0,t[s-4]),this.$=t[s-5].concat(t[s]);break;case 53:this.$=t[s-4].concat(t[s]);break;case 54:this.$=t[s];break;case 55:this.$=t[s-2],n.setClass(t[s-2],t[s]);break;case 56:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"square");break;case 57:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"doublecircle");break;case 58:this.$=t[s-5],n.addVertex(t[s-5],t[s-2],"circle");break;case 59:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"ellipse");break;case 60:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"stadium");break;case 61:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"subroutine");break;case 62:this.$=t[s-7],n.addVertex(t[s-7],t[s-1],"rect",void 0,void 0,void 0,Object.fromEntries([[t[s-5],t[s-3]]]));break;case 63:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"cylinder");break;case 64:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"round");break;case 65:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"diamond");break;case 66:this.$=t[s-5],n.addVertex(t[s-5],t[s-2],"hexagon");break;case 67:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"odd");break;case 68:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"trapezoid");break;case 69:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"inv_trapezoid");break;case 70:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"lean_right");break;case 71:this.$=t[s-3],n.addVertex(t[s-3],t[s-1],"lean_left");break;case 72:this.$=t[s],n.addVertex(t[s]);break;case 73:t[s-1].text=t[s],this.$=t[s-1];break;case 74:case 75:t[s-2].text=t[s-1],this.$=t[s-2];break;case 76:this.$=t[s];break;case 77:var V=n.destructLink(t[s],t[s-2]);this.$={type:V.type,stroke:V.stroke,length:V.length,text:t[s-1]};break;case 78:var V=n.destructLink(t[s],t[s-2]);this.$={type:V.type,stroke:V.stroke,length:V.length,text:t[s-1],id:t[s-3]};break;case 79:this.$={text:t[s],type:"text"};break;case 80:this.$={text:t[s-1].text+""+t[s],type:t[s-1].type};break;case 81:this.$={text:t[s],type:"string"};break;case 82:this.$={text:t[s],type:"markdown"};break;case 83:var V=n.destructLink(t[s]);this.$={type:V.type,stroke:V.stroke,length:V.length};break;case 84:var V=n.destructLink(t[s]);this.$={type:V.type,stroke:V.stroke,length:V.length,id:t[s-1]};break;case 85:this.$=t[s-1];break;case 86:this.$={text:t[s],type:"text"};break;case 87:this.$={text:t[s-1].text+""+t[s],type:t[s-1].type};break;case 88:this.$={text:t[s],type:"string"};break;case 89:case 104:this.$={text:t[s],type:"markdown"};break;case 101:this.$={text:t[s],type:"text"};break;case 102:this.$={text:t[s-1].text+""+t[s],type:t[s-1].type};break;case 103:this.$={text:t[s],type:"text"};break;case 105:this.$=t[s-4],n.addClass(t[s-2],t[s]);break;case 106:this.$=t[s-4],n.setClass(t[s-2],t[s]);break;case 107:case 115:this.$=t[s-1],n.setClickEvent(t[s-1],t[s]);break;case 108:case 116:this.$=t[s-3],n.setClickEvent(t[s-3],t[s-2]),n.setTooltip(t[s-3],t[s]);break;case 109:this.$=t[s-2],n.setClickEvent(t[s-2],t[s-1],t[s]);break;case 110:this.$=t[s-4],n.setClickEvent(t[s-4],t[s-3],t[s-2]),n.setTooltip(t[s-4],t[s]);break;case 111:this.$=t[s-2],n.setLink(t[s-2],t[s]);break;case 112:this.$=t[s-4],n.setLink(t[s-4],t[s-2]),n.setTooltip(t[s-4],t[s]);break;case 113:this.$=t[s-4],n.setLink(t[s-4],t[s-2],t[s]);break;case 114:this.$=t[s-6],n.setLink(t[s-6],t[s-4],t[s]),n.setTooltip(t[s-6],t[s-2]);break;case 117:this.$=t[s-1],n.setLink(t[s-1],t[s]);break;case 118:this.$=t[s-3],n.setLink(t[s-3],t[s-2]),n.setTooltip(t[s-3],t[s]);break;case 119:this.$=t[s-3],n.setLink(t[s-3],t[s-2],t[s]);break;case 120:this.$=t[s-5],n.setLink(t[s-5],t[s-4],t[s]),n.setTooltip(t[s-5],t[s-2]);break;case 121:this.$=t[s-4],n.addVertex(t[s-2],void 0,void 0,t[s]);break;case 122:this.$=t[s-4],n.updateLink([t[s-2]],t[s]);break;case 123:this.$=t[s-4],n.updateLink(t[s-2],t[s]);break;case 124:this.$=t[s-8],n.updateLinkInterpolate([t[s-6]],t[s-2]),n.updateLink([t[s-6]],t[s]);break;case 125:this.$=t[s-8],n.updateLinkInterpolate(t[s-6],t[s-2]),n.updateLink(t[s-6],t[s]);break;case 126:this.$=t[s-6],n.updateLinkInterpolate([t[s-4]],t[s]);break;case 127:this.$=t[s-6],n.updateLinkInterpolate(t[s-4],t[s]);break;case 128:case 130:this.$=[t[s]];break;case 129:case 131:t[s-2].push(t[s]),this.$=t[s-2];break;case 133:this.$=t[s-1]+t[s];break;case 181:this.$=t[s];break;case 182:this.$=t[s-1]+""+t[s];break;case 184:this.$=t[s-1]+""+t[s];break;case 185:this.$={stmt:"dir",value:"TB"};break;case 186:this.$={stmt:"dir",value:"BT"};break;case 187:this.$={stmt:"dir",value:"RL"};break;case 188:this.$={stmt:"dir",value:"LR"};break;case 189:this.$={stmt:"dir",value:"TD"};break}},"anonymous"),table:[{3:1,4:2,9:i,10:r,12:a},{1:[3]},e(u,f,{5:6}),{4:7,9:i,10:r,12:a},{4:8,9:i,10:r,12:a},{13:[1,9],14:[1,10]},{1:[2,1],6:11,7:12,8:l,9:b,10:h,11:_,20:17,22:18,23:19,24:20,25:21,26:22,27:y,33:24,34:L,36:A,38:o,42:28,43:39,44:c,45:40,47:41,60:S,84:B,85:Q,86:de,87:pe,88:De,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U,121:Oe,122:Me,123:Ue,124:ze,125:We},e(u,[2,9]),e(u,[2,10]),e(u,[2,11]),{8:[1,55],9:[1,56],10:fe,15:54,18:57},e(E,[2,3]),e(E,[2,4]),e(E,[2,5]),e(E,[2,6]),e(E,[2,7]),e(E,[2,8]),{8:ee,9:te,11:se,21:59,41:60,72:64,75:[1,65],77:[1,67],78:[1,66]},{8:ee,9:te,11:se,21:68},{8:ee,9:te,11:se,21:69},{8:ee,9:te,11:se,21:70},{8:ee,9:te,11:se,21:71},{8:ee,9:te,11:se,21:72},{8:ee,9:te,10:[1,73],11:se,21:74},e(E,[2,36]),{35:[1,75]},{37:[1,76]},e(E,[2,39]),e(Te,[2,50],{18:77,39:78,10:fe,40:at}),{10:[1,80]},{10:[1,81]},{10:[1,82]},{10:[1,83]},{14:Se,44:Ee,60:ye,80:[1,87],89:xe,95:[1,84],97:[1,85],101:86,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie,120:88},e(E,[2,185]),e(E,[2,186]),e(E,[2,187]),e(E,[2,188]),e(E,[2,189]),e(ke,[2,51]),e(ke,[2,54],{46:[1,100]}),e(W,[2,72],{113:113,29:[1,101],44:c,48:[1,102],50:[1,103],52:[1,104],54:[1,105],56:[1,106],58:[1,107],60:S,63:[1,108],65:[1,109],67:[1,110],68:[1,111],70:[1,112],89:I,102:w,105:R,106:N,109:G,111:P,114:O,115:M,116:U}),e(H,[2,181]),e(H,[2,142]),e(H,[2,143]),e(H,[2,144]),e(H,[2,145]),e(H,[2,146]),e(H,[2,147]),e(H,[2,148]),e(H,[2,149]),e(H,[2,150]),e(H,[2,151]),e(H,[2,152]),e(u,[2,12]),e(u,[2,18]),e(u,[2,19]),{9:[1,114]},e(nt,[2,26],{18:115,10:fe}),e(E,[2,27]),{42:116,43:39,44:c,45:40,47:41,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},e(E,[2,40]),e(E,[2,41]),e(E,[2,42]),e(we,[2,76],{73:117,62:[1,119],74:[1,118]}),{76:120,79:121,80:ut,81:ot,116:je,119:Ke},{75:[1,126],77:[1,127]},e(lt,[2,83]),e(E,[2,28]),e(E,[2,29]),e(E,[2,30]),e(E,[2,31]),e(E,[2,32]),{10:ct,12:ht,14:dt,27:pt,28:128,32:ft,44:gt,60:bt,75:At,80:[1,130],81:[1,131],83:141,84:kt,85:mt,86:Ct,87:Dt,88:Tt,89:St,90:Et,91:129,105:yt,109:xt,111:Ft,114:_t,115:Bt,116:vt},e(Xe,f,{5:154}),e(E,[2,37]),e(E,[2,38]),e(Te,[2,48],{44:Lt}),e(Te,[2,49],{18:156,10:fe,40:Vt}),e(ke,[2,44]),{44:c,47:158,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},{102:[1,159],103:160,105:[1,161]},{44:c,47:162,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},{44:c,47:163,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},e(v,[2,107],{10:[1,164],96:[1,165]}),{80:[1,166]},e(v,[2,115],{120:168,10:[1,167],14:Se,44:Ee,60:ye,89:xe,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie}),e(v,[2,117],{10:[1,169]}),e(q,[2,183]),e(q,[2,170]),e(q,[2,171]),e(q,[2,172]),e(q,[2,173]),e(q,[2,174]),e(q,[2,175]),e(q,[2,176]),e(q,[2,177]),e(q,[2,178]),e(q,[2,179]),e(q,[2,180]),{44:c,47:170,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},{30:171,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:179,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:181,50:[1,180],67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:182,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:183,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:184,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{109:[1,185]},{30:186,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:187,65:[1,188],67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:189,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:190,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{30:191,67:m,80:j,81:K,82:172,116:C,117:D,118:T},e(H,[2,182]),e(u,[2,20]),e(nt,[2,25]),e(Te,[2,46],{39:192,18:193,10:fe,40:at}),e(we,[2,73],{10:[1,194]}),{10:[1,195]},{30:196,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{77:[1,197],79:198,116:je,119:Ke},e(Re,[2,79]),e(Re,[2,81]),e(Re,[2,82]),e(Re,[2,168]),e(Re,[2,169]),{76:199,79:121,80:ut,81:ot,116:je,119:Ke},e(lt,[2,84]),{8:ee,9:te,10:ct,11:se,12:ht,14:dt,21:201,27:pt,29:[1,200],32:ft,44:gt,60:bt,75:At,83:141,84:kt,85:mt,86:Ct,87:Dt,88:Tt,89:St,90:Et,91:202,105:yt,109:xt,111:Ft,114:_t,115:Bt,116:vt},e(x,[2,101]),e(x,[2,103]),e(x,[2,104]),e(x,[2,157]),e(x,[2,158]),e(x,[2,159]),e(x,[2,160]),e(x,[2,161]),e(x,[2,162]),e(x,[2,163]),e(x,[2,164]),e(x,[2,165]),e(x,[2,166]),e(x,[2,167]),e(x,[2,90]),e(x,[2,91]),e(x,[2,92]),e(x,[2,93]),e(x,[2,94]),e(x,[2,95]),e(x,[2,96]),e(x,[2,97]),e(x,[2,98]),e(x,[2,99]),e(x,[2,100]),{6:11,7:12,8:l,9:b,10:h,11:_,20:17,22:18,23:19,24:20,25:21,26:22,27:y,32:[1,203],33:24,34:L,36:A,38:o,42:28,43:39,44:c,45:40,47:41,60:S,84:B,85:Q,86:de,87:pe,88:De,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U,121:Oe,122:Me,123:Ue,124:ze,125:We},{10:fe,18:204},{44:[1,205]},e(ke,[2,43]),{10:[1,206],44:c,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:113,114:O,115:M,116:U},{10:[1,207]},{10:[1,208],106:[1,209]},e(It,[2,128]),{10:[1,210],44:c,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:113,114:O,115:M,116:U},{10:[1,211],44:c,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:113,114:O,115:M,116:U},{80:[1,212]},e(v,[2,109],{10:[1,213]}),e(v,[2,111],{10:[1,214]}),{80:[1,215]},e(q,[2,184]),{80:[1,216],98:[1,217]},e(ke,[2,55],{113:113,44:c,60:S,89:I,102:w,105:R,106:N,109:G,111:P,114:O,115:M,116:U}),{31:[1,218],67:m,82:219,116:C,117:D,118:T},e(ge,[2,86]),e(ge,[2,88]),e(ge,[2,89]),e(ge,[2,153]),e(ge,[2,154]),e(ge,[2,155]),e(ge,[2,156]),{49:[1,220],67:m,82:219,116:C,117:D,118:T},{30:221,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{51:[1,222],67:m,82:219,116:C,117:D,118:T},{53:[1,223],67:m,82:219,116:C,117:D,118:T},{55:[1,224],67:m,82:219,116:C,117:D,118:T},{57:[1,225],67:m,82:219,116:C,117:D,118:T},{60:[1,226]},{64:[1,227],67:m,82:219,116:C,117:D,118:T},{66:[1,228],67:m,82:219,116:C,117:D,118:T},{30:229,67:m,80:j,81:K,82:172,116:C,117:D,118:T},{31:[1,230],67:m,82:219,116:C,117:D,118:T},{67:m,69:[1,231],71:[1,232],82:219,116:C,117:D,118:T},{67:m,69:[1,234],71:[1,233],82:219,116:C,117:D,118:T},e(Te,[2,45],{18:156,10:fe,40:Vt}),e(Te,[2,47],{44:Lt}),e(we,[2,75]),e(we,[2,74]),{62:[1,235],67:m,82:219,116:C,117:D,118:T},e(we,[2,77]),e(Re,[2,80]),{77:[1,236],79:198,116:je,119:Ke},{30:237,67:m,80:j,81:K,82:172,116:C,117:D,118:T},e(Xe,f,{5:238}),e(x,[2,102]),e(E,[2,35]),{43:239,44:c,45:40,47:41,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},{10:fe,18:240},{10:ie,60:re,84:ae,92:241,105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},{10:ie,60:re,84:ae,92:252,104:[1,253],105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},{10:ie,60:re,84:ae,92:254,104:[1,255],105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},{105:[1,256]},{10:ie,60:re,84:ae,92:257,105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},{44:c,47:258,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},e(v,[2,108]),{80:[1,259]},{80:[1,260],98:[1,261]},e(v,[2,116]),e(v,[2,118],{10:[1,262]}),e(v,[2,119]),e(W,[2,56]),e(ge,[2,87]),e(W,[2,57]),{51:[1,263],67:m,82:219,116:C,117:D,118:T},e(W,[2,64]),e(W,[2,59]),e(W,[2,60]),e(W,[2,61]),{109:[1,264]},e(W,[2,63]),e(W,[2,65]),{66:[1,265],67:m,82:219,116:C,117:D,118:T},e(W,[2,67]),e(W,[2,68]),e(W,[2,70]),e(W,[2,69]),e(W,[2,71]),e([10,44,60,89,102,105,106,109,111,114,115,116],[2,85]),e(we,[2,78]),{31:[1,266],67:m,82:219,116:C,117:D,118:T},{6:11,7:12,8:l,9:b,10:h,11:_,20:17,22:18,23:19,24:20,25:21,26:22,27:y,32:[1,267],33:24,34:L,36:A,38:o,42:28,43:39,44:c,45:40,47:41,60:S,84:B,85:Q,86:de,87:pe,88:De,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U,121:Oe,122:Me,123:Ue,124:ze,125:We},e(ke,[2,53]),{43:268,44:c,45:40,47:41,60:S,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U},e(v,[2,121],{106:Ne}),e(wt,[2,130],{108:270,10:ie,60:re,84:ae,105:ne,109:ue,110:oe,111:le,112:ce}),e($,[2,132]),e($,[2,134]),e($,[2,135]),e($,[2,136]),e($,[2,137]),e($,[2,138]),e($,[2,139]),e($,[2,140]),e($,[2,141]),e(v,[2,122],{106:Ne}),{10:[1,271]},e(v,[2,123],{106:Ne}),{10:[1,272]},e(It,[2,129]),e(v,[2,105],{106:Ne}),e(v,[2,106],{113:113,44:c,60:S,89:I,102:w,105:R,106:N,109:G,111:P,114:O,115:M,116:U}),e(v,[2,110]),e(v,[2,112],{10:[1,273]}),e(v,[2,113]),{98:[1,274]},{51:[1,275]},{62:[1,276]},{66:[1,277]},{8:ee,9:te,11:se,21:278},e(E,[2,34]),e(ke,[2,52]),{10:ie,60:re,84:ae,105:ne,107:279,108:243,109:ue,110:oe,111:le,112:ce},e($,[2,133]),{14:Se,44:Ee,60:ye,89:xe,101:280,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie,120:88},{14:Se,44:Ee,60:ye,89:xe,101:281,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie,120:88},{98:[1,282]},e(v,[2,120]),e(W,[2,58]),{30:283,67:m,80:j,81:K,82:172,116:C,117:D,118:T},e(W,[2,66]),e(Xe,f,{5:284}),e(wt,[2,131],{108:270,10:ie,60:re,84:ae,105:ne,109:ue,110:oe,111:le,112:ce}),e(v,[2,126],{120:168,10:[1,285],14:Se,44:Ee,60:ye,89:xe,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie}),e(v,[2,127],{120:168,10:[1,286],14:Se,44:Ee,60:ye,89:xe,105:Fe,106:_e,109:Be,111:ve,114:Le,115:Ve,116:Ie}),e(v,[2,114]),{31:[1,287],67:m,82:219,116:C,117:D,118:T},{6:11,7:12,8:l,9:b,10:h,11:_,20:17,22:18,23:19,24:20,25:21,26:22,27:y,32:[1,288],33:24,34:L,36:A,38:o,42:28,43:39,44:c,45:40,47:41,60:S,84:B,85:Q,86:de,87:pe,88:De,89:I,102:w,105:R,106:N,109:G,111:P,113:42,114:O,115:M,116:U,121:Oe,122:Me,123:Ue,124:ze,125:We},{10:ie,60:re,84:ae,92:289,105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},{10:ie,60:re,84:ae,92:290,105:ne,107:242,108:243,109:ue,110:oe,111:le,112:ce},e(W,[2,62]),e(E,[2,33]),e(v,[2,124],{106:Ne}),e(v,[2,125],{106:Ne})],defaultActions:{},parseError:k(function(d,p){if(p.recoverable)this.trace(d);else{var g=new Error(d);throw g.hash=p,g}},"parseError"),parse:k(function(d){var p=this,g=[0],n=[],F=[null],t=[],Pe=this.table,s="",V=0,Rt=0,jt=2,Nt=1,Kt=t.slice.call(arguments,1),z=Object.create(this.lexer),me={yy:{}};for(var Ze in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Ze)&&(me.yy[Ze]=this.yy[Ze]);z.setInput(d,me.yy),me.yy.lexer=z,me.yy.parser=this,typeof z.yylloc>"u"&&(z.yylloc={});var Je=z.yylloc;t.push(Je);var Yt=z.options&&z.options.ranges;typeof me.yy.parseError=="function"?this.parseError=me.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function Ht(X){g.length=g.length-2*X,F.length=F.length-X,t.length=t.length-X}k(Ht,"popStack");function Gt(){var X;return X=n.pop()||z.lex()||Nt,typeof X!="number"&&(X instanceof Array&&(n=X,X=n.pop()),X=p.symbols_[X]||X),X}k(Gt,"lex");for(var Y,Ce,Z,$e,Ge={},He,he,Pt,qe;;){if(Ce=g[g.length-1],this.defaultActions[Ce]?Z=this.defaultActions[Ce]:((Y===null||typeof Y>"u")&&(Y=Gt()),Z=Pe[Ce]&&Pe[Ce][Y]),typeof Z>"u"||!Z.length||!Z[0]){var et="";qe=[];for(He in Pe[Ce])this.terminals_[He]&&He>jt&&qe.push("'"+this.terminals_[He]+"'");z.showPosition?et="Parse error on line "+(V+1)+`: +`+z.showPosition()+` +Expecting `+qe.join(", ")+", got '"+(this.terminals_[Y]||Y)+"'":et="Parse error on line "+(V+1)+": Unexpected "+(Y==Nt?"end of input":"'"+(this.terminals_[Y]||Y)+"'"),this.parseError(et,{text:z.match,token:this.terminals_[Y]||Y,line:z.yylineno,loc:Je,expected:qe})}if(Z[0]instanceof Array&&Z.length>1)throw new Error("Parse Error: multiple actions possible at state: "+Ce+", token: "+Y);switch(Z[0]){case 1:g.push(Y),F.push(z.yytext),t.push(z.yylloc),g.push(Z[1]),Y=null,Rt=z.yyleng,s=z.yytext,V=z.yylineno,Je=z.yylloc;break;case 2:if(he=this.productions_[Z[1]][1],Ge.$=F[F.length-he],Ge._$={first_line:t[t.length-(he||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(he||1)].first_column,last_column:t[t.length-1].last_column},Yt&&(Ge._$.range=[t[t.length-(he||1)].range[0],t[t.length-1].range[1]]),$e=this.performAction.apply(Ge,[s,Rt,V,me.yy,Z[1],F,t].concat(Kt)),typeof $e<"u")return $e;he&&(g=g.slice(0,-1*he*2),F=F.slice(0,-1*he),t=t.slice(0,-1*he)),g.push(this.productions_[Z[1]][0]),F.push(Ge.$),t.push(Ge._$),Pt=Pe[g[g.length-2]][g[g.length-1]],g.push(Pt);break;case 3:return!0}}return!0},"parse")},Wt=(function(){var be={EOF:1,parseError:k(function(p,g){if(this.yy.parser)this.yy.parser.parseError(p,g);else throw new Error(p)},"parseError"),setInput:k(function(d,p){return this.yy=p||this.yy||{},this._input=d,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:k(function(){var d=this._input[0];this.yytext+=d,this.yyleng++,this.offset++,this.match+=d,this.matched+=d;var p=d.match(/(?:\r\n?|\n).*/g);return p?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),d},"input"),unput:k(function(d){var p=d.length,g=d.split(/(?:\r\n?|\n)/g);this._input=d+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-p),this.offset-=p;var n=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),g.length-1&&(this.yylineno-=g.length-1);var F=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:g?(g.length===n.length?this.yylloc.first_column:0)+n[n.length-g.length].length-g[0].length:this.yylloc.first_column-p},this.options.ranges&&(this.yylloc.range=[F[0],F[0]+this.yyleng-p]),this.yyleng=this.yytext.length,this},"unput"),more:k(function(){return this._more=!0,this},"more"),reject:k(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:k(function(d){this.unput(this.match.slice(d))},"less"),pastInput:k(function(){var d=this.matched.substr(0,this.matched.length-this.match.length);return(d.length>20?"...":"")+d.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:k(function(){var d=this.match;return d.length<20&&(d+=this._input.substr(0,20-d.length)),(d.substr(0,20)+(d.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:k(function(){var d=this.pastInput(),p=new Array(d.length+1).join("-");return d+this.upcomingInput()+` +`+p+"^"},"showPosition"),test_match:k(function(d,p){var g,n,F;if(this.options.backtrack_lexer&&(F={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(F.yylloc.range=this.yylloc.range.slice(0))),n=d[0].match(/(?:\r\n?|\n).*/g),n&&(this.yylineno+=n.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:n?n[n.length-1].length-n[n.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+d[0].length},this.yytext+=d[0],this.match+=d[0],this.matches=d,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(d[0].length),this.matched+=d[0],g=this.performAction.call(this,this.yy,this,p,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),g)return g;if(this._backtrack){for(var t in F)this[t]=F[t];return!1}return!1},"test_match"),next:k(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var d,p,g,n;this._more||(this.yytext="",this.match="");for(var F=this._currentRules(),t=0;tp[0].length)){if(p=g,n=t,this.options.backtrack_lexer){if(d=this.test_match(g,F[t]),d!==!1)return d;if(this._backtrack){p=!1;continue}else return!1}else if(!this.options.flex)break}return p?(d=this.test_match(p,F[n]),d!==!1?d:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:k(function(){var p=this.next();return p||this.lex()},"lex"),begin:k(function(p){this.conditionStack.push(p)},"begin"),popState:k(function(){var p=this.conditionStack.length-1;return p>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:k(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:k(function(p){return p=this.conditionStack.length-1-Math.abs(p||0),p>=0?this.conditionStack[p]:"INITIAL"},"topState"),pushState:k(function(p){this.begin(p)},"pushState"),stateStackSize:k(function(){return this.conditionStack.length},"stateStackSize"),options:{},performAction:k(function(p,g,n,F){switch(n){case 0:return this.begin("acc_title"),34;case 1:return this.popState(),"acc_title_value";case 2:return this.begin("acc_descr"),36;case 3:return this.popState(),"acc_descr_value";case 4:this.begin("acc_descr_multiline");break;case 5:this.popState();break;case 6:return"acc_descr_multiline_value";case 7:return this.pushState("shapeData"),g.yytext="",40;case 8:return this.pushState("shapeDataStr"),40;case 9:return this.popState(),40;case 10:const t=/\n\s*/g;return g.yytext=g.yytext.replace(t,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "),40;case 11:return 40;case 12:this.popState();break;case 13:this.begin("callbackname");break;case 14:this.popState();break;case 15:this.popState(),this.begin("callbackargs");break;case 16:return 95;case 17:this.popState();break;case 18:return 96;case 19:return"MD_STR";case 20:this.popState();break;case 21:this.begin("md_string");break;case 22:return"STR";case 23:this.popState();break;case 24:this.pushState("string");break;case 25:return 84;case 26:return 102;case 27:return 85;case 28:return 104;case 29:return 86;case 30:return 87;case 31:return 97;case 32:this.begin("click");break;case 33:this.popState();break;case 34:return 88;case 35:return p.lex.firstGraph()&&this.begin("dir"),12;case 36:return p.lex.firstGraph()&&this.begin("dir"),12;case 37:return p.lex.firstGraph()&&this.begin("dir"),12;case 38:return p.lex.firstGraph()&&this.begin("dir"),12;case 39:return 27;case 40:return 32;case 41:return 98;case 42:return 98;case 43:return 98;case 44:return 98;case 45:return this.popState(),13;case 46:return this.popState(),14;case 47:return this.popState(),14;case 48:return this.popState(),14;case 49:return this.popState(),14;case 50:return this.popState(),14;case 51:return this.popState(),14;case 52:return this.popState(),14;case 53:return this.popState(),14;case 54:return this.popState(),14;case 55:return this.popState(),14;case 56:return 121;case 57:return 122;case 58:return 123;case 59:return 124;case 60:return 125;case 61:return 78;case 62:return 105;case 63:return 111;case 64:return 46;case 65:return 60;case 66:return 44;case 67:return 8;case 68:return 106;case 69:return 115;case 70:return this.popState(),77;case 71:return this.pushState("edgeText"),75;case 72:return 119;case 73:return this.popState(),77;case 74:return this.pushState("thickEdgeText"),75;case 75:return 119;case 76:return this.popState(),77;case 77:return this.pushState("dottedEdgeText"),75;case 78:return 119;case 79:return 77;case 80:return this.popState(),53;case 81:return"TEXT";case 82:return this.pushState("ellipseText"),52;case 83:return this.popState(),55;case 84:return this.pushState("text"),54;case 85:return this.popState(),57;case 86:return this.pushState("text"),56;case 87:return 58;case 88:return this.pushState("text"),67;case 89:return this.popState(),64;case 90:return this.pushState("text"),63;case 91:return this.popState(),49;case 92:return this.pushState("text"),48;case 93:return this.popState(),69;case 94:return this.popState(),71;case 95:return 117;case 96:return this.pushState("trapText"),68;case 97:return this.pushState("trapText"),70;case 98:return 118;case 99:return 67;case 100:return 90;case 101:return"SEP";case 102:return 89;case 103:return 115;case 104:return 111;case 105:return 44;case 106:return 109;case 107:return 114;case 108:return 116;case 109:return this.popState(),62;case 110:return this.pushState("text"),62;case 111:return this.popState(),51;case 112:return this.pushState("text"),50;case 113:return this.popState(),31;case 114:return this.pushState("text"),29;case 115:return this.popState(),66;case 116:return this.pushState("text"),65;case 117:return"TEXT";case 118:return"QUOTE";case 119:return 9;case 120:return 10;case 121:return 11}},"anonymous"),rules:[/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:@\{)/,/^(?:["])/,/^(?:["])/,/^(?:[^\"]+)/,/^(?:[^}^"]+)/,/^(?:\})/,/^(?:call[\s]+)/,/^(?:\([\s]*\))/,/^(?:\()/,/^(?:[^(]*)/,/^(?:\))/,/^(?:[^)]*)/,/^(?:[^`"]+)/,/^(?:[`]["])/,/^(?:["][`])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:["])/,/^(?:style\b)/,/^(?:default\b)/,/^(?:linkStyle\b)/,/^(?:interpolate\b)/,/^(?:classDef\b)/,/^(?:class\b)/,/^(?:href[\s])/,/^(?:click[\s]+)/,/^(?:[\s\n])/,/^(?:[^\s\n]*)/,/^(?:flowchart-elk\b)/,/^(?:swimlane-beta\b)/,/^(?:graph\b)/,/^(?:flowchart\b)/,/^(?:subgraph\b)/,/^(?:end\b\s*)/,/^(?:_self\b)/,/^(?:_blank\b)/,/^(?:_parent\b)/,/^(?:_top\b)/,/^(?:(\r?\n)*\s*\n)/,/^(?:\s*LR\b)/,/^(?:\s*RL\b)/,/^(?:\s*TB\b)/,/^(?:\s*BT\b)/,/^(?:\s*TD\b)/,/^(?:\s*BR\b)/,/^(?:\s*<)/,/^(?:\s*>)/,/^(?:\s*\^)/,/^(?:\s*v\b)/,/^(?:.*direction\s+TB[^\n]*)/,/^(?:.*direction\s+BT[^\n]*)/,/^(?:.*direction\s+RL[^\n]*)/,/^(?:.*direction\s+LR[^\n]*)/,/^(?:.*direction\s+TD[^\n]*)/,/^(?:[^\s\"]+@(?=[^\{\"]))/,/^(?:[0-9]+)/,/^(?:#)/,/^(?::::)/,/^(?::)/,/^(?:&)/,/^(?:;)/,/^(?:,)/,/^(?:\*)/,/^(?:\s*[xo<]?--+[-xo>]\s*)/,/^(?:\s*[xo<]?--\s*)/,/^(?:[^-]|-(?!-)+)/,/^(?:\s*[xo<]?==+[=xo>]\s*)/,/^(?:\s*[xo<]?==\s*)/,/^(?:[^=]|=(?!))/,/^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,/^(?:\s*[xo<]?-\.\s*)/,/^(?:[^\.]|\.(?!))/,/^(?:\s*~~[\~]+\s*)/,/^(?:[-/\)][\)])/,/^(?:[^\(\)\[\]\{\}]|!\)+)/,/^(?:\(-)/,/^(?:\]\))/,/^(?:\(\[)/,/^(?:\]\])/,/^(?:\[\[)/,/^(?:\[\|)/,/^(?:>)/,/^(?:\)\])/,/^(?:\[\()/,/^(?:\)\)\))/,/^(?:\(\(\()/,/^(?:[\\(?=\])][\]])/,/^(?:\/(?=\])\])/,/^(?:\/(?!\])|\\(?!\])|[^\\\[\]\(\)\{\}\/]+)/,/^(?:\[\/)/,/^(?:\[\\)/,/^(?:<)/,/^(?:>)/,/^(?:\^)/,/^(?:\\\|)/,/^(?:v\b)/,/^(?:\*)/,/^(?:#)/,/^(?:&)/,/^(?:([A-Za-z0-9!"\#$%&'*+\.`?\\_\/]|-(?=[^\>\-\.])|(?!))+)/,/^(?:-)/,/^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/,/^(?:\|)/,/^(?:\|)/,/^(?:\))/,/^(?:\()/,/^(?:\])/,/^(?:\[)/,/^(?:(\}))/,/^(?:\{)/,/^(?:[^\[\]\(\)\{\}\|\"]+)/,/^(?:")/,/^(?:(\r?\n)+)/,/^(?:\s)/,/^(?:$)/],conditions:{shapeDataEndBracket:{rules:[21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},shapeDataStr:{rules:[9,10,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},shapeData:{rules:[8,11,12,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},callbackargs:{rules:[17,18,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},callbackname:{rules:[14,15,16,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},href:{rules:[21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},click:{rules:[21,24,33,34,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},dottedEdgeText:{rules:[21,24,76,78,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},thickEdgeText:{rules:[21,24,73,75,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},edgeText:{rules:[21,24,70,72,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},trapText:{rules:[21,24,79,82,84,86,90,92,93,94,95,96,97,110,112,114,116],inclusive:!1},ellipseText:{rules:[21,24,79,80,81,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},text:{rules:[21,24,79,82,83,84,85,86,89,90,91,92,96,97,109,110,111,112,113,114,115,116,117],inclusive:!1},vertex:{rules:[21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},dir:{rules:[21,24,45,46,47,48,49,50,51,52,53,54,55,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},acc_descr_multiline:{rules:[5,6,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},acc_descr:{rules:[3,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},acc_title:{rules:[1,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},md_string:{rules:[19,20,21,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},string:{rules:[21,22,23,24,79,82,84,86,90,92,96,97,110,112,114,116],inclusive:!1},INITIAL:{rules:[0,2,4,7,13,21,24,25,26,27,28,29,30,31,32,35,36,37,38,39,40,41,42,43,44,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,73,74,76,77,79,82,84,86,87,88,90,92,96,97,98,99,100,101,102,103,104,105,106,107,108,110,112,114,116,118,119,120,121],inclusive:!0}}};return be})();Qe.lexer=Wt;function Ye(){this.yy={}}return k(Ye,"Parser"),Ye.prototype=Qe,Qe.Parser=Ye,new Ye})();rt.parser=rt;var Mt=rt,Ut=Object.assign({},Mt);Ut.parse=e=>{const i=e.replace(/}\s*\n/g,`} +`);return Mt.parse(i)};var D1=Ut,T1=k((e,i)=>{const r=g1,a=r(e,"r"),u=r(e,"g"),f=r(e,"b");return p1(a,u,f,i)},"fade"),S1=k(e=>`.label { + font-family: ${e.fontFamily}; + color: ${e.nodeTextColor||e.textColor}; + } + .cluster-label text { + fill: ${e.titleColor}; + } + .cluster-label span { + color: ${e.titleColor}; + } + .cluster-label span p { + background-color: transparent; + } + + .label text,span { + fill: ${e.nodeTextColor||e.textColor}; + color: ${e.nodeTextColor||e.textColor}; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${e.mainBkg}; + stroke: ${e.nodeBorder}; + stroke-width: ${e.strokeWidth??1}px; + } + .rough-node .label text , .node .label text, .image-shape .label, .icon-shape .label { + text-anchor: middle; + } + + .node .katex path { + fill: #000; + stroke: #000; + stroke-width: 1px; + } + + .rough-node .label,.node .label, .image-shape .label, .icon-shape .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + + .root .anchor path { + fill: ${e.lineColor} !important; + stroke-width: 0; + stroke: ${e.lineColor}; + } + + .arrowheadPath { + fill: ${e.arrowheadColor}; + } + + .edgePaths .path { + stroke: ${e.lineColor}; + stroke-width: ${e.strokeWidth??2}px; + } + + .flowchart-link { + stroke: ${e.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${e.edgeLabelBackground}; + p { + background-color: ${e.edgeLabelBackground}; + } + rect { + opacity: 0.5; + background-color: ${e.edgeLabelBackground}; + fill: ${e.edgeLabelBackground}; + } + text-align: center; + } + + /* For html labels only */ + .labelBkg { + background-color: ${T1(e.edgeLabelBackground,.5)}; + // background-color: + } + + .cluster rect { + fill: ${e.clusterBkg}; + stroke: ${e.clusterBorder}; + stroke-width: 1px; + } + + .cluster text { + fill: ${e.titleColor}; + } + + .cluster span { + color: ${e.titleColor}; + } + /* .cluster div { + color: ${e.titleColor}; + } */ + + /* Collapsed subgraph node (@{ view: collapsed }) */ + .node .collapsed-indicator { + fill: ${e.clusterBorder}; + stroke: none; + opacity: 0.6; + } + + .node .collapsed-separator { + stroke: ${e.clusterBorder}; + stroke-width: 0.75px; + } + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${e.fontFamily}; + font-size: 12px; + background: ${e.tertiaryColor}; + border: 1px solid ${e.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .flowchartTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${e.textColor}; + } + + rect.text { + fill: none; + stroke-width: 0; + } + + .icon-shape, .image-shape { + background-color: ${e.edgeLabelBackground}; + p { + background-color: ${e.edgeLabelBackground}; + padding: 2px; + } + .label rect { + opacity: 0.5; + background-color: ${e.edgeLabelBackground}; + fill: ${e.edgeLabelBackground}; + } + text-align: center; + } + ${qt()} +`,"getStyles"),E1=S1,zt=k(({defaultLayout:e,styles:i=E1}={})=>({parser:D1,get db(){return new A1},renderer:C1,styles:i,init:k(r=>{r.flowchart||(r.flowchart={});const a=Zt().layout??e??r.layout;a&&Ot({layout:a}),r.flowchart.arrowMarkerAbsolute=r.arrowMarkerAbsolute,Ot({flowchart:{arrowMarkerAbsolute:r.arrowMarkerAbsolute}})},"init")}),"createFlowDiagram"),y1=zt();const V1=Object.freeze(Object.defineProperty({__proto__:null,createFlowDiagram:zt,diagram:y1},Symbol.toStringTag,{value:"Module"}));export{zt as c,V1 as f,E1 as s}; diff --git a/packages/tempo/public/v4/assets/chunks/framework.DNL3hc5c.js b/packages/tempo/public/v4/assets/chunks/framework.DNL3hc5c.js new file mode 100644 index 00000000..a05858ac --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/framework.DNL3hc5c.js @@ -0,0 +1,20 @@ +const Sl="modulepreload",Tl=function(e){return"/magma/v4/"+e},jr={},wf=function(t,n,s){let r=Promise.resolve();if(n&&n.length>0){document.getElementsByTagName("link");const o=document.querySelector("meta[property=csp-nonce]"),l=o?.nonce||o?.getAttribute("nonce");r=Promise.allSettled(n.map(c=>{if(c=Tl(c),c in jr)return;jr[c]=!0;const u=c.endsWith(".css"),a=u?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${c}"]${a}`))return;const f=document.createElement("link");if(f.rel=u?"stylesheet":Sl,u||(f.as="script"),f.crossOrigin="",f.href=c,l&&f.setAttribute("nonce",l),document.head.appendChild(f),u)return new Promise((g,y)=>{f.addEventListener("load",g),f.addEventListener("error",()=>y(new Error(`Unable to preload CSS for ${c}`)))})}))}function i(o){const l=new Event("vite:preloadError",{cancelable:!0});if(l.payload=o,window.dispatchEvent(l),!l.defaultPrevented)throw o}return r.then(o=>{for(const l of o||[])l.status==="rejected"&&i(l.reason);return t().catch(i)})};/** +* @vue/shared v3.5.44 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/function dr(e){const t=Object.create(null);for(const n of e.split(","))t[n]=1;return n=>n in t}const se={},At=[],Qe=()=>{},Ni=()=>!1,bn=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),ls=e=>e.startsWith("onUpdate:"),ge=Object.assign,hr=(e,t)=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)},El=Object.prototype.hasOwnProperty,Z=(e,t)=>El.call(e,t),U=Array.isArray,gt=e=>wn(e)==="[object Map]",Dt=e=>wn(e)==="[object Set]",Vr=e=>wn(e)==="[object Date]",q=e=>typeof e=="function",le=e=>typeof e=="string",Le=e=>typeof e=="symbol",ee=e=>e!==null&&typeof e=="object",Di=e=>(ee(e)||q(e))&&q(e.then)&&q(e.catch),Hi=Object.prototype.toString,wn=e=>Hi.call(e),xl=e=>wn(e).slice(8,-1),ki=e=>wn(e)==="[object Object]",cs=e=>le(e)&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e,Rt=dr(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),as=e=>{const t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},Cl=/-\w/g,Ae=as(e=>e.replace(Cl,t=>t.slice(1).toUpperCase())),Al=/\B([A-Z])/g,bt=as(e=>e.replace(Al,"-$1").toLowerCase()),us=as(e=>e.charAt(0).toUpperCase()+e.slice(1)),jn=as(e=>e?`on${us(e)}`:""),Je=(e,t)=>!Object.is(e,t),Vn=(e,...t)=>{for(let n=0;n{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:s,value:n})},fs=e=>{const t=parseFloat(e);return isNaN(t)?e:t},ji=e=>{const t=le(e)?Number(e):NaN;return isNaN(t)?e:t};let Br;const ds=()=>Br||(Br=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{});function pr(e){if(U(e)){const t={};for(let n=0;nn.startsWith("/*")?"":n).split(Ml).forEach(n=>{if(n){const s=n.split(Rl);s.length>1&&(t[s[0].trim()]=s[1].trim())}}),t}function gr(e){let t="";if(le(e))t=e;else if(U(e))for(let n=0;nmt(n,t))}const Bi=e=>!!(e&&e.__v_isRef===!0),Hl=e=>le(e)?e:e==null?"":U(e)||ee(e)&&(e.toString===Hi||!q(e.toString))?Bi(e)?Hl(e.value):JSON.stringify(e,Ui,2):String(e),Ui=(e,t)=>Bi(t)?Ui(e,t.value):gt(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((n,[s,r],i)=>(n[As(s,i)+" =>"]=r,n),{})}:Dt(t)?{[`Set(${t.size})`]:[...t.values()].map(n=>As(n))}:Le(t)?As(t):ee(t)&&!U(t)&&!ki(t)?String(t):t,As=(e,t="")=>{var n;return Le(e)?`Symbol(${(n=e.description)!=null?n:t})`:e};/** +* @vue/reactivity v3.5.44 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/let ye;class kl{constructor(t=!1){this.detached=t,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!t&&ye&&(ye.active?(this.parent=ye,this.index=(ye.scopes||(ye.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let t,n;if(this.scopes){const s=this.scopes.slice();for(t=0,n=s.length;t0&&--this._on===0){if(ye===this)ye=this.prevScope;else{let t=ye;for(;t;){if(t.prevScope===this){t.prevScope=this.prevScope;break}t=t.prevScope}}this.prevScope=void 0}}stop(t){if(this._active){this._active=!1;let n,s;for(n=0,s=this.effects.length;n0)return;if(an){let t=an;for(an=void 0;t;){const n=t.next;t.next=void 0,t.flags&=-9,t=n}}let e;for(;cn;){let t=cn;for(cn=void 0;t;){const n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(s){e||(e=s)}t=n}}if(e)throw e}function Xi(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function Yi(e){let t,n=e.depsTail,s=n;for(;s;){const r=s.prevDep;s.version===-1?(s===n&&(n=r),vr(s),jl(s)):t=s,s.dep.activeLink=s.prevActiveLink,s.prevActiveLink=void 0,s=r}e.deps=t,e.depsTail=n}function Xs(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ji(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ji(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===dn)||(e.globalVersion=dn,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Xs(e))))return;e.flags|=2;const t=e.dep,n=ie,s=Ue;ie=e,Ue=!0;try{Xi(e);const r=e.fn(e._value);(t.version===0||Je(r,e._value))&&(e.flags|=128,e._value=r,t.version++)}catch(r){throw t.version++,r}finally{ie=n,Ue=s,Yi(e),e.flags&=-3}}function vr(e,t=!1){const{dep:n,prevSub:s,nextSub:r}=e;if(s&&(s.nextSub=r,e.prevSub=void 0),r&&(r.prevSub=s,e.nextSub=void 0),n.subs===e&&(n.subs=s,!s&&n.computed)){n.computed.flags&=-5;for(let i=n.computed.deps;i;i=i.nextDep)vr(i,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function jl(e){const{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}let Ue=!0;const zi=[];function Ze(){zi.push(Ue),Ue=!1}function et(){const e=zi.pop();Ue=e===void 0?!0:e}function Kr(e){const{cleanup:t}=e;if(e.cleanup=void 0,t){const n=ie;ie=void 0;try{t()}finally{ie=n}}}let dn=0;class Vl{constructor(t,n){this.sub=t,this.dep=n,this.version=n.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}}class hs{constructor(t){this.computed=t,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(t){if(!ie||!Ue||ie===this.computed)return;let n=this.activeLink;if(n===void 0||n.sub!==ie)n=this.activeLink=new Vl(ie,this),ie.deps?(n.prevDep=ie.depsTail,ie.depsTail.nextDep=n,ie.depsTail=n):ie.deps=ie.depsTail=n,Qi(n);else if(n.version===-1&&(n.version=this.version,n.nextDep)){const s=n.nextDep;s.prevDep=n.prevDep,n.prevDep&&(n.prevDep.nextDep=s),n.prevDep=ie.depsTail,n.nextDep=void 0,ie.depsTail.nextDep=n,ie.depsTail=n,ie.deps===n&&(ie.deps=s)}return n}trigger(t){this.version++,dn++,this.notify(t)}notify(t){mr();try{for(let n=this.subs;n;n=n.prevSub)n.sub.notify()&&n.sub.dep.notify()}finally{yr()}}}function Qi(e){if(e.dep.sc++,e.sub.flags&4){const t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let s=t.deps;s;s=s.nextDep)Qi(s)}const n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}const qn=new WeakMap,Ot=Symbol(""),Ys=Symbol(""),hn=Symbol("");function Te(e,t,n){if(Ue&&ie){let s=qn.get(e);s||qn.set(e,s=new Map);let r=s.get(n);r||(s.set(n,r=new hs),r.map=s,r.key=n),r.track()}}function ot(e,t,n,s,r,i){const o=qn.get(e);if(!o){dn++;return}const l=c=>{c&&c.trigger()};if(mr(),t==="clear")o.forEach(l);else{const c=U(e),u=c&&cs(n);if(c&&n==="length"){const a=Number(s);o.forEach((f,g)=>{(g==="length"||g===hn||!Le(g)&&g>=a)&&l(f)})}else switch((n!==void 0||o.has(void 0))&&l(o.get(n)),u&&l(o.get(hn)),t){case"add":c?u&&l(o.get("length")):(l(o.get(Ot)),gt(e)&&l(o.get(Ys)));break;case"delete":c||(l(o.get(Ot)),gt(e)&&l(o.get(Ys)));break;case"set":gt(e)&&l(o.get(Ot));break}}yr()}function Bl(e,t){const n=qn.get(e);return n&&n.get(t)}function $t(e){const t=Q(e);return t===e||(Te(t,"iterate",hn),Fe(e))?t:tt(e)?ct(e)?t.map(n=>yt($e(n))):t.map(yt):t.map($e)}function ps(e){return Te(e=Q(e),"iterate",hn),e}function Xe(e,t){return tt(e)?yt(ct(e)?$e(t):t):$e(t)}const Ul={__proto__:null,[Symbol.iterator](){return Rs(this,Symbol.iterator,e=>Xe(this,e))},concat(...e){return $t(this).concat(...e.map(t=>U(t)?$t(t):t))},entries(){return Rs(this,"entries",e=>(e[1]=Xe(this,e[1]),e))},every(e,t){return nt(this,"every",e,t,void 0,arguments)},filter(e,t){return nt(this,"filter",e,t,n=>n.map(s=>Xe(this,s)),arguments)},find(e,t){return nt(this,"find",e,t,n=>Xe(this,n),arguments)},findIndex(e,t){return nt(this,"findIndex",e,t,void 0,arguments)},findLast(e,t){return nt(this,"findLast",e,t,n=>Xe(this,n),arguments)},findLastIndex(e,t){return nt(this,"findLastIndex",e,t,void 0,arguments)},forEach(e,t){return nt(this,"forEach",e,t,void 0,arguments)},includes(...e){return Os(this,"includes",e)},indexOf(...e){return Os(this,"indexOf",e)},join(e){return $t(this).join(e)},lastIndexOf(...e){return Os(this,"lastIndexOf",e)},map(e,t){return nt(this,"map",e,t,void 0,arguments)},pop(){return tn(this,"pop")},push(...e){return tn(this,"push",e)},reduce(e,...t){return Gr(this,"reduce",e,t)},reduceRight(e,...t){return Gr(this,"reduceRight",e,t)},shift(){return tn(this,"shift")},some(e,t){return nt(this,"some",e,t,void 0,arguments)},splice(...e){return tn(this,"splice",e)},toReversed(){return $t(this).toReversed()},toSorted(e){return $t(this).toSorted(e)},toSpliced(...e){return $t(this).toSpliced(...e)},unshift(...e){return tn(this,"unshift",e)},values(){return Rs(this,"values",e=>Xe(this,e))}};function Rs(e,t,n){const s=ps(e),r=s[t],i=r.call(s);if(s!==e&&!Fe(e)){if(i[Symbol.toStringTag]==="Array Iterator"){const o=Object.create(Object.getPrototypeOf(i));return o.next=()=>qr(i.next(),n),r!==Zi[t]&&Object.defineProperties(o,{return:{get(){const l=i.return;return typeof l=="function"?l.bind(i):l}},throw:{get(){const l=i.throw;return typeof l=="function"?l.bind(i):l}}}),o}i._next=i.next,i.next=()=>qr(i._next(),n)}return i}function qr(e,t){return e.done||(e.value=t(e.value)),e}const Zi=Array.prototype;function nt(e,t,n,s,r,i){const o=ps(e),l=o!==e&&!Fe(e),c=o[t];if(c!==Zi[t]){const f=c.apply(e,i);return l?$e(f):f}let u=n;o!==e&&(l?u=function(f,g){return n.call(this,Xe(e,f),g,e)}:n.length>2&&(u=function(f,g){return n.call(this,f,g,e)}));const a=c.call(o,u,s);return l&&r?r(a):a}function Gr(e,t,n,s){const r=ps(e),i=r!==e&&!Fe(e);let o=n,l=!1;r!==e&&(i?(l=s.length===0,o=function(u,a,f){return l&&(l=!1,u=Xe(e,u)),n.call(this,u,Xe(e,a),f,e)}):n.length>3&&(o=function(u,a,f){return n.call(this,u,a,f,e)}));const c=r[t](o,...s);return l?Xe(e,c):c}function Os(e,t,n){const s=Q(e);Te(s,"iterate",hn);const r=s[t](...n);return(r===-1||r===!1)&&gs(n[0])?(n[0]=Q(n[0]),s[t](...n)):r}function tn(e,t,n=[]){Ze(),mr();const s=Q(e)[t].apply(e,n);return yr(),et(),s}const Wl=dr("__proto__,__v_isRef,__isVue"),eo=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!=="arguments"&&e!=="caller").map(e=>Symbol[e]).filter(Le));function Kl(e){Le(e)||(e=String(e));const t=Q(this);return Te(t,"has",e),t.hasOwnProperty(e)}class to{constructor(t=!1,n=!1){this._isReadonly=t,this._isShallow=n}get(t,n,s){if(n==="__v_skip")return t.__v_skip;const r=this._isReadonly,i=this._isShallow;if(n==="__v_isReactive")return!r;if(n==="__v_isReadonly")return r;if(n==="__v_isShallow")return i;if(n==="__v_raw")return s===(r?i?tc:io:i?ro:so).get(t)||Object.getPrototypeOf(t)===Object.getPrototypeOf(s)?t:void 0;const o=U(t);if(!r){let c;if(o&&(c=Ul[n]))return c;if(n==="hasOwnProperty")return Kl}const l=Reflect.get(t,n,de(t)?t:s);if((Le(n)?eo.has(n):Wl(n))||(r||Te(t,"get",n),i))return l;if(de(l)){const c=o&&cs(n)?l:l.value;return r&&ee(c)?pn(c):c}return ee(l)?r?pn(l):qt(l):l}}class no extends to{constructor(t=!1){super(!1,t)}set(t,n,s,r){let i=t[n];const o=U(t)&&cs(n);if(!this._isShallow){const u=tt(i);if(!Fe(s)&&!tt(s)&&(i=Q(i),s=Q(s)),!o&&de(i)&&!de(s))return u||(i.value=s),!0}const l=o?Number(n)e,Mn=e=>Reflect.getPrototypeOf(e);function Jl(e,t,n){return function(...s){const r=this.__v_raw,i=Q(r),o=gt(i),l=e==="entries"||e===Symbol.iterator&&o,c=e==="keys"&&o,u=r[e](...s),a=n?Js:t?yt:$e;return!t&&Te(i,"iterate",c?Ys:Ot),ge(Object.create(u),{next(){const{value:f,done:g}=u.next();return g?{value:f,done:g}:{value:l?[a(f[0]),a(f[1])]:a(f),done:g}}})}}function Rn(e){return function(...t){return e==="delete"?!1:e==="clear"?void 0:this}}function zl(e,t){const n={get(r){const i=this.__v_raw,o=Q(i),l=Q(r);e||(Je(r,l)&&Te(o,"get",r),Te(o,"get",l));const{has:c}=Mn(o),u=t?Js:e?yt:$e;if(c.call(o,r))return u(i.get(r));if(c.call(o,l))return u(i.get(l));i!==o&&i.get(r)},get size(){const r=this.__v_raw;return!e&&Te(Q(r),"iterate",Ot),r.size},has(r){const i=this.__v_raw,o=Q(i),l=Q(r);return e||(Je(r,l)&&Te(o,"has",r),Te(o,"has",l)),r===l?i.has(r):i.has(r)||i.has(l)},forEach(r,i){const o=this,l=o.__v_raw,c=Q(l),u=t?Js:e?yt:$e;return!e&&Te(c,"iterate",Ot),l.forEach((a,f)=>r.call(i,u(a),u(f),o))}};return ge(n,e?{add:Rn("add"),set:Rn("set"),delete:Rn("delete"),clear:Rn("clear")}:{add(r){const i=Q(this),o=Mn(i),l=Q(r),c=!t&&!Fe(r)&&!tt(r)?l:r;return o.has.call(i,c)||Je(r,c)&&o.has.call(i,r)||Je(l,c)&&o.has.call(i,l)||(i.add(c),ot(i,"add",c,c)),this},set(r,i){!t&&!Fe(i)&&!tt(i)&&(i=Q(i));const o=Q(this),{has:l,get:c}=Mn(o);let u=l.call(o,r);u||(r=Q(r),u=l.call(o,r));const a=c.call(o,r);return o.set(r,i),u?Je(i,a)&&ot(o,"set",r,i):ot(o,"add",r,i),this},delete(r){const i=Q(this),{has:o,get:l}=Mn(i);let c=o.call(i,r);c||(r=Q(r),c=o.call(i,r)),l&&l.call(i,r);const u=i.delete(r);return c&&ot(i,"delete",r,void 0),u},clear(){const r=Q(this),i=r.size!==0,o=r.clear();return i&&ot(r,"clear",void 0,void 0),o}}),["keys","values","entries",Symbol.iterator].forEach(r=>{n[r]=Jl(r,e,t)}),n}function _r(e,t){const n=zl(e,t);return(s,r,i)=>r==="__v_isReactive"?!e:r==="__v_isReadonly"?e:r==="__v_isShallow"?t:r==="__v_raw"?s:Reflect.get(Z(n,r)&&r in s?n:s,r,i)}const Ql={get:_r(!1,!1)},Zl={get:_r(!1,!0)},ec={get:_r(!0,!1)};const so=new WeakMap,ro=new WeakMap,io=new WeakMap,tc=new WeakMap;function nc(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function qt(e){return tt(e)?e:br(e,!1,Gl,Ql,so)}function sc(e){return br(e,!1,Yl,Zl,ro)}function pn(e){return br(e,!0,Xl,ec,io)}function br(e,t,n,s,r){if(!ee(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;const i=r.get(e);if(i)return i;const o=nc(xl(e));if(o===0)return e;const l=new Proxy(e,o===2?s:n);return r.set(e,l),l}function ct(e){return tt(e)?ct(e.__v_raw):!!(e&&e.__v_isReactive)}function tt(e){return!!(e&&e.__v_isReadonly)}function Fe(e){return!!(e&&e.__v_isShallow)}function gs(e){return e?!!e.__v_raw:!1}function Q(e){const t=e&&e.__v_raw;return t?Q(t):e}function Bn(e){return!Z(e,"__v_skip")&&Object.isExtensible(e)&&$i(e,"__v_skip",!0),e}const $e=e=>ee(e)?qt(e):e,yt=e=>ee(e)?pn(e):e;function de(e){return e?e.__v_isRef===!0:!1}function We(e){return oo(e,!1)}function Re(e){return oo(e,!0)}function oo(e,t){return de(e)?e:new rc(e,t)}class rc{constructor(t,n){this.dep=new hs,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=n?t:Q(t),this._value=n?t:$e(t),this.__v_isShallow=n}get value(){return this.dep.track(),this._value}set value(t){const n=this._rawValue,s=this.__v_isShallow||Fe(t)||tt(t);t=s?t:Q(t),Je(t,n)&&(this._rawValue=t,this._value=s?t:$e(t),this.dep.trigger())}}function ms(e){return de(e)?e.value:e}function ue(e){return q(e)?e():ms(e)}const ic={get:(e,t,n)=>t==="__v_raw"?e:ms(Reflect.get(e,t,n)),set:(e,t,n,s)=>{const r=e[t];return de(r)&&!de(n)?(r.value=n,!0):Reflect.set(e,t,n,s)}};function lo(e){return ct(e)?e:new Proxy(e,ic)}class oc{constructor(t){this.__v_isRef=!0,this._value=void 0;const n=this.dep=new hs,{get:s,set:r}=t(n.track.bind(n),n.trigger.bind(n));this._get=s,this._set=r}get value(){return this._value=this._get()}set value(t){this._set(t)}}function lc(e){return new oc(e)}class cc{constructor(t,n,s){this._object=t,this._defaultValue=s,this.__v_isRef=!0,this._value=void 0,this._key=Le(n)?n:String(n),this._raw=Q(t);let r=!0,i=t;if(!U(t)||Le(this._key)||!cs(this._key))do r=!gs(i)||Fe(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let t=this._object[this._key];return this._shallow&&(t=ms(t)),this._value=t===void 0?this._defaultValue:t}set value(t){if(this._shallow&&de(this._raw[this._key])){const n=this._object[this._key];if(de(n)){n.value=t;return}}this._object[this._key]=t}get dep(){return Bl(this._raw,this._key)}}class ac{constructor(t){this._getter=t,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}}function uc(e,t,n){return de(e)?e:q(e)?new ac(e):ee(e)&&arguments.length>1?fc(e,t,n):We(e)}function fc(e,t,n){return new cc(e,t,n)}class dc{constructor(t,n,s){this.fn=t,this.setter=n,this._value=void 0,this.dep=new hs(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=dn-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!n,this.isSSR=s}notify(){if(this.flags|=16,!(this.flags&8)&&ie!==this)return Gi(this,!0),!0}get value(){const t=this.dep.track();return Ji(this),t&&(t.version=this.dep.version),this._value}set value(t){this.setter&&this.setter(t)}}function hc(e,t,n=!1){let s,r;return q(e)?s=e:(s=e.get,r=e.set),new dc(s,r,n)}const On={},Gn=new WeakMap;let Et;function pc(e,t=!1,n=Et){if(n){let s=Gn.get(n);s||Gn.set(n,s=[]),s.push(e)}}function gc(e,t,n=se){const{immediate:s,deep:r,once:i,scheduler:o,augmentJob:l,call:c}=n,u=m=>r?m:Fe(m)||r===!1||r===0?lt(m,1):lt(m);let a,f,g,y,b=!1,_=!1;if(de(e)?(f=()=>e.value,b=Fe(e)):ct(e)?(f=()=>u(e),b=!0):U(e)?(_=!0,b=e.some(m=>ct(m)||Fe(m)),f=()=>e.map(m=>{if(de(m))return m.value;if(ct(m))return u(m);if(q(m))return c?c(m,2):m()})):q(e)?t?f=c?()=>c(e,2):e:f=()=>{if(g){Ze();try{g()}finally{et()}}const m=Et;Et=a;try{return c?c(e,3,[y]):e(y)}finally{Et=m}}:f=Qe,t&&r){const m=f,v=r===!0?1/0:r;f=()=>lt(m(),v)}const H=Wi(),O=()=>{a.stop(),H&&H.active&&hr(H.effects,a)};if(i&&t){const m=t;t=(...v)=>{try{return m(...v)}finally{O()}}}let P=_?new Array(e.length).fill(On):On;const p=m=>{if(!(!(a.flags&1)||!a.dirty&&!m))if(t){const v=a.run();if(m||r||b||(_?v.some((F,E)=>Je(F,P[E])):Je(v,P))){const F=Et;Ze();try{g&&g(),Et=a;const E=[v,P===On?void 0:_&&P[0]===On?[]:P,y];P=v,c?c(t,3,E):t(...E)}finally{Et=F,et()}}}else a.run()};return l&&l(p),a=new Ki(f),a.scheduler=o?()=>o(p,!1):p,y=m=>pc(m,!1,a),g=a.onStop=()=>{const m=Gn.get(a);if(m){if(c)c(m,4);else for(const v of m)v();Gn.delete(a)}},t?s?p(!0):P=a.run():o?o(p.bind(null,!0),!0):a.run(),O.pause=a.pause.bind(a),O.resume=a.resume.bind(a),O.stop=O,O}function lt(e,t=1/0,n){if(t<=0||!ee(e)||e.__v_skip||(n=n||new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,de(e))lt(e.value,t,n);else if(U(e))for(let s=0;s{lt(s,t,n)});else if(ki(e)){for(const s in e)lt(e[s],t,n);for(const s of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,s)&<(e[s],t,n)}return e}/** +* @vue/runtime-core v3.5.44 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/function Sn(e,t,n,s){try{return s?e(...s):e()}catch(r){zt(r,t,n)}}function je(e,t,n,s){if(q(e)){const r=Sn(e,t,n,s);return r&&Di(r)&&r.catch(i=>{zt(i,t,n)}),r}if(U(e)){const r=[];for(let i=0;i>>1,r=Ce[s],i=gn(r);i=gn(n)?Ce.push(e):Ce.splice(yc(t),0,e),e.flags|=1,ao()}}function ao(){Xn||(Xn=co.then(fo))}function zs(e){if(!U(e))pt&&e.id===-1?pt.splice(Vt+1,0,e):e.flags&1||(Ye.push(e),e.flags|=1);else for(let t=0;t=t))continue;Ce.splice(s,1),s=e?s-1:Be,r.flags&4&&(r.flags&=-2),r(),r.flags&4||(r.flags&=-2)}}}function Yn(e,t,n=0){if(Ye.length){let s=Ye,r=0;if(t){s=[];for(let o=0;ogn(o)-gn(l));if(Ye.length=r,pt){for(let o=0;oe.id==null?e.flags&2?-1:1/0:e.id;function fo(e){try{for(Be=0;Be{s._d&&ns(-1);const i=Jn(t),o=at.length;let l;try{l=e(...r)}finally{for(let c=at.length;c>o;c--)Ss();Jn(i),s._d&&ns(1)}return l};return s._n=!0,s._c=!0,s._d=!0,s}function Sf(e,t){if(be===null)return e;const n=Ts(be),s=e.dirs||(e.dirs=[]);for(let r=0;r1)return n&&q(t)?t.call(s&&s.proxy):t}}function po(){return!!(Ht()||Ft)}const wc=Symbol.for("v-scx"),Sc=()=>Pt(wc);function Sr(e,t){return ys(e,null,t)}function Tf(e,t){return ys(e,null,{flush:"post"})}function ke(e,t,n){return ys(e,t,n)}function ys(e,t,n=se){const{immediate:s,deep:r,flush:i,once:o}=n,l=ge({},n),c=t&&s||!t&&i!=="post";let u;if(Jt){if(i==="sync"){const y=Sc();u=y.__watcherHandles||(y.__watcherHandles=[])}else if(!c){const y=()=>{};return y.stop=Qe,y.resume=Qe,y.pause=Qe,y}}const a=_e;l.call=(y,b,_)=>je(y,a,b,_);let f=!1;i==="post"?l.scheduler=y=>{y.i=a,we(y,a&&a.suspense)}:i!=="sync"&&(f=!0,l.scheduler=(y,b)=>{b?y():wr(y)}),l.augmentJob=y=>{t&&(y.flags|=4),f&&(y.flags|=2,a&&(y.id=a.uid,y.i=a))};const g=gc(e,t,l);return Jt&&(u?u.push(g):c&&g()),g}function Tc(e,t,n){const s=this.proxy,r=le(e)?e.includes(".")?go(s,e):()=>s[e]:e.bind(s,s);let i;q(t)?i=t:(i=t.handler,n=t);const o=Cn(this),l=ys(r,i.bind(s),n);return o(),l}function go(e,t){const n=t.split(".");return()=>{let s=e;for(let r=0;re.__isTeleport,xt=e=>e&&(e.disabled||e.disabled===""),Ec=e=>e&&(e.defer||e.defer===""),Xr=e=>typeof SVGElement<"u"&&e instanceof SVGElement,Yr=e=>typeof MathMLElement=="function"&&e instanceof MathMLElement,Qs=(e,t)=>{const n=e&&e.to;return le(n)?t?t(n):null:n},xc={name:"Teleport",__isTeleport:!0,process(e,t,n,s,r,i,o,l,c,u){const{mc:a,pc:f,pbc:g,o:{insert:y,querySelector:b,createText:_,createComment:H,parentNode:O}}=u,P=xt(t.props);let{dynamicChildren:p}=t;const m=(E,$,T)=>{E.shapeFlag&16&&a(E.children,$,T,r,i,o,l,c)},v=(E=t)=>{const $=xt(E.props),T=E.target=Qs(E.props,b),L=Zs(T,E,_,y);T&&(o!=="svg"&&Xr(T)?o="svg":o!=="mathml"&&Yr(T)&&(o="mathml"),r&&r.isCE&&(r.ce._teleportTargets||(r.ce._teleportTargets=new Set)).add(T),$||(m(E,T,L),rn(E,!1)))},F=E=>{const $=()=>{if(ht.get(E)===$){if(ht.delete(E),xt(E.props)){const T=O(E.el)||n;m(E,T,E.anchor),rn(E,!0)}v(E)}};ht.set(E,$),we($,i)};if(e==null){const E=t.el=_(""),$=t.anchor=_("");if(y(E,n,s),y($,n,s),Ec(t.props)||i&&i.pendingBranch){F(t);return}P&&(m(t,n,$),rn(t,!0)),v()}else{t.el=e.el;const E=t.anchor=e.anchor,$=ht.get(e);if($){$.flags|=8,ht.delete(e),F(t);return}t.targetStart=e.targetStart;const T=t.target=e.target,L=t.targetAnchor=e.targetAnchor,x=xt(e.props),S=x?n:T,I=x?E:L;if(o==="svg"||Xr(T)?o="svg":(o==="mathml"||Yr(T))&&(o="mathml"),p?(g(e.dynamicChildren,p,S,r,i,o,l),Rr(e,t,!0)):c||f(e,t,S,I,r,i,o,l,!1),P)x?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):Pn(t,n,E,u,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){const W=Qs(t.props,b);W&&(t.target=W,Pn(t,W,null,u,0))}else x&&Pn(t,T,L,u,1);rn(t,P)}},remove(e,t,n,{um:s,o:{remove:r}},i){const{shapeFlag:o,children:l,anchor:c,targetStart:u,targetAnchor:a,target:f,props:g}=e,y=xt(g),b=i||!y,_=ht.get(e);if(_&&(_.flags|=8,ht.delete(e)),f&&(r(u),r(a)),i&&r(c),!_&&(y||f)&&o&16)for(let H=0;H{e.isMounted=!0}),So(()=>{e.isUnmounting=!0}),e}const Ne=[Function,Array],yo={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Ne,onEnter:Ne,onAfterEnter:Ne,onEnterCancelled:Ne,onBeforeLeave:Ne,onLeave:Ne,onAfterLeave:Ne,onLeaveCancelled:Ne,onBeforeAppear:Ne,onAppear:Ne,onAfterAppear:Ne,onAppearCancelled:Ne},Mc={name:"BaseTransition",props:yo,setup(e,{slots:t}){const n=Ht(),s=Ac();return()=>{const r=t.default&&bo(t.default(),!0),i=r&&r.length?vo(r):n.subTree?Ma():void 0;if(!i)return;const o=Q(e),{mode:l}=o;if(s.isLeaving)return Is(i);const c=zn(i);if(!c)return Is(i);let u=er(c,o,s,n,f=>u=f);c.type!==pe&&Gt(c,u);let a=n.subTree&&zn(n.subTree);if(a&&a.type!==pe&&!ze(a,c)&&mn(n.subTree)){let f=er(a,o,s,n);if(Gt(a,f),l==="out-in"&&c.type!==pe)return s.isLeaving=!0,f.afterLeave=()=>{s.isLeaving=!1,n.job.flags&8||n.update(),delete f.afterLeave,a=void 0},Is(i);l==="in-out"&&c.type!==pe?f.delayLeave=(g,y,b)=>{const _=_o(s,a);_[String(a.key)]=a,g[He]=()=>{y(),g[He]=void 0,delete u.delayedLeave,a=void 0},u.delayedLeave=()=>{b(),delete u.delayedLeave,a=void 0}}:a=void 0}else a&&(a=void 0);return i}}};function vo(e){let t=e[0];if(e.length>1){for(const n of e)if(n.type!==pe){t=n;break}}return t}const Rc=Mc;function _o(e,t){const{leavingVNodes:n}=e;let s=n.get(t.type);return s||(s=Object.create(null),n.set(t.type,s)),s}function er(e,t,n,s,r){const{appear:i,mode:o,persisted:l=!1,onBeforeEnter:c,onEnter:u,onAfterEnter:a,onEnterCancelled:f,onBeforeLeave:g,onLeave:y,onAfterLeave:b,onLeaveCancelled:_,onBeforeAppear:H,onAppear:O,onAfterAppear:P,onAppearCancelled:p}=t,m=String(e.key),v=_o(n,e),F=(T,L)=>{T&&je(T,s,9,L)},E=(T,L)=>{const x=L[1];F(T,L),U(T)?T.every(S=>S.length<=1)&&x():T.length<=1&&x()},$={mode:o,persisted:l,beforeEnter(T){let L=c;if(!n.isMounted)if(i)L=H||c;else return;T[He]&&T[He](!0);const x=v[m];if(x&&ze(e,x)){let S=x.el[He];if(!S){const I=mn(x);S=I&&I.el[He]}S&&S()}F(L,[T])},enter(T){if(v[m]===e)return;let L=u,x=a,S=f;if(!n.isMounted)if(i)L=O||u,x=P||a,S=p||f;else return;let I=!1;T[nn]=J=>{I||(I=!0,J?F(S,[T]):F(x,[T]),$.delayedLeave&&$.delayedLeave(),T[nn]=void 0)};const W=T[nn].bind(null,!1);L?E(L,[T,W]):W()},leave(T,L){const x=String(e.key);if(T[nn]&&T[nn](!0),n.isUnmounting)return L();F(g,[T]);let S=!1;T[He]=W=>{S||(S=!0,L(),W?F(_,[T]):F(b,[T]),T[He]=void 0,v[x]===e&&delete v[x])};const I=T[He].bind(null,!1);v[x]=e,y?E(y,[T,I]):I()},clone(T){const L=er(T,t,n,s,r);return r&&r(L),L}};return $}function Is(e){if(En(e))return e=vt(e),e.children=null,e}function zn(e){if(!En(e))return vs(e.type)&&e.children?vo(e.children):e;if(e.component)return e.component.subTree;const{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&q(n.default))return n.default()}}function Gt(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;const n=e.component.subTree;Gt(vs(n.type)&&zn(n)||n,t)}else if(e.shapeFlag&128)e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback);else if(e.transition=t,e.type===Ee&&U(e.children)){const n=Cr(e.children,!1);n&&Gt(n,t)}}function bo(e,t=!1,n){let s=[],r=0;for(let i=0;i1)for(let i=0;iUt(_,t&&(U(t)?t[H]:t),n,s,r));return}if(It(s)&&!r){s.shapeFlag&512&&s.type.__asyncResolved&&s.component.subTree.component&&Ut(e,t,n,s.component.subTree);return}const i=s.shapeFlag&4?Ts(s.component):s.el,o=r?null:i,{i:l,r:c}=e,u=t&&t.r,a=l.refs===se?l.refs={}:l.refs,f=l.setupState,g=Q(f),y=f===se?Ni:_=>Jr(a,_)?!1:Z(g,_),b=(_,H)=>!(H&&Jr(a,H));if(u!=null&&u!==c){if(zr(t),le(u))a[u]=null,y(u)&&(f[u]=null);else if(de(u)){const _=t;b(u,_.k)&&(u.value=null),_.k&&(a[_.k]=null)}}if(q(c))Sn(c,l,12,[o,a]);else{const _=le(c),H=de(c);if(_||H){const O=()=>{if(e.f){const P=_?y(c)?f[c]:a[c]:b()||!e.k?c.value:a[e.k];if(r)U(P)&&hr(P,i);else if(U(P))P.includes(i)||P.push(i);else if(_)a[c]=[i],y(c)&&(f[c]=a[c]);else{const p=[i];b(c,e.k)&&(c.value=p),e.k&&(a[e.k]=p)}}else _?(a[c]=o,y(c)&&(f[c]=o)):H&&(b(c,e.k)&&(c.value=o),e.k&&(a[e.k]=o))};if(o){const P=()=>{O(),Qn.delete(e)};P.id=-1,Qn.set(e,P),we(P,n)}else zr(e),O()}}}function zr(e){const t=Qn.get(e);t&&(t.flags|=8,Qn.delete(e))}let Qr=!1;const jt=()=>{Qr||(console.error("Hydration completed but contains mismatches."),Qr=!0)},Oc=e=>e.namespaceURI.includes("svg")&&e.tagName!=="foreignObject",Pc=e=>e.namespaceURI.includes("MathML"),In=e=>{if(e.nodeType===1){if(Oc(e))return"svg";if(Pc(e))return"mathml"}},Bt=e=>e.nodeType===8;function Ic(e){const{mt:t,p:n,o:{patchProp:s,createText:r,nextSibling:i,parentNode:o,remove:l,insert:c,createComment:u}}=e,a=(p,m)=>{if(!m.hasChildNodes()){n(null,p,m),Yn(),m._vnode=p;return}f(m.firstChild,p,null,null,null),Yn(),m._vnode=p},f=(p,m,v,F,E,$=!1)=>{$=$||!!m.dynamicChildren;const T=Bt(p)&&p.data==="[",L=()=>_(p,m,v,F,E,T),{type:x,ref:S,shapeFlag:I,patchFlag:W}=m;let J=p.nodeType;m.el=p,W===-2&&($=!1,m.dynamicChildren=null);let V=null;switch(x){case Lt:J!==3?m.children===""?(c(m.el=r(""),o(p),p),V=p):V=L():(p.data!==m.children&&(jt(),p.data=m.children),V=i(p));break;case pe:P(p)?(V=i(p),O(m.el=p.content.firstChild,p,v)):J!==8||T?V=L():V=i(p);break;case Kt:if(T&&(p=i(p),J=p.nodeType),J===1||J===3){V=p;const X=!m.children.length;for(let G=0;G{$=$||!!m.dynamicChildren;const{type:T,dynamicProps:L,props:x,patchFlag:S,shapeFlag:I,dirs:W,transition:J}=m,V=T==="input"||T==="option",X=!!L;if(V||X||S!==-1){W&&Ge(m,null,v,"created");let G=!1;if(P(p)){G=Vo(null,J)&&v&&v.vnode.props&&v.vnode.props.appear;const re=p.content.firstChild;if(G){const ve=re.getAttribute("class");ve&&(re.$cls=ve),J.beforeEnter(re)}O(re,p,v),m.el=p=re}if(I&16&&!(x&&(x.innerHTML||x.textContent))){let re=y(p.firstChild,m,p,v,F,E,$);for(re&&!Un(p,1)&&jt();re;){const ve=re;re=re.nextSibling,l(ve)}}else if(I&8){let re=m.children;re[0]===` +`&&(p.tagName==="PRE"||p.tagName==="TEXTAREA")&&(re=re.slice(1));const{textContent:ve}=p;ve!==re&&ve!==re.replace(/\r\n|\r/g,` +`)&&(Un(p,0)||jt(),p.textContent=m.children)}if(x){if(V||X||!$||S&48){const re=p.tagName.includes("-"),ve=p.namespaceURI.includes("svg")?"svg":p.namespaceURI.includes("MathML")?"mathml":void 0;for(const ae in x)if(V&&(ae.endsWith("value")||ae==="indeterminate")||bn(ae)&&!Rt(ae)||ae[0]==="."||re&&!Rt(ae)||L&&L.includes(ae)){if(Lc(p,ae,x[ae]))continue;s(p,ae,null,x[ae],ve,v)}}else if(x.onClick)s(p,"onClick",null,x.onClick,void 0,v);else if(S&4&&ct(x.style))for(const re in x.style)x.style[re]}let ce;(ce=x&&x.onVnodeBeforeMount)&&De(ce,v,m),W&&Ge(m,null,v,"beforeMount"),((ce=x&&x.onVnodeMounted)||W||G)&&Ko(()=>{ce&&De(ce,v,m),G&&J.enter(p),W&&Ge(m,null,v,"mounted")},F)}return p.nextSibling},y=(p,m,v,F,E,$,T)=>{T=T||!!m.dynamicChildren;const L=m.children,x=L.length;let S=!1;for(let I=0;I{const{slotScopeIds:T}=m;T&&(E=E?E.concat(T):T);const L=o(p),x=y(i(p),m,L,v,F,E,$);return x&&Bt(x)&&x.data==="]"?i(m.anchor=x):(jt(),c(m.anchor=u("]"),L,x),x)},_=(p,m,v,F,E,$)=>{if(Dc(p,m)||jt(),m.el=null,$){const x=H(p);for(;;){const S=i(p);if(S&&S!==x)l(S);else break}}const T=i(p),L=o(p);return l(p),n(null,m,L,T,v,F,In(L),E),v&&(v.vnode.el=m.el,ws(v,m.el)),T},H=(p,m="[",v="]")=>{let F=0;for(;p;)if(p=i(p),p&&Bt(p)&&(p.data===m&&F++,p.data===v)){if(F===0)return i(p);F--}return p},O=(p,m,v)=>{const F=m.parentNode;F&&F.replaceChild(p,m);let E=v;for(;E;)E.vnode.el===m&&(E.vnode.el=E.subTree.el=p),E=E.parent},P=p=>p.nodeType===1&&p.tagName==="TEMPLATE";return[a,f]}const Fc=new Set(["src","srcset","href","poster"]);function Lc(e,t,n){return Fc.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}const Zn="data-allow-mismatch",Nc={0:"text",1:"children",2:"class",3:"style",4:"attribute"};function Un(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(Zn);)e=e.parentElement;return xr(e&&e.getAttribute(Zn),t)}function xr(e,t){if(e==null)return!1;if(e==="")return!0;{const n=e.split(",");return t===0&&n.includes("children")?!0:n.includes(Nc[t])}}function Dc(e,t){return Un(e.parentElement,1)||Hc(e)||kc(t)}function Hc(e){return e.nodeType===1&&xr(e.getAttribute(Zn),1)}function kc({props:e}){const t=e&&e[Zn];return typeof t=="string"&&xr(t,1)}ds().requestIdleCallback;ds().cancelIdleCallback;function $c(e,t){if(Bt(e)&&e.data==="["){let n=1,s=e.nextSibling;for(;s;){if(s.nodeType===1){if(t(s)===!1)break}else if(Bt(s))if(s.data==="]"){if(--n===0)break}else s.data==="["&&n++;s=s.nextSibling}}else t(e)}const It=e=>!!e.type.__asyncLoader;function xf(e){q(e)&&(e={loader:e});const{loader:t,loadingComponent:n,errorComponent:s,delay:r=200,hydrate:i,timeout:o,suspensible:l=!0,onError:c}=e;let u=null,a,f=0;const g=()=>(f++,u=null,y()),y=()=>{let b;return u||(b=u=t().catch(_=>{if(_=_ instanceof Error?_:new Error(String(_)),c)return new Promise((H,O)=>{c(_,()=>H(g()),()=>O(_),f+1)});throw _}).then(_=>b!==u&&u?u:(_&&(_.__esModule||_[Symbol.toStringTag]==="Module")&&(_=_.default),a=_,_)))};return Tr({name:"AsyncComponentWrapper",__asyncLoader:y,__asyncHydrate(b,_,H){const O=b.isConnected;let P=!1;(_.bu||(_.bu=[])).push(()=>P=!0);const p=()=>{P||!b.parentNode||O&&!b.isConnected||H()},m=i?()=>{const v=i(p,F=>$c(b,F));v&&(_.bum||(_.bum=[])).push(v)}:p;a?m():y().then(()=>!_.isUnmounted&&m())},get __asyncResolved(){return a},setup(){const b=_e;if(Er(b),a)return()=>Fn(a,b);const _=v=>{u=null,zt(v,b,13,!s)};if(l&&b.suspense||Jt)return y().then(v=>()=>Fn(v,b)).catch(v=>(_(v),()=>s?fe(s,{error:v}):null));const H=We(!1),O=We(),P=We(!!r);let p,m;return xn(()=>{p!=null&&clearTimeout(p),m!=null&&clearTimeout(m)}),r&&(m=setTimeout(()=>{b.isUnmounted||(P.value=!1)},r)),o!=null&&(p=setTimeout(()=>{if(!b.isUnmounted&&!H.value&&!O.value){const v=new Error(`Async component timed out after ${o}ms.`);_(v),O.value=v}},o)),y().then(()=>{b.isUnmounted||(H.value=!0,b.parent&&En(b.parent.vnode)&&b.parent.update())}).catch(v=>{if(b.isUnmounted){u=null;return}_(v),O.value=v}),()=>{if(H.value&&a)return Fn(a,b);if(O.value&&s)return fe(s,{error:O.value});if(n&&!P.value)return Fn(n,b)}}})}function Fn(e,t){const{ref:n,props:s,children:r,ce:i}=t.vnode,o=fe(e,s,r);return o.ref=n,o.ce=i,delete t.vnode.ce,o}const En=e=>e.type.__isKeepAlive;function jc(e,t){wo(e,"a",t)}function Vc(e,t){wo(e,"da",t)}function wo(e,t,n=_e){const s=e.__wdc||(e.__wdc=()=>{let r=n;for(;r;){if(r.isDeactivated)return;r=r.parent}return e()});if(_s(t,s,n),n){let r=n.parent;for(;r&&r.parent;)En(r.parent.vnode)&&Bc(s,t,n,r),r=r.parent}}function Bc(e,t,n,s){const r=_s(t,e,s,!0);xn(()=>{hr(s[t],r)},n)}function _s(e,t,n=_e,s=!1){if(n){const r=n[e]||(n[e]=[]),i=t.__weh||(t.__weh=(...o)=>{Ze();const l=Cn(n),c=je(t,n,e,o);return l(),et(),c});return s?r.unshift(i):r.push(i),i}}const ft=e=>(t,n=_e)=>{(!Jt||e==="sp")&&_s(e,(...s)=>t(...s),n)},Uc=ft("bm"),Qt=ft("m"),Wc=ft("bu"),Kc=ft("u"),So=ft("bum"),xn=ft("um"),qc=ft("sp"),Gc=ft("rtg"),Xc=ft("rtc");function Yc(e,t=_e){_s("ec",e,t)}const To="components";function Cf(e,t){return xo(To,e,!0,t)||e}const Eo=Symbol.for("v-ndc");function Af(e){return le(e)?xo(To,e,!1)||e:e||Eo}function xo(e,t,n=!0,s=!1){const r=be||_e;if(r){const i=r.type;{const l=Da(i,!1);if(l&&(l===t||l===Ae(t)||l===us(Ae(t))))return i}const o=Zr(r[e]||i[e],t)||Zr(r.appContext[e],t);return!o&&s?i:o}}function Zr(e,t){return e&&(e[t]||e[Ae(t)]||e[us(Ae(t))])}function Mf(e,t,n,s){let r;const i=n,o=U(e);if(o||le(e)){const l=o&&ct(e);let c=!1,u=!1;l&&(c=!Fe(e),u=tt(e),e=ps(e)),r=new Array(e.length);for(let a=0,f=e.length;at(l,c,void 0,i));else{const l=Object.keys(e);r=new Array(l.length);for(let c=0,u=l.length;c0;return t!=="default"&&(u.name=t),ts(),lr(Ee,null,[fe("slot",u,s&&s())],a?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);const l=at.length;ts();let c;try{const u=o&&Co(o(n)),a=n.key||i||u&&u.key;c=lr(Ee,{key:(a&&!Le(a)?a:`_${t}`)+(!u&&s?"_fb":"")},u||(s?s():[]),u&&e._===1?64:-2)}catch(u){for(let a=at.length;a>l;a--)Ss();throw u}finally{o&&o._c&&(o._d=!0)}return!r&&c.scopeId&&(c.slotScopeIds=[c.scopeId+"-s"]),c}function Co(e){return e.some(t=>Yt(t)?!(t.type===pe||t.type===Ee&&!Co(t.children)):!0)?e:null}function Of(e,t){const n={};for(const s in e)n[/[A-Z]/.test(s)?`on:${s}`:jn(s)]=e[s];return n}const tr=e=>e?zo(e)?Ts(e):tr(e.parent):null,un=ge(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>tr(e.parent),$root:e=>tr(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Mo(e),$forceUpdate:e=>e.f||(e.f=()=>{wr(e.update)}),$nextTick:e=>e.n||(e.n=Tn.bind(e.proxy)),$watch:e=>Tc.bind(e)}),Fs=(e,t)=>e!==se&&!e.__isScriptSetup&&Z(e,t),Jc={get({_:e},t){if(t==="__v_skip")return!0;const{ctx:n,setupState:s,data:r,props:i,accessCache:o,type:l,appContext:c}=e;if(t[0]!=="$"){const g=o[t];if(g!==void 0)switch(g){case 1:return s[t];case 2:return r[t];case 4:return n[t];case 3:return i[t]}else{if(Fs(s,t))return o[t]=1,s[t];if(r!==se&&Z(r,t))return o[t]=2,r[t];if(Z(i,t))return o[t]=3,i[t];if(n!==se&&Z(n,t))return o[t]=4,n[t];nr&&(o[t]=0)}}const u=un[t];let a,f;if(u)return t==="$attrs"&&Te(e.attrs,"get",""),u(e);if((a=l.__cssModules)&&(a=a[t]))return a;if(n!==se&&Z(n,t))return o[t]=4,n[t];if(f=c.config.globalProperties,Z(f,t))return f[t]},set({_:e},t,n){const{data:s,setupState:r,ctx:i}=e;return Fs(r,t)?(r[t]=n,!0):s!==se&&Z(s,t)?(s[t]=n,!0):Z(e.props,t)||t[0]==="$"&&t.slice(1)in e?!1:(i[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:s,appContext:r,props:i,type:o}},l){let c;return!!(n[l]||e!==se&&l[0]!=="$"&&Z(e,l)||Fs(t,l)||Z(i,l)||Z(s,l)||Z(un,l)||Z(r.config.globalProperties,l)||(c=o.__cssModules)&&c[l])},defineProperty(e,t,n){return n.get!=null?e._.accessCache[t]=0:Z(n,"value")&&this.set(e,t,n.value,null),Reflect.defineProperty(e,t,n)}};function Pf(){return zc().slots}function zc(e){const t=Ht();return t.setupContext||(t.setupContext=Zo(t))}function ei(e){return U(e)?e.reduce((t,n)=>(t[n]=null,t),{}):e}let nr=!0;function Qc(e){const t=Mo(e),n=e.proxy,s=e.ctx;nr=!1,t.beforeCreate&&ti(t.beforeCreate,e,"bc");const{data:r,computed:i,methods:o,watch:l,provide:c,inject:u,created:a,beforeMount:f,mounted:g,beforeUpdate:y,updated:b,activated:_,deactivated:H,beforeDestroy:O,beforeUnmount:P,destroyed:p,unmounted:m,render:v,renderTracked:F,renderTriggered:E,errorCaptured:$,serverPrefetch:T,expose:L,inheritAttrs:x,components:S,directives:I,filters:W}=t;if(u&&Zc(u,s,null),o)for(const X in o){const G=o[X];q(G)&&(s[X]=G.bind(n))}if(r){const X=r.call(n,n);ee(X)&&(e.data=qt(X))}if(nr=!0,i)for(const X in i){const G=i[X],ce=q(G)?G.bind(n,n):q(G.get)?G.get.bind(n,n):Qe,re=!q(G)&&q(G.set)?G.set.bind(n):Qe,ve=oe({get:ce,set:re});Object.defineProperty(s,X,{enumerable:!0,configurable:!0,get:()=>ve.value,set:ae=>ve.value=ae})}if(l)for(const X in l)Ao(l[X],s,n,X);if(c){const X=q(c)?c.call(n):c;Reflect.ownKeys(X).forEach(G=>{bc(G,X[G])})}a&&ti(a,e,"c");function V(X,G){U(G)?G.forEach(ce=>X(ce.bind(n))):G&&X(G.bind(n))}if(V(Uc,f),V(Qt,g),V(Wc,y),V(Kc,b),V(jc,_),V(Vc,H),V(Yc,$),V(Xc,F),V(Gc,E),V(So,P),V(xn,m),V(qc,T),U(L))if(L.length){const X=e.exposed||(e.exposed={});L.forEach(G=>{Object.defineProperty(X,G,{get:()=>n[G],set:ce=>n[G]=ce,enumerable:!0})})}else e.exposed||(e.exposed={});v&&e.render===Qe&&(e.render=v),x!=null&&(e.inheritAttrs=x),S&&(e.components=S),I&&(e.directives=I),T&&Er(e)}function Zc(e,t,n=Qe){U(e)&&(e=sr(e));for(const s in e){const r=e[s];let i;ee(r)?"default"in r?i=Pt(r.from||s,r.default,!0):i=Pt(r.from||s):i=Pt(r),de(i)?Object.defineProperty(t,s,{enumerable:!0,configurable:!0,get:()=>i.value,set:o=>i.value=o}):t[s]=i}}function ti(e,t,n){je(U(e)?e.map(s=>s.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ao(e,t,n,s){let r=s.includes(".")?go(n,s):()=>n[s];if(le(e)){const i=t[e];q(i)&&ke(r,i)}else if(q(e))ke(r,e.bind(n));else if(ee(e))if(U(e))e.forEach(i=>Ao(i,t,n,s));else{const i=q(e.handler)?e.handler.bind(n):t[e.handler];q(i)&&ke(r,i,e)}}function Mo(e){const t=e.type,{mixins:n,extends:s}=t,{mixins:r,optionsCache:i,config:{optionMergeStrategies:o}}=e.appContext,l=i.get(t);let c;return l?c=l:!r.length&&!n&&!s?c=t:(c={},r.length&&r.forEach(u=>es(c,u,o,!0)),es(c,t,o)),ee(t)&&i.set(t,c),c}function es(e,t,n,s=!1){const{mixins:r,extends:i}=t;i&&es(e,i,n,!0),r&&r.forEach(o=>es(e,o,n,!0));for(const o in t)if(!(s&&o==="expose")){const l=ea[o]||n&&n[o];e[o]=l?l(e[o],t[o]):t[o]}return e}const ea={data:ni,props:si,emits:si,methods:on,computed:on,beforeCreate:xe,created:xe,beforeMount:xe,mounted:xe,beforeUpdate:xe,updated:xe,beforeDestroy:xe,beforeUnmount:xe,destroyed:xe,unmounted:xe,activated:xe,deactivated:xe,errorCaptured:xe,serverPrefetch:xe,components:on,directives:on,watch:na,provide:ni,inject:ta};function ni(e,t){return t?e?function(){return ge(q(e)?e.call(this,this):e,q(t)?t.call(this,this):t)}:t:e}function ta(e,t){return on(sr(e),sr(t))}function sr(e){if(U(e)){const t={};for(let n=0;nt==="modelValue"||t==="model-value"?e.modelModifiers:e[`${t}Modifiers`]||e[`${Ae(t)}Modifiers`]||e[`${bt(t)}Modifiers`];function oa(e,t,...n){if(e.isUnmounted)return;const s=e.vnode.props||se;let r=n;const i=t.startsWith("update:"),o=i&&ia(s,t.slice(7));o&&(o.trim&&(r=n.map(a=>le(a)?a.trim():a)),o.number&&(r=r.map(fs)));let l,c=s[l=jn(t)]||s[l=jn(Ae(t))];!c&&i&&(c=s[l=jn(bt(t))]),c&&je(c,e,6,r);const u=s[l+"Once"];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[l])return;e.emitted[l]=!0,je(u,e,6,r)}}const la=new WeakMap;function Oo(e,t,n=!1){const s=n?la:t.emitsCache,r=s.get(e);if(r!==void 0)return r;const i=e.emits;let o={},l=!1;if(!q(e)){const c=u=>{const a=Oo(u,t,!0);a&&(l=!0,ge(o,a))};!n&&t.mixins.length&&t.mixins.forEach(c),e.extends&&c(e.extends),e.mixins&&e.mixins.forEach(c)}return!i&&!l?(ee(e)&&s.set(e,null),null):(U(i)?i.forEach(c=>o[c]=null):ge(o,i),ee(e)&&s.set(e,o),o)}function bs(e,t){return!e||!bn(t)?!1:(t=t.slice(2),t=t==="Once"?t:t.replace(/Once$/,""),Z(e,t[0].toLowerCase()+t.slice(1))||Z(e,bt(t))||Z(e,t))}function Ls(e){const{type:t,vnode:n,proxy:s,withProxy:r,propsOptions:[i],slots:o,attrs:l,emit:c,render:u,renderCache:a,props:f,data:g,setupState:y,ctx:b,inheritAttrs:_}=e,H=Jn(e);let O,P;try{if(n.shapeFlag&4){const m=r||s,v=m;O=Ie(u.call(v,m,a,f,y,g,b)),P=l}else{const m=t;O=Ie(m.length>1?m(f,{attrs:l,slots:o,emit:c}):m(f,null)),P=t.props?l:ca(l)}}catch(m){at.length=0,zt(m,e,1),O=fe(pe)}let p=O;if(P&&_!==!1){const m=Object.keys(P),{shapeFlag:v}=p;m.length&&v&7&&(i&&m.some(ls)&&(P=aa(P,i)),p=vt(p,P,!1,!0))}if(n.dirs&&(p=vt(p,null,!1,!0),p.dirs=p.dirs?p.dirs.concat(n.dirs):n.dirs),n.transition){const m=vs(p.type)&&zn(p)||p;Gt(m,n.transition)}return O=p,Jn(H),O}function Cr(e,t=!0){let n;for(let s=0;s{let t;for(const n in e)(n==="class"||n==="style"||bn(n))&&((t||(t={}))[n]=e[n]);return t},aa=(e,t)=>{const n={};for(const s in e)(!ls(s)||!(s.slice(9)in t))&&(n[s]=e[s]);return n};function ua(e,t,n){const{props:s,children:r,component:i}=e,{props:o,children:l,patchFlag:c}=t,u=i.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return s?ri(s,o,u):!!o;if(c&8){const a=t.dynamicProps;for(let f=0;fObject.create(Io),Lo=e=>Object.getPrototypeOf(e)===Io;function fa(e,t,n,s=!1){const r={},i=Fo();e.propsDefaults=Object.create(null),No(e,t,r,i);for(const o in e.propsOptions[0])o in r||(r[o]=void 0);n?e.props=s?r:sc(r):e.type.props?e.props=r:e.props=i,e.attrs=i}function da(e,t,n,s){const{props:r,attrs:i,vnode:{patchFlag:o}}=e,l=Q(r),[c]=e.propsOptions;let u=!1;if((s||o>0)&&!(o&16)){if(o&8){const a=e.vnode.dynamicProps;for(let f=0;f{c=!0;const[g,y]=Do(f,t,!0);ge(o,g),y&&l.push(...y)};!n&&t.mixins.length&&t.mixins.forEach(a),e.extends&&a(e.extends),e.mixins&&e.mixins.forEach(a)}if(!i&&!c)return ee(e)&&s.set(e,At),At;if(U(i))for(let a=0;ae==="_"||e==="_ctx"||e==="$stable",Mr=e=>U(e)?e.map(Ie):[Ie(e)],pa=(e,t,n)=>{if(t._n)return t;const s=_c((...r)=>Mr(t(...r)),n);return s._c=!1,s},Ho=(e,t,n)=>{const s=e._ctx;for(const r in e){if(Ar(r))continue;const i=e[r];if(q(i))t[r]=pa(r,i,s);else if(i!=null){const o=Mr(i);t[r]=()=>o}}},ko=(e,t)=>{const n=Mr(t);e.slots.default=()=>n},$o=(e,t,n)=>{for(const s in t)(n||!Ar(s))&&(e[s]=t[s])},ga=(e,t,n)=>{const s=e.slots=Fo();if(e.vnode.shapeFlag&32){const r=t._;r?($o(s,t,n),n&&$i(s,"_",r,!0)):Ho(t,s)}else t&&ko(e,t)},ma=(e,t,n)=>{const{vnode:s,slots:r}=e;let i=!0,o=se;if(s.shapeFlag&32){const l=t._;l?n&&l===1?i=!1:$o(r,t,n):(i=!t.$stable,Ho(t,r)),o=t}else t&&(ko(e,t),o={default:1});if(i)for(const l in r)!Ar(l)&&o[l]==null&&delete r[l]},we=Ko;function ya(e){return jo(e)}function va(e){return jo(e,Ic)}function jo(e,t){const n=ds();n.__VUE__=!0;const{insert:s,remove:r,patchProp:i,createElement:o,createText:l,createComment:c,setText:u,setElementText:a,parentNode:f,nextSibling:g,setScopeId:y=Qe,insertStaticContent:b}=e,_=(d,h,w,R=null,C=null,M=null,k=void 0,D=null,N=!!h.dynamicChildren)=>{if(d===h)return;d&&!ze(d,h)&&(R=An(d),ae(d,C,M,!0),d=null),h.patchFlag===-2&&(N=!1,h.dynamicChildren=null),h.dynamicChildren&&d&&d.dynamicChildren&&d.dynamicChildren.hasOnce&&(h.dynamicChildren===At&&(h.dynamicChildren=[]),h.dynamicChildren.hasOnce=!0);const{type:A,ref:K,shapeFlag:j}=h;switch(A){case Lt:H(d,h,w,R);break;case pe:O(d,h,w,R);break;case Kt:d==null&&P(h,w,R,k);break;case Ee:S(d,h,w,R,C,M,k,D,N);break;default:j&1?v(d,h,w,R,C,M,k,D,N):j&6?I(d,h,w,R,C,M,k,D,N):(j&64||j&128)&&A.process(d,h,w,R,C,M,k,D,N,kt)}K!=null&&C?Ut(K,d&&d.ref,M,h||d,!h):K==null&&d&&d.ref!=null&&Ut(d.ref,null,M,d,!0)},H=(d,h,w,R)=>{if(d==null)s(h.el=l(h.children),w,R);else{const C=h.el=d.el;h.children!==d.children&&u(C,h.children)}},O=(d,h,w,R)=>{d==null?s(h.el=c(h.children||""),w,R):h.el=d.el},P=(d,h,w,R)=>{[d.el,d.anchor]=b(d.children,h,w,R,d.el,d.anchor)},p=({el:d,anchor:h},w,R)=>{let C;for(;d&&d!==h;)C=g(d),s(d,w,R),d=C;s(h,w,R)},m=({el:d,anchor:h})=>{let w;for(;d&&d!==h;)w=g(d),r(d),d=w;r(h)},v=(d,h,w,R,C,M,k,D,N)=>{if(h.type==="svg"?k="svg":h.type==="math"&&(k="mathml"),d==null)F(h,w,R,C,M,k,D,N);else{const A=d.el&&d.el._isVueCE?d.el:null;try{A&&A._beginPatch(),T(d,h,C,M,k,D,N)}finally{A&&A._endPatch()}}},F=(d,h,w,R,C,M,k,D)=>{let N,A;const{props:K,shapeFlag:j,transition:B,dirs:Y}=d;if(N=d.el=o(d.type,M,K&&K.is,K),j&8?a(N,d.children):j&16&&$(d.children,N,null,R,C,Ns(d,M),k,D),Y&&Ge(d,null,R,"created"),E(N,d,d.scopeId,k,R),K){for(const ne in K)ne!=="value"&&!Rt(ne)&&i(N,ne,null,K[ne],M,R);"value"in K&&i(N,"value",null,K.value,M),(A=K.onVnodeBeforeMount)&&De(A,R,d)}Y&&Ge(d,null,R,"beforeMount");const z=Vo(C,B);z&&B.beforeEnter(N),s(N,h,w),((A=K&&K.onVnodeMounted)||z||Y)&&we(()=>{A&&De(A,R,d),z&&B.enter(N),Y&&Ge(d,null,R,"mounted")},C)},E=(d,h,w,R,C)=>{if(w&&y(d,w),R)for(let M=0;M{for(let A=N;A{const D=h.el=d.el;let{patchFlag:N,dynamicChildren:A,dirs:K}=h;N|=d.patchFlag&16;const j=d.props||se,B=h.props||se;let Y;if(w&&wt(w,!1),(Y=B.onVnodeBeforeUpdate)&&De(Y,w,h,d),K&&Ge(h,d,w,"beforeUpdate"),w&&wt(w,!0),A&&(!d.dynamicChildren||d.dynamicChildren.length!==A.length)&&(N=0,k=!1,A=null),(j.innerHTML&&B.innerHTML==null||j.textContent&&B.textContent==null)&&a(D,""),A?L(d.dynamicChildren,A,D,w,R,Ns(h,C),M):k||G(d,h,D,null,w,R,Ns(h,C),M,!1),N>0){if(N&16)x(D,j,B,w,C);else if(N&2&&j.class!==B.class&&i(D,"class",null,B.class,C),N&4&&i(D,"style",j.style,B.style,C),N&8){const z=h.dynamicProps;for(let ne=0;ne{Y&&De(Y,w,h,d),K&&Ge(h,d,w,"updated")},R)},L=(d,h,w,R,C,M,k)=>{for(let D=0;D{if(h!==w){if(h!==se)for(const M in h)!Rt(M)&&!(M in w)&&i(d,M,h[M],null,C,R);for(const M in w){if(Rt(M))continue;const k=w[M],D=h[M];k!==D&&M!=="value"&&i(d,M,D,k,C,R)}"value"in w&&i(d,"value",h.value,w.value,C)}},S=(d,h,w,R,C,M,k,D,N)=>{const A=h.el=d?d.el:l(""),K=h.anchor=d?d.anchor:l("");let{patchFlag:j,dynamicChildren:B,slotScopeIds:Y}=h;Y&&(D=D?D.concat(Y):Y),d==null?(s(A,w,R),s(K,w,R),$(h.children||[],w,K,C,M,k,D,N)):j>0&&j&64&&B&&d.dynamicChildren&&d.dynamicChildren.length===B.length?(L(d.dynamicChildren,B,w,C,M,k,D),(h.key!=null||C&&h===C.subTree)&&Rr(d,h,!0)):G(d,h,w,K,C,M,k,D,N)},I=(d,h,w,R,C,M,k,D,N)=>{h.slotScopeIds=D,d==null?h.shapeFlag&512?C.ctx.activate(h,w,R,k,N):W(h,w,R,C,M,k,N):J(d,h,N)},W=(d,h,w,R,C,M,k)=>{const D=d.component=Ia(d,R,C);if(En(d)&&(D.ctx.renderer=kt),Fa(D,!1,k),D.asyncDep){if(C&&C.registerDep(D,V,k,M),!d.el){const N=D.subTree=fe(pe);O(null,N,h,w),d.placeholder=N.el}}else V(D,d,h,w,C,M,k)},J=(d,h,w)=>{const R=h.component=d.component;if(ua(d,h,w))if(R.asyncDep&&!R.asyncResolved){h.el=d.el,h.placeholder=d.placeholder,X(R,h,w);return}else R.next=h,R.update();else h.el=d.el,h.placeholder=d.placeholder,R.vnode=h},V=(d,h,w,R,C,M,k)=>{const D=()=>{if(d.isMounted){let{next:j,bu:B,u:Y,parent:z,vnode:ne}=d;{const Oe=Bo(d);if(Oe){j&&(j.el=ne.el,X(d,j,k)),Oe.asyncDep.then(()=>{we(()=>{d.isUnmounted||A()},C)});return}}let te=j,he;wt(d,!1),j?(j.el=ne.el,X(d,j,k)):j=ne,B&&Vn(B),(he=j.props&&j.props.onVnodeBeforeUpdate)&&De(he,z,j,ne),wt(d,!0);const me=Ls(d),Ve=d.subTree;d.subTree=me,_(Ve,me,f(Ve.el),An(Ve),d,C,M),j.el=me.el,te===null&&ws(d,me.el),Y&&we(Y,C),(he=j.props&&j.props.onVnodeUpdated)&&we(()=>De(he,z,j,ne),C)}else{let j;const{el:B,props:Y}=h,{bm:z,m:ne,parent:te,root:he,type:me}=d,Ve=It(h);if(wt(d,!1),z&&Vn(z),!Ve&&(j=Y&&Y.onVnodeBeforeMount)&&De(j,te,h),wt(d,!0),B&&Cs){const Oe=()=>{d.subTree=Ls(d),Cs(B,d.subTree,d,C,null)};Ve&&me.__asyncHydrate?me.__asyncHydrate(B,d,Oe):Oe()}else{he.ce&&he.ce._hasShadowRoot()&&he.ce._injectChildStyle(me,d.parent?d.parent.type:void 0);const Oe=d.subTree=Ls(d);_(null,Oe,w,R,d,C,M),h.el=Oe.el}if(ne&&we(ne,C),!Ve&&(j=Y&&Y.onVnodeMounted)){const Oe=h;we(()=>De(j,te,Oe),C)}(h.shapeFlag&256||te&&It(te.vnode)&&te.vnode.shapeFlag&256)&&d.a&&we(d.a,C),d.isMounted=!0,h=w=R=null}};d.scope.on();const N=d.effect=new Ki(D);d.scope.off();const A=d.update=N.run.bind(N),K=d.job=N.runIfDirty.bind(N);K.i=d,K.id=d.uid,N.scheduler=()=>wr(K),wt(d,!0),A()},X=(d,h,w)=>{h.component=d;const R=d.vnode.props;d.vnode=h,d.next=null,da(d,h.props,R,w),ma(d,h.children,w),Ze(),uo(d),et()},G=(d,h,w,R,C,M,k,D,N=!1)=>{const A=d&&d.children,K=d?d.shapeFlag:0,j=h.children,{patchFlag:B,shapeFlag:Y}=h;if(B>0){if(B&128){re(A,j,w,R,C,M,k,D,N);return}else if(B&256){ce(A,j,w,R,C,M,k,D,N);return}}Y&8?(K&16&&Zt(A,C,M),j!==A&&a(w,j)):K&16?Y&16?re(A,j,w,R,C,M,k,D,N):Zt(A,C,M,!0):(K&8&&a(w,""),Y&16&&$(j,w,R,C,M,k,D,N))},ce=(d,h,w,R,C,M,k,D,N)=>{d=d||At,h=h||At;const A=d.length,K=h.length,j=Math.min(A,K);let B;for(B=0;BK?Zt(d,C,M,!0,!1,j):$(h,w,R,C,M,k,D,N,j)},re=(d,h,w,R,C,M,k,D,N)=>{let A=0;const K=h.length;let j=d.length-1,B=K-1;for(;A<=j&&A<=B;){const Y=d[A],z=h[A]=N?it(h[A]):Ie(h[A]);if(ze(Y,z))_(Y,z,w,null,C,M,k,D,N);else break;A++}for(;A<=j&&A<=B;){const Y=d[j],z=h[B]=N?it(h[B]):Ie(h[B]);if(ze(Y,z))_(Y,z,w,null,C,M,k,D,N);else break;j--,B--}if(A>j){if(A<=B){const Y=B+1,z=YB)for(;A<=j;)ae(d[A],C,M,!0),A++;else{const Y=A,z=A,ne=new Map;for(A=z;A<=B;A++){const Pe=h[A]=N?it(h[A]):Ie(h[A]);Pe.key!=null&&ne.set(Pe.key,A)}let te,he=0;const me=B-z+1;let Ve=!1,Oe=0;const en=new Array(me);for(A=0;A=me){ae(Pe,C,M,!0);continue}let qe;if(Pe.key!=null)qe=ne.get(Pe.key);else for(te=z;te<=B;te++)if(en[te-z]===0&&ze(Pe,h[te])){qe=te;break}qe===void 0?ae(Pe,C,M,!0):(en[qe-z]=A+1,qe>=Oe?Oe=qe:Ve=!0,_(Pe,h[qe],w,null,C,M,k,D,N),he++)}const Hr=Ve?_a(en):At;for(te=Hr.length-1,A=me-1;A>=0;A--){const Pe=z+A,qe=h[Pe],kr=h[Pe+1],$r=Pe+1{const{el:M,type:k,transition:D,children:N,shapeFlag:A}=d;if(A&6){ve(d.component.subTree,h,w,R);return}if(A&128){d.suspense.move(h,w,R);return}if(A&64){k.move(d,h,w,kt);return}if(k===Ee){s(M,h,w);for(let j=0;jD.enter(M),C));else{const{leave:j,delayLeave:B,afterLeave:Y}=D,z=()=>{d.ctx.isUnmounted?r(M):s(M,h,w)},ne=()=>{const te=M._isLeaving||!!M[He];M._isLeaving&&M[He](!0),D.persisted&&!te?z():j(M,()=>{z(),Y&&Y()})};B?B(M,z,ne):ne()}else s(M,h,w)},ae=(d,h,w,R=!1,C=!1)=>{const{type:M,props:k,ref:D,children:N,dynamicChildren:A,shapeFlag:K,patchFlag:j,dirs:B,cacheIndex:Y,memo:z}=d;if((j===-2||A&&A.hasOnce)&&(C=!1),D!=null&&(Ze(),Ut(D,null,w,d,!0),et()),Y!=null&&(!d.ctx||d.ctx===h)&&(h.renderCache[Y]=void 0),K&256){h.ctx.deactivate(d);return}const ne=K&1&&B,te=!It(d);let he;if(te&&(he=k&&k.onVnodeBeforeUnmount)&&De(he,h,d),K&6)wl(d.component,w,R);else{if(K&128){d.suspense.unmount(w,R);return}ne&&Ge(d,null,h,"beforeUnmount"),K&64?d.type.remove(d,h,w,kt,R):A&&!A.hasOnce&&(M!==Ee||j>0&&j&64)?Zt(A,h,w,!1,!0):(M===Ee&&j&384||!C&&K&16)&&Zt(N,h,w),R&&Lr(d)}const me=z!=null&&Y==null;(te&&(he=k&&k.onVnodeUnmounted)||ne||me)&&we(()=>{he&&De(he,h,d),ne&&Ge(d,null,h,"unmounted"),me&&(d.el=null)},w)},Lr=d=>{const{type:h,el:w,anchor:R,transition:C}=d,M=h===Ee;if(M&&!C){Nr(w,R);return}if(h===Kt){m(d),C&&!C.persisted&&C.afterLeave&&C.afterLeave();return}const k=M?mn(d):d,D=()=>{M?f(w)&&Nr(w,R):r(w),C&&!C.persisted&&C.afterLeave&&C.afterLeave()};if(k&&k.shapeFlag&1&&C&&!C.persisted){const{leave:N,delayLeave:A}=C,K=k.el,j=()=>N(K,D);A?A(K,D,j):j()}else D()},Nr=(d,h)=>{let w;for(;d!==h;)w=g(d),r(d),d=w;r(h)},wl=(d,h,w)=>{const{bum:R,scope:C,job:M,subTree:k,um:D,m:N,a:A}=d;oi(N),oi(A),R&&Vn(R),C.stop(),M?(M.flags|=8,ae(k,d,h,w)):d.vnode.el&&k&&(k.transition=d.vnode.transition,ae(k,d,h,w)),D&&we(D,h),we(()=>{d.isUnmounted=!0},h)},Zt=(d,h,w,R=!1,C=!1,M=0)=>{for(let k=M;k{if(d.shapeFlag&6)return An(d.component.subTree);if(d.shapeFlag&128)return d.suspense.next();const h=g(d.anchor||d.el),w=h&&h[mo];return w?g(w):h},Dr=(d,h,w)=>{const R=d&&h._vnode?void 0:d&&d.component?d.component.uid:Pa();vc(()=>{d==null?h._vnode&&ae(h._vnode,null,null,!0):_(h._vnode||null,d,h,null,null,null,w),h._vnode=d},R)},kt={p:_,um:ae,m:ve,r:Lr,mt:W,mc:$,pc:G,pbc:L,n:An,o:e};let xs,Cs;return t&&([xs,Cs]=t(kt)),{render:Dr,hydrate:xs,createApp:ra(Dr,xs)}}function Ns({type:e,props:t},n){return n==="svg"&&e==="foreignObject"||n==="mathml"&&e==="annotation-xml"&&t&&t.encoding&&t.encoding.includes("html")?void 0:n}function wt({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Vo(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Rr(e,t,n=!1){const s=e.children,r=t.children;if(U(s)&&U(r))for(let i=0;i>1,e[n[l]]0&&(t[s]=n[i-1]),n[i]=s)}}for(i=n.length,o=n[i-1];i-- >0;)n[i]=o,o=t[o];return n}function Bo(e){const t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Bo(t)}function oi(e){if(e)for(let t=0;te.__isSuspense;let or=0;const ba={name:"Suspense",__isSuspense:!0,process(e,t,n,s,r,i,o,l,c,u){if(e==null)wa(t,n,s,r,i,o,l,c,u);else{if(i&&i.deps>0&&!e.suspense.isInFallback&&!i.isHydrating){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}Sa(e,t,n,s,r,o,l,c,u)}},hydrate:Ta,normalize:Ea},If=ba;function yn(e,t){const n=e.props&&e.props[t];q(n)&&n()}function wa(e,t,n,s,r,i,o,l,c){const{p:u,o:{createElement:a}}=c,f=a("div"),g=e.suspense=Wo(e,r,s,t,f,n,i,o,l,c);u(null,g.pendingBranch=e.ssContent,f,null,s,g,i,o),g.deps>0?(yn(e,"onPending"),yn(e,"onFallback"),u(null,e.ssFallback,t,n,s,null,i,o),Wt(g,e.ssFallback)):g.resolve(!1,!0)}function Sa(e,t,n,s,r,i,o,l,{p:c,um:u,o:{createElement:a}}){const f=t.suspense=e.suspense;f.vnode=t,t.el=e.el;const g=t.ssContent,y=t.ssFallback,{activeBranch:b,pendingBranch:_,isInFallback:H,isHydrating:O}=f;if(_)f.pendingBranch=g,ze(_,g)?(f.deps++,c(_,g,O?n:f.hiddenContainer,null,r,f,i,o,l),f.deps--,f.deps<=0?f.resolve():H&&!O&&!f.isFallbackMountPending&&(c(b,y,n,s,r,null,i,o,l),Wt(f,y))):(f.pendingId=or++,O?(f.isHydrating=!1,f.activeBranch=_):u(_,r,f),f.deps=0,f.effects.length=0,f.hiddenContainer=a("div"),H?(c(null,g,f.hiddenContainer,null,r,f,i,o,l),f.deps<=0?f.resolve():f.isFallbackMountPending||(c(b,y,n,s,r,null,i,o,l),Wt(f,y))):b&&ze(b,g)?(c(b,g,n,s,r,f,i,o,l),f.resolve(!0)):(c(null,g,f.hiddenContainer,null,r,f,i,o,l),f.deps<=0&&f.resolve()));else if(b&&ze(b,g))c(b,g,n,s,r,f,i,o,l),Wt(f,g);else if(yn(t,"onPending"),f.pendingBranch=g,g.shapeFlag&512?f.pendingId=g.component.suspenseId:f.pendingId=or++,c(null,g,f.hiddenContainer,null,r,f,i,o,l),f.deps<=0)f.resolve();else{const{timeout:P,pendingId:p}=f;P>0?setTimeout(()=>{f.pendingId===p&&f.fallback(y)},P):P===0&&f.fallback(y)}}function Wo(e,t,n,s,r,i,o,l,c,u,a=!1){const{p:f,m:g,um:y,n:b,o:{parentNode:_,remove:H}}=u;let O;const P=xa(e);P&&t&&t.pendingBranch&&(O=t.pendingId,t.deps++);const p=e.props?ji(e.props.timeout):void 0,m=i,v={vnode:e,parent:t,parentComponent:n,namespace:o,container:s,hiddenContainer:r,deps:0,pendingId:or++,timeout:typeof p=="number"?p:-1,activeBranch:null,isFallbackMountPending:!1,pendingBranch:null,isInFallback:!a,isHydrating:a,isUnmounted:!1,effects:[],resolve(F=!1,E=!1){const{vnode:$,activeBranch:T,pendingBranch:L,pendingId:x,effects:S,parentComponent:I,container:W,isInFallback:J}=v;let V=!1;if(v.isHydrating)v.isHydrating=!1;else if(!F){V=T&&L.transition&&L.transition.mode==="out-in";let ce=!1;V&&(T.transition.afterLeave=()=>{x===v.pendingId&&(g(L,W,i===m&&!ce?b(T):i,0),zs(S),J&&$.ssFallback&&($.ssFallback.el=null))}),T&&!v.isFallbackMountPending&&(_(T.el)===W&&(i=b(T),ce=!0),y(T,I,v,!0),!V&&J&&$.ssFallback&&we(()=>$.ssFallback.el=null,v)),V||g(L,W,i,0)}v.isFallbackMountPending=!1,Wt(v,L),v.pendingBranch=null,v.isInFallback=!1;let X=v.parent,G=!1;for(;X;){if(X.pendingBranch){for(let ce=0;ce{if(v.isFallbackMountPending=!1,!v.isInFallback)return;const J=v.vnode.ssFallback;f(null,J,L,S,T,null,x,l,c),Wt(v,J)},W=F.transition&&F.transition.mode==="out-in";W&&(v.isFallbackMountPending=!0,$.transition.afterLeave=I),v.isInFallback=!0,y($,T,null,!0),W||I()},move(F,E,$){v.activeBranch&&g(v.activeBranch,F,E,$),v.container=F},next(){return v.activeBranch&&b(v.activeBranch)},registerDep(F,E,$,T){const L=!!v.pendingBranch;L&&v.deps++;const x=F.vnode.el;F.asyncDep.catch(S=>{zt(S,F,0)}).then(S=>{if(F.isUnmounted||v.isUnmounted||v.pendingId!==F.suspenseId)return;if(cr(),!F.scope.active){L&&--v.deps===0&&v.resolve();return}F.asyncResolved=!0;const{vnode:I}=F;ar(F,S),x&&(I.el=x);const W=!x&&F.subTree.el;E(F,I,_(x||F.subTree.el),x?null:b(F.subTree),v,T,$),W&&(I.placeholder=null,H(W)),ws(F,I.el),L&&--v.deps===0&&v.resolve()})},unmount(F,E){v.isUnmounted=!0,v.activeBranch&&y(v.activeBranch,n,F,E),v.pendingBranch&&y(v.pendingBranch,n,F,E)}};return v}function Ta(e,t,n,s,r,i,o,l,c){const u=t.suspense=Wo(t,s,n,e.parentNode,document.createElement("div"),null,r,i,o,l,!0),a=c(e,u.pendingBranch=t.ssContent,n,u,i,o);return u.deps===0&&u.resolve(!1,!0),a}function Ea(e){const{shapeFlag:t,children:n}=e,s=t&32;e.ssContent=li(s?n.default:n),e.ssFallback=s?li(n.fallback):fe(pe)}function li(e){let t;if(q(e)){const n=Xt&&e._c;n&&(e._d=!1,ts()),e=e(),n&&(e._d=!0,t=Me,Ss())}return U(e)&&(e=Cr(e)),e=Ie(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(n=>n!==e)),e}function Ko(e,t){t&&t.pendingBranch?U(e)?t.effects.push(...e):t.effects.push(e):zs(e)}function Wt(e,t){e.activeBranch=t;const{vnode:n,parentComponent:s}=e;let r=t.el;for(;!r&&t.component;)t=t.component.subTree,r=t.el;n.el=r,s&&s.subTree===n&&(s.vnode.el=r,ws(s,r))}function xa(e){const t=e.props&&e.props.suspensible;return t!=null&&t!==!1}const Ee=Symbol.for("v-fgt"),Lt=Symbol.for("v-txt"),pe=Symbol.for("v-cmt"),Kt=Symbol.for("v-stc"),at=[];let Me=null;function ts(e=!1){at.push(Me=e?null:[])}function Ss(){at.pop(),Me=at[at.length-1]||null}let Xt=1;function ns(e,t=!1){Xt+=e,e<0&&Me&&t&&(Me.hasOnce=!0)}function qo(e){return e.dynamicChildren=Xt>0?Me||At:null,Ss(),Xt>0&&Me&&Me.push(e),e}function Ff(e,t,n,s,r,i){return qo(Xo(e,t,n,s,r,i,!0))}function lr(e,t,n,s,r){return qo(fe(e,t,n,s,r,!0))}function Yt(e){return e?e.__v_isVNode===!0:!1}function ze(e,t){return e.type===t.type&&e.key===t.key}const Go=({key:e})=>e??null,Wn=({ref:e,ref_key:t,ref_for:n})=>(typeof e=="number"&&(e=""+e),e!=null?le(e)||de(e)||q(e)?{i:be,r:e,k:t,f:!!n}:e:null);function Xo(e,t=null,n=null,s=0,r=null,i=e===Ee?0:1,o=!1,l=!1){const c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&Go(t),ref:t&&Wn(t),scopeId:ho,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:i,patchFlag:s,dynamicProps:r,dynamicChildren:null,appContext:null,ctx:be};return l?(ss(c,n),i&128&&e.normalize(c)):n&&(c.shapeFlag|=le(n)?8:16),Xt>0&&!o&&Me&&(c.patchFlag>0||i&6)&&c.patchFlag!==32&&Me.push(c),c}const fe=Ca;function Ca(e,t=null,n=null,s=0,r=null,i=!1){if((!e||e===Eo)&&(e=pe),Yt(e)){const l=vt(e,t,!0);return n&&ss(l,n),Xt>0&&!i&&Me&&(l.shapeFlag&6?Me[Me.indexOf(e)]=l:Me.push(l)),l.patchFlag=-2,l}if(Ha(e)&&(e=e.__vccOpts),t){t=Aa(t);let{class:l,style:c}=t;l&&!le(l)&&(t.class=gr(l)),ee(c)&&(gs(c)&&!U(c)&&(c=ge({},c)),t.style=pr(c))}const o=le(e)?1:Uo(e)?128:vs(e)?64:ee(e)?4:q(e)?2:0;return Xo(e,t,n,s,r,o,i,!0)}function Aa(e){return e?gs(e)||Lo(e)?ge({},e):e:null}function vt(e,t,n=!1,s=!1){const{props:r,ref:i,patchFlag:o,children:l,transition:c}=e,u=t?Ra(r||{},t):r,a={__v_isVNode:!0,__v_skip:!0,type:e.type,props:u,key:u&&Go(u),ref:t&&t.ref?n&&i?U(i)?i.concat(Wn(t)):[i,Wn(t)]:Wn(t):i,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:l,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==Ee?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&vt(e.ssContent),ssFallback:e.ssFallback&&vt(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce,cacheIndex:e.cacheIndex};return c&&s&&Gt(a,c.clone(a)),a}function Yo(e=" ",t=0){return fe(Lt,null,e,t)}function Lf(e,t){const n=fe(Kt,null,e);return n.staticCount=t,n}function Ma(e="",t=!1){return t?(ts(),lr(pe,null,e)):fe(pe,null,e)}function Ie(e){return e==null||typeof e=="boolean"?fe(pe):U(e)?fe(Ee,null,e.slice()):Yt(e)?it(e):fe(Lt,null,String(e))}function it(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:vt(e)}function ss(e,t){let n=0;const{shapeFlag:s}=e;if(t==null)t=null;else if(U(t))n=16;else if(typeof t=="object")if(s&65){const r=t.default;r&&(r._c&&(r._d=!1),ss(e,r()),r._c&&(r._d=!0));return}else{n=32;const r=t._;!r&&!Lo(t)?t._ctx=be:r===3&&be&&(be.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}else if(q(t)){if(s&65){ss(e,{default:t});return}t={default:t,_ctx:be},n=32}else t=String(t),s&64?(n=16,t=[Yo(t)]):n=8;e.children=t,e.shapeFlag|=n}function Ra(...e){const t={};for(let n=0;n_e||be;let rs,vn;{const e=ds(),t=(n,s)=>{let r;return(r=e[n])||(r=e[n]=[]),r.push(s),i=>{r.length>1?r.forEach(o=>o(i)):r[0](i)}};rs=t("__VUE_INSTANCE_SETTERS__",n=>_e=n),vn=t("__VUE_SSR_SETTERS__",n=>Jt=n)}const Cn=e=>{const t=_e;return rs(e),e.scope.on(),()=>{e.scope.off(),rs(t)}},cr=()=>{_e&&_e.scope.off(),rs(null)};function zo(e){return e.vnode.shapeFlag&4}let Jt=!1;function Fa(e,t=!1,n=!1){t&&vn(t);const{props:s,children:r}=e.vnode,i=zo(e);fa(e,s,i,t),ga(e,r,n||t);const o=i?La(e,t):void 0;return t&&vn(!1),o}function La(e,t){const n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,Jc);const{setup:s}=n;if(s){Ze();const r=e.setupContext=s.length>1?Zo(e):null,i=Cn(e),o=Sn(s,e,0,[e.props,r]),l=Di(o);if(et(),i(),(l||e.sp)&&!It(e)&&Er(e),l){if(o.then(cr,cr),t)return o.then(c=>{vn(!0);try{ar(e,c,t)}finally{vn(!1)}}).catch(c=>{zt(c,e,0)});e.asyncDep=o}else ar(e,o)}else Qo(e)}function ar(e,t,n){q(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:ee(t)&&(e.setupState=lo(t)),Qo(e)}function Qo(e,t,n){const s=e.type;e.render||(e.render=s.render||Qe);{const r=Cn(e);Ze();try{Qc(e)}finally{et(),r()}}}const Na={get(e,t){return Te(e,"get",""),e[t]}};function Zo(e){const t=n=>{e.exposed=n||{}};return{attrs:new Proxy(e.attrs,Na),slots:e.slots,emit:e.emit,expose:t}}function Ts(e){return e.exposed?e.exposeProxy||(e.exposeProxy=new Proxy(lo(Bn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in un)return un[n](e)},has(t,n){return n in t||n in un}})):e.proxy}function Da(e,t=!0){return q(e)?e.displayName||e.name:e.name||t&&e.__name}function Ha(e){return q(e)&&"__vccOpts"in e}const oe=(e,t)=>hc(e,t,Jt);function ur(e,t,n){try{ns(-1);const s=arguments.length;return s===2?ee(t)&&!U(t)?Yt(t)?fe(e,null,[t]):fe(e,t):fe(e,null,t):(s>3?n=Array.prototype.slice.call(arguments,2):s===3&&Yt(n)&&(n=[n]),fe(e,t,n))}finally{ns(1)}}const ka="3.5.44";/** +* @vue/runtime-dom v3.5.44 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/let fr;const ci=typeof window<"u"&&window.trustedTypes;if(ci)try{fr=ci.createPolicy("vue",{createHTML:e=>e})}catch{}const el=fr?e=>fr.createHTML(e):e=>e,$a="http://www.w3.org/2000/svg",ja="http://www.w3.org/1998/Math/MathML",rt=typeof document<"u"?document:null,ai=rt&&rt.createElement("template"),Va={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,s)=>{const r=t==="svg"?rt.createElementNS($a,e):t==="mathml"?rt.createElementNS(ja,e):n?rt.createElement(e,{is:n}):rt.createElement(e);return e==="select"&&s&&s.multiple!=null&&r.setAttribute("multiple",s.multiple),r},createText:e=>rt.createTextNode(e),createComment:e=>rt.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>rt.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,s,r,i){const o=n?n.previousSibling:t.lastChild;if(r&&(r===i||r.nextSibling))for(;t.insertBefore(r.cloneNode(!0),n),!(r===i||!(r=r.nextSibling)););else{ai.innerHTML=el(s==="svg"?`${e}`:s==="mathml"?`${e}`:e);const l=ai.content;if(s==="svg"||s==="mathml"){const c=l.firstChild;for(;c.firstChild;)l.appendChild(c.firstChild);l.removeChild(c)}t.insertBefore(l,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},dt="transition",sn="animation",_n=Symbol("_vtc"),tl={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Ba=ge({},yo,tl),Ua=e=>(e.displayName="Transition",e.props=Ba,e),Nf=Ua((e,{slots:t})=>ur(Rc,Wa(e),t)),St=(e,t=[])=>{U(e)?e.forEach(n=>n(...t)):e&&e(...t)},ui=e=>e?U(e)?e.some(t=>t.length>1):e.length>1:!1;function Wa(e){const t={};for(const S in e)S in tl||(t[S]=e[S]);if(e.css===!1)return t;const{name:n="v",type:s,duration:r,enterFromClass:i=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:l=`${n}-enter-to`,appearFromClass:c=i,appearActiveClass:u=o,appearToClass:a=l,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:g=`${n}-leave-active`,leaveToClass:y=`${n}-leave-to`}=e,b=Ka(r),_=b&&b[0],H=b&&b[1],{onBeforeEnter:O,onEnter:P,onEnterCancelled:p,onLeave:m,onLeaveCancelled:v,onBeforeAppear:F=O,onAppear:E=P,onAppearCancelled:$=p}=t,T=(S,I,W,J)=>{S._enterCancelled=J,Tt(S,I?a:l),Tt(S,I?u:o),W&&W()},L=(S,I)=>{S._isLeaving=!1,Tt(S,f),Tt(S,y),Tt(S,g),I&&I()},x=S=>(I,W)=>{const J=S?E:P,V=()=>T(I,S,W);St(J,[I,V]),fi(()=>{Tt(I,S?c:i),st(I,S?a:l),ui(J)||di(I,s,_,V)})};return ge(t,{onBeforeEnter(S){St(O,[S]),st(S,i),st(S,o)},onBeforeAppear(S){St(F,[S]),st(S,c),st(S,u)},onEnter:x(!1),onAppear:x(!0),onLeave(S,I){S._isLeaving=!0;const W=()=>L(S,I);st(S,f),S._enterCancelled?(st(S,g),gi(S)):(gi(S),st(S,g)),fi(()=>{S._isLeaving&&(Tt(S,f),st(S,y),ui(m)||di(S,s,H,W))}),St(m,[S,W])},onEnterCancelled(S){T(S,!1,void 0,!0),St(p,[S])},onAppearCancelled(S){T(S,!0,void 0,!0),St($,[S])},onLeaveCancelled(S){L(S),St(v,[S])}})}function Ka(e){if(e==null)return null;if(ee(e))return[Ds(e.enter),Ds(e.leave)];{const t=Ds(e);return[t,t]}}function Ds(e){return ji(e)}function st(e,t){t.split(/\s+/).forEach(n=>n&&e.classList.add(n)),(e[_n]||(e[_n]=new Set)).add(t)}function Tt(e,t){t.split(/\s+/).forEach(s=>s&&e.classList.remove(s));const n=e[_n];n&&(n.delete(t),n.size||(e[_n]=void 0))}function fi(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let qa=0;function di(e,t,n,s){const r=e._endId=++qa,i=()=>{r===e._endId&&s()};if(n!=null)return setTimeout(i,n);const{type:o,timeout:l,propCount:c}=Ga(e,t);if(!o)return s();const u=o+"end";let a=0;const f=()=>{e.removeEventListener(u,g),i()},g=y=>{y.target===e&&++a>=c&&f()};setTimeout(()=>{a(n[b]||"").split(", "),r=s(`${dt}Delay`),i=s(`${dt}Duration`),o=hi(r,i),l=s(`${sn}Delay`),c=s(`${sn}Duration`),u=hi(l,c);let a=null,f=0,g=0;t===dt?o>0&&(a=dt,f=o,g=i.length):t===sn?u>0&&(a=sn,f=u,g=c.length):(f=Math.max(o,u),a=f>0?o>u?dt:sn:null,g=a?a===dt?i.length:c.length:0);const y=a===dt&&/\b(?:transform|all)(?:,|$)/.test(s(`${dt}Property`).toString());return{type:a,timeout:f,propCount:g,hasTransform:y}}function hi(e,t){for(;e.lengthpi(n)+pi(e[s])))}function pi(e){return e==="auto"?0:Number(e.slice(0,-1).replace(",","."))*1e3}function gi(e){return(e?e.ownerDocument:document).body.offsetHeight}function Xa(e,t,n){const s=e[_n];s&&(t=(t?[t,...s]:[...s]).join(" ")),t==null?e.removeAttribute("class"):n?e.setAttribute("class",t):e.className=t}const mi=Symbol("_vod"),Ya=Symbol("_vsh"),Ja=Symbol(""),za=/(?:^|;)\s*display\s*:/;function Qa(e,t,n){const s=e.style,r=le(n);let i=!1;if(n&&!r){if(t)if(le(t))for(const o of t.split(";")){const l=o.slice(0,o.indexOf(":")).trim();n[l]==null&&ln(s,l,"")}else for(const o in t)n[o]==null&&ln(s,o,"");for(const o in n){o==="display"&&(i=!0);const l=n[o];l!=null?eu(e,o,!le(t)&&t?t[o]:void 0,l)||ln(s,o,l):ln(s,o,"")}}else if(r){if(t!==n){const o=s[Ja];o&&(n+=";"+o),s.cssText=n,i=za.test(n)}}else t&&e.removeAttribute("style");mi in e&&((!r||t!==n)&&(e[mi]=i?s.display:""),e[Ya]&&(s.display="none"))}const Ln=/\s*!important$/;function ln(e,t,n){if(U(n))n.forEach(s=>ln(e,t,s));else if(n==null&&(n=""),t.startsWith("--"))Ln.test(n)?e.setProperty(t,n.replace(Ln,""),"important"):e.setProperty(t,n);else{const s=Za(e,t);Ln.test(n)?e.setProperty(bt(s),n.replace(Ln,""),"important"):e[s]=n}}const yi=["Webkit","Moz","ms"],Hs={};function Za(e,t){const n=Hs[t];if(n)return n;let s=Ae(t);if(s!=="filter"&&s in e)return Hs[t]=s;s=us(s);for(let r=0;rks||(ou.then(()=>ks=0),ks=Date.now());function cu(e,t){const n=s=>{if(!s._vts)s._vts=Date.now();else if(s._vts<=n.attached)return;const r=n.value;if(U(r)){const i=s.stopImmediatePropagation;s.stopImmediatePropagation=()=>{i.call(s),s._stopped=!0};const o=r.slice(),l=[s];for(let c=0;ce.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,au=(e,t,n,s,r,i)=>{const o=r==="svg";t==="class"?Xa(e,s,o):t==="style"?Qa(e,n,s):bn(t)?ls(t)||nu(e,t,n,s,i):(t[0]==="."?(t=t.slice(1),!0):t[0]==="^"?(t=t.slice(1),!1):uu(e,t,s,o))?(bi(e,t,s),!e.tagName.includes("-")&&(t==="value"||t==="checked"||t==="selected")&&_i(e,t,s,o,i,t!=="value")):e._isVueCE&&(fu(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!le(s)))?bi(e,Ae(t),s,i,t):(t==="true-value"?e._trueValue=s:t==="false-value"&&(e._falseValue=s),_i(e,t,s,o))};function uu(e,t,n,s){if(s)return!!(t==="innerHTML"||t==="textContent"||t in e&&Si(t)&&q(n));if(t==="spellcheck"||t==="draggable"||t==="translate"||t==="autocorrect"||t==="sandbox"&&e.tagName==="IFRAME"||t==="form"||t==="list"&&e.tagName==="INPUT"||t==="type"&&e.tagName==="TEXTAREA")return!1;if(t==="width"||t==="height"){const r=e.tagName;if(r==="IMG"||r==="VIDEO"||r==="CANVAS"||r==="SOURCE")return!1}return Si(t)&&le(n)?!1:t in e}function fu(e,t){const n=e._def.props;if(!n)return!1;const s=Ae(t);return Array.isArray(n)?n.some(r=>Ae(r)===s):Object.keys(n).some(r=>Ae(r)===s)}const is=e=>{const t=e.props["onUpdate:modelValue"]||!1;return U(t)?n=>Vn(t,n):t};function du(e){e.target.composing=!0}function Ti(e){const t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event("input")))}const Mt=Symbol("_assign"),Nn=Symbol("_initialValue");function $s(e,t,n){return t&&(e=e.trim()),n&&(e=fs(e)),e}const Df={created(e,{modifiers:{lazy:t,trim:n,number:s}},r){e.parentNode&&(e.type==="text"?e[Nn]=e.defaultValue.replace(/[\r\n]/g,""):e.type==="textarea"&&(e[Nn]=e.defaultValue.replace(/\r\n?/g,` +`))),e[Mt]=is(r);const i=s||r.props&&r.props.type==="number";Ct(e,t?"change":"input",o=>{o.target.composing||e[Mt]($s(e.value,n,i))}),(n||i)&&Ct(e,"change",()=>{e.value=$s(e.value,n,i)}),t||(Ct(e,"compositionstart",du),Ct(e,"compositionend",Ti),Ct(e,"change",Ti))},mounted(e,{value:t,modifiers:{trim:n,number:s}}){const r=t??"",i=e[Nn];delete e[Nn],i!==void 0&&(e.type==="text"||e.type==="textarea")&&e.value!==i?e[Mt]($s(e.value,n,s)):e.value=r},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:s,trim:r,number:i}},o){if(e[Mt]=is(o),e.composing)return;const l=(i||e.type==="number")&&!/^0\d/.test(e.value)?fs(e.value):e.value,c=t??"";if(l===c)return;const u=e.getRootNode();(u instanceof Document||u instanceof ShadowRoot)&&u.activeElement===e&&e.type!=="range"&&(s&&t===n||r&&e.value.trim()===c)||(e.value=c)}},Hf={deep:!0,created(e,{value:t,modifiers:{number:n}},s){e._modelValue=t,Ct(e,"change",()=>{const r=Array.prototype.filter.call(e.options,c=>c.selected).map(c=>n?fs(os(c)):os(c)),i=e.multiple,o=i?Dt(e._modelValue)?new Set(r):r:r[0],l=e._pendingValue=[i,i?U(o)?r.slice():r:o];try{e[Mt](o)}finally{Tn(()=>{e._pendingValue===l&&(e._pendingValue=void 0)})}}),e[Mt]=is(s)},mounted(e,{value:t}){Ei(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Mt]=is(n)},updated(e,{value:t}){const n=e._pendingValue;e._pendingValue=void 0,(!n||n[0]!==e.multiple||!hu(t,n[1],n[0]))&&Ei(e,t)}};function hu(e,t,n){if(!n||U(e))return mt(e,t);if(Dt(e)){if(e.size!==t.length)return!1;for(const s of t)if(!e.has(s))return!1;return!0}return!1}function Ei(e,t){const n=e.multiple,s=U(t);if(!(n&&!s&&!Dt(t))){for(let r=0,i=e.options.length;rString(u)===String(l)):o.selected=Dl(t,l)>-1}else o.selected=t.has(l);else if(mt(os(o),t)){e.selectedIndex!==r&&(e.selectedIndex=r);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function os(e){return"_value"in e?e._value:e.value}const pu=["ctrl","shift","alt","meta"],gu={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>"button"in e&&e.button!==0,middle:e=>"button"in e&&e.button!==1,right:e=>"button"in e&&e.button!==2,exact:(e,t)=>pu.some(n=>e[`${n}Key`]&&!t.includes(n))},kf=(e,t)=>{if(!e)return e;const n=e._withMods||(e._withMods={}),s=t.join(".");return n[s]||(n[s]=((r,...i)=>{for(let o=0;o{const n=e._withKeys||(e._withKeys={}),s=t.join(".");return n[s]||(n[s]=(r=>{if(!("key"in r))return;const i=bt(r.key);if(t.some(o=>o===i||mu[o]===i))return e(r)}))},nl=ge({patchProp:au},Va);let fn,xi=!1;function yu(){return fn||(fn=ya(nl))}function vu(){return fn=xi?fn:va(nl),xi=!0,fn}const jf=((...e)=>{const t=yu().createApp(...e),{mount:n}=t;return t.mount=s=>{const r=rl(s);if(!r)return;const i=t._component;!q(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent="");const o=n(r,!1,sl(r));return r instanceof Element&&(r.removeAttribute("v-cloak"),r.setAttribute("data-v-app","")),o},t}),Vf=((...e)=>{const t=vu().createApp(...e),{mount:n}=t;return t.mount=s=>{const r=rl(s);if(r)return n(r,!0,sl(r))},t});function sl(e){if(e instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&e instanceof MathMLElement)return"mathml"}function rl(e){return le(e)?document.querySelector(e):e}const _u=window.__VP_SITE_DATA__;function il(e){return Wi()?($l(e),!0):!1}const js=new WeakMap,bu=(...e)=>{var t;const n=e[0],s=(t=Ht())==null?void 0:t.proxy;if(s==null&&!po())throw new Error("injectLocal must be called in setup");return s&&js.has(s)&&n in js.get(s)?js.get(s)[n]:Pt(...e)},ol=typeof window<"u"&&typeof document<"u";typeof WorkerGlobalScope<"u"&&globalThis instanceof WorkerGlobalScope;const Bf=e=>e!=null,wu=Object.prototype.toString,Su=e=>wu.call(e)==="[object Object]",_t=()=>{},Ci=Tu();function Tu(){var e,t;return ol&&((e=window?.navigator)==null?void 0:e.userAgent)&&(/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||((t=window?.navigator)==null?void 0:t.maxTouchPoints)>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function Or(e,t){function n(...s){return new Promise((r,i)=>{Promise.resolve(e(()=>t.apply(this,s),{fn:t,thisArg:this,args:s})).then(r).catch(i)})}return n}const ll=e=>e();function cl(e,t={}){let n,s,r=_t;const i=c=>{clearTimeout(c),r(),r=_t};let o;return c=>{const u=ue(e),a=ue(t.maxWait);return n&&i(n),u<=0||a!==void 0&&a<=0?(s&&(i(s),s=null),Promise.resolve(c())):new Promise((f,g)=>{r=t.rejectOnCancel?g:f,o=c,a&&!s&&(s=setTimeout(()=>{n&&i(n),s=null,f(o())},a)),n=setTimeout(()=>{s&&i(s),s=null,f(c())},u)})}}function Eu(...e){let t=0,n,s=!0,r=_t,i,o,l,c,u;!de(e[0])&&typeof e[0]=="object"?{delay:o,trailing:l=!0,leading:c=!0,rejectOnCancel:u=!1}=e[0]:[o,l=!0,c=!0,u=!1]=e;const a=()=>{n&&(clearTimeout(n),n=void 0,r(),r=_t)};return g=>{const y=ue(o),b=Date.now()-t,_=()=>i=g();return a(),y<=0?(t=Date.now(),_()):(b>y&&(c||!s)?(t=Date.now(),_()):l&&(i=new Promise((H,O)=>{r=u?O:H,n=setTimeout(()=>{t=Date.now(),s=!0,H(_()),a()},Math.max(0,y-b))})),!c&&!n&&(n=setTimeout(()=>s=!0,y)),s=!1,i)}}function xu(e=ll,t={}){const{initialState:n="active"}=t,s=Pr(n==="active");function r(){s.value=!1}function i(){s.value=!0}return{isActive:pn(s),pause:r,resume:i,eventFilter:(...l)=>{s.value&&e(...l)}}}function Ai(e){return e.endsWith("rem")?Number.parseFloat(e)*16:Number.parseFloat(e)}function Cu(e){return Ht()}function Vs(e){return Array.isArray(e)?e:[e]}function Pr(...e){if(e.length!==1)return uc(...e);const t=e[0];return typeof t=="function"?pn(lc(()=>({get:t,set:_t}))):We(t)}function Au(e,t=200,n={}){return Or(cl(t,n),e)}function Mu(e,t=200,n=!1,s=!0,r=!1){return Or(Eu(t,n,s,r),e)}function al(e,t,n={}){const{eventFilter:s=ll,...r}=n;return ke(e,Or(s,t),r)}function Ru(e,t,n={}){const{eventFilter:s,initialState:r="active",...i}=n,{eventFilter:o,pause:l,resume:c,isActive:u}=xu(s,{initialState:r});return{stop:al(e,t,{...i,eventFilter:o}),pause:l,resume:c,isActive:u}}function Es(e,t=!0,n){Cu()?Qt(e,n):t?e():Tn(e)}function Uf(e,t,n={}){const{debounce:s=0,maxWait:r=void 0,...i}=n;return al(e,t,{...i,eventFilter:cl(s,{maxWait:r})})}function Ou(e,t,n){return ke(e,t,{...n,immediate:!0})}function Wf(e,t,n){let s;de(n)?s={evaluating:n}:s={};const{lazy:r=!1,evaluating:i=void 0,shallow:o=!0,onError:l=_t}=s,c=Re(!r),u=o?Re(t):We(t);let a=0;return Sr(async f=>{if(!c.value)return;a++;const g=a;let y=!1;i&&Promise.resolve().then(()=>{i.value=!0});try{const b=await e(_=>{f(()=>{i&&(i.value=!1),y||_()})});g===a&&(u.value=b)}catch(b){l(b)}finally{i&&g===a&&(i.value=!1),y=!0}}),r?oe(()=>(c.value=!0,u.value)):u}const Ke=ol?window:void 0;function Ir(e){var t;const n=ue(e);return(t=n?.$el)!=null?t:n}function ut(...e){const t=[],n=()=>{t.forEach(l=>l()),t.length=0},s=(l,c,u,a)=>(l.addEventListener(c,u,a),()=>l.removeEventListener(c,u,a)),r=oe(()=>{const l=Vs(ue(e[0])).filter(c=>c!=null);return l.every(c=>typeof c!="string")?l:void 0}),i=Ou(()=>{var l,c;return[(c=(l=r.value)==null?void 0:l.map(u=>Ir(u)))!=null?c:[Ke].filter(u=>u!=null),Vs(ue(r.value?e[1]:e[0])),Vs(ms(r.value?e[2]:e[1])),ue(r.value?e[3]:e[2])]},([l,c,u,a])=>{if(n(),!l?.length||!c?.length||!u?.length)return;const f=Su(a)?{...a}:a;t.push(...l.flatMap(g=>c.flatMap(y=>u.map(b=>s(g,y,b,f)))))},{flush:"post"}),o=()=>{i(),n()};return il(n),o}function Pu(){const e=Re(!1),t=Ht();return t&&Qt(()=>{e.value=!0},t),e}function Iu(e){const t=Pu();return oe(()=>(t.value,!!e()))}function Fu(e){return typeof e=="function"?e:typeof e=="string"?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Kf(...e){let t,n,s={};e.length===3?(t=e[0],n=e[1],s=e[2]):e.length===2?typeof e[1]=="object"?(t=!0,n=e[0],s=e[1]):(t=e[0],n=e[1]):(t=!0,n=e[0]);const{target:r=Ke,eventName:i="keydown",passive:o=!1,dedupe:l=!1}=s,c=Fu(t);return ut(r,i,a=>{a.repeat&&ue(l)||c(a)&&n(a)},o)}const Lu=Symbol("vueuse-ssr-width");function Nu(){const e=po()?bu(Lu,null):null;return typeof e=="number"?e:void 0}function ul(e,t={}){const{window:n=Ke,ssrWidth:s=Nu()}=t,r=Iu(()=>n&&"matchMedia"in n&&typeof n.matchMedia=="function"),i=Re(typeof s=="number"),o=Re(),l=Re(!1),c=u=>{l.value=u.matches};return Sr(()=>{if(i.value){i.value=!r.value;const u=ue(e).split(",");l.value=u.some(a=>{const f=a.includes("not all"),g=a.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/),y=a.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);let b=!!(g||y);return g&&b&&(b=s>=Ai(g[1])),y&&b&&(b=s<=Ai(y[1])),f?!b:b});return}r.value&&(o.value=n.matchMedia(ue(e)),l.value=o.value.matches)}),ut(o,"change",c,{passive:!0}),oe(()=>l.value)}const Dn=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{},Hn="__vueuse_ssr_handlers__",Du=Hu();function Hu(){return Hn in Dn||(Dn[Hn]=Dn[Hn]||{}),Dn[Hn]}function fl(e,t){return Du[e]||t}function dl(e){return ul("(prefers-color-scheme: dark)",e)}function ku(e){return e==null?"any":e instanceof Set?"set":e instanceof Map?"map":e instanceof Date?"date":typeof e=="boolean"?"boolean":typeof e=="string"?"string":typeof e=="object"?"object":Number.isNaN(e)?"any":"number"}const $u={boolean:{read:e=>e==="true",write:e=>String(e)},object:{read:e=>JSON.parse(e),write:e=>JSON.stringify(e)},number:{read:e=>Number.parseFloat(e),write:e=>String(e)},any:{read:e=>e,write:e=>String(e)},string:{read:e=>e,write:e=>String(e)},map:{read:e=>new Map(JSON.parse(e)),write:e=>JSON.stringify(Array.from(e.entries()))},set:{read:e=>new Set(JSON.parse(e)),write:e=>JSON.stringify(Array.from(e))},date:{read:e=>new Date(e),write:e=>e.toISOString()}},Mi="vueuse-storage";function Fr(e,t,n,s={}){var r;const{flush:i="pre",deep:o=!0,listenToStorageChanges:l=!0,writeDefaults:c=!0,mergeDefaults:u=!1,shallow:a,window:f=Ke,eventFilter:g,onError:y=x=>{console.error(x)},initOnMounted:b}=s,_=(a?Re:We)(typeof t=="function"?t():t),H=oe(()=>ue(e));if(!n)try{n=fl("getDefaultStorage",()=>{var x;return(x=Ke)==null?void 0:x.localStorage})()}catch(x){y(x)}if(!n)return _;const O=ue(t),P=ku(O),p=(r=s.serializer)!=null?r:$u[P],{pause:m,resume:v}=Ru(_,()=>E(_.value),{flush:i,deep:o,eventFilter:g});ke(H,()=>T(),{flush:i}),f&&l&&Es(()=>{n instanceof Storage?ut(f,"storage",T,{passive:!0}):ut(f,Mi,L),b&&T()}),b||T();function F(x,S){if(f){const I={key:H.value,oldValue:x,newValue:S,storageArea:n};f.dispatchEvent(n instanceof Storage?new StorageEvent("storage",I):new CustomEvent(Mi,{detail:I}))}}function E(x){try{const S=n.getItem(H.value);if(x==null)F(S,null),n.removeItem(H.value);else{const I=p.write(x);S!==I&&(n.setItem(H.value,I),F(S,I))}}catch(S){y(S)}}function $(x){const S=x?x.newValue:n.getItem(H.value);if(S==null)return c&&O!=null&&n.setItem(H.value,p.write(O)),O;if(!x&&u){const I=p.read(S);return typeof u=="function"?u(I,O):P==="object"&&!Array.isArray(I)?{...O,...I}:I}else return typeof S!="string"?S:p.read(S)}function T(x){if(!(x&&x.storageArea!==n)){if(x&&x.key==null){_.value=O;return}if(!(x&&x.key!==H.value)){m();try{x?.newValue!==p.write(_.value)&&(_.value=$(x))}catch(S){y(S)}finally{x?Tn(v):v()}}}}function L(x){T(x.detail)}return _}const ju="*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";function Vu(e={}){const{selector:t="html",attribute:n="class",initialValue:s="auto",window:r=Ke,storage:i,storageKey:o="vueuse-color-scheme",listenToStorageChanges:l=!0,storageRef:c,emitAuto:u,disableTransition:a=!0}=e,f={auto:"",light:"light",dark:"dark",...e.modes||{}},g=dl({window:r}),y=oe(()=>g.value?"dark":"light"),b=c||(o==null?Pr(s):Fr(o,s,i,{window:r,listenToStorageChanges:l})),_=oe(()=>b.value==="auto"?y.value:b.value),H=fl("updateHTMLAttrs",(m,v,F)=>{const E=typeof m=="string"?r?.document.querySelector(m):Ir(m);if(!E)return;const $=new Set,T=new Set;let L=null;if(v==="class"){const S=F.split(/\s/g);Object.values(f).flatMap(I=>(I||"").split(/\s/g)).filter(Boolean).forEach(I=>{S.includes(I)?$.add(I):T.add(I)})}else L={key:v,value:F};if($.size===0&&T.size===0&&L===null)return;let x;a&&(x=r.document.createElement("style"),x.appendChild(document.createTextNode(ju)),r.document.head.appendChild(x));for(const S of $)E.classList.add(S);for(const S of T)E.classList.remove(S);L&&E.setAttribute(L.key,L.value),a&&(r.getComputedStyle(x).opacity,document.head.removeChild(x))});function O(m){var v;H(t,n,(v=f[m])!=null?v:m)}function P(m){e.onChanged?e.onChanged(m,O):O(m)}ke(_,P,{flush:"post",immediate:!0}),Es(()=>P(_.value));const p=oe({get(){return u?b.value:_.value},set(m){b.value=m}});return Object.assign(p,{store:b,system:y,state:_})}function Bu(e={}){const{valueDark:t="dark",valueLight:n=""}=e,s=Vu({...e,onChanged:(o,l)=>{var c;e.onChanged?(c=e.onChanged)==null||c.call(e,o==="dark",l,o):l(o)},modes:{dark:t,light:n}}),r=oe(()=>s.system.value);return oe({get(){return s.value==="dark"},set(o){const l=o?"dark":"light";r.value===l?s.value="auto":s.value=l}})}function Bs(e){return typeof Window<"u"&&e instanceof Window?e.document.documentElement:typeof Document<"u"&&e instanceof Document?e.documentElement:e}const Ri=1;function Uu(e,t={}){const{throttle:n=0,idle:s=200,onStop:r=_t,onScroll:i=_t,offset:o={left:0,right:0,top:0,bottom:0},eventListenerOptions:l={capture:!1,passive:!0},behavior:c="auto",window:u=Ke,onError:a=E=>{console.error(E)}}=t,f=Re(0),g=Re(0),y=oe({get(){return f.value},set(E){_(E,void 0)}}),b=oe({get(){return g.value},set(E){_(void 0,E)}});function _(E,$){var T,L,x,S;if(!u)return;const I=ue(e);if(!I)return;(x=I instanceof Document?u.document.body:I)==null||x.scrollTo({top:(T=ue($))!=null?T:b.value,left:(L=ue(E))!=null?L:y.value,behavior:ue(c)});const W=((S=I?.document)==null?void 0:S.documentElement)||I?.documentElement||I;y!=null&&(f.value=W.scrollLeft),b!=null&&(g.value=W.scrollTop)}const H=Re(!1),O=qt({left:!0,right:!1,top:!0,bottom:!1}),P=qt({left:!1,right:!1,top:!1,bottom:!1}),p=E=>{H.value&&(H.value=!1,P.left=!1,P.right=!1,P.top=!1,P.bottom=!1,r(E))},m=Au(p,n+s),v=E=>{var $;if(!u)return;const T=(($=E?.document)==null?void 0:$.documentElement)||E?.documentElement||Ir(E),{display:L,flexDirection:x,direction:S}=getComputedStyle(T),I=S==="rtl"?-1:1,W=T.scrollLeft;P.left=Wf.value;const J=Math.abs(W*I)<=(o.left||0),V=Math.abs(W*I)+T.clientWidth>=T.scrollWidth-(o.right||0)-Ri;L==="flex"&&x==="row-reverse"?(O.left=V,O.right=J):(O.left=J,O.right=V),f.value=W;let X=T.scrollTop;E===u.document&&!X&&(X=u.document.body.scrollTop),P.top=Xg.value;const G=Math.abs(X)<=(o.top||0),ce=Math.abs(X)+T.clientHeight>=T.scrollHeight-(o.bottom||0)-Ri;L==="flex"&&x==="column-reverse"?(O.top=ce,O.bottom=G):(O.top=G,O.bottom=ce),g.value=X},F=E=>{var $;if(!u)return;const T=($=E.target.documentElement)!=null?$:E.target;v(T),H.value=!0,m(E),i(E)};return ut(e,"scroll",n?Mu(F,n,!0,!1):F,l),Es(()=>{try{const E=ue(e);if(!E)return;v(E)}catch(E){a(E)}}),ut(e,"scrollend",p,l),{x:y,y:b,isScrolling:H,arrivedState:O,directions:P,measure(){const E=ue(e);u&&E&&v(E)}}}function qf(e,t,n={}){const{window:s=Ke}=n;return Fr(e,t,s?.localStorage,n)}function hl(e){const t=window.getComputedStyle(e);if(t.overflowX==="scroll"||t.overflowY==="scroll"||t.overflowX==="auto"&&e.clientWidth1?!0:(t.preventDefault&&t.preventDefault(),!1)}const Us=new WeakMap;function Gf(e,t=!1){const n=Re(t);let s=null,r="";ke(Pr(e),l=>{const c=Bs(ue(l));if(c){const u=c;if(Us.get(u)||Us.set(u,u.style.overflow),u.style.overflow!=="hidden"&&(r=u.style.overflow),u.style.overflow==="hidden")return n.value=!0;if(n.value)return u.style.overflow="hidden"}},{immediate:!0});const i=()=>{const l=Bs(ue(e));!l||n.value||(Ci&&(s=ut(l,"touchmove",c=>{Wu(c)},{passive:!1})),l.style.overflow="hidden",n.value=!0)},o=()=>{const l=Bs(ue(e));!l||!n.value||(Ci&&s?.(),l.style.overflow=r,Us.delete(l),n.value=!1)};return il(o),oe({get(){return n.value},set(l){l?i():o()}})}function Xf(e,t,n={}){const{window:s=Ke}=n;return Fr(e,t,s?.sessionStorage,n)}function Yf(e={}){const{window:t=Ke,...n}=e;return Uu(t,n)}function Jf(e={}){const{window:t=Ke,initialWidth:n=Number.POSITIVE_INFINITY,initialHeight:s=Number.POSITIVE_INFINITY,listenOrientation:r=!0,includeScrollbar:i=!0,type:o="inner"}=e,l=Re(n),c=Re(s),u=()=>{if(t)if(o==="outer")l.value=t.outerWidth,c.value=t.outerHeight;else if(o==="visual"&&t.visualViewport){const{width:f,height:g,scale:y}=t.visualViewport;l.value=Math.round(f*y),c.value=Math.round(g*y)}else i?(l.value=t.innerWidth,c.value=t.innerHeight):(l.value=t.document.documentElement.clientWidth,c.value=t.document.documentElement.clientHeight)};u(),Es(u);const a={passive:!0};if(ut("resize",u,a),t&&o==="visual"&&t.visualViewport&&ut(t.visualViewport,"resize",u,a),r){const f=ul("(orientation: portrait)");ke(f,()=>u())}return{width:l,height:c}}const Ku={};var qu={};const pl=/^(?:[a-z]+:|\/\/)/i,Gu="vitepress-theme-appearance",Xu=/#.*$/,Yu=/[?#].*$/,Ju=/(?:(^|\/)index)?\.(?:md|html)$/,Se=typeof document<"u",gl={relativePath:"404.md",filePath:"",title:"404",description:"Not Found",headers:[],frontmatter:{sidebar:!1,layout:"page"},lastUpdated:0,isNotFound:!0};function zu(e,t,n=!1){if(t===void 0)return!1;if(e=Oi(`/${e}`),n)return new RegExp(t).test(e);if(Oi(t)!==e)return!1;const s=t.match(Xu);return s?(Se?location.hash:"")===s[0]:!0}function Oi(e){return decodeURI(e).replace(Yu,"").replace(Ju,"$1")}function Qu(e){return pl.test(e)}function Zu(e,t){return Object.keys(e?.locales||{}).find(n=>n!=="root"&&!Qu(n)&&zu(t,`/${n}/`,!0))||"root"}function ef(e,t){const n=Zu(e,t);return Object.assign({},e,{localeIndex:n,lang:e.locales[n]?.lang??e.lang,dir:e.locales[n]?.dir??e.dir,title:e.locales[n]?.title??e.title,titleTemplate:e.locales[n]?.titleTemplate??e.titleTemplate,description:e.locales[n]?.description??e.description,head:yl(e.head,e.locales[n]?.head??[]),themeConfig:{...e.themeConfig,...e.locales[n]?.themeConfig}})}function ml(e,t){const n=t.title||e.title,s=t.titleTemplate??e.titleTemplate;if(typeof s=="string"&&s.includes(":title"))return s.replace(/:title/g,n);const r=tf(e.title,s);return n===r.slice(3)?n:`${n}${r}`}function tf(e,t){return t===!1?"":t===!0||t===void 0?` | ${e}`:e===t?"":` | ${t}`}function nf(e,t){const[n,s]=t;if(n!=="meta")return!1;const r=Object.entries(s)[0];return r==null?!1:e.some(([i,o])=>i===n&&o[r[0]]===r[1])}function yl(e,t){return[...e.filter(n=>!nf(t,n)),...t]}const sf=/[\u0000-\u001F"#$&*+,:;<=>?[\]^`{|}\u007F]/g,rf=/^[a-z]:/i;function Pi(e){const t=rf.exec(e),n=t?t[0]:"";return n+e.slice(n.length).replace(sf,"_").replace(/(^|\/)_+(?=[^/]*$)/,"$1")}const Ws=new Set;function of(e){if(Ws.size===0){const n=typeof process=="object"&&qu?.VITE_EXTRA_EXTENSIONS||Ku?.VITE_EXTRA_EXTENSIONS||"";("3g2,3gp,aac,ai,apng,au,avif,bin,bmp,cer,class,conf,crl,css,csv,dll,doc,eps,epub,exe,gif,gz,ics,ief,jar,jpe,jpeg,jpg,js,json,jsonld,m4a,man,mid,midi,mjs,mov,mp2,mp3,mp4,mpe,mpeg,mpg,mpp,oga,ogg,ogv,ogx,opus,otf,p10,p7c,p7m,p7s,pdf,png,ps,qt,roff,rtf,rtx,ser,svg,t,tif,tiff,tr,ts,tsv,ttf,txt,vtt,wav,weba,webm,webp,woff,woff2,xhtml,xml,yaml,yml,zip"+(n&&typeof n=="string"?","+n:"")).split(",").forEach(s=>Ws.add(s))}const t=e.split(".").pop();return t==null||!Ws.has(t.toLowerCase())}function zf(e){return e.replace(/[|\\{}()[\]^$+*?.]/g,"\\$&").replace(/-/g,"\\x2d")}const lf=Symbol(),Nt=Re(_u);function Qf(e){const t=oe(()=>ef(Nt.value,e.data.relativePath)),n=t.value.appearance,s=n==="force-dark"?We(!0):n==="force-auto"?dl():n?Bu({storageKey:Gu,initialValue:()=>n==="dark"?"dark":"auto",...typeof n=="object"?n:{}}):We(!1),r=We(Se?location.hash:"");return Se&&window.addEventListener("hashchange",()=>{r.value=location.hash}),ke(()=>e.data,()=>{r.value=Se?location.hash:""}),{site:t,theme:oe(()=>t.value.themeConfig),page:oe(()=>e.data),frontmatter:oe(()=>e.data.frontmatter),params:oe(()=>e.data.params),lang:oe(()=>t.value.lang),dir:oe(()=>e.data.frontmatter.dir||t.value.dir),localeIndex:oe(()=>t.value.localeIndex||"root"),title:oe(()=>ml(t.value,e.data)),description:oe(()=>e.data.description||t.value.description),isDark:s,hash:oe(()=>r.value)}}function cf(){const e=Pt(lf);if(!e)throw new Error("vitepress data not properly injected in app");return e}function af(e,t){return`${e}${t}`.replace(/\/+/g,"/")}function Ii(e){return pl.test(e)||!e.startsWith("/")?e:af(Nt.value.base,e)}function uf(e){let t=e.replace(/\.html$/,"");if(t=decodeURIComponent(t),t=t.replace(/\/$/,"/index"),Se){const n="/magma/v4/";t=Pi(t.slice(n.length).replace(/\//g,"_")||"index")+".md";let s=__VP_HASH_MAP__[t.toLowerCase()];if(s||(t=t.endsWith("_index.md")?t.slice(0,-9)+".md":t.slice(0,-3)+"_index.md",s=__VP_HASH_MAP__[t.toLowerCase()]),!s)return null;t=`${n}assets/${t}.${s}.js`}else t=`./${Pi(t.slice(1).replace(/\//g,"_"))}.md.js`;return t}let Kn=[];function Zf(e){Kn.push(e),xn(()=>{Kn=Kn.filter(t=>t!==e)})}function ff(){let e=Nt.value.scrollOffset,t=0,n=24;if(typeof e=="object"&&"padding"in e&&(n=e.padding,e=e.selector),typeof e=="number")t=e;else if(typeof e=="string")t=Fi(e,n);else if(Array.isArray(e))for(const s of e){const r=Fi(s,n);if(r){t=r;break}}return t}function Fi(e,t){const n=document.querySelector(e);if(!n)return 0;const s=n.getBoundingClientRect().bottom;return s<0?0:s+t}const df=Symbol(),vl="http://a.com",hf=()=>({path:"/",component:null,data:gl});function ed(e,t){const n=qt(hf()),s={route:n,go:r};async function r(l=Se?location.href:"/"){l=Ks(l),await s.onBeforeRouteChange?.(l)!==!1&&(Se&&l!==Ks(location.href)&&(history.replaceState({scrollPosition:window.scrollY},""),history.pushState({},"",l)),await o(l),await(s.onAfterRouteChange??s.onAfterRouteChanged)?.(l))}let i=null;async function o(l,c=0,u=!1){if(await s.onBeforePageLoad?.(l)===!1)return;const a=new URL(l,vl),f=i=a.pathname;try{let g=await e(f);if(!g)throw new Error(`Page not found: ${f}`);if(i===f){i=null;const{default:y,__pageData:b}=g;if(!y)throw new Error(`Invalid route component: ${y}`);await s.onAfterPageLoad?.(l),n.path=Se?f:Ii(f),n.component=Bn(y),n.data=Bn(b),Se&&Tn(()=>{let _=Nt.value.base+b.relativePath.replace(/(?:(^|\/)index)?\.md$/,"$1");if(!Nt.value.cleanUrls&&!_.endsWith("/")&&(_+=".html"),_!==a.pathname&&(a.pathname=_,l=_+a.search+a.hash,history.replaceState({},"",l)),a.hash&&!c){let H=null;try{H=document.getElementById(decodeURIComponent(a.hash).slice(1))}catch(O){console.warn(O)}if(H){Li(H,a.hash);return}}window.scrollTo(0,c)})}}catch(g){if(!/fetch|Page not found/.test(g.message)&&!/^\/404(\.html|\/)?$/.test(l)&&console.error(g),!u)try{const y=await fetch(Nt.value.base+"hashmap.json");window.__VP_HASH_MAP__=await y.json(),await o(l,c,!0);return}catch{}if(i===f){i=null,n.path=Se?f:Ii(f),n.component=t?Bn(t):null;const y=Se?f.replace(/(^|\/)$/,"$1index").replace(/(\.html)?$/,".md").replace(/^\//,""):"404.md";n.data={...gl,relativePath:y}}}}return Se&&(history.state===null&&history.replaceState({},""),window.addEventListener("click",l=>{if(l.defaultPrevented||!(l.target instanceof Element)||l.target.closest("button")||l.button!==0||l.ctrlKey||l.shiftKey||l.altKey||l.metaKey)return;const c=l.target.closest("a");if(!c||c.closest(".vp-raw")||c.hasAttribute("download")||c.hasAttribute("target"))return;const u=c.getAttribute("href")??(c instanceof SVGAElement?c.getAttribute("xlink:href"):null);if(u==null)return;const{href:a,origin:f,pathname:g,hash:y,search:b}=new URL(u,c.baseURI),_=new URL(location.href);f===_.origin&&of(g)&&(l.preventDefault(),g===_.pathname&&b===_.search?(y!==_.hash&&(history.pushState({},"",a),window.dispatchEvent(new HashChangeEvent("hashchange",{oldURL:_.href,newURL:a}))),y?Li(c,y,c.classList.contains("header-anchor")):window.scrollTo(0,0)):r(a))},{capture:!0}),window.addEventListener("popstate",async l=>{if(l.state===null)return;const c=Ks(location.href);await o(c,l.state&&l.state.scrollPosition||0),await(s.onAfterRouteChange??s.onAfterRouteChanged)?.(c)}),window.addEventListener("hashchange",l=>{l.preventDefault()})),s}function pf(){const e=Pt(df);if(!e)throw new Error("useRouter() is called without provider.");return e}function _l(){return pf().route}function Li(e,t,n=!1){let s=null;try{s=e.classList.contains("header-anchor")?e:document.getElementById(decodeURIComponent(t).slice(1))}catch(r){console.warn(r)}if(s){let r=function(){!n||Math.abs(o-window.scrollY)>window.innerHeight?window.scrollTo(0,o):window.scrollTo({left:0,top:o,behavior:"smooth"})};const i=parseInt(window.getComputedStyle(s).paddingTop,10),o=window.scrollY+s.getBoundingClientRect().top-ff()+i;requestAnimationFrame(r)}}function Ks(e){const t=new URL(e,vl);return t.pathname=t.pathname.replace(/(^|\/)index(\.html)?$/,"$1"),Nt.value.cleanUrls?t.pathname=t.pathname.replace(/\.html$/,""):!t.pathname.endsWith("/")&&!t.pathname.endsWith(".html")&&(t.pathname+=".html"),t.pathname+t.search+t.hash}const kn=()=>Kn.forEach(e=>e()),td=Tr({name:"VitePressContent",props:{as:{type:[Object,String],default:"div"}},setup(e){const t=_l(),{frontmatter:n,site:s}=cf();return ke(n,kn,{deep:!0,flush:"post"}),()=>ur(e.as,s.value.contentProps??{style:{position:"relative"}},[t.component?ur(t.component,{onVnodeMounted:kn,onVnodeUpdated:kn,onVnodeUnmounted:kn}):"404 Page Not Found"])}}),nd=(e,t)=>{const n=e.__vccOpts||e;for(const[s,r]of t)n[s]=r;return n},sd=Tr({setup(e,{slots:t}){const n=We(!1);return Qt(()=>{n.value=!0}),()=>n.value&&t.default?t.default():null}});function rd(){Se&&window.addEventListener("click",e=>{const t=e.target;if(t.matches(".vp-code-group input")){const n=t.parentElement?.parentElement;if(!n)return;const s=Array.from(n.querySelectorAll("input")).indexOf(t);if(s<0)return;const r=n.querySelector(".blocks");if(!r)return;const i=Array.from(r.children).find(c=>c.classList.contains("active"));if(!i)return;const o=r.children[s];if(!o||i===o)return;i.classList.remove("active"),o.classList.add("active"),n?.querySelector(`label[for="${t.id}"]`)?.scrollIntoView({block:"nearest"})}})}function id(){if(Se){const e=new WeakMap;window.addEventListener("click",t=>{const n=t.target;if(n.matches('div[class*="language-"] > button.copy')){const s=n.parentElement,r=n.nextElementSibling?.nextElementSibling;if(!s||!r)return;const i=/language-(shellscript|shell|bash|sh|zsh)/.test(s.className),o=[".vp-copy-ignore",".diff.remove"],l=r.cloneNode(!0);l.querySelectorAll(o.join(",")).forEach(u=>u.remove());let c=l.textContent||"";i&&(c=c.replace(/^ *(\$|>) /gm,"").trim()),gf(c).then(()=>{n.classList.add("copied"),clearTimeout(e.get(n));const u=setTimeout(()=>{n.classList.remove("copied"),n.blur(),e.delete(n)},2e3);e.set(n,u)})}})}}async function gf(e){try{return navigator.clipboard.writeText(e)}catch{const t=document.createElement("textarea"),n=document.activeElement;t.value=e,t.setAttribute("readonly",""),t.style.contain="strict",t.style.position="absolute",t.style.left="-9999px",t.style.fontSize="12pt";const s=document.getSelection(),r=s?s.rangeCount>0&&s.getRangeAt(0):null;document.body.appendChild(t),t.select(),t.selectionStart=0,t.selectionEnd=e.length,document.execCommand("copy"),document.body.removeChild(t),r&&(s.removeAllRanges(),s.addRange(r)),n&&n.focus()}}function od(e,t){let n=!0,s=[];const r=i=>{if(n){n=!1,i.forEach(l=>{const c=qs(l);for(const u of document.head.children)if(u.isEqualNode(c)){s.push(u);return}});return}const o=i.map(qs);s.forEach((l,c)=>{const u=o.findIndex(a=>a?.isEqualNode(l??null));u!==-1?delete o[u]:(l?.remove(),delete s[c])}),o.forEach(l=>l&&document.head.appendChild(l)),s=[...s,...o].filter(Boolean)};Sr(()=>{const i=e.data,o=t.value,l=i&&i.description,c=i&&i.frontmatter.head||[],u=ml(o,i);u!==document.title&&(document.title=u);const a=l||o.description;let f=document.querySelector("meta[name=description]");f?f.getAttribute("content")!==a&&f.setAttribute("content",a):qs(["meta",{name:"description",content:a}]),r(yl(o.head,yf(c)))})}function qs([e,t,n]){const s=document.createElement(e);for(const r in t)s.setAttribute(r,t[r]);return n&&(s.innerHTML=n),e==="script"&&t.async==null&&(s.async=!1),s}function mf(e){return e[0]==="meta"&&e[1]&&e[1].name==="description"}function yf(e){return e.filter(t=>!mf(t))}const Gs=new Set,bl=()=>document.createElement("link"),vf=e=>{const t=bl();t.rel="prefetch",t.href=e,document.head.appendChild(t)},_f=e=>{const t=new XMLHttpRequest;t.open("GET",e,t.withCredentials=!0),t.send()};let $n;const bf=Se&&($n=bl())&&$n.relList&&$n.relList.supports&&$n.relList.supports("prefetch")?vf:_f;function ld(){if(!Se||!window.IntersectionObserver)return;let e;if((e=navigator.connection)&&(e.saveData||/2g/.test(e.effectiveType)))return;const t=window.requestIdleCallback||setTimeout;let n=null;const s=()=>{n&&n.disconnect(),n=new IntersectionObserver(i=>{i.forEach(o=>{if(o.isIntersecting){const l=o.target;n.unobserve(l);const{pathname:c}=l;if(!Gs.has(c)){Gs.add(c);const u=uf(c);u&&bf(u)}}})}),t(()=>{document.querySelectorAll("#app a").forEach(i=>{const{hostname:o,pathname:l}=new URL(i.href instanceof SVGAnimatedString?i.href.animVal:i.href,i.baseURI),c=l.match(/\.\w+$/);c&&c[0]!==".html"||i.target!=="_blank"&&o===location.hostname&&(l!==location.pathname?n.observe(i):Gs.add(l))})})};Qt(s);const r=_l();ke(()=>r.path,s),xn(()=>{n&&n.disconnect()})}export{So as $,ff as A,Mf as B,Cf as C,Zf as D,fe as E,Ee as F,Re as G,Af as H,pl as I,_l as J,Ra as K,Pt as L,Jf as M,pr as N,Kf as O,Tn as P,Yf as Q,Se as R,pn as S,Nf as T,xf as U,wf as V,Gf as W,bc as X,Of as Y,$f as Z,nd as _,Yo as a,kf as a0,Pf as a1,Lf as a2,Sf as a3,Df as a4,If as a5,Hf as a6,il as a7,ue as a8,Vs as a9,rd as aA,ur as aB,Ir as aa,Bf as ab,Wf as ac,Xf as ad,qf as ae,Uf as af,pf as ag,ut as ah,de as ai,Ef as aj,Bn as ak,jf as al,lf as am,uf as an,zf as ao,Q as ap,od as aq,df as ar,Qf as as,td as at,sd as au,Nt as av,ed as aw,Vf as ax,ld as ay,id as az,lr as b,Ff as c,Tr as d,Ma as e,of as f,Ii as g,oe as h,Qu as i,Xo as j,ms as k,zu as l,ul as m,gr as n,ts as o,We as p,ke as q,Rf as r,Sr as s,Hl as t,cf as u,Qt as v,_c as w,xn as x,Tf as y,Kc as z}; diff --git a/packages/tempo/public/v4/assets/chunks/ganttDiagram-EL5Y4UJY.xjuXBlhL.js b/packages/tempo/public/v4/assets/chunks/ganttDiagram-EL5Y4UJY.xjuXBlhL.js new file mode 100644 index 00000000..afd1e117 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/ganttDiagram-EL5Y4UJY.xjuXBlhL.js @@ -0,0 +1,292 @@ +import{bh as cn,bi as Pn,bj as un,bk as ln,bl as fn,bm as ue,bn as Vn,b5 as zn,b6 as Rn,g as Bn,s as Zn,q as Xn,p as qn,a as Gn,b as jn,_ as d,c as Ut,j as Jt,d as Qn,bo as it,l as bt,k as Jn,o as Kn,r as tr,z as er}from"../app.CbekdYod.js";import{b as nr,t as Ve,c as rr,a as ir,l as ar}from"./linear.D7HjFZ5V.js";import{i as sr}from"./init.Gi6I4Gst.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./defaultLocale.DX6XiGOO.js";function or(t,e){let n;if(e===void 0)for(const r of t)r!=null&&(n=r)&&(n=r);else{let r=-1;for(let i of t)(i=e(i,++r,t))!=null&&(n=i)&&(n=i)}return n}function cr(t,e){let n;if(e===void 0)for(const r of t)r!=null&&(n>r||n===void 0&&r>=r)&&(n=r);else{let r=-1;for(let i of t)(i=e(i,++r,t))!=null&&(n>i||n===void 0&&i>=i)&&(n=i)}return n}function ur(t){return t}var te=1,le=2,we=3,Kt=4,ze=1e-6;function lr(t){return"translate("+t+",0)"}function fr(t){return"translate(0,"+t+")"}function dr(t){return e=>+t(e)}function hr(t,e){return e=Math.max(0,t.bandwidth()-e*2)/2,t.round()&&(e=Math.round(e)),n=>+t(n)+e}function mr(){return!this.__axis}function dn(t,e){var n=[],r=null,i=null,a=6,s=6,h=3,T=typeof window<"u"&&window.devicePixelRatio>1?0:.5,M=t===te||t===Kt?-1:1,w=t===Kt||t===le?"x":"y",E=t===te||t===we?lr:fr;function C(D){var V=r??(e.ticks?e.ticks.apply(e,n):e.domain()),N=i??(e.tickFormat?e.tickFormat.apply(e,n):ur),F=Math.max(a,0)+h,B=e.range(),J=+B[0]+T,z=+B[B.length-1]+T,Z=(e.bandwidth?hr:dr)(e.copy(),T),G=D.selection?D.selection():D,y=G.selectAll(".domain").data([null]),k=G.selectAll(".tick").data(V,e).order(),v=k.exit(),H=k.enter().append("g").attr("class","tick"),x=k.select("line"),Y=k.select("text");y=y.merge(y.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),k=k.merge(H),x=x.merge(H.append("line").attr("stroke","currentColor").attr(w+"2",M*a)),Y=Y.merge(H.append("text").attr("fill","currentColor").attr(w,M*F).attr("dy",t===te?"0em":t===we?"0.71em":"0.32em")),D!==G&&(y=y.transition(D),k=k.transition(D),x=x.transition(D),Y=Y.transition(D),v=v.transition(D).attr("opacity",ze).attr("transform",function(S){return isFinite(S=Z(S))?E(S+T):this.getAttribute("transform")}),H.attr("opacity",ze).attr("transform",function(S){var _=this.parentNode.__axis;return E((_&&isFinite(_=_(S))?_:Z(S))+T)})),v.remove(),y.attr("d",t===Kt||t===le?s?"M"+M*s+","+J+"H"+T+"V"+z+"H"+M*s:"M"+T+","+J+"V"+z:s?"M"+J+","+M*s+"V"+T+"H"+z+"V"+M*s:"M"+J+","+T+"H"+z),k.attr("opacity",1).attr("transform",function(S){return E(Z(S)+T)}),x.attr(w+"2",M*a),Y.attr(w,M*F).text(N),G.filter(mr).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===le?"start":t===Kt?"end":"middle"),G.each(function(){this.__axis=Z})}return C.scale=function(D){return arguments.length?(e=D,C):e},C.ticks=function(){return n=Array.from(arguments),C},C.tickArguments=function(D){return arguments.length?(n=D==null?[]:Array.from(D),C):n.slice()},C.tickValues=function(D){return arguments.length?(r=D==null?null:Array.from(D),C):r&&r.slice()},C.tickFormat=function(D){return arguments.length?(i=D,C):i},C.tickSize=function(D){return arguments.length?(a=s=+D,C):a},C.tickSizeInner=function(D){return arguments.length?(a=+D,C):a},C.tickSizeOuter=function(D){return arguments.length?(s=+D,C):s},C.tickPadding=function(D){return arguments.length?(h=+D,C):h},C.offset=function(D){return arguments.length?(T=+D,C):T},C}function gr(t){return dn(te,t)}function yr(t){return dn(we,t)}const kr=Math.PI/180,vr=180/Math.PI,re=18,hn=.96422,mn=1,gn=.82521,yn=4/29,It=6/29,kn=3*It*It,pr=It*It*It;function vn(t){if(t instanceof ft)return new ft(t.l,t.a,t.b,t.opacity);if(t instanceof gt)return pn(t);t instanceof cn||(t=Pn(t));var e=me(t.r),n=me(t.g),r=me(t.b),i=fe((.2225045*e+.7168786*n+.0606169*r)/mn),a,s;return e===n&&n===r?a=s=i:(a=fe((.4360747*e+.3850649*n+.1430804*r)/hn),s=fe((.0139322*e+.0971045*n+.7141733*r)/gn)),new ft(116*i-16,500*(a-i),200*(i-s),t.opacity)}function Tr(t,e,n,r){return arguments.length===1?vn(t):new ft(t,e,n,r??1)}function ft(t,e,n,r){this.l=+t,this.a=+e,this.b=+n,this.opacity=+r}un(ft,Tr,ln(fn,{brighter(t){return new ft(this.l+re*(t??1),this.a,this.b,this.opacity)},darker(t){return new ft(this.l-re*(t??1),this.a,this.b,this.opacity)},rgb(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,n=isNaN(this.b)?t:t-this.b/200;return e=hn*de(e),t=mn*de(t),n=gn*de(n),new cn(he(3.1338561*e-1.6168667*t-.4906146*n),he(-.9787684*e+1.9161415*t+.033454*n),he(.0719453*e-.2289914*t+1.4052427*n),this.opacity)}}));function fe(t){return t>pr?Math.pow(t,1/3):t/kn+yn}function de(t){return t>It?t*t*t:kn*(t-yn)}function he(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function me(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function xr(t){if(t instanceof gt)return new gt(t.h,t.c,t.l,t.opacity);if(t instanceof ft||(t=vn(t)),t.a===0&&t.b===0)return new gt(NaN,0(t(a=new Date(+a)),a),i.ceil=a=>(t(a=new Date(a-1)),e(a,1),t(a),a),i.round=a=>{const s=i(a),h=i.ceil(a);return a-s(e(a=new Date(+a),s==null?1:Math.floor(s)),a),i.range=(a,s,h)=>{const T=[];if(a=i.ceil(a),h=h==null?1:Math.floor(h),!(a0))return T;let M;do T.push(M=new Date(+a)),e(a,h),t(a);while(Met(s=>{if(s>=s)for(;t(s),!a(s);)s.setTime(s-1)},(s,h)=>{if(s>=s)if(h<0)for(;++h<=0;)for(;e(s,-1),!a(s););else for(;--h>=0;)for(;e(s,1),!a(s););}),n&&(i.count=(a,s)=>(ge.setTime(+a),ye.setTime(+s),t(ge),t(ye),Math.floor(n(ge,ye))),i.every=a=>(a=Math.floor(a),!isFinite(a)||!(a>0)?null:a>1?i.filter(r?s=>r(s)%a===0:s=>i.count(0,s)%a===0):i)),i}const Et=et(()=>{},(t,e)=>{t.setTime(+t+e)},(t,e)=>e-t);Et.every=t=>(t=Math.floor(t),!isFinite(t)||!(t>0)?null:t>1?et(e=>{e.setTime(Math.floor(e/t)*t)},(e,n)=>{e.setTime(+e+n*t)},(e,n)=>(n-e)/t):Et);Et.range;const yt=1e3,ot=yt*60,kt=ot*60,vt=kt*24,Ye=vt*7,Re=vt*30,ke=vt*365,Tt=et(t=>{t.setTime(t-t.getMilliseconds())},(t,e)=>{t.setTime(+t+e*yt)},(t,e)=>(e-t)/yt,t=>t.getUTCSeconds());Tt.range;const Rt=et(t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*yt)},(t,e)=>{t.setTime(+t+e*ot)},(t,e)=>(e-t)/ot,t=>t.getMinutes());Rt.range;const Mr=et(t=>{t.setUTCSeconds(0,0)},(t,e)=>{t.setTime(+t+e*ot)},(t,e)=>(e-t)/ot,t=>t.getUTCMinutes());Mr.range;const Bt=et(t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*yt-t.getMinutes()*ot)},(t,e)=>{t.setTime(+t+e*kt)},(t,e)=>(e-t)/kt,t=>t.getHours());Bt.range;const Cr=et(t=>{t.setUTCMinutes(0,0,0)},(t,e)=>{t.setTime(+t+e*kt)},(t,e)=>(e-t)/kt,t=>t.getUTCHours());Cr.range;const wt=et(t=>t.setHours(0,0,0,0),(t,e)=>t.setDate(t.getDate()+e),(t,e)=>(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*ot)/vt,t=>t.getDate()-1);wt.range;const Fe=et(t=>{t.setUTCHours(0,0,0,0)},(t,e)=>{t.setUTCDate(t.getUTCDate()+e)},(t,e)=>(e-t)/vt,t=>t.getUTCDate()-1);Fe.range;const Sr=et(t=>{t.setUTCHours(0,0,0,0)},(t,e)=>{t.setUTCDate(t.getUTCDate()+e)},(t,e)=>(e-t)/vt,t=>Math.floor(t/vt));Sr.range;function Ct(t){return et(e=>{e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)},(e,n)=>{e.setDate(e.getDate()+n*7)},(e,n)=>(n-e-(n.getTimezoneOffset()-e.getTimezoneOffset())*ot)/Ye)}const qt=Ct(0),Zt=Ct(1),Tn=Ct(2),xn=Ct(3),Dt=Ct(4),bn=Ct(5),wn=Ct(6);qt.range;Zt.range;Tn.range;xn.range;Dt.range;bn.range;wn.range;function St(t){return et(e=>{e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)},(e,n)=>{e.setUTCDate(e.getUTCDate()+n*7)},(e,n)=>(n-e)/Ye)}const Dn=St(0),ie=St(1),_r=St(2),Yr=St(3),At=St(4),Fr=St(5),Ur=St(6);Dn.range;ie.range;_r.range;Yr.range;At.range;Fr.range;Ur.range;const Xt=et(t=>{t.setDate(1),t.setHours(0,0,0,0)},(t,e)=>{t.setMonth(t.getMonth()+e)},(t,e)=>e.getMonth()-t.getMonth()+(e.getFullYear()-t.getFullYear())*12,t=>t.getMonth());Xt.range;const Ir=et(t=>{t.setUTCDate(1),t.setUTCHours(0,0,0,0)},(t,e)=>{t.setUTCMonth(t.getUTCMonth()+e)},(t,e)=>e.getUTCMonth()-t.getUTCMonth()+(e.getUTCFullYear()-t.getUTCFullYear())*12,t=>t.getUTCMonth());Ir.range;const pt=et(t=>{t.setMonth(0,1),t.setHours(0,0,0,0)},(t,e)=>{t.setFullYear(t.getFullYear()+e)},(t,e)=>e.getFullYear()-t.getFullYear(),t=>t.getFullYear());pt.every=t=>!isFinite(t=Math.floor(t))||!(t>0)?null:et(e=>{e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)},(e,n)=>{e.setFullYear(e.getFullYear()+n*t)});pt.range;const Mt=et(t=>{t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},(t,e)=>{t.setUTCFullYear(t.getUTCFullYear()+e)},(t,e)=>e.getUTCFullYear()-t.getUTCFullYear(),t=>t.getUTCFullYear());Mt.every=t=>!isFinite(t=Math.floor(t))||!(t>0)?null:et(e=>{e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},(e,n)=>{e.setUTCFullYear(e.getUTCFullYear()+n*t)});Mt.range;function Lr(t,e,n,r,i,a){const s=[[Tt,1,yt],[Tt,5,5*yt],[Tt,15,15*yt],[Tt,30,30*yt],[a,1,ot],[a,5,5*ot],[a,15,15*ot],[a,30,30*ot],[i,1,kt],[i,3,3*kt],[i,6,6*kt],[i,12,12*kt],[r,1,vt],[r,2,2*vt],[n,1,Ye],[e,1,Re],[e,3,3*Re],[t,1,ke]];function h(M,w,E){const C=wF).right(s,C);if(D===s.length)return t.every(Ve(M/ke,w/ke,E));if(D===0)return Et.every(Math.max(Ve(M,w,E),1));const[V,N]=s[C/s[D-1][2]53)return null;"w"in f||(f.w=1),"Z"in f?(O=pe(Ht(f.y,0,1)),Q=O.getUTCDay(),O=Q>4||Q===0?ie.ceil(O):ie(O),O=Fe.offset(O,(f.V-1)*7),f.y=O.getUTCFullYear(),f.m=O.getUTCMonth(),f.d=O.getUTCDate()+(f.w+6)%7):(O=ve(Ht(f.y,0,1)),Q=O.getDay(),O=Q>4||Q===0?Zt.ceil(O):Zt(O),O=wt.offset(O,(f.V-1)*7),f.y=O.getFullYear(),f.m=O.getMonth(),f.d=O.getDate()+(f.w+6)%7)}else("W"in f||"U"in f)&&("w"in f||(f.w="u"in f?f.u%7:"W"in f?1:0),Q="Z"in f?pe(Ht(f.y,0,1)).getUTCDay():ve(Ht(f.y,0,1)).getDay(),f.m=0,f.d="W"in f?(f.w+6)%7+f.W*7-(Q+5)%7:f.w+f.U*7-(Q+6)%7);return"Z"in f?(f.H+=f.Z/100|0,f.M+=f.Z%100,pe(f)):ve(f)}}function v(m,W,P,f){for(var rt=0,O=W.length,Q=P.length,q,ct;rt=Q)return-1;if(q=W.charCodeAt(rt++),q===37){if(q=W.charAt(rt++),ct=G[q in Be?W.charAt(rt++):q],!ct||(f=ct(m,P,f))<0)return-1}else if(q!=P.charCodeAt(f++))return-1}return f}function H(m,W,P){var f=M.exec(W.slice(P));return f?(m.p=w.get(f[0].toLowerCase()),P+f[0].length):-1}function x(m,W,P){var f=D.exec(W.slice(P));return f?(m.w=V.get(f[0].toLowerCase()),P+f[0].length):-1}function Y(m,W,P){var f=E.exec(W.slice(P));return f?(m.w=C.get(f[0].toLowerCase()),P+f[0].length):-1}function S(m,W,P){var f=B.exec(W.slice(P));return f?(m.m=J.get(f[0].toLowerCase()),P+f[0].length):-1}function _(m,W,P){var f=N.exec(W.slice(P));return f?(m.m=F.get(f[0].toLowerCase()),P+f[0].length):-1}function c(m,W,P){return v(m,e,W,P)}function p(m,W,P){return v(m,n,W,P)}function b(m,W,P){return v(m,r,W,P)}function g(m){return s[m.getDay()]}function A(m){return a[m.getDay()]}function o(m){return T[m.getMonth()]}function $(m){return h[m.getMonth()]}function l(m){return i[+(m.getHours()>=12)]}function K(m){return 1+~~(m.getMonth()/3)}function u(m){return s[m.getUTCDay()]}function U(m){return a[m.getUTCDay()]}function I(m){return T[m.getUTCMonth()]}function X(m){return h[m.getUTCMonth()]}function L(m){return i[+(m.getUTCHours()>=12)]}function j(m){return 1+~~(m.getUTCMonth()/3)}return{format:function(m){var W=y(m+="",z);return W.toString=function(){return m},W},parse:function(m){var W=k(m+="",!1);return W.toString=function(){return m},W},utcFormat:function(m){var W=y(m+="",Z);return W.toString=function(){return m},W},utcParse:function(m){var W=k(m+="",!0);return W.toString=function(){return m},W}}}var Be={"-":"",_:" ",0:"0"},nt=/^\s*\d+/,Or=/^%/,$r=/[\\^$*+?|[\]().{}]/g;function R(t,e,n){var r=t<0?"-":"",i=(r?-t:t)+"",a=i.length;return r+(a[e.toLowerCase(),n]))}function Nr(t,e,n){var r=nt.exec(e.slice(n,n+1));return r?(t.w=+r[0],n+r[0].length):-1}function Pr(t,e,n){var r=nt.exec(e.slice(n,n+1));return r?(t.u=+r[0],n+r[0].length):-1}function Vr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.U=+r[0],n+r[0].length):-1}function zr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.V=+r[0],n+r[0].length):-1}function Rr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.W=+r[0],n+r[0].length):-1}function Ze(t,e,n){var r=nt.exec(e.slice(n,n+4));return r?(t.y=+r[0],n+r[0].length):-1}function Xe(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),n+r[0].length):-1}function Br(t,e,n){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n,n+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),n+r[0].length):-1}function Zr(t,e,n){var r=nt.exec(e.slice(n,n+1));return r?(t.q=r[0]*3-3,n+r[0].length):-1}function Xr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.m=r[0]-1,n+r[0].length):-1}function qe(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.d=+r[0],n+r[0].length):-1}function qr(t,e,n){var r=nt.exec(e.slice(n,n+3));return r?(t.m=0,t.d=+r[0],n+r[0].length):-1}function Ge(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.H=+r[0],n+r[0].length):-1}function Gr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.M=+r[0],n+r[0].length):-1}function jr(t,e,n){var r=nt.exec(e.slice(n,n+2));return r?(t.S=+r[0],n+r[0].length):-1}function Qr(t,e,n){var r=nt.exec(e.slice(n,n+3));return r?(t.L=+r[0],n+r[0].length):-1}function Jr(t,e,n){var r=nt.exec(e.slice(n,n+6));return r?(t.L=Math.floor(r[0]/1e3),n+r[0].length):-1}function Kr(t,e,n){var r=Or.exec(e.slice(n,n+1));return r?n+r[0].length:-1}function ti(t,e,n){var r=nt.exec(e.slice(n));return r?(t.Q=+r[0],n+r[0].length):-1}function ei(t,e,n){var r=nt.exec(e.slice(n));return r?(t.s=+r[0],n+r[0].length):-1}function je(t,e){return R(t.getDate(),e,2)}function ni(t,e){return R(t.getHours(),e,2)}function ri(t,e){return R(t.getHours()%12||12,e,2)}function ii(t,e){return R(1+wt.count(pt(t),t),e,3)}function Mn(t,e){return R(t.getMilliseconds(),e,3)}function ai(t,e){return Mn(t,e)+"000"}function si(t,e){return R(t.getMonth()+1,e,2)}function oi(t,e){return R(t.getMinutes(),e,2)}function ci(t,e){return R(t.getSeconds(),e,2)}function ui(t){var e=t.getDay();return e===0?7:e}function li(t,e){return R(qt.count(pt(t)-1,t),e,2)}function Cn(t){var e=t.getDay();return e>=4||e===0?Dt(t):Dt.ceil(t)}function fi(t,e){return t=Cn(t),R(Dt.count(pt(t),t)+(pt(t).getDay()===4),e,2)}function di(t){return t.getDay()}function hi(t,e){return R(Zt.count(pt(t)-1,t),e,2)}function mi(t,e){return R(t.getFullYear()%100,e,2)}function gi(t,e){return t=Cn(t),R(t.getFullYear()%100,e,2)}function yi(t,e){return R(t.getFullYear()%1e4,e,4)}function ki(t,e){var n=t.getDay();return t=n>=4||n===0?Dt(t):Dt.ceil(t),R(t.getFullYear()%1e4,e,4)}function vi(t){var e=t.getTimezoneOffset();return(e>0?"-":(e*=-1,"+"))+R(e/60|0,"0",2)+R(e%60,"0",2)}function Qe(t,e){return R(t.getUTCDate(),e,2)}function pi(t,e){return R(t.getUTCHours(),e,2)}function Ti(t,e){return R(t.getUTCHours()%12||12,e,2)}function xi(t,e){return R(1+Fe.count(Mt(t),t),e,3)}function Sn(t,e){return R(t.getUTCMilliseconds(),e,3)}function bi(t,e){return Sn(t,e)+"000"}function wi(t,e){return R(t.getUTCMonth()+1,e,2)}function Di(t,e){return R(t.getUTCMinutes(),e,2)}function Mi(t,e){return R(t.getUTCSeconds(),e,2)}function Ci(t){var e=t.getUTCDay();return e===0?7:e}function Si(t,e){return R(Dn.count(Mt(t)-1,t),e,2)}function _n(t){var e=t.getUTCDay();return e>=4||e===0?At(t):At.ceil(t)}function _i(t,e){return t=_n(t),R(At.count(Mt(t),t)+(Mt(t).getUTCDay()===4),e,2)}function Yi(t){return t.getUTCDay()}function Fi(t,e){return R(ie.count(Mt(t)-1,t),e,2)}function Ui(t,e){return R(t.getUTCFullYear()%100,e,2)}function Ii(t,e){return t=_n(t),R(t.getUTCFullYear()%100,e,2)}function Li(t,e){return R(t.getUTCFullYear()%1e4,e,4)}function Ei(t,e){var n=t.getUTCDay();return t=n>=4||n===0?At(t):At.ceil(t),R(t.getUTCFullYear()%1e4,e,4)}function Ai(){return"+0000"}function Je(){return"%"}function Ke(t){return+t}function tn(t){return Math.floor(+t/1e3)}var Yt,ae;Wi({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function Wi(t){return Yt=Wr(t),ae=Yt.format,Yt.parse,Yt.utcFormat,Yt.utcParse,Yt}function Oi(t){return new Date(t)}function $i(t){return t instanceof Date?+t:+new Date(+t)}function Yn(t,e,n,r,i,a,s,h,T,M){var w=rr(),E=w.invert,C=w.domain,D=M(".%L"),V=M(":%S"),N=M("%I:%M"),F=M("%I %p"),B=M("%a %d"),J=M("%b %d"),z=M("%B"),Z=M("%Y");function G(y){return(T(y)4&&(E+=7),w.add(E,Te)},i=function(T){return T.add(4-T.isoWeekday(),Te)},a=e.prototype;a.isoWeekYear=function(){var h=i(this);return h.year()},a.isoWeek=function(h){if(!this.$utils().u(h))return this.add((h-this.isoWeek())*7,Te);var T=i(this),M=r(this.isoWeekYear(),this.$u);return T.diff(M,Ni)+1},a.isoWeekday=function(h){return this.$utils().u(h)?this.day()||7:this.day(this.day()%7?h:h-7)};var s=a.startOf;a.startOf=function(h,T){var M=this.$utils(),w=M.u(T)?!0:T,E=M.p(h);return E===zi?w?this.date(this.date()-(this.isoWeekday()-1)).startOf("day"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf("day"):s.bind(this)(h,T)}});var Bi=function(e){return e.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,function(n,r,i){return r||i.slice(1)})},Zi={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},Xi=function(e,n){return e.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,function(r,i,a){var s=a&&a.toUpperCase();return i||n[a]||Zi[a]||Bi(n[s])})},qi=/(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,en=/\d/,Vt=/\d\d/,Gi=/\d{3}/,ji=/\d{4}/,ut=/\d\d?/,Qi=/[+-]?\d+/,Ji=/[+-]\d\d:?(\d\d)?|Z/,zt=/\d*[^-_:/,()\s\d]+/,xt={},Fn=function(e){return e=+e,e+(e>68?1900:2e3)};function Ki(t){if(!t||t==="Z")return 0;var e=t.match(/([+-]|\d\d)/g),n=+(e[1]*60)+(+e[2]||0);return n===0?0:e[0]==="+"?-n:n}var at=function(e){return function(n){this[e]=+n}},nn=[Ji,function(t){var e=this.zone||(this.zone={});e.offset=Ki(t)}],xe=function(e){var n=xt[e];return n&&(n.indexOf?n:n.s.concat(n.f))},rn=function(e,n){var r,i=xt,a=i.meridiem;if(!a)r=e===(n?"pm":"PM");else for(var s=1;s<=24;s+=1)if(e.indexOf(a(s,0,n))>-1){r=s>12;break}return r},ta={A:[zt,function(t){this.afternoon=rn(t,!1)}],a:[zt,function(t){this.afternoon=rn(t,!0)}],Q:[en,function(t){this.month=(t-1)*3+1}],S:[en,function(t){this.milliseconds=+t*100}],SS:[Vt,function(t){this.milliseconds=+t*10}],SSS:[Gi,function(t){this.milliseconds=+t}],s:[ut,at("seconds")],ss:[ut,at("seconds")],m:[ut,at("minutes")],mm:[ut,at("minutes")],H:[ut,at("hours")],h:[ut,at("hours")],HH:[ut,at("hours")],hh:[ut,at("hours")],D:[ut,at("day")],DD:[Vt,at("day")],Do:[zt,function(t){var e=xt,n=e.ordinal,r=t.match(/\d+/);if(this.day=r[0],!!n)for(var i=1;i<=31;i+=1)n(i).replace(/\[|\]/g,"")===t&&(this.day=i)}],w:[ut,at("week")],ww:[Vt,at("week")],M:[ut,at("month")],MM:[Vt,at("month")],MMM:[zt,function(t){var e=xe("months"),n=xe("monthsShort"),r=(n||e.map(function(i){return i.slice(0,3)})).indexOf(t)+1;if(r<1)throw new Error;this.month=r%12||r}],MMMM:[zt,function(t){var e=xe("months"),n=e.indexOf(t)+1;if(n<1)throw new Error;this.month=n%12||n}],Y:[Qi,at("year")],YY:[Vt,function(t){this.year=Fn(t)}],YYYY:[ji,at("year")],Z:nn,ZZ:nn};function ea(t){var e=t.afternoon;if(e!==void 0){var n=t.hours;e?n<12&&(t.hours+=12):n===12&&(t.hours=0),delete t.afternoon}}function na(t){t=Xi(t,xt&&xt.formats);for(var e=t.match(qi),n=e.length,r=0;r-1)return new Date((n==="X"?1e3:1)*e);var a=na(n),s=a(e),h=s.year,T=s.month,M=s.day,w=s.hours,E=s.minutes,C=s.seconds,D=s.milliseconds,V=s.zone,N=s.week,F=new Date,B=M||(!h&&!T?F.getDate():1),J=h||F.getFullYear(),z=0;h&&!T||(z=T>0?T-1:F.getMonth());var Z=w||0,G=E||0,y=C||0,k=D||0;if(V)return new Date(Date.UTC(J,z,B,Z,G,y,k+V.offset*60*1e3));if(r)return new Date(Date.UTC(J,z,B,Z,G,y,k));var v;return v=new Date(J,z,B,Z,G,y,k),N&&(v=i(v).week(N).toDate()),v}catch{return new Date("")}};const ia=(function(t,e,n){n.p.customParseFormat=!0,t&&t.parseTwoDigitYear&&(Fn=t.parseTwoDigitYear);var r=e.prototype,i=r.parse;r.parse=function(a){var s=a.date,h=a.utc,T=a.args;this.$u=h;var M=T[1];if(typeof M=="string"){var w=T[2]===!0,E=T[3]===!0,C=w||E,D=T[2];E&&(D=T[2]),xt=this.$locale(),!w&&D&&(xt=n.Ls[D]),this.$d=ra(s,M,h,n),this.init(),D&&D!==!0&&(this.$L=this.locale(D).$L),C&&s!=this.format(M)&&(this.$d=new Date("")),xt={}}else if(M instanceof Array)for(var V=M.length,N=1;N<=V;N+=1){T[1]=M[N-1];var F=n.apply(this,T);if(F.isValid()){this.$d=F.$d,this.$L=F.$L,this.init();break}N===V&&(this.$d=new Date(""))}else i.call(this,a)}}),aa=(function(t,e){var n=e.prototype,r=n.format;n.format=function(i){var a=this,s=this.$locale();if(!this.isValid())return r.bind(this)(i);var h=this.$utils(),T=i||Vi,M=T.replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,function(w){switch(w){case"Q":return Math.ceil((a.$M+1)/3);case"Do":return s.ordinal(a.$D);case"gggg":return a.weekYear();case"GGGG":return a.isoWeekYear();case"wo":return s.ordinal(a.week(),"W");case"w":case"ww":return h.s(a.week(),w==="w"?1:2,"0");case"W":case"WW":return h.s(a.isoWeek(),w==="W"?1:2,"0");case"k":case"kk":return h.s(String(a.$H===0?24:a.$H),w==="k"?1:2,"0");case"X":return Math.floor(a.$d.getTime()/1e3);case"x":return a.$d.getTime();case"z":return"["+a.offsetName()+"]";case"zzz":return"["+a.offsetName("long")+"]";default:return w}});return r.bind(this)(M)}});var Un={exports:{}};(function(t,e){(function(n,r){t.exports=r()})(zn,(function(){var n,r,i=1e3,a=6e4,s=36e5,h=864e5,T=31536e6,M=2628e6,w=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/,E=/\[([^\]]+)]|YYYY|YY|Y|M{1,2}|D{1,2}|H{1,2}|m{1,2}|s{1,2}|SSS/g,C={years:T,months:M,days:h,hours:s,minutes:a,seconds:i,milliseconds:1,weeks:6048e5},D=function(y){return y instanceof Z},V=function(y,k,v){return new Z(y,v,k.$l)},N=function(y){return r.p(y)+"s"},F=function(y){return y<0},B=function(y){return F(y)?Math.ceil(y):Math.floor(y)},J=function(y){return Math.abs(y)},z=function(y,k){return y?F(y)?{negative:!0,format:""+J(y)+k}:{negative:!1,format:""+y+k}:{negative:!1,format:""}},Z=(function(){function y(v,H,x){var Y=this;if(this.$d={},this.$l=x,v===void 0&&(this.$ms=0,this.parseFromMilliseconds()),H)return V(v*C[N(H)],this);if(typeof v=="number")return this.$ms=v,this.parseFromMilliseconds(),this;if(typeof v=="object")return Object.keys(v).forEach((function(c){Y.$d[N(c)]=v[c]})),this.calMilliseconds(),this;if(typeof v=="string"){var S=v.match(w);if(S){var _=S.slice(2).map((function(c){return c!=null?Number(c):0}));return this.$d.years=_[0],this.$d.months=_[1],this.$d.weeks=_[2],this.$d.days=_[3],this.$d.hours=_[4],this.$d.minutes=_[5],this.$d.seconds=_[6],this.calMilliseconds(),this}}return this}var k=y.prototype;return k.calMilliseconds=function(){var v=this;this.$ms=Object.keys(this.$d).reduce((function(H,x){return H+(v.$d[x]||0)*C[x]}),0)},k.parseFromMilliseconds=function(){var v=this.$ms;this.$d.years=B(v/T),v%=T,this.$d.months=B(v/M),v%=M,this.$d.days=B(v/h),v%=h,this.$d.hours=B(v/s),v%=s,this.$d.minutes=B(v/a),v%=a,this.$d.seconds=B(v/i),v%=i,this.$d.milliseconds=v},k.toISOString=function(){var v=z(this.$d.years,"Y"),H=z(this.$d.months,"M"),x=+this.$d.days||0;this.$d.weeks&&(x+=7*this.$d.weeks);var Y=z(x,"D"),S=z(this.$d.hours,"H"),_=z(this.$d.minutes,"M"),c=this.$d.seconds||0;this.$d.milliseconds&&(c+=this.$d.milliseconds/1e3,c=Math.round(1e3*c)/1e3);var p=z(c,"S"),b=v.negative||H.negative||Y.negative||S.negative||_.negative||p.negative,g=S.format||_.format||p.format?"T":"",A=(b?"-":"")+"P"+v.format+H.format+Y.format+g+S.format+_.format+p.format;return A==="P"||A==="-P"?"P0D":A},k.toJSON=function(){return this.toISOString()},k.format=function(v){var H=v||"YYYY-MM-DDTHH:mm:ss",x={Y:this.$d.years,YY:r.s(this.$d.years,2,"0"),YYYY:r.s(this.$d.years,4,"0"),M:this.$d.months,MM:r.s(this.$d.months,2,"0"),D:this.$d.days,DD:r.s(this.$d.days,2,"0"),H:this.$d.hours,HH:r.s(this.$d.hours,2,"0"),m:this.$d.minutes,mm:r.s(this.$d.minutes,2,"0"),s:this.$d.seconds,ss:r.s(this.$d.seconds,2,"0"),SSS:r.s(this.$d.milliseconds,3,"0")};return H.replace(E,(function(Y,S){return S||String(x[Y])}))},k.as=function(v){return this.$ms/C[N(v)]},k.get=function(v){var H=this.$ms,x=N(v);return x==="milliseconds"?H%=1e3:H=x==="weeks"?B(H/C[x]):this.$d[x],H||0},k.add=function(v,H,x){var Y;return Y=H?v*C[N(H)]:D(v)?v.$ms:V(v,this).$ms,V(this.$ms+Y*(x?-1:1),this)},k.subtract=function(v,H){return this.add(v,H,!0)},k.locale=function(v){var H=this.clone();return H.$l=v,H},k.clone=function(){return V(this.$ms,this)},k.humanize=function(v){return n().add(this.$ms,"ms").locale(this.$l).fromNow(!v)},k.valueOf=function(){return this.asMilliseconds()},k.milliseconds=function(){return this.get("milliseconds")},k.asMilliseconds=function(){return this.as("milliseconds")},k.seconds=function(){return this.get("seconds")},k.asSeconds=function(){return this.as("seconds")},k.minutes=function(){return this.get("minutes")},k.asMinutes=function(){return this.as("minutes")},k.hours=function(){return this.get("hours")},k.asHours=function(){return this.as("hours")},k.days=function(){return this.get("days")},k.asDays=function(){return this.as("days")},k.weeks=function(){return this.get("weeks")},k.asWeeks=function(){return this.as("weeks")},k.months=function(){return this.get("months")},k.asMonths=function(){return this.as("months")},k.years=function(){return this.get("years")},k.asYears=function(){return this.as("years")},y})(),G=function(y,k,v){return y.add(k.years()*v,"y").add(k.months()*v,"M").add(k.days()*v,"d").add(k.hours()*v,"h").add(k.minutes()*v,"m").add(k.seconds()*v,"s").add(k.milliseconds()*v,"ms")};return function(y,k,v){n=v,r=v().$utils(),v.duration=function(Y,S){var _=v.locale();return V(Y,{$l:_},S)},v.isDuration=D;var H=k.prototype.add,x=k.prototype.subtract;k.prototype.add=function(Y,S){return D(Y)?G(this,Y,1):H.bind(this)(Y,S)},k.prototype.subtract=function(Y,S){return D(Y)?G(this,Y,-1):x.bind(this)(Y,S)}}}))})(Un);var sa=Un.exports;const oa=Rn(sa);var Me=(function(){var t=d(function(_,c,p,b){for(p=p||{},b=_.length;b--;p[_[b]]=c);return p},"o"),e=[6,8,10,12,13,14,15,16,17,18,20,21,22,23,24,25,26,27,28,29,30,31,33,35,36,38,40],n=[1,26],r=[1,27],i=[1,28],a=[1,29],s=[1,30],h=[1,31],T=[1,32],M=[1,33],w=[1,34],E=[1,9],C=[1,10],D=[1,11],V=[1,12],N=[1,13],F=[1,14],B=[1,15],J=[1,16],z=[1,19],Z=[1,20],G=[1,21],y=[1,22],k=[1,23],v=[1,25],H=[1,35],x={trace:d(function(){},"trace"),yy:{},symbols_:{error:2,start:3,gantt:4,document:5,EOF:6,line:7,SPACE:8,statement:9,NL:10,weekday:11,weekday_monday:12,weekday_tuesday:13,weekday_wednesday:14,weekday_thursday:15,weekday_friday:16,weekday_saturday:17,weekday_sunday:18,weekend:19,weekend_friday:20,weekend_saturday:21,dateFormat:22,inclusiveEndDates:23,topAxis:24,axisFormat:25,tickInterval:26,excludes:27,includes:28,todayMarker:29,title:30,acc_title:31,acc_title_value:32,acc_descr:33,acc_descr_value:34,acc_descr_multiline_value:35,section:36,clickStatement:37,taskTxt:38,taskData:39,click:40,callbackname:41,callbackargs:42,href:43,clickStatementDebug:44,$accept:0,$end:1},terminals_:{2:"error",4:"gantt",6:"EOF",8:"SPACE",10:"NL",12:"weekday_monday",13:"weekday_tuesday",14:"weekday_wednesday",15:"weekday_thursday",16:"weekday_friday",17:"weekday_saturday",18:"weekday_sunday",20:"weekend_friday",21:"weekend_saturday",22:"dateFormat",23:"inclusiveEndDates",24:"topAxis",25:"axisFormat",26:"tickInterval",27:"excludes",28:"includes",29:"todayMarker",30:"title",31:"acc_title",32:"acc_title_value",33:"acc_descr",34:"acc_descr_value",35:"acc_descr_multiline_value",36:"section",38:"taskTxt",39:"taskData",40:"click",41:"callbackname",42:"callbackargs",43:"href"},productions_:[0,[3,3],[5,0],[5,2],[7,2],[7,1],[7,1],[7,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[19,1],[19,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,1],[9,2],[9,2],[9,1],[9,1],[9,1],[9,2],[37,2],[37,3],[37,3],[37,4],[37,3],[37,4],[37,2],[44,2],[44,3],[44,3],[44,4],[44,3],[44,4],[44,2]],performAction:d(function(c,p,b,g,A,o,$){var l=o.length-1;switch(A){case 1:return o[l-1];case 2:this.$=[];break;case 3:o[l-1].push(o[l]),this.$=o[l-1];break;case 4:case 5:this.$=o[l];break;case 6:case 7:this.$=[];break;case 8:g.setWeekday("monday");break;case 9:g.setWeekday("tuesday");break;case 10:g.setWeekday("wednesday");break;case 11:g.setWeekday("thursday");break;case 12:g.setWeekday("friday");break;case 13:g.setWeekday("saturday");break;case 14:g.setWeekday("sunday");break;case 15:g.setWeekend("friday");break;case 16:g.setWeekend("saturday");break;case 17:g.setDateFormat(o[l].substr(11)),this.$=o[l].substr(11);break;case 18:g.enableInclusiveEndDates(),this.$=o[l].substr(18);break;case 19:g.TopAxis(),this.$=o[l].substr(8);break;case 20:g.setAxisFormat(o[l].substr(11)),this.$=o[l].substr(11);break;case 21:g.setTickInterval(o[l].substr(13)),this.$=o[l].substr(13);break;case 22:g.setExcludes(o[l].substr(9)),this.$=o[l].substr(9);break;case 23:g.setIncludes(o[l].substr(9)),this.$=o[l].substr(9);break;case 24:g.setTodayMarker(o[l].substr(12)),this.$=o[l].substr(12);break;case 27:g.setDiagramTitle(o[l].substr(6)),this.$=o[l].substr(6);break;case 28:this.$=o[l].trim(),g.setAccTitle(this.$);break;case 29:case 30:this.$=o[l].trim(),g.setAccDescription(this.$);break;case 31:g.addSection(o[l].substr(8)),this.$=o[l].substr(8);break;case 33:g.addTask(o[l-1],o[l]),this.$="task";break;case 34:this.$=o[l-1],g.setClickEvent(o[l-1],o[l],null);break;case 35:this.$=o[l-2],g.setClickEvent(o[l-2],o[l-1],o[l]);break;case 36:this.$=o[l-2],g.setClickEvent(o[l-2],o[l-1],null),g.setLink(o[l-2],o[l]);break;case 37:this.$=o[l-3],g.setClickEvent(o[l-3],o[l-2],o[l-1]),g.setLink(o[l-3],o[l]);break;case 38:this.$=o[l-2],g.setClickEvent(o[l-2],o[l],null),g.setLink(o[l-2],o[l-1]);break;case 39:this.$=o[l-3],g.setClickEvent(o[l-3],o[l-1],o[l]),g.setLink(o[l-3],o[l-2]);break;case 40:this.$=o[l-1],g.setLink(o[l-1],o[l]);break;case 41:case 47:this.$=o[l-1]+" "+o[l];break;case 42:case 43:case 45:this.$=o[l-2]+" "+o[l-1]+" "+o[l];break;case 44:case 46:this.$=o[l-3]+" "+o[l-2]+" "+o[l-1]+" "+o[l];break}},"anonymous"),table:[{3:1,4:[1,2]},{1:[3]},t(e,[2,2],{5:3}),{6:[1,4],7:5,8:[1,6],9:7,10:[1,8],11:17,12:n,13:r,14:i,15:a,16:s,17:h,18:T,19:18,20:M,21:w,22:E,23:C,24:D,25:V,26:N,27:F,28:B,29:J,30:z,31:Z,33:G,35:y,36:k,37:24,38:v,40:H},t(e,[2,7],{1:[2,1]}),t(e,[2,3]),{9:36,11:17,12:n,13:r,14:i,15:a,16:s,17:h,18:T,19:18,20:M,21:w,22:E,23:C,24:D,25:V,26:N,27:F,28:B,29:J,30:z,31:Z,33:G,35:y,36:k,37:24,38:v,40:H},t(e,[2,5]),t(e,[2,6]),t(e,[2,17]),t(e,[2,18]),t(e,[2,19]),t(e,[2,20]),t(e,[2,21]),t(e,[2,22]),t(e,[2,23]),t(e,[2,24]),t(e,[2,25]),t(e,[2,26]),t(e,[2,27]),{32:[1,37]},{34:[1,38]},t(e,[2,30]),t(e,[2,31]),t(e,[2,32]),{39:[1,39]},t(e,[2,8]),t(e,[2,9]),t(e,[2,10]),t(e,[2,11]),t(e,[2,12]),t(e,[2,13]),t(e,[2,14]),t(e,[2,15]),t(e,[2,16]),{41:[1,40],43:[1,41]},t(e,[2,4]),t(e,[2,28]),t(e,[2,29]),t(e,[2,33]),t(e,[2,34],{42:[1,42],43:[1,43]}),t(e,[2,40],{41:[1,44]}),t(e,[2,35],{43:[1,45]}),t(e,[2,36]),t(e,[2,38],{42:[1,46]}),t(e,[2,37]),t(e,[2,39])],defaultActions:{},parseError:d(function(c,p){if(p.recoverable)this.trace(c);else{var b=new Error(c);throw b.hash=p,b}},"parseError"),parse:d(function(c){var p=this,b=[0],g=[],A=[null],o=[],$=this.table,l="",K=0,u=0,U=2,I=1,X=o.slice.call(arguments,1),L=Object.create(this.lexer),j={yy:{}};for(var m in this.yy)Object.prototype.hasOwnProperty.call(this.yy,m)&&(j.yy[m]=this.yy[m]);L.setInput(c,j.yy),j.yy.lexer=L,j.yy.parser=this,typeof L.yylloc>"u"&&(L.yylloc={});var W=L.yylloc;o.push(W);var P=L.options&&L.options.ranges;typeof j.yy.parseError=="function"?this.parseError=j.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function f(st){b.length=b.length-2*st,A.length=A.length-st,o.length=o.length-st}d(f,"popStack");function rt(){var st;return st=g.pop()||L.lex()||I,typeof st!="number"&&(st instanceof Array&&(g=st,st=g.pop()),st=p.symbols_[st]||st),st}d(rt,"lex");for(var O,Q,q,ct,dt={},jt,ht,Pe,Qt;;){if(Q=b[b.length-1],this.defaultActions[Q]?q=this.defaultActions[Q]:((O===null||typeof O>"u")&&(O=rt()),q=$[Q]&&$[Q][O]),typeof q>"u"||!q.length||!q[0]){var ce="";Qt=[];for(jt in $[Q])this.terminals_[jt]&&jt>U&&Qt.push("'"+this.terminals_[jt]+"'");L.showPosition?ce="Parse error on line "+(K+1)+`: +`+L.showPosition()+` +Expecting `+Qt.join(", ")+", got '"+(this.terminals_[O]||O)+"'":ce="Parse error on line "+(K+1)+": Unexpected "+(O==I?"end of input":"'"+(this.terminals_[O]||O)+"'"),this.parseError(ce,{text:L.match,token:this.terminals_[O]||O,line:L.yylineno,loc:W,expected:Qt})}if(q[0]instanceof Array&&q.length>1)throw new Error("Parse Error: multiple actions possible at state: "+Q+", token: "+O);switch(q[0]){case 1:b.push(O),A.push(L.yytext),o.push(L.yylloc),b.push(q[1]),O=null,u=L.yyleng,l=L.yytext,K=L.yylineno,W=L.yylloc;break;case 2:if(ht=this.productions_[q[1]][1],dt.$=A[A.length-ht],dt._$={first_line:o[o.length-(ht||1)].first_line,last_line:o[o.length-1].last_line,first_column:o[o.length-(ht||1)].first_column,last_column:o[o.length-1].last_column},P&&(dt._$.range=[o[o.length-(ht||1)].range[0],o[o.length-1].range[1]]),ct=this.performAction.apply(dt,[l,u,K,j.yy,q[1],A,o].concat(X)),typeof ct<"u")return ct;ht&&(b=b.slice(0,-1*ht*2),A=A.slice(0,-1*ht),o=o.slice(0,-1*ht)),b.push(this.productions_[q[1]][0]),A.push(dt.$),o.push(dt._$),Pe=$[b[b.length-2]][b[b.length-1]],b.push(Pe);break;case 3:return!0}}return!0},"parse")},Y=(function(){var _={EOF:1,parseError:d(function(p,b){if(this.yy.parser)this.yy.parser.parseError(p,b);else throw new Error(p)},"parseError"),setInput:d(function(c,p){return this.yy=p||this.yy||{},this._input=c,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:d(function(){var c=this._input[0];this.yytext+=c,this.yyleng++,this.offset++,this.match+=c,this.matched+=c;var p=c.match(/(?:\r\n?|\n).*/g);return p?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),c},"input"),unput:d(function(c){var p=c.length,b=c.split(/(?:\r\n?|\n)/g);this._input=c+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-p),this.offset-=p;var g=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),b.length-1&&(this.yylineno-=b.length-1);var A=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:b?(b.length===g.length?this.yylloc.first_column:0)+g[g.length-b.length].length-b[0].length:this.yylloc.first_column-p},this.options.ranges&&(this.yylloc.range=[A[0],A[0]+this.yyleng-p]),this.yyleng=this.yytext.length,this},"unput"),more:d(function(){return this._more=!0,this},"more"),reject:d(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:d(function(c){this.unput(this.match.slice(c))},"less"),pastInput:d(function(){var c=this.matched.substr(0,this.matched.length-this.match.length);return(c.length>20?"...":"")+c.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:d(function(){var c=this.match;return c.length<20&&(c+=this._input.substr(0,20-c.length)),(c.substr(0,20)+(c.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:d(function(){var c=this.pastInput(),p=new Array(c.length+1).join("-");return c+this.upcomingInput()+` +`+p+"^"},"showPosition"),test_match:d(function(c,p){var b,g,A;if(this.options.backtrack_lexer&&(A={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(A.yylloc.range=this.yylloc.range.slice(0))),g=c[0].match(/(?:\r\n?|\n).*/g),g&&(this.yylineno+=g.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:g?g[g.length-1].length-g[g.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+c[0].length},this.yytext+=c[0],this.match+=c[0],this.matches=c,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(c[0].length),this.matched+=c[0],b=this.performAction.call(this,this.yy,this,p,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),b)return b;if(this._backtrack){for(var o in A)this[o]=A[o];return!1}return!1},"test_match"),next:d(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var c,p,b,g;this._more||(this.yytext="",this.match="");for(var A=this._currentRules(),o=0;op[0].length)){if(p=b,g=o,this.options.backtrack_lexer){if(c=this.test_match(b,A[o]),c!==!1)return c;if(this._backtrack){p=!1;continue}else return!1}else if(!this.options.flex)break}return p?(c=this.test_match(p,A[g]),c!==!1?c:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:d(function(){var p=this.next();return p||this.lex()},"lex"),begin:d(function(p){this.conditionStack.push(p)},"begin"),popState:d(function(){var p=this.conditionStack.length-1;return p>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:d(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:d(function(p){return p=this.conditionStack.length-1-Math.abs(p||0),p>=0?this.conditionStack[p]:"INITIAL"},"topState"),pushState:d(function(p){this.begin(p)},"pushState"),stateStackSize:d(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:d(function(p,b,g,A){switch(g){case 0:return this.begin("open_directive"),"open_directive";case 1:return this.begin("acc_title"),31;case 2:return this.popState(),"acc_title_value";case 3:return this.begin("acc_descr"),33;case 4:return this.popState(),"acc_descr_value";case 5:this.begin("acc_descr_multiline");break;case 6:this.popState();break;case 7:return"acc_descr_multiline_value";case 8:break;case 9:break;case 10:break;case 11:return 10;case 12:break;case 13:break;case 14:this.begin("href");break;case 15:this.popState();break;case 16:return 43;case 17:this.begin("callbackname");break;case 18:this.popState();break;case 19:this.popState(),this.begin("callbackargs");break;case 20:return 41;case 21:this.popState();break;case 22:return 42;case 23:this.begin("click");break;case 24:this.popState();break;case 25:return 40;case 26:return 4;case 27:return 22;case 28:return 23;case 29:return 24;case 30:return 25;case 31:return 26;case 32:return 28;case 33:return 27;case 34:return 29;case 35:return 12;case 36:return 13;case 37:return 14;case 38:return 15;case 39:return 16;case 40:return 17;case 41:return 18;case 42:return 20;case 43:return 21;case 44:return"date";case 45:return 30;case 46:return"accDescription";case 47:return 36;case 48:return 38;case 49:return 39;case 50:return":";case 51:return 6;case 52:return"INVALID"}},"anonymous"),rules:[/^(?:%%\{)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:%%(?!\{)*[^\n]*)/i,/^(?:[^\}]%%*[^\n]*)/i,/^(?:%%*[^\n]*[\n]*)/i,/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?:%[^\n]*)/i,/^(?:href[\s]+["])/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:call[\s]+)/i,/^(?:\([\s]*\))/i,/^(?:\()/i,/^(?:[^(]*)/i,/^(?:\))/i,/^(?:[^)]*)/i,/^(?:click[\s]+)/i,/^(?:[\s\n])/i,/^(?:[^\s\n]*)/i,/^(?:gantt\b)/i,/^(?:dateFormat\s[^#\n;]+)/i,/^(?:inclusiveEndDates\b)/i,/^(?:topAxis\b)/i,/^(?:axisFormat\s[^#\n;]+)/i,/^(?:tickInterval\s[^#\n;]+)/i,/^(?:includes\s[^#\n;]+)/i,/^(?:excludes\s[^#\n;]+)/i,/^(?:todayMarker\s[^\n;]+)/i,/^(?:weekday\s+monday\b)/i,/^(?:weekday\s+tuesday\b)/i,/^(?:weekday\s+wednesday\b)/i,/^(?:weekday\s+thursday\b)/i,/^(?:weekday\s+friday\b)/i,/^(?:weekday\s+saturday\b)/i,/^(?:weekday\s+sunday\b)/i,/^(?:weekend\s+friday\b)/i,/^(?:weekend\s+saturday\b)/i,/^(?:\d\d\d\d-\d\d-\d\d\b)/i,/^(?:title\s[^\n]+)/i,/^(?:accDescription\s[^#\n;]+)/i,/^(?:section\s[^\n]+)/i,/^(?:[^:\n]+)/i,/^(?::[^#\n;]+)/i,/^(?::)/i,/^(?:$)/i,/^(?:.)/i],conditions:{acc_descr_multiline:{rules:[6,7],inclusive:!1},acc_descr:{rules:[4],inclusive:!1},acc_title:{rules:[2],inclusive:!1},callbackargs:{rules:[21,22],inclusive:!1},callbackname:{rules:[18,19,20],inclusive:!1},href:{rules:[15,16],inclusive:!1},click:{rules:[24,25],inclusive:!1},INITIAL:{rules:[0,1,3,5,8,9,10,11,12,13,14,17,23,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52],inclusive:!0}}};return _})();x.lexer=Y;function S(){this.yy={}}return d(S,"Parser"),S.prototype=x,x.Parser=S,new S})();Me.parser=Me;var ca=Me;it.extend(Ri);it.extend(ia);it.extend(aa);var an={friday:5,saturday:6},lt="",Ue="",Ie=void 0,Le="",Wt=[],Ot=[],Ee=new Map,Ae=[],se=[],$t="",We="",In=["active","done","crit","milestone","vert"],Oe=[],Ft="",Gt=!1,$e=!1,He="sunday",oe="saturday",Ce=0,ua=d(function(){Ae=[],se=[],$t="",Oe=[],ee=0,_e=void 0,ne=void 0,tt=[],lt="",Ue="",We="",Ie=void 0,Le="",Wt=[],Ot=[],Gt=!1,$e=!1,Ce=0,Ee=new Map,Ft="",tr(),He="sunday",oe="saturday"},"clear"),la=d(function(t){Ft=t},"setDiagramId"),fa=d(function(t){Ue=t},"setAxisFormat"),da=d(function(){return Ue},"getAxisFormat"),ha=d(function(t){Ie=t},"setTickInterval"),ma=d(function(){return Ie},"getTickInterval"),ga=d(function(t){Le=t},"setTodayMarker"),ya=d(function(){return Le},"getTodayMarker"),ka=d(function(t){lt=t},"setDateFormat"),va=d(function(){Gt=!0},"enableInclusiveEndDates"),pa=d(function(){return Gt},"endDatesAreInclusive"),Ta=d(function(){$e=!0},"enableTopAxis"),xa=d(function(){return $e},"topAxisEnabled"),ba=d(function(t){We=t},"setDisplayMode"),wa=d(function(){return We},"getDisplayMode"),Da=d(function(){return lt},"getDateFormat"),Ln=d((t,e)=>{const n=e.toLowerCase().split(/[\s,]+/).filter(r=>r!=="");return[...new Set([...t,...n])]},"mergeTokens"),Ma=d(function(t){Wt=Ln(Wt,t)},"setIncludes"),Ca=d(function(){return Wt},"getIncludes"),Sa=d(function(t){Ot=Ln(Ot,t)},"setExcludes"),_a=d(function(){return Ot},"getExcludes"),Ya=d(function(){return Ee},"getLinks"),Fa=d(function(t){$t=t,Ae.push(t)},"addSection"),Ua=d(function(){return Ae},"getSections"),Ia=d(function(){let t=sn();const e=10;let n=0;for(;!t&&nh))throw new Error("Failed to find a valid date that was not excluded by `excludes` after 10,000 iterations.");t=t.add(1,"d")}return[e,s]},"fixTaskDates"),Se=d(function(t,e,n){if(n=n.trim(),d(h=>{const T=h.trim();return T==="x"||T==="X"},"isTimestampFormat")(e)&&/^\d+$/.test(n))return new Date(Number(n));const a=/^after\s+(?[\d\w- ]+)/.exec(n);if(a!==null){let h=null;for(const M of a.groups.ids.split(" ")){let w=_t(M);w!==void 0&&(!h||w.endTime>h.endTime)&&(h=w)}if(h)return h.endTime;const T=new Date;return T.setHours(0,0,0,0),T}let s=it(n,e.trim(),!0);if(s.isValid())return s.toDate();{bt.debug("Invalid date:"+n),bt.debug("With date format:"+e.trim());const h=new Date(n);if(h===void 0||isNaN(h.getTime())||h.getFullYear()<-1e4||h.getFullYear()>1e4)throw new Error("Invalid date:"+n);return h}},"getStartDate"),Wn=d(function(t){const e=/^(\d+(?:\.\d+)?)([Mdhmswy]|ms)$/.exec(t.trim());return e!==null?[Number.parseFloat(e[1]),e[2]]:[NaN,"ms"]},"parseDuration"),On=d(function(t,e,n,r=!1){n=n.trim();const a=/^until\s+(?[\d\w- ]+)/.exec(n);if(a!==null){let w=null;for(const C of a.groups.ids.split(" ")){let D=_t(C);D!==void 0&&(!w||D.startTime{window.open(n,"_self")}),Ee.set(r,n))}),Hn(t,"clickable")},"setLink"),Hn=d(function(t,e){t.split(",").forEach(function(n){let r=_t(n);r!==void 0&&r.classes.push(e)})},"setClass"),Va=d(function(t,e,n){if(Ut().securityLevel!=="loose"||e===void 0)return;let r=[];if(typeof n=="string"){r=n.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);for(let a=0;a{er.runFunc(e,...r)})},"setClickFun"),Nn=d(function(t,e){Oe.push(function(){const n=Ft?`${Ft}-${t}`:t,r=document.querySelector(`[id="${n}"]`);r!==null&&r.addEventListener("click",function(){e()})},function(){const n=Ft?`${Ft}-${t}`:t,r=document.querySelector(`[id="${n}-text"]`);r!==null&&r.addEventListener("click",function(){e()})})},"pushFun"),za=d(function(t,e,n){t.split(",").forEach(function(r){Va(r,e,n)}),Hn(t,"clickable")},"setClickEvent"),Ra=d(function(t){Oe.forEach(function(e){e(t)})},"bindFunctions"),Ba={getConfig:d(()=>Ut().gantt,"getConfig"),clear:ua,setDateFormat:ka,getDateFormat:Da,enableInclusiveEndDates:va,endDatesAreInclusive:pa,enableTopAxis:Ta,topAxisEnabled:xa,setAxisFormat:fa,getAxisFormat:da,setTickInterval:ha,getTickInterval:ma,setTodayMarker:ga,getTodayMarker:ya,setAccTitle:jn,getAccTitle:Gn,setDiagramTitle:qn,getDiagramTitle:Xn,setDiagramId:la,setDisplayMode:ba,getDisplayMode:wa,setAccDescription:Zn,getAccDescription:Bn,addSection:Fa,getSections:Ua,getTasks:Ia,addTask:Ha,findTaskById:_t,addTaskOrg:Na,setIncludes:Ma,getIncludes:Ca,setExcludes:Sa,getExcludes:_a,setClickEvent:za,setLink:Pa,getLinks:Ya,bindFunctions:Ra,parseDuration:Wn,isInvalidDate:En,setWeekday:La,getWeekday:Ea,setWeekend:Aa};function Ne(t,e,n){let r=!0;for(;r;)r=!1,n.forEach(function(i){const a="^\\s*"+i+"\\s*$",s=new RegExp(a);t[0].match(s)&&(e[i]=!0,t.shift(1),r=!0)})}d(Ne,"getTaskTags");it.extend(oa);var Za=d(function(){bt.debug("Something is calling, setConf, remove the call")},"setConf"),on={monday:Zt,tuesday:Tn,wednesday:xn,thursday:Dt,friday:bn,saturday:wn,sunday:qt},Xa=d((t,e)=>{let n=[...t].map(()=>-1/0),r=[...t].sort((a,s)=>a.startTime-s.startTime||a.order-s.order),i=0;for(const a of r)for(let s=0;s=n[s]){n[s]=a.endTime,a.order=s+e,s>i&&(i=s);break}return i},"getMaxIntersections"),mt,be=1e4,qa=d(function(t,e,n,r){const i=Ut().gantt;r.db.setDiagramId(e);const a=Ut().securityLevel;let s;a==="sandbox"&&(s=Jt("#i"+e));const h=a==="sandbox"?Jt(s.nodes()[0].contentDocument.body):Jt("body"),T=a==="sandbox"?s.nodes()[0].contentDocument:document,M=T.getElementById(e);mt=M.parentElement.offsetWidth,mt===void 0&&(mt=1200),i.useWidth!==void 0&&(mt=i.useWidth);const w=r.db.getTasks(),E=w.filter(x=>!x.vert);let C=[];for(const x of E)C.push(x.type);C=H(C);const D={};let V=2*i.topPadding;if(r.db.getDisplayMode()==="compact"||i.displayMode==="compact"){const x={};for(const S of E)x[S.section]===void 0?x[S.section]=[S]:x[S.section].push(S);let Y=0;for(const S of Object.keys(x)){const _=Xa(x[S],Y)+1;Y+=_,V+=_*(i.barHeight+i.barGap),D[S]=_}}else{V+=E.length*(i.barHeight+i.barGap);for(const x of C)D[x]=E.filter(Y=>Y.type===x).length}M.setAttribute("viewBox","0 0 "+mt+" "+V);const N=h.select(`[id="${e}"]`),F=Hi().domain([cr(w,function(x){return x.startTime}),or(w,function(x){return x.endTime})]).rangeRound([0,mt-i.leftPadding-i.rightPadding]);function B(x,Y){const S=x.startTime,_=Y.startTime;let c=0;return S>_?c=1:S<_&&(c=-1),c}d(B,"taskCompare"),w.sort(B),J(w,mt,V),Qn(N,V,mt,i.useMaxWidth),N.append("text").text(r.db.getDiagramTitle()).attr("x",mt/2).attr("y",i.titleTopMargin).attr("class","titleText");function J(x,Y,S){const _=i.barHeight,c=_+i.barGap,p=i.topPadding,b=i.leftPadding,g=ar().domain([0,C.length]).range(["#00B9FA","#F95002"]).interpolate(wr);Z(c,p,b,Y,S,x,r.db.getExcludes(),r.db.getIncludes()),y(b,p,Y,S),z(x,c,p,b,_,g,Y),k(c,p),v(b,p,Y,S)}d(J,"makeGantt");function z(x,Y,S,_,c,p,b){x.sort((u,U)=>u.vert===U.vert?0:u.vert?1:-1);const g=x.filter(u=>!u.vert),o=[...new Set(g.map(u=>u.order))].map(u=>g.find(U=>U.order===u));N.append("g").selectAll("rect").data(o).enter().append("rect").attr("x",0).attr("y",function(u,U){return U=u.order,U*Y+S-2}).attr("width",function(){return b-i.rightPadding/2}).attr("height",Y).attr("class",function(u){for(const[U,I]of C.entries())if(u.type===I)return"section section"+U%i.numberSectionStyles;return"section section0"}).enter();const $=N.append("g").selectAll("rect").data(x).enter(),l=r.db.getLinks();if($.append("rect").attr("id",function(u){return e+"-"+u.id}).attr("rx",3).attr("ry",3).attr("x",function(u){return u.milestone?F(u.startTime)+_+.5*(F(u.endTime)-F(u.startTime))-.5*c:F(u.startTime)+_}).attr("y",function(u,U){return U=u.order,u.vert?i.gridLineStartPadding:U*Y+S}).attr("width",function(u){return u.milestone?c:u.vert?.08*c:F(u.renderEndTime||u.endTime)-F(u.startTime)}).attr("height",function(u){return u.vert?g.length*(i.barHeight+i.barGap)+i.barHeight*2:c}).attr("transform-origin",function(u,U){return U=u.order,(F(u.startTime)+_+.5*(F(u.endTime)-F(u.startTime))).toString()+"px "+(U*Y+S+.5*c).toString()+"px"}).attr("class",function(u){const U="task";let I="";u.classes.length>0&&(I=u.classes.join(" "));let X=0;for(const[j,m]of C.entries())u.type===m&&(X=j%i.numberSectionStyles);let L="";return u.active?u.crit?L+=" activeCrit":L=" active":u.done?u.crit?L=" doneCrit":L=" done":u.crit&&(L+=" crit"),L.length===0&&(L=" task"),u.milestone&&(L=" milestone "+L),u.vert&&(L=" vert "+L),L+=X,L+=" "+I,U+L}),$.append("text").attr("id",function(u){return e+"-"+u.id+"-text"}).text(function(u){return u.task}).attr("font-size",i.fontSize).attr("x",function(u){let U=F(u.startTime),I=F(u.renderEndTime||u.endTime);if(u.milestone&&(U+=.5*(F(u.endTime)-F(u.startTime))-.5*c,I=U+c),u.vert)return F(u.startTime)+_;const X=this.getBBox().width;return X>I-U?I+X+1.5*i.leftPadding>b?U+_-5:I+_+5:(I-U)/2+U+_}).attr("y",function(u,U){return u.vert?i.gridLineStartPadding+g.length*(i.barHeight+i.barGap)+60:(U=u.order,U*Y+i.barHeight/2+(i.fontSize/2-2)+S)}).attr("text-height",c).attr("class",function(u){const U=F(u.startTime);let I=F(u.endTime);u.milestone&&(I=U+c);const X=this.getBBox().width;let L="";u.classes.length>0&&(L=u.classes.join(" "));let j=0;for(const[W,P]of C.entries())u.type===P&&(j=W%i.numberSectionStyles);let m="";return u.active&&(u.crit?m="activeCritText"+j:m="activeText"+j),u.done?u.crit?m=m+" doneCritText"+j:m=m+" doneText"+j:u.crit&&(m=m+" critText"+j),u.milestone&&(m+=" milestoneText"),u.vert&&(m+=" vertText"),X>I-U?I+X+1.5*i.leftPadding>b?L+" taskTextOutsideLeft taskTextOutside"+j+" "+m:L+" taskTextOutsideRight taskTextOutside"+j+" "+m+" width-"+X:L+" taskText taskText"+j+" "+m+" width-"+X}),Ut().securityLevel==="sandbox"){let u;u=Jt("#i"+e);const U=u.nodes()[0].contentDocument;$.filter(function(I){return l.has(I.id)}).each(function(I){var X=U.querySelector("#"+CSS.escape(e+"-"+I.id)),L=U.querySelector("#"+CSS.escape(e+"-"+I.id+"-text"));const j=X.parentNode;var m=U.createElement("a");m.setAttribute("xlink:href",l.get(I.id)),m.setAttribute("target","_top"),j.appendChild(m),m.appendChild(X),m.appendChild(L)})}}d(z,"drawRects");function Z(x,Y,S,_,c,p,b,g){if(b.length===0&&g.length===0)return;let A,o;for(const{startTime:I,endTime:X}of p)(A===void 0||Io)&&(o=X);if(!A||!o)return;if(it(o).diff(it(A),"year")>5){bt.warn("The difference between the min and max time is more than 5 years. This will cause performance issues. Skipping drawing exclude days.");return}const $=r.db.getDateFormat(),l=[];let K=null,u=it(A);for(;u.valueOf()<=o;)r.db.isInvalidDate(u,$,b,g)?K?K.end=u:K={start:u,end:u}:K&&(l.push(K),K=null),u=u.add(1,"d");N.append("g").selectAll("rect").data(l).enter().append("rect").attr("id",I=>e+"-exclude-"+I.start.format("YYYY-MM-DD")).attr("x",I=>F(I.start.startOf("day"))+S).attr("y",i.gridLineStartPadding).attr("width",I=>F(I.end.endOf("day"))-F(I.start.startOf("day"))).attr("height",c-Y-i.gridLineStartPadding).attr("transform-origin",function(I,X){return(F(I.start)+S+.5*(F(I.end)-F(I.start))).toString()+"px "+(X*x+.5*c).toString()+"px"}).attr("class","exclude-range")}d(Z,"drawExcludeDays");function G(x,Y,S,_){if(S<=0||x>Y)return 1/0;const c=Y-x,p=it.duration({[_??"day"]:S}).asMilliseconds();return p<=0?1/0:Math.ceil(c/p)}d(G,"getEstimatedTickCount");function y(x,Y,S,_){const c=r.db.getDateFormat(),p=r.db.getAxisFormat();let b;p?b=p:c==="D"?b="%d":b=i.axisFormat??"%Y-%m-%d";let g=yr(F).tickSize(-_+Y+i.gridLineStartPadding).tickFormat(ae(b));const o=/^([1-9]\d*)(millisecond|second|minute|hour|day|week|month)$/.exec(r.db.getTickInterval()||i.tickInterval);if(o!==null){const $=parseInt(o[1],10);if(isNaN($)||$<=0)bt.warn(`Invalid tick interval value: "${o[1]}". Skipping custom tick interval.`);else{const l=o[2],K=r.db.getWeekday()||i.weekday,u=F.domain(),U=u[0],I=u[1],X=G(U,I,$,l);if(X>be)bt.warn(`The tick interval "${$}${l}" would generate ${X} ticks, which exceeds the maximum allowed (${be}). This may indicate an invalid date or time range. Skipping custom tick interval.`);else switch(l){case"millisecond":g.ticks(Et.every($));break;case"second":g.ticks(Tt.every($));break;case"minute":g.ticks(Rt.every($));break;case"hour":g.ticks(Bt.every($));break;case"day":g.ticks(wt.every($));break;case"week":g.ticks(on[K].every($));break;case"month":g.ticks(Xt.every($));break}}}if(N.append("g").attr("class","grid").attr("transform","translate("+x+", "+(_-50)+")").call(g).selectAll("text").style("text-anchor","middle").attr("fill","#000").attr("stroke","none").attr("font-size",10).attr("dy","1em"),r.db.topAxisEnabled()||i.topAxis){let $=gr(F).tickSize(-_+Y+i.gridLineStartPadding).tickFormat(ae(b));if(o!==null){const l=parseInt(o[1],10);if(isNaN(l)||l<=0)bt.warn(`Invalid tick interval value: "${o[1]}". Skipping custom tick interval.`);else{const K=o[2],u=r.db.getWeekday()||i.weekday,U=F.domain(),I=U[0],X=U[1];if(G(I,X,l,K)<=be)switch(K){case"millisecond":$.ticks(Et.every(l));break;case"second":$.ticks(Tt.every(l));break;case"minute":$.ticks(Rt.every(l));break;case"hour":$.ticks(Bt.every(l));break;case"day":$.ticks(wt.every(l));break;case"week":$.ticks(on[u].every(l));break;case"month":$.ticks(Xt.every(l));break}}}N.append("g").attr("class","grid").attr("transform","translate("+x+", "+Y+")").call($).selectAll("text").style("text-anchor","middle").attr("fill","#000").attr("stroke","none").attr("font-size",10)}}d(y,"makeGrid");function k(x,Y){let S=0;const _=Object.keys(D).map(c=>[c,D[c]]);N.append("g").selectAll("text").data(_).enter().append(function(c){const p=c[0].split(Jn.lineBreakRegex),b=-(p.length-1)/2,g=T.createElementNS("http://www.w3.org/2000/svg","text");g.setAttribute("dy",b+"em");for(const[A,o]of p.entries()){const $=T.createElementNS("http://www.w3.org/2000/svg","tspan");$.setAttribute("alignment-baseline","central"),$.setAttribute("x","10"),A>0&&$.setAttribute("dy","1em"),$.textContent=o,g.appendChild($)}return g}).attr("x",10).attr("y",function(c,p){if(p>0)for(let b=0;b` + .mermaid-main-font { + font-family: ${t.fontFamily}; + } + + .exclude-range { + fill: ${t.excludeBkgColor}; + } + + .section { + stroke: none; + opacity: 0.2; + } + + .section0 { + fill: ${t.sectionBkgColor}; + } + + .section2 { + fill: ${t.sectionBkgColor2}; + } + + .section1, + .section3 { + fill: ${t.altSectionBkgColor}; + opacity: 0.2; + } + + .sectionTitle0 { + fill: ${t.titleColor}; + } + + .sectionTitle1 { + fill: ${t.titleColor}; + } + + .sectionTitle2 { + fill: ${t.titleColor}; + } + + .sectionTitle3 { + fill: ${t.titleColor}; + } + + .sectionTitle { + text-anchor: start; + font-family: ${t.fontFamily}; + } + + + /* Grid and axis */ + + .grid .tick { + stroke: ${t.gridColor}; + opacity: 0.8; + shape-rendering: crispEdges; + } + + .grid .tick text { + font-family: ${t.fontFamily}; + fill: ${t.textColor}; + } + + .grid path { + stroke-width: 0; + } + + + /* Today line */ + + .today { + fill: none; + stroke: ${t.todayLineColor}; + stroke-width: 2px; + } + + + /* Task styling */ + + /* Default task */ + + .task { + stroke-width: 2; + } + + .taskText { + text-anchor: middle; + font-family: ${t.fontFamily}; + } + + .taskTextOutsideRight { + fill: ${t.taskTextDarkColor}; + text-anchor: start; + font-family: ${t.fontFamily}; + } + + .taskTextOutsideLeft { + fill: ${t.taskTextDarkColor}; + text-anchor: end; + } + + + /* Special case clickable */ + + .task.clickable { + cursor: pointer; + } + + .taskText.clickable { + cursor: pointer; + fill: ${t.taskTextClickableColor} !important; + font-weight: bold; + } + + .taskTextOutsideLeft.clickable { + cursor: pointer; + fill: ${t.taskTextClickableColor} !important; + font-weight: bold; + } + + .taskTextOutsideRight.clickable { + cursor: pointer; + fill: ${t.taskTextClickableColor} !important; + font-weight: bold; + } + + + /* Specific task settings for the sections*/ + + .taskText0, + .taskText1, + .taskText2, + .taskText3 { + fill: ${t.taskTextColor}; + } + + .task0, + .task1, + .task2, + .task3 { + fill: ${t.taskBkgColor}; + stroke: ${t.taskBorderColor}; + } + + .taskTextOutside0, + .taskTextOutside2 + { + fill: ${t.taskTextOutsideColor}; + } + + .taskTextOutside1, + .taskTextOutside3 { + fill: ${t.taskTextOutsideColor}; + } + + + /* Active task */ + + .active0, + .active1, + .active2, + .active3 { + fill: ${t.activeTaskBkgColor}; + stroke: ${t.activeTaskBorderColor}; + } + + .activeText0, + .activeText1, + .activeText2, + .activeText3 { + fill: ${t.taskTextDarkColor} !important; + } + + + /* Completed task */ + + .done0, + .done1, + .done2, + .done3 { + stroke: ${t.doneTaskBorderColor}; + fill: ${t.doneTaskBkgColor}; + stroke-width: 2; + } + + .doneText0, + .doneText1, + .doneText2, + .doneText3 { + fill: ${t.taskTextDarkColor} !important; + } + + /* Done task text displayed outside the bar sits against the diagram background, + not against the done-task bar, so it must use the outside/contrast color. */ + .doneText0.taskTextOutsideLeft, + .doneText0.taskTextOutsideRight, + .doneText1.taskTextOutsideLeft, + .doneText1.taskTextOutsideRight, + .doneText2.taskTextOutsideLeft, + .doneText2.taskTextOutsideRight, + .doneText3.taskTextOutsideLeft, + .doneText3.taskTextOutsideRight { + fill: ${t.taskTextOutsideColor} !important; + } + + + /* Tasks on the critical line */ + + .crit0, + .crit1, + .crit2, + .crit3 { + stroke: ${t.critBorderColor}; + fill: ${t.critBkgColor}; + stroke-width: 2; + } + + .activeCrit0, + .activeCrit1, + .activeCrit2, + .activeCrit3 { + stroke: ${t.critBorderColor}; + fill: ${t.activeTaskBkgColor}; + stroke-width: 2; + } + + .doneCrit0, + .doneCrit1, + .doneCrit2, + .doneCrit3 { + stroke: ${t.critBorderColor}; + fill: ${t.doneTaskBkgColor}; + stroke-width: 2; + cursor: pointer; + shape-rendering: crispEdges; + } + + .milestone { + transform: rotate(45deg) scale(0.8,0.8); + } + + .milestoneText { + font-style: italic; + } + .doneCritText0, + .doneCritText1, + .doneCritText2, + .doneCritText3 { + fill: ${t.taskTextDarkColor} !important; + } + + /* Done-crit task text outside the bar — same reasoning as doneText above. */ + .doneCritText0.taskTextOutsideLeft, + .doneCritText0.taskTextOutsideRight, + .doneCritText1.taskTextOutsideLeft, + .doneCritText1.taskTextOutsideRight, + .doneCritText2.taskTextOutsideLeft, + .doneCritText2.taskTextOutsideRight, + .doneCritText3.taskTextOutsideLeft, + .doneCritText3.taskTextOutsideRight { + fill: ${t.taskTextOutsideColor} !important; + } + + .vert { + stroke: ${t.vertLineColor}; + } + + .vertText { + font-size: 15px; + text-anchor: middle; + fill: ${t.vertLineColor} !important; + } + + .activeCritText0, + .activeCritText1, + .activeCritText2, + .activeCritText3 { + fill: ${t.taskTextDarkColor} !important; + } + + .titleText { + text-anchor: middle; + font-size: 18px; + fill: ${t.titleColor||t.textColor}; + font-family: ${t.fontFamily}; + } +`,"getStyles"),Qa=ja,is={parser:ca,db:Ba,renderer:Ga,styles:Qa};export{is as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/gitGraphDiagram-WWUBYQGX.Cf6cAMBl.js b/packages/tempo/public/v4/assets/chunks/gitGraphDiagram-WWUBYQGX.Cf6cAMBl.js new file mode 100644 index 00000000..50eb4731 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/gitGraphDiagram-WWUBYQGX.Cf6cAMBl.js @@ -0,0 +1,106 @@ +import{I as le}from"./chunk-2Q5K7J3B.3yPGAHkH.js";import{p as he}from"./chunk-JWPE2WC7.5yopTNlD.js";import{q as $e,p as fe,s as ge,g as ue,a as ye,b as xe,_ as h,A as J,l as w,j as me,c as W,z as pe,B as be,r as we,k as B,D as ke,E as ve,F as Ce}from"../app.CbekdYod.js";import{p as Ee}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var m={NORMAL:0,REVERSE:1,HIGHLIGHT:2,MERGE:3,CHERRY_PICK:4},Be=ve.gitGraph,S=h(()=>ke({...Be,...J().gitGraph}),"getConfig"),d=new le(()=>{const e=S(),r=e.mainBranchName,t=e.mainBranchOrder;return{mainBranchName:r,commits:new Map,head:null,branchConfig:new Map([[r,{name:r,order:t}]]),branches:new Map([[r,null]]),currBranch:r,direction:"LR",seq:0,options:{}}});function Y(){return Ce({length:7})}h(Y,"getID");function te(e,r){const t=Object.create(null);return e.reduce((s,o)=>{const i=r(o);return t[i]||(t[i]=!0,s.push(o)),s},[])}h(te,"uniqBy");var Te=h(function(e){d.records.direction=e},"setDirection"),Le=h(function(e){w.debug("options str",e),e=e?.trim(),e=e||"{}";try{d.records.options=JSON.parse(e)}catch(r){w.error("error while parsing gitGraph options",r.message)}},"setOptions"),Me=h(function(){return d.records.options},"getOptions"),Re=h(function(e){let r=e.msg,t=e.id;const s=e.type;let o=e.tags;w.info("commit",r,t,s,o),w.debug("Entering commit:",r,t,s,o);const i=S();t=B.sanitizeText(t,i),r=B.sanitizeText(r,i),o=o?.map(a=>B.sanitizeText(a,i));const n={id:t||d.records.seq+"-"+Y(),message:r,seq:d.records.seq++,type:s??m.NORMAL,tags:o??[],parents:d.records.head==null?[]:[d.records.head.id],branch:d.records.currBranch};d.records.head=n,w.info("main branch",i.mainBranchName),d.records.commits.has(n.id)&&w.warn(`Commit ID ${n.id} already exists`),d.records.commits.set(n.id,n),d.records.branches.set(d.records.currBranch,n.id),w.debug("in pushCommit "+n.id)},"commit"),Ie=h(function(e){let r=e.name;const t=e.order;if(r=B.sanitizeText(r,S()),d.records.branches.has(r))throw new Error(`Trying to create an existing branch. (Help: Either use a new name if you want create a new branch or try using "checkout ${r}")`);d.records.branches.set(r,d.records.head!=null?d.records.head.id:null),d.records.branchConfig.set(r,{name:r,order:t}),ae(r),w.debug("in createBranch")},"branch"),Oe=h(e=>{let r=e.branch,t=e.id;const s=e.type,o=e.tags,i=S();r=B.sanitizeText(r,i),t&&(t=B.sanitizeText(t,i));const n=d.records.branches.get(d.records.currBranch),a=d.records.branches.get(r),l=n?d.records.commits.get(n):void 0,f=a?d.records.commits.get(a):void 0;if(l&&f&&l.branch===r)throw new Error(`Cannot merge branch '${r}' into itself.`);if(d.records.currBranch===r){const c=new Error('Incorrect usage of "merge". Cannot merge a branch to itself');throw c.hash={text:`merge ${r}`,token:`merge ${r}`,expected:["branch abc"]},c}if(l===void 0||!l){const c=new Error(`Incorrect usage of "merge". Current branch (${d.records.currBranch})has no commits`);throw c.hash={text:`merge ${r}`,token:`merge ${r}`,expected:["commit"]},c}if(!d.records.branches.has(r)){const c=new Error('Incorrect usage of "merge". Branch to be merged ('+r+") does not exist");throw c.hash={text:`merge ${r}`,token:`merge ${r}`,expected:[`branch ${r}`]},c}if(f===void 0||!f){const c=new Error('Incorrect usage of "merge". Branch to be merged ('+r+") has no commits");throw c.hash={text:`merge ${r}`,token:`merge ${r}`,expected:['"commit"']},c}if(l===f){const c=new Error('Incorrect usage of "merge". Both branches have same head');throw c.hash={text:`merge ${r}`,token:`merge ${r}`,expected:["branch abc"]},c}if(t&&d.records.commits.has(t)){const c=new Error('Incorrect usage of "merge". Commit with id:'+t+" already exists, use different custom id");throw c.hash={text:`merge ${r} ${t} ${s} ${o?.join(" ")}`,token:`merge ${r} ${t} ${s} ${o?.join(" ")}`,expected:[`merge ${r} ${t}_UNIQUE ${s} ${o?.join(" ")}`]},c}const g=a||"",$={id:t||`${d.records.seq}-${Y()}`,message:`merged branch ${r} into ${d.records.currBranch}`,seq:d.records.seq++,parents:d.records.head==null?[]:[d.records.head.id,g],branch:d.records.currBranch,type:m.MERGE,customType:s,customId:!!t,tags:o??[]};d.records.head=$,d.records.commits.set($.id,$),d.records.branches.set(d.records.currBranch,$.id),w.debug(d.records.branches),w.debug("in mergeBranch")},"merge"),_e=h(function(e){let r=e.id,t=e.targetId,s=e.tags,o=e.parent;w.debug("Entering cherryPick:",r,t,s);const i=S();if(r=B.sanitizeText(r,i),t=B.sanitizeText(t,i),s=s?.map(l=>B.sanitizeText(l,i)),o=B.sanitizeText(o,i),!r||!d.records.commits.has(r)){const l=new Error('Incorrect usage of "cherryPick". Source commit id should exist and provided');throw l.hash={text:`cherryPick ${r} ${t}`,token:`cherryPick ${r} ${t}`,expected:["cherry-pick abc"]},l}const n=d.records.commits.get(r);if(n===void 0||!n)throw new Error('Incorrect usage of "cherryPick". Source commit id should exist and provided');if(o&&!(Array.isArray(n.parents)&&n.parents.includes(o)))throw new Error("Invalid operation: The specified parent commit is not an immediate parent of the cherry-picked commit.");const a=n.branch;if(n.type===m.MERGE&&!o)throw new Error("Incorrect usage of cherry-pick: If the source commit is a merge commit, an immediate parent commit must be specified.");if(!t||!d.records.commits.has(t)){if(a===d.records.currBranch){const $=new Error('Incorrect usage of "cherryPick". Source commit is already on current branch');throw $.hash={text:`cherryPick ${r} ${t}`,token:`cherryPick ${r} ${t}`,expected:["cherry-pick abc"]},$}const l=d.records.branches.get(d.records.currBranch);if(l===void 0||!l){const $=new Error(`Incorrect usage of "cherry-pick". Current branch (${d.records.currBranch})has no commits`);throw $.hash={text:`cherryPick ${r} ${t}`,token:`cherryPick ${r} ${t}`,expected:["cherry-pick abc"]},$}const f=d.records.commits.get(l);if(f===void 0||!f){const $=new Error(`Incorrect usage of "cherry-pick". Current branch (${d.records.currBranch})has no commits`);throw $.hash={text:`cherryPick ${r} ${t}`,token:`cherryPick ${r} ${t}`,expected:["cherry-pick abc"]},$}const g={id:d.records.seq+"-"+Y(),message:`cherry-picked ${n?.message} into ${d.records.currBranch}`,seq:d.records.seq++,parents:d.records.head==null?[]:[d.records.head.id,n.id],branch:d.records.currBranch,type:m.CHERRY_PICK,tags:s?s.filter(Boolean):[`cherry-pick:${n.id}${n.type===m.MERGE?`|parent:${o}`:""}`]};d.records.head=g,d.records.commits.set(g.id,g),d.records.branches.set(d.records.currBranch,g.id),w.debug(d.records.branches),w.debug("in cherryPick")}},"cherryPick"),ae=h(function(e){if(e=B.sanitizeText(e,S()),d.records.branches.has(e)){d.records.currBranch=e;const r=d.records.branches.get(d.records.currBranch);r===void 0||!r?d.records.head=null:d.records.head=d.records.commits.get(r)??null}else{const r=new Error(`Trying to checkout branch which is not yet created. (Help try using "branch ${e}")`);throw r.hash={text:`checkout ${e}`,token:`checkout ${e}`,expected:[`branch ${e}`]},r}},"checkout");function V(e,r,t){const s=e.indexOf(r);s===-1?e.push(t):e.splice(s,1,t)}h(V,"upsert");function Q(e){const r=e.reduce((o,i)=>o.seq>i.seq?o:i,e[0]);let t="";e.forEach(function(o){o===r?t+=" *":t+=" |"});const s=[t,r.id,r.seq];for(const o in d.records.branches)d.records.branches.get(o)===r.id&&s.push(o);if(w.debug(s.join(" ")),r.parents&&r.parents.length==2&&r.parents[0]&&r.parents[1]){const o=d.records.commits.get(r.parents[0]);V(e,r,o),r.parents[1]&&e.push(d.records.commits.get(r.parents[1]))}else{if(r.parents.length==0)return;if(r.parents[0]){const o=d.records.commits.get(r.parents[0]);V(e,r,o)}}e=te(e,o=>o.id),Q(e)}h(Q,"prettyPrintCommitHistory");var Ge=h(function(){w.debug(d.records.commits);const e=ne()[0];Q([e])},"prettyPrint"),He=h(function(){d.reset(),we()},"clear"),Se=h(function(){return[...d.records.branchConfig.values()].map((r,t)=>r.order!==null&&r.order!==void 0?r:{...r,order:parseFloat(`0.${t}`)}).sort((r,t)=>(r.order??0)-(t.order??0)).map(({name:r})=>({name:r}))},"getBranchesAsObjArray"),Ae=h(function(){return d.records.branches},"getBranches"),De=h(function(){return d.records.commits},"getCommits"),ne=h(function(){const e=[...d.records.commits.values()];return e.forEach(function(r){w.debug(r.id)}),e.sort((r,t)=>r.seq-t.seq),e},"getCommitsArray"),qe=h(function(){return d.records.currBranch},"getCurrentBranch"),Pe=h(function(){return d.records.direction},"getDirection"),We=h(function(){return d.records.head},"getHead"),se={commitType:m,getConfig:S,setDirection:Te,setOptions:Le,getOptions:Me,commit:Re,branch:Ie,merge:Oe,cherryPick:_e,checkout:ae,prettyPrint:Ge,clear:He,getBranchesAsObjArray:Se,getBranches:Ae,getCommits:De,getCommitsArray:ne,getCurrentBranch:qe,getDirection:Pe,getHead:We,setAccTitle:xe,getAccTitle:ye,getAccDescription:ue,setAccDescription:ge,setDiagramTitle:fe,getDiagramTitle:$e},Ne=h((e,r)=>{he(e,r),e.dir&&r.setDirection(e.dir);for(const t of e.statements)Fe(t,r)},"populate"),Fe=h((e,r)=>{const s={Commit:h(o=>r.commit(ze(o)),"Commit"),Branch:h(o=>r.branch(Ye(o)),"Branch"),Merge:h(o=>r.merge(je(o)),"Merge"),Checkout:h(o=>r.checkout(Ue(o)),"Checkout"),CherryPicking:h(o=>r.cherryPick(Ke(o)),"CherryPicking")}[e.$type];s?s(e):w.error(`Unknown statement type: ${e.$type}`)},"parseStatement"),ze=h(e=>({id:e.id,msg:e.message??"",type:e.type!==void 0?m[e.type]:m.NORMAL,tags:e.tags??void 0}),"parseCommit"),Ye=h(e=>({name:e.name,order:e.order??0}),"parseBranch"),je=h(e=>({branch:e.branch,id:e.id??"",type:e.type!==void 0?m[e.type]:void 0,tags:e.tags??void 0}),"parseMerge"),Ue=h(e=>e.branch,"parseCheckout"),Ke=h(e=>({id:e.id,targetId:"",tags:e.tags?.length===0?void 0:e.tags,parent:e.parent}),"parseCherryPicking"),Ve={parse:h(async e=>{const r=await Ee("gitGraph",e);w.debug(r),Ne(r,se)},"parse")},O=10,_=40,L=4,R=2,G=8,j=new Set(["redux","redux-dark","redux-color","redux-dark-color"]),X=12,Z=new Set(["redux-color","redux-dark-color"]),Xe=new Set(["dark","redux-dark","redux-dark-color","neo-dark"]),H=h((e,r,t=!1)=>t&&e>0?(e-1)%(r-1)+1:e%r,"calcColorIndex"),C=new Map,E=new Map,F=30,q=new Map,z=[],I=0,y="LR",Je=h(()=>{C.clear(),E.clear(),q.clear(),I=0,z=[],y="LR"},"clear"),oe=h(e=>{const r=document.createElementNS("http://www.w3.org/2000/svg","text");return(typeof e=="string"?e.split(/\\n|\n|/gi):e).forEach(s=>{const o=document.createElementNS("http://www.w3.org/2000/svg","tspan");o.setAttributeNS("http://www.w3.org/XML/1998/namespace","xml:space","preserve"),o.setAttribute("dy","1em"),o.setAttribute("x","0"),o.setAttribute("class","row"),o.textContent=s.trim(),r.appendChild(o)}),r},"drawText"),ce=h(e=>{let r,t,s;return y==="BT"?(t=h((o,i)=>o<=i,"comparisonFunc"),s=1/0):(t=h((o,i)=>o>=i,"comparisonFunc"),s=0),e.forEach(o=>{const i=y==="TB"||y=="BT"?E.get(o)?.y:E.get(o)?.x;i!==void 0&&t(i,s)&&(r=o,s=i)}),r},"findClosestParent"),Qe=h(e=>{let r="",t=1/0;return e.forEach(s=>{const o=E.get(s).y;o<=t&&(r=s,t=o)}),r||void 0},"findClosestParentBT"),Ze=h((e,r,t)=>{let s=t,o=t;const i=[];e.forEach(n=>{const a=r.get(n);if(!a)throw new Error(`Commit not found for key ${n}`);a.parents.length?(s=rr(a),o=Math.max(s,o)):i.push(a),tr(a,s)}),s=o,i.forEach(n=>{ar(n,s,t)}),e.forEach(n=>{const a=r.get(n);if(a?.parents.length){const l=Qe(a.parents);s=E.get(l).y-_,s<=o&&(o=s);const f=C.get(a.branch).pos,g=s-O;E.set(a.id,{x:f,y:g})}})},"setParallelBTPos"),er=h(e=>{const r=ce(e.parents.filter(s=>s!==null));if(!r)throw new Error(`Closest parent not found for commit ${e.id}`);const t=E.get(r)?.y;if(t===void 0)throw new Error(`Closest parent position not found for commit ${e.id}`);return t},"findClosestParentPos"),rr=h(e=>er(e)+_,"calculateCommitPosition"),tr=h((e,r)=>{const t=C.get(e.branch);if(!t)throw new Error(`Branch not found for commit ${e.id}`);const s=t.pos,o=r+O;return E.set(e.id,{x:s,y:o}),{x:s,y:o}},"setCommitPosition"),ar=h((e,r,t)=>{const s=C.get(e.branch);if(!s)throw new Error(`Branch not found for commit ${e.id}`);const o=r+t,i=s.pos;E.set(e.id,{x:i,y:o})},"setRootPosition"),nr=h((e,r,t,s,o,i)=>{const{theme:n}=W(),a=j.has(n??""),l=Z.has(n??""),f=Xe.has(n??"");if(i===m.HIGHLIGHT)e.append("rect").attr("x",t.x-10+(a?3:0)).attr("y",t.y-10+(a?3:0)).attr("width",a?14:20).attr("height",a?14:20).attr("class",`commit ${r.id} commit-highlight${H(o,G,l)} ${s}-outer`),e.append("rect").attr("x",t.x-6+(a?2:0)).attr("y",t.y-6+(a?2:0)).attr("width",a?8:12).attr("height",a?8:12).attr("class",`commit ${r.id} commit${H(o,G,l)} ${s}-inner`);else if(i===m.CHERRY_PICK)e.append("circle").attr("cx",t.x).attr("cy",t.y).attr("r",a?7:10).attr("class",`commit ${r.id} ${s}`),e.append("circle").attr("cx",t.x-3).attr("cy",t.y+2).attr("r",a?2.5:2.75).attr("fill",f?"#000000":"#fff").attr("class",`commit ${r.id} ${s}`),e.append("circle").attr("cx",t.x+3).attr("cy",t.y+2).attr("r",a?2.5:2.75).attr("fill",f?"#000000":"#fff").attr("class",`commit ${r.id} ${s}`),e.append("line").attr("x1",t.x+3).attr("y1",t.y+1).attr("x2",t.x).attr("y2",t.y-5).attr("stroke",f?"#000000":"#fff").attr("class",`commit ${r.id} ${s}`),e.append("line").attr("x1",t.x-3).attr("y1",t.y+1).attr("x2",t.x).attr("y2",t.y-5).attr("stroke",f?"#000000":"#fff").attr("class",`commit ${r.id} ${s}`);else{const g=e.append("circle");if(g.attr("cx",t.x),g.attr("cy",t.y),g.attr("r",a?7:10),g.attr("class",`commit ${r.id} commit${H(o,G,l)}`),i===m.MERGE){const $=e.append("circle");$.attr("cx",t.x),$.attr("cy",t.y),$.attr("r",a?5:6),$.attr("class",`commit ${s} ${r.id} commit${H(o,G,l)}`)}if(i===m.REVERSE){const $=e.append("path"),c=a?4:5;$.attr("d",`M ${t.x-c},${t.y-c}L${t.x+c},${t.y+c}M${t.x-c},${t.y+c}L${t.x+c},${t.y-c}`).attr("class",`commit ${s} ${r.id} commit${H(o,G,l)}`)}}},"drawCommitBullet"),sr=h((e,r,t,s,o)=>{if(r.type!==m.CHERRY_PICK&&(r.customId&&r.type===m.MERGE||r.type!==m.MERGE)&&o.showCommitLabel){const i=e.append("g"),n=i.insert("rect").attr("class","commit-label-bkg"),a=i.append("text").attr("x",s).attr("y",t.y+25).attr("class","commit-label").text(r.id),l=a.node()?.getBBox();if(l&&(n.attr("x",t.posWithOffset-l.width/2-R).attr("y",t.y+13.5).attr("width",l.width+2*R).attr("height",l.height+2*R),y==="TB"||y==="BT"?(n.attr("x",t.x-(l.width+4*L+5)).attr("y",t.y-12),a.attr("x",t.x-(l.width+4*L)).attr("y",t.y+l.height-12)):a.attr("x",t.posWithOffset-l.width/2),o.rotateCommitLabel))if(y==="TB"||y==="BT")a.attr("transform","rotate(-45, "+t.x+", "+t.y+")"),n.attr("transform","rotate(-45, "+t.x+", "+t.y+")");else{const f=-7.5-(l.width+10)/25*9.5,g=10+l.width/25*8.5;i.attr("transform","translate("+f+", "+g+") rotate(-45, "+s+", "+t.y+")")}}},"drawCommitLabel"),or=h((e,r,t,s)=>{if(r.tags.length>0){let o=0,i=0,n=0;const a=[];for(const l of r.tags.reverse()){const f=e.insert("polygon"),g=e.append("circle"),$=e.append("text").attr("y",t.y-16-o).attr("class","tag-label").text(l),c=$.node()?.getBBox();if(!c)throw new Error("Tag bbox not found");i=Math.max(i,c.width),n=Math.max(n,c.height),$.attr("x",t.posWithOffset-c.width/2),a.push({tag:$,hole:g,rect:f,yOffset:o}),o+=20}for(const{tag:l,hole:f,rect:g,yOffset:$}of a){const c=n/2,x=t.y-19.2-$;if(g.attr("class","tag-label-bkg").attr("points",` + ${s-i/2-L/2},${x+R} + ${s-i/2-L/2},${x-R} + ${t.posWithOffset-i/2-L},${x-c-R} + ${t.posWithOffset+i/2+L},${x-c-R} + ${t.posWithOffset+i/2+L},${x+c+R} + ${t.posWithOffset-i/2-L},${x+c+R}`),f.attr("cy",x).attr("cx",s-i/2+L/2).attr("r",1.5).attr("class","tag-hole"),y==="TB"||y==="BT"){const u=s+$;g.attr("class","tag-label-bkg").attr("points",` + ${t.x},${u+2} + ${t.x},${u-2} + ${t.x+O},${u-c-2} + ${t.x+O+i+4},${u-c-2} + ${t.x+O+i+4},${u+c+2} + ${t.x+O},${u+c+2}`).attr("transform","translate(12,12) rotate(45, "+t.x+","+s+")"),f.attr("cx",t.x+L/2).attr("cy",u).attr("transform","translate(12,12) rotate(45, "+t.x+","+s+")"),l.attr("x",t.x+5).attr("y",u+3).attr("transform","translate(14,14) rotate(45, "+t.x+","+s+")")}}}},"drawCommitTags"),cr=h(e=>{switch(e.customType??e.type){case m.NORMAL:return"commit-normal";case m.REVERSE:return"commit-reverse";case m.HIGHLIGHT:return"commit-highlight";case m.MERGE:return"commit-merge";case m.CHERRY_PICK:return"commit-cherry-pick";default:return"commit-normal"}},"getCommitClassType"),ir=h((e,r,t,s)=>{const o={x:0,y:0};if(e.parents.length>0){const i=ce(e.parents);if(i){const n=s.get(i)??o;return r==="TB"?n.y+_:r==="BT"?(s.get(e.id)??o).y-_:n.x+_}}else return r==="TB"?F:r==="BT"?(s.get(e.id)??o).y-_:0;return 0},"calculatePosition"),dr=h((e,r,t)=>{const s=y==="BT"&&t?r:r+O,o=C.get(e.branch)?.pos,i=y==="TB"||y==="BT"?C.get(e.branch)?.pos:s;if(i===void 0||o===void 0)throw new Error(`Position were undefined for commit ${e.id}`);const n=j.has(W().theme??""),a=y==="TB"||y==="BT"?s:o+(n?X/2+1:-2);return{x:i,y:a,posWithOffset:s}},"getCommitPosition"),re=h((e,r,t,s)=>{const o=e.append("g").attr("class","commit-bullets"),i=e.append("g").attr("class","commit-labels");let n=y==="TB"||y==="BT"?F:0;const a=[...r.keys()],l=s.parallelCommits??!1,f=h(($,c)=>{const x=r.get($)?.seq,u=r.get(c)?.seq;return x!==void 0&&u!==void 0?x-u:0},"sortKeys");let g=a.sort(f);y==="BT"&&(l&&Ze(g,r,n),g=g.reverse()),g.forEach($=>{const c=r.get($);if(!c)throw new Error(`Commit not found for key ${$}`);l&&(n=ir(c,y,n,E));const x=dr(c,n,l);if(t){const u=cr(c),p=c.customType??c.type,b=C.get(c.branch)?.index??0;nr(o,c,x,u,b,p),sr(i,c,x,n,s),or(i,c,x,n)}y==="TB"||y==="BT"?E.set(c.id,{x:x.x,y:x.posWithOffset}):E.set(c.id,{x:x.posWithOffset,y:x.y}),n=y==="BT"&&l?n+_:n+_+O,n>I&&(I=n)})},"drawCommits"),lr=h((e,r,t,s,o)=>{const n=(y==="TB"||y==="BT"?t.xf.branch===n,"isOnBranchToGetCurve"),l=h(f=>f.seq>e.seq&&f.seql(f)&&a(f))},"shouldRerouteArrow"),P=h((e,r,t=0)=>{const s=e+Math.abs(e-r)/2;if(t>5)return s;if(z.every(n=>Math.abs(n-s)>=10))return z.push(s),s;const i=Math.abs(e-r);return P(e,r-i/5,t+1)},"findLane"),hr=h((e,r,t,s)=>{const{theme:o}=W(),i=Z.has(o??""),n=E.get(r.id),a=E.get(t.id);if(n===void 0||a===void 0)throw new Error(`Commit positions not found for commits ${r.id} and ${t.id}`);const l=lr(r,t,n,a,s);let f="",g="",$=0,c=0,x=C.get(t.branch)?.index;t.type===m.MERGE&&r.id!==t.parents[0]&&(x=C.get(r.branch)?.index);let u;if(l){f="A 10 10, 0, 0, 0,",g="A 10 10, 0, 0, 1,",$=10,c=10;const p=n.ya.x&&(f="A 20 20, 0, 0, 0,",g="A 20 20, 0, 0, 1,",$=20,c=20,t.type===m.MERGE&&r.id!==t.parents[0]?u=`M ${n.x} ${n.y} L ${n.x} ${a.y-$} ${g} ${n.x-c} ${a.y} L ${a.x} ${a.y}`:u=`M ${n.x} ${n.y} L ${a.x+$} ${n.y} ${f} ${a.x} ${n.y+c} L ${a.x} ${a.y}`),n.x===a.x&&(u=`M ${n.x} ${n.y} L ${a.x} ${a.y}`)):y==="BT"?(n.xa.x&&(f="A 20 20, 0, 0, 0,",g="A 20 20, 0, 0, 1,",$=20,c=20,t.type===m.MERGE&&r.id!==t.parents[0]?u=`M ${n.x} ${n.y} L ${n.x} ${a.y+$} ${f} ${n.x-c} ${a.y} L ${a.x} ${a.y}`:u=`M ${n.x} ${n.y} L ${a.x+$} ${n.y} ${g} ${a.x} ${n.y-c} L ${a.x} ${a.y}`),n.x===a.x&&(u=`M ${n.x} ${n.y} L ${a.x} ${a.y}`)):(n.ya.y&&(t.type===m.MERGE&&r.id!==t.parents[0]?u=`M ${n.x} ${n.y} L ${a.x-$} ${n.y} ${f} ${a.x} ${n.y-c} L ${a.x} ${a.y}`:u=`M ${n.x} ${n.y} L ${n.x} ${a.y+$} ${g} ${n.x+c} ${a.y} L ${a.x} ${a.y}`),n.y===a.y&&(u=`M ${n.x} ${n.y} L ${a.x} ${a.y}`));if(u===void 0)throw new Error("Line definition not found");e.append("path").attr("d",u).attr("class","arrow arrow"+H(x,G,i))},"drawArrow"),$r=h((e,r)=>{const t=e.append("g").attr("class","commit-arrows");[...r.keys()].forEach(s=>{const o=r.get(s);o.parents&&o.parents.length>0&&o.parents.forEach(i=>{hr(t,r.get(i),o,r)})})},"drawArrows"),fr=h((e,r,t,s)=>{const{look:o,theme:i,themeVariables:n}=W(),{dropShadow:a,THEME_COLOR_LIMIT:l}=n,f=j.has(i??""),g=Z.has(i??""),$=e.append("g");r.forEach((c,x)=>{const u=H(x,f?l:G,g),p=C.get(c.name)?.pos;if(p===void 0)throw new Error(`Position not found for branch ${c.name}`);const b=y==="TB"||y==="BT"?p:f?p+X/2+1:p-2,k=$.append("line");k.attr("x1",0),k.attr("y1",b),k.attr("x2",I),k.attr("y2",b),k.attr("class","branch branch"+u),y==="TB"?(k.attr("y1",F),k.attr("x1",p),k.attr("y2",I),k.attr("x2",p)):y==="BT"&&(k.attr("y1",I),k.attr("x1",p),k.attr("y2",F),k.attr("x2",p)),z.push(b);const U=c.name,D=oe(U),T=$.insert("rect"),M=$.insert("g").attr("class","branchLabel").insert("g").attr("class","label branch-label"+u);M.node().appendChild(D);const v=D.getBBox(),ee=f?0:4,N=f?16:0,A=f?X:0;o==="neo"&&T.attr("data-look","neo"),T.attr("class","branchLabelBkg label"+u).attr("style",o==="neo"?`filter:${f?`url(#${s}-drop-shadow)`:a}`:"").attr("rx",ee).attr("ry",ee).attr("x",-v.width-4-(t.rotateCommitLabel===!0?30:0)).attr("y",-v.height/2+10).attr("width",v.width+18+N).attr("height",v.height+4+A),M.attr("transform","translate("+(-v.width-14-(t.rotateCommitLabel===!0?30:0)+N/2)+", "+(b-v.height/2-2)+")"),y==="TB"?(T.attr("x",p-v.width/2-10).attr("y",0),M.attr("transform","translate("+(p-v.width/2-5)+", 0)"),f&&(T.attr("transform",`translate(${-N/2-3}, ${-A-10})`),M.attr("transform","translate("+(p-v.width/2-5)+", "+(-A*2+7)+")"))):y==="BT"?(T.attr("x",p-v.width/2-10).attr("y",I),M.attr("transform","translate("+(p-v.width/2-5)+", "+I+")"),f&&(T.attr("transform",`translate(${-N/2-3}, ${A+10})`),M.attr("transform","translate("+(p-v.width/2-5)+", "+(I+A*2+4)+")"))):T.attr("transform","translate(-19, "+(b-12-A/2)+")")})},"drawBranches"),gr=h(function(e,r,t,s,o){return C.set(e,{pos:r,index:t}),r+=50+(o?40:0)+(y==="TB"||y==="BT"?s.width/2:0),r},"setBranchPosition"),ur=h(function(e,r,t,s){Je(),w.debug("in gitgraph renderer",e+` +`,"id:",r,t);const o=s.db;if(!o.getConfig){w.error("getConfig method is not available on db");return}const i=o.getConfig(),n=i.rotateCommitLabel??!1;q=o.getCommits();const a=o.getBranchesAsObjArray();y=o.getDirection();const l=me(`[id="${r}"]`),{look:f,theme:g,themeVariables:$}=W(),{useGradient:c,gradientStart:x,gradientStop:u,filterColor:p}=$;if(c){const k=l.append("defs").append("linearGradient").attr("id",r+"-gradient").attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");k.append("stop").attr("offset","0%").attr("stop-color",x).attr("stop-opacity",1),k.append("stop").attr("offset","100%").attr("stop-color",u).attr("stop-opacity",1)}f==="neo"&&j.has(g??"")&&l.append("defs").append("filter").attr("id",r+"-drop-shadow").attr("height","130%").attr("width","130%").append("feDropShadow").attr("dx","4").attr("dy","4").attr("stdDeviation",0).attr("flood-opacity","0.06").attr("flood-color",p);let b=0;a.forEach((k,U)=>{const D=oe(k.name),T=l.append("g"),K=T.insert("g").attr("class","branchLabel"),M=K.insert("g").attr("class","label branch-label");M.node()?.appendChild(D);const v=D.getBBox();b=gr(k.name,b,U,v,n),M.remove(),K.remove(),T.remove()}),re(l,q,!1,i),i.showBranches&&fr(l,a,i,r),$r(l,q),re(l,q,!0,i),pe.insertTitle(l,"gitTitleText",i.titleTopMargin??0,o.getDiagramTitle()),be(void 0,l,i.diagramPadding,i.useMaxWidth)},"draw"),yr={draw:ur},ie=8,de=new Set(["redux","redux-dark","redux-color","redux-dark-color"]),xr=new Set(["redux-color","redux-dark-color"]),mr=new Set(["neo","neo-dark"]),pr=new Set(["dark","redux-dark","redux-dark-color","neo-dark"]),br=new Set(["redux","redux-dark","redux-color","redux-dark-color","neo","neo-dark"]),wr=h(e=>{const{svgId:r}=e;let t="";if(e.useGradient&&r)for(let s=0;s{const r=J(),{theme:t,themeVariables:s}=r,{borderColorArray:o}=s,i=de.has(t);if(mr.has(t)){let n="";for(let a=0;a`${Array.from({length:e.THEME_COLOR_LIMIT},(r,t)=>t).map(r=>{const t=r%ie;return` + .branch-label${r} { fill: ${e["gitBranchLabel"+t]}; } + .commit${r} { stroke: ${e["git"+t]}; fill: ${e["git"+t]}; } + .commit-highlight${r} { stroke: ${e["gitInv"+t]}; fill: ${e["gitInv"+t]}; } + .label${r} { fill: ${e["git"+t]}; } + .arrow${r} { stroke: ${e["git"+t]}; } + `}).join(` +`)}`,"normalTheme"),Cr=h(e=>{const r=J(),{theme:t}=r,s=br.has(t);return` + .commit-id, + .commit-msg, + .branch-label { + fill: lightgrey; + color: lightgrey; + font-family: 'trebuchet ms', verdana, arial, sans-serif; + font-family: var(--mermaid-font-family); + } + + ${s?kr(e):vr(e)} + + .branch { + stroke-width: ${e.strokeWidth}; + stroke: ${e.commitLineColor??e.lineColor}; + stroke-dasharray: ${s?"4 2":"2"}; + } + .commit-label { font-size: ${e.commitLabelFontSize}; fill: ${s?e.nodeBorder:e.commitLabelColor}; ${s?`font-weight:${e.noteFontWeight};`:""}} + .commit-label-bkg { font-size: ${e.commitLabelFontSize}; fill: ${s?"transparent":e.commitLabelBackground}; opacity: ${s?"":.5}; } + .tag-label { font-size: ${e.tagLabelFontSize}; fill: ${e.tagLabelColor};} + .tag-label-bkg { fill: ${s?e.mainBkg:e.tagLabelBackground}; stroke: ${s?e.nodeBorder:e.tagLabelBorder}; ${s?`filter:${e.dropShadow}`:""} } + .tag-hole { fill: ${e.textColor}; } + + .commit-merge { + stroke: ${s?e.mainBkg:e.primaryColor}; + fill: ${s?e.mainBkg:e.primaryColor}; + } + .commit-reverse { + stroke: ${s?e.mainBkg:e.primaryColor}; + fill: ${s?e.mainBkg:e.primaryColor}; + stroke-width: ${s?e.strokeWidth:3}; + } + .commit-highlight-outer { + } + .commit-highlight-inner { + stroke: ${s?e.mainBkg:e.primaryColor}; + fill: ${s?e.mainBkg:e.primaryColor}; + } + + .arrow { + /* Intentional: neo themes keep the bold 8px arrow (like classic themes); only redux-geometry themes use the thinner options.strokeWidth. */ + stroke-width: ${de.has(t)?e.strokeWidth:8}; + stroke-linecap: round; + fill: none + } + .gitTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${e.textColor}; + } +`},"getStyles"),Er=Cr,Or={parser:Ve,db:se,renderer:yr,styles:Er};export{Or as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/index.phNTaoDP.js b/packages/tempo/public/v4/assets/chunks/index.phNTaoDP.js new file mode 100644 index 00000000..86a4d38c --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/index.phNTaoDP.js @@ -0,0 +1,5 @@ +const Fa=Symbol.for("$LibraryTarget"),Wi=Symbol.for("$LibraryDiscover"),Ua=Symbol.for("$LibraryExtensible"),Wa=Symbol.for("nodejs.util.inspect.custom"),ji=Symbol.for("$LibraryLogConfig"),ja=Symbol.for("$LibraryRegistry"),Ka=Symbol.for("$LibraryRegister"),Ba=Symbol.for("$LibrarySerializerRegistry"),tt=Symbol.for("$LibraryMutable"),wn=Symbol.for("$LibraryIdentity"),Ki=Symbol.for("$LibraryUnwrapped"),G={$Target:Fa,$Discover:Wi,$Extensible:Ua,$Inspect:Wa,$LogConfig:ji,$Registry:ja,$Register:Ka,$SerializerRegistry:Ba,$Identity:wn,$Mutable:tt,$Unwrapped:Ki};function Bi(e,t,n=!0){if(e!==null&&(typeof e=="object"||typeof e=="function")&&typeof t=="symbol"&&!(t in e&&e[t]===n)&&Object.isExtensible(e))try{Object.defineProperty(e,t,{value:n,enumerable:!1,writable:!0,configurable:!0})}catch{}return e}const He=e=>Bi(e,G.$LogConfig),Ye=e=>Bi(e,G.$Extensible);function Ae(e){let t=e,n=0;const r=50;for(;t;){const s=t[G.$Target];if(!s||n>=r)break;t=s,n++}return t}function q(e,t=!1){if(!e||typeof e!="object")return[];const n=Ae(e);if(!t){const h=Reflect.ownKeys(n),f=[];for(const m of h){const p=Object.getOwnPropertyDescriptor(n,m);p&&p.enumerable&&f.push([m,n[m]])}return f}const r=[],s=50;let i=0,o=n;for(;o&&o!==Object.prototype&&i++n)}function ys(e,t=!1){return q(e,t).map(([n,r])=>r)}function he(e,t,...n){if(e===null||typeof e!="object"&&typeof e!="function")return!1;const r=Ae(e);if(!Object.hasOwn(r,t))return!1;if(n.length===0)return!0;const s=r[t];return Zi(s,n)}function Za(e,...t){if(e===null||typeof e!="object"&&typeof e!="function")return!1;const n=Ae(e);return t.length===0||t.every(r=>r in n)}function Kt(e,...t){if(e===null||typeof e!="object"&&typeof e!="function"||t.length===0)return!1;const n=Ae(e);return t.some(r=>r in n)}function Tt(e,...t){if(e===null||typeof e!="object"&&typeof e!="function")return!0;const n=Ae(e);return!t.some(r=>r in n)}function pe(e,t,...n){if(e===null||typeof e!="object"&&typeof e!="function")return!1;const r=Ae(e);if(!(t in r))return!1;if(n.length===0)return!0;const s=r[t];return Zi(s,n)}function Zi(e,t){for(let n=0;nr.length>0).reduce((r,s)=>r?.[s]??null,e)??n}function Or(e,t,n){return t?Or(e.map(t,n)):Array.from(new Set(e))}const cr=[],vr=e=>{if(e===null)return"Null";if(e===void 0)return"Undefined";const t=typeof e;if(t==="string")return"String";if(t==="number")return"Number";if(t==="boolean")return"Boolean";if(t==="bigint")return"BigInt";if(t==="symbol")return"Symbol";try{const n=t==="object"?Ae(e):e;return Object.prototype.toString.call(n).slice(8,-1)}catch{return t==="function"?"Function":"Object"}},Dr=e=>{try{const t=e?.[Symbol.toStringTag]??e?.prototype?.[Symbol.toStringTag];if(typeof t=="string")return t}catch{}},dt=(e,...t)=>{let n=e;try{n=e?.[G.$Target]??e}catch{n=e}const r=vr(n);switch(r){case"Function":try{return qa(n)?"Class":"Function"}catch{return"Function"}case"Object":{try{if("length"in n&&Object.keys(n).every(i=>i==="length"||Number.isFinite(Number(i))))return"ArrayLike";for(const i of t){const o=i.class?.[G.$Target]??i.class;if(n===o||o&&n instanceof o)return i.type}const s=globalThis[G.$Registry]??[];for(const i of[...cr,...s]){const o=i.class?.[G.$Target]??i.class;if(n===o||o&&n instanceof o)return i.type}}catch{return"Object"}return"Object"}default:return r}},xt=(e,...t)=>({type:dt(e,...t),value:e}),Ja=()=>{cr.length=0,Array.isArray(globalThis[G.$Registry])&&(globalThis[G.$Registry].length=0)},Ga=/^\s*(class\s|\[native code\])/,qa=e=>{if(typeof e!="function")return!1;const t=e?.[G.$Target]??e;if(!("prototype"in t))return!1;const n=t?.name,r=Dr(t);if(t?.[G.$Identity]||t?.prototype?.[G.$Identity]||typeof r=="string"&&r.startsWith("Temporal."))return!0;if(typeof r=="string"&&r.endsWith("Function"))return!1;if((globalThis[G.$Registry]??[]).some(i=>(i.class?.[G.$Target]??i.class)===t||n&&i.type===n||r&&i.type===r))return!0;try{const i=Function.prototype.toString.call(t);if(Ga.test(i))return!0;const o=Object.getOwnPropertyDescriptor(t,"prototype");if(o&&o.writable===!1&&!Object.isFrozen(t))return!0;const a=t.prototype;if(a&&Object.getOwnPropertyNames(a).length>2)return!0}catch{return!1}return!1},Nt=(e,t)=>{if(typeof e!="function")return;const n=Dr(e),r=t??n??e.name;r&&!["Object","Function",""].includes(r)&&(cr.some(s=>s.class===e)||cr.push({class:e,type:r}))},Me=e=>e,de=(e,...t)=>t.includes(dt(e)),an=e=>e===null||typeof e!="object"&&typeof e!="function",rt=e=>!an(e),Hi=e=>Symbol.iterator in Object(e)&&!_(e),_=e=>typeof e=="string",Ce=e=>typeof e=="string"&&e.trim().length>0,j=e=>Number.isFinite(e),Yi=/^\d+$/,Ji=/^[+-]?[0-9]+$/,bs=/^[+-]?[0-9]+n$/,Gi=/^\/.*\/$/,qi=/^https?:\/\//i,ws=/^file:\/\//i,Ss=/\s+/,Ts=/\s+/g,Vi=/[\u0300-\u036f]/g,Xi=/^[0-9a-f]+$/i,Va=/^[0-9a-f]{8}$/i,Qi=/^[A-Za-z0-9+/]*={0,2}$/,Es=/^[A-Za-z0-9_-]*$/,eo=/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,Os=e=>typeof e=="string"&&Yi.test(e),cn=e=>typeof e=="string"&&qi.test(e),Mn=e=>typeof e=="string"&&ws.test(e),Xa=e=>typeof e=="string"&&e.length>0&&e.trim().length===0,Qa=e=>typeof e=="string"&&Xi.test(e),ec=e=>typeof e=="string"&&e.length%4!==1&&(!e.includes("=")||e.length%4===0)&&Qi.test(e),tc=e=>typeof e=="string"&&e.length%4!==1&&Es.test(e),nc=e=>typeof e=="string"&&eo.test(e);function Lt(e){switch(typeof e){case"number":return Number.isFinite(e);case"bigint":return!0;case"string":{const n=e.trim();return n.length===0?!1:bs.test(n)||j(Number(n))}default:return!1}}const zt=e=>typeof e=="bigint",vs=e=>typeof e=="string"&&bs.test(e.trim()),rc=e=>typeof e=="number"?Number.isFinite(e):typeof e=="bigint",lr=e=>typeof e=="boolean",ht=e=>Array.isArray(e),to=e=>vr(e)==="Object"&&"length"in e&&Object.keys(e).every(t=>t==="length"||j(Number(t))),P=e=>de(e,"Object"),we=e=>{if(e===null||typeof e!="object")return!1;const t=Object.getPrototypeOf(e);return t===Object.prototype||t===null},Pn=e=>de(e,"Date"),kn=e=>de(e,"RegExp"),sc=e=>typeof e=="string"&&Gi.test(e),ue=e=>typeof e=="symbol",Ds=e=>typeof e=="symbol"&&Symbol.keyFor(e)!==void 0,ic=e=>{const t=typeof e;return t==="string"||t==="number"||t==="symbol"},oc=["__proto__","constructor","prototype"],it=e=>!oc.includes(e),ac=e=>e===null,ke=e=>e==null||de(e,"Void","Empty"),z=e=>e===void 0||de(e,"Void","Empty"),S=e=>e!=null&&!ke(e),ur=e=>de(e,"Class"),A=e=>de(e,"Function","AsyncFunction","GeneratorFunction","AsyncGeneratorFunction"),K=e=>typeof e=="function",Xr=e=>de(e,"Promise"),nn=e=>de(e,"Map"),rn=e=>de(e,"Set"),gt=(e,t)=>de(e,"Error")&&(t?e instanceof t:!0),cc=e=>vr(e).startsWith("Temporal.")||S(globalThis.Temporal)&&(e instanceof globalThis.Temporal.Instant||e instanceof globalThis.Temporal.ZonedDateTime||e instanceof globalThis.Temporal.PlainDate||e instanceof globalThis.Temporal.PlainTime||e instanceof globalThis.Temporal.PlainDateTime||e instanceof globalThis.Temporal.Duration||e instanceof globalThis.Temporal.PlainYearMonth||e instanceof globalThis.Temporal.PlainMonthDay),lc=e=>de(e,"Temporal.Instant")||S(globalThis.Temporal?.Instant)&&e instanceof globalThis.Temporal.Instant||S(e)&&e[Symbol.toStringTag]==="Temporal.Instant"||S(e)&&A(e.toZonedDateTimeISO)&&z(e.timeZoneId)&&z(e.timeZone),Ze=e=>de(e,"Temporal.ZonedDateTime")||S(globalThis.Temporal?.ZonedDateTime)&&e instanceof globalThis.Temporal.ZonedDateTime||S(e)&&e[Symbol.toStringTag]==="Temporal.ZonedDateTime"||S(e)&&A(e.toInstant)&&(S(e.timeZoneId)||S(e.timeZone)),uc=e=>de(e,"Temporal.PlainDate")||S(globalThis.Temporal?.PlainDate)&&e instanceof globalThis.Temporal.PlainDate||S(e)&&e[Symbol.toStringTag]==="Temporal.PlainDate"||S(e)&&A(e.toZonedDateTime)&&z(e.timeZoneId)&&z(e.timeZone)&&S(e.daysInMonth)&&z(e.hour)&&z(e.minute)&&z(e.second)&&z(e.nanosecond),fc=e=>de(e,"Temporal.PlainTime")||S(globalThis.Temporal?.PlainTime)&&e instanceof globalThis.Temporal.PlainTime||S(e)&&e[Symbol.toStringTag]==="Temporal.PlainTime"||S(e)&&A(e.toPlainDateTime)&&z(e.daysInMonth),dc=e=>de(e,"Temporal.PlainDateTime")||S(globalThis.Temporal?.PlainDateTime)&&e instanceof globalThis.Temporal.PlainDateTime||S(e)&&e[Symbol.toStringTag]==="Temporal.PlainDateTime"||S(e)&&A(e.toZonedDateTime)&&z(e.timeZoneId)&&z(e.timeZone)&&(S(e.hour)||S(e.minute)||S(e.second)||S(e.nanosecond)),no=e=>de(e,"Temporal.Duration")||S(globalThis.Temporal?.Duration)&&e instanceof globalThis.Temporal.Duration||S(e)&&e[Symbol.toStringTag]==="Temporal.Duration",Qr=e=>_(e)||no(e)||P(e)&&("years"in e||"months"in e||"weeks"in e||"days"in e||"hours"in e||"minutes"in e||"seconds"in e||"milliseconds"in e||"microseconds"in e||"nanoseconds"in e||"yy"in e||"mm"in e||"ww"in e||"dd"in e||"hh"in e||"mi"in e||"ss"in e||"ms"in e||"us"in e||"ns"in e),hc=e=>_(e)||Ze(e)||P(e)&&("year"in e||"month"in e||"day"in e||"hour"in e||"minute"in e||"second"in e||"millisecond"in e||"microsecond"in e||"nanosecond"in e||"monthCode"in e||"offset"in e||"timeZone"in e||"calendar"in e),mc=e=>de(e,"Temporal.PlainYearMonth")||S(globalThis.Temporal?.PlainYearMonth)&&e instanceof globalThis.Temporal.PlainYearMonth,pc=e=>de(e,"Temporal.PlainMonthDay")||S(globalThis.Temporal?.PlainMonthDay)&&e instanceof globalThis.Temporal.PlainMonthDay,Ar=e=>typeof Intl<"u"&&typeof Intl.Locale=="function"&&e instanceof Intl.Locale,gc=e=>de(e,"Enumify"),yc=e=>de(e,"Pledge"),bc=e=>S(e?.[G.$Extensible]),wc=e=>S(e?.[G.$Target]),Ir=e=>rt(e)&&"aborted"in e&&K(e.addEventListener)&&K(e.removeEventListener),Sc=e=>rt(e)&&"signal"in e&&K(e.abort),te=e=>ke(e)||P(e)&&Reflect.ownKeys(e).length===0||_(e)&&e.trim().length===0||typeof e=="number"&&Number.isNaN(e)||ht(e)&&e.length===0||rn(e)&&e.size===0||nn(e)&&e.size===0||ArrayBuffer.isView(e)&&e.byteLength===0||Pn(e)&&Number.isNaN(e.getTime());function As(e,t){if(!e)throw new Error(t)}function ro(e){As(_(e),`Invalid string: ${e}`)}function Tc(e){throw new Error(`Unexpected object: ${e}`)}const Ec=/"([^"]+)":/g,Oc=/,/g,vc=e=>JSON.stringify(e)?.replace(Ec,"$1: ")?.replace(Oc,", "),Dc=e=>{const t=new Set;let n=e,r=0;for(;n&&n!==Object.prototype&&r++<10;){const s=Object.getOwnPropertyDescriptors(n);for(const[i,o]of Object.entries(s))it(i)&&(o.enumerable||A(o.get))&&t.add(i);n=Object.getPrototypeOf(n)}return Array.from(t)},In=e=>{if(an(e)||A(e))return e;if(ht(e))return Me(e.map(n=>In(n)));if(Pn(e)||kn(e)||nn(e)||rn(e))return e;try{if(A(e.toJSON))return In(e.toJSON())}catch{}const t={};for(const n of Dc(e))try{t[n]=In(e[n])}catch{}return t},vt=(e,t)=>{if(e===t)return!0;if(ke(e)||ke(t))return e===t;if(dt(e)!==dt(t))return!1;if(ht(e)&&ht(t)){const n=e,r=t;return n.length===r.length&&n.every((s,i)=>vt(s,r[i]))}if(nn(e)&&nn(t)){const n=e,r=t;return n.size===r.size&&Array.from(n.keys()).every(s=>r.has(s)&&vt(n.get(s),r.get(s)))}if(rn(e)&&rn(t)){const n=e,r=t;if(n.size!==r.size)return!1;const s=Array.from(r),i=new Set;for(const o of n){const a=s.findIndex((c,h)=>!i.has(h)&&vt(o,c));if(a===-1)return!1;i.add(a)}return!0}if(P(e)&&P(t)){const n=e,r=t,s=new Set,i=A(n.keys)&&Object.getPrototypeOf(n)!==Object.prototype?Array.from(n.keys()):be(n),o=A(r.keys)&&Object.getPrototypeOf(r)!==Object.prototype?Array.from(r.keys()):be(r);return i.forEach(a=>s.add(a)),o.forEach(a=>s.add(a)),s.size!==i.length||s.size!==o.length?!1:[...s].every(a=>vt(n[a],r[a]))}return!1},Ac=(e,t=!1)=>{const n=new Set;let r=e;do Object.getOwnPropertyNames(r).map(s=>n.add(s));while(t&&(r=Object.getPrototypeOf(r)));return[...n.keys()].filter(s=>A(e[s]))};function qt(e){return q(e).reduce((t,[n,r])=>(it(n)&&S(r)&&(t[n]=r),t),{})}function Ic(e,...t){const n=t.flat(),r={};for(const s of n)s in e&&Object.defineProperty(r,s,{value:e[s],writable:!0,enumerable:!0,configurable:!0});return r}const Rc=(e,t)=>e.map(n=>n[t]),_c=(e,...t)=>Object.assign(e,...t),fr=(...e)=>e.reduce((t,n)=>(P(n)&&Object.entries(n).forEach(([r,s])=>{if(!it(r))return;const i=t[r];P(i)&&P(s)?t[r]=fr(i,s):P(s)?t[r]=fr({},s):t[r]=s}),t),{}),Cc=(e={})=>be(e).length;function Te(e){return S(e)?A(e)?e():e:t=>A(t)?t():t}Te.stringSymbol=Te();Te.symbolRegExp=Te();Te.symbolString=Te();Te.stringString=Te();const nt=e=>e?.[W.$Identity]===!0,es=Symbol.for("magmacomputing/tempo/termError"),Nc={parse:Symbol.for("magmacomputing/tempo/term/parse"),ordinal:Symbol.for("magmacomputing/tempo/term/ordinal"),step:Symbol.for("magmacomputing/tempo/term/step"),diff:Symbol.for("magmacomputing/tempo/term/diff"),bound:Symbol.for("magmacomputing/tempo/term/bound"),format:Symbol.for("magmacomputing/tempo/term/format")},Bt=Symbol.for("$Tempo"),so=Symbol.for("magmacomputing/tempo/register"),Mc=Symbol.for("magmacomputing/tempo/interpreter"),Zt=Symbol.for("magmacomputing/tempo/guard"),tr=Symbol.for("magmacomputing/tempo/errored"),Z=Symbol.for("magmacomputing/tempo/internal"),Pc=Symbol.for("magmacomputing/tempo/runtime"),kc=Symbol.for("magmacomputing/tempo/runtime/brand"),$c=Symbol.for("magmacomputing/tempo/descriptor"),xc=Symbol.for("magmacomputing/tempo/pluginType"),ot=Symbol.for("magmacomputing/tempo/setConfig"),Ht=Symbol.for("magmacomputing/tempo/setDiscovery"),Sn=Symbol.for("magmacomputing/tempo/setEvents"),Tn=Symbol.for("magmacomputing/tempo/setPeriods"),nr=Symbol.for("magmacomputing/tempo/setAliases"),wt=Symbol.for("magmacomputing/tempo/buildGuard"),rr=Symbol.for("magmacomputing/tempo/isBase"),Lc={$Tempo:Bt,$Register:so,$Interpreter:Mc,$guard:Zt,$errored:tr,$Internal:Z,$Bridge:Pc,$RuntimeBrand:kc,$Descriptor:$c,$setConfig:ot,$setDiscovery:Ht,$setEvents:Sn,$setPeriods:Tn,$setAliases:nr,$buildGuard:wt,$IsBase:rr,$PluginType:xc},W=Object.assign(Object.create(G),Lc),R=Te()({yy:Symbol("yy"),yw:Symbol("yw"),mm:Symbol("mm"),ww:Symbol("ww"),dd:Symbol("dd"),hh:Symbol("hh"),mi:Symbol("mi"),ss:Symbol("ss"),ff:Symbol("ff"),ord:Symbol("ord"),mer:Symbol("mer"),www:Symbol("www"),afx:Symbol("afx"),sfx:Symbol("sfx"),unt:Symbol("unt"),sep:Symbol("sep"),mod:Symbol("mod"),nbr:Symbol("nbr"),slk:Symbol("slk"),evt:Symbol("evt"),per:Symbol("per"),tz:Symbol("tz"),era:Symbol("era"),nth:Symbol("nth"),Rm:Symbol("romanMonth"),Ry:Symbol("romanYear"),dt:Symbol("date"),tm:Symbol("time"),hms:Symbol("hourMinuteSecond"),dmy6:Symbol("dayMonthYearShort"),mdy6:Symbol("monthDayYearShort"),ymd6:Symbol("yearMonthDayShort"),dtm:Symbol("dateTime"),tmd:Symbol("timeDate"),dmy:Symbol("dayMonthYear"),mdy:Symbol("monthDayYear"),ymd:Symbol("yearMonthDay"),off:Symbol("offset"),wkd:Symbol("weekDay"),rel:Symbol("relativeOffset"),brk:Symbol("brackets"),ye:Symbol("yearEra"),ey:Symbol("eraYearLeading"),ordWkd:Symbol("ordinalWeekday"),ordUnt:Symbol("ordinalUnit"),dRy:Symbol("dayRomanMonthYear"),Ryy:Symbol("romanYearOnly")});function Ie(e,t,n,r,s,i){function o(l){if(l!==void 0&&typeof l!="function")throw new TypeError("Function expected");return l}for(var a=r.kind,c=a==="getter"?"get":a==="setter"?"set":"value",h=!t&&e?r.static?e:e.prototype:null,f=t||(h?Object.getOwnPropertyDescriptor(h,r.name):{}),m,p=!1,b=n.length-1;b>=0;b--){var O={};for(var D in r)O[D]=D==="access"?{}:r[D];for(var D in r.access)O.access[D]=r.access[D];O.addInitializer=function(l){if(p)throw new TypeError("Cannot add initializers after decoration has completed");i.push(o(l||null))};var g=(0,n[b])(a==="accessor"?{get:f.get,set:f.set}:f[c],O);if(a==="accessor"){if(g===void 0)continue;if(g===null||typeof g!="object")throw new TypeError("Object expected");(m=o(g.get))&&(f.get=m),(m=o(g.set))&&(f.set=m),(m=o(g.init))&&s.unshift(m)}else(m=o(g))&&(a==="field"?s.unshift(m):f[c]=m)}h&&Object.defineProperty(h,r.name,f),p=!0}function Re(e,t,n){for(var r=arguments.length>2,s=0;s!ue(s)).map(s=>Number(s)).filter(s=>Number.isInteger(s)&&s>=0&&si-s).forEach(s=>r.splice(s,1));break;case"Object":(te(t)?be(r):t).forEach(s=>Reflect.deleteProperty(r,s))}return r}function Fc(e){return Object.fromEntries(q(e,!0))}const Qe=e=>Object.defineProperties({},Object.getOwnPropertyDescriptors(e)),Uc=(e={})=>Wc(e,"get"),Wc=(e={},t)=>{const n=[];let s=0,i=e.prototype||Object.getPrototypeOf(e);for(;i&&i!==Object.prototype&&++s<50;){const a=Object.getOwnPropertyDescriptors(i);Reflect.ownKeys(a).forEach(c=>{A(a[c][t])&&n.push(c)}),i=Object.getPrototypeOf(i)}let o=A(e)?e:e.constructor;for(s=0;o&&o!==Function.prototype&&o!==Object.prototype&&++s<50;){const a=Object.getOwnPropertyDescriptors(o);Reflect.ownKeys(a).forEach(c=>{A(a[c][t])&&n.push(c)}),o=Object.getPrototypeOf(o)}return Or(n)},ae={Unknown:"unknown",Browser:"browser",WebWorker:"web-worker",NodeJS:"nodejs",Deno:"deno",GoogleAppsScript:"google-apps-script"},Bn=()=>{const e=globalThis;try{if(S(e.SpreadsheetApp))return{global:e,type:ae.GoogleAppsScript};if(S(e.window?.document))return{global:e,type:ae.Browser};if(A(e.importScripts)||S(e.WorkerGlobalScope)&&e instanceof e.WorkerGlobalScope)return{global:e,type:ae.WebWorker};if(S(e.Deno))return{global:e,type:ae.Deno};if(S(e.process?.versions?.node)&&e.process?.release?.name==="node")return{global:e,type:ae.NodeJS}}catch{}return{global:e,type:ae.Unknown}},jc=new WeakSet;function $n(e,t,n=new WeakSet){const r=t instanceof WeakSet?t:t?.skip??jc;return an(e)||n.has(e)||r.has(e)||e instanceof Date||e instanceof RegExp||e instanceof Error||e instanceof Map||e instanceof Set||e instanceof Promise||e?.[Symbol.toStringTag]==="Enumify"||e[G.$Extensible]?e:(n.add(e),q(e).forEach(([s,i])=>{it(s)&&$n(i,{skip:r},n)}),Object.freeze(e))}const oi=new WeakMap;function ln(e,t={},n=!1){const{frozen:r,lock:s,appendOnly:i,onGet:o,keys:a,bind:c,skip:h}=t,f=new Set;let m,p;const b=Ae(e);s&&$n(b,h?{skip:h}:void 0),Nt(b);const O={isExtensible:D=>Reflect.isExtensible(D),getPrototypeOf:D=>Reflect.getPrototypeOf(D),setPrototypeOf:(D,g)=>{if(r)throw new TypeError("Security: Prototype mutation attempt on protected object");return Reflect.setPrototypeOf(D,g)},getOwnPropertyDescriptor:(D,g)=>{if(!(a&&!a.includes(g))){if(a){if(o&&!ue(g)&&!f.has(g)){f.add(g);try{const l=o(g,D);if(S(l))return{enumerable:!0,configurable:!0,value:l}}finally{f.delete(g)}}return{enumerable:!0,configurable:!0}}return Reflect.getOwnPropertyDescriptor(D,g)}},ownKeys:D=>{if(a)return a;if(o&&!f.has(G.$Discover)){f.add(G.$Discover);try{o(G.$Discover,D)}finally{f.delete(G.$Discover)}}return Reflect.ownKeys(D)},has:(D,g)=>a?a.includes(g):Reflect.has(D,g),deleteProperty:(D,g)=>{if(r)throw new TypeError(`Cannot delete property '${String(g)}' from a protected object.`);if(i&&Reflect.has(D,g))throw new Error(`Security: Deletion attempt on protected key '${String(g)}'`);return Reflect.deleteProperty(D,g)},defineProperty:(D,g,l)=>{if(r&&!Object.isFrozen(D))throw new TypeError(`Cannot define property '${String(g)}' on a frozen object.`);if(i&&Reflect.has(D,g))throw new Error(`Security: Mutation attempt on protected key '${String(g)}'`);return Reflect.defineProperty(D,g,l)},set:(D,g,l,u)=>{if(r&&u===p)throw new TypeError(`Cannot set property '${String(g)}' on a frozen object.`);if(i){if(Array.isArray(D)&&g==="length"&&l{if(g===G.$Target)return l===p?D:void 0;if(r&&(g===G.$Inspect||g==="toJSON")){const d=Object.getOwnPropertyDescriptor(D,g);return d&&A(d.value)?d.value:(m||(m=()=>Fc(D)),m)}if(a&&!a.includes(g))return;if(o&&!ue(g)&&!Reflect.has(D,g)&&!f.has(g)){f.add(g);try{const d=o(g,D);if(S(d))return d}finally{f.delete(g)}}const u=Reflect.get(D,g,l);if(c&&g!=="constructor"&&A(u)){const d=Object.getOwnPropertyDescriptor(D,g);if(d&&!d.configurable&&!d.writable)return u;let y=oi.get(u);y||(y=new WeakMap,oi.set(u,y));const w=y.get(D);if(w)return w;const T=u.bind(D);return y.set(D,T),T}return u}};if(n){const D=Proxy.revocable(b,O);return p=D.proxy,{proxy:D.proxy,revoke:D.revoke}}return p=new Proxy(b,O),p}function je(e,t=!0,n=t,r=new WeakSet){return ln(e,{frozen:t,lock:n,skip:r,bind:t})}function Qt(e,t,n=!0){return ln(e,{onGet:t,frozen:n})}function io(e){return ln(e,{appendOnly:!0})}function ve(e,t=new WeakSet){return ln(e,{frozen:!0,lock:!0,skip:t,bind:!0})}function Kc(e,t){const n=Array.isArray(e)?e:Reflect.ownKeys(e);return ln({},{keys:n,onGet:t,frozen:!0})}function oo(e,t,n=!0){return Qt(e,r=>_(r)&&r!=="length"&&!(r in Array.prototype)&&!j(Number(r))?t(r):void 0,n)}function ts(e){return P(e)?new Proxy(e,{get(t,n,r){if(n===G.$Target)return t;const s=Reflect.get(t,n,r);if(!A(s)||ue(n)||n==="constructor")return s;const i=Reflect.getOwnPropertyDescriptor(t,n);return i&&!i.configurable&&!i.writable?s:s.call(t)},has(t,n){return Reflect.has(t,n)},ownKeys(t){return Reflect.ownKeys(t)},getOwnPropertyDescriptor(t,n){return Reflect.getOwnPropertyDescriptor(t,n)}}):e}function ao(e,t={}){return ln(e,t,!0)}function Bc(e,t,n={}){const{proxy:r,revoke:s}=ao(e,n);try{const i=t(r);return i&&typeof i.then=="function"?Promise.resolve(i).finally(()=>s()):(s(),i)}catch(i){throw s(),i}}function xn(e,t=new WeakSet){return JSON.stringify(e,function(n,r){if(r===void 0)return"\0__undefined__\0";if(zt(r))return`\0__bigint:${r}__\0`;if(A(r))return`function:${r.name||"anonymous"}`;if(rt(r)){if(t.has(r))return"";if(t.add(r),Ar(r))return r.toString();if(nn(r))return`map:[${Array.from(r.entries()).map(s=>xn(s,t)).sort().join(",")}]`;if(rn(r))return`set:[${Array.from(r).map(s=>xn(s,t)).sort().join(",")}]`}return r})}function co(e){return function t(...n){return n.length>=e.length?e(...n):(...r)=>t(...n,...r)}}function $e(e){const t=new Map;return function(...n){const r=xn(this!==void 0&&this!==globalThis?[this,...n]:n);if(!t.has(r)){const s=e.apply(this,n);t.set(r,s)}return t.get(r)}}const ns=new WeakMap;function Rt(e){ns.delete(e)}function En(e,t){return{enumerable:!1,configurable:!1,writable:!1,value:function(...n){const r=`${String(e)},${xn(n)}`;let s=ns.get(this);if(s||(s=new Map,ns.set(this,s)),!s.has(r)){const i=t.apply(this,n);ve(i),s.set(r,i)}return s.get(r)}}}function Is(e){if(!_(e))throw new TypeError("Expected string input to stripJSONC");let t=!1,n="",r=!1,s="";const i=e.length;for(let m=0;m{try{const t=e?.prototype?.[Symbol.toStringTag]??e?.[Symbol.toStringTag];return _(t)?t:void 0}catch{return}},Jc=(e,t)=>{const n=e.startsWith("$")?e:`$${e}`;if(sr.has(n)){const r=sr.get(n),s=ai(r),i=ai(t),o=r.name||s,a=t.name||i||(e.startsWith("$")?e.slice(1):e);if(r===t||r.toString()===t.toString()||!!t[G.$Identity]&&r[G.$Identity]===t[G.$Identity]||!!t[G.$Target]&&r[G.$Target]===t[G.$Target]||!!o&&!!a&&o===a)return;throw new Error(`[registerSerializable] Collision: '${n}' is already registered with ${r.name||"anonymous constructor"}`)}sr.set(n,t)};function lo(e,t){try{return globalThis.structuredClone(e,t)}catch{return Rs(e)}}function Gc(e,t){try{return Zn(yt(e),t)}catch(n){return console.warn("Could not cloneify object: ",e),console.warn("stack: ",n.stack),e}}function qc(e,t){return Xc(t)}const uo={"%20":" ","%22":'"',"%3B":";","%3C":"<","%3E":">","%5B":"[","%5D":"]","%5E":"^","%7B":"{","%7C":"|","%7D":"}"},Vc=new RegExp(Object.keys(uo).join("|"),"gi");function ci(e){let t=encodeURI(e);return t.includes("%")&&(t=t.replace(Vc,n=>uo[n.toUpperCase()]??decodeURI(n))),t}function Xc(e){if(_(e))try{return decodeURI(e)}catch{}return e}function dn(e){return!de(e,"Function","AsyncFunction","WeakMap","WeakSet","WeakRef")}function Qc(e,t){return`{"$${e}":${t}}`}function el(e){return We(ue(e)?`${Ds(e)?"@":""}@(${e.description??""})`:e)}const tl=/^@(@)?\(([^\)]*)\)$/;function rs(e){const[t,n,r]=e.toString().match(tl)||[null,void 0,void 0];switch(!0){case ue(e):case ke(t):case(S(n)&&z(r)):return e;case S(n):return Symbol.for(r);case z(n):default:return Symbol(r)}}const nl=globalThis.crypto?.randomUUID?globalThis.crypto.randomUUID().split("-")[0]:Math.random().toString(36).slice(2,10),fo=(e,t=nl)=>{let n=2166136261,r=2654435769;const s=`${t}:${e}`;for(let i=0;i>>0).toString(16).padStart(8,"0")+(r>>>0).toString(16).padStart(8,"0")},rl=(e,t)=>{if(!_(e)||!_(t)||e.length!==t.length)return!1;let n=0;for(let r=0;rdn(i)).map(([i,o])=>`${el(i)}: ${We(o)}`).join(",")}}`;case"Array":return`[${n.value.filter(i=>dn(i)).map(i=>We(i)).join(",")}]`;case"Map":{const s=Array.from(n.value.entries()).filter(([,i])=>dn(i)).map(([i,o])=>`[${We(i)}, ${We(o)}]`).join(",");return r(`[${s}]`)}case"Set":{const s=Array.from(n.value.values()).filter(i=>dn(i)).map(i=>We(i)).join(",");return r(`[${s}]`)}case"Symbol":{const s=`${Ds(n.value)?"@":""}@(${n.value.description??""})`;return Dt?JSON.stringify(`~y${s}`):r(JSON.stringify(s))}case"RegExp":return r(We({source:n.value.source,flags:n.value.flags}));default:{const s=n.value;switch(!0){case!dn(s):return;case A(s.toJSON):return r(We(s.toJSON()));case(A(s.toString)&&s.toString!==Object.prototype.toString):{const i=s.toString();return r(i.includes('"')?i:JSON.stringify(i))}case(A(s.valueOf)&&s.valueOf!==Object.prototype.valueOf):return r(JSON.stringify(s.valueOf()));default:{const i=In(s);return rt(i)&&Object.keys(i).length>0?We(i):r(JSON.stringify(s,(o,a)=>te(o)?a:We(a)))}}}}}const sl=64,il=512;function Zn(e,t){if(!_(e))return e;const n=A(t)?{sentinel:t}:t??{};if(e.startsWith("$sig:")){const s=e.indexOf(":",5);if(s!==-1){const i=e.substring(5,s),o=e.substring(s+1);if(!_(n.secret)||!n.secret){if(console.warn("objectify: signature verification requires an explicit secret string"),n.throwOnError)throw new TypeError("objectify: signature verification requires an explicit secret string");return e}const a=fo(o,n.secret);if(!rl(i,a)){if(console.warn("objectify: signature verification failed"),n.throwOnError)throw new Error("objectify: signature verification failed");return e}e=o}else if(n.requireSigned){if(console.warn("objectify: malformed signed payload"),n.throwOnError)throw new Error("objectify: malformed signed payload");return e}}else if(n.requireSigned){if(console.warn("objectify: unsigned string rejected by requireSigned policy"),n.throwOnError)throw new Error("objectify: unsigned string rejected by requireSigned policy");return e}let r;try{r=JSON.parse(e,qc)}catch(s){return e.startsWith('"')&&e.endsWith('"')?(console.warn(`objectify.parse: -> ${e}, ${s.message}`),e):Zn(`"${e}"`,n.requireSigned?{...n,requireSigned:!1}:n)}switch(!0){case(e.startsWith("{")&&e.endsWith("}")):case(e.startsWith("[")&&e.endsWith("]")):return ss(r,n,0);default:return On(r,n)}}function ss(e,t,n=0){const r=t.maxDepth??sl;return n>=r?e:P(e)?On(q(e).filter(([s])=>it(s)).reduce((s,[i,o])=>Object.assign(s,{[rs(i)]:On(ss(o,t,n+1),t)}),{}),t):ht(e)?ys(e).map(s=>On(ss(s,t,n+1),t)):On(e,t)}function On(e,t){if(_(e)&&e.startsWith("~"))try{if(e.startsWith("~~"))return e.substring(1);if(e.startsWith("~n"))return BigInt(e.substring(2));if(e.startsWith("~t")){const i=e.substring(2),o=new Date(Lt(i)?Number(i):i);return isNaN(o.getTime())?e:o}if(e==="~u")return t.sentinel?.();if(e.startsWith("~y"))return rs(e.substring(2))}catch{return e}if(!P(e)||be(e).length!==1)return e;const[n,r]=q(e)[0];if(!String(n).startsWith("$"))return e;const s=n.substring(1);try{switch(s){case"String":case"Boolean":case"Object":case"Array":return r;case"Number":return Number(r);case"BigInt":return BigInt(r);case"Null":return null;case"Undefined":case"Empty":case"Void":return t.sentinel?.();case"Date":return new Date(r);case"RegExp":return t.allowRegExp===!1||!P(r)||!_(r.source)||r.source.length>il?e:new RegExp(r.source,r.flags);case"Symbol":return rs(r);case"Map":return ht(r)?new Map(r):e;case"Set":return ht(r)?new Set(r):e;default:{if(t.allowClasses===!1||t.allowedClasses&&!(t.allowedClasses instanceof Set?t.allowedClasses.has(n)||t.allowedClasses.has(s):t.allowedClasses.includes(n)||t.allowedClasses.includes(s)))return e;const i=sr.get(n);return i?Reflect.construct(i,[r]):(console.warn(`objectify: dont know how to deserialize '${s}'`),e)}}}catch{return e}}function Hn(e,t){return Dr(e)??(z(t)?e.name||void 0:String(t))}function ho(e,t,n,r,s){const i=t||"Anonymous";n(()=>{const f=Symbol.metadata,m=s??(f?e[f]:void 0),p=[...e[tt]??e.$Mutable??[],...e?.prototype?.[tt]??e?.prototype?.$Mutable??[],...m?.[tt]??m?.$Mutable??[]];ol(e,e,p)});const o=K(e)?Function.prototype.toString.call(e):"",a=o.includes("#")||o.includes("WeakMap")||o.includes("__private")||o.includes("privateMap");if(e[Ki]===!0||e.raw===!0||e[tt]==="unwrapped"||a)return t&&Nt(e,t),e;const h={[i]:class extends e{constructor(...f){return super(...f),r(this)}}}[i];return t&&Nt(h,t),h}function li(e,t){return Array.isArray(t)?t.some(n=>{if(_(n)||ue(n))return n===e;if(pe(n,"name")){if(n.name!==e)return!1;const r=n.condition;return K(r)?!!r():!!(r??!0)}return!1}):!1}function ol(e,t,n){const r=i=>{Reflect.ownKeys(i).forEach(o=>{if(o==="prototype"||o==="length"||o==="name"||o==="constructor"||li(o,n))return;const a=Object.getOwnPropertyDescriptor(i,o);if(!a)return;const c={};a.configurable&&(c.configurable=!1),"writable"in a&&a.writable&&(c.writable=!1),Object.keys(c).length&&Object.defineProperty(i,o,{...a,...c})})};r(e),r(t);const s=i=>{rt(i)&&Reflect.ownKeys(i).forEach(o=>{if(o==="constructor"||li(o,n))return;const a=Object.getOwnPropertyDescriptor(i,o);if(!a)return;const c={};a.configurable&&(c.configurable=!1),"writable"in a&&a.writable&&(c.writable=!1),Object.keys(c).length&&Object.defineProperty(i,o,{...a,...c})})};s(e.prototype),s(t.prototype)}function al(e,{kind:t,name:n,addInitializer:r,metadata:s}){const i=Hn(e,n);if(t==="class")return ho(e,i,r,ve,s);throw new Error(`@Securable decorating unknown 'kind': ${t} (${n})`)}function Ft(e,{kind:t,name:n,addInitializer:r,metadata:s}){const i=Hn(e,n);if(t==="class")return ho(e,i,r,o=>(Object.freeze(o),o),s);throw new Error(`@Immutable decorating unknown 'kind': ${t} (${n})`)}function _s(e,{kind:t,name:n,addInitializer:r}){const s=Hn(e,n);if(s&&Nt(e,s),t==="class")return s&&r(()=>Jc(s,e)),e;throw new Error(`@Serializable decorating unknown 'kind': ${t} (${n})`)}function cl(e,{kind:t,name:n}){const r=Hn(e,n);if(t==="class"){const s=r||"Anonymous",i={[s]:class extends e{constructor(...o){throw new TypeError(`${s} is not a constructor`)}}}[s];return r&&(Nt(e,`${r}_original`),Nt(i,r)),i}else throw new Error(`@Static decorating unknown 'kind': ${t} (${n})`)}function _e(e,t){const n=(r,s,i)=>{const o=r.prototype,a=s??Hn(r,i);if(a&&(o&&!he(o,Symbol.toStringTag)&&Object.defineProperty(o,Symbol.toStringTag,{value:a,configurable:!0,writable:!1,enumerable:!1}),!r.name||r.name!==a))try{Object.defineProperty(r,"name",{value:a,configurable:!0,writable:!1,enumerable:!1})}catch{}return r};return K(e)&&t?.kind==="class"?n(e,void 0,t.name):(r,s)=>n(r,_(e)?e:void 0,s?.name)}function ll(e,t){const n=(r,s)=>{let i,o;const a=r.name||"Singleton",c={[a]:class extends r{constructor(...h){if(i){if(s?.allowArgMismatch!==!0&&o){const f=o;if(h.length!==f.length||h.some((p,b)=>p!==f[b]))throw new Error(`[Singleton] Argument mismatch on subsequent instantiation of '${a}'`)}return i}return super(...h),o=h,i=this,this}}}[a];return Object.defineProperty(c,"instance",{get:()=>i,configurable:!0,enumerable:!1}),c};return K(e)&&t?.kind==="class"?n(e):(r,s)=>n(r,e)}function mo(e,t){const n=(r,s)=>{const i={name:r.name,condition:K(s)?s:()=>s??!0};if(r.metadata){let o=r.metadata[tt];Array.isArray(o)||(o=[],Object.defineProperty(r.metadata,tt,{value:o,writable:!0,configurable:!0})),o.push(i)}r.addInitializer(function(){const o=[this];this&&K(this.constructor)&&this.constructor!==this&&o.push(this.constructor);for(const a of o){let c=a[tt];Array.isArray(c)||(c=[],Object.defineProperty(a,tt,{value:c,writable:!0,configurable:!0})),c.push(i)}})};return pe(t,"kind")?n(t,!0):(r,s)=>{n(s,e)}}const ul="Enumify",Se=ve(Object.create(null,{keys:En("keys",function(){return q(this,!0).map(([e])=>e)}),values:En("values",function(){return q(this,!0).map(([e,t])=>t)}),entries:En("entries",function(){return q(this,!0).map(([e,t])=>Object.freeze([e,t]))}),invert:En("invert",function(){return Object.fromEntries(Se.entries.call(this).map(([e,t])=>[t,e]))}),has:Ke(function(e){return Se.keys.call(this).includes(e)}),hasOwn:Ke(function(e){return Object.prototype.hasOwnProperty.call(this,e)}),get:Ke(function(e){return Se.has.call(this,e)?this[e]:void 0}),count:Ke(function(){return Se.keys.call(this).length}),includes:Ke(function(e){return Se.values.call(this).includes(e)}),keyOf:Ke(function(e){return Se.invert.call(this)[e]}),extend:Ke(function(e,t){return Q.call(this,e,t)}),forEach:Ke(function(e,t){Se.entries.call(this).forEach((n,r)=>e.call(t,n,r,this))}),filter:Ke(function(e,t){return Q(Se.entries.call(this).reduce((n,r,s)=>e.call(t,r,s,this)?Object.assign(n,{[r[0]]:r[1]}):n,{}))}),map:Ke(function(e,t){return Q(Se.entries.call(this).reduce((n,r,s)=>Object.assign(n,{[r[0]]:e.call(t,r,s,this)}),{}))}),[Symbol.iterator]:Ke(function*(){for(const e of Se.entries.call(this))yield e}),[Symbol.toStringTag]:{enumerable:!1,configurable:!1,writable:!1,value:ul}}));function Ke(e){return{enumerable:!1,configurable:!1,writable:!1,value:e}}const fl={has(e,t){return Se.has.call(e,t)},hasOwn(e,t){return Object.prototype.hasOwnProperty.call(e,t)},get(e,t){return Se.get.call(e,t)},keys(e){return Se.keys.call(e)},values(e){return Se.values.call(e)},entries(e){return Se.entries.call(e)},keyOf(e,t){return Se.keyOf.call(e,t)},includes(e,t){return Se.includes.call(e,t)},count(e){return Se.count.call(e)},invert(e){return Se.invert.call(e)},extend(e,t,n){return Q.call(e,t,n)},[Symbol.hasInstance](e){return e!=null&&(e[Symbol.toStringTag]==="Enumify"||A(e?.has))}},ie=Object.freeze(Object.assign(Object.create(null),fl));function Q(e,t=!0){const r=dt(this)!=="Module"&&pe(this,"has",A)?this:Se,s=xt(e),i=Object.create(r);switch(s.type){case"Enumify":case"Object":Object.defineProperties(i,Object.getOwnPropertyDescriptors(s.value));break;case"Array":s.value.forEach((o,a)=>{if(Lt(o))throw new TypeError(`Enumify: numeric keys are not supported ("${o}").`);if(Object.prototype.hasOwnProperty.call(i,o))throw new TypeError(`Enumify: duplicate member key "${o}" found in array definition.`);Object.defineProperty(i,o,{value:a,enumerable:!0,writable:!1,configurable:!1})});break;default:throw new TypeError(`Enumify: invalid argument type: ${s.type}`)}return je(i,!0,t)}(()=>{let e=[_s,_e("Enumify")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}constructor(s){return Q(s)}},r})();const po=Q({Spring:"spring",Summer:"summer",Autumn:"autumn",Winter:"winter"},!1),go=Te()(Q({North:"north",South:"south",East:"east",West:"west",Equator:"equator"},!1)),Be={NUMBER:{zero:0,one:1,two:2,three:3,four:4,five:5,six:6,seven:7,eight:8,nine:9,ten:10},ORDINAL:{current:0,first:1,second:2,third:3,fourth:4,fifth:5,sixth:6,seventh:7,eighth:8,ninth:9,tenth:10,last:-1},DURATION:{year:31536e3,month:2628e3,week:604800,day:86400,hour:3600,minute:60,second:1,millisecond:.001,microsecond:1e-6,nanosecond:1e-9},TIMEZONE:{utc:"UTC",gmt:"UTC",est:"America/New_York",edt:"America/New_York",cst:"America/Chicago",cdt:"America/Chicago",mst:"America/Denver",mdt:"America/Denver",pst:"America/Los_Angeles",pdt:"America/Los_Angeles",aest:"Australia/Sydney",aedt:"Australia/Sydney",acst:"Australia/Adelaide",acdt:"Australia/Adelaide",awst:"Australia/Perth",nzt:"Pacific/Auckland",nzst:"Pacific/Auckland",nzdt:"Pacific/Auckland",cet:"Europe/Paris",cest:"Europe/Paris",eet:"Europe/Helsinki",eest:"Europe/Helsinki",ist:"Asia/Kolkata",npt:"Asia/Kathmandu",jst:"Asia/Tokyo"},DURATIONS:{years:31536e6,months:2628e6,weeks:6048e5,days:864e5,hours:36e5,minutes:6e4,seconds:1e3,milliseconds:1,microseconds:.001,nanoseconds:1e-6},FORMAT:{display:"{www}, {dd} {mmm} {yyyy}",weekDate:"{www}, {yyyy}-{mmm}-{dd}",weekTime:"{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}",weekStamp:"{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}",dayMonth:"{dd}-{mmm}",dayDate:"{dd}-{mmm}-{yyyy}",dayTime:"{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}",logStamp:"{ymd}T{hms}.{ff}",sortTime:"{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}",yearWeek:"{yw}{wy}",yearMonth:"{yyyy}{mm}",yearMonthDay:"{ymd}",date:"{yyyy}-{mm}-{dd}",time:"{hh}:{mi}:{ss}"},LIMIT:{get maxTempo(){return Temporal.Instant.from("9999-12-31T23:59:59.999999999+00:00").epochNanoseconds},get minTempo(){return Temporal.Instant.from("1000-01-01T00:00+00:00").epochNanoseconds}},MONTH_DAY:{locales:["en-US","en-AS"],layouts:[["dayMonthYearShort","monthDayYearShort"],["dayMonthYear","monthDayYear"]],timezones:{"en-US":["America/Adak","America/Anchorage","America/Boise","America/Chicago","America/Denver","America/Detroit","America/Indiana/Indianapolis","America/Indiana/Knox","America/Indiana/Marengo","America/Indiana/Petersburg","America/Indiana/Tell_City","America/Indiana/Vevay","America/Indiana/Vincennes","America/Indiana/Winamac","America/Indianapolis","America/Juneau","America/Kentucky/Louisville","America/Kentucky/Monticello","America/Los_Angeles","America/Louisville","America/Menominee","America/Metlakatla","America/New_York","America/Nome","America/North_Dakota/Beulah","America/North_Dakota/Center","America/North_Dakota/New_Salem","America/Phoenix","America/Sitka","America/Yakutat","Pacific/Honolulu","US/Aleutian","US/Alaska","US/Arizona","US/Central","US/Eastern","US/Mountain","US/Pacific"],"en-AS":["Pacific/Pago_Pago"]}},LOCALE:{}},ce={NUMBER:Qe(Be.NUMBER),ORDINAL:Qe(Be.ORDINAL),DURATION:Qe(Be.DURATION),TIMEZONE:Qe(Be.TIMEZONE),DURATIONS:Qe(Be.DURATIONS),FORMAT:Qe(Be.FORMAT),LIMIT:Qe(Be.LIMIT),MONTH_DAY:Qe(Be.MONTH_DAY),LOCALE:Qe(Be.LOCALE)},bt=e=>Object.defineProperty(e,W.$Extensible,{value:!0,enumerable:!1,configurable:!1,writable:!1});bt(ce.NUMBER);bt(ce.ORDINAL);bt(ce.FORMAT);bt(ce.TIMEZONE);bt(ce.DURATION);bt(ce.DURATIONS);bt(ce.MONTH_DAY);bt(ce.LOCALE);const yo=Q(["All","Mon","Tue","Wed","Thu","Fri","Sat","Sun"]),bo=Q(["Everyday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"]),wo=Q(["All","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]),So=Q(["Every","January","February","March","April","May","June","July","August","September","October","November","December"]),_r=Te()(Q(ce.NUMBER,!1)),Cr=Te()(Q(ce.ORDINAL,!1)),Nr=Te()(je(ce.TIMEZONE,!0,!1)),Cs=Q(ce.DURATION,!1),Ns=Q(ce.DURATIONS,!1),Mr=Te()(Q(ce.FORMAT,!1)),Ms=je(ce.LIMIT,!0,!1),Pr=je(ce.MONTH_DAY,!0,!1),kr=je(ce.LOCALE,!0,!0),To=["yy","mm","wy","ww","woy","dd","hh","mi","ss","ms","us","ns"],Eo=Q({yy:"year",mm:"month",wy:"week",ww:"week",woy:"week",dd:"day",hh:"hour",mi:"minute",ss:"second",ms:"millisecond",us:"microsecond",ns:"nanosecond"},!1),dl=[...To,"yw","yow","isoYear","isoyear","isoWeek","isoweek","event","period","clock","time","date","start","mid","end"],Oo=Q(dl,!1),hl=["value","timeZoneId","calendarId","monthCode","offset","timeZone","calendar","year","month","day","hour","minute","second",...To],vo=Q(hl,!1),ml=["config","parse","value","intl","localeInfo","store","discovery","debug","catch","silent","timeZone","calendar","locale","sphere","geo","latitude","lat","longitude","lng","timeStamp","registry","plugins","extends","cache"],Do=Q(ml,!1),Ps=Q({Auto:"auto",Strict:"strict",Defer:"defer"},!1),Ao=Q({Off:!1,On:!0,Refresh:"refresh"},!1),pl=["monthDay","planner","layoutOrder","preFilter","mode","pivot","snippet","layout","event","period","anchor"],Io=Q(pl,!1),gl=["options","extends","plugins","terms","timeZones","monthDay","intl","planner","numbers","ordinals","formats","ignore"],Yt=Q(gl,!1),Rn={NUMBER:_r,ORDINAL:Cr,DURATION:Cs,TIMEZONE:Nr,DURATIONS:Ns,FORMAT:Mr,LIMIT:Ms,MONTH_DAY:Pr,LOCALE:kr},F={SEASON:po,COMPASS:go,WEEKDAY:yo,WEEKDAYS:bo,MONTH:wo,MONTHS:So,NUMBER:_r,ORDINAL:Cr,TIMEZONE:Nr,DURATION:Cs,DURATIONS:Ns,FORMAT:Mr,LIMIT:Ms,ELEMENT:Eo,MUTATION:Oo,ZONED_DATE_TIME:vo,CONFIG:Do,MODE:Ps,CACHE:Ao,PARSE:Io,MONTH_DAY:Pr,LOCALE:kr,Enum:ie},De=Q(["Off","Error","Warn","Info","Debug","Trace"]),Le={Off:"off",Log:"log",Info:"info",Warn:"warn",Debug:"debug",Trace:"trace",Error:"error"},Ro={[Le.Off]:De.Off,[Le.Error]:De.Error,[Le.Warn]:De.Warn,[Le.Info]:De.Info,[Le.Log]:De.Info,[Le.Debug]:De.Debug,[Le.Trace]:De.Trace};function dr(e,t=De.Info){return j(e)?e>=De.Off&&e<=De.Trace?e:t:_(e)?Ro[e.toLowerCase()]??t:t}let Yn=(()=>{let e=[_e("Logger")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e;level;constructor(s,i=De.Info){this.#e=s.startsWith("[")?s:`[${s}]`,this.level=i}#t(s,...i){let o;if(i.length>0&&P(i[0]))try{i[0][G.$LogConfig]&&(o=i.shift())}catch{}let a=this.level;if(o){if(o.silent===!0)return;o.debug!==void 0&&(a=dr(o.debug,a))}if(a===De.Off||(Ro[s]??0)>a)return;const h=i.map(f=>{if(gt(f))return f.message;if(P(f))try{const m=f.constructor?.name??"Object";if(m==="Object"){const p=Object.keys(f);return`{ ${p.slice(0,3).join(", ")}${p.length>3?`, ... (+${p.length-3} more)`:""} }`}return`[${m}]`}catch{return"[Object]"}return String(f)}).filter(f=>!te(f)).join(" ");te(h)||console[s](`${this.#e} ${h}`)}log=(...s)=>this.#t(Le.Log,...s);info=(...s)=>this.#t(Le.Info,...s);warn=(...s)=>this.#t(Le.Warn,...s);debug=(...s)=>this.#t(Le.Debug,...s);trace=(...s)=>this.#t(Le.Trace,...s);error=(...s)=>this.#t(Le.Error,...s)},r})();function yl(e,t={}){const n=_(e)?new Error(e):e;if(t.silent||(t.logger?t.logger.error(n):console.error("[Boundary]",n)),!t.catch)throw n}const bl=/\t/g,wl=/(\r\n|\n|\r)/g,Sl=/\s{2,}/g,Tl=/\w\S*/g,El=/ /g,ui=/\$\{(\d+)\}/g,Ol=/%[sj]/g,vl=/\${(.*?)}/g;function ks(e,t){return(t?e.toString().replace(t,""):e.toString()).replace(bl," ").replace(wl," ").replace(Sl," ").trim()}function _o(...e){return e.flat().map(t=>t.replace(Tl,n=>n.charAt(0).toUpperCase()+n.substring(1).toLowerCase())).join(" ")}function Dl(e,t){try{return e.charAt(0).toLocaleUpperCase(t)+e.slice(1).toLocaleLowerCase(t)}catch{return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()}}const Al=/[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g,Il=e=>{let[t,...n]=e.match(Al)??[""];return Lt(t)&&n.length>0&&(t=n[0],n.splice(0,1)),t??="",(e.startsWith("_")?"_":"")+t.toLocaleLowerCase()+_o(...n).replace(El,"")},Rl=16,fi="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",_l=(e=36)=>{const t=globalThis.crypto;if(t&&K(t.getRandomValues)){const r=new Uint8Array(e),s=65536;for(let o=0;o`\${${r++}}`);const s=Array.from(n.matchAll(ui)).map(i=>Number(i[1]));return t.forEach((i,o)=>{s.includes(o)||(n+=`${n.length===0?"":n.endsWith(":")?" ":", "}\${${o}}`)}),n.replace(ui,(i,o)=>t[o]?.toString?.()||yt(t[o]))}const Nl=(e,t,n=t+"s")=>{const r=(s,i,o=i+"s")=>[1,-1].includes(Number(s))?i:o;return P(e)?(s,i)=>r(s,i,e[i]):r(e,t,n)},Ml=e=>e.endsWith("s")&&e.length>3?e.slice(0,-1):e,Pl=e=>t=>String(e).replace(vl,(n,r)=>{const s=t[r.trim()];return s!==void 0?String(s):""}),kl=e=>_(e)?e.toLowerCase().trim():e,$l=e=>_(e)?e.toUpperCase().trim():e,xl=(e,t,n)=>(ro(e),As(e.length>=t&&e.length<=(n??t),"string length is not between specified min and max"),e),Jt=(e=0,t=2,n)=>e.toString().padStart(t,(n??(Lt(e)?"0":" ")).toString()),Ll=(e,t=6)=>(Lt(e)?Number(e).toFixed(2):e?.toString()??"").padStart(t," "),Co=(e,t=4,n="=")=>{const r=String(e??""),s=r.length%t;return s===0?r:r.padEnd(r.length+(t-s),String(n))},zl=e=>e.map(t=>String.fromCharCode(t)).join(""),Fl=e=>e.split("").map(t=>t.charCodeAt(0));function U(e=[],t){const n=r=>z(t)||S(r)?r:lo(t);return to(e)||Hi(e)&&!_(e)?Array.from(e,n):[e]}function Ln(e){return ke(e)?"":zt(e)?e.toString()+"n":yt(e)}function Ul(e,t,n=!1){if(_(e)){const r=n?ks(e):e.trim();if(r.length>0)return r}return t}function Wl(e,t,n){return t(e)?e:n}function $s(e,t){if(j(e))return e;if(zt(e)){const n=Number(e);return j(n)?n:t}if(_(e)){const n=e.trim();if(n.length>0){const r=Number(n);if(j(r))return r}}return t}const jl=/^[+-]/,Kl=BigInt(Number.MAX_SAFE_INTEGER),Bl=BigInt(Number.MIN_SAFE_INTEGER);function No(e){return String(e).trim().replace(jl,"")}function Mo(e){if(zt(e))return e;if(j(e))return BigInt(Math.trunc(e));const t=String(e).trim(),n=No(e);if(n.length===0)return BigInt(t);const r=t.startsWith("-")?-1n:1n,s=vs(n)?-1:void 0;return r*BigInt(n.slice(0,s))}function Kr(e){return e>Kl||e{if(zt(e))return Kr(e);if(j(e))return Number.isInteger(e)?Kr(BigInt(e)):e;const n=No(e);return Lt(e)&&(!n.startsWith("0")||t)?vs(n)||Ji.test(n)?Kr(Mo(e)):$s(e,0):e},Hl=e=>e??0,Yl=e=>e??"",is=(e,t)=>e??t;function Mt(e){if(gt(e))return e;const t=new Error(pe(e,"message",_)?e.message:String(e));return P(e)&&(t.name=pe(e,"name","string")?e.name:"Error",pe(e,"code","string","number")&&(t.code=e.code),pe(e,"stack","string")&&(t.stack=e.stack)),t}if(typeof globalThis.Temporal>"u")throw new Error("Temporal API is not available. Node 20+ with a polyfill (e.g. @js-temporal/polyfill) is highly recommended. Native Temporal is fully reliable only on Node 26+ (while Node 22 may have instabilities).");try{if(typeof Temporal.Now.zonedDateTimeISO=="function"&&typeof Temporal.Now.zonedDateTimeISO().add!="function")throw new Error("Incomplete Temporal implementation")}catch(e){const t=Mt(e);if(console.warn("Tempo: Native Temporal implementation appears incomplete. Consider loading a polyfill.",t),t.message!=="Incomplete Temporal implementation")throw t}const qn=new FinalizationRegistry(e=>{try{A(e)&&e()}catch(t){console.error("Finalizer callback error:",t)}});let zn=(()=>{let e=[_e("Finalizer")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e;constructor(s){this.#e=s}get isFinalizer(){return!0}register(s,i,o){const a=o??Object.create(null),c=this.#e;qn.register(s,()=>{c(i)},a)}unregister(s){return qn.unregister(s)}static register(s,i,o){const a=o??Object.create(null);return qn.register(s,i,a),()=>qn.unregister(a)}},r})(),Pt=(()=>{let e=[_e("WeakCache")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e=new Map;#t;constructor(){this.#t=new zn(s=>{const i=this.#e.get(s.key);i&&i.token===s.token&&this.#e.delete(s.key)})}get isWeakCache(){return!0}set(s,i){this.delete(s);const o=Object.create(null);return this.#e.set(s,{ref:new WeakRef(i),token:o}),this.#t.register(i,{key:s,token:o},o),this}get(s){const i=this.#e.get(s);if(z(i))return;const o=i.ref.deref();if(z(o)){this.#t.unregister(i.token),this.#e.delete(s);return}return o}has(s){return S(this.get(s))}getOrSet(s,i){const o=this.get(s);if(S(o))return o;const a=i(s);return this.set(s,a),a}delete(s){const i=this.#e.get(s);return S(i)?(this.#e.delete(s),this.#t.unregister(i.token),!0):!1}clear(){for(const s of this.#e.values())this.#t.unregister(s.token);this.#e.clear()}},r})();const di=new Map;function qe(){return Temporal.Now.instant()}function ko(e=Intl.DateTimeFormat().resolvedOptions().timeZone){return Temporal.Now.plainDateISO(e)}function Jl(){return Math.trunc(qe().epochMilliseconds/1e3)}function Gl(){return qe().epochNanoseconds}function xs(e,t=2024){const n=`${e}::${t}`;let r=di.get(n);if(z(r)){const s=Temporal.ZonedDateTime.from({year:t,month:1,day:1,hour:0,minute:0,second:0,timeZone:e}).offsetNanoseconds,i=Temporal.ZonedDateTime.from({year:t,month:7,day:1,hour:0,minute:0,second:0,timeZone:e}).offsetNanoseconds;r=Object.freeze({jan:s,jul:i}),di.set(n,r)}return r}function ql(e,t=Intl.DateTimeFormat().resolvedOptions().timeZone){const n=_(e)?Ls(e,t):e??qe().toZonedDateTimeISO(t),{jan:r,jul:s}=xs(n.timeZoneId,n.year);return n.offsetNanoseconds!==Math.min(r,s)}function Vl(e){const t=[["hours","minutes",60],["minutes","seconds",60],["seconds","milliseconds",1e3],["milliseconds","microseconds",1e3],["microseconds","nanoseconds",1e3]];for(const[n,r,s]of t){const i=e[n];if(j(i)&&i!==Math.trunc(i)){const o=Math.trunc(i),a=i-o;o?e[n]=o:delete e[n],e[r]=(e[r]??0)+Math.round(a*s)}}return e}const Xl=/^(\d{4}-\d{2}-\d{2})\s+(?=\d{2}:\d{2})/,Ql=/\s+(?=[Zz]|[+-]\d{2}|\[)/,hi=/\[!?u-ca=[^\]]+\]/i,eu=/\[(?!!?u-ca=)[^\]]+\]/i,tu=/Z$|[+-]\d{2}(:?\d{2})?$/i,nu=/^UTC([+-])(\d{1,2})(?::(\d{2}))?$/i,ru=new Pt,su=new Pt;function Ls(e,t="UTC"){if(!_(e))return Temporal.ZonedDateTime.from(e);const n=`${e}::${t}`;return ru.getOrSet(n,()=>{const r=e.trim().replace(Xl,"$1T").replace(Ql,"");return eu.test(r)?Temporal.ZonedDateTime.from(r):hi.test(r)?Temporal.ZonedDateTime.from(r.replace(hi,`[${t}]$&`)):r.includes("T")&&tu.test(r)?Temporal.Instant.from(r).toZonedDateTimeISO(t):Temporal.ZonedDateTime.from(`${r}[${t}]`)})}function iu(e){return _(e)?su.getOrSet(e,()=>Temporal.PlainDate.from(e)):Temporal.PlainDate.from(e)}function ou(e){return Temporal.Instant.fromEpochNanoseconds(e)}function en(e,t){const n=Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC";let r,s;if(Ze(e)){const f=e;r=f.timeZoneId??f.timeZone?.id??f.timeZone,s=S(t)?t:f.calendarId??f.calendar?.id??f.calendar}else r=e,s=t;const i=f=>_(f)?f:Ze(f)?i(f.timeZoneId??f.timeZone?.id??f.timeZone):P(f)?String(f.id??f.timeZoneId??f.calendarId??""):String(f??""),o=i(r),a=i(s),c=Ce(o)&&o!=="[object Object]"&&o!=="undefined"?o:n,h=Ce(a)&&a!=="[object Object]"&&a!=="undefined"?a:"iso8601";return[c,h]}function zs(e){const t=nu.exec(e);if(!t)return e;const[,n,r,s]=t,i=Number(r),o=Number(s??"0");return i>14||o>59||n==="+"&&i===14&&o!==0||n==="-"&&i>12?e:`${n}${r.padStart(2,"0")}:${s??"00"}`}function au(e,t=75,n){if(e>=100||e<0||!Number.isFinite(e))return e;const s=(j(n)?n:n?n.year:ko().year)-t;let i=Math.floor(s/100)*100+e;return itypeof Intl<"u"&&(!e||he(Intl,e,K)),Ut=e=>{if(Ar(e)&&(e=e.toString()),!_(e))return;const t=e.trim();if(te(t))return;const n=t.split(uu)[0];if(!te(n))return n.replace(lu,"-")},mi=$e((e,t)=>new Intl.RelativeTimeFormat(Ut(e),t)),pi=$e((e,t)=>new Intl.ListFormat(Ut(e),t)),At=$e((e,t)=>new Intl.DateTimeFormat(Ut(e),t)),du=$e((e,t)=>{try{return new Intl.PluralRules(Ut(e),t)}catch{return Me({select:()=>"other"})}}),os=$e((e,t)=>new Intl.NumberFormat(Ut(e),t));function hn(e,t,n){if(e){if(K(e[t]))return e[t]();if(n&&n in e)return e[n]}}const hu=new Set(["US","CA","MX","BR","IL","JP","TW","HK","MO","PH","SG","TH","IN","KR","CO","PE","VE","ZA"]),mu=new Set(["SA","AF","BH","DJ","DZ","EG","IQ","IR","JO","KW","LY","OM","QA","SD","SY","YE"]),pu=new Set(["MV"]),gu=new Set(["SA","BH","DJ","DZ","EG","IQ","JO","KW","LY","OM","QA","SD","SY","YE"]),yu=new Set(["AD","AN","AT","AX","BE","BG","CH","CZ","DE","DK","EE","ES","FI","FJ","FO","FR","GB","GF","GG","GI","GP","GR","HU","IE","IM","IS","IT","JE","LI","LT","LU","LV","MC","MQ","NL","NO","PL","PT","RE","RO","RU","SE","SI","SJ","SK","SM","VA","YT"]),bu=new Set(["ar","he","fa","ur","yi","ps","sd","ug","ckb"]),wu=new Set(["Arab","Hebr","Thaa","Syrc","Mand","Samr","Nkoo"]),gi=Object.freeze([6,7]),Su=Object.freeze([5,6]),Tu=Object.freeze([5]),Eu=Object.freeze([4,5]);function Ou(e){return e?pu.has(e)?5:mu.has(e)?6:hu.has(e)?7:1:1}function vu(e){return e?e==="IR"?Tu:e==="AF"?Eu:gu.has(e)?Su:gi:gi}function Du(e){return e&&yu.has(e)?4:1}function Au(e,t){const n=e?.script??(K(e?.maximize)?e.maximize().script:void 0);return n&&wu.has(n)||t&&bu.has(t)?"rtl":"ltr"}const st=$e(e=>{if(Ar(e))return e;if(Fn("Locale"))try{const t=Ut(e);return new Intl.Locale(t||"en-US")}catch{return}}),$o=$e(e=>{const t=st(e)??st("en-US"),n=t?.baseName??xo(e)??"en-US",r=t?.language??n.split("-")[0]?.toLowerCase(),s=[];for(const T of n.split("-").slice(1)){if(T.length===1)break;s.push(T)}const i=t?.region??(K(t?.maximize)?t.maximize().region:void 0)??s.find(T=>fu.test(T))?.toUpperCase(),o=t?.script??(K(t?.maximize)?t.maximize().script:void 0),a=hn(t,"getWeekInfo","weekInfo"),c=a?.firstDay??Ou(i),h=a?.minimalDays??Du(i),f=Array.isArray(a?.weekend)?Object.freeze([...a.weekend]):vu(i),p=hn(t,"getHourCycles","hourCycles")??t?.hourCycle??(Fn("DateTimeFormat")?At(n,{hour:"numeric"}).resolvedOptions().hourCycle:void 0),b=Array.isArray(p)&&p.length>0?Object.freeze([...p]):_(p)?Object.freeze([p]):Object.freeze(["h23"]),O=hn(t,"getTextInfo","textInfo"),D=O?.direction==="rtl"||O?.direction==="ltr"?O.direction:Au(t,r),l=hn(t,"getNumberingSystems","numberingSystems")??t?.numberingSystem??(Fn("NumberFormat")?os(n).resolvedOptions().numberingSystem:void 0),u=Array.isArray(l)&&l.length>0?Object.freeze([...l]):_(l)?Object.freeze([l]):Object.freeze(["latn"]),d=hn(t,"getTimeZones","timeZones"),y=Array.isArray(d)&&d.length>0?Object.freeze([...d]):Object.freeze([]),w=Object.freeze({firstDay:c,minimalDays:h,weekend:f});return Object.freeze({locale:t,baseName:n,language:r,region:i,script:o,weekInfo:w,firstDay:c,minimalDays:h,weekend:f,hourCycle:b[0],hourCycles:b,direction:D,numberingSystem:u[0],numberingSystems:u,timeZones:y})}),yi=$e((e,t)=>{const n=$o(e),r=st(e)??st("en-US"),s=r?.toString()??n.baseName,i=t?en(t)[0]:void 0;return Object.freeze({info:n,locale:r,relativeTime(o,a,c){return mi(s,c).format(o,a)},list(o,a){return pi(s,a).format(Array.from(o))},number(o,a){return os(s,a).format(o)},plural(o,a){return du(s,a).select(o)},dtf(o){const a=i&&!o?.timeZone?{...o,timeZone:i}:o;return At(s,a)},rtf(o){return mi(s,o)},lf(o){return pi(s,o)},nf(o){return os(s,o)},firstDay:n.firstDay,minimalDays:n.minimalDays,weekend:n.weekend,direction:n.direction,hourCycle:n.hourCycle,hourCycles:n.hourCycles,numberingSystem:n.numberingSystem,numberingSystems:n.numberingSystems,region:n.region,script:n.script,language:n.language,timeZones:n.timeZones,baseName:n.baseName,weekInfo:n.weekInfo})}),Iu=Object.freeze({locale:"en-US",calendar:"iso8601",numberingSystem:"latn",timeZone:"UTC"}),lt=$e(()=>Fn("DateTimeFormat")?Object.freeze(At().resolvedOptions()):Iu),xo=$e(e=>{const t=Ut(e);if(t){if(Fn("getCanonicalLocales"))try{return Intl.getCanonicalLocales(t)[0]}catch{return}return st(t)?.baseName??t}}),$r=$e(e=>Object.freeze(U(e).map(t=>xo(t)).filter(Boolean)));function Lo(e){const t=$r(e);if(t.length!==0)return t.length===1?t[0]:t}function bi(e){const t=$r(e);return t.length>0&&t.every(n=>n.split("-")[0]?.toLowerCase()==="en")}const tn=$e((e=lt().timeZone)=>{try{const{jan:t,jul:n}=xs(e),s=["Australia","Antarctica","Africa/Johannesburg","America/Argentina/Buenos_Aires","America/Sao_Paulo"].some(i=>e.startsWith(i));switch(!0){case n>t:return"north";case n=0?n.add({days:r}):n.subtract({days:-r}),i=s.year;return{weekOfYear:Math.ceil(s.dayOfYear/7),yearOfWeek:i}}class Fs{constructor(){this[W.$RuntimeBrand]=!0,Ye(this),Ye(this.extensions)}extensions=[];modules={};installed=new Set;resetHooks=new Set;state;logger;usrCount=0;#e=new Map;setHook(t,n){const r=this.#e.get(t);return this.#e.set(t,n),r}getHook(t){return this.#e.get(t)}emit(t,n){this.#e.get(t)?.(n)}addTerm(t,n){if(!n||!Ce(n.key))return;const s=(t.pluginsDb?.terms??[]).findIndex(i=>i?.key===n.key);Br(t,"terms",s,n)}addPlugin(t,n){if(!n)return;const r=t.pluginsDb?.plugins??[],s=Ce(n.name)?r.findIndex(i=>i?.name===n.name):-1;s>=0?Br(t,"plugins",s,n):r.includes(n)||Br(t,"plugins",-1,n)}addExtension(t){t&&(Ye(this.extensions),this.extensions.includes(t)||(Object.isExtensible(this.extensions)?this.extensions.push(t):this.extensions=Ye([...this.extensions,t])))}static createScoped(){return new Fs}}function Br(e,t,n,r){e.pluginsDb||(e.pluginsDb={terms:[],plugins:[]}),e.pluginsDb[t]||(e.pluginsDb[t]=[]),Ye(e.pluginsDb),Ye(e.pluginsDb[t]);const s=e.pluginsDb[t];if(Object.isExtensible(s))n>=0?s[n]=r:s.push(r);else{const i=Ye([...s]);n>=0?i[n]=r:i.push(r),Object.isExtensible(e.pluginsDb)?e.pluginsDb[t]=i:e.pluginsDb=Ye({...e.pluginsDb,[t]:i})}}let Zr;function Oe(){const e=globalThis[W.$Bridge];if(e&&e[W.$RuntimeBrand]===!0)return e;if(Zr)return Zr;const t=new Fs;if(!e)Object.defineProperty(globalThis,W.$Bridge,{value:t,enumerable:!1,configurable:!1,writable:!1});else{const n=Object.getOwnPropertyDescriptor(globalThis,W.$Bridge);n&&n.configurable!==!1?Object.defineProperty(globalThis,W.$Bridge,{value:t,enumerable:!1,configurable:!1,writable:!1}):Zr=t}return t}function wi(e){return U(e).map(t=>String(t).trim()).filter(Boolean)}const x=(e,t,n)=>{Object.isExtensible(e)?Object.defineProperty(e,t,{value:n,writable:!0,configurable:!0,enumerable:!0}):Ve(`[tempo] setProperty: Cannot define property '${String(t)}' on non-extensible object`,{},e)},Hr=(e,t)=>{q(t).forEach(([n,r])=>x(e,n,r))},Un=new Yn("Tempo"),Ru=new Yn("Tempo:Parse"),_u=new Yn("Tempo:Engine"),Cu=[Un,Ru,_u];function Si(e){const t=dr(e,De.Info);Cu.forEach(n=>n.level=t)}const Nu=e=>e.map(t=>gt(t)?t.message:String(t)).join(" ");function Mu(e,t={},...n){const r=Mt(e);if(n.length>0){const s=Nu(n);s&&(r.message=`${r.message} ${s}`)}yl(r,{catch:t?.catch??!1,silent:t?.silent??!1,logger:Un})}const me=Mu,zo=e=>(t,n={},...r)=>{n?.silent||(n[W.$LogConfig]?Un[e](n,t,...r):Un[e](t,...r))},Ve=zo("warn"),Dn=zo("debug"),Fo=e=>Object.getPrototypeOf(Ae(e));function Pu(e,t){const n=Fo(e);if(!P(n))return me(`[Tempo#create] Failed to create shadowed object for '${t}'. Proto(obj) is null or not an object.`,null),{};const r=n[t];return P(r)?{...r}:(me(`[Tempo#create] Failed to create shadowed object for '${t}'. The prototype entry from proto(obj) is missing or not an object (received: ${dt(r)}).`,null),{})}function _n(e){if(ue(e))return e;if(z(e)){const t=Oe(),n=`usr.${++t.usrCount}`;return R[n]=Symbol(n)}if(_(e)&&e.includes(".")){const t=e.split(".").at(-1);return R[e]??=Symbol(t)}return R[e]??W[e]??Symbol.for(`$Tempo.${e}`)}function Uo(e,t,n){const r=xt(t);switch(r.type){case"Object":q(r.value).forEach(([s,i])=>e[_n(s)]=n(i));break;case"String":case"RegExp":e[_n()]=n(r.value);break;case"Array":r.value.forEach(s=>Uo(e,s,n));break}}const An=[["year","yy"],["month","mm"],["day","dd"],["hour","hh"],["minute","mi"],["second","ss"],["millisecond","ms"],["microsecond","us"],["nanosecond","ns"]];function Wo(e){for(const[t]of An)if(e.some(n=>n[t]!==void 0))return t;return"nanosecond"}function Us(e={},t){const n=lr(e)||S(e.active);lr(e)&&(e={active:e});const r=new Set,s=[...new Set([...U(t.locales),...U(e.locales)])],i=[...new Set([...U(t.layouts),...U(e.layouts)])],o={...t.timezones};e.timezones&&Object.entries(e.timezones).forEach(([c,h])=>{const f=st(c)?.baseName??c;o[f]=[...new Set([...U(o[f]||[]),...U(h)])]});const a=s.map(c=>{const h=st(c),f=h?.baseName??c,m=h?.getTimeZones?.()??[],p=o[f]??[];return m.length===0&&p.length===0&&!r.has(f)&&r.add(f),{locale:f,timeZones:m.length>0?m:p}});return{...e,isExplicit:n||t.isExplicit,locales:s,layouts:i,timezones:o,resolvedLocales:a}}const ku=/[.*+?^${}()|[\]\\]/g,$u=/\\?\.$/,xu=/\.$/,Vn=e=>e.replace(ku,"\\$&"),Xn=e=>e.replace($u,"\\.?"),Lu=e=>e.replace(xu,"").toLowerCase(),Ti=e=>e.normalize("NFD").replace(Vi,""),zu=$e(e=>{const t=e.split(","),n={},r={},s=[],i=[],o=[],a=[],c={},h={timeZone:"UTC"},f=(b,O,D,g,l,u)=>{const d=Lu(D),y=Ti(d);b[d]={value:g,locale:O},y!==d&&(b[y]={value:g,locale:O}),l.push(Xn(Vn(D))),y!==d&&l.push(Xn(Vn(y))),u&&(u.push(Xn(Vn(D))),y!==d&&u.push(Xn(Vn(y))))};for(const b of t){const O=At(b,{...h,month:"long"}),D=At(b,{...h,month:"short"});for(let u=0;u<12;u++){const d=new Date(Date.UTC(2024,u,15)),y=O.format(d).toLowerCase(),w=D.format(d).toLowerCase();f(n,b,y,u+1,s,i),w!==y&&f(n,b,w,u+1,i)}const g=At(b,{...h,weekday:"long"}),l=At(b,{...h,weekday:"short"});for(let u=1;u<=7;u++){const d=new Date(Date.UTC(2024,0,u)),y=g.format(d).toLowerCase(),w=l.format(d).toLowerCase();f(r,b,y,u,o,a),w!==y&&f(r,b,w,u,a)}try{const u=new Intl.RelativeTimeFormat(b,{numeric:"auto"}),d=u.format(-1,"day").toLowerCase(),y=u.format(0,"day").toLowerCase(),w=u.format(1,"day").toLowerCase(),T=(E,N)=>{if(!E)return;c[E]=N;const M=Ti(E);M!==E&&(c[M]=N)};T(d,"yesterday"),T(y,"today"),T(w,"tomorrow")}catch{}}const m=(b,O)=>O.length-b.length,p=b=>[...new Set(b)];return{snippets:{mon:p(s).sort(m).join("|"),mmm:p([...s,...i]).sort(m).join("|"),wkd:p(o).sort(m).join("|"),www:p([...o,...a]).sort(m).join("|")},events:c,monthMap:n,weekdayMap:r}}),Fu=e=>zu(U(e).join(",")),jo=2**31-1,Ws=(e=[],t)=>U(e).flat(1e6).filter(Number.isInteger).map(n=>(n+256).toString(16).slice(-2)).join("").toLowerCase().substring(0,t??Number.MAX_SAFE_INTEGER),Uu=(e=0)=>{const t=Math.abs(e),n=t%100;if(n>=11&&n<=13)return`${e}th`;switch(t%10){case 1:return`${e}st`;case 2:return`${e}nd`;case 3:return`${e}rd`;default:return`${e}th`}};function Wu(e,t=".",n=!0){return e?.toString().split(t).map(r=>Po(r,n))||[]}const ju=(e=0,t=2)=>$s(e,0).toFixed(t),Ku=e=>Number(String(e).replace(":","")),Bu=[[1e3,"M"],[900,"CM"],[500,"D"],[400,"CD"],[100,"C"],[90,"XC"],[50,"L"],[40,"XL"],[10,"X"],[9,"IX"],[5,"V"],[4,"IV"],[1,"I"]],Ei={I:1,V:5,X:10,L:50,C:100,D:500,M:1e3},Zu=/^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/;function Hu(e){if(!Number.isInteger(e)||e<1||e>3999)return"";let t=e,n="";for(const[r,s]of Bu)for(;t>=r;)n+=s,t-=r;return n}function Ko(e){const t=e?.trim?.().toUpperCase();if(!t||!Zu.test(t))return NaN;let n=0;for(let r=0;r{let e=[_e("Aborter")],t,n=[],r,s=AbortController;var i=class extends s{static{r=this}static{const o=typeof Symbol=="function"&&Symbol.metadata?Object.create(s[Symbol.metadata]??null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:o},null,n),i=r=t.value,o&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:o}),Re(r,n)}static create(){return new i}[Symbol.dispose](){this.signal.aborted||this.abort()}};return i=r})();const Wn=Object.freeze(()=>{});function xr(e,t){if(!e)return Wn;if(e.aborted)return K(t)&&t(),Wn;const n=()=>{K(t)&&t()};return e.addEventListener("abort",n,{once:!0}),()=>e.removeEventListener("abort",n)}function Bo(...e){const t=e.filter(Ir);if(t.length===0)return new AbortController().signal;if(t.length===1)return t[0];for(const a of t)if(a.aborted){const c=new AbortController;return c.abort(a.reason),c.signal}const n=new AbortController,r=[],s=()=>{for(const a of r)a();r.length=0},i=a=>{s(),n.signal.aborted||n.abort(a)};for(const a of t)r.push(xr(a,()=>i(a.reason)));const o=n.signal;return o.cleanup=s,o[Symbol.dispose]=s,o}function Ju(e,t){const n=(j(e)||e===1/0)&&e>=0?Math.min(Math.round(e),jo):0,r=AbortSignal.timeout(n);return Ir(t)?Bo(t,r):r}function Gu(e){e&&(K(e.cleanup)?e.cleanup():K(e[Symbol.dispose])&&e[Symbol.dispose]())}const Ne=Q(["CLEAN","CHECK_DIRTY","DIRTY"]);let ze=null;const Zo=[];let ut=!1;function qu(e){Zo.push(ze),ze=e}function Vu(){ze=Zo.pop()??null}class js{#e=0;#t=new Set;#r=new WeakMap;#s=0;get epoch(){return this.#e}bumpEpoch(){this.#e++}addConsumer(t){if(this.#r.has(t))return;const n=new WeakRef(t);if(this.#r.set(t,n),this.#t.add(n),++this.#s>=64){this.#s=0;for(const r of this.#t)r.deref()||this.#t.delete(r)}}removeConsumer(t){const n=this.#r.get(t);n&&(this.#r.delete(t),this.#t.delete(n))}notifyConsumers(t=!0){if(this.#t.size===0)return;const n=[...this.#t];for(const r of n){const s=r.deref();s?t?s.notifyDirty(this):s.notifyCheckDirty(this):this.#t.delete(r)}}clearConsumers(){this.#t.clear()}}let Ks=(()=>{let e=[Ft,_e("Signify.State")],t,n=[],r,s=js;return class extends s{static{r=this}static{const i=typeof Symbol=="function"&&Symbol.metadata?Object.create(s[Symbol.metadata]??null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:i},null,n),r=t.value,i&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:i}),Re(r,n)}#e;#t;constructor(i,o){super(),this.#e=i,this.#t=o?.equals,Object.freeze(this)}get(){return ze&&!ut&&(this.addConsumer(ze),ze instanceof un&&ze.recordSource(this,this.epoch)),this.#e}set(i){(A(this.#t)?this.#t(this.#e,i):Object.is(this.#e,i))||(this.#e=i,this.bumpEpoch(),this.notifyConsumers(!0))}poll(){return!1}},r})(),un=(()=>{let e=[Ft,_e("Signify.Computed")],t,n=[],r,s=js;var i=class extends s{static{r=this}static{const o=typeof Symbol=="function"&&Symbol.metadata?Object.create(s[Symbol.metadata]??null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:o},null,n),i=r=t.value,o&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:o}),Re(r,n)}#e;#t;#r=void 0;#s=void 0;#o=!1;#i=!1;#a=Ne.DIRTY;#l=!1;#u=!1;#c=new Map;#h=null;constructor(o,a){if(super(),!A(o))throw new TypeError("Signify.Computed requires a function calculation argument");this.#e=o,this.#t=a?.equals,Object.freeze(this)}get(){if(this.#u)throw new Error("Cannot read from a disposed Signify.Computed");if(this.#l)throw new RangeError("Circular dependency detected in Signify.Computed");if(ze&&!ut&&(this.addConsumer(ze),ze instanceof i&&ze.recordSource(this,this.epoch)),this.#a===Ne.CHECK_DIRTY&&this.#n(),this.#a===Ne.DIRTY&&this.#p(),this.#o)throw this.#s;return this.#r}poll(){if(this.#a===Ne.CHECK_DIRTY&&this.#n(),this.#a===Ne.DIRTY){const o=this.epoch;return this.#p(),this.epoch!==o}return!1}#n(){for(const[o,a]of this.#c)if(o.poll(),o.epoch!==a){this.#a=Ne.DIRTY;return}this.#a=Ne.CLEAN}#p(){this.#l=!0,this.#h=new Map,qu(this);const o=ut;ut=!1;let a,c,h=!1;try{a=this.#e()}catch(b){c=b,h=!0}finally{ut=o,Vu(),this.#l=!1}const f=this.#h;this.#h=null;for(const[b]of this.#c)f.has(b)||b.removeConsumer(this);if(this.#c=f,this.#a=Ne.CLEAN,h){this.#o=!0,this.#s=c,this.bumpEpoch();return}const p=!(!this.#o&&this.#i)||(A(this.#t)?!this.#t(this.#r,a):!Object.is(this.#r,a));this.#o=!1,this.#s=void 0,this.#i=!0,p&&(this.#r=a,this.bumpEpoch())}recordSource(o,a){this.#h&&this.#h.set(o,a)}notifyDirty(o){this.#a!==Ne.DIRTY&&(this.#a=Ne.DIRTY,this.notifyConsumers(!0))}notifyCheckDirty(o){this.#a===Ne.CLEAN&&(this.#a=Ne.CHECK_DIRTY,this.notifyConsumers(!1))}dispose(){if(!this.#u){this.#u=!0;for(const[o]of this.#c)o.removeConsumer(this);this.#c.clear(),this.clearConsumers()}}[Symbol.dispose](){this.dispose()}};return i=r})(),Bs=(()=>{let e=[Ft,_e("Signify.subtle.Watcher")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e;#t=new Set;#r=new Set;#s=!1;constructor(s){if(!A(s))throw new TypeError("Signify.subtle.Watcher requires a notify callback function");this.#e=s,Object.freeze(this)}watch(...s){if(!this.#s)for(const i of s)this.#t.has(i)||(this.#t.add(i),i.addConsumer(this))}unwatch(...s){for(const i of s)this.#t.delete(i)&&(i.removeConsumer(this),this.#r.delete(i))}getPending(){const s=[...this.#r];return this.#r.clear(),s}notifyDirty(s){if(this.#s)return;const i=this.#r.size===0;if(this.#r.add(s),i)try{this.#e.call(this)}catch(o){console.error("Signify.subtle.Watcher notify callback error:",o)}}notifyCheckDirty(s){this.notifyDirty(s)}dispose(){if(!this.#s){this.#s=!0;for(const s of this.#t)s.removeConsumer(this);this.#t.clear(),this.#r.clear()}}[Symbol.dispose](){this.dispose()}},r})();function Ho(e){const t=ut;ut=!0;try{return e()}finally{ut=t}}function Yo(){return ze instanceof un?ze:void 0}const Xu=K(globalThis?.queueMicrotask)?queueMicrotask:e=>Promise.resolve().then(e);function kt(e,t){const n=new Ks(e,t),r=function(...s){return s.length===0||n.set(s[0]),n.get()};return Object.defineProperties(r,{get:{value:()=>n.get(),writable:!1,configurable:!1},set:{value:s=>n.set(s),writable:!1,configurable:!1},value:{get:()=>n.get(),set:s=>n.set(s),configurable:!1,enumerable:!0},epoch:{get:()=>n.epoch,configurable:!1,enumerable:!0},addConsumer:{value:s=>n.addConsumer(s),writable:!1,configurable:!1},removeConsumer:{value:s=>n.removeConsumer(s),writable:!1,configurable:!1},poll:{value:()=>n.poll(),writable:!1,configurable:!1},[Symbol.toStringTag]:{value:"Signify",writable:!1,configurable:!1}}),Object.freeze(r)}function Jo(e,t){const n=new un(e,t),r=function(){return n.get()};return Object.defineProperties(r,{get:{value:()=>n.get(),writable:!1,configurable:!1},value:{get:()=>n.get(),configurable:!1,enumerable:!0},epoch:{get:()=>n.epoch,configurable:!1,enumerable:!0},addConsumer:{value:s=>n.addConsumer(s),writable:!1,configurable:!1},removeConsumer:{value:s=>n.removeConsumer(s),writable:!1,configurable:!1},poll:{value:()=>n.poll(),writable:!1,configurable:!1},dispose:{value:()=>n.dispose(),writable:!1,configurable:!1},[Symbol.dispose]:{value:()=>n.dispose(),writable:!1,configurable:!1},[Symbol.toStringTag]:{value:"Signify.Computed",writable:!1,configurable:!1}}),Object.freeze(r)}const Oi=new Set;function Go(e){if(!K(e))throw new TypeError("Signify.effect requires a function argument");let t,n=!1,r=!1,s=null,i=null;const o=()=>{if(!n){if(r=!1,K(t)){try{t()}catch(h){console.error("Signify.effect cleanup error:",h)}t=void 0}i&&s&&i.getPending();try{t=s?.get()}catch(h){console.error("Signify.effect evaluation error:",h)}}},a=()=>{n||r||(r=!0,Xu(o))};return s=new un(e),i=new Bs(a),i.watch(s),Oi.add(i),o(),Object.freeze({get closed(){return n},dispose(){if(!n){if(n=!0,K(t)){try{t()}catch(h){console.error("Signify.effect cleanup error:",h)}t=void 0}i&&(Oi.delete(i),i.dispose(),i=null),s&&(s.dispose(),s=null)}},[Symbol.dispose](){this.dispose()}})}function Qu(e,t){if(e&&K(e.toSignal))return e.toSignal(t);throw new TypeError("Signify.from requires an object implementing .toSignal()")}const Lr=Ks,zr=un,Zs=Bs,Hs=Ho,Ys=Yo,Js=Ne,Gs=Jo,qs=Go,Vs=Qu;var Xe;(function(e){e.State=Lr,e.Computed=zr,e.StateFlag=Js,e.computed=Gs,e.effect=qs,e.from=Vs,(function(t){t.Watcher=Zs,t.untrack=Hs,t.currentComputed=Ys})(e.subtle||(e.subtle={}))})(Xe||(Xe={}));(function(e){e.State=Lr,e.Computed=zr,e.StateFlag=Js,e.computed=Gs,e.effect=qs,e.from=Vs,(function(t){t.Watcher=Zs,t.untrack=Hs,t.currentComputed=Ys})(e.subtle||(e.subtle={}))})(kt||(kt={}));Object.assign(kt,{State:Lr,Computed:zr,StateFlag:Js,computed:Gs,effect:qs,from:Vs,subtle:Xe.subtle});const mn=(()=>{try{const e=globalThis?.Signal;if(K(e?.State)&&K(e?.Computed)&&K(e?.subtle?.Watcher))return e}catch{}})();var jn;(function(e){e.State=mn?.State??Lr,e.Computed=mn?.Computed??zr,(function(t){t.Watcher=mn?.subtle?.Watcher??Zs,t.untrack=mn?.subtle?.untrack??Hs,t.currentComputed=mn?.subtle?.currentComputed??Ys})(e.subtle||(e.subtle={}))})(jn||(jn={}));Object.freeze(Xe.subtle);Object.freeze(Xe);Object.freeze(kt.subtle);Object.freeze(kt);Object.freeze(jn.subtle);Object.freeze(jn);const ir=7,ct=Object.freeze({MO:1,TU:2,WE:3,TH:4,FR:5,SA:6,SU:7,MON:1,TUE:2,WED:3,THU:4,FRI:5,SAT:6,SUN:7}),as=Object.freeze({JAN:1,FEB:2,MAR:3,APR:4,MAY:5,JUN:6,JUL:7,AUG:8,SEP:9,OCT:10,NOV:11,DEC:12}),ef=Object.freeze({1:"Monday",2:"Tuesday",3:"Wednesday",4:"Thursday",5:"Friday",6:"Saturday",7:"Sunday"}),vi=[0,31,28,31,30,31,30,31,31,30,31,30,31],tf=[31,28,31,30,31,30,31,31,30,31,30,31],nf=[31,29,31,30,31,30,31,31,30,31,30,31],_t=864e5,hr=36e5,mr=6e4,pr=1e3;function gr(e,t=!1){return t?(e%4+4)%4===0:e%4===0&&e%100!==0||e%400===0}function yr(e,t,n=!1){if(t>=1&&t<=12)return t===2?gr(e,n)?29:28:vi[t];const r=e+Math.floor((t-1)/12),s=((t-1)%12+12)%12+1;return s===2?gr(r,n)?29:28:vi[s]}function or(e,t){return new Date(e.getTime()+t*_t)}function mt(e,t,n){if(t<1||t>12){const c=t-1;e+=Math.floor(c/12),t=(c%12+12)%12+1}const r=e-(t<=2?1:0),s=Math.floor(r/400),i=r-s*400,o=Math.floor((153*(t>2?t-3:t+9)+2)/5)+n-1,a=i*365+Math.floor(i/4)-Math.floor(i/100)+o;return s*146097+a-719468}function Fr(e){const t=e+719468,n=Math.floor(t/146097),r=t-n*146097,s=Math.floor((r-Math.floor(r/1460)+Math.floor(r/36524)-Math.floor(r/146096))/365),i=s+n*400,o=r-(365*s+Math.floor(s/4)-Math.floor(s/100)),a=Math.floor((5*o+2)/153),c=o-Math.floor((153*a+2)/5)+1,h=a<10?a+3:a-9;return{year:i+(h<=2?1:0),month:h,day:c}}function ft(e){return(e%7+10)%7+1}function br(e,t,n,r=0,s=0,i=0,o=0){return mt(e,t,n)*_t+r*hr+s*mr+i*pr+o}function wr(e){const t=Math.floor(e/_t);let n=e-t*_t;n<0&&(n+=_t);const{year:r,month:s,day:i}=Fr(t),o=ft(t),a=Math.floor(n/hr);n%=hr;const c=Math.floor(n/mr);n%=mr;const h=Math.floor(n/pr),f=n%pr;return{year:r,month:s,day:i,weekday:o,hours:a,minutes:c,seconds:h,milliseconds:f}}function Vt(e){const{year:t,month:n,day:r,hours:s=0,minutes:i=0,seconds:o=0,milliseconds:a=0}=e;return new Date(br(t,n,r,s,i,o,a))}function sn(e,t,n){return!Number.isInteger(e)||!Number.isInteger(t)||!Number.isInteger(n)||t<1||t>12||n<1?!1:n<=yr(e,t)}function qo(e,t){const n=wr(e.getTime());return Vt({...n,...t})}function rf(e,t){const n=gr(e),r=n?366:365;if(t<1||t>r)return;const s=n?nf:tf;let i=t;for(let o=0;o<12;o++){if(i<=s[o])return{month:o+1,day:i};i-=s[o]}}function Vo(e){if(typeof e.weekOfYear=="number"&&typeof e.yearOfWeek=="number")return{weekOfYear:e.weekOfYear,yearOfWeek:e.yearOfWeek};const t=mt(e.year,e.month,e.day),n=ft(t),r=t+4-n,i=Fr(r).year,o=mt(i,1,1);return{weekOfYear:Math.floor((r-o)/7)+1,yearOfWeek:i}}function sf(e,t,n=1){const r=mt(e,1,4),s=ft(r),o=r-(s-1)+(t-1)*7+(n-1);return Fr(o)}function of(e,t,n,r){const s=t===12&&n>=29?[e,e-1]:t===1&&n<=3?[e,e+1]:[e],i=[];for(const o of s){if(!sn(o,t,n)||Vo({year:o,month:t,day:n}).yearOfWeek!==e)continue;const a=mt(o,t,n),c=ft(a);r!==void 0&&c!==r||i.push(o)}return i.length===1?i[0]:void 0}const Di=/[^\]]+/,ne=je({braces:/{([#]?[\w]+(?:\.[\w]+)*)}/g,formatBraces:/{([#]?[\w]+(?:\.[\w]+)*(?:\:[\w-]+)*)}/g,captures:/\(\?<([a-zA-Z][\w]*)>(.*?)(?][\=]?/,strips:/\(|\)/g,spaces:/\s+/g,zed:/^Z$/,guard:/[\d\s\-\.\:T\/Z\+\-\(\)\,\=\#\<\>]/i,bracket:/\[[^\]]+\]/i,shorthand:/(?:(?:#[\w]+|[\w]+)\.(?:[\+\-\<\>]=?)?(?:[0-9]+)?(?:[\w]*))/,slick:/^(?#[\w]+|[\w]+)\.(?[\+\-\<\>\=]=?)?(?-?[0-9]+)?(?[\w]*)$/,slickValue:/^(?[\+\-\<\>\=]=?)?(?-?[0-9]+)?(?[\w]*)$/,offset:/(?:[+-]\d{2}:\d{2}|[+-]\d{4}|(?<=\s|T|GMT|UTC)\s*[+-]\d{1,2}(?::?\d{2})?)/,escape:e=>String(e).replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),safeAlias:e=>String(e).replace(/[*+{}!^$\\]/g,"\\$&"),numeric:/^\s*[-+]?\d+(\.\d+)?\s*$/,backtrack:/(\(.*\)\+|\(.*\)\*|\(.*\)\{.*\})/},!0,!1),Xt=Te()({[R.yy]:/(?[0-9]{1,4})/,[R.mm]:/(?Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?|1[0-2]|[0 ]?[1-9])/,[R.ww]:/(?0?[1-9]|[1-4][0-9]|5[0-3])/,[R.dd]:/(?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3[01]|[12][0-9]|[0 ]?[1-9]){ord}?/,[R.hh]:/(?2[0-4]|[01]?[0-9])/,[R.mi]:/(\:(?[0-5][0-9]))/,[R.ss]:/(\:(?[0-5][0-9]))/,[R.ff]:/(\.(?[0-9]{1,9}))/,[R.ord]:/(?:\s?(?:st|nd|rd|th|e|er|re|ème|eme))?/i,[R.mer]:/(\s*(?am|pm))/,[R.sfx]:/((?:{sep}+|T)({tm}){tz}?)/,[R.wkd]:/(?Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)/,[R.tz]:new RegExp(`\\s*(?:(?:GMT|UTC)(?=\\s*[+-]))?\\s*(?Z|(?:${Object.keys(Nr).map(e=>ne.escape(e.toUpperCase())).join("|")})|${ne.offset.source})`,"i"),[R.nbr]:new RegExp(`(?[0-9]+|${Object.keys(_r).map(e=>ne.escape(e)).join("|")})`),[R.afx]:new RegExp(`((s)? (?${ne.modifier.source}))?{sep}?`),[R.mod]:new RegExp(`((?${ne.modifier.source})? *)`),[R.sep]:new RegExp(`(?:${ne.separator.source})`),[R.unt]:/(?year|month|week|day|hour|minute|second|millisecond|microsecond|nanosecond)(?:s)?/,[R.brk]:new RegExp(`(\\[(?${Di.source})\\](?:\\[(?${Di.source})\\])?)?`),[R.slk]:new RegExp(ne.shorthand.source),[R.era]:/(?:\s*(?b\.?c\.?e\.?|c\.?e\.?|b\.?c\.?|a\.?d\.?))/i,[R.nth]:/(?(?:[0-9]{0,2}11th|[0-9]{0,2}12th|[0-9]{0,2}13th|[0-9]{0,2}[04-9]th|[0-9]{0,2}[02-9]1st|1st|[0-9]{0,2}[02-9]2nd|2nd|[0-9]{0,2}[02-9]3rd|3rd|[1-9][0-9]{0,2})|current|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|last)/i,[R.Rm]:/(?XII|XI|X|IX|VIII|VII|VI|V|IV|III|II|I)/i,[R.Ry]:/(?(?=[MDCLXVI])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3}))/i}),cs={dmy:"{mod}?(?:{dd}(?:{sep}?{mm}|{sep}{Rm})({sep}?{yy})?|{evt}|(?{slk})|{wkd}){afx}?",mdy:"{mod}?(?:{mm}{sep}?{dd}({sep}?{yy})?|{evt}|(?{slk})|{wkd}){afx}?"},ls=Te()({[R.hms]:"(?(?:[01][0-9]|2[0-4]))(?[0-5][0-9])(?[0-5][0-9])",[R.dmy6]:"(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])(?0[1-9]|1[0-2])(?[0-9]{2})",[R.mdy6]:"(?0[1-9]|1[0-2])(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])(?[0-9]{2})",[R.ymd6]:"(?[0-9]{2})(?0[1-9]|1[0-2])(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])",[R.ordWkd]:"{mod}?{nth}?{sep}+{wkd}(?:{sep}+(?:in|of))?{sep}+(?:{mm}(?:{sep}?{yy})?){afx}?{sfx}?",[R.ordUnt]:"{mod}?{nth}?{sep}+{unt}(?:{sep}+(?:in|of))?{sep}+(?:(?[0-9]{4})|{mm}(?:{sep}?(?[0-9]{2,4}))?){afx}?{sfx}?",[R.wkd]:"{mod}?{nbr}?{sep}?{wkd}{afx}?{sfx}?",[R.dt]:cs.dmy,[R.tm]:"({hh}{mi}?{ss}?{ff}?{mer}?|{per})",[R.dtm]:"({dt})(?:(?:{sep}+|T)({tm}))?{tz}?{brk}?",[R.tmd]:"({tm})(?:(?:{sep}+|T)({dt}))?{tz}?{brk}?",[R.dmy]:"{mod}?({wkd}{sep}+)?{dd}{sep}?{mm}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[R.mdy]:"{mod}?({wkd}{sep}+)?{mm}{sep}?{dd}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[R.ymd]:"{mod}?({wkd}{sep}+)?{yy}{sep}?{mm}({sep}?{dd})?{era}?{afx}?{sfx}?{brk}?",[R.off]:"{mod}?{dd}{afx}?",[R.rel]:"{nbr}{sep}?{unt}{sep}?{afx}",[R.ye]:"{mod}?{yy}{era}",[R.ey]:"{mod}?{era}{sep}?{yy}",[R.dRy]:"{mod}?({wkd}{sep}+)?{dd}{sep}{Rm}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[R.Ryy]:"{mod}?(?:anno\\s+domini\\s+|(?:copyright\\s*)?(?:©\\s*)?)?{Ry}{era}?{afx}?{sfx}?{brk}?"}),af=Te()({"new.?years? ?eve":"31 Dec",nye:"31 Dec","new.?years?(?: ?day)?":"01 Jan",ny:"01 Jan","christmas ?eve":"24 Dec",christmas:"25 Dec","xmas ?eve":"24 Dec",xmas:"25 Dec",now:function(){return this.toNow()},today:function(){const{yy:e,mm:t,dd:n}=this.toNow();return this.toDateTime().with({year:e,month:t,day:n})},tomorrow:function(){return this.add({days:1})},yesterday:function(){return this.add({days:-1})},fortnight:function(){return this.add({weeks:2})}}),cf=Te()({"mid[ -]?night":"24:00",morning:"8:00","mid[ -]?morning":"10:00","mid[ -]?day":"12:00",noon:"12:00","after[ -]?noon":"3:00pm",evening:"18:00",night:"20:00","half[ -]?hour":function(){return`${this.hh}:30`}}),lf=["at","the","o-clock","o'clock","oclock","on","in","of","by","for","to"],Xo=["am","pm","gmt","utc","ago","hence","this","next","prev","last","from","now","today","yesterday","tomorrow","start","mid","end","year","month","week","day","hour","minute","second","millisecond","microsecond","nanosecond","years","months","weeks","days","hours","minutes","seconds","milliseconds","microseconds","nanoseconds","st","nd","rd","th","monday","tuesday","wednesday","thursday","friday","saturday","sunday","mondays","tuesdays","wednesdays","thursdays","fridays","saturdays","sundays","bc","bce","ad","ce","b.c.","b.c.e.","a.d.","c.e.","anno","domini","copyright","©"],uf={relativeTimeFormat:{style:"narrow"},durationFormat:{style:"long"}},oe=ve({debug:De.Info,catch:!1,silent:!1,mode:Ps.Auto,pivot:75,timeStamp:"ms",calendar:"iso8601",timeZone:lt().timeZone,locale:lt().locale,sphere:void 0,monthDay:Pr,localeInfo:!1,intl:uf,pluginOptions:{},registry:{formats:Mr,locales:kr,modifiers:{"+":["next","hence","from now"],"-":["ago","last","prev"],"=":["this"],"<":[],">":[],"<=":[],">=":[]},ordinals:Cr},planner:{layoutOrder:[R.hms,R.dmy6,R.mdy6,R.ymd6,R.wkd,R.ye,R.ey,R.dt,R.tm,R.dtm,R.tmd,R.dmy,R.mdy,R.ymd,R.off,R.rel],preFilter:!0}});function Yr(e){const t=e?.epoch?.ns??e?.epochNanoseconds;if(zt(t))return t;throw new TypeError("Invalid TemporalPoint: missing epoch.ns or epochNanoseconds")}let Qo=(()=>{let e=[Ft,_e("Interval")],t,n=[],r;var s=class{static{r=this}static{const i=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:i},null,n),s=r=t.value,i&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:i}),Re(r,n)}#e;#t;#r;#s;constructor(i,o){const a=i===null?-1/0:Yr(i),c=o===null?1/0:Yr(o);return c=this.#r&&oi.#r}abuts(i){return this.#s===i.#r||this.#r===i.#s}intersection(i){if(!this.overlaps(i))return null;const o=this.#r>i.#r?this.#e:i.#e,a=this.#si.#s?this.#t:i.#t;return new s(o,a)}};return s=r})();const pn=new Yn("[Pledge]");let Fe={};const xe=ve({Pending:Symbol("pending"),Resolved:Symbol("resolved"),Rejected:Symbol("rejected")});let ea=(()=>{let e=[Ft,_e("Pledge")],t,n=[],r;var s=class{static{r=this}static{const i=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:i},null,n),s=r=t.value,i&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:i}),Re(r,n)}#e;#t={};#r;#s=void 0;static get STATE(){return xe}static init(i){return P(i)?(te(i)&&(Fe={}),He(Fe),Object.assign(Fe,qt({tag:i.tag,debug:i.debug,catch:i.catch,silent:i.silent}),qt({onResolve:i.onResolve,onReject:i.onReject,onSettle:i.onSettle}))):(He(Fe),Object.assign(Fe,qt({tag:i}))),pn.debug(Fe,Fe),s.status}static[Symbol.dispose](){s.init({})}static get status(){return{...Fe,state:xe.Pending}}constructor(i){const o=P(i)?i:{tag:i},a={...Fe,...qt({tag:o.tag,debug:o.debug,catch:o.catch,silent:o.silent})};if(Promise.withResolvers)this.#e=Promise.withResolvers();else{let O,D;const g=new Promise((l,u)=>{O=l,D=u});this.#e={promise:g,resolve:O,reject:D}}this.#t=He({state:xe.Pending,...a}),this.#r=kt(0);const c=U(Fe.onResolve).concat(U(o.onResolve)),h=U(Fe.onReject).concat(U(o.onReject)),f=U(Fe.onSettle).concat(U(o.onSettle)),m=(O,...D)=>{O.forEach(g=>{try{g(...D)}catch(l){pn.warn(this.#t,"Pledge callback failed",l)}})};c.length&&this.#e.promise.then(O=>m(c,O)).catch(()=>{}),h.length&&this.#e.promise.catch(O=>m(h,O)),f.length&&this.#e.promise.finally(()=>m(f)).catch(()=>{}),this.#t.catch&&this.#e.promise.catch(O=>pn.warn(this.#t,O));const p=this.#t,b=this.#e;return zn.register(this,()=>{if(p.state===xe.Pending){const O=p.tag?`'${p.tag}'`:"instance";p.error=new Error(`Pledge ${O} collected while pending`),p.state=xe.Rejected;try{b.promise.catch(()=>{})}catch{}b.reject(p.error)}}),Object.freeze(this)}[Symbol.dispose](){if(this.isPending){try{this.promise.catch(()=>{})}catch{}this.reject(new Error("Pledge disposed"))}}get status(){const i={...this.#t,state:this.state};try{return Rs(i)}catch{return{tag:this.#t.tag,state:this.state}}}get promise(){return this.#e.promise}get state(){return this.#t.state.description}get isPending(){return this.#r(),this.#t.state===xe.Pending}get isResolved(){return this.#r(),this.#t.state===xe.Resolved}get isRejected(){return this.#r(),this.#t.state===xe.Rejected}get isSettled(){return this.#r(),this.#t.state!==xe.Pending}toSignal(i){return Xe.computed(()=>{if(this.#r(),this.#t.state===xe.Resolved)return this.#t.settled;if(this.#t.state===xe.Rejected)throw this.#t.error;return i})}get signal(){return this.#s??=this.toSignal()}toString(){try{return JSON.stringify(this.status)}catch{return`[Pledge ${this.state}]`}}resolve(i){return this.isPending&&(this.#t.settled=i,this.#t.state=xe.Resolved,pn.debug(this.#t,"Resolved"),this.#e.resolve(i),this.#r(this.#r()+1)),this.#e.promise}reject(i){return this.isPending&&(this.#t.error=i,this.#t.state=xe.Rejected,pn.debug(this.#t,"Rejected",i),this.#e.reject(i),this.#r(this.#r()+1)),this.#e.promise}then(i,o){return this.promise.then(i,o)}};return s=r})(),ff=(()=>{let e=[_e("Reactive.Subscription")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e=!1;#t=Wn;#r=Wn;constructor(s,i){K(s)&&(this.#t=s),this.#r=xr(i,()=>this.unsubscribe())}get closed(){return this.#e}unsubscribe(){this.#e||(this.#e=!0,this.#r(),this.#t())}[Symbol.dispose](){this.unsubscribe()}},r})();function Ai(e){if(!e.completed){if(e.completed=!0,e.waiters.length>0){const t=e.waiters.splice(0);for(const n of t)n.isPending&&n.resolve({done:!0,value:void 0})}if(e.endListeners.size>0){const t=[...e.endListeners];for(const n of t)try{n()}catch(r){console.error("Reactive end listener failed:",r)}}e.dataListeners.clear(),e.errorListeners.clear(),e.endListeners.clear(),e.signalListeners.clear()}}let df=(()=>{let e=[_e("Reactive")],t,n=[],r;var s=class{static{r=this}static{const i=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:i},null,n),s=r=t.value,i&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:i})}static Subscription=ff;#e;#t;#r;#s=!0;#o=!1;#i=0;#a=[];#l=[];#u=new Set;#c=new Set;#h=new Set;#n=new Set;#p;#f=!1;#d;#m;#g;#T=void 0;constructor(i){const o=P(i)?i:_(i)?{tag:i}:{};this.#e=o.tag,this.#t=j(o.bufferSize)&&o.bufferSize>=0?o.bufferSize:1/0,this.#r=!!o.catch,this.#d=()=>this.complete();const a={completed:!1,waiters:this.#l,endListeners:this.#h,dataListeners:this.#u,errorListeners:this.#c,signalListeners:this.#n};this.#m=a,o.finalizer!==!1&&(this.#g=zn.register(this,()=>{Ai(a)}))}get isReactive(){return!0}get state(){return{tag:this.#e,active:this.#s,completed:this.#o,emitted:this.#i,subscribers:this.#u.size+this.#c.size+this.#h.size+this.#n.size,queued:this.#l.length,buffered:this.#a.length}}push(i){if(A(i))return this.on("data",i);if(!this.#s||this.#o)return!1;if(this.#i++,this.#p=i,this.#f=!0,this.#n.size>0){const a=[...this.#n];for(const c of a)try{c(i)}catch(h){this.error(h instanceof Error?h:new Error(String(h)))}}let o=!1;for(;this.#l.length>0;){const a=this.#l.shift();if(a.isPending){a.resolve({done:!1,value:i}),o=!0;break}}if(!o&&this.#u.size===0&&this.#a.length0){const a=[...this.#u];for(const c of a)try{c(i,this.#d)}catch(h){this.error(h instanceof Error?h:new Error(String(h)))}}return!0}cast(i){if(!this.#s||this.#o)return!1;if(this.#i++,this.#p=i,this.#f=!0,this.#n.size>0){const o=[...this.#n];for(const a of o)try{a(i)}catch(c){this.error(c instanceof Error?c:new Error(String(c)))}}if(this.#l.length>0){const o=this.#l.splice(0);for(const a of o)a.isPending&&a.resolve({done:!1,value:i})}if(this.#u.size>0){const o=[...this.#u];for(const a of o)try{a(i,this.#d)}catch(c){this.error(c instanceof Error?c:new Error(String(c)))}}return!0}broadcast(i){return this.cast(i)}emit(i){return this.push(i)}#y;error(i){if(this.#o)return;if(this.#y=i,this.#c.size>0){const a=[...this.#c];for(const c of a)try{c(i,this.#d)}catch(h){console.error("Reactive error listener failed:",h)}}const o=this.#l.length>0;if(o){const a=this.#l.splice(0);for(const c of a)c.isPending&&(this.#r?c.resolve({done:!0,value:void 0}):c.reject(i))}this.#r?this.complete():this.#c.size===0&&!o&&console.error("Unhandled Reactive error:",i)}complete(i){this.#o||(i!==void 0&&this.push(i),this.#o=!0,this.#s=!1,Ai(this.#m),this.#g&&(this.#g(),this.#g=void 0))}stop(i){this.complete(i)}on(i,o,a){if(!A(o))return new s.Subscription(()=>{});if(a?.signal?.aborted)return new s.Subscription(()=>{},a.signal);let c=o;a?.once&&(c=(...m)=>{f.unsubscribe(),o(...m)});let h;if(i==="data"){if(this.#u.add(c),h=()=>{this.#u.delete(c)},this.#a.length>0){const m=[...this.#a];this.#a=[];for(const p of m)c(p,this.#d)}}else i==="error"?(this.#c.add(c),h=()=>{this.#c.delete(c)}):i==="end"||i==="stop"?this.#o?(queueMicrotask(()=>c()),h=()=>{}):(this.#h.add(c),h=()=>{this.#h.delete(c)}):h=()=>{};const f=new s.Subscription(h,a?.signal);return f}once(i,o,a){return this.on(i,o,{...a,once:!0})}off(i,o){return i==="data"?this.#u.delete(o):i==="error"?this.#c.delete(o):(i==="end"||i==="stop")&&this.#h.delete(o),this}until(i){const o=new s({tag:this.#e?`${this.#e}.until`:"Reactive.until",bufferSize:this.#t,catch:this.#r});let a=[];const c=()=>{h.unsubscribe(),f.unsubscribe(),m.unsubscribe();for(const p of a)p();a=[],o.complete()},h=this.on("data",p=>o.push(p)),f=this.on("error",p=>o.error(p)),m=this.on("end",()=>o.complete());if(o.on("end",()=>{h.unsubscribe(),f.unsubscribe(),m.unsubscribe();for(const p of a)p();a=[]}),Ir(i))a.push(xr(i,c));else if(Xr(i)||S(i)&&A(i.then))i.then(c,c);else if(S(i)&&A(i.on)){const p=i,b=p.on("data",c,{once:!0}),O=p.on("end",c,{once:!0});a.push(()=>{b.unsubscribe(),O.unsubscribe()})}return o}async pull(){const i=await this.next();return i.done?void 0:i.value}async next(){if(this.#a.length>0)return{done:!1,value:this.#a.shift()};if(this.#y&&!this.#r)throw this.#y;if(this.#o||!this.#s)return{done:!0,value:void 0};const i=new ea(this.#e?`${this.#e}.waiter`:"Reactive.waiter");return this.#l.push(i),i.promise}async return(){return this.complete(),{done:!0,value:void 0}}async throw(i){const o=i instanceof Error?i:new Error(String(i));return this.error(o),this.complete(),{done:!0,value:void 0}}[Symbol.asyncIterator](){return this}toSignal(i){const o=this.#f?this.#p:i,a=new Xe.State(o),c=b=>{a.set(b)},h=this.#n;h.add(c);let f=!1;const m=()=>{f||(f=!0,h.delete(c))},p=function(){return a.get()};return Object.defineProperties(p,{get:{value:()=>a.get(),writable:!1,configurable:!1},value:{get:()=>a.get(),configurable:!1,enumerable:!0},epoch:{get:()=>a.epoch,configurable:!1,enumerable:!0},addConsumer:{value:b=>a.addConsumer(b),writable:!1,configurable:!1},removeConsumer:{value:b=>a.removeConsumer(b),writable:!1,configurable:!1},poll:{value:()=>a.poll(),writable:!1,configurable:!1},dispose:{value:m,writable:!1,configurable:!1},[Symbol.dispose]:{value:m,writable:!1,configurable:!1},[Symbol.toStringTag]:{value:"Signify.Computed",writable:!1,configurable:!1}}),zn.register(p,m),Object.freeze(p)}get signal(){return this.#T??=this.toSignal()}[Symbol.dispose](){this.complete()}async[Symbol.asyncDispose](){this.complete()}static fromSignal(i,o){const a=new s(o),c=K(i)?i:()=>i.get(),h=Xe.effect(()=>{let f;try{f=c()}catch(m){a.error(m instanceof Error?m:new Error(String(m)));return}Xe.subtle.untrack(()=>{a.push(f)})});return a.on("stop",()=>{h.dispose()}),a.on("end",()=>{h.dispose()}),a}static from(i,o){if(S(i)&&A(i[Symbol.asyncIterator])){const c=new s(o);return(async()=>{try{for await(const h of i){if(!c.state.active)break;c.push(h)}c.complete()}catch(h){c.error(h instanceof Error?h:new Error(String(h))),c.complete()}})(),c}if(S(i)&&A(i[Symbol.iterator])){const c=new s(o);try{for(const h of i){if(!c.state.active)break;c.push(h)}c.complete()}catch(h){c.error(h instanceof Error?h:new Error(String(h))),c.complete()}return c}if(Xr(i)||S(i)&&A(i.then)){const c=new s(o);return i.then(h=>{c.push(h),c.complete()}).catch(h=>{c.error(h instanceof Error?h:new Error(String(h))),c.complete()}),c}return S(i)&&(P(i)&&A(i.get)&&i.get.length===0||K(i)&&!ur(i))?s.fromSignal(i,o):new s(o)}static{Re(r,n)}};return s=r})(),It=(()=>{let e=[_e("BoundedCache")],t,n=[],r,s=Map;var i=class extends s{static{r=this}static{const o=typeof Symbol=="function"&&Symbol.metadata?Object.create(s[Symbol.metadata]??null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:o},null,n),i=r=t.value,o&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:o}),Re(r,n)}#e=new Map;#t=new Set;#r=new Map;maxSize;ttl;constructor(o=1e3,a=1440*60*1e3){super(),this.maxSize=o,this.ttl=a}get isBoundedCache(){return!0}#s(o){const a=this.#e.get(o);return a===void 0?!1:Date.now()>a}evictExpired(){if(this.#e.size===0)return;const o=Date.now();for(const[a,c]of this.#e.entries())o>c&&this.delete(a)}setStatic(o,a){return super.has(o)&&super.delete(o),super.set(o,a),this.#t.add(o),this.#e.delete(o),this.#r.delete(o),this}isStatic(o){return this.#t.has(o)}get(o){if(this.#s(o)){this.delete(o);return}if(!super.has(o))return;const a=super.get(o);return super.delete(o),super.set(o,a),a}has(o){return this.#s(o)?(this.delete(o),!1):super.has(o)}get size(){return this.evictExpired(),super.size}forEach(o,a){this.evictExpired(),super.forEach(o,a)}set(o,a,c){this.evictExpired();const h=this.#e.get(o);for(super.has(o)&&super.delete(o),super.set(o,a),this.#t.delete(o),S(c)?c!==1/0?(this.#e.set(o,Date.now()+c),this.#r.set(o,c)):(this.#e.delete(o),this.#r.delete(o)):h!==void 0?this.#e.set(o,h):this.ttl!==1/0?(this.#e.set(o,Date.now()+this.ttl),this.#r.delete(o)):(this.#e.delete(o),this.#r.delete(o));this.size-this.#t.size>this.maxSize;){let f=!1;const m=super.keys();let p=m.next();for(;!p.done;){const b=p.value;if(!this.#t.has(b)){this.delete(b),f=!0;break}p=m.next()}if(!f)break}return this}delete(o){return this.#t.delete(o),this.#e.delete(o),this.#r.delete(o),super.delete(o)}deletePrefix(o){const a=String(o).trim().toLowerCase();if(te(a))return 0;const c=[];for(const h of super.keys())_(h)&&h.toLowerCase().startsWith(a)&&c.push(h);for(const h of c)this.delete(h);return c.length}clear(o){if(o===void 0){this.#t.clear(),this.#e.clear(),this.#r.clear(),super.clear();return}let a=0;for(const c of super.keys()){if(a>=o)break;this.#t.has(c)||(this.delete(c),a++)}}keys(){return this.evictExpired(),super.keys()}values(){return this.evictExpired(),super.values()}entries(){return this.evictExpired(),super.entries()}[Symbol.iterator](){return this.evictExpired(),super[Symbol.iterator]()}toJSON(){this.evictExpired();const o=[];for(const[a,c]of super.entries())_(a)&&o.push([a,c]);return Object.fromEntries(o)}static fromEntries(o,a=1e3,c=1440*60*1e3){const h=new i(a,c);for(const[f,m]of o)h.set(f,m);return h}};return i=r})();const Pe=Bn(),ta=(e=1e3,t=1/0)=>{const n=new It(e,t);return{get length(){return n.size},clear:()=>n.clear(),getItem:r=>n.get(r)??null,key:r=>Array.from(n.keys())[r]??null,removeItem:r=>{n.delete(r)},setItem:(r,s)=>{n.set(r,String(s))}}},Ii=new Map,hf=e=>{let t=Ii.get(e);return t||(t=ta(),Ii.set(e,t)),t},mf=(e="localStorage")=>{try{const t=globalThis?.[e];if(t&&K(t.getItem)&&K(t.setItem)&&K(t.removeItem)&&K(t.clear)&&K(t.key)&&j(t.length))return t}catch{}return hf(e)};let us=Pe.type===ae.Browser?mf():ta();const Sr=new It(1e3,1/0),pf=e=>{try{const t=Reflect.get(Pe.global,"process");if(!t||typeof t!="object")return;const n=Reflect.get(t,"env");return!n||typeof n!="object"?void 0:Reflect.get(n,e)}catch{return}};function Cn(e,t){let n;if(z(e))return t??{};switch(Pe.type){case ae.Browser:n=us.getItem(e);break;case ae.NodeJS:n=Sr.has(e)?Sr.get(e):pf(e);break;case ae.Deno:n=Pe.global.Deno.env.get(e);break;case ae.GoogleAppsScript:n=Pe.global.PropertiesService?.getUserProperties().getProperty(e);break;case ae.WebWorker:case ae.Unknown:n=void 0;break;default:throw new Error(`Cannot determine Javascript context: ${Pe.type}`)}return _(n)?Zn(n):t}function na(e,t,n){const r=S(t)?yt(t):void 0,s=S(r);switch(Pe.type){case ae.Browser:try{s?us.setItem(e,r):us.removeItem(e)}catch(i){console.warn(`[Storage] Failed to ${s?"setItem":"removeItem"} for key '${e}':`,i)}break;case ae.NodeJS:s?Sr.set(e,r,n?.ttl):Sr.set(e,void 0,n?.ttl);break;case ae.Deno:s?Pe.global.Deno.env.set(e,r):Pe.global.Deno.env.delete(e);break;case ae.GoogleAppsScript:s?Pe.global.PropertiesService?.getUserProperties().setProperty(e,r):Pe.global.PropertiesService?.getUserProperties().deleteProperty(e);break;case ae.WebWorker:case ae.Unknown:break;default:throw new Error(`Cannot determine Javascript context: ${Pe.type}`)}}const gf=()=>!!(Pe.global.VITEST||Pe.global.__VITEST_ENVIRONMENT__||Cn("TEMPO_TESTING",!1)||Cn("NODE_ENV","")==="test"||Cn("CI",!1));function re(...e){for(const t of e){const n=A(t)?t():t;if(n!==void 0)return n}}function yf(e,...t){return A(e)?e(...t):e}function bf(e,...t){const n=A(e)?e(...t):e;return ke(n)?"":String(n)}async function wf(...e){const t=e.map(n=>{if(!A(n)){const r=Promise.resolve(n);return r.catch(()=>{}),r}});for(let n=0;n{const i=e[s];return A(i)?i():i}));for(let s=0;s{if(!S(e)||lr(e))return NaN;if(_(e)){const t=e.trim();return t.length>0?Number(t):NaN}return j(e)?e:NaN},Xs=(e,t=!0)=>{const n=ra(e);if(!(!j(n)||n<-90||n>90))return t?Math.round(n*1e3)/1e3:n},Qs=(e,t=!0)=>{const n=ra(e);if(!(!j(n)||n<-180||n>180))return t?Math.round(n*1e3)/1e3:n},fs=(e,t,n=!0)=>{const r=Xs(e,n),s=Qs(t,n);return S(r)&&S(s)?{lat:r,lng:s}:void 0},sa=e=>j(e)?Math.round(e*1e3)/1e3:void 0,ia=(e,t)=>{if(e==="north"||e==="south"||e==="equator")return e;if(j(t))return t>.001?"north":t<-.001?"south":"equator"},oa=(e,t=!0)=>{if(_(e)&&e.includes(",")){const n=e.split(",").map(r=>r.trim());return n.length>=2?fs(n[0],n[1],t):void 0}return Array.isArray(e)&&e.length>=2?fs(e[0],e[1],t):void 0},ds=(e,t)=>{const n="lat"in e?e.lat:e.latitude,r="lng"in e?e.lng:e.longitude,s=Xs(n),i=Qs(r),o=ia(t?.sphere,s??n),a=sa(t?.elevation);return{latitude:s??n,longitude:i??r,...o?{sphere:o}:{},...Ce(t?.city)?{city:t.city.trim()}:{},...Ce(t?.country)?{country:t.country.trim()}:{},...a!==void 0?{elevation:a}:{},...Ce(t?.timezone)?{timezone:t.timezone.trim()}:{}}},Df=(e,t=vf)=>{const n={};if(rt(e))for(const r of Object.keys(e))it(r)&&!t.includes(r)&&(n[r]=e[r]);return n},hs=e=>{const t=oa(e);if(t)return ds(t);if(an(e))return;const n=e.geo??e,r=e.config?.geo??e.config,s=re(n?.latitude,n?.lat,e.latitude,e.lat,r?.latitude,r?.lat),i=re(n?.longitude,n?.lng,n?.lon,n?.long,e.longitude,e.lng,e.lon,e.long,r?.longitude,r?.lng,r?.lon,r?.long),o=re(n?.elevation,e.elevation,r?.elevation),a=re(n?.sphere,e.sphere,r?.sphere),c=re(n?.country,e.country,r?.country),h=re(n?.city,e.city,r?.city),f=re(n?.timezone,n?.tz,e.timezone,e.tz,r?.timezone,r?.tz),m={},p=Xs(s),b=Qs(i);p!==void 0&&(m.latitude=p),b!==void 0&&(m.longitude=b);const O=sa(o);O!==void 0&&(m.elevation=O);const D=ia(a,m.latitude);D&&(m.sphere=D),_(c)&&(m.country=c),_(h)&&(m.city=h),_(f)&&(m.timezone=f);const g=rt(e.geo)?e.geo:rt(e.config?.geo)?e.config.geo:void 0,l=Df(g);return Object.assign(m,l),Object.keys(m).length>0?m:void 0},aa=e=>{if(Ce(e)){const t=e.trim();return t.startsWith(Jr)?t:`${Jr}:${t}`}return Jr},Ri=e=>{const t=aa(e);try{const n=Cn(t)??(pe(globalThis?.localStorage,"getItem",K)?globalThis.localStorage.getItem(t):void 0);if(!n)return;const r=_(n)&&(n.startsWith("{")||n.startsWith("["))?JSON.parse(n):n;if(P(r)&&j(r._expires)&&Date.now()>r._expires){Af(e);return}const s=oa(r);if(s)return ds(s);if(P(r)){const i=r.geolocation?.coords??r.coords??r,o=i?.latitude??i?.lat,a=i?.longitude??i?.lng??i?.lon??i?.long,c=fs(o,a);if(c){const h=r.elevation??i.elevation;return ds(c,{elevation:h,sphere:r.sphere,country:r.country,city:r.city,timezone:r.timezone})}}}catch{}},Af=e=>{const t=aa(e);na(t,void 0)};new It(Of,Ef);class $t extends Error{constructor(t){super(`[Tempo] ${t}`),this.name="TempoError",Object.setPrototypeOf(this,$t.prototype)}}const Ur="5.0.0";function fn(e){const t=Oe().modules.Tempo;return K(e)?e:nt(e)?e.constructor??t:t??e?.constructor}function Et(e,t,n=!1){const r=fn(e),s=Oe(),i=t==="term"?"TermsModule":t,o=s.modules[i],a=r[W.$Internal]?.()||s.state,c=i==="TermsModule"&&a&&(S(o)||s.installed.has("TermsModule")||a.pluginsDb.plugins.some(h=>h.name==="TermsModule"))&&a.pluginsDb.terms.length>0;if(!S(o)&&!c){const h=i.endsWith("Module")?i.slice(0,-6):i,f=h==="Terms"?"term":h.toLowerCase(),m=`${i} not loaded. (Did you forget to Tempo.use(${i}) or import '#tempo/${f}' / '@magmacomputing/tempo/${f}'?)`;if(n||me(m,e?.config),n||e?.config?.catch===!0)return!1;throw new $t(m)}return!0}function at(e,t,n,r=!1,...s){if(fn(e),!Et(e,t,r))return A(n)?n.apply(e,s):(_(n)||z(n))&&(e?.config?.catch===!0||r)?e:void 0;const o=Oe().modules[t],a=_(n)?o[n]:o;if(!A(a)){if(A(n))return n.apply(e,s);if(_(s[0])&&pe(o,s[0],A)){const h=s.shift();return o[h].apply(e,s)}const c=`${t} method '${String(n)}' not found`;throw me(c,e?.config),new $t(c)}return a.apply(e,s)}function ca(e){const t={...e,[W.$PluginType]:"module"};return Ct(t),Me(t)}function la(e,t){for(const[n,r]of Object.entries(t)){const s=P(r)&&(r[W.$Descriptor]===!0||(S(r.get)||S(r.set)||S(r.value)||S(r.writable)||S(r.configurable)||S(r.enumerable))&&(!S(r.get)||A(r.get))&&(!S(r.set)||A(r.set)));if(he(e,n)){const i=Object.getOwnPropertyDescriptor(e,n);if(i){if(!s&&i.value===r)continue;if(s){if(pe(r,"get",A)||pe(r,"set",A)){const c=r;if(i.get===c.get&&i.set===c.set)continue}else if(pe(r,"value")){const c=r;if(i.value===c.value&&i.writable===(c.writable??!0)&&i.enumerable===(c.enumerable??!1)&&i.configurable===(c.configurable??!0))continue}}}const o=`Static name collision on "${n}". Property is already defined on the host class.`;me(o,{...e?.config,catch:!0});continue}Object.defineProperty(e,n,{...s?r:{value:r,writable:!0},enumerable:!1,configurable:!0})}}function If(e,t,n){return ca({name:e,version:Ur,install(r){const i=Oe().modules;if(z(i[e]))i[e]=t;else if(i[e]!==t)throw new $t(`Tempo Security: Core Module clash for '${e}'. Logic is already defined.`);if(z(r[W.$Interpreter])&&Object.defineProperty(r,W.$Interpreter,{value:io({}),enumerable:!1,configurable:!0,writable:!0}),S(r[W.$Interpreter][e])){if(r[W.$Interpreter][e]!==t)throw new $t(`Tempo Interpreter Module clash: '${e}' logic is already defined.`)}else r[W.$Interpreter][e]=t;S(n)&&la(r,n)}})}function ua(e){const t=function(i){return{...e,options:i,[W.$PluginType]:"plugin"}},{name:n,...r}=e,s=Object.assign(t,r,{[W.$PluginType]:"plugin"});return n&&Object.defineProperty(s,"name",{value:n,configurable:!0}),Ct(s),Me(s)}function Ct(e,t){const n=Oe();t?n.addPlugin(t,e):n.state&&n.addPlugin(n.state,e);const r=t??n.state;return(!r||r===n.state)&&n.addExtension(e),n.emit(W.$Register,e),e}function Rf(e){if(ue(e.name)&&!e.name.description)throw new $t("Tempo Security: Symbol namespaces must have a description.");const t=ue(e.name)?Symbol.keyFor(e.name)?`@@${Symbol.keyFor(e.name)}`:`@${e.name.description}`:e.name,n=`${t}Namespace`,r=new WeakMap,s=Me({name:n,version:e.version??Ur,[W.$PluginType]:"namespace",install(h,f){Object.defineProperty(h.prototype,e.name,{get(){const m=ue(e.name)?t:`_${t}`,p=Reflect.isExtensible(this);if(!p&&r.has(this))return r.get(this);if(p&&this[m])return this[m];const O=Qt(Object.create(null),D=>{const g=e.resolvers[D];if(g)return g(this)},!0);return p?Object.defineProperty(this,m,{value:O,writable:!0,configurable:!0,enumerable:!1}):r.set(this,O),O},configurable:!0,enumerable:!1})}}),i=function(h){return{...s,options:h,[W.$PluginType]:"namespace"}},{name:o,...a}=s,c=Object.assign(i,a,{[W.$PluginType]:"namespace"});return o&&Object.defineProperty(c,"name",{value:o,configurable:!0}),Ct(c),Me(c)}function _f(e){const t=fn(null),n=globalThis.Tempo;if(pe(t,"use",A))t.use(e);else if(pe(n,"use",A))n.use(e);else{const r=Oe();Array.isArray(r.modules.$pendingAutoInstalls)||(r.modules.$pendingAutoInstalls=[]),r.modules.$pendingAutoInstalls.push(e)}}const Cf=(e=[],t,n)=>{const r=P(t)&&S(n);let s=0,i=e.length;for(;s>>1,a=r?e[o][n]:e[o],c=r?t[n]:t;aP(n)?n:{field:yt(n)});return(n,r)=>{let s=0;return t.forEach(i=>{if(s===0){const o=i.dir==="desc"?-1:1,a=i.field+(S(i.index)?`[${i.index}]`:""),c=Vr(n,a,is(i.default,0)),h=Vr(r,a,is(i.default,0));switch(!0){case(j(c)&&j(h)):case(Pn(c)&&Pn(h)):case(P(c)&&P(h)&&j(c.valueOf())&&j(h.valueOf())):s=o*(c-h);break;default:s=o*Ln(c)?.localeCompare(Ln(h));break}}}),s}}function ei(e,...t){return e.sort(fa(...t))}const _i=(e,t)=>{if(K(Object.groupBy))return Object.groupBy(e,t);const n=Object.create(null);for(let r=0;rr.map(i=>z(s[i])?"":yt(s[i])).join("."))}function Nf(e,t,...n){const r=A(t)?Tr(e,t):Tr(e,t,...n);return q(r).reduce((s,[i,o])=>Object.assign(s,{[i]:o?.pop()}),{})}function Mf(e){return e.fill(null).length=0,e}function da(...e){if(e.length===0)return[];if(e.length===1)return(e[0]||[]).map(i=>[i]);const[t,n=[],...r]=e,s=(i,o)=>[].concat(...i.map(a=>o.map(c=>[].concat(a,c))));return n.length?da(s(t,n),...r):t||[]}function Pf(e,t){return t(e),e}const ha=e=>{const t=new Set;for(const a of U(e.aliases))a!==e.key&&t.add(a);e.scope&&e.scope!==e.key&&t.add(e.scope);const n={...e,...t.size>0?{aliases:Array.from(t)}:{},[W.$PluginType]:"term",version:e.version??Ur},r=function(a){return $n({...n,options:P(a)?{...a}:a,[W.$PluginType]:"term"})},{name:s,...i}=n,o=Object.assign(r,i,{[W.$PluginType]:"term"});return s&&Object.defineProperty(o,"name",{value:s,configurable:!0}),ar(o),$n(o)};function kf(e,...t){return ve(Tr(e,...t))}function ms(e,t,n=!0,r){const s=ei([...t],"year","month","day","hour","minute","second","millisecond","microsecond","nanosecond");if(s.length===0)return;let i=nt(r)?r.toDateTime():Ze(r)?r:nt(e)?e.toDateTime():void 0;Ze(i)||(i=qe().toZonedDateTimeISO(e.config.timeZone??"UTC"));const o=Wo(t),a=An.findIndex(([l])=>l===o),c=Math.max(0,a-1),h=An[c][0],f=(l,u)=>{const d={};for(let E=0;Ec)d[N]=E<=2?1:0;else{const v=u[N];d[N]=j(v)?v:E<=2?1:0}}const[y,w]=en(u.timeZoneId,u.calendarId),T=Ls({...d,timeZone:y,calendar:w});return new(fn(e))(T,e.config)},m=s.findLastIndex(l=>f(l,i).toDateTime().epochNanoseconds<=i.epochNanoseconds);if(j(n)){const l=Math.floor(s.length/3);if(l===0||!Number.isInteger(n)||n<1||n>l)return;const u=m===-1?l:Math.floor(m/l)*l,d=s[u+(n-1)];if(!d)return;const y=f(d,i);let w;const T=u+(n-1),E=s[T+1];if(E)w=f(E,i);else{const N={...d};j(N.year)&&N.year++,w=f(N,i.add({[`${h}s`]:1}))}return{start:y,end:w,...d}}if(Ce(n)){const l=Math.floor(s.length/3),u=m===-1?l:Math.floor(m/l)*l,d=l>0?s.slice(u,u+l):s,y=n.toLowerCase(),w=s.find(v=>v.year===i.year&&(v.key?.toLowerCase()===y||v.label?.toLowerCase()===y))??d.find(v=>v.key?.toLowerCase()===y||v.label?.toLowerCase()===y)??s.find(v=>v.key?.toLowerCase()===y||v.label?.toLowerCase()===y);if(!w)return;const T=f(w,i),E=s.indexOf(w),N=s[E+1];let M;if(N)M=f(N,i);else{const v={...w};j(v.year)&&v.year++,M=f(v,i.add({[`${h}s`]:1}))}return{start:T,end:M,...w}}const p=s[m===-1?0:m];if(n===!0)return p.key;const b=s.indexOf(p),O=s[b+1],D=f(p,i);let g;if(O)g=f(O,i);else{const l={...p};j(l.year)&&l.year++,g=f(l,i.add({[`${h}s`]:1}))}return{start:D,end:g,...p}}function $f(e,t,{anchor:n,groupBy:r=[],...s}={}){const i=nt(e)?e:S(e)?new(fn(e))(e):e;if(!nt(i))return[];let o=[];if(!S(t))return i.constructor[es]?.(i.config,"template"),[];if(!Array.isArray(t)&&r.length>0){const g=r.map(l=>s[l]??n?.[l]??i[l]??i.config[l]??"").join(".");if(o=t[g]??[],o.length===0&&r.includes("sphere")){const l=r.indexOf("sphere"),u=g.split("."),d=(u.length>l?u[l]:"").toLowerCase();let y,w=-1;for(const T of Object.keys(t)){const E=T.split(".");if(E.length!==u.length)continue;const N=(E[l]??"").trim();if(!N||!E.every((k,Y)=>Y===l||k===u[Y]))continue;const v=N.toLowerCase();d.includes(v)&&(N.length>w||N.length===w&&(!y||T.localeCompare(y)<0))&&(y=T,w=N.length)}y&&(o=t[y])}if(o.length===0){const l=r.filter(d=>z(s[d])&&z(n?.[d])&&z(i[d])&&z(i.config[d])),u=l.length>0?`Missing grouping criteria: ${l.join(", ")}`:`No ranges found for group: ${g}`;return i.constructor[es]?.(i.config,u),[]}}else o=Array.isArray(t)?t:Object.values(t).flat();if(o.length===0)return[];o=[...o],ei(o,"year","month","day","hour","minute","second","millisecond","microsecond","nanosecond");const a=Wo(o);if(!["year","month","day"].includes(a)){const g=[];for(const l of[-1,0,1]){const u=i.add({days:l});o.forEach(d=>{g.push({...d,year:u.yy,month:u.mm,day:u.dd})})}return g}const c=i.yy,h=i.mm,f=i.dd,m=o[0],p=m.month??1,b=m.day??1;let O=c;(h{const d={...u};j(u.year)?d.year=u.year>=-10&&u.year<=10?u.year+l:u.year:d.year=l,D.push(d)})}return D}function ar(e,t){const n=Oe();t?n.addTerm(t,e):n.state&&n.addTerm(n.state,e),n.emit(W.$Register,e)}function xf(e,t,n){const r=t.value??(_(t.ord)?parseInt(t.ord,10):void 0);if(!Number.isFinite(r)||r===0)return;const i=(t.term||"").slice(1).split(".")[1];let o;if(S(i)&&i!==""){const m=parseInt(i,10);Number.isInteger(m)&&m>0?o=A(e.define)?e.define.call(n,m,n):void 0:o=A(e.define)?e.define.call(n,i,n):void 0}else o=A(e.define)?e.define.call(n,!1,n):void 0;if(!o||!o.start||!o.end)return;const a=r>0?o.start.add({days:r-1}):o.end.subtract({days:Math.abs(r)}),c=a.toDateTime().epochNanoseconds,h=o.start.toDateTime().epochNanoseconds,f=o.end.toDateTime().epochNanoseconds;return c=f?void 0:a}function ma(e,t,n,r){if(!A(e?.define))return;const s=e.define.call(r,!1,r),i=e.define.call(t,!1,t);if(!s?.start||!s?.end||!i?.start||!i?.end)return;const o=s.start.toDateTime().epochNanoseconds,a=i.start.toDateTime().epochNanoseconds;if(o===a)return 0;if(aa);){c++;const p=e.define.call(h.end,!1,h.end);if(!p?.start||!p?.end||p.start.toDateTime().epochNanoseconds<=h.start.toDateTime().epochNanoseconds)return;h=p}return c>=f?void 0:c}function Lf(e,t,n){if(!A(e?.define))return;const r=e.define.call(n,!1,n);if(!r)return;const s=t.slice(1).split("."),i=s.slice(1);if(i.length===0){const c=s[0]?.toLowerCase()===e.scope?.toLowerCase(),h=P(r)?c?r.label??r.key:r.key??r.label:r;return S(h)?String(h):void 0}let o=r;for(const a of i){if(ke(o)||!it(a))return;o=o[a]}if(!(ke(o)||A(o)))return nt(o)?Me(o).format("{yyyy}-{mm}-{dd}"):P(o)?String(o.label??o.key??o.name??o.value??o):String(o)}class Ot{static aliasPattern=/^(evt|per)(\d+)_(\d+)$/;static _idCounter=0;static _getBaseWord(t){return t.normalize("NFC").toLowerCase().replace(/\[[^\]]*\]\?/g,"").replace(/.\?/g,"").replace(/[^\p{L}\p{M}\p{N}]/gu,"")}#e;#t;#r;#s;#o;#i;#a;#l=0;get depth(){return this.#r}get id(){return this.#a}get parent(){return this.#e}getWords(){return this.#i}constructor(t={}){const n=t.parent;this.#t=t.config,this.#a=Ot._idCounter++,n instanceof Ot?(this.#e=n,this.#r=n.depth+1,this.#o=Object.create(n.#o),this.#i=Object.create(n.#i)):(n&&me("Parent engine must be an instance of AliasEngine",this.#t),this.#e=null,this.#r=0,this.#o=Object.create(null),this.#i=Object.create(null)),this.#s={evt:0,per:0}}fork(t){return new Ot({parent:this,config:t??this.#t??null})}registerAliases(t,n){let r=!1;for(const[s,i]of n){const o=Ot._getBaseWord(s),a=this.#i[o],c=a?this.getAlias(a):void 0;if(this.getAliases(t,!0).some(p=>p.target===i&&p.name.normalize("NFC")===s.normalize("NFC")))continue;r=!0;const h=this.#s[t]++,f=`${t}${this.#r}_${h}`,m=!(c?.type==="evt"&&t==="per");o in this.#i&&Ve(`[AliasEngine] Collision detected for ${t} alias "${s}". ${m?"Overwriting":"Preserving"} existing alias.`,this.#t),m&&(this.#i[o]=f),this.#o[f]={name:s,target:i,type:t,baseWord:o,collision:S(a),depth:this.#r}}return r&&this.#l++,this.getPatterns(t)}getPatterns(t,n=new Set,r){const s=[],i=r??this.#i;for(const[o,a]of q(this.#o))if(a.type===t&&!n.has(a.baseWord)){if(t==="per"){const m=i[a.baseWord],p=this.getAlias(m);if(p&&p.type==="evt")continue}n.add(a.baseWord);const c=a.name.normalize("NFC"),h=a.name.normalize("NFD"),f=c===h?ne.safeAlias(a.name):`${ne.safeAlias(c)}|${ne.safeAlias(h)}`;s.push(`(?<${o}>${f})`)}if(this.#e){const o=this.#e.getPatterns(t,n,i);o&&s.push(o)}return s.join("|")}getVersion(){return this.#l+(this.#e?.getVersion()??0)}hasAlias(t,n){const r=Ot._getBaseWord(t),s=this.#i[r];return s?n?this.#o[s].type===n:!0:!1}resolveAlias(t,n){const r=this.getAlias(t);if(!r)return;let s="";const i=A(r.target);if(A(r.target)){const o=r.target.call(n);s=S(o)?o.toString():""}else s=r.target.toString();return{value:s,key:r.baseWord,type:r.type,source:r.depth===0?"global":"local",isClock:ne.clock.test(s),isFunction:i}}getAlias(t){return this.#o[t]??this.#e?.getAlias(t)}getAliases(t,n=!1){const r=[];return q(this.#o).filter(([s,i])=>!t||i.type===t).forEach(([s,i])=>{r.push(Object.assign({},{key:s},i))}),n&&this.#e&&r.push(...this.#e.getAliases(t,!0)),r}clear(t){this.#s[t]=0;for(const n in this.#o)this.#o[n].type===t&&delete this.#o[n];this.#i=Object.create(this.#e?this.#e.#i:null),this.#s={evt:0,per:0};for(const[n,r]of q(this.#o))this.#i[r.baseWord]=n,this.#s[r.type]++;this.#l++}}const zf=new RegExp(ne.braces,"g"),Ci=/\(\?<([a-zA-Z][\w]*)>/g,Ff=/[^A-Za-z0-9_$]/g,Uf=/^[A-Za-z_$]/;class pa{#e;#t=new Pt;#r=new WeakMap;constructor(t){this.#e=t.state}get state(){return this.#e}compileRegExp(t,n){const r=this.#e,s=kn(t)?t.source:t;let i;if(n?(this.#r.has(n)||this.#r.set(n,new Pt),i=this.#r.get(n)):i=this.#t,i.has(s))return i.get(s);const o=(a,c=0)=>c>10?(Ve("[PatternCompiler] Recursion limit exceeded in matcher (d > 10) for src:",this.#e.config,a,"depth:",c),a):(a.length>=2&&a.startsWith("/")&&a.endsWith("/")&&(a=a.slice(1,-1)),a.startsWith("^")&&a.endsWith("$")&&(a=a.slice(1,-1)),a.replace(zf,(h,f)=>{const m=_n(f),p=n?.[m]?.source??n?.[f]?.source,b=r.parse.snippet[m]?.source??r.parse.snippet[f]?.source,O=r.parse.layout[m]??r.parse.layout[f],D=ls[m];let g=p??b??O??D;if(ke(g)&&f.includes(".")){const l=f.split(".")[0],u=_n(l);g=n?.[u]?.source??n?.[l]?.source??r.parse.snippet[u]?.source??r.parse.snippet[l]?.source??r.parse.layout[u]??r.parse.layout[l]??ls[u]}if(g&&f.includes(".")){let l=f.trim().replace(Ff,"_");Uf.test(l)||(l=`_${l}`),g.startsWith(`(?<${l}>`)||(g=`(?<${l}>${g})`)}return ke(g)||g===h?h:o(g,c+1)}));try{const a=Wf(o(s)),c=new RegExp(`^(${a})$`,"i");return i.set(s,c),c}catch(a){return me(a,this.#e.config,{context:"pattern compile failed",pattern:s}),new RegExp(`^${ne.escape(s)}$`,"i")}}setPatterns(){this.clearCache();const t=this.#e;t.parse.snippet={...t.parse.snippet},t.parse.pattern=new Map;const n=t.parse.snippet;if(F?.NUMBER){const s=t.config.registry?.numbers??{},i=Array.from(new Set([...ie.keys(F.NUMBER),...Object.keys(s)])).map(h=>ne.escape(h)),o=new RegExp(`(?[0-9]+|${i.sort((h,f)=>f.length-h.length).join("|")})`);n[R.nbr]=o;let a=ne.modifier.source,c=ne.modifier.source;if(t.config.registry?.modifiers){const h=["+","-","<","<=",">",">=","="],f=new Set;if(h.forEach(m=>{U(t.config.registry.modifiers[m]).forEach(p=>f.add(p))}),f.size>0){const m=Array.from(f).map(g=>ne.escape(g));m.sort((g,l)=>l.length-g.length);const p=m.join("|");a=`[\\+\\-\\<\\>][\\=]?|${p}`,c=`[\\+\\-\\<\\>][\\=]?|${p}`;const b="[\\+\\-\\<\\>]=?",O="(?:#[\\w]+|[\\w]+)",D="(?:[\\w]*)";n[R.slk]=new RegExp(`(?:${O}\\.(?:${b}|${p})?(?:[0-9]+)?${D})`,"i")}}n[R.mod]=new RegExp(`((?${a})? *)`,"i"),n[R.afx]=new RegExp(`((s)? (?${c}))?${n[R.sep]?.source||""}?`,"i")}if(F?.ORDINAL){const s=t.config.registry?.ordinals??{},o=Array.from(new Set([...ie.keys(F.ORDINAL),...Object.keys(s)])).map(a=>ne.escape(a)).sort((a,c)=>c.length-a.length).join("|");n[R.nth]=new RegExp(`(?(?:[0-9]{0,2}11th|[0-9]{0,2}12th|[0-9]{0,2}13th|[0-9]{0,2}[04-9]th|[0-9]{0,2}[02-9]1st|1st|[0-9]{0,2}[02-9]2nd|2nd|[0-9]{0,2}[02-9]3rd|3rd|[1-9][0-9]{0,2})|${o})`,"i")}const r=be(t.parse.ignore,!0);if(te(r))delete t.parse.ignorePattern;else{const s=r.filter(_).map(i=>ne.escape(i.toLowerCase())).join("|");t.parse.ignorePattern=new RegExp(`\\b(${s})\\b`,"gi")}q(t.parse.layout,!0).forEach(([s,i])=>{const o=_n(s),a=this.compileRegExp(i,n);t.parse.pattern.set(o,a)})}clearCache(){this.#t.clear(),this.#r=new WeakMap}}function et(e){(!he(e,"patternCompiler")||!e.patternCompiler)&&(e.patternCompiler=new pa({state:e})),e.patternCompiler.setPatterns()}function Wf(e){if(!e.includes("|")||!e.includes("(?<"))return e;const t=new Set,n=e.matchAll(Ci);for(const s of n)t.add(s[1]);const r=new Map;return e.replace(Ci,(s,i)=>{const o=r.get(i)??0;if(r.set(i,o+1),o===0)return s;let a=o,c=`${i}_alt${a}`;for(;t.has(c);)a++,c=`${i}_alt${a}`;return t.add(c),`(?<${c}>`})}function jf(e){const t=e.filter(i=>_(i)||ue(i)&&S(i.description)).map(i=>(ue(i)?i.description:i).toLowerCase()).filter(Boolean),n=new Set(t);let r=0;for(const i of t)i.length>r&&(r=i.length);const s=r;return{test(i){if(!i||!_(i))return!1;let o=0;const a=i.length;let c=!1;for(;o0;b--){const O=p.substring(0,b);if(n.has(O)){o+=b,f=!0,c=!0;break}}if(!f){if(h>="a"&&h<="z"||h>="A"&&h<="Z"){const b=i.substring(o).match(/^[a-zA-Z]+/);if(b){const O=b[0],D=O===O.toUpperCase(),g=o>0?i[o-1]:void 0,l=o+O.length{const o=r.findIndex(([f])=>f.description===s),a=r.findIndex(([f])=>f.description===i);if(o===-1||a===-1)return;const c=oa&&!n;(c||h)&&([r[o],r[a]]=[r[a],r[o]])}),r}const Ni=new Map(q(R,!0).map(([e,t])=>[t,e])),Bf=new Map(q(R,!0).map(([e,t])=>[e,t.description??""]).filter(([,e])=>e.length>0)),Wr=Symbol("default");function Zf(e){return{[Wr]:ga(e)}}function Hf(e,t,n=Wr){const r=t[n]??[];if(r.length===0)return e;const s=q(e),i=new Map;s.forEach(([h,f])=>{i.set(h,[h,f]);const m=h.description??"";m&&i.set(m,[h,f]);const p=Ni.get(h);p&&i.set(p,[h,f])});const o=[],a=new Set;return r.forEach(h=>{const f=ue(h),m=f?h.description??"":"",p=f?Ni.get(h):void 0,b=f?void 0:Bf.get(h)??h,O=f?i.get(h)??i.get(m)??(p?i.get(p):void 0):i.get(b)??i.get(h);O&&(a.has(O[0])||(a.add(O[0]),o.push(O)))}),s.forEach(h=>{a.has(h[0])||o.push(h)}),o.length===s.length&&o.some((h,f)=>h[0]!==s[f][0])?Object.fromEntries(o):e}function Yf({layout:e,monthDayLayouts:t,isMonthDay:n,layoutController:r,classification:s}){const i=Hf(e,r??Zf(e),s??Wr),o=q(i),a=Kf(i,t,n);return a.length!==o.length?i:a.some((h,f)=>h[0]!==o[f][0])?Object.fromEntries(a):i}function ga(e){return q(e).map(([t])=>t.description??String(t))}const Je=Bn();let Wt,jt;function Jf(e,t,n){if(cn(e)||Mn(e))return e;if(t&&n){const r=t.endsWith("/")||!n.extname(t)?t:n.dirname(t);return n.resolve(r,e)}return e}const Mi=10,ti=25;function ps(e){return e.remaining<=0?(e.warned||(e.warned=!0,console.warn(`[Tempo] Maximum config extends target budget reached (${ti}). Skipping further extends resolution.`)),!0):!1}function Pi(e,t){const n={...e,...t};if((e.registry||t.registry)&&(n.registry={...e.registry,...t.registry,formats:{...e.registry?.formats,...t.registry?.formats},locales:{...e.registry?.locales,...t.registry?.locales},numbers:{...e.registry?.numbers,...t.registry?.numbers},ordinals:{...e.registry?.ordinals,...t.registry?.ordinals}}),(e.planner||t.planner)&&(n.planner={...e.planner,...t.planner}),e.pluginOptions||t.pluginOptions){const r=P(e.pluginOptions)?e.pluginOptions:{},s=P(t.pluginOptions)?t.pluginOptions:{},i=new Set([...Object.keys(r),...Object.keys(s)]),o={};for(const a of i){if(!it(a))continue;const c=r[a],h=s[a];P(c)||P(h)?o[a]={...P(c)?c:{},...P(h)?h:{}}:o[a]=h!==void 0?h:c}n.pluginOptions=o}return(e.plugins||t.plugins)&&(n.plugins=[...U(e.plugins),...U(t.plugins)]),n}async function ya(e,t,n,r,s,i=new Set,o=0,a={remaining:ti}){if(!e||!e.extends)return e;if(o>=Mi)return console.warn(`[Tempo] Maximum config extends depth limit reached (${Mi}). Skipping further extends resolution.`),e;if(ps(a))return e;const h=U(e.extends).filter(_);if(h.length===0)return e;let f={};for(const b of h){if(ps(a))break;if(cn(b)){console.warn(`[Tempo] Remote HTTP(S) config extends is not supported, skipping: ${b}`);continue}const O=Jf(b,t,r);if(i.has(O)){console.warn(`[Tempo] Circular extends detected for config target: ${O}`);continue}const D=r?r.dirname(t):typeof process<"u"?process.cwd():"",g=new Set(i),l=await qf(O,D,n,r,s,g,o+1,a);l&&(f=Pi(f,l))}const{extends:m,...p}=e;return Pi(f,p)}const Gf=new Set([".json",".jsonc",".js",".mjs",".cjs",".ts",".mts"]);function ba(e,t,n,r){if(Mn(e)){try{const s=new URL(e);if(s.hostname&&s.hostname!=="localhost"){console.warn(`[Tempo] Remote file URL with host is not supported: ${e}`);return}}catch{console.warn(`[Tempo] Invalid file URL config target: ${e}`);return}return r?.fileURLToPath?r.fileURLToPath(e):e.replace(ws,"")}return n&&!n.isAbsolute(e)?n.resolve(t,e):e}async function qf(e,t,n,r,s,i=new Set,o=1,a={remaining:ti}){if(i.has(e))return;if(cn(e)){console.warn(`[Tempo] Remote HTTP(S) config target is not supported: ${e}`);return}if(ps(a))return;a.remaining--,i.add(e);const c=ba(e,t,r,s);if(c&&n&&n.existsSync(c))try{const h=r?r.extname(c):".json";if(h!==".json"&&h!==".jsonc"){console.warn(`[Tempo] Config extends only supports static .json and .jsonc data files, skipping: ${c}`);return}const f=await n.promises.readFile(c,"utf8"),m=Rr(f);if(m)return ya(m,c,n,r,s,i,o,a)}catch(h){console.warn(`[Tempo] Failed to load config file at ${c}:`,h)}}async function ki(e,t,n,r,s){if(cn(e)){console.warn(`[Tempo] Remote HTTP(S) config target is not supported: ${e}`);return}const i=ba(e,t,r,s);if(i&&n&&n.existsSync(i))try{const o=r?r.extname(i):".json";if(!Gf.has(o)){console.warn(`[Tempo] Unsupported configuration file format, skipping: ${i}`);return}let a;if(o===".json"||o===".jsonc"){const c=await n.promises.readFile(i,"utf8");a=Rr(c)}else if(s){const c=await import(s.pathToFileURL(i).href);a=c.default||c}if(a)return ya(a,i,n,r,s,new Set([e]),0)}catch(o){console.warn(`[Tempo] Failed to load config file at ${i}:`,o)}}function Vf(){if(Wt!==void 0)return Wt;if(Je.type!==ae.NodeJS||!A(Je.global.process?.cwd))return Wt=null;try{const e=A(Je.global.require)?Je.global.require:A(Je.global.process?.mainModule?.require)?Je.global.process.mainModule.require:null;if(e){const n=import.meta?.url,r=e("node:module")?.createRequire;return Wt=r&&n?r(n):e}let t=null;try{typeof require<"u"&&A(require)?t=require:A(Je.global.process?.mainModule?.require)&&(t=Je.global.process.mainModule.require)}catch{}if(t){const n=import.meta?.url,r=t("node:module")?.createRequire;return Wt=r&&n?r(n):t}}catch{}return Wt=null}function Xf(e){if(jt!==void 0&&!e)return jt||void 0;if(Je.type!==ae.NodeJS||!A(Je.global.process?.cwd)){jt=null;return}try{const t=Vf();if(!t){e||(jt=null);return}const n="node:fs",r="node:path",s=t(n),i=t(r);let o=e?.cwd||process.cwd();e?.configFile;const a=i.parse(o).root,c=["jsonc","json"];for(;o&&o!==a;){for(const m of c){const p=i.join(o,`tempo.config.${m}`);if(s.existsSync(p))try{const b=s.readFileSync(p,"utf8"),O=Rr(b);return e||(jt=O),O}catch(b){console.warn(`[Tempo] Found config file at ${p} but failed to parse JSONC:`,b)}}const h=i.join(o,"package.json");if(s.existsSync(h))break;const f=i.dirname(o);if(f===o)break;o=f}}catch{}jt=null}async function Qf(e){if(e?.configFile){if(cn(e.configFile)){console.warn(`[Tempo] Remote HTTP(S) configFile is not supported: ${e.configFile}`);return}if(Mn(e.configFile))try{const n=new URL(e.configFile);if(n.hostname&&n.hostname!=="localhost"){console.warn(`[Tempo] Remote file URL with host is not supported: ${e.configFile}`);return}}catch{console.warn(`[Tempo] Invalid file URL configFile: ${e.configFile}`);return}}const t=Bn();if(!(t.type!==ae.NodeJS||!A(t.global.process?.cwd)))try{const n="node:fs",r="node:url",s="node:path",[i,o,a]=await Promise.all([import(n),import(s),import(r)]);let c=e?.cwd||process.cwd();if(e?.configFile){const f=Mn(e.configFile)?e.configFile:o.resolve(c,e.configFile);return await ki(f,c,i,o,a)}const h=o.parse(c).root;for(;c&&c!==h;){const f=o.join(c,"package.json"),m=[".mts",".ts",".mjs",".js",".jsonc",".json"];for(const b of m){const O=o.join(c,`tempo.config${b}`);if(i.existsSync(O))try{const D=await ki(O,c,i,o,a);if(D)return D}catch(D){console.warn(`[Tempo] Found config file at ${O} but failed to load it:`,D);continue}}if(i.existsSync(f))break;const p=o.dirname(c);if(p===c)break;c=p}}catch{}}function ed(e){const t=ve({get(n){const r=String(n).trim().toLowerCase();return e().weakCache.get(r)},has(n){const r=String(n).trim().toLowerCase();return e().weakCache.has(r)},set(n,r){const s=String(n).trim().toLowerCase();return e().weakCache.set(s,r),this},getOrSet(n,r){const s=String(n).trim().toLowerCase();return e().weakCache.getOrSet(s,r)},delete(n){const r=String(n).trim().toLowerCase();return e().weakCache.delete(r)},clear(){e().weakCache.clear()},get isWeakCache(){return!0}});return ve({get(n){const r=String(n).trim().toLowerCase();return e().cache.get(r)},has(n){const r=String(n).trim().toLowerCase();return e().cache.has(r)},set(n,r){const s=String(n).trim().toLowerCase();return e().cache.set(s,String(r)),this},setStatic(n,r){const s=String(n).trim().toLowerCase();return e().cache.setStatic(s,String(r)),this},delete(n){const r=String(n).trim().toLowerCase();return e().cache.delete(r)},deletePrefix(n){const r=String(n).trim().toLowerCase();return e().cache.deletePrefix(r)},clear(n){e().cache.clear(n)},entries(){return e().cache.entries()},fromEntries(n){for(const[r,s]of n){const i=String(r).trim().toLowerCase();e().cache.set(i,String(s))}return this},toJSON(){return e().cache.toJSON()},weak:t})}let td=(()=>{let e=[_e("ScopedSet")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),Re(r,n)}#e=new Set;#t;constructor(s){this.#t=s}has(s){return this.#e.has(s)||(this.#t?.has(s)??!1)}add(s){return this.#e.add(s),this}delete(s){return this.#e.delete(s)}clear(){this.#e.clear()}get size(){return this.#e.size}forEach(s,i){this.#e.forEach((o,a)=>s.call(i,o,a,this))}values(){return this.#e.values()}keys(){return this.#e.keys()}entries(){return this.#e.entries()}[Symbol.iterator](){return this.#e[Symbol.iterator]()}},r})();const Gt=Oe(),wa=()=>Gt.resetHooks;function nd(e){wa().add(e)}function rd(){be(ce).forEach(t=>{const n=ce[t],r=Be[t],s=Ae(Rn[t]);[n,s].filter(i=>i!=null).forEach(i=>{const o=Object.values(W);Reflect.ownKeys(i).filter(a=>!ue(a)||!o.includes(a)).forEach(a=>{Object.getOwnPropertyDescriptor(i,a)?.configurable&&delete i[a]})}),Reflect.ownKeys(r).forEach(i=>{const o=Object.getOwnPropertyDescriptor(r,i);o&&[n,s].filter(a=>a!=null).forEach(a=>{Object.isExtensible(a)||he(a,i)?Object.defineProperty(a,i,o):Ve(`[tempo] registryReset: Cannot define property '${String(i)}' on non-extensible object (property does not exist)`,{},a)})}),s&&Rt(s),Rn[t]&&Rt(Rn[t]),Rt(n)}),Gt.state&&(Gt.state.pluginsDb.terms.length=0,Gt.state.pluginsDb.plugins.length=0),Gt.extensions.length=0,Gt.installed.clear(),wa().forEach(t=>t())}function Ge(e,t){const n=Rn[e],r=ce[e],s=Ae(n)??n;if(!S(s))return;const i=(o,a,c)=>{Object.entries(a).forEach(([h,f])=>{const m=o[h];if(z(m)){x(o,h,f),S(c)&&(c[h]=f);return}if(Array.isArray(m)&&Array.isArray(f)){const p=m;f.forEach(b=>{p.some(O=>vt(O,b))||(p.push(b),S(c)&&(Array.isArray(c[h])||x(c,h,[]),c[h].some(O=>vt(O,b))||c[h].push(b)))});return}if(we(m)&&we(f)){S(c)&&!we(c[h])&&x(c,h,{}),i(m,f,S(c)?c[h]:void 0);return}})};i(s,t,r),Rt(s),n&&Rt(n),r&&Rt(r)}function $i(e,t){if(!!(e?.isBoundedCache||e instanceof It))return e;if(e instanceof Map||e&&A(e.entries)){const r=t??new It;for(const[s,i]of e.entries())r.setStatic(String(s).trim().toLowerCase(),String(i));return r}else{if(t&&(t.isBoundedCache||t instanceof It))return S(e?.maxSize)&&(t.maxSize=e.maxSize),S(e?.ttl)&&(t.ttl=e.ttl),t;{const r=e?.maxSize??1e3,s=e?.ttl??1440*60*1e3;return new It(r,s)}}}function xi(e={},t=!0,n,r){const s=Oe();if(t&&s.state&&!n)return s.state.cache=$i(e.cache,s.state.cache),s.state;const{timeZone:i,calendar:o}=lt(),a=n?{terms:[...n.pluginsDb.terms],plugins:[...n.pluginsDb.plugins]}:{terms:[],plugins:[]};Ye(a),Ye(a.terms),Ye(a.plugins);const c=n?Object.create(n):{config:{},parse:{},pluginsDb:a,userProvidedKeys:new Set};n&&(c.config=Object.create(n.config),n.config.registry&&(c.config.registry=Object.create(n.config.registry)),c.parse=Object.create(n.parse),c.userProvidedKeys=new Set(n.userProvidedKeys),c.installed=new td(s.installed),c.pluginsDb=a),c.options=e;const h=n?.cache??s.state?.cache??r;c.cache=$i(e.cache,h),c.weakCache=n?new Pt:s.state?.weakCache??new Pt;const f={token:R,result:[],snippet:Object.assign({},n?.parse.snippet??Xt),layout:Object.assign({},n?.parse.layout??ls),event:Object.assign({},n?.parse.event??af),period:Object.assign({},n?.parse.period??cf),ignore:n?{...n.parse.ignore}:Object.fromEntries(U(lf).map(p=>[p,p])),monthDay:n?{...n.parse.monthDay,locales:[...U(n.parse.monthDay.locales)],layouts:[...U(n.parse.monthDay.layouts)],timezones:{...n.parse.monthDay.timezones},...n.parse.monthDay.resolvedLocales?{resolvedLocales:n.parse.monthDay.resolvedLocales.map(p=>({...p,timeZones:[...p.timeZones]}))}:{}}:Us({},oe.monthDay),planner:n?{...n.parse.planner.layoutOrder?{layoutOrder:[...U(n.parse.planner.layoutOrder)]}:{},...S(n.parse.planner.preFilter)?{preFilter:!!n.parse.planner.preFilter}:{}}:{layoutOrder:[...U(oe.planner?.layoutOrder??oe.layoutOrder)],preFilter:!!(oe.planner?.preFilter??oe.preFilter)},pivot:n?.parse.pivot??oe.pivot,mode:n?.parse.mode??oe.mode,lazy:!1,pattern:new Map(n?.parse.pattern),...n?{...S(n.parse.isAnchored)?{isAnchored:n.parse.isAnchored}:{},...S(n.parse.anchor)?{anchor:n.parse.anchor}:{},...S(n.parse.format)?{format:n.parse.format}:{},...S(n.parse.term)?{term:n.parse.term}:{},...S(n.parse.guard)?{guard:n.parse.guard}:{}}:{}};c.parse=He(f);const m=Object.fromEntries(Object.entries(oe).filter(([p])=>F.CONFIG.has(p)));if(t){He(Object.assign(c.config,m)),c.config.registry&&(c.config.registry={...c.config.registry,modifiers:{...c.config.registry.modifiers??{}}});const{timeZone:p,calendar:b}=lt();Hr(c.config,{calendar:b,timeZone:p,locale:lt().locale??"en-US",discovery:Symbol.keyFor(W.$Tempo),formats:Q(ce.FORMAT,!1),sphere:tn(p),scope:"global",catch:e.catch??!1,silent:e.silent??!1,intl:{}}),Object.defineProperty(c.config,"get",{value:function(O){return this[O]},enumerable:!1,writable:!0,configurable:!0})}else n?(c.config=He(Object.create(n.config)),n.config.registry&&(c.config.registry=Object.create(n.config.registry)),c.parse=Object.create(n.parse),Hr(c.config,{scope:"local",catch:e.catch??n.config.catch??!1,silent:e.silent??n.config.silent??!1,intl:Object.create(n.config.intl||{})}),Object.defineProperty(c.config,"get",{value:function(p){return this[p]},enumerable:!1,writable:!0,configurable:!0})):(He(Object.assign(c.config,m)),c.config.registry&&(c.config.registry={...c.config.registry,modifiers:{...c.config.registry.modifiers??{}}}),Hr(c.config,{calendar:o,timeZone:i,locale:lt().locale??"en-US",discovery:Symbol.keyFor(W.$Tempo),formats:Q(ce.FORMAT,!1),sphere:tn(i),scope:"local",silent:e.silent??!1,intl:{}}),Object.defineProperty(c.config,"get",{value:function(p){return this[p]},enumerable:!1,writable:!0,configurable:!0}),S(e.catch)&&x(c.config,"catch",e.catch),S(e.silent)&&x(c.config,"silent",e.silent));return c.OPTION=new Set(Object.keys(m)),c.ZONED_DATE_TIME=new Set(["year","month","day","hour","minute","second","millisecond","microsecond","nanosecond","offset","timeZone","calendar"]),t&&(s.state=c),c}const sd=Object.assign(Object.create(null),{timezone:"timeZone",timestamp:"timeStamp",monthday:"monthDay",errorhandling:"error"});function id(e,t){let n=!1;const r=()=>{(e.parse.monthMap||e.parse.weekdayMap)&&(delete e.parse.monthMap,delete e.parse.weekdayMap,e.parse.snippet[R.mm]=Xt[R.mm],e.parse.snippet[R.wkd]=Xt[R.wkd],e.parse.localizedEvents&&(e.parse.localizedEvents.forEach(i=>{delete e.parse.event[i]}),delete e.parse.localizedEvents),n=!0)};q(t).forEach(([i,o])=>{if(z(o))return;const a=_(i)?sd[i.toLowerCase()]??i:i;e.userProvidedKeys.add(a),e.userProvidedKeys.add(i);const c=A(o)&&e.config?.scope!=="local",h=["timeZone","calendar","locale","sphere","pivot"].includes(a)&&!c?re(o):o,f=xt(h);switch(a){case"error":{switch(String(f.value).toLowerCase()){case"throw":z(t.catch)&&x(e.config,"catch",!1),z(t.silent)&&x(e.config,"silent",!1);break;case"catch":z(t.catch)&&x(e.config,"catch",!0),z(t.silent)&&x(e.config,"silent",!1);break;case"silent":z(t.catch)&&x(e.config,"catch",!0),z(t.silent)&&x(e.config,"silent",!0);break;case"log":z(t.catch)&&x(e.config,"catch",!0),z(t.silent)&&x(e.config,"silent",!1),z(t.debug)&&x(e.config,"debug",dr("warn"));break;default:me(`[Tempo#extend] Invalid error option policy: ${String(f.value)}. Expected 'throw', 'catch', 'silent', or 'log'.`,e.config);break}break}case"monthDay":e.parse.monthDay=Us(f.value,e.parse.monthDay);break;case"timeZone":{const m=String(f.value).toLowerCase(),p=t.timeZones?.[m]??e.config.timeZones?.[m]??F.TIMEZONE[m]??zs(String(f.value));x(e.config,"timeZone",c?o:p),S(t.sphere)||e.userProvidedKeys?.has("sphere")&&S(e.config.sphere)||x(e.config,"sphere",tn(p));break}case"calendar":x(e.config,"calendar",c?o:String(f.value));break;case"locale":{if(c){x(e.config,"locale",o);break}const m=Lo(f.value);m&&(x(e.config,"locale",m),bi(m)&&r());break}case"localeInfo":x(e.config,"localeInfo",!!f.value);break;case"discovery":x(e.config,"discovery",f.value);break;case"registry":if(P(f.value)){if(e.config.registry={...e.config.registry,modifiers:{...e.config.registry?.modifiers??{}}},f.value.formats){const p=e.config.registry.formats?ie.extend(e.config.registry.formats,f.value.formats):f.value.formats;x(e.config.registry,"formats",p)}if(f.value.locales){const p=e.config.registry.locales?ie.extend(e.config.registry.locales,f.value.locales):f.value.locales;x(e.config.registry,"locales",p)}if(f.value.modifiers){const p=e.config.registry.modifiers??{},b={};for(const[O,D]of Object.entries(p))b[O]=[...U(D)];for(const[O,D]of Object.entries(f.value.modifiers)){const g=b[O]??[];b[O]=[...new Set([...g,...U(D)])]}x(e.config.registry,"modifiers",b),n=!0}if(f.value.tokens){const p=e.config.registry.tokens??{};x(e.config.registry,"tokens",{...p,...f.value.tokens})}if(f.value.dialects){const p=e.config.registry.dialects??{};x(e.config.registry,"dialects",{...p,...f.value.dialects})}if(f.value.numbers){const p=e.config.registry.numbers??{};x(e.config.registry,"numbers",{...p,...f.value.numbers}),e.config?.scope==="global"&&Ge("NUMBER",f.value.numbers),n=!0}if(f.value.ordinals){const p=e.config.registry.ordinals??{};x(e.config.registry,"ordinals",{...p,...f.value.ordinals}),e.config?.scope==="global"&&Ge("ORDINAL",f.value.ordinals),n=!0}const m={snippets:"snippet",layouts:"layout",events:"event",periods:"period",ignores:"ignore"};q(f.value).forEach(([p,b])=>{if(_(p)&&p in m){const O=m[p];e.userProvidedKeys.add(O),n=!0,he(e.parse,O)||(e.parse[O]=Pu(e.parse,O));const D=e.parse[O];["snippet","layout"].includes(O)?Uo(D,b,g=>{if(O==="snippet"){const l=kn(g)?g.source:String(g);return l.length>500?(me("[Tempo#extend] Snippet pattern too long (max 500 chars).",e.config),new RegExp(ne.escape(l))):ne.backtrack.test(l)?(me("[Tempo#extend] Snippet contains suspicious nested quantifiers.",e.config),new RegExp(ne.escape(l))):new RegExp(l)}return kn(g)?g.source:g}):U(b).forEach(g=>{P(g)?Object.assign(D,g):_(g)&&Object.assign(D,{[g]:g})})}})}break;case"sphere":c?x(e.config,"sphere",o):S(f.value)&&x(e.config,"sphere",f.value);break;case"geo":case"latitude":case"lat":case"longitude":case"lng":case"lon":case"long":{const m=hs(t);m&&x(e.config,"geo",m);break}case"catch":x(e.config,"catch",!!f.value);break;case"silent":x(e.config,"silent",!!f.value);break;case"pivot":{const m=parseInt(String(f.value));e.parse.pivot=Number.isFinite(m)&&m>=0&&m<=99?m:oe.pivot;break}case"mode":e.parse.mode=f.value;break;case"intl":e.config.intl=fr(e.config.intl??{},f.value);break;case"planner":S(f.value.layoutOrder)&&(e.parse.planner.layoutOrder=wi(f.value.layoutOrder)),S(f.value.preFilter)&&(e.parse.planner.preFilter=!!f.value.preFilter);break;case"layoutOrder":e.parse.planner.layoutOrder=wi(f.value);break;case"preFilter":e.parse.planner.preFilter=!!f.value;break;case"timeStamp":{const m=(_(f.value)?f.value:f.value?.unit)?.trim()?.toLowerCase();if(z(m)||!["ss","ms","us","ns"].includes(m)){me(`[Tempo#extend] Invalid timeStamp unit: ${String(m??f.value)}. Expected 'ss', 'ms', 'us', or 'ns'.`,e.config);break}x(e.config,a,m);break}case"debug":x(e.config,"debug",dr(f.value));break;case"cache":P(f.value)?(f.value.maxSize!==void 0&&(e.cache.maxSize=f.value.maxSize),f.value.ttl!==void 0&&(e.cache.ttl=f.value.ttl)):x(e.config,"cache",f.value);break;case"extends":break;case"format":x(e.config,"format",f.value);break;case"dialect":_(f.value)||A(f.value)?x(e.config,"dialect",f.value):me(`[Tempo#extend] Invalid dialect option: ${String(f.value)}. Expected a string or function.`,e.config);break;case"pluginOptions":if(P(f.value)){const m=e.config.pluginOptions??{};x(e.config,"pluginOptions",{...m,...f.value});const p=e.config.plugins??{};x(e.config,"plugins",{...p,...f.value})}break;case"plugins":if(we(f.value)&&Tt(f.value,"install","key")){const m=e.config.plugins??{};x(e.config,"plugins",{...m,...f.value});const p=e.config.pluginOptions??{};x(e.config,"pluginOptions",{...p,...f.value})}break;default:x(e.config,a,f.value);break}});const s=A(e.config.locale)&&e.config?.scope!=="local"?void 0:re(e.config.locale);if(s){const i=$r(s);if(i.length>0&&!bi(i)){const{snippets:o,monthMap:a,weekdayMap:c,events:h}=Fu(i);e.parse.monthMap=a,e.parse.weekdayMap=c,Object.assign(e.parse.snippet,o);const f=Xt[R.mm].source.replace(/^\(\?|\)$/g,""),m=Xt[R.wkd].source.replace(/^\(\?|\)$/g,"");e.parse.snippet[R.mm]=new RegExp(`(?${f}|${o.mmm})`,"i"),e.parse.snippet[R.wkd]=new RegExp(`(?${m}|${o.www})`,"i"),te(h)||(Object.assign(e.parse.event,h),e.parse.localizedEvents=Object.keys(h),e.aliasEngine&&(e.config.scope==="local"&&e.aliasEngine.depth===0&&A(e.aliasEngine.fork)&&(e.aliasEngine=e.aliasEngine.fork(e.config)),e.aliasEngine.registerAliases("evt",q(h)))),n=!0}else i.length>0&&r()}return n}const Li=Bn(),Qn=new WeakMap,od=((e,t)=>new on(e,t).ts),ad=((e,t)=>new on(e,t)),cd=((e,t,n)=>new on(t,n).format(e));let gn={},Gr=0;const Ue={bootstrap:!0,initialising:!1,extendDepth:0,ready:!1},ld={construct(e,t){const n=r=>r===null?null:r instanceof on?r:new on(r);return new e(n(t[0]),n(t[1]))}};let on=(()=>{var e,t,n,r,s,i,o,a,c,h;let f=[_s,Ft,_e("Tempo")],m,p=[],b,O=[],D;var g=b=class{static{b=this}static{zc(this,"Tempo")}static{const l=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;Ie(this,null,D,{kind:"method",name:"init",static:!0,private:!1,access:{has:u=>"init"in u,get:u=>u.init},metadata:l},null,O),Ie(null,m={value:b},f,{kind:"class",name:b.name,metadata:l},null,p),g=b=m.value,l&&Object.defineProperty(b,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:l})}static Interval=(Re(b,O),Me(new Proxy(Qo,ld)));static get enums(){return F}static get WEEKDAY(){return F.WEEKDAY}static get WEEKDAYS(){return F.WEEKDAYS}static get MONTH(){return F.MONTH}static get MONTHS(){return F.MONTHS}static get DURATION(){return F.DURATION}static get DURATIONS(){return F.DURATIONS}static get SEASON(){return F.SEASON}static get COMPASS(){return F.COMPASS}static get isInitializing(){return!Ue.ready}static get isExtending(){return Ue.extendDepth>0}static{e={value:{Tempo:Ur}}}static get versions(){return Object.freeze({...J(g,b,"f",e)})}static get version(){return J(g,b,"f",e).Tempo}static get cache(){return ed(()=>this[Z]())}static get weakCache(){return this.cache.weak}static{n={value:new Map}}static{r={value:new Set}}static get[(t=function(){return g[Z]().pluginsDb.terms},Zt)](){return this[Z]()[Zt]??{test:()=>!0}}static[rr]=!0;static[Z](){return Qn.get(this)??gn}get[wn](){return!0}static[nr](l,u,d,y){const w=u==="evt"?"event":"period",T=Fo(l),E=T.parse?.[w]??{},N=y??q(l.parse[w],!0).filter(([C,k])=>!(C in E)||l.parse[w][C]!==E[C]);if(y&&(he(l.parse,w)||(l.parse[w]={...l.parse[w]}),y.forEach(([C,k])=>{he(l.parse[w],C)||(l.parse[w][C]=k)})),N.length===0&&!he(l,"aliasEngine"))return;let M=l.aliasEngine;he(l,"aliasEngine")||(M=l.aliasEngine=new Ot({parent:T.aliasEngine,config:l.config}));const v=M.registerAliases(u,N);if(v){const C=T.parse?.snippet?.[d]?.source;v!==C&&(he(l.parse,"snippet")||(l.parse.snippet={...l.parse.snippet}),x(l.parse.snippet,d,new RegExp(v)))}else he(l.parse.snippet,d)&&(he(l.parse,"snippet")||(l.parse.snippet={...l.parse.snippet}),delete l.parse.snippet[d])}static[Sn](l,u,d=!0){this[nr](l,"evt",R.evt,u),d&&et(l)}static[Tn](l,u,d=!0){this[nr](l,"per",R.per,u),d&&et(l)}static{s={value:(l,u)=>{const d=u.sphere??u.geo?.sphere;if(S(d)){const T=re(d);if(S(T))return T}const y=hs(u)??l.config.geo??Ri();if(S(y?.sphere))return y.sphere;if(j(y?.latitude))return y.latitude>.001?"north":y.latitude<-.001?"south":"equator";const w=u.timeZone??l.config.timeZone;if(S(w)&&String(w).toLowerCase()!=="utc"){const T=tn(String(w));if(S(T))return T}}}}static{a={value:l=>{const u=Li.global;return $r(l)[0]??u?.navigator?.languages?.[0]??u?.navigator?.language??oe.locale??U(l)[0]}}}static[(i=function(u){const{timeZone:d,locale:y}=u.config,w=u.parse.monthDay,T=F.MONTH_DAY,E=J(g,b,"f",a).call(g,y);!st(E)&&!J(g,b,"f",r).has(E)&&(J(g,b,"f",r).add(E),Ve(`Invalid locale encountered in #isMonthDay: ${y}. Falling back to en-US.`,u.config));const N=$o(E),M=N.baseName,v=N.language??N.locale?.language,C=String(d);return!!(w.resolvedLocales?.find(Y=>Y.locale===M||v&&Y.locale===v)?.timeZones?.includes(C)||T.timezones?.[M]?.includes(C)||v&&T.timezones?.[v]?.includes(C)||(U(T.locales).includes(M)||v&&U(T.locales).includes(v))&&N.timeZones.includes(C))},o=function(u){const{layouts:d}=u.parse.monthDay;if(te(d))return;const y=u.parse.monthDay.isExplicit?u.parse.monthDay.active:J(g,b,"m",i).call(g,u);u.parse.monthDay.active=y;const w=y?cs.mdy:cs.dmy;u.parse.layout[R.dt]!==w&&(u.parse.layout={...u.parse.layout,[R.dt]:w});const T=(u.parse.planner.layoutOrder?.length??0)>0?{[Wr]:[...u.parse.planner.layoutOrder]}:void 0,E=Yf({layout:u.parse.layout,monthDayLayouts:d,isMonthDay:y,...qt({layoutController:T})});E!==u.parse.layout&&(u.parse.layout=E),Dn(`Resolved layout order: ${ga(E).join(" -> ")}`,u.config)},ot)](l,...u){const d=Object.assign({},...u),y=d.store,w=y?Object.assign(g.readStore(y),d):d;if(te(w))return;const T=id(l,w);let E=T;if(T&&l.config.scope==="local"&&this[wt](l),(S(w.sphere)||S(w.latitude)||S(w.lat)||S(w.geo))&&!A(w.sphere)){const M=J(g,b,"f",s).call(g,l,w);S(M)&&(l.config.sphere=M)}const N=l.parse.layout;J(g,b,"m",o).call(g,l),N!==l.parse.layout&&(E=!0),S(l.parse.event)&&(this[Sn](l,void 0,!1),E=!0),S(l.parse.period)&&(this[Tn](l,void 0,!1),E=!0),E&&(et(l),this[wt](l))}static[Ht](l,u){if(!P(u))return{};He(u);const d=l!==gn;let y=re(u.options,{})??{};if(u.timeZones){const E=Object.fromEntries(q(u.timeZones,!0).map(([N,M])=>[String(N).toLowerCase(),M]));d?y={...y,timeZones:E}:Ge("TIMEZONE",E)}if(u.monthDay){let E=u.monthDay;if(E.timezones){const N=Object.fromEntries(q(E.timezones,!0).map(([M,v])=>[st(String(M))?.baseName??String(M),v]));d?E={...E,timezones:N}:Ge("MONTH_DAY",{timezones:N})}d||(E.locales&&Ge("MONTH_DAY",{locales:U(E.locales)}),E.layouts&&Ge("MONTH_DAY",{layouts:U(E.layouts)})),y={...y,monthDay:E}}u.intl&&(y={...y,intl:u.intl}),P(u.planner)&&(y={...y,planner:u.planner}),u.terms&&this.use(U(u.terms));let w=u.registry??{};if(Object.keys(w).length>0&&(y={...y,registry:w},d||(w.formats&&Ge("FORMAT",w.formats),w.locales&&Ge("LOCALE",w.locales),w.numbers&&Ge("NUMBER",w.numbers),w.ordinals&&Ge("ORDINAL",w.ordinals))),u.pluginOptions&&we(u.pluginOptions)&&(y={...y,pluginOptions:we(y.pluginOptions)?{...y.pluginOptions,...u.pluginOptions}:u.pluginOptions}),u.plugins&&we(u.plugins)&&Tt(u.plugins,"install","key")&&(y={...y,plugins:we(y.plugins)?{...y.plugins,...u.plugins}:u.plugins,pluginOptions:we(y.pluginOptions)?{...u.plugins,...y.pluginOptions}:u.plugins}),u.ignore){const E=re(u.ignore);y={...y,ignore:E}}const T=re(y,{})??{};return l===gn&&(this[wt](),et(l)),T}static[wt](l){const u=l??this[Z](),d=[...ie.keys(F.NUMBER),...Object.keys(u.config.registry?.numbers??{}),...ie.keys(F.ORDINAL),...Object.keys(u.config.registry?.ordinals??{}),...ie.keys(F.WEEKDAY),...ie.keys(F.WEEKDAYS),...ie.keys(F.MONTH),...ie.keys(F.MONTHS),...ie.keys(F.DURATION),...ie.keys(F.DURATIONS),...ie.keys(F.TIMEZONE),...u.aliasEngine?.getAliases(void 0,!0).map(w=>w.name)??[],...be(u.parse.ignore),...be(u.parse.snippet),...be(u.parse.layout),R.slk,...J(g,b,"a",t).map(w=>w.key),...J(g,b,"a",t).map(w=>w.scope),...Xo,...u.config.registry?.modifiers?Object.values(u.config.registry.modifiers).flat():[],...ys(u.parse.layout,!0).flatMap(w=>{const T=w instanceof RegExp?w.source:_(w)?w:"";return T?T.replace(/\{[#]?[\w]+(?:\.[\w]+)*(?:\:[a-zA-Z]+)*\}/g," ").replace(/\(\?<[\w]+>/g," ").replace(/\\\\/g,"").replace(/\\\|/g,"\0").replace(/[\(\)\?\:\^\$\d\{\}\[\]]/g," ").replace(/\\(.)/g,"$1").replace(/\u0001/g,"\\").split(/[\s\|]+/).map(E=>E.replace(/\u0000/g,"|")).filter(Boolean).filter(E=>E!=="["&&E!=="]"):[]})],y=jf(d);l?(l.parse.guard=y,l[Zt]=y):(this[Z]()[Zt]=y,this[Z]().parse.guard=y),!l&&this[Z]()===gn&&et(this[Z]())}static use(...l){const u=v=>Array.isArray(v)||A(v)||Kt(v,"install","define",W.$PluginType),d=v=>we(v)&&!be(v).some(C=>Yt.has(C))&&Tt(v,"name","key","install","define",W.$PluginType)&&be(v).length>0&&be(v).every(C=>P(v[C])),y=v=>Array.isArray(v)&&v.length===2&&!Array.isArray(v[0])&&u(v[0])&&P(v[1])&&!d(v[1])&&!u(v[1]),w=v=>P(v)&&!u(v)&&!d(v),T=l.at(-1);let E=l.length>1&&(w(T)||ue(T))?l.pop():void 0;const N=v=>{const C=[];for(const k of v)y(k)?C.push(k):Array.isArray(k)?C.push(...N(k)):k!=null&&C.push(k);return C},M=N(l);if(te(M))return this;Ue.extendDepth++;try{M.forEach(v=>{let C=v,k;if(y(v)&&(C=v[0],k=v[1]),A(C)){if(C[W.$PluginType]||A(C.install)||A(C.define))k={...C.options??{},...k??{}};else if(C.length===0&&k!==void 0){const B=C(k);Kt(B,"install","define",W.$PluginType)&&(C=B,k={...B.options??{},...k??{}})}}else pe(C,"options")&&C.options&&(k={...C.options??{},...k??{}});let Y=C?.[W.$PluginType]||C?.type;if(!Y&&pe(C,"define",A)&&pe(C,"key")&&(Y="term"),!Y&&pe(C,"install",A)&&(Y="plugin"),!Y&&A(C)){const B=this[Z](),I=Oe(),H=B.installed??I.installed;if(H.has(C))return;H.add(C),Ct(C,B);const se=C.name,V=Ce(se)?B.config.pluginOptions?.[se]??B.config.plugins?.[se]:void 0,ee={...P(V)?V:{},...P(E)?E:{},...P(k)?k:{}};Ce(se)&&se!=="anonymous"&&!te(ee)&&(B.config.pluginOptions={...B.config.pluginOptions??{},[se]:ee});try{C(this,te(ee)?E:ee,X=>new this(X))}catch(X){const L=(X?.message??"").toLowerCase();if(L.includes("constructor")||L.includes("class")||L.includes("extensible")||L.includes("read only")||ur(C))Ve(`Misidentified class or frozen sandbox in plugin registration: ${C.name}`,B.config,X.stack??X);else throw X}return}if(P(C)||A(C)){const B=(I,H)=>{if(!I){const se=this[Z]().config;if(se.catch)return me(H,se),!1;throw new TypeError(H)}return!0};switch(Y){case"plugin":case"namespace":case"module":{if(!B(A(C.install),`[Tempo] Invalid ${Y} object: missing 'install()' method.`))return;const I=C.name,H=this[Z](),se=Oe(),V=H.installed??se.installed,ee=I?H.config.pluginOptions?.[I]??H.config.plugins?.[I]:void 0,X={...P(ee)?ee:{},...P(E)?E:{},...P(k)?k:{}};I&&!te(X)&&(H.config.pluginOptions={...H.config.pluginOptions??{},[I]:X});const L=P(k)&&!te(k)||P(E)&&!te(E);if(I&&V.has(I)){if(L){Ct(C,H);const ge=X;C.install.call(this,this,ge)}else Dn(`Plugin already installed by name: ${I}`,H.config);return}if(!I&&V.has(C))return;if(I?V.add(I):V.add(C),Ct(C,H),C.version&&_(I)){let ge="";Y==="plugin"?ge="Plugin":Y==="namespace"?ge="Namespace":Y==="module"?ge="Module":ge="Plugin",J(g,b,"f",e)[`${I}${I.endsWith(ge)?"":ge}`]=C.version}const Ee=te(X)?E:X;C.install.call(this,this,Ee);break}case"term":{if(!B(A(C.define),"[Tempo] Invalid term object: missing 'define()' method."))return;const I=C,H=this[Z](),se=I.scope||I.key,V=se?H.config.pluginOptions?.[se]??H.config.plugins?.[se]:void 0,ee={...P(V)?V:{},...P(E)?E:{},...P(k)?k:{}};se&&!te(ee)&&(H.config.pluginOptions={...H.config.pluginOptions??{},[se]:ee});const X=te(ee)?I:{...I,options:ee};if(J(g,b,"f",n).get(I.key)===I){te(ee)||(J(g,b,"f",n).set(I.key,X),I.scope&&J(g,b,"f",n).set(I.scope,X),ar(X,this[Z]()));return}if(J(g,b,"f",n).has(I.key)){const L=J(g,b,"f",n).get(I.key),Ee=JSON.stringify(L?.ranges)===JSON.stringify(I.ranges);if(L?.scope===I.scope&&L?.description===I.description&&Ee){Dn(`[Tempo#extend] Duplicate term registration ignored for key: "${I.key}"`,H.config),te(ee)||(J(g,b,"f",n).set(I.key,X),I.scope&&J(g,b,"f",n).set(I.scope,X),ar(X,this[Z]()));return}me(`[Tempo#extend] Term collision on key: "${I.key}". Registration aborted.`,H.config);return}if(!(I.scope&&J(g,b,"f",n).get(I.scope)===I)){if(I.scope&&J(g,b,"f",n).has(I.scope)){const L=J(g,b,"f",n).get(I.scope),Ee=JSON.stringify(L?.ranges)===JSON.stringify(I.ranges);if(!(L?.key===I.key&&L?.description===I.description&&Ee)){me(`[Tempo#extend] Term collision on scope: "${I.scope}". Registration aborted.`,H.config);return}}}J(g,b,"f",n).set(I.key,X),I.scope&&J(g,b,"f",n).set(I.scope,X);for(const L of U(I.aliases))J(g,b,"f",n).has(L)||J(g,b,"f",n).set(L,X);if(I.version){const L=I.scope||I.key;J(g,b,"f",e)[`${L}Term`]=I.version}if(ar(X,this[Z]()),I.scope&&I.ranges){const L=I.scope==="period"?"per":I.scope==="event"?"evt":void 0;if(L){const Ee=[],ge=ie.keys(g.MONTH);if(I.ranges.forEach(ye=>{if(ye.key){let Jn;S(ye.hour)?Number.isInteger(ye.hour)&&ye.hour>=0&&ye.hour<=23&&(Jn=`${ye.hour}:${Jt(ye.minute??0)}`):ye.month&&Number.isInteger(ye.month)&&ye.month>=1&&ye.month<=12&&(Jn=`${Jt(ye.day??1)} ${ge[ye.month-1]}`),Jn&&Ee.push([ye.key,Jn])}}),Ee.length>0){const ye=this[Z]();L==="per"?this[Tn](ye,Ee):L==="evt"&&this[Sn](ye,Ee)}}}break}default:{const I=v,H=this[Ht](this[Z](),I);if(te(H)||this[ot](this[Z](),H),we(I)&&!be(I).some(V=>Yt.has(V))&&Tt(I,"name","key","install")){const V=this[Z]();V.config.plugins={...V.config.plugins??{},...I},V.config.pluginOptions={...V.config.pluginOptions??{},...I}}if(I.plugins&&(Array.isArray(I.plugins)||A(I.plugins)||Kt(I.plugins,"name","key","install"))&&this.use(I.plugins),be(v).some(V=>Yt.has(V))){const V=(ue(E)?E:E?.discovery)??W.$Tempo,ee=_(V)?Symbol.for(V):V;globalThis[ee]!==v&&(globalThis[ee]=v),this[ot](this[Z](),{discovery:ee})}break}}}})}finally{Ue.extendDepth--}return Ue.extendDepth===0&&(this[wt](),et(this[Z]())),this}static create(l,u){let d={},y;A(l)?y=l:P(l)&&(d=l,A(u)&&(y=u));const w=d.discovery,T=P(w)&&!ue(w)||z(w)||ue(w)&&!Symbol.keyFor(w)?Symbol("TempoSandbox"):_(w)?Symbol.for(w):w;let E=!1;const N=class extends this{static[Symbol.toStringTag]="TempoSandbox";static[rr]=!1;static get isDisposed(){return E}static[Symbol.dispose](){E||(E=!0,globalThis[T]===M&&delete globalThis[T],Qn.delete(N))}};let M={options:{...d,discovery:T},scope:"sandbox"};P(d.discovery)&&!ue(d.discovery)&&(M={...M,...d.discovery}),globalThis[T]=M;const v=xi(d,!1,this[Z]());v.config.discovery=T,Qn.set(N,v),et(v),N[ot](v,{scope:"sandbox",discovery:T,catch:d.catch??!1},N[Ht](v,M),{...d,discovery:T});const C=d.plugins??M?.plugins;if(C&&(Array.isArray(C)||A(C)||Kt(C,"name","key","install",W.$PluginType,"type"))){let Y=C;if(Array.isArray(C)){const B=H=>we(H)&&!be(H).some(se=>Yt.has(se))&&Tt(H,"name","key","install","define",W.$PluginType),I=[];for(const H of C)B(H)?(v.config.plugins={...v.config.plugins??{},...H},v.config.pluginOptions={...v.config.pluginOptions??{},...H}):I.push(H);Y=I}te(Y)||N.use(Y)}Object.freeze(N);const k=Me(N);if(y)try{const Y=y(k);return Y&&K(Y.then)?Promise.resolve(Y).finally(()=>{k[Symbol.dispose]?.()}):(k[Symbol.dispose]?.(),Y)}catch(Y){throw k[Symbol.dispose]?.(),Y}return k}static async ready(){return"none"}static async bootstrap(l){const u=await Qf(l);return this.init(u||{}),await this.ready(),this}static init(l={}){if(Ue.initialising)return this;Ue.initialising=!0;try{Si(l.debug??oe?.debug??De.Info);const u=Oe(),d=u.state?.cache,y=!!this[rr];y&&(u.state=void 0);const w=y?void 0:Object.getPrototypeOf(this)[Z](),T=xi(l,y,w,d);T._count=0,y?gn=T:Qn.set(this,T);const E=T.parse;E.pattern??=new Map,E.monthDay=Us(oe.monthDay,F.MONTH_DAY),E.planner.layoutOrder=U(oe.planner?.layoutOrder??oe.layoutOrder),E.planner.preFilter=!!(oe.planner?.preFilter??oe.preFilter),E.pivot??=oe.pivot,E.mode??=oe.mode,E.lazy=!1;const N=lt(),M=T.config,v=re(M.timeZone,N.timeZone),C=re(M.calendar,N.calendar);let k=l.discovery??Symbol.keyFor(Bt);const Y=l.store||M.store||Symbol.keyFor(Bt);if(P(k)&&!ue(k)){const L=k;k=Symbol.for(`tempo.discovery.${Gr++}`),globalThis[k]=L}const B=_(k)?Symbol.for(k):k,I=globalThis[B],se=l.locale??M.locale??J(g,b,"f",a).call(g);he(M,"get")||Object.defineProperty(M,"get",{value:function(L){return this[L]},enumerable:!1,writable:!0,configurable:!0}),Gr=0;for(const L of Object.keys(R))L.startsWith("usr.")&&delete R[L];J(g,b,"f",n).clear(),rd(),this[ot](T,{calendar:C,timeZone:v,locale:se,discovery:B,registry:{formats:M.registry?.formats??M.formats??F.FORMAT,locales:M.registry?.locales??M.locales??je(ce.LOCALE,!0,!0)},scope:"global",catch:l.catch??M.catch??!1},{store:Y,discovery:B,scope:"global"},this.readStore(Y),this[Ht](T,T.pluginsDb),this[Ht](T,I),l),Si(T.config.debug??l.debug??oe?.debug??De.Info);const V=L=>Array.isArray(L)||A(L)||Kt(L,"name","key","install",W.$PluginType,"type"),ee=L=>we(L)&&!be(L).some(Ee=>Yt.has(Ee))&&Tt(L,"name","key","install","define",W.$PluginType),X=L=>{if(!Array.isArray(L))return L;const Ee=[];for(const ge of L)ee(ge)?(T.config.plugins={...T.config.plugins??{},...ge},T.config.pluginOptions={...T.config.pluginOptions??{},...ge}):Ee.push(ge);return Ee};return I?.plugins&&V(I.plugins)&&this.use(X(I.plugins)),l.plugins&&V(l.plugins)&&this.use(X(l.plugins)),(Li.type===ae.Browser||T.config.debug===De.Debug)&&Dn("Tempo:",this.config,T.config),et(T),Ue.ready=!0,this}catch(u){throw Ue.ready=!1,u}finally{Ue.initialising=!1,Ue.bootstrap=!1}}static setCatchMode(l){return this[ot](this[Z](),{catch:l}),this}static unloadModule(l){const u=Oe();delete u.modules[l],u.installed.delete(l);const d=l.endsWith("Module")?l.slice(0,-6):l;return u.installed.delete(d),this}static hasModule(l){const u=Oe(),d=l==="term"?"TermsModule":l;return S(u.modules[d])||u.installed.has(d)||this[Z]().pluginsDb.plugins.some(y=>y.name===d)}static readStore(l=this[Z]().config.store||Symbol.keyFor(Bt)){return Cn(l,{})}static writeStore(l,u=this[Z]().config.store||Symbol.keyFor(Bt)){return na(u,l)}static getSymbol(l){if(z(l)){const u=`usr.${++Gr}`;return R[u]=Symbol(u)}if(ue(l))return l;if(_(l)&&l.includes(".")){const u=l.split(".").at(-1);return R[l]??=Symbol(u)}return R[l]??Symbol.for(`$Tempo.${l}`)}static regexp(l,u){const d=this[Z]();return(!d.patternCompiler||d.patternCompiler.state!==d)&&(d.patternCompiler=new pa({state:d})),d.patternCompiler.compileRegExp(l,u)}static compare(l,u){const d=pe(this,wn)?this:g,y=d.isTempo(l)?l:new d(l),w=d.isTempo(u)?u:new d(u);return Number(y.nano>w.nano||-(y.nanoie.has(F.CONFIG,w))),d=Object.create(u),y=Gn(Object.getOwnPropertyDescriptors(l.config),"value","anchor","result");return Object.defineProperties(d,y),Object.defineProperty(d,"toJSON",{value:()=>Object.fromEntries(Object.entries(d)),enumerable:!1,configurable:!0}),Object.defineProperty(d,W.$Inspect,{value:()=>Object.fromEntries(Object.entries(d)),enumerable:!1,configurable:!0}),ts(je(d))}static get discovery(){const l=this.config.discovery,u=_(l)?Symbol.for(l):l;return J(g,b,"m",c).call(g,u)}static get options(){const l=this.config.store??Symbol.keyFor(Bt),u=je(Object.assign({key:l,scope:"storage"},Gn(g.readStore(l),"value")));return Object.assign({},this.default,u,this.discovery,this.config)}static from(l,u){return new this(l,u)}static now(l){const u=qe();switch(l){case"ss":return Math.trunc(u.epochMilliseconds/1e3);case"ms":return u.epochMilliseconds;case"us":return Number(u.epochNanoseconds/1000n);default:return u.epochNanoseconds}}static get epoch(){return J(g,b,"m",h).call(g,qe())}static get instant(){return Temporal.Instant.fromEpochNanoseconds(g.now())}static get terms(){const l=J(g,b,"a",t).map(({define:u,resolve:d,...y})=>{const w={...y},T=new Set;for(const E of U(w.aliases))E!==w.key&&T.add(E);return w.scope&&w.scope!==w.key&&T.add(w.scope),T.size>0&&(w.aliases=Array.from(T)),w});return Me(oo(l,u=>l.find(d=>d.key===u||d.scope===u||U(d.aliases).includes(u))))}static get registry(){return this.config.registry}static get intl(){return yi(J(g,b,"f",a).call(g,this.config.locale),this.config.timeZone)}static get properties(){return ve(Uc(g).filter(l=>dt(l)!=="Symbol"))}static get default(){return Me(Object.freeze({...oe,scope:"default",timeZone:oe.timeZone||F.TIMEZONE.utc}))}static get parse(){const l=this[Z]().parse,u={layoutOrder:[...l.planner?.layoutOrder??[]],preFilter:l.planner?.preFilter??!1};return ve({...Gn({...l},"token","planner"),snippet:{...l.snippet},layout:{...l.layout},event:{...l.event},period:{...l.period},ignore:{...l.ignore},monthDay:lo(l.monthDay),planner:u})}static[(c=function(u){const d=globalThis[u];return je(Gn({...d,scope:"discovery"},"value"))},h=function(u){return ve({ss:Math.trunc(u.epochMilliseconds/1e3),ms:u.epochMilliseconds,us:Number(u.epochNanoseconds/1000n),ns:u.epochNanoseconds})},D=[mo(gf)],Symbol.iterator)](){return g.properties[Symbol.iterator]()}static[Symbol.dispose](){g.init()}static get ignores(){return ve(be(this[Z]().parse.ignore,!0))}static[wn]=!0;static[Symbol.hasInstance](l){return pe(l,wn)}static isTempo(l){return l instanceof g}static{Oe().setHook(so,u=>{g.isExtending||g.use(u)}),nd(()=>{const u=g[W.$Internal]();u.aliasEngine&&u.aliasEngine.depth===0&&(u.aliasEngine.clear("evt"),u.aliasEngine.clear("per")),g[wt](),g[Sn](u,void 0,!1),g[Tn](u,void 0,!1),et(u)});const l=Xf();g.init(l||{}),Oe().logger=Un}#e;#t={};#r;#s;#o={};#i=!1;#a;#l;#u;#c=0;#h=0;#n={config:Me({[ji]:!0}),parse:{result:[]}};static[tr]=tr;static[es](l,u){const d=J(g,b,"a",t).length===0?". (No term plugins are registered—did you forget to call Tempo.use(TermsModule)?)":"",y=`Unknown Term identifier: ${u}${d}`;me(y,l)}[Z](){const l=Ae(this),u={get zdt(){return l.#s},set zdt(d){l.#s=d},get errored(){return l.#i},set errored(d){l.#i=d},get parseDepth(){return l.#c},set parseDepth(d){l.#c=d},get mutateDepth(){return l.#h},set mutateDepth(d){l.#h=d},get matches(){return l.#u},set matches(d){l.#u=d},get anchor(){return l.#a},set anchor(d){l.#a=d},get options(){return l.#t},get tempo(){return l.#e},get now(){return l.#y},config:l.#n.config,parse:l.#n.parse,userProvidedKeys:l.#n.userProvidedKeys,pluginsDb:l.#n.pluginsDb,aliasEngine:l.#n.aliasEngine,_id:l.#n._id,tempoInstance:l,CONFIG:F.CONFIG,PARSE:F.PARSE,ZONED_DATE_TIME:F.ZONED_DATE_TIME};return Object.setPrototypeOf(u,l.#n)}[Symbol.toPrimitive](l){switch(l){case"string":return this.toString();case"number":return this.epoch.ms;default:return this.nano}}[Symbol.iterator](){return q(this.fmt,!0)[Symbol.iterator]()}constructor(l,u={}){[this.#e,this.#t]=this.#E(l,u),Ze(this.#e)&&(this.#s=this.#e),this.#b(this.#t),this.#t=this.#n.options??{},this.#a=re(this.#t.anchor),!this.#s&&P(this.#e)&&Qr(this.#e)&&(this.#s=this.#A(this.#a).add(this.#e));const d=String(this.#e??""),y=this.#n.parse.guard||this.constructor[Zt],{mode:w}=this.#n.parse;w===F.MODE.Defer?this.#n.parse.lazy=!0:w===F.MODE.Strict?this.#n.parse.lazy=!1:_(this.#e)&&Ce(d)&&y.test(ks(d))&&(this.#n.parse.lazy=!0);const T=this.#t[Z];return P(T)?(this.#i=T.errored??!1,this.#h=T.mutateDepth??0,this.#c=0,this.#u=T.matches):this.#t[tr]&&(this.#i=!0),this.#n.parse.lazy||this.#f(),Object.freeze(this)}setCatchMode(l){return x(this.#n.config,"catch",l),this}unloadModule(l){return this.constructor.unloadModule(l),this}hasModule(l){return this.constructor.hasModule(l)}#p(){return(!this.#o.tz||!this.#o.cal)&&([this.#o.tz,this.#o.cal]=en(this.toDateTime())),[this.#o.tz,this.#o.cal]}#f(l){if(!this.#s)try{const d=[this.#n.parse.format,this.#n.parse.term,this.#n.parse.result].filter(S);if(this.#s=this.#w(this.#e,this.#a),z(this.#s)){this.#i=!0;const y=`Tempo parse returned undefined for: ${String(this.#e)}`;me(y,this.#n.config),this.#s=this.#y.toZonedDateTimeISO("UTC")}ve(this.#n.config),ve(this.#n.parse,new WeakSet(d))}catch(d){this.#i=!0;const y=`Cannot create Tempo: ${d.message} +${d.stack}`;if(this.#n.config.catch===!0)me(y,this.#n.config),this.#s=this.#y.toZonedDateTimeISO("UTC");else throw me(d,this.#n.config,y),d}const u=Ze(this.#s)?this.#s:this.#y.toZonedDateTimeISO("UTC");return l?.(u)??u}#d(l,u,d,y=!1){if(S(u)&&S(d)){const w=Object.getOwnPropertyDescriptor(l,u);if(w)return"value"in w?()=>w.value:w.get;let T=!1,E,N=!1;const M=()=>{if(!T){T=!0;try{if(!N){try{E=d.call(this,y)}catch(v){const C=(v?.message??"").toLowerCase();if(C.includes("constructor")||C.includes("class")||v instanceof TypeError||ur(d))Ve(`Misidentified class in delegator evaluate: ${String(d)}`,this.#n.config,v.stack??v),E=d;else throw v}N=!0,Reflect.isExtensible(l)&&Object.defineProperty(l,u,{value:E,enumerable:!0,configurable:!0,writable:!1})}return E}finally{T=!1}}};return Reflect.isExtensible(l)&&Object.defineProperty(l,u,{get:M,enumerable:!0,configurable:!0}),M}}#m(l){const u=Object.create(null),d=Qt(u,y=>{if(y===Wi)return this.#g(l,u);if(_(y))switch(l){case"fmt":{if(!Et(this,"FormatModule"))return;const w=Object.assign({},F.FORMAT,this.#n.config.registry?.formats);return S(w[y])?this.#d(u,y,()=>this.format(y))?.():void 0}case"term":{if(!Et(this,"TermsModule"))return;const w=J(g,b,"f",n).get(y);if(w){const T=y===w.key?!!w.scope:y!==w.scope,E=N=>{try{const M=w.define.call(this,N),v=Array.isArray(M)?ms(this,M,N):M;return P(v)?ve(v):v}catch(M){const v=Mt(M);if(v.message.includes("Class constructor"))Ve(`Misidentified class in term definition: ${y}`,this.#n.config,v.stack??v);else throw v}};return this.#d(u,y,E,T)?.()}return}default:return}},!0);return this.#n.parse.lazy||this.#g(l,u),d}#g(l,u){if(Ue.ready)switch(l){case"fmt":{if(!Et(this,"FormatModule"))return;const d=Object.assign({},F.FORMAT,this.#n.config.registry?.formats);be(d).forEach(y=>{_(y)&&this.#d(u,y,()=>this.format(y))});break}case"term":{if(!Et(this,"TermsModule"))return;J(g,b,"a",t).forEach(d=>{const y=(w,T,E)=>{try{const N=d.define?d.define.call(this,w,T,E):void 0,M=Array.isArray(N)?ms(this,N,w,T):N;return P(M)?ve(M):M}catch(N){const M=Mt(N);if(M.message.includes("Class constructor"))Ve(`Misidentified class in term discovery: ${d.key}`,this.#n.config,M.stack??M);else throw M}};this.#d(u,d.key,w=>y(w,this.toDateTime(),d.key),!!d.scope),d.scope&&this.#d(u,d.scope,w=>y(w,this.toDateTime(),d.scope),!1);for(const w of U(d.aliases))w!==d.scope&&this.#d(u,w,T=>y(T,this.toDateTime(),w),!0)});break}}}get yy(){return this.toDateTime().year}get era(){return this.toDateTime().era}get eon(){return this.toDateTime().eraYear}get yw(){return vn(this.toDateTime()).yearOfWeek}get yow(){return vn(this.toDateTime()).yearOfWeek}get wy(){return vn(this.toDateTime()).weekOfYear}get woy(){return vn(this.toDateTime()).weekOfYear}get mm(){return this.toDateTime().month}get dd(){return this.toDateTime().day}get intl(){return yi(this.locale,this.tz)}get hh(){return this.toDateTime().hour}get mi(){return this.toDateTime().minute}get ss(){return this.toDateTime().second}get ms(){return this.toDateTime().millisecond}get us(){return this.toDateTime().microsecond}get ns(){return this.toDateTime().nanosecond}get ff(){return+`0.${Jt(this.ms,3)}${Jt(this.us,3)}${Jt(this.ns,3)}`}get tz(){return this.#p()[0]}get cal(){return this.#p()[1]}get locale(){return J(g,b,"f",a).call(g,this.#n.config.locale??this[Z]().config.locale)}get geo(){if(he(this.#o,"geo"))return this.#o.geo;const l=this.#n.config.geo??this[Z]().config.geo??Ri();return this.#o.geo=l?Object.freeze({...l}):void 0}get sphere(){if(he(this.#o,"sphere"))return this.#o.sphere;const l=this[Z]().config.timeZone,u=S(this.tz)&&String(this.tz).toLowerCase()!=="utc"&&(z(l)||String(this.tz).toLowerCase()!==String(l).toLowerCase()),d=this.geo?.latitude,y=this.geo?.sphere,w=re(he(this.#n.options,"sphere")?this.#n.options?.sphere:void 0,y,j(d)?d>.001?"north":d<-.001?"south":"equator":void 0,u?()=>tn(String(this.tz)):void 0,he(this.#n.config,"sphere")?this.#n.config.sphere:void 0,()=>S(this.tz)&&String(this.tz).toLowerCase()!=="utc"?tn(String(this.tz)):void 0,this[Z]().config.sphere,oe.sphere);return this.#o.sphere=w}get ts(){return this.epoch[this.#n.config.timeStamp??"ms"]}get mmm(){return g.MONTH.keyOf(this.toDateTime().month)}get mon(){return g.MONTHS.keyOf(this.toDateTime().month)}get www(){return g.WEEKDAY.keyOf(this.toDateTime().dayOfWeek)}get wkd(){return g.WEEKDAYS.keyOf(this.toDateTime().dayOfWeek)}get dow(){return this.toDateTime().dayOfWeek}get doy(){return this.toDateTime().dayOfYear}get dim(){return this.toDateTime().daysInMonth}get jj(){const l=this.toDateTime().toPlainDate().withCalendar("iso8601");return 2440588+Math.floor(l.since(Temporal.PlainDate.from("1970-01-01"),{largestUnit:"day"}).days)}get nano(){return this.toDateTime().epochNanoseconds}get iso(){return this.toDateTime().toInstant().toString()}get isValid(){return this.#f(l=>!this.#i&&Ze(l))}get terms(){const l={};return g.terms.forEach(u=>{const d=u.ranges||u.groups||[],y=Array.isArray(d)?d:Object.values(d).flat(1/0),w=[...new Set(y.map(T=>T.key).filter(_))];l[u.key]=w}),Qt(l,u=>{if(!_(u))return;const d=g.terms.find(y=>y.key===u||y.scope===u||U(y.aliases).includes(u));return d?l[d.key]:void 0})}get ranges(){const l={};return g.terms.forEach(u=>{const d=this.term[u.key];_(d)&&(l[u.key]=d)}),Qt(l,u=>{if(!_(u))return;const d=g.terms.find(y=>y.key===u||y.scope===u||U(y.aliases).includes(u));return d?l[d.key]:void 0})}get config(){const l=this[Z]().config,u=He(Object.create(l));return Object.entries(this.#n.config).forEach(([d,y])=>x(u,d,y)),Object.defineProperty(u,"sphere",{get:()=>this.sphere,enumerable:!0,configurable:!0}),Object.defineProperty(u,"toJSON",{value:()=>Object.fromEntries(Object.entries(u)),enumerable:!1,configurable:!0}),ts(je(u))}get parse(){const l=Ae(this);l.#f();const u=Object.create(l.#n.parse),d=["anchor","isAnchored","mode","lazy","pivot"];for(const y of d)l.#n.parse[y]!==void 0&&Object.defineProperty(u,y,{value:l.#n.parse[y],enumerable:!0,configurable:!0});return Object.defineProperty(u,"result",{value:l.#u??l.#n.parse.result??[],enumerable:!0,configurable:!0}),u}get zdt(){return this.toDateTime()}get term(){return this.#l??=this.#m("term")}get fmt(){return this.#o.fmt??=this.#m("fmt")}get epoch(){return J(g,b,"m",h).call(g,this.toDateTime())}get#T(){return this.constructor}get#y(){return this.#r??=qe()}format(l,u){return this.#f(()=>at(this,"FormatModule",()=>`{${String(l)}}`,!1,l,u))}until(l,u){return this.#f(()=>at(this,"DurationModule",void 0,!1,"until",l,u)??this)}since(l,u){return this.#f(()=>at(this,"DurationModule",void 0,!1,"since",l,u)??this)}add(l,u){return this.#f(()=>at(this,"MutateModule","add",!1,l,u)??this)}plus(l,u){return this.add(l,u)}subtract(l,u){return this.#f(()=>at(this,"MutateModule","subtract",!1,l,u)??this)}sub(l,u){return this.subtract(l,u)}minus(l,u){return this.subtract(l,u)}set(l,u){return this.#f(()=>at(this,"MutateModule","set",!1,l,u)??this)}toDateTime(){return this.#f()}toPlainDate(){return this.toDateTime().toPlainDate()}toPlainTime(){return this.toDateTime().toPlainTime()}toPlainDateTime(){return this.toDateTime().toPlainDateTime()}toInstant(){return this.toDateTime().toInstant()}toNow(){const[l,u]=en(this.#n.config.timeZone,this.#n.config.calendar);return qe().toZonedDateTimeISO(l).withCalendar(u)}toDate(){return new Date(this.toDateTime().round({smallestUnit:F.ELEMENT.ms}).epochMilliseconds)}toJSON(){return{...this.#n.config,value:this.toString()}}toString(){return this.isValid&&!this.#i?this.toPlainDateTime().toString({calendarName:"never"}):String(this.#e??"")}#b(l={}){const u=this.constructor[Z](),d=l.store,w={...d?this.constructor.readStore(d):{},...l};this.#n=Object.create(u);const T=Ae(this);this.#n.config=He(Object.create(u.config)),u.config.registry&&(this.#n.config.registry=Object.create(u.config.registry)),Object.assign(this.#n.config,{scope:"local"});const E=w.timeZone??w.timezone??w.TimeZone,N=re(E),M=N??re(u.config.timeZone);let v;if(S(M)){const ge=P(M)?en(M)[0]:String(M),ye=ge.toLowerCase();v=this.constructor.timeZones?.[ye]??u.config.timeZones?.[ye]??F.TIMEZONE[ye]??zs(ge),x(this.#n.config,"timeZone",v)}const C=w.calendar??w.Calendar,k=re(C),Y=k??re(u.config.calendar);S(Y)&&x(this.#n.config,"calendar",String(Y));let B;const I=w.locale??w.Locale,H=re(I),se=H??re(u.config.locale);S(se)&&(B=Lo(se),B&&x(this.#n.config,"locale",B)),this.#n.userProvidedKeys=new Set;let V,ee;const X=w.sphere??w.Sphere??w.geo?.sphere;S(X)?(V=re(X),ee=V,x(this.#n.config,"sphere",ee),this.#n.userProvidedKeys.add("sphere")):u.userProvidedKeys?.has("sphere")&&(ee=re(u.config.sphere),x(this.#n.config,"sphere",ee));const L=hs(w);S(L)?(x(this.#n.config,"geo",L),this.#n.userProvidedKeys.add("geo"),z(ee)&&S(L.sphere)&&(ee=L.sphere,x(this.#n.config,"sphere",ee))):u.userProvidedKeys?.has("geo")&&x(this.#n.config,"geo",u.config.geo);const Ee={...w,...S(N)?{timeZone:v}:{},...S(k)?{calendar:String(Y)}:{},...S(H)?{locale:B}:{},...S(V)?{sphere:V}:{},...S(L)?{geo:L}:{}};this.#n.options=Ee,this.#n.parse=He(Object.create(u.parse)),this.#n.parse.event={...u.parse.event},this.#n.parse.period={...u.parse.period},this.#n.parse.snippet={...u.parse.snippet},this.#n.userProvidedKeys=new Set(u.userProvidedKeys),this.#n.parse.planner={...u.parse.planner.layoutOrder?{layoutOrder:[...U(u.parse.planner.layoutOrder)]}:{},...S(u.parse.planner.preFilter)?{preFilter:!!u.parse.planner.preFilter}:{}},this.#n.parse.monthDay={...u.parse.monthDay,locales:[...U(u.parse.monthDay.locales)],layouts:[...U(u.parse.monthDay.layouts)],timezones:{...u.parse.monthDay.timezones},...u.parse.monthDay.resolvedLocales?{resolvedLocales:u.parse.monthDay.resolvedLocales.map(ge=>({...ge,timeZones:[...ge.timeZones]}))}:{}},x(this.#n.parse,"result",[...w.result??[]]),Object.defineProperty(this.#n,"tempoInstance",{value:T,writable:!1,configurable:!0,enumerable:!1}),this.constructor[ot](this.#n,Ee)}#w(l,u,d){if(!Et(this,"ParseModule",!0))return this.#v(l,u,d);const y=at(this,"ParseModule","parse",!1,l,u,d);if(z(y)){const w=`ParseModule error. Could not parse ${String(l)}`;me(w,this.#n.config);return}return he(y,"value")?y.value??void 0:y}#v(l,u,d){if(Ze(l))return l;if(nt(l))return l.toDateTime();if(_(l))try{const w=this.#n.config.timeZone??"UTC";return l.includes("[")?Temporal.ZonedDateTime.from(l):Temporal.PlainDateTime.from(l).toZonedDateTime(w)}catch{}if(z(l)||te(l))return u??qe().toZonedDateTimeISO(this.#n.config.timeZone);me("Tempo ParseModule not loaded. Did you forget to Tempo.use(ParseModule)?",this.#n.config)}#A(l){return nt(l)?l.toDateTime():Ze(l)?l:S(l)?new this.constructor(l,this.#t).toDateTime():this.#y.toZonedDateTimeISO(this.#n.config.timeZone)}#E(l,u={}){if(nt(l))return[l,Object.assign({result:[...l.parse.result]},u)];let d=l;if(P(l)&&Qr(l)){const y={...Me(l)};let w=!1;for(const[T,E]of Object.entries(y)){const N=ie.has(F.ELEMENT,T)?`${F.ELEMENT[T]}s`:void 0;N&&(y[N]=E,delete y[T],w=!0)}w&&(d=y)}return this.#D(d)?[d.value,Object.assign({},d)]:[d,u]}#D(l){if(!we(l))return!1;const u=be(l);return u.some(d=>ie.has(F.MUTATION,d))||u.some(d=>ie.has(F.ZONED_DATE_TIME,d)&&!ie.has(F.CONFIG,d)||ie.has(F.DURATIONS,d))?!1:(u.some(d=>ie.has(F.CONFIG,d)||ie.has(F.PARSE,d)),!0)}static{Re(b,p)}};return g=b})();const zi=8192,ud=/\+/g,fd=/\//g,dd=/=/g,hd=/-/g,md=/_/g,pt=e=>new TextEncoder().encode(e),ni=e=>new TextEncoder().encode(yt(e)),gs=(e,t="utf-8",n)=>new TextDecoder(t,n).decode(e),ri=e=>{if(typeof Buffer<"u")return Buffer.from(e).toString("base64");let t="";for(let n=0;n{if(typeof Buffer<"u")return new Uint8Array(Buffer.from(e,"base64"));const t=atob(e),n=new Uint8Array(t.length);for(let r=0;re.replace(ud,"-").replace(fd,"_").replace(dd,""),pd=e=>Co(e.replace(hd,"+").replace(md,"/"),4,"="),gd=e=>Sa(ri(e)),Fi=e=>Sa(ri(pt(e))),qr=e=>{if(!Es.test(e)||e.length%4===1)throw new Error("Invalid base64url segment");return jr(pd(e))},Kn=globalThis.crypto,fe=Kn.subtle,le={Algorithm:"SHA-256",Encoding:"utf-8",SignKey:"RSASSA-PKCS1-v1_5",TypeKey:"AES-GCM"};let yd;const Ta=()=>yd??=fe.generateKey({name:le.TypeKey,length:128},!1,["encrypt","decrypt"]).catch(Mt);let bd;const Ea=()=>bd??=fe.generateKey({name:le.SignKey,modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:{name:le.Algorithm}},!1,["sign","verify"]).catch(Mt),wd=()=>Kn.randomUUID().split("-")[0],Sd=async(e,t,n="SHA-512",r)=>{const s=new TextEncoder,i=s.encode(t),o=s.encode(Ln(e)),a=await fe.importKey("raw",i,{name:"HMAC",hash:{name:n}},!1,["sign"]),c=await fe.sign("HMAC",a,o);return Ws(Array.from(new Uint8Array(c)),r)},Td=async(e,t,n="SHA-256")=>{const r=pt(Ln(e)),s=await fe.digest(n,r);return Ws(Array.from(new Uint8Array(s)),t)},Ed=async e=>{const t=Kn.getRandomValues(new Uint8Array(16)),n=await Ta();if(gt(n))throw new Error(`Cipher: Key generation failed: ${n.message}`,{cause:n});const r=await fe.encrypt({name:le.TypeKey,iv:t},n,ni(e)),s=new Uint8Array(16+r.byteLength);return s.set(t,0),s.set(new Uint8Array(r),16),ri(s)},Od=async e=>{const[t,n]=await Promise.all([e,Ta()]);if(gt(n))throw new Error(`Cipher: Key generation failed: ${n.message}`,{cause:n});const r=jr(t),s=r.slice(0,16),i=r.slice(16);return fe.decrypt({name:le.TypeKey,iv:s},n,i).then(o=>new Uint8Array(o)).then(gs).then(Zn)},vd=async e=>{const t=await Ea();if(gt(t))throw new Error(`Cipher: Key generation failed: ${t.message}`,{cause:t});if(!t.privateKey)throw new Error("Cipher: Missing private key");return fe.sign(le.SignKey,t.privateKey,ni(e)).then(n=>new Uint8Array(n))},Dd=async(e,t)=>{const[n,r]=await Promise.all([e,Ea()]);if(gt(r))throw new Error(`Cipher: Key generation failed: ${r.message}`,{cause:r});if(!r.publicKey)throw new Error("Cipher: Missing public key");return fe.verify(le.SignKey,r.publicKey,n,ni(t))},Oa=(e,t)=>{if(e.length!==t.length)return!1;let n=0;for(let r=0;r{const r="-----BEGIN PUBLIC KEY-----",s="-----END PUBLIC KEY-----";if(!e||!e.includes(r)||!e.includes(s))throw new Error("Invalid PEM key format");const i=e.substring(e.indexOf(r)+r.length,e.indexOf(s)).replace(Ts,""),o=jr(i);return fe.importKey("spki",o,{name:t,hash:n},!1,["verify"])},Da=async(e,t=le.SignKey,n=le.Algorithm)=>{const r="-----BEGIN PRIVATE KEY-----",s="-----END PRIVATE KEY-----";if(!e||!e.includes(r)||!e.includes(s))throw new Error("Invalid PEM key format");const i=e.substring(e.indexOf(r)+r.length,e.indexOf(s)).replace(Ts,""),o=jr(i);return fe.importKey("pkcs8",o,{name:t,hash:n},!1,["sign"])},Ad=async(e,t,n=!1)=>{if(!we(e))throw new TypeError("Cipher: JWK must be an object");if(e.kty==="RSA"){const r=e.alg==="RS512"?"SHA-512":e.alg==="RS384"?"SHA-384":"SHA-256",s=e.d?["sign"]:["verify"];return fe.importKey("jwk",e,{name:le.SignKey,hash:r},n,t??s)}if(e.kty==="oct"){const r=e.alg==="HS512"?"SHA-512":e.alg==="HS384"?"SHA-384":"SHA-256",s=["sign","verify"];return fe.importKey("jwk",e,{name:"HMAC",hash:r},n,t??s)}throw new Error(`Cipher: Unsupported JWK key type "${e.kty}"`)},Id=async e=>fe.exportKey("jwk",e),Aa=async(e,t,n=le.SignKey)=>{const r=_(e)?pt(e):e,s=await fe.sign(n,t,r);return new Uint8Array(s)},Ia=async(e,t,n,r=le.SignKey)=>{const s=_(t)?pt(t):t;return fe.verify(r,n,e,s)},si=async(e,t,n="SHA-256")=>{const r=_(t)?pt(t):t,s=_(e)?pt(e):e,i=await fe.importKey("raw",r,{name:"HMAC",hash:{name:n}},!1,["sign"]),o=await fe.sign("HMAC",i,s);return new Uint8Array(o)},Ra=async(e,t,n,r="SHA-256")=>{const s=await si(t,n,r),i=e instanceof Uint8Array?e:e instanceof ArrayBuffer?new Uint8Array(e):new Uint8Array(e.buffer,e.byteOffset,e.byteLength);return Oa(s,i)},Rd=async()=>fe.generateKey({name:le.SignKey,modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:{name:le.Algorithm}},!0,["sign","verify"]),Er=new Uint8Array([77,70,83,49]),_a=16,Ca=12,Na=Er.length+_a+Ca;async function Ma(e,t,n=1e5,r=["encrypt","decrypt"]){const s=_(e)?pt(e):e,i=await fe.importKey("raw",s,"PBKDF2",!1,["deriveKey"]);return fe.deriveKey({name:"PBKDF2",salt:t,iterations:n,hash:"SHA-256"},i,{name:le.TypeKey,length:256},!1,r)}async function _d(e,t,n=1e5){if(!Ce(t))throw new TypeError("Cipher: A non-empty password string is required for encryption.");const r=Kn.getRandomValues(new Uint8Array(_a)),s=Kn.getRandomValues(new Uint8Array(Ca)),i=await Ma(t,r,n,["encrypt"]),o=_(e)?pt(e):e instanceof Uint8Array?e:e instanceof ArrayBuffer?new Uint8Array(e):new Uint8Array(e.buffer,e.byteOffset,e.byteLength),a=await fe.encrypt({name:le.TypeKey,iv:s},i,o),c=new Uint8Array(Na+a.byteLength);return c.set(Er,0),c.set(r,4),c.set(s,20),c.set(new Uint8Array(a),32),c}async function Cd(e,t,n=1e5){if(!Ce(t))throw new TypeError("Cipher: A non-empty password string is required for decryption.");const r=e instanceof Uint8Array?e:e instanceof ArrayBuffer?new Uint8Array(e):new Uint8Array(e.buffer,e.byteOffset,e.byteLength);if(r.lengthu.trim());switch(D){case"FREQ":r=g.toUpperCase();break;case"INTERVAL":{const u=parseInt(g,10);s=j(u)&&u>0?u:1;break}case"COUNT":{const u=parseInt(g,10);i=j(u)&&u>0?u:void 0;break}case"UNTIL":{if($d.test(g)){const u=parseInt(g.slice(0,4),10),d=parseInt(g.slice(4,6),10),y=parseInt(g.slice(6,8),10);sn(u,d,y)&&(o=br(u,d,y,23,59,59,999))}else{const u=g.match(Ui);if(u){const d=parseInt(u[1],10),y=parseInt(u[2],10),w=parseInt(u[3],10),T=S(u[4])?parseInt(u[4],10):0,E=S(u[5])?parseInt(u[5],10):0,N=S(u[6])?parseInt(u[6],10):0;sn(d,y,w)&&(o=br(d,y,w,T,E,N,0))}if(!j(o)){const d=g.replace(Ui,"$1-$2-$3T$4:$5:$6Z"),y=new Date(d);o=j(y.getTime())?y.getTime():void 0}}break}case"BYMONTH":{const u=l.map(d=>{const y=parseInt(d,10);if(j(y)&&y>=1&&y<=12)return y;const w=d.slice(0,3).toUpperCase();return w in as?as[w]:void 0}).filter(d=>S(d));u.length>0&&(a=u);break}case"BYDAY":{const u=l.map(d=>{const y=d.match(xd),w=y&&y[1]?parseInt(y[1],10):void 0,E=(y?y[2]:d).slice(0,2).toUpperCase();return{nth:j(w)?w:void 0,day:E}}).filter(d=>d.day in ct);u.length>0&&(c=u);break}case"BYHOUR":{const u=l.map(d=>parseInt(d,10)).filter(d=>j(d)&&d>=0&&d<=23);u.length>0&&(h=u);break}case"BYMINUTE":{const u=l.map(d=>parseInt(d,10)).filter(d=>j(d)&&d>=0&&d<=59);u.length>0&&(f=u);break}case"BYSETPOS":{const u=l.map(d=>parseInt(d,10)).filter(j);u.length>0&&(m=u);break}}}return{freq:r,interval:s,count:i,untilMs:o,byMonth:a,byDay:c,byHour:h,byMinute:f,bySetPos:m}}function ka(e,t,n){const r=Pa(e),s=new Date(t),i=[],o=S(r.count)&&S(n?.count)?Math.min(r.count,n.count):r.count??n?.count??100;let a=0,c=0,h=0;const f=1e3,{year:m,month:p,day:b,hours:O,minutes:D,seconds:g,milliseconds:l}=wr(t);for(;c0){const E=Math.floor(T.getTime()/_t),N=ft(E);u=r.byDay.map(M=>{const C=((M.day in ct?ct[M.day]:1)-N+ir)%ir;return or(T,C)})}else u=[T];break}case"MONTHLY":{const T=m*12+(p-1)+h*r.interval,E=Math.floor(T/12),N=T%12+1;if(r.byDay&&r.byDay.length>0){const M=yr(E,N),v=[],C=mt(E,N,1);for(const k of r.byDay){const Y=k.day in ct?ct[k.day]:1,B=[];for(let I=1;I<=M;I++)ft(C+I-1)===Y&&B.push(Vt({year:E,month:N,day:I,hours:O,minutes:D,seconds:g,milliseconds:l}));S(k.nth)?k.nth>0&&k.nth<=B.length?v.push(B[k.nth-1]):k.nth<0&&Math.abs(k.nth)<=B.length&&v.push(B[B.length+k.nth]):v.push(...B)}u=v}else sn(E,N,b)&&(u=[Vt({year:E,month:N,day:b,hours:O,minutes:D,seconds:g,milliseconds:l})]);break}case"YEARLY":{const T=m+h*r.interval,E=r.byMonth&&r.byMonth.length>0?r.byMonth:[p],N=[];for(const M of E)if(r.byDay&&r.byDay.length>0){const v=yr(T,M),C=mt(T,M,1);for(const k of r.byDay){const Y=k.day in ct?ct[k.day]:1,B=[];for(let I=1;I<=v;I++)ft(C+I-1)===Y&&B.push(Vt({year:T,month:M,day:I,hours:O,minutes:D,seconds:g,milliseconds:l}));S(k.nth)?k.nth>0&&k.nth<=B.length?N.push(B[k.nth-1]):k.nth<0&&Math.abs(k.nth)<=B.length&&N.push(B[B.length+k.nth]):N.push(...B)}}else sn(T,M,b)&&N.push(Vt({year:T,month:M,day:b,hours:O,minutes:D,seconds:g,milliseconds:l}));u=N;break}case"DAILY":{u=[or(s,h*r.interval)];break}default:throw new Error(`Unsupported RRULE frequency: ${r.freq}`)}r.byMonth&&r.byMonth.length>0&&r.freq!=="YEARLY"&&(u=u.filter(T=>r.byMonth.includes(T.getUTCMonth()+1)));const d=[];for(const T of u){const{hours:E,minutes:N}=wr(T.getTime()),M=r.byHour&&r.byHour.length>0?r.byHour:[E],v=r.byMinute&&r.byMinute.length>0?r.byMinute:[N];for(const C of M)for(const k of v)d.push(qo(T,{hours:C,minutes:k,seconds:g,milliseconds:l}))}d.sort((T,E)=>T.getTime()-E.getTime());let y=d;if(r.bySetPos&&r.bySetPos.length>0&&d.length>0){y=[];for(const T of r.bySetPos)T>0&&T<=d.length?y.push(d[T-1]):T<0&&Math.abs(T)<=d.length&&y.push(d[d.length+T])}h++;let w=!1;for(const T of y){a++;const E=T.getTime();if(S(r.untilMs)&&E>r.untilMs){w=!0;break}if(S(r.count)&&a>r.count){w=!0;break}if(S(n?.beforeMs)&&E>n.beforeMs){w=!0;break}if(!(S(n?.afterMs)&&E<=n.afterMs)&&(i.push(E),c++,c>=o)){w=!0;break}}if(w)break}return i}function Fd(e,t){const n=ka(e,t,{count:1,afterMs:t});return n.length>0?n[0]:null}function yn(e,t,n){const r=e.trim();if(!Os(r))throw new Error(`Invalid numeric cron token: "${e}"`);const s=Number(r);if(sn)throw new Error(`Cron token out of range [${t}-${n}]: "${e}"`);return s}function bn(e,t,n){const r=new Set;if(e==="*"||e==="?"){for(let i=t;i<=n;i++)r.add(i);return{allowed:r,restricted:!1}}const s=e.split(",");for(const i of s)if(i.includes("/")){const o=i.split("/");if(o.length!==2)throw new Error(`Invalid step expression: ${i}`);const[a,c]=o;if(!Os(c.trim()))throw new Error(`Invalid step value: ${c}`);const h=Number(c.trim());if(h<=0)throw new Error(`Invalid step value: ${c}`);let f=t,m=n;if(a!=="*")if(a.includes("-")){const p=a.split("-");if(p.length!==2)throw new Error(`Invalid range: ${a}`);if(f=yn(p[0],t,n),m=yn(p[1],t,n),f>m)throw new Error(`Invalid range: ${a}`)}else throw new Error(`Invalid step expression range: "${a}/${c}"`);for(let p=f;p<=m;p+=h)r.add(p)}else if(i.includes("-")){const o=i.split("-");if(o.length!==2)throw new Error(`Invalid range: ${i}`);const a=yn(o[0],t,n),c=yn(o[1],t,n);if(a>c)throw new Error(`Invalid range: ${i}`);for(let h=a;h<=c;h++)r.add(h)}else r.add(yn(i,t,n));return{allowed:r,restricted:!0}}function ii(e){const t=e.trim().split(Ss);if(t.length!==5)throw new Error("Invalid cron pattern. Expected 5 fields (min, hr, dom, mon, dow).");return{minutes:bn(t[0],0,59),hours:bn(t[1],0,23),daysOfMonth:bn(t[2],1,31),months:bn(t[3],1,12),daysOfWeek:bn(t[4],0,7)}}function Ud(e){if(!_(e))return!1;const t=e.trim();if(t.startsWith("FREQ=")||t.startsWith("RRULE:")||t.split(Ss).length!==5)return!1;try{return ii(t),!0}catch{return!1}}function Wd(e,t,n){const r=e.daysOfMonth.allowed.has(t),s=e.daysOfWeek.allowed.has(n)||n===7&&e.daysOfWeek.allowed.has(0);return e.daysOfMonth.restricted&&e.daysOfWeek.restricted?r||s:r&&s}function $a(e,t,n,r){const s=ii(e),i=Temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(n),o=r===1,a=i.second===0&&i.millisecond===0&&i.microsecond===0&&i.nanosecond===0;let c=o?i.add({minutes:1}).with({second:0,millisecond:0,microsecond:0,nanosecond:0}):a?i.subtract({minutes:1}).with({second:0,millisecond:0,microsecond:0,nanosecond:0}):i.with({second:0,millisecond:0,microsecond:0,nanosecond:0});const h=o?c.add({years:5}).epochMilliseconds:c.subtract({years:5}).epochMilliseconds,f=o?"Could not find next cron match within 5 years.":"Could not find previous cron match within 5 years.";for(;;){if(o?c.epochMilliseconds>h:c.epochMilliseconds{if(!e||e.length>Bd){if(t?.strict)throw new Error("JWT too large: Exceeds maximum length.");return null}const n=e.split(".");if(n.length!==3){if(t?.strict)throw new Error("Invalid JWT format: Expected 3 segments (header.payload.signature)");return null}if(n[1].length>Zd){if(t?.strict)throw new Error("JWT payload too large: Encoded segment exceeds maximum length.");return null}try{const r=gs(qr(n[0]),le.Encoding,{fatal:!0}),s=gs(qr(n[1]),le.Encoding,{fatal:!0}),i=qr(n[2]),o=JSON.parse(r),a=JSON.parse(s);if(!we(o)||!we(a))throw new Error("Invalid JWT shape");return{header:o,payload:a,signature:i,raw:{header:n[0],payload:n[1],signature:n[2]}}}catch{if(t?.strict)throw new Error("Invalid JWT: Segment decoding failed.");return null}};async function Hd(e,t,n){try{if(!_(n)||!n)return St.error('VERIFY_ERROR: Missing or invalid "expectedAlg" parameter'),!1;const r=xa(e);if(!r)return!1;const{header:s,signature:i,raw:o}=r,a=`${o.header}.${o.payload}`,c=s.alg;if(!_(c)||!c)return St.error('VERIFY_ERROR: Missing or invalid "alg" header parameter'),!1;if(c!==n)return St.error(`VERIFY_ERROR: Algorithm mismatch. Expected "${n}", got "${c}"`),!1;if(n==="RS256"){const h=_(t)?await va(t):t;return await Ia(i,a,h,le.SignKey)}return n==="HS256"||n==="HS384"||n==="HS512"?_(t)&&t.includes("-----BEGIN ")&&t.includes("KEY-----")?(St.error("VERIFY_ERROR: Refusing to use asymmetric PEM key as HMAC secret"),!1):await Ra(i,a,t,n==="HS512"?"SHA-512":n==="HS384"?"SHA-384":"SHA-256"):(St.error(`VERIFY_ERROR: Unsupported algorithm "${n}"`),!1)}catch(r){return St.error("VERIFY_ERROR:",r.stack),!1}}async function Yd(e,t,n={alg:"RS256",typ:"JWT"}){if(an(e))throw new TypeError("WebToken: Payload must be a non-null object");const r=JSON.stringify(e);if(!r||!we(JSON.parse(r)))throw new TypeError("WebToken: Payload must be a non-null object");try{const s=n?.alg??"RS256",i={typ:"JWT",...n,alg:s},o=Fi(JSON.stringify(i)),a=Fi(r),c=`${o}.${a}`;let h;if(s==="RS256"){const f=_(t)?await Da(t):t;h=await Aa(c,f,le.SignKey)}else if(s==="HS256"||s==="HS384"||s==="HS512"){if(_(t)&&t.includes("-----BEGIN ")&&t.includes("KEY-----"))throw new TypeError("WebToken: Refusing to use asymmetric PEM key as HMAC secret");h=await si(c,t,s==="HS512"?"SHA-512":s==="HS384"?"SHA-384":"SHA-256")}else throw new Error(`WebToken: Unsupported algorithm "${s}"`);return`${c}.${gd(h)}`}catch(s){throw St.error("SIGN_ERROR:",s.stack),s}}const Jd=Object.freeze(Object.defineProperty({__proto__:null,parseJWT:xa,signJWS:Yd,verifyJWS:Hd},Symbol.toStringTag,{value:"Module"})),Gd=Object.freeze(Object.defineProperty({__proto__:null,Aborter:Yu,CACHE:Ao,COMPASS:go,CONFIG:Do,CONTEXT:ae,Computed:un,DAYS_IN_WEEK:ir,DAY_MAP:ct,DEFAULTS:Be,DISCOVERY:Yt,DURATION:Cs,DURATIONS:Ns,Default:oe,ELEMENT:Eo,Enum:ie,FORMAT:Mr,Finalizer:zn,Guard:Xo,ISO_WEEKDAY_NAMES:ef,Immutable:Ft,Interval:Qo,LIMIT:Ms,LOCALE:kr,MODE:Ps,MONTH:wo,MONTHS:So,MONTH_DAY:Pr,MONTH_MAP:as,MS_PER_DAY:_t,MS_PER_HOUR:hr,MS_PER_MINUTE:mr,MS_PER_SECOND:pr,MUTATION:Oo,Match:ne,Mutable:mo,NOOP:Wn,NUMBER:_r,ORDINAL:Cr,PARSE:Io,Pledge:ea,REGISTRIES:Rn,RE_BASE64:Qi,RE_BASE64URL:Es,RE_BIGINT_LITERAL:bs,RE_COMBINING_MARKS:Vi,RE_DIGITS:Yi,RE_FILE_URL:ws,RE_HEX:Xi,RE_HEX_8:Va,RE_HTTP_URL:qi,RE_INTEGER:Ji,RE_REGEXP_LITERAL:Gi,RE_UUID:eo,RE_WHITESPACE:Ss,RE_WHITESPACES:Ts,Reactive:df,ReactiveSource:js,SEASON:po,STATE:ce,Securable:al,Serializable:_s,get Signal(){return jn},get Signify(){return Xe},Singleton:ll,Snippet:Xt,State:Ks,StateFlag:Ne,Static:cl,StringTag:_e,TIMEOUT_MAX:jo,TIMEZONE:Nr,Tempo:on,TermHook:Nc,Token:R,WEEKDAY:yo,WEEKDAYS:bo,Watcher:Bs,WeakCache:Pt,ZONED_DATE_TIME:vo,anySignal:Bo,asArray:U,asError:Mt,asInteger:Zl,asNumber:$s,asObject:In,asString:Ln,asText:Ul,asTime:Ku,asType:xt,assertCondition:As,assertNever:Tc,assertString:ro,attachStatics:la,autoInstall:_f,byKey:Tr,byLkp:Nf,cartesian:da,cast:Me,cipher:Nd,civilToDays:mt,cleanify:Rs,cleanupSignal:Gu,clear:Mf,clearCache:Rt,cloneify:Gc,computed:Jo,conceal:Fl,countProperties:Cc,currentComputed:Yo,curry:co,daysToCivil:Fr,deepFreeze:$n,deepMerge:fr,defineInterpreterModule:If,defineModule:ca,defineNamespace:Rf,definePlugin:ua,defineRange:kf,defineTerm:ha,delegate:Qt,delegator:Kc,distinct:Or,dynamicProxy:ts,effect:Go,ensureModule:Et,enumify:Q,enums:F,ephemeral:Bc,epoch:Gl,epochMsFromParts:br,evaluate:re,evaluateAsync:wf,evaluateConfig:Sf,evaluateConfigAsync:Tf,evaluateString:bf,evaluateWith:yf,expandRRuleEpochs:ka,extend:_c,extract:Vr,fix:ju,fmtTempo:cd,fromIsoWeek:sf,fromRoman:Ko,fromUtcParts:Vt,getContext:Bn,getDaysInMonth:yr,getHost:fn,getISOWeekOfYear:vn,getIsoWeek:Vo,getMethods:Ac,getNextCronEpoch:jd,getNextRRuleEpoch:Fd,getOffsets:xs,getPrevCronEpoch:Kd,getRuntime:Oe,getSafeTag:Dr,getStamp:od,getTempo:ad,getTemporalIds:en,getTermRange:ms,getType:dt,hasAnyOf:Kt,hasKey:pe,hasKeys:Za,hasNoneOf:Tt,hasOwn:he,ifDefined:qt,ifNumeric:Po,indexedArray:oo,instant:qe,interpret:at,isAbortController:Sc,isAbortSignal:Ir,isArray:ht,isArrayLike:to,isBase64:ec,isBase64Url:tc,isBoolean:lr,isCallable:K,isClass:ur,isCronString:Ud,isDST:ql,isDate:Pn,isDefined:S,isDigit:rc,isDigits:Os,isDuration:no,isDurationLike:Qr,isEmpty:te,isEnum:gc,isEqual:vt,isError:gt,isExtensible:bc,isFileUrl:Mn,isFiniteRRule:zd,isFunction:A,isHex:Qa,isHttpUrl:cn,isInstant:lc,isInteger:zt,isIntegerLike:vs,isIterable:Hi,isJSON:Zc,isLeapYear:gr,isLocale:Ar,isMap:nn,isNull:ac,isNullish:ke,isNumber:j,isNumeric:Lt,isObject:P,isPlainDate:uc,isPlainDateTime:dc,isPlainMonthDay:pc,isPlainObject:we,isPlainTime:fc,isPlainYearMonth:mc,isPledge:yc,isPrimitive:an,isPromise:Xr,isPropertyKey:ic,isRRuleString:Ld,isRawJSON:Yc,isReference:rt,isRegExp:kn,isRegExpLike:sc,isSafeKey:it,isSet:rn,isString:_,isSymbol:ue,isSymbolFor:Ds,isTarget:wc,isTemporal:cc,isText:Ce,isType:de,isUndefined:z,isUuid:nc,isValidDate:sn,isWhitespace:Xa,isZonedDateTime:Ze,isZonedDateTimeLike:hc,isoWeekdayFromDays:ft,logDebug:Dn,logError:me,logWarn:Ve,looseIndex:Te,makeTemplate:Pl,memoizeFunction:$e,memoizeMethod:En,normaliseFractionalDurations:Vl,normalizeUtcOffset:zs,nullishToEmpty:Yl,nullishToValue:is,nullishToZero:Hl,objectify:Zn,onAbort:xr,ownEntries:q,ownKeys:be,ownValues:ys,pad:Jt,padString:Ll,padTo:Co,parseCron:ii,parseJSONC:Rr,parseRRule:Pa,partsFromEpochMs:wr,pick:Ic,pluck:Rc,plural:Nl,protoType:vr,proxify:je,randomString:_l,rawJSON:Hc,registerPlugin:Ct,registerType:Nt,resetRegistry:Ja,resolveCycleWindow:$f,resolveDayOfYear:rf,resolveFractionalSeconds:cu,resolveIsoCalendarYear:of,resolveRangeDiff:ma,resolveRangeFormat:Lf,resolveRangeOrdinal:xf,resolveTwoDigitYear:au,reveal:zl,revocable:ao,secure:ve,secureRef:io,shiftDateByDays:or,get signify(){return kt},singular:Ml,sortBy:fa,sortInsert:Cf,sortKey:ei,split:Wu,sprintf:Cl,stringify:yt,stripJSONC:Is,strlen:xl,suffix:Uu,tap:Pf,timeoutSignal:Ju,toCamelCase:Il,toHex:Ws,toInstant:ou,toLower:kl,toPlainDate:iu,toProperCase:_o,toRoman:Hu,toTitleCase:Dl,toUpper:$l,toZonedDateTime:Ls,today:ko,trimAll:ks,unQuoteObj:vc,unix:Jl,untrack:Ho,unwrap:Ae,webToken:Jd,when:Wl,withUtcParts:qo},Symbol.toStringTag,{value:"Module"}));var La=Object.defineProperty,qd=Object.getOwnPropertyDescriptor,Vd=Object.getOwnPropertyNames,Xd=Object.prototype.hasOwnProperty,Qd=(e,t)=>{for(var n in t)La(e,n,{get:t[n],enumerable:!0})},eh=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of Vd(t))!Xd.call(e,s)&&s!==n&&La(e,s,{get:()=>t[s],enumerable:!(r=qd(t,s))||r.enumerable});return e},th=(e,t,n)=>(eh(e,t,"default"),n),$={};Qd($,{definePlugin:()=>za,defineTerm:()=>nh});th($,Gd);var za=e=>ua({...e,version:"2.6.1"}),nh=e=>ha({...e,version:"2.6.1"}),Nn=new Set,rh={get active(){const e=[];for(const t of Nn){const n=t.ref.deref();if((0,$.isUndefined)(n)||n.info.stopped)Nn.delete(t);else{const{label:r,next:s,ticks:i,limit:o,interval:a,rrule:c,cron:h,stopped:f,ntp:m}=n.info;e.push({ticker:n,label:r,next:s,ticks:i,limit:o,interval:a,rrule:c,cron:h,stopped:f,ntp:m})}}return e}},sh=class{#e;#t;#r={};#s;#o;#i;#a;#l;#u=0;#c=!1;#h=!1;#n=!0;#p=!1;#f=!1;#d;#m;#g=new Set;#T=new Set;#y=!1;#b=!1;#w=!1;#v=!1;#A=!1;#E;#D;#O=void 0;#C=void 0;constructor(e,t,n){this.#e=e;let r={},s;const i=d=>(0,$.isObject)(d)&&("epoch"in d||"epochMilliseconds"in d||"toZonedDateTimeISO"in d||"getTime"in d),o=d=>(0,$.isObject)(d)&&!i(d);switch(!0){case(0,$.isFunction)(t):s=t;break;case o(t):Object.assign(r,t),(0,$.isFunction)(n)?s=n:o(n)&&Object.assign(r,n);break;default:if((0,$.isDefined)(t))if((0,$.isCronString)(t))r.cron=t;else if((0,$.isRRuleString)(t))r.rrule=t;else{const d=Number(t);(0,$.isNumeric)(t)?r.seconds=d:r.seed=t}(0,$.isFunction)(n)?s=n:o(n)&&Object.assign(r,n)}if((0,$.isDefined)(r.interval)&&(0,$.isUndefined)(r.seconds)&&(0,$.isUndefined)(r.cron)&&(0,$.isUndefined)(r.rrule)){const d=r.interval;(0,$.isCronString)(d)?r.cron=d:(0,$.isRRuleString)(d)?r.rrule=d:(0,$.isNumeric)(d)?r.seconds=Number(d):r.seed=d}const{label:a,limit:c,until:h,seed:f,rrule:m,cron:p,ntp:b,...O}=r;this.#E=O,this.#t=a,this.#l=c,this.#w=!!b,this.#v=!!(this.#w&&this.#e.ntp?.isCalibrated),m&&(this.#s=(0,$.isString)(m)?m:m.rrule),this.#b=!!(r.catch??this.#e.config?.catch),this.#m=new $.Reactive({tag:this.#t??"Ticker",catch:this.#b}),(0,$.isDefined)(p)&&((0,$.isCronString)(p)?this.#o=p:(this.#y=!0,(0,$.logError)(new Error(`Invalid Ticker cron schedule: ${String(p)}`),{...this.#E,catch:this.#b}))),s&&this.#m.on("data",d=>s(d,()=>this.stop()));for(const[d,y]of Object.entries(O))(0,$.isDefined)(y)&&(d.startsWith("#")||$.Enum.has($.enums.DURATIONS,d)||$.Enum.has($.enums.ELEMENT,d))&&(this.#r[d]=y);const D=(0,$.isDefined)(r.seed),g=(0,$.isDefined)(this.#s),l=(0,$.isDefined)(this.#o),u=!(0,$.isEmpty)(this.#r)||(0,$.isDefined)(r.seconds)&&(0,$.isNumber)(r.seconds);(0,$.isDefined)(t)&&!o(t)&&!u&&!D&&!g&&!l&&!s&&(0,$.logError)(new Error(`Invalid Ticker interval, seed, cron, or rrule: ${String(t)}`),{...this.#E,catch:this.#b}),this.#a=h?new this.#e(o(h)?void 0:h,o(h)?{...O,...h}:O):void 0,(0,$.isEmpty)(this.#r)&&!g&&!l&&!this.#y&&((0,$.isDefined)(f)?this.#l??=1:this.#r.seconds=1),(0,$.normaliseFractionalDurations)(this.#r),(0,$.isDefined)(f)?(this.#i=new this.#e(o(f)?void 0:f,o(f)?{...O,...f}:O),this.#A=(!o(f)||(0,$.isDefined)(f.epoch))&&this.#i.epoch.ms>(0,$.instant)().epochMilliseconds):this.#w&&(0,$.isFunction)(this.#e.ntp?.now)?this.#i=this.#e.ntp.now(O):this.#i=new this.#e(void 0,O)}bootstrap(e){if(this.#D=new WeakRef(e),this.#O={ref:this.#D,token:Object.create(null)},this.#l===0)return this.stop(),e;if(this.#y)return this.stop(),e;if(!this.#i.isValid)this.stop(),(0,$.logError)(new Error(`Invalid Ticker seed: ${String(this.#i)}`),this.#i.config);else if(this.#a&&!this.#a.isValid)this.stop(),(0,$.logError)(new Error(`Invalid Ticker boundary: ${String(this.#a)}`),this.#i.config);else try{if(this.#o||this.#s)this.#n=!0,this.#p=!1,Nn.add(this.#O),this.#S();else{const t=Object.entries(this.#r).some(([i,o])=>i.startsWith("#")&&(0,$.isString)(o)&&/^[<>]/.test(o.trim())),n=Object.keys(this.#r).some(i=>!i.startsWith("#"));if(t&&n)throw new Error("Ambiguous Ticker payload: cannot mix directional shorthand terms (e.g. '>') with relative durations (e.g. 'hours'). Use one or the other.");this.#f=t;const r=Object.keys(this.#r).some(i=>i.startsWith("#")),s=this.#f?this.#i.set(this.#r):this.#i.add(this.#r);if(!s.isValid)throw new Error(`Invalid Ticker payload resolution for ${JSON.stringify(this.#r)}`);this.#n=this.#e.compare(s,this.#i)>=0,this.#p=s.epoch.ns===this.#i.epoch.ns,r&&(this.#i=s),Nn.add(this.#O),this.#S()}}catch{this.stop();const n=`Invalid Ticker payload resolution for ${JSON.stringify(this.#r)}`;(0,$.logError)(new Error(n),this.#i.config),queueMicrotask(()=>this.#g.forEach(r=>r(this.#i,()=>this.stop()))),this.#n=!0,this.#p=!1}return e}#_(){const e=this.#w&&!!this.#e.ntp?.isCalibrated;e&&!this.#v&&!this.#A&&this.#u===0&&(0,$.isFunction)(this.#e.ntp?.now)&&(this.#i=this.#e.ntp.now(this.#E),Object.keys(this.#r).some(s=>s.startsWith("#"))&&(this.#i=this.#f?this.#i.set(this.#r):this.#i.add(this.#r)),this.#v=!0);const t=e&&(0,$.isFunction)(this.#e.ntp?.now)?this.#e.ntp.now().epoch.ms:(0,$.instant)().epochMilliseconds,n=Math.round(this.#i.epoch.ms-t);if(n>0)return Math.min(n,2147483647);if(!this.#n){const r=Math.abs(Math.round(this.#i.add(this.#r).epoch.ms-this.#i.epoch.ms));return Math.max(20,Math.min(50,r||1e3))}return 0}#I(){try{return this.pulse()}catch(e){const t=[...this.#g];if(this.stop(),t.forEach(n=>n(this.#i,()=>this.stop())),!this.#b)throw e;return this.#i}}#R(){this.#c||this.#p||(this.#d=setTimeout(()=>{this.#c||(this.#I(),this.#R())},this.#_()))}#S(){if((this.#m.state.subscribers>0||this.#m.state.queued>0)&&!this.#c&&!this.#d){const e=this.#_();e>0?this.#d=setTimeout(()=>{this.#c||(this.#I(),this.#R())},e):(this.#I(),this.#R())}}pulse(){if(this.#c)return new this.#e(null,this.#i.config);const e=this.#i;if(!e.isValid){const n=[...this.#g];return this.stop(),n.forEach(r=>r(e,()=>this.stop())),e}if(this.#o){const n=(0,$.getNextCronEpoch)(this.#o,e.epoch.ms,e.tz);this.#i=new this.#e(n,e.config)}else if(this.#s){const n=(0,$.getNextRRuleEpoch)(this.#s,e.epoch.ms);this.#i=new this.#e(n,e.config)}else this.#i=this.#p?e:this.#f?e.set(this.#r):e.add(this.#r);this.#u++;const t=this.#l!==void 0&&this.#u>=this.#l||(0,$.isDefined)(this.#a)&&(this.#n&&this.#e.compare(e,this.#a)>=0||!this.#n&&this.#e.compare(e,this.#a)<=0);return this.#c&&this.#l===0||(this.#m.cast(e),t&&this.stop()),e}on(e,t){return e==="pulse"?(this.#m.on("data",n=>t(n,()=>this.stop())),this.#S()):e==="catch"?this.#g.add(t):e==="stop"&&this.#T.add(t),this}stop(e){if(this.#c)return;this.#c=!0,this.#O&&(Nn.delete(this.#O),this.#O=void 0),this.#d&&(clearTimeout(this.#d),this.#d=void 0);const t=[...this.#T];this.#T.clear(),this.#g.clear(),this.#m.complete(e);for(const n of t)n(this.#i,()=>{})}get[Symbol.toStringTag](){return"Tempo.Ticker"}get info(){return{label:this.#t,next:this.#i,ticks:this.#u,limit:this.#l,interval:{...this.#r},rrule:this.#s,cron:this.#o,stopped:this.#c,ntp:this.#w}}async pull(){const e=await this.next();return e.done?void 0:e.value}until(e){const t=this.#m.until(e);return this.#S(),t}toSignal(...e){const t=e.length>0?e[0]:this.#i,n=this.#m.toSignal(t);return this.#S(),n}get signal(){return this.#C??=this.toSignal()}async next(){if(this.#c||this.#p)return{done:!0,value:void 0};const e=this.#m.next();this.#h?this.#S():(this.#h=!0,this.#_()>0?this.#S():queueMicrotask(()=>{(!this.#c||this.#m.state.queued>0)&&(this.#I(),this.#R())}));const t=await e;return t.done?{done:!0,value:void 0}:t.value&&t.value.isValid?{done:!1,value:t.value}:{done:!0,value:void 0}}async return(){return this.stop(),{done:!0,value:void 0}}async throw(e){throw this.stop(),e}async[Symbol.asyncDispose](){this.stop()}[Symbol.asyncIterator](){return this.#D?.deref()??this}[Symbol.dispose](){this.stop()}};function er(e,t,n){const r=new sh(e,t,n),s=new Proxy((()=>r.stop()),{get:(i,o)=>o==="pulse"?r.pulse.bind(r):o==="pull"?r.pull.bind(r):o==="until"?r.until.bind(r):o==="on"?(a,c)=>(r.on(a,c),s):o==="stop"?r.stop.bind(r):o==="signal"?r.signal:o==="toSignal"?r.toSignal.bind(r):o==="next"?r.next.bind(r):o==="return"?r.return.bind(r):o==="throw"?r.throw.bind(r):o==="info"?r.info:o===Symbol.asyncIterator?()=>s:o===Symbol.asyncDispose?r[Symbol.asyncDispose].bind(r):o===Symbol.dispose?r[Symbol.dispose].bind(r):r[o],apply:i=>i()});return $.Finalizer.register(s,()=>{r.stop()}),r.bootstrap((0,$.cast)(s))}var ih={get:()=>rh.active},oh=za({name:"ticker",install(e,t){const n=t,r=e||this,s=function(i,o){const a=(0,$.hasKey)(this,"prototype")?this:(0,$.hasKey)(this?.constructor,"prototype")?this.constructor:r,c=n??a?.config?.pluginOptions?.ticker;if(c&&(0,$.isObject)(c)){if((0,$.isUndefined)(i))return er(a,c);if((0,$.isFunction)(i)&&(0,$.isUndefined)(o))return er(a,c,i);if((0,$.isObject)(i)&&!(0,$.isFunction)(i))return er(a,{...c,...i},o)}return er(a,i,o)};s.signal=function(i){const o=s(i),a=o.signal,c=()=>{o.stop(),a.dispose?.()},h=function(){return a()},f=new Proxy(h,{get(m,p){return p==="dispose"||p===Symbol.dispose?c:p==="get"?()=>a.get():a[p]},apply(m,p,b){return a.apply(p,b)}});return $.Finalizer.register(f,()=>{o.stop()}),f},(0,$.attachStatics)(r,{ticker:s,tickers:ih})}}),ah=oh,ch=$.isCronString;export{rh as Ticker,oh as TickerPlugin,ah as default,ch as isCronString}; diff --git a/packages/tempo/public/v4/assets/chunks/infoDiagram-27XIBGKW.C3BlkN34.js b/packages/tempo/public/v4/assets/chunks/infoDiagram-27XIBGKW.C3BlkN34.js new file mode 100644 index 00000000..8327122b --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/infoDiagram-27XIBGKW.C3BlkN34.js @@ -0,0 +1,2 @@ +import{_ as e,l as s,G as n,d as i}from"../app.CbekdYod.js";import{p}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var g={parse:e(async r=>{const a=await p("info",r);s.debug(a)},"parse")},d={version:"11.17.2"},v=e(()=>d.version,"getVersion"),m={getVersion:v},c=e((r,a,o)=>{s.debug(`rendering info diagram +`+r);const t=n(a);i(t,100,400,!0),t.append("g").append("text").attr("x",100).attr("y",40).attr("class","version").attr("font-size",32).style("text-anchor","middle").text(`v${o}`)},"draw"),l={draw:c},w={parser:g,db:m,renderer:l};export{w as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/init.Gi6I4Gst.js b/packages/tempo/public/v4/assets/chunks/init.Gi6I4Gst.js new file mode 100644 index 00000000..d44de941 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/init.Gi6I4Gst.js @@ -0,0 +1 @@ +function t(e,a){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(a).domain(e);break}return this}export{t as i}; diff --git a/packages/tempo/public/v4/assets/chunks/ishikawaDiagram-5VMMS53U.dqUjFnmd.js b/packages/tempo/public/v4/assets/chunks/ishikawaDiagram-5VMMS53U.dqUjFnmd.js new file mode 100644 index 00000000..6c7caeb8 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/ishikawaDiagram-5VMMS53U.dqUjFnmd.js @@ -0,0 +1,70 @@ +import{_ as l,c as lt,a2 as ct,G as ut,an as dt,r as yt,k as ft,p as et,a as pt,b as gt,g as kt,s as mt,q as wt,d as _t}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var Q=(function(){var t=l(function(T,e,s,i){for(s=s||{},i=T.length;i--;s[T[i]]=e);return s},"o"),d=[1,4],n=[1,14],a=[1,12],o=[1,13],y=[6,7,8],p=[1,20],u=[1,18],m=[1,19],c=[6,7,11],k=[1,6,13,14],g=[1,23],_=[1,24],x=[1,6,7,11,13,14],D={trace:l(function(){},"trace"),yy:{},symbols_:{error:2,start:3,ishikawa:4,spaceLines:5,SPACELINE:6,NL:7,ISHIKAWA:8,document:9,stop:10,EOF:11,statement:12,SPACELIST:13,TEXT:14,$accept:0,$end:1},terminals_:{2:"error",6:"SPACELINE",7:"NL",8:"ISHIKAWA",11:"EOF",13:"SPACELIST",14:"TEXT"},productions_:[0,[3,1],[3,2],[5,1],[5,2],[5,2],[4,2],[4,3],[10,1],[10,1],[10,1],[10,2],[10,2],[9,3],[9,2],[12,2],[12,1],[12,1],[12,1]],performAction:l(function(e,s,i,h,f,r,v){var w=r.length-1;switch(f){case 6:case 7:return h;case 15:h.addNode(r[w-1].length,r[w].trim());break;case 16:h.addNode(0,r[w].trim());break}},"anonymous"),table:[{3:1,4:2,5:3,6:[1,5],8:d},{1:[3]},{1:[2,1]},{4:6,6:[1,7],7:[1,8],8:d},{6:n,7:[1,10],9:9,12:11,13:a,14:o},t(y,[2,3]),{1:[2,2]},t(y,[2,4]),t(y,[2,5]),{1:[2,6],6:n,12:15,13:a,14:o},{6:n,9:16,12:11,13:a,14:o},{6:p,7:u,10:17,11:m},t(c,[2,18],{14:[1,21]}),t(c,[2,16]),t(c,[2,17]),{6:p,7:u,10:22,11:m},{1:[2,7],6:n,12:15,13:a,14:o},t(k,[2,14],{7:g,11:_}),t(x,[2,8]),t(x,[2,9]),t(x,[2,10]),t(c,[2,15]),t(k,[2,13],{7:g,11:_}),t(x,[2,11]),t(x,[2,12])],defaultActions:{2:[2,1],6:[2,2]},parseError:l(function(e,s){if(s.recoverable)this.trace(e);else{var i=new Error(e);throw i.hash=s,i}},"parseError"),parse:l(function(e){var s=this,i=[0],h=[],f=[null],r=[],v=this.table,w="",I=0,$=0,L=2,A=1,C=r.slice.call(arguments,1),b=Object.create(this.lexer),S={yy:{}};for(var P in this.yy)Object.prototype.hasOwnProperty.call(this.yy,P)&&(S.yy[P]=this.yy[P]);b.setInput(e,S.yy),S.yy.lexer=b,S.yy.parser=this,typeof b.yylloc>"u"&&(b.yylloc={});var R=b.yylloc;r.push(R);var H=b.options&&b.options.ranges;typeof S.yy.parseError=="function"?this.parseError=S.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function X(B){i.length=i.length-2*B,f.length=f.length-B,r.length=r.length-B}l(X,"popStack");function J(){var B;return B=h.pop()||b.lex()||A,typeof B!="number"&&(B instanceof Array&&(h=B,B=h.pop()),B=s.symbols_[B]||B),B}l(J,"lex");for(var M,W,N,Y,F={},G,V,tt,U;;){if(W=i[i.length-1],this.defaultActions[W]?N=this.defaultActions[W]:((M===null||typeof M>"u")&&(M=J()),N=v[W]&&v[W][M]),typeof N>"u"||!N.length||!N[0]){var q="";U=[];for(G in v[W])this.terminals_[G]&&G>L&&U.push("'"+this.terminals_[G]+"'");b.showPosition?q="Parse error on line "+(I+1)+`: +`+b.showPosition()+` +Expecting `+U.join(", ")+", got '"+(this.terminals_[M]||M)+"'":q="Parse error on line "+(I+1)+": Unexpected "+(M==A?"end of input":"'"+(this.terminals_[M]||M)+"'"),this.parseError(q,{text:b.match,token:this.terminals_[M]||M,line:b.yylineno,loc:R,expected:U})}if(N[0]instanceof Array&&N.length>1)throw new Error("Parse Error: multiple actions possible at state: "+W+", token: "+M);switch(N[0]){case 1:i.push(M),f.push(b.yytext),r.push(b.yylloc),i.push(N[1]),M=null,$=b.yyleng,w=b.yytext,I=b.yylineno,R=b.yylloc;break;case 2:if(V=this.productions_[N[1]][1],F.$=f[f.length-V],F._$={first_line:r[r.length-(V||1)].first_line,last_line:r[r.length-1].last_line,first_column:r[r.length-(V||1)].first_column,last_column:r[r.length-1].last_column},H&&(F._$.range=[r[r.length-(V||1)].range[0],r[r.length-1].range[1]]),Y=this.performAction.apply(F,[w,$,I,S.yy,N[1],f,r].concat(C)),typeof Y<"u")return Y;V&&(i=i.slice(0,-1*V*2),f=f.slice(0,-1*V),r=r.slice(0,-1*V)),i.push(this.productions_[N[1]][0]),f.push(F.$),r.push(F._$),tt=v[i[i.length-2]][i[i.length-1]],i.push(tt);break;case 3:return!0}}return!0},"parse")},O=(function(){var T={EOF:1,parseError:l(function(s,i){if(this.yy.parser)this.yy.parser.parseError(s,i);else throw new Error(s)},"parseError"),setInput:l(function(e,s){return this.yy=s||this.yy||{},this._input=e,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:l(function(){var e=this._input[0];this.yytext+=e,this.yyleng++,this.offset++,this.match+=e,this.matched+=e;var s=e.match(/(?:\r\n?|\n).*/g);return s?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),e},"input"),unput:l(function(e){var s=e.length,i=e.split(/(?:\r\n?|\n)/g);this._input=e+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-s),this.offset-=s;var h=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),i.length-1&&(this.yylineno-=i.length-1);var f=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:i?(i.length===h.length?this.yylloc.first_column:0)+h[h.length-i.length].length-i[0].length:this.yylloc.first_column-s},this.options.ranges&&(this.yylloc.range=[f[0],f[0]+this.yyleng-s]),this.yyleng=this.yytext.length,this},"unput"),more:l(function(){return this._more=!0,this},"more"),reject:l(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:l(function(e){this.unput(this.match.slice(e))},"less"),pastInput:l(function(){var e=this.matched.substr(0,this.matched.length-this.match.length);return(e.length>20?"...":"")+e.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:l(function(){var e=this.match;return e.length<20&&(e+=this._input.substr(0,20-e.length)),(e.substr(0,20)+(e.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:l(function(){var e=this.pastInput(),s=new Array(e.length+1).join("-");return e+this.upcomingInput()+` +`+s+"^"},"showPosition"),test_match:l(function(e,s){var i,h,f;if(this.options.backtrack_lexer&&(f={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(f.yylloc.range=this.yylloc.range.slice(0))),h=e[0].match(/(?:\r\n?|\n).*/g),h&&(this.yylineno+=h.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:h?h[h.length-1].length-h[h.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+e[0].length},this.yytext+=e[0],this.match+=e[0],this.matches=e,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(e[0].length),this.matched+=e[0],i=this.performAction.call(this,this.yy,this,s,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),i)return i;if(this._backtrack){for(var r in f)this[r]=f[r];return!1}return!1},"test_match"),next:l(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var e,s,i,h;this._more||(this.yytext="",this.match="");for(var f=this._currentRules(),r=0;rs[0].length)){if(s=i,h=r,this.options.backtrack_lexer){if(e=this.test_match(i,f[r]),e!==!1)return e;if(this._backtrack){s=!1;continue}else return!1}else if(!this.options.flex)break}return s?(e=this.test_match(s,f[h]),e!==!1?e:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:l(function(){var s=this.next();return s||this.lex()},"lex"),begin:l(function(s){this.conditionStack.push(s)},"begin"),popState:l(function(){var s=this.conditionStack.length-1;return s>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:l(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:l(function(s){return s=this.conditionStack.length-1-Math.abs(s||0),s>=0?this.conditionStack[s]:"INITIAL"},"topState"),pushState:l(function(s){this.begin(s)},"pushState"),stateStackSize:l(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:l(function(s,i,h,f){switch(h){case 0:return 6;case 1:return 8;case 2:return 8;case 3:return 6;case 4:return 7;case 5:return 13;case 6:return 14;case 7:return 11}},"anonymous"),rules:[/^(?:\s*%%.*)/i,/^(?:ishikawa-beta\b)/i,/^(?:ishikawa\b)/i,/^(?:[\s]+[\n])/i,/^(?:[\n]+)/i,/^(?:[\s]+)/i,/^(?:[^\n]+)/i,/^(?:$)/i],conditions:{INITIAL:{rules:[0,1,2,3,4,5,6,7],inclusive:!0}}};return T})();D.lexer=O;function E(){this.yy={}}return l(E,"Parser"),E.prototype=D,D.Parser=E,new E})();Q.parser=Q;var bt=Q,xt=class{constructor(){this.stack=[],this.clear=this.clear.bind(this),this.addNode=this.addNode.bind(this),this.getRoot=this.getRoot.bind(this)}static{l(this,"IshikawaDB")}clear(){this.root=void 0,this.stack=[],this.baseLevel=void 0,yt()}getRoot(){return this.root}addNode(t,d){const n=ft.sanitizeText(d,lt());if(!this.root){this.root={text:n,children:[]},this.stack=[{level:0,node:this.root}],et(n);return}this.baseLevel??=t;let a=t-this.baseLevel+1;for(a<=0&&(a=1);this.stack.length>1&&this.stack[this.stack.length-1].level>=a;)this.stack.pop();const o=this.stack[this.stack.length-1].node,y={text:n,children:[]};o.children.push(y),this.stack.push({level:a,node:y})}getAccTitle(){return pt()}setAccTitle(t){gt(t)}getAccDescription(){return kt()}setAccDescription(t){mt(t)}getDiagramTitle(){return wt()}setDiagramTitle(t){et(t)}},vt=14,j=250,St=30,$t=60,Et=5,ot=82*Math.PI/180,it=Math.cos(ot),st=Math.sin(ot),nt=l((t,d,n)=>{const a=t.node().getBBox(),o=a.width+d*2,y=a.height+d*2;_t(t,y,o,n),t.attr("viewBox",`${a.x-d} ${a.y-d} ${o} ${y}`)},"applyPaddedViewBox"),At=l((t,d,n,a)=>{const y=a.db.getRoot();if(!y)return;const p=lt(),{look:u,handDrawnSeed:m,themeVariables:c}=p,k=ct(p.fontSize)[0]??vt,g=u==="handDrawn",_=y.children??[],x=p.ishikawa?.diagramPadding??20,D=p.ishikawa?.useMaxWidth??!1,O=ut(d),E=O.append("g").attr("class","ishikawa"),T=g?dt.svg(O.node()):void 0,e=T?{roughSvg:T,seed:m??0,lineColor:c?.lineColor??"#333",fillColor:c?.mainBkg??"#fff"}:void 0,s=`ishikawa-arrow-${d}`;g||E.append("defs").append("marker").attr("id",s).attr("viewBox","0 0 10 10").attr("refX",0).attr("refY",5).attr("markerWidth",6).attr("markerHeight",6).attr("orient","auto").append("path").attr("d","M 10 0 L 0 5 L 10 10 Z").attr("class","ishikawa-arrow");let i=0,h=j;const f=g?void 0:z(E,i,h,i,h,"ishikawa-spine");if(It(E,i,h,y.text,k,e),!_.length){g&&z(E,i,h,i,h,"ishikawa-spine",e),nt(O,x,D);return}i-=20;const r=_.filter((S,P)=>P%2===0),v=_.filter((S,P)=>P%2===1),w=at(r),I=at(v),$=w.total+I.total;let L=j,A=j;if($>0){const S=j*2,P=j*.3;L=Math.max(P,S*(w.total/$)),A=Math.max(P,S*(I.total/$))}const C=k*2;L=Math.max(L,w.max*C),A=Math.max(A,I.max*C),h=Math.max(L,j),f&&f.attr("y1",h).attr("y2",h),E.select(".ishikawa-head-group").attr("transform",`translate(0,${h})`);const b=Math.ceil(_.length/2);for(let S=0;SMath.min(R,H.getBBox().x),1/0)}if(g)z(E,i,h,0,h,"ishikawa-spine",e);else{f.attr("x1",i);const S=`url(#${s})`;E.selectAll("line.ishikawa-branch, line.ishikawa-sub-branch").attr("marker-start",S)}nt(O,x,D)},"draw"),at=l(t=>{const d=l(n=>n.children.reduce((a,o)=>a+1+d(o),0),"countDescendants");return t.reduce((n,a)=>{const o=d(a);return n.total+=o,n.max=Math.max(n.max,o),n},{total:0,max:0})},"sideStats"),It=l((t,d,n,a,o,y)=>{const p=Math.max(6,Math.floor(110/(o*.6))),u=t.append("g").attr("class","ishikawa-head-group").attr("transform",`translate(${d},${n})`),m=Z(u,ht(a,p),0,0,"ishikawa-head-label","start",o),c=m.node().getBBox(),k=Math.max(60,c.width+6),g=Math.max(40,c.height*2+40),_=`M 0 ${-g/2} L 0 ${g/2} Q ${k*2.4} 0 0 ${-g/2} Z`;if(y){const x=y.roughSvg.path(_,{roughness:1.5,seed:y.seed,fill:y.fillColor,fillStyle:"hachure",fillWeight:2.5,hachureGap:5,stroke:y.lineColor,strokeWidth:2});u.insert(()=>x,":first-child").attr("class","ishikawa-head")}else u.insert("path",":first-child").attr("class","ishikawa-head").attr("d",_);m.attr("transform",`translate(${(k-c.width)/2-c.x+3},${-c.y-c.height/2})`)},"drawHead"),Lt=l((t,d)=>{const n=[],a=[],o=l((y,p,u)=>{const m=d===-1?[...y].reverse():y;for(const c of m){const k=n.length,g=c.children??[];n.push({depth:u,text:ht(c.text,15),parentIndex:p,childCount:g.length}),u%2===0?(a.push(k),g.length&&o(g,k,u+1)):(g.length&&o(g,k,u+1),a.push(k))}},"walk");return o(t,-1,2),{entries:n,yOrder:a}},"flattenTree"),Tt=l((t,d,n,a,o,y,p)=>{const u=t.append("g").attr("class","ishikawa-label-group"),c=Z(u,d,n,a+11*o,"ishikawa-label cause","middle",y).node().getBBox();if(p){const k=p.roughSvg.rectangle(c.x-20,c.y-2,c.width+40,c.height+4,{roughness:1.5,seed:p.seed,fill:p.fillColor,fillStyle:"hachure",fillWeight:2.5,hachureGap:5,stroke:p.lineColor,strokeWidth:2});u.insert(()=>k,":first-child").attr("class","ishikawa-label-box")}else u.insert("rect",":first-child").attr("class","ishikawa-label-box").attr("x",c.x-20).attr("y",c.y-2).attr("width",c.width+40).attr("height",c.height+4)},"drawCauseLabel"),K=l((t,d,n,a,o,y)=>{const p=Math.sqrt(a*a+o*o);if(p===0)return;const u=a/p,m=o/p,c=6,k=-m*c,g=u*c,_=d,x=n,D=`M ${_} ${x} L ${_-u*c*2+k} ${x-m*c*2+g} L ${_-u*c*2-k} ${x-m*c*2-g} Z`,O=y.roughSvg.path(D,{roughness:1,seed:y.seed,fill:y.lineColor,fillStyle:"solid",stroke:y.lineColor,strokeWidth:1});t.append(()=>O)},"drawArrowMarker"),Mt=l((t,d,n,a,o,y,p,u)=>{const m=d.children??[],c=y*(m.length?1:.2),k=-it*c,g=st*c*o,_=n+k,x=a+g;if(z(t,n,a,_,x,"ishikawa-branch",u),u&&K(t,n,a,n-_,a-x,u),Tt(t,d.text,_,x,o,p,u),!m.length)return;const{entries:D,yOrder:O}=Lt(m,o),E=D.length,T=new Array(E);for(const[f,r]of O.entries())T[r]=a+g*((f+1)/(E+1));const e=new Map;e.set(-1,{x0:n,y0:a,x1:_,y1:x,childCount:m.length,childrenDrawn:0});const s=-it,i=st*o,h=o<0?"ishikawa-label up":"ishikawa-label down";for(const[f,r]of D.entries()){const v=T[f],w=e.get(r.parentIndex),I=t.append("g").attr("class","ishikawa-sub-group");let $=0,L=0,A=0;if(r.depth%2===0){const C=w.y1-w.y0;$=rt(w.x0,w.x1,C?(v-w.y0)/C:.5),L=v,A=$-(r.childCount>0?$t+r.childCount*Et:St),z(I,$,v,A,v,"ishikawa-sub-branch",u),u&&K(I,$,v,1,0,u),Z(I,r.text,A,v,"ishikawa-label align","end",p)}else{const C=w.childrenDrawn++;$=rt(w.x0,w.x1,(w.childCount-C)/(w.childCount+1)),L=w.y0,A=$+s*((v-L)/i),z(I,$,L,A,v,"ishikawa-sub-branch",u),u&&K(I,$,L,$-A,L-v,u),Z(I,r.text,A,v,h,"end",p)}r.childCount>0&&e.set(f,{x0:$,y0:L,x1:A,y1:v,childCount:r.childCount,childrenDrawn:0})}},"drawBranch"),Pt=l(t=>t.split(/|\n/),"splitLines"),ht=l((t,d)=>{if(t.length<=d)return t;const n=[];for(const a of t.split(/\s+/)){const o=n.length-1;o>=0&&n[o].length+1+a.length<=d?n[o]+=" "+a:n.push(a)}return n.join(` +`)},"wrapText"),Z=l((t,d,n,a,o,y,p)=>{const u=Pt(d),m=p*1.05,c=t.append("text").attr("class",o).attr("text-anchor",y).attr("x",n).attr("y",a-(u.length-1)*m/2);for(const[k,g]of u.entries())c.append("tspan").attr("x",n).attr("dy",k===0?0:m).text(g);return c},"drawMultilineText"),rt=l((t,d,n)=>t+(d-t)*n,"lerp"),z=l((t,d,n,a,o,y,p)=>{if(p){const u=p.roughSvg.line(d,n,a,o,{roughness:1.5,seed:p.seed,stroke:p.lineColor,strokeWidth:2});t.append(()=>u).attr("class",y);return}return t.append("line").attr("class",y).attr("x1",d).attr("y1",n).attr("x2",a).attr("y2",o)},"drawLine"),Bt={draw:At},Nt=l(t=>` +.ishikawa .ishikawa-spine, +.ishikawa .ishikawa-branch, +.ishikawa .ishikawa-sub-branch { + stroke: ${t.lineColor}; + stroke-width: 2; + fill: none; +} + +.ishikawa .ishikawa-sub-branch { + stroke-width: 1; +} + +.ishikawa .ishikawa-arrow { + fill: ${t.lineColor}; +} + +.ishikawa .ishikawa-head { + fill: ${t.mainBkg}; + stroke: ${t.lineColor}; + stroke-width: 2; +} + +.ishikawa .ishikawa-label-box { + fill: ${t.mainBkg}; + stroke: ${t.lineColor}; + stroke-width: 2; +} + +.ishikawa text { + font-family: ${t.fontFamily}; + font-size: ${t.fontSize}; + fill: ${t.textColor}; +} + +.ishikawa .ishikawa-head-label { + font-weight: 600; + text-anchor: middle; + dominant-baseline: middle; + font-size: 14px; +} + +.ishikawa .ishikawa-label { + text-anchor: end; +} + +.ishikawa .ishikawa-label.cause { + text-anchor: middle; + dominant-baseline: middle; +} + +.ishikawa .ishikawa-label.align { + text-anchor: end; + dominant-baseline: middle; +} + +.ishikawa .ishikawa-label.up { + dominant-baseline: baseline; +} + +.ishikawa .ishikawa-label.down { + dominant-baseline: hanging; +} +`,"getStyles"),Dt=Nt,Rt={parser:bt,get db(){return new xt},renderer:Bt,styles:Dt};export{Rt as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/journeyDiagram-3NMN7TZE.NTDjZdp_.js b/packages/tempo/public/v4/assets/chunks/journeyDiagram-3NMN7TZE.NTDjZdp_.js new file mode 100644 index 00000000..835906ca --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/journeyDiagram-3NMN7TZE.NTDjZdp_.js @@ -0,0 +1,139 @@ +import{g as gt}from"./chunk-5VM5RSS4.-zPOtr2J.js";import{a as mt,b as lt,h as xt,d as kt}from"./chunk-F27PBJKO.CcniKEe6.js";import{g as _t,s as vt,a as bt,b as wt,q as Tt,p as St,_ as s,c as R,j as X,d as $t,r as Mt}from"../app.CbekdYod.js";import{d as it}from"./arc.BFiNID6s.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var U=(function(){var t=s(function(h,r,n,l){for(n=n||{},l=h.length;l--;n[h[l]]=r);return n},"o"),e=[6,8,10,11,12,14,16,17,18],a=[1,9],f=[1,10],i=[1,11],u=[1,12],p=[1,13],o=[1,14],g={trace:s(function(){},"trace"),yy:{},symbols_:{error:2,start:3,journey:4,document:5,EOF:6,line:7,SPACE:8,statement:9,NEWLINE:10,title:11,acc_title:12,acc_title_value:13,acc_descr:14,acc_descr_value:15,acc_descr_multiline_value:16,section:17,taskName:18,taskData:19,$accept:0,$end:1},terminals_:{2:"error",4:"journey",6:"EOF",8:"SPACE",10:"NEWLINE",11:"title",12:"acc_title",13:"acc_title_value",14:"acc_descr",15:"acc_descr_value",16:"acc_descr_multiline_value",17:"section",18:"taskName",19:"taskData"},productions_:[0,[3,3],[5,0],[5,2],[7,2],[7,1],[7,1],[7,1],[9,1],[9,2],[9,2],[9,1],[9,1],[9,2]],performAction:s(function(r,n,l,y,d,c,v){var k=c.length-1;switch(d){case 1:return c[k-1];case 2:this.$=[];break;case 3:c[k-1].push(c[k]),this.$=c[k-1];break;case 4:case 5:this.$=c[k];break;case 6:case 7:this.$=[];break;case 8:y.setDiagramTitle(c[k].substr(6)),this.$=c[k].substr(6);break;case 9:this.$=c[k].trim(),y.setAccTitle(this.$);break;case 10:case 11:this.$=c[k].trim(),y.setAccDescription(this.$);break;case 12:y.addSection(c[k].substr(8)),this.$=c[k].substr(8);break;case 13:y.addTask(c[k-1],c[k]),this.$="task";break}},"anonymous"),table:[{3:1,4:[1,2]},{1:[3]},t(e,[2,2],{5:3}),{6:[1,4],7:5,8:[1,6],9:7,10:[1,8],11:a,12:f,14:i,16:u,17:p,18:o},t(e,[2,7],{1:[2,1]}),t(e,[2,3]),{9:15,11:a,12:f,14:i,16:u,17:p,18:o},t(e,[2,5]),t(e,[2,6]),t(e,[2,8]),{13:[1,16]},{15:[1,17]},t(e,[2,11]),t(e,[2,12]),{19:[1,18]},t(e,[2,4]),t(e,[2,9]),t(e,[2,10]),t(e,[2,13])],defaultActions:{},parseError:s(function(r,n){if(n.recoverable)this.trace(r);else{var l=new Error(r);throw l.hash=n,l}},"parseError"),parse:s(function(r){var n=this,l=[0],y=[],d=[null],c=[],v=this.table,k="",C=0,Q=0,yt=2,D=1,dt=c.slice.call(arguments,1),_=Object.create(this.lexer),I={yy:{}};for(var O in this.yy)Object.prototype.hasOwnProperty.call(this.yy,O)&&(I.yy[O]=this.yy[O]);_.setInput(r,I.yy),I.yy.lexer=_,I.yy.parser=this,typeof _.yylloc>"u"&&(_.yylloc={});var Y=_.yylloc;c.push(Y);var ft=_.options&&_.options.ranges;typeof I.yy.parseError=="function"?this.parseError=I.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function pt(w){l.length=l.length-2*w,d.length=d.length-w,c.length=c.length-w}s(pt,"popStack");function tt(){var w;return w=y.pop()||_.lex()||D,typeof w!="number"&&(w instanceof Array&&(y=w,w=y.pop()),w=n.symbols_[w]||w),w}s(tt,"lex");for(var b,A,T,q,F={},N,M,et,z;;){if(A=l[l.length-1],this.defaultActions[A]?T=this.defaultActions[A]:((b===null||typeof b>"u")&&(b=tt()),T=v[A]&&v[A][b]),typeof T>"u"||!T.length||!T[0]){var H="";z=[];for(N in v[A])this.terminals_[N]&&N>yt&&z.push("'"+this.terminals_[N]+"'");_.showPosition?H="Parse error on line "+(C+1)+`: +`+_.showPosition()+` +Expecting `+z.join(", ")+", got '"+(this.terminals_[b]||b)+"'":H="Parse error on line "+(C+1)+": Unexpected "+(b==D?"end of input":"'"+(this.terminals_[b]||b)+"'"),this.parseError(H,{text:_.match,token:this.terminals_[b]||b,line:_.yylineno,loc:Y,expected:z})}if(T[0]instanceof Array&&T.length>1)throw new Error("Parse Error: multiple actions possible at state: "+A+", token: "+b);switch(T[0]){case 1:l.push(b),d.push(_.yytext),c.push(_.yylloc),l.push(T[1]),b=null,Q=_.yyleng,k=_.yytext,C=_.yylineno,Y=_.yylloc;break;case 2:if(M=this.productions_[T[1]][1],F.$=d[d.length-M],F._$={first_line:c[c.length-(M||1)].first_line,last_line:c[c.length-1].last_line,first_column:c[c.length-(M||1)].first_column,last_column:c[c.length-1].last_column},ft&&(F._$.range=[c[c.length-(M||1)].range[0],c[c.length-1].range[1]]),q=this.performAction.apply(F,[k,Q,C,I.yy,T[1],d,c].concat(dt)),typeof q<"u")return q;M&&(l=l.slice(0,-1*M*2),d=d.slice(0,-1*M),c=c.slice(0,-1*M)),l.push(this.productions_[T[1]][0]),d.push(F.$),c.push(F._$),et=v[l[l.length-2]][l[l.length-1]],l.push(et);break;case 3:return!0}}return!0},"parse")},m=(function(){var h={EOF:1,parseError:s(function(n,l){if(this.yy.parser)this.yy.parser.parseError(n,l);else throw new Error(n)},"parseError"),setInput:s(function(r,n){return this.yy=n||this.yy||{},this._input=r,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:s(function(){var r=this._input[0];this.yytext+=r,this.yyleng++,this.offset++,this.match+=r,this.matched+=r;var n=r.match(/(?:\r\n?|\n).*/g);return n?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),r},"input"),unput:s(function(r){var n=r.length,l=r.split(/(?:\r\n?|\n)/g);this._input=r+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-n),this.offset-=n;var y=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),l.length-1&&(this.yylineno-=l.length-1);var d=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:l?(l.length===y.length?this.yylloc.first_column:0)+y[y.length-l.length].length-l[0].length:this.yylloc.first_column-n},this.options.ranges&&(this.yylloc.range=[d[0],d[0]+this.yyleng-n]),this.yyleng=this.yytext.length,this},"unput"),more:s(function(){return this._more=!0,this},"more"),reject:s(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:s(function(r){this.unput(this.match.slice(r))},"less"),pastInput:s(function(){var r=this.matched.substr(0,this.matched.length-this.match.length);return(r.length>20?"...":"")+r.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:s(function(){var r=this.match;return r.length<20&&(r+=this._input.substr(0,20-r.length)),(r.substr(0,20)+(r.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:s(function(){var r=this.pastInput(),n=new Array(r.length+1).join("-");return r+this.upcomingInput()+` +`+n+"^"},"showPosition"),test_match:s(function(r,n){var l,y,d;if(this.options.backtrack_lexer&&(d={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(d.yylloc.range=this.yylloc.range.slice(0))),y=r[0].match(/(?:\r\n?|\n).*/g),y&&(this.yylineno+=y.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:y?y[y.length-1].length-y[y.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+r[0].length},this.yytext+=r[0],this.match+=r[0],this.matches=r,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(r[0].length),this.matched+=r[0],l=this.performAction.call(this,this.yy,this,n,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),l)return l;if(this._backtrack){for(var c in d)this[c]=d[c];return!1}return!1},"test_match"),next:s(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var r,n,l,y;this._more||(this.yytext="",this.match="");for(var d=this._currentRules(),c=0;cn[0].length)){if(n=l,y=c,this.options.backtrack_lexer){if(r=this.test_match(l,d[c]),r!==!1)return r;if(this._backtrack){n=!1;continue}else return!1}else if(!this.options.flex)break}return n?(r=this.test_match(n,d[y]),r!==!1?r:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:s(function(){var n=this.next();return n||this.lex()},"lex"),begin:s(function(n){this.conditionStack.push(n)},"begin"),popState:s(function(){var n=this.conditionStack.length-1;return n>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:s(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:s(function(n){return n=this.conditionStack.length-1-Math.abs(n||0),n>=0?this.conditionStack[n]:"INITIAL"},"topState"),pushState:s(function(n){this.begin(n)},"pushState"),stateStackSize:s(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:s(function(n,l,y,d){switch(y){case 0:break;case 1:break;case 2:return 10;case 3:break;case 4:break;case 5:return 4;case 6:return 11;case 7:return this.begin("acc_title"),12;case 8:return this.popState(),"acc_title_value";case 9:return this.begin("acc_descr"),14;case 10:return this.popState(),"acc_descr_value";case 11:this.begin("acc_descr_multiline");break;case 12:this.popState();break;case 13:return"acc_descr_multiline_value";case 14:return 17;case 15:return 18;case 16:return 19;case 17:return":";case 18:return 6;case 19:return"INVALID"}},"anonymous"),rules:[/^(?:%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?:#[^\n]*)/i,/^(?:journey\b)/i,/^(?:title\s[^#\n;]+)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:section\s[^#:\n;]+)/i,/^(?:[^#:\n;]+)/i,/^(?::[^#\n;]+)/i,/^(?::)/i,/^(?:$)/i,/^(?:.)/i],conditions:{acc_descr_multiline:{rules:[12,13],inclusive:!1},acc_descr:{rules:[10],inclusive:!1},acc_title:{rules:[8],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,9,11,14,15,16,17,18,19],inclusive:!0}}};return h})();g.lexer=m;function x(){this.yy={}}return s(x,"Parser"),x.prototype=g,g.Parser=x,new x})();U.parser=U;var Et=U,V="",J=[],L=[],B=[],Ct=s(function(){J.length=0,L.length=0,V="",B.length=0,Mt()},"clear"),Pt=s(function(t){V=t,J.push(t)},"addSection"),It=s(function(){return J},"getSections"),At=s(function(){let t=rt();const e=100;let a=0;for(;!t&&a{a.people&&t.push(...a.people)}),[...new Set(t)].sort()},"updateActors"),Vt=s(function(t,e){const a=e.substr(1).split(":");let f=0,i=[];a.length===1?(f=Number(a[0]),i=[]):(f=Number(a[0]),i=a[1].split(","));const u=i.map(o=>o.trim()),p={section:V,type:V,people:u,task:t,score:f};B.push(p)},"addTask"),Rt=s(function(t){const e={section:V,type:V,description:t,task:t,classes:[]};L.push(e)},"addTaskOrg"),rt=s(function(){const t=s(function(a){return B[a].processed},"compileTask");let e=!0;for(const[a,f]of B.entries())t(a),e=e&&f.processed;return e},"compileTasks"),Lt=s(function(){return Ft()},"getActors"),nt={getConfig:s(()=>R().journey,"getConfig"),clear:Ct,setDiagramTitle:St,getDiagramTitle:Tt,setAccTitle:wt,getAccTitle:bt,setAccDescription:vt,getAccDescription:_t,addSection:Pt,getSections:It,getTasks:At,addTask:Vt,addTaskOrg:Rt,getActors:Lt},Bt=s(t=>`.label { + font-family: ${t.fontFamily}; + color: ${t.textColor}; + } + .mouth { + stroke: #666; + } + + line { + stroke: ${t.textColor} + } + + .legend { + fill: ${t.textColor}; + font-family: ${t.fontFamily}; + } + + .label text { + fill: #333; + } + .label { + color: ${t.textColor} + } + + .face { + ${t.faceColor?`fill: ${t.faceColor}`:"fill: #FFF8DC"}; + stroke: #999; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${t.mainBkg}; + stroke: ${t.nodeBorder}; + stroke-width: 1px; + } + + .node .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + .arrowheadPath { + fill: ${t.arrowheadColor}; + } + + .edgePaths .path { + stroke: ${t.lineColor}; + stroke-width: 1.5px; + } + + .flowchart-link { + stroke: ${t.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${t.edgeLabelBackground}; + rect { + opacity: 0.5; + } + text-align: center; + } + + .cluster rect { + } + + .cluster text { + fill: ${t.titleColor}; + } + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${t.fontFamily}; + font-size: 12px; + background: ${t.tertiaryColor}; + border: 1px solid ${t.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .task-type-0, .section-type-0 { + ${t.fillType0?`fill: ${t.fillType0}`:""}; + } + .task-type-1, .section-type-1 { + ${t.fillType0?`fill: ${t.fillType1}`:""}; + } + .task-type-2, .section-type-2 { + ${t.fillType0?`fill: ${t.fillType2}`:""}; + } + .task-type-3, .section-type-3 { + ${t.fillType0?`fill: ${t.fillType3}`:""}; + } + .task-type-4, .section-type-4 { + ${t.fillType0?`fill: ${t.fillType4}`:""}; + } + .task-type-5, .section-type-5 { + ${t.fillType0?`fill: ${t.fillType5}`:""}; + } + .task-type-6, .section-type-6 { + ${t.fillType0?`fill: ${t.fillType6}`:""}; + } + .task-type-7, .section-type-7 { + ${t.fillType0?`fill: ${t.fillType7}`:""}; + } + + .actor-0 { + ${t.actor0?`fill: ${t.actor0}`:""}; + } + .actor-1 { + ${t.actor1?`fill: ${t.actor1}`:""}; + } + .actor-2 { + ${t.actor2?`fill: ${t.actor2}`:""}; + } + .actor-3 { + ${t.actor3?`fill: ${t.actor3}`:""}; + } + .actor-4 { + ${t.actor4?`fill: ${t.actor4}`:""}; + } + .actor-5 { + ${t.actor5?`fill: ${t.actor5}`:""}; + } + ${gt()} +`,"getStyles"),jt=Bt,K=s(function(t,e){return kt(t,e)},"drawRect"),Nt=s(function(t,e){const f=t.append("circle").attr("cx",e.cx).attr("cy",e.cy).attr("class","face").attr("r",15).attr("stroke-width",2).attr("overflow","visible"),i=t.append("g");i.append("circle").attr("cx",e.cx-15/3).attr("cy",e.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666"),i.append("circle").attr("cx",e.cx+15/3).attr("cy",e.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666");function u(g){const m=it().startAngle(Math.PI/2).endAngle(3*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);g.append("path").attr("class","mouth").attr("d",m).attr("transform","translate("+e.cx+","+(e.cy+2)+")")}s(u,"smile");function p(g){const m=it().startAngle(3*Math.PI/2).endAngle(5*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);g.append("path").attr("class","mouth").attr("d",m).attr("transform","translate("+e.cx+","+(e.cy+7)+")")}s(p,"sad");function o(g){g.append("line").attr("class","mouth").attr("stroke",2).attr("x1",e.cx-5).attr("y1",e.cy+7).attr("x2",e.cx+5).attr("y2",e.cy+7).attr("class","mouth").attr("stroke-width","1px").attr("stroke","#666")}return s(o,"ambivalent"),e.score>3?u(i):e.score<3?p(i):o(i),f},"drawFace"),ot=s(function(t,e){const a=t.append("circle");return a.attr("cx",e.cx),a.attr("cy",e.cy),a.attr("class","actor-"+e.pos),a.attr("fill",e.fill),a.attr("stroke",e.stroke),a.attr("r",e.r),a.class!==void 0&&a.attr("class",a.class),e.title!==void 0&&a.append("title").text(e.title),a},"drawCircle"),ct=s(function(t,e){return xt(t,e)},"drawText"),zt=s(function(t,e){function a(i,u,p,o,g){return i+","+u+" "+(i+p)+","+u+" "+(i+p)+","+(u+o-g)+" "+(i+p-g*1.2)+","+(u+o)+" "+i+","+(u+o)}s(a,"genPoints");const f=t.append("polygon");f.attr("points",a(e.x,e.y,50,20,7)),f.attr("class","labelBox"),e.y=e.y+e.labelMargin,e.x=e.x+.5*e.labelMargin,ct(t,e)},"drawLabel"),Wt=s(function(t,e,a){const f=t.append("g"),i=lt();i.x=e.x,i.y=e.y,i.fill=e.fill,i.width=a.width*e.taskCount+a.diagramMarginX*(e.taskCount-1),i.height=a.height,i.class="journey-section section-type-"+e.num,i.rx=3,i.ry=3,K(f,i),ht(a)(e.text,f,i.x,i.y,i.width,i.height,{class:"journey-section section-type-"+e.num},a,e.colour)},"drawSection"),Z=-1,Ot=s(function(t,e,a,f){const i=e.x+a.width/2,u=t.append("g");Z++,u.append("line").attr("id",f+"-task"+Z).attr("x1",i).attr("y1",e.y).attr("x2",i).attr("y2",450).attr("class","task-line").attr("stroke-width","1px").attr("stroke-dasharray","4 2").attr("stroke","#666"),Nt(u,{cx:i,cy:300+(5-e.score)*30,score:e.score});const o=lt();o.x=e.x,o.y=e.y,o.fill=e.fill,o.width=a.width,o.height=a.height,o.class="task task-type-"+e.num,o.rx=3,o.ry=3,K(u,o);let g=e.x+14;e.people.forEach(m=>{const x=e.actors[m].color,h={cx:g,cy:e.y,r:7,fill:x,stroke:"#000",title:m,pos:e.actors[m].position};ot(u,h),g+=10}),ht(a)(e.task,u,o.x,o.y,o.width,o.height,{class:"task"},a,e.colour)},"drawTask"),Yt=s(function(t,e){mt(t,e)},"drawBackgroundRect"),ht=(function(){function t(i,u,p,o,g,m,x,h){const r=u.append("text").attr("x",p+g/2).attr("y",o+m/2+5).style("font-color",h).style("text-anchor","middle").text(i);f(r,x)}s(t,"byText");function e(i,u,p,o,g,m,x,h,r){const{taskFontSize:n,taskFontFamily:l}=h,y=i.split(//gi);for(let d=0;d{const u=E[i].color,p={cx:20,cy:f,r:7,fill:u,stroke:"#000",pos:E[i].position};j.drawCircle(t,p);let o=t.append("text").attr("visibility","hidden").text(i);const g=o.node().getBoundingClientRect().width;o.remove();let m=[];if(g<=a)m=[i];else{const x=i.split(" ");let h="";o=t.append("text").attr("visibility","hidden"),x.forEach(r=>{const n=h?`${h} ${r}`:r;if(o.text(n),o.node().getBoundingClientRect().width>a){if(h&&m.push(h),h=r,o.text(r),o.node().getBoundingClientRect().width>a){let y="";for(const d of r)y+=d,o.text(y+"-"),o.node().getBoundingClientRect().width>a&&(m.push(y.slice(0,-1)+"-"),y=d);h=y}}else h=n}),h&&m.push(h),o.remove()}m.forEach((x,h)=>{const r={x:40,y:f+7+h*20,fill:"#666",text:x,textMargin:e.boxTextMargin??5},l=j.drawText(t,r).node().getBoundingClientRect().width;l>W&&l>e.leftMargin-l&&(W=l)}),f+=Math.max(20,m.length*20)})}s(ut,"drawActorLegend");var $=R().journey,P=0,Xt=s(function(t,e,a,f){const i=R(),u=i.journey.titleColor,p=i.journey.titleFontSize,o=i.journey.titleFontFamily,g=i.securityLevel;let m;g==="sandbox"&&(m=X("#i"+e));const x=g==="sandbox"?X(m.nodes()[0].contentDocument.body):X("body");S.init();const h=x.select("#"+e);j.initGraphics(h,e);const r=f.db.getTasks(),n=f.db.getDiagramTitle(),l=f.db.getActors();for(const C in E)delete E[C];let y=0;l.forEach(C=>{E[C]={color:$.actorColours[y%$.actorColours.length],position:y},y++}),ut(h),P=$.leftMargin+W,S.insert(0,0,P,Object.keys(E).length*50),Gt(h,r,0,e);const d=S.getBounds();n&&h.append("text").text(n).attr("x",P).attr("font-size",p).attr("font-weight","bold").attr("y",25).attr("fill",u).attr("font-family",o);const c=d.stopy-d.starty+2*$.diagramMarginY,v=P+d.stopx+2*$.diagramMarginX;$t(h,c,v,$.useMaxWidth),h.append("line").attr("x1",P).attr("y1",$.height*4).attr("x2",v-P-4).attr("y2",$.height*4).attr("stroke-width",4).attr("stroke","black").attr("marker-end","url(#"+e+"-arrowhead)");const k=n?70:0;h.attr("viewBox",`${d.startx} -25 ${v} ${c+k}`),h.attr("preserveAspectRatio","xMinYMin meet"),h.attr("height",c+k+25)},"draw"),S={data:{startx:void 0,stopx:void 0,starty:void 0,stopy:void 0},verticalPos:0,sequenceItems:[],init:s(function(){this.sequenceItems=[],this.data={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0},this.verticalPos=0},"init"),updateVal:s(function(t,e,a,f){t[e]===void 0?t[e]=a:t[e]=f(a,t[e])},"updateVal"),updateBounds:s(function(t,e,a,f){const i=R().journey,u=this;let p=0;function o(g){return s(function(x){p++;const h=u.sequenceItems.length-p+1;u.updateVal(x,"starty",e-h*i.boxMargin,Math.min),u.updateVal(x,"stopy",f+h*i.boxMargin,Math.max),u.updateVal(S.data,"startx",t-h*i.boxMargin,Math.min),u.updateVal(S.data,"stopx",a+h*i.boxMargin,Math.max),g!=="activation"&&(u.updateVal(x,"startx",t-h*i.boxMargin,Math.min),u.updateVal(x,"stopx",a+h*i.boxMargin,Math.max),u.updateVal(S.data,"starty",e-h*i.boxMargin,Math.min),u.updateVal(S.data,"stopy",f+h*i.boxMargin,Math.max))},"updateItemBounds")}s(o,"updateFn"),this.sequenceItems.forEach(o())},"updateBounds"),insert:s(function(t,e,a,f){const i=Math.min(t,a),u=Math.max(t,a),p=Math.min(e,f),o=Math.max(e,f);this.updateVal(S.data,"startx",i,Math.min),this.updateVal(S.data,"starty",p,Math.min),this.updateVal(S.data,"stopx",u,Math.max),this.updateVal(S.data,"stopy",o,Math.max),this.updateBounds(i,p,u,o)},"insert"),bumpVerticalPos:s(function(t){this.verticalPos=this.verticalPos+t,this.data.stopy=this.verticalPos},"bumpVerticalPos"),getVerticalPos:s(function(){return this.verticalPos},"getVerticalPos"),getBounds:s(function(){return this.data},"getBounds")},G=$.sectionFills,st=$.sectionColours,Gt=s(function(t,e,a,f){const i=R().journey;let u="";const p=i.height*2+i.diagramMarginY,o=a+p;let g=0,m="#CCC",x="black",h=0;for(const[r,n]of e.entries()){if(u!==n.section){m=G[g%G.length],h=g%G.length,x=st[g%st.length];let y=0;const d=n.section;for(let v=r;v(E[d]&&(y[d]=E[d]),y),{});n.x=r*i.taskMargin+r*i.width+P,n.y=o,n.width=i.diagramMarginX,n.height=i.diagramMarginY,n.colour=x,n.fill=m,n.num=h,n.actors=l,j.drawTask(t,n,i,f),S.insert(n.x,n.y,n.x+n.width+i.taskMargin,450)}},"drawTasks"),at={setConf:Ht,draw:Xt},te={parser:Et,db:nt,renderer:at,styles:jt,init:s(t=>{at.setConf(t.journey),nt.clear()},"init")};export{te as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/kanban-definition-UXKFOSKX.BU_et4EL.js b/packages/tempo/public/v4/assets/chunks/kanban-definition-UXKFOSKX.BU_et4EL.js new file mode 100644 index 00000000..7443d1bd --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/kanban-definition-UXKFOSKX.BU_et4EL.js @@ -0,0 +1,89 @@ +import{_ as o,l as te,c as H,G as fe,ah as ye,ai as me,aj as be,af as Ee,E as K,i as G,Z as _e,$ as ke,ac as Se,ad as ce,ae as le}from"../app.CbekdYod.js";import{g as Ne}from"./chunk-5VM5RSS4.-zPOtr2J.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var $=(function(){var e=o(function(O,i,n,r){for(n=n||{},r=O.length;r--;n[O[r]]=i);return n},"o"),h=[1,4],p=[1,13],s=[1,12],d=[1,15],E=[1,16],b=[1,20],l=[1,19],D=[6,7,8],I=[1,26],g=[1,24],w=[1,25],_=[6,7,11],F=[1,31],N=[6,7,11,24],V=[1,6,13,16,17,20,23],f=[1,35],A=[1,36],L=[1,6,7,11,13,16,17,20,23],M=[1,38],T={trace:o(function(){},"trace"),yy:{},symbols_:{error:2,start:3,mindMap:4,spaceLines:5,SPACELINE:6,NL:7,KANBAN:8,document:9,stop:10,EOF:11,statement:12,SPACELIST:13,node:14,shapeData:15,ICON:16,CLASS:17,nodeWithId:18,nodeWithoutId:19,NODE_DSTART:20,NODE_DESCR:21,NODE_DEND:22,NODE_ID:23,SHAPE_DATA:24,$accept:0,$end:1},terminals_:{2:"error",6:"SPACELINE",7:"NL",8:"KANBAN",11:"EOF",13:"SPACELIST",16:"ICON",17:"CLASS",20:"NODE_DSTART",21:"NODE_DESCR",22:"NODE_DEND",23:"NODE_ID",24:"SHAPE_DATA"},productions_:[0,[3,1],[3,2],[5,1],[5,2],[5,2],[4,2],[4,3],[10,1],[10,1],[10,1],[10,2],[10,2],[9,3],[9,2],[12,3],[12,2],[12,2],[12,2],[12,1],[12,2],[12,1],[12,1],[12,1],[12,1],[14,1],[14,1],[19,3],[18,1],[18,4],[15,2],[15,1]],performAction:o(function(i,n,r,a,u,t,U){var c=t.length-1;switch(u){case 6:case 7:return a;case 8:a.getLogger().trace("Stop NL ");break;case 9:a.getLogger().trace("Stop EOF ");break;case 11:a.getLogger().trace("Stop NL2 ");break;case 12:a.getLogger().trace("Stop EOF2 ");break;case 15:a.getLogger().info("Node: ",t[c-1].id),a.addNode(t[c-2].length,t[c-1].id,t[c-1].descr,t[c-1].type,t[c]);break;case 16:a.getLogger().info("Node: ",t[c].id),a.addNode(t[c-1].length,t[c].id,t[c].descr,t[c].type);break;case 17:a.getLogger().trace("Icon: ",t[c]),a.decorateNode({icon:t[c]});break;case 18:case 23:a.decorateNode({class:t[c]});break;case 19:a.getLogger().trace("SPACELIST");break;case 20:a.getLogger().trace("Node: ",t[c-1].id),a.addNode(0,t[c-1].id,t[c-1].descr,t[c-1].type,t[c]);break;case 21:a.getLogger().trace("Node: ",t[c].id),a.addNode(0,t[c].id,t[c].descr,t[c].type);break;case 22:a.decorateNode({icon:t[c]});break;case 27:a.getLogger().trace("node found ..",t[c-2]),this.$={id:t[c-1],descr:t[c-1],type:a.getType(t[c-2],t[c])};break;case 28:this.$={id:t[c],descr:t[c],type:0};break;case 29:a.getLogger().trace("node found ..",t[c-3]),this.$={id:t[c-3],descr:t[c-1],type:a.getType(t[c-2],t[c])};break;case 30:this.$=t[c-1]+t[c];break;case 31:this.$=t[c];break}},"anonymous"),table:[{3:1,4:2,5:3,6:[1,5],8:h},{1:[3]},{1:[2,1]},{4:6,6:[1,7],7:[1,8],8:h},{6:p,7:[1,10],9:9,12:11,13:s,14:14,16:d,17:E,18:17,19:18,20:b,23:l},e(D,[2,3]),{1:[2,2]},e(D,[2,4]),e(D,[2,5]),{1:[2,6],6:p,12:21,13:s,14:14,16:d,17:E,18:17,19:18,20:b,23:l},{6:p,9:22,12:11,13:s,14:14,16:d,17:E,18:17,19:18,20:b,23:l},{6:I,7:g,10:23,11:w},e(_,[2,24],{18:17,19:18,14:27,16:[1,28],17:[1,29],20:b,23:l}),e(_,[2,19]),e(_,[2,21],{15:30,24:F}),e(_,[2,22]),e(_,[2,23]),e(N,[2,25]),e(N,[2,26]),e(N,[2,28],{20:[1,32]}),{21:[1,33]},{6:I,7:g,10:34,11:w},{1:[2,7],6:p,12:21,13:s,14:14,16:d,17:E,18:17,19:18,20:b,23:l},e(V,[2,14],{7:f,11:A}),e(L,[2,8]),e(L,[2,9]),e(L,[2,10]),e(_,[2,16],{15:37,24:F}),e(_,[2,17]),e(_,[2,18]),e(_,[2,20],{24:M}),e(N,[2,31]),{21:[1,39]},{22:[1,40]},e(V,[2,13],{7:f,11:A}),e(L,[2,11]),e(L,[2,12]),e(_,[2,15],{24:M}),e(N,[2,30]),{22:[1,41]},e(N,[2,27]),e(N,[2,29])],defaultActions:{2:[2,1],6:[2,2]},parseError:o(function(i,n){if(n.recoverable)this.trace(i);else{var r=new Error(i);throw r.hash=n,r}},"parseError"),parse:o(function(i){var n=this,r=[0],a=[],u=[null],t=[],U=this.table,c="",W=0,se=0,ue=2,re=1,ge=t.slice.call(arguments,1),m=Object.create(this.lexer),R={yy:{}};for(var J in this.yy)Object.prototype.hasOwnProperty.call(this.yy,J)&&(R.yy[J]=this.yy[J]);m.setInput(i,R.yy),R.yy.lexer=m,R.yy.parser=this,typeof m.yylloc>"u"&&(m.yylloc={});var Z=m.yylloc;t.push(Z);var de=m.options&&m.options.ranges;typeof R.yy.parseError=="function"?this.parseError=R.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function pe(S){r.length=r.length-2*S,u.length=u.length-S,t.length=t.length-S}o(pe,"popStack");function ae(){var S;return S=a.pop()||m.lex()||re,typeof S!="number"&&(S instanceof Array&&(a=S,S=a.pop()),S=n.symbols_[S]||S),S}o(ae,"lex");for(var k,P,x,q,j={},z,C,oe,X;;){if(P=r[r.length-1],this.defaultActions[P]?x=this.defaultActions[P]:((k===null||typeof k>"u")&&(k=ae()),x=U[P]&&U[P][k]),typeof x>"u"||!x.length||!x[0]){var Q="";X=[];for(z in U[P])this.terminals_[z]&&z>ue&&X.push("'"+this.terminals_[z]+"'");m.showPosition?Q="Parse error on line "+(W+1)+`: +`+m.showPosition()+` +Expecting `+X.join(", ")+", got '"+(this.terminals_[k]||k)+"'":Q="Parse error on line "+(W+1)+": Unexpected "+(k==re?"end of input":"'"+(this.terminals_[k]||k)+"'"),this.parseError(Q,{text:m.match,token:this.terminals_[k]||k,line:m.yylineno,loc:Z,expected:X})}if(x[0]instanceof Array&&x.length>1)throw new Error("Parse Error: multiple actions possible at state: "+P+", token: "+k);switch(x[0]){case 1:r.push(k),u.push(m.yytext),t.push(m.yylloc),r.push(x[1]),k=null,se=m.yyleng,c=m.yytext,W=m.yylineno,Z=m.yylloc;break;case 2:if(C=this.productions_[x[1]][1],j.$=u[u.length-C],j._$={first_line:t[t.length-(C||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(C||1)].first_column,last_column:t[t.length-1].last_column},de&&(j._$.range=[t[t.length-(C||1)].range[0],t[t.length-1].range[1]]),q=this.performAction.apply(j,[c,se,W,R.yy,x[1],u,t].concat(ge)),typeof q<"u")return q;C&&(r=r.slice(0,-1*C*2),u=u.slice(0,-1*C),t=t.slice(0,-1*C)),r.push(this.productions_[x[1]][0]),u.push(j.$),t.push(j._$),oe=U[r[r.length-2]][r[r.length-1]],r.push(oe);break;case 3:return!0}}return!0},"parse")},Y=(function(){var O={EOF:1,parseError:o(function(n,r){if(this.yy.parser)this.yy.parser.parseError(n,r);else throw new Error(n)},"parseError"),setInput:o(function(i,n){return this.yy=n||this.yy||{},this._input=i,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:o(function(){var i=this._input[0];this.yytext+=i,this.yyleng++,this.offset++,this.match+=i,this.matched+=i;var n=i.match(/(?:\r\n?|\n).*/g);return n?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),i},"input"),unput:o(function(i){var n=i.length,r=i.split(/(?:\r\n?|\n)/g);this._input=i+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-n),this.offset-=n;var a=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),r.length-1&&(this.yylineno-=r.length-1);var u=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:r?(r.length===a.length?this.yylloc.first_column:0)+a[a.length-r.length].length-r[0].length:this.yylloc.first_column-n},this.options.ranges&&(this.yylloc.range=[u[0],u[0]+this.yyleng-n]),this.yyleng=this.yytext.length,this},"unput"),more:o(function(){return this._more=!0,this},"more"),reject:o(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:o(function(i){this.unput(this.match.slice(i))},"less"),pastInput:o(function(){var i=this.matched.substr(0,this.matched.length-this.match.length);return(i.length>20?"...":"")+i.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:o(function(){var i=this.match;return i.length<20&&(i+=this._input.substr(0,20-i.length)),(i.substr(0,20)+(i.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:o(function(){var i=this.pastInput(),n=new Array(i.length+1).join("-");return i+this.upcomingInput()+` +`+n+"^"},"showPosition"),test_match:o(function(i,n){var r,a,u;if(this.options.backtrack_lexer&&(u={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(u.yylloc.range=this.yylloc.range.slice(0))),a=i[0].match(/(?:\r\n?|\n).*/g),a&&(this.yylineno+=a.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:a?a[a.length-1].length-a[a.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+i[0].length},this.yytext+=i[0],this.match+=i[0],this.matches=i,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(i[0].length),this.matched+=i[0],r=this.performAction.call(this,this.yy,this,n,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),r)return r;if(this._backtrack){for(var t in u)this[t]=u[t];return!1}return!1},"test_match"),next:o(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var i,n,r,a;this._more||(this.yytext="",this.match="");for(var u=this._currentRules(),t=0;tn[0].length)){if(n=r,a=t,this.options.backtrack_lexer){if(i=this.test_match(r,u[t]),i!==!1)return i;if(this._backtrack){n=!1;continue}else return!1}else if(!this.options.flex)break}return n?(i=this.test_match(n,u[a]),i!==!1?i:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:o(function(){var n=this.next();return n||this.lex()},"lex"),begin:o(function(n){this.conditionStack.push(n)},"begin"),popState:o(function(){var n=this.conditionStack.length-1;return n>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:o(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:o(function(n){return n=this.conditionStack.length-1-Math.abs(n||0),n>=0?this.conditionStack[n]:"INITIAL"},"topState"),pushState:o(function(n){this.begin(n)},"pushState"),stateStackSize:o(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:o(function(n,r,a,u){switch(a){case 0:return this.pushState("shapeData"),r.yytext="",24;case 1:return this.pushState("shapeDataStr"),24;case 2:return this.popState(),24;case 3:const t=/\n\s*/g;return r.yytext=r.yytext.replace(t,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "),24;case 4:return 24;case 5:this.popState();break;case 6:return n.getLogger().trace("Found comment",r.yytext),6;case 7:return 8;case 8:this.begin("CLASS");break;case 9:return this.popState(),17;case 10:this.popState();break;case 11:n.getLogger().trace("Begin icon"),this.begin("ICON");break;case 12:return n.getLogger().trace("SPACELINE"),6;case 13:return 7;case 14:return 16;case 15:n.getLogger().trace("end icon"),this.popState();break;case 16:return n.getLogger().trace("Exploding node"),this.begin("NODE"),20;case 17:return n.getLogger().trace("Cloud"),this.begin("NODE"),20;case 18:return n.getLogger().trace("Explosion Bang"),this.begin("NODE"),20;case 19:return n.getLogger().trace("Cloud Bang"),this.begin("NODE"),20;case 20:return this.begin("NODE"),20;case 21:return this.begin("NODE"),20;case 22:return this.begin("NODE"),20;case 23:return this.begin("NODE"),20;case 24:return 13;case 25:return 23;case 26:return 11;case 27:this.begin("NSTR2");break;case 28:return"NODE_DESCR";case 29:this.popState();break;case 30:n.getLogger().trace("Starting NSTR"),this.begin("NSTR");break;case 31:return n.getLogger().trace("description:",r.yytext),"NODE_DESCR";case 32:this.popState();break;case 33:return this.popState(),n.getLogger().trace("node end ))"),"NODE_DEND";case 34:return this.popState(),n.getLogger().trace("node end )"),"NODE_DEND";case 35:return this.popState(),n.getLogger().trace("node end ...",r.yytext),"NODE_DEND";case 36:return this.popState(),n.getLogger().trace("node end (("),"NODE_DEND";case 37:return this.popState(),n.getLogger().trace("node end (-"),"NODE_DEND";case 38:return this.popState(),n.getLogger().trace("node end (-"),"NODE_DEND";case 39:return this.popState(),n.getLogger().trace("node end (("),"NODE_DEND";case 40:return this.popState(),n.getLogger().trace("node end (("),"NODE_DEND";case 41:return n.getLogger().trace("Long description:",r.yytext),21;case 42:return n.getLogger().trace("Long description:",r.yytext),21}},"anonymous"),rules:[/^(?:@\{)/i,/^(?:["])/i,/^(?:["])/i,/^(?:[^\"]+)/i,/^(?:[^}^"]+)/i,/^(?:\})/i,/^(?:\s*%%.*)/i,/^(?:kanban\b)/i,/^(?::::)/i,/^(?:.+)/i,/^(?:\n)/i,/^(?:::icon\()/i,/^(?:[\s]+[\n])/i,/^(?:[\n]+)/i,/^(?:[^\)]+)/i,/^(?:\))/i,/^(?:-\))/i,/^(?:\(-)/i,/^(?:\)\))/i,/^(?:\))/i,/^(?:\(\()/i,/^(?:\{\{)/i,/^(?:\()/i,/^(?:\[)/i,/^(?:[\s]+)/i,/^(?:[^\(\[\n\)\{\}@]+)/i,/^(?:$)/i,/^(?:["][`])/i,/^(?:[^`"]+)/i,/^(?:[`]["])/i,/^(?:["])/i,/^(?:[^"]+)/i,/^(?:["])/i,/^(?:[\)]\))/i,/^(?:[\)])/i,/^(?:[\]])/i,/^(?:\}\})/i,/^(?:\(-)/i,/^(?:-\))/i,/^(?:\(\()/i,/^(?:\()/i,/^(?:[^\)\]\(\}]+)/i,/^(?:.+(?!\(\())/i],conditions:{shapeDataEndBracket:{rules:[],inclusive:!1},shapeDataStr:{rules:[2,3],inclusive:!1},shapeData:{rules:[1,4,5],inclusive:!1},CLASS:{rules:[9,10],inclusive:!1},ICON:{rules:[14,15],inclusive:!1},NSTR2:{rules:[28,29],inclusive:!1},NSTR:{rules:[31,32],inclusive:!1},NODE:{rules:[27,30,33,34,35,36,37,38,39,40,41,42],inclusive:!1},INITIAL:{rules:[0,6,7,8,11,12,13,16,17,18,19,20,21,22,23,24,25,26],inclusive:!0}}};return O})();T.lexer=Y;function B(){this.yy={}}return o(B,"Parser"),B.prototype=T,T.Parser=B,new B})();$.parser=$;var xe=$,v=[],ne=[],ee=0,ie={},ve=o(()=>{v=[],ne=[],ee=0,ie={}},"clear"),De=o(e=>{if(v.length===0)return null;const h=v[0].level;let p=null;for(let s=v.length-1;s>=0;s--)if(v[s].level===h&&!p&&(p=v[s]),v[s].levell.parentId===d.id);for(const l of b){const D={id:l.id,parentId:d.id,label:G(l.label??"",s),labelType:"markdown",isGroup:!1,ticket:l?.ticket,priority:l?.priority,assigned:l?.assigned,icon:l?.icon,shape:"kanbanItem",level:l.level,rx:5,ry:5,cssStyles:["text-align: left"]};h.push(D)}}return{nodes:h,edges:e,other:{},config:H()}},"getData"),Oe=o((e,h,p,s,d)=>{const E=H();let b=E.mindmap?.padding??K.mindmap.padding;switch(s){case y.ROUNDED_RECT:case y.RECT:case y.HEXAGON:b*=2}const l={id:G(h,E)||"kbn"+ee++,level:e,label:G(p,E),width:E.mindmap?.maxNodeWidth??K.mindmap.maxNodeWidth,padding:b,isGroup:!1};if(d!==void 0){let I;d.includes(` +`)?I=d+` +`:I=`{ +`+d+` +}`;const g=_e(I,{schema:ke});if(g.shape&&(g.shape!==g.shape.toLowerCase()||g.shape.includes("_")))throw new Error(`No such shape: ${g.shape}. Shape names should be lowercase.`);g?.shape&&g.shape==="kanbanItem"&&(l.shape=g?.shape),g?.label&&(l.label=g?.label),g?.icon&&(l.icon=g?.icon.toString()),g?.assigned&&(l.assigned=g?.assigned.toString()),g?.ticket&&(l.ticket=g?.ticket.toString()),g?.priority&&(l.priority=g?.priority)}const D=De(e);D?l.parentId=D.id||"kbn"+ee++:ne.push(l),v.push(l)},"addNode"),y={DEFAULT:0,NO_BORDER:0,ROUNDED_RECT:1,RECT:2,CIRCLE:3,CLOUD:4,BANG:5,HEXAGON:6},Ie=o((e,h)=>{switch(te.debug("In get type",e,h),e){case"[":return y.RECT;case"(":return h===")"?y.ROUNDED_RECT:y.CLOUD;case"((":return y.CIRCLE;case")":return y.CLOUD;case"))":return y.BANG;case"{{":return y.HEXAGON;default:return y.DEFAULT}},"getType"),Ce=o((e,h)=>{ie[e]=h},"setElementForId"),we=o(e=>{if(!e)return;const h=H(),p=v[v.length-1];e.icon&&(p.icon=G(e.icon,h)),e.class&&(p.cssClasses=G(e.class,h))},"decorateNode"),Ae=o(e=>{switch(e){case y.DEFAULT:return"no-border";case y.RECT:return"rect";case y.ROUNDED_RECT:return"rounded-rect";case y.CIRCLE:return"circle";case y.CLOUD:return"cloud";case y.BANG:return"bang";case y.HEXAGON:return"hexgon";default:return"no-border"}},"type2Str"),Te=o(()=>te,"getLogger"),Re=o(e=>ie[e],"getElementById"),Pe={clear:ve,addNode:Oe,getSections:he,getData:Le,nodeType:y,getType:Ie,setElementForId:Ce,decorateNode:we,type2Str:Ae,getLogger:Te,getElementById:Re},Ve=Pe,Be=o(async(e,h,p,s)=>{te.debug(`Rendering kanban diagram +`+e);const E=s.db.getData(),b=H();b.htmlLabels=!1;const l=fe(h);for(const f of E.nodes)f.domId=`${h}-${f.id}`;const D=l.append("g");D.attr("class","sections");const I=l.append("g");I.attr("class","items");const g=E.nodes.filter(f=>f.isGroup);let w=0;const _=10,F=[];let N=25;for(const f of g){const A=b?.kanban?.sectionWidth||200;w=w+1,f.x=A*w+(w-1)*_/2,f.width=A,f.y=0,f.height=A*3,f.rx=5,f.ry=5,f.cssClasses=f.cssClasses+" section-"+w;const L=await ye(D,f);N=Math.max(N,L?.labelBBox?.height),F.push(L)}let V=0;for(const f of g){const A=F[V];V=V+1;const L=b?.kanban?.sectionWidth||200,M=-L*3/2+N;let T=M;const Y=E.nodes.filter(i=>i.parentId===f.id);for(const i of Y){if(i.isGroup)throw new Error("Groups within groups are not allowed in Kanban diagrams");i.x=f.x,i.width=L-1.5*_;const r=(await me(I,i,{config:b})).node().getBBox();i.y=T+r.height/2,await be(i),T=i.y+r.height/2+_/2}const B=A.cluster.select("rect"),O=Math.max(T-M+3*_,50)+(N-25);B.attr("height",O)}Ee(void 0,l,b.mindmap?.padding??K.kanban.padding,b.mindmap?.useMaxWidth??K.kanban.useMaxWidth)},"draw"),je={draw:Be},Ge=o(e=>{let h="";for(let s=0;se.darkMode?le(s,d):ce(s,d),"adjuster");for(let s=0;s` + .edge { + stroke-width: 3; + } + ${Ge(e)} + .section-root rect, .section-root path, .section-root circle, .section-root polygon { + fill: ${e.git0}; + } + .section-root text { + fill: ${e.gitBranchLabel0}; + } + .icon-container { + height:100%; + display: flex; + justify-content: center; + align-items: center; + } + .edge { + fill: none; + } + .cluster-label, .label { + color: ${e.textColor}; + fill: ${e.textColor}; + } + .kanban-label { + dy: 1em; + alignment-baseline: middle; + text-anchor: middle; + dominant-baseline: middle; + text-align: center; + } + ${Ne()} +`,"getStyles"),Me=Fe,Xe={db:Ve,renderer:je,parser:xe,styles:Me};export{Xe as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/katex.HP8lGamR.js b/packages/tempo/public/v4/assets/chunks/katex.HP8lGamR.js new file mode 100644 index 00000000..baa1bbe7 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/katex.HP8lGamR.js @@ -0,0 +1,257 @@ +class S extends Error{constructor(e,t){var a="KaTeX parse error: "+e,i,s,u=t&&t.loc;if(u&&u.start<=u.end){var h=u.lexer.input;i=u.start,s=u.end,i===h.length?a+=" at end of input: ":a+=" at position "+(i+1)+": ";var c=h.slice(i,s).replace(/[^]/g,"$&̲"),v;i>15?v="…"+h.slice(i-15,i):v=h.slice(0,i);var p;s+15r.replace(Y1,"-$1").toLowerCase(),W1={"&":"&",">":">","<":"<",'"':""","'":"'"},j1=/[&><"']/g,i0=r=>String(r).replace(j1,e=>W1[e]),Ce=r=>r.type==="ordgroup"||r.type==="color"?r.body.length===1?Ce(r.body[0]):r:r.type==="font"?Ce(r.body):r,Z1=new Set(["mathord","textord","atom"]),D0=r=>Z1.has(Ce(r).type),K1=r=>{var e=/^[\x00-\x20]*([^\\/#?]*?)(:|�*58|�*3a|&colon)/i.exec(r);return e?e[2]!==":"||!/^[a-zA-Z][a-zA-Z0-9+\-.]*$/.test(e[1])?null:e[1].toLowerCase():"_relative"},dt={displayMode:{type:"boolean",description:"Render math in display mode, which puts the math in display style (so \\int and \\sum are large, for example), and centers the math on the page on its own line.",cli:"-d, --display-mode"},output:{type:{enum:["htmlAndMathml","html","mathml"]},description:"Determines the markup language of the output.",cli:"-F, --format "},leqno:{type:"boolean",description:"Render display math in leqno style (left-justified tags)."},fleqn:{type:"boolean",description:"Render display math flush left."},throwOnError:{type:"boolean",default:!0,cli:"-t, --no-throw-on-error",cliDescription:"Render errors (in the color given by --error-color) instead of throwing a ParseError exception when encountering an error."},errorColor:{type:"string",default:"#cc0000",cli:"-c, --error-color ",cliDescription:"A color string given in the format 'rgb' or 'rrggbb' (no #). This option determines the color of errors rendered by the -t option.",cliProcessor:r=>"#"+r},macros:{type:"object",cli:"-m, --macro ",cliDescription:"Define custom macro of the form '\\foo:expansion' (use multiple -m arguments for multiple macros).",cliDefault:[],cliProcessor:(r,e)=>(e.push(r),e)},minRuleThickness:{type:"number",description:"Specifies a minimum thickness, in ems, for fraction lines, `\\sqrt` top lines, `{array}` vertical lines, `\\hline`, `\\hdashline`, `\\underline`, `\\overline`, and the borders of `\\fbox`, `\\boxed`, and `\\fcolorbox`.",processor:r=>Math.max(0,r),cli:"--min-rule-thickness ",cliProcessor:parseFloat},colorIsTextColor:{type:"boolean",description:"Makes \\color behave like LaTeX's 2-argument \\textcolor, instead of LaTeX's one-argument \\color mode change.",cli:"-b, --color-is-text-color"},strict:{type:[{enum:["warn","ignore","error"]},"boolean","function"],description:"Turn on strict / LaTeX faithfulness mode, which throws an error if the input uses features that are not supported by LaTeX.",cli:"-S, --strict",cliDefault:!1},trust:{type:["boolean","function"],description:"Trust the input, enabling all HTML features such as \\url.",cli:"-T, --trust"},maxSize:{type:"number",default:1/0,description:"If non-zero, all user-specified sizes, e.g. in \\rule{500em}{500em}, will be capped to maxSize ems. Otherwise, elements and spaces can be arbitrarily large",processor:r=>Math.max(0,r),cli:"-s, --max-size ",cliProcessor:parseInt},maxExpand:{type:"number",default:1e3,description:"Limit the number of macro expansions to the specified number, to prevent e.g. infinite macro loops. If set to Infinity, the macro expander will try to fully expand as in LaTeX.",processor:r=>Math.max(0,r),cli:"-e, --max-expand ",cliProcessor:r=>r==="Infinity"?1/0:parseInt(r)},globalGroup:{type:"boolean",cli:!1}};function J1(r){if(typeof r!="string")return r.enum[0];switch(r){case"boolean":return!1;case"string":return"";case"number":return 0;case"object":return{};default:throw new Error("Unexpected schema type; settings must declare an explicit default.")}}function Q1(r){if(r.default!==void 0)return r.default;var e=Array.isArray(r.type)?r.type[0]:r.type;return J1(e)}function _1(r,e,t,a){var i=t[e];r[e]=i!==void 0?a.processor?a.processor(i):i:Q1(a)}class Et{constructor(e){e===void 0&&(e={}),this.displayMode=void 0,this.output=void 0,this.leqno=void 0,this.fleqn=void 0,this.throwOnError=void 0,this.errorColor=void 0,this.macros=void 0,this.minRuleThickness=void 0,this.colorIsTextColor=void 0,this.strict=void 0,this.trust=void 0,this.maxSize=void 0,this.maxExpand=void 0,this.globalGroup=void 0,e=e||{};for(var t of Object.keys(dt)){var a=dt[t];a&&_1(this,t,e,a)}}reportNonstrict(e,t,a){var i=this.strict;if(typeof i=="function"&&(i=i(e,t,a)),!(!i||i==="ignore")){if(i===!0||i==="error")throw new S("LaTeX-incompatible input and strict mode is set to 'error': "+(t+" ["+e+"]"),a);i==="warn"?typeof console<"u"&&console.warn("LaTeX-incompatible input and strict mode is set to 'warn': "+(t+" ["+e+"]")):typeof console<"u"&&console.warn("LaTeX-incompatible input and strict mode is set to "+("unrecognized '"+i+"': "+t+" ["+e+"]"))}}useStrictBehavior(e,t,a){var i=this.strict;if(typeof i=="function")try{i=i(e,t,a)}catch{i="error"}return!i||i==="ignore"?!1:i===!0||i==="error"?!0:i==="warn"?(typeof console<"u"&&console.warn("LaTeX-incompatible input and strict mode is set to 'warn': "+(t+" ["+e+"]")),!1):(typeof console<"u"&&console.warn("LaTeX-incompatible input and strict mode is set to "+("unrecognized '"+i+"': "+t+" ["+e+"]")),!1)}isTrusted(e){if("url"in e&&e.url&&!e.protocol){var t=K1(e.url);if(t==null)return!1;e.protocol=t}var a=typeof this.trust=="function"?this.trust(e):this.trust;return!!a}}class F0{constructor(e,t,a){this.id=void 0,this.size=void 0,this.cramped=void 0,this.id=e,this.size=t,this.cramped=a}sup(){return w0[ea[this.id]]}sub(){return w0[ta[this.id]]}fracNum(){return w0[ra[this.id]]}fracDen(){return w0[aa[this.id]]}cramp(){return w0[ia[this.id]]}text(){return w0[na[this.id]]}isTight(){return this.size>=2}}var Rt=0,qe=1,_0=2,B0=3,me=4,p0=5,ee=6,l0=7,w0=[new F0(Rt,0,!1),new F0(qe,0,!0),new F0(_0,1,!1),new F0(B0,1,!0),new F0(me,2,!1),new F0(p0,2,!0),new F0(ee,3,!1),new F0(l0,3,!0)],ea=[me,p0,me,p0,ee,l0,ee,l0],ta=[p0,p0,p0,p0,l0,l0,l0,l0],ra=[_0,B0,me,p0,ee,l0,ee,l0],aa=[B0,B0,p0,p0,l0,l0,l0,l0],ia=[qe,qe,B0,B0,p0,p0,l0,l0],na=[Rt,qe,_0,B0,_0,B0,_0,B0],N={DISPLAY:w0[Rt],TEXT:w0[_0],SCRIPT:w0[me],SCRIPTSCRIPT:w0[ee]},ft=[{name:"latin",blocks:[[256,591],[768,879]]},{name:"cyrillic",blocks:[[1024,1279]]},{name:"armenian",blocks:[[1328,1423]]},{name:"brahmic",blocks:[[2304,4255]]},{name:"georgian",blocks:[[4256,4351]]},{name:"cjk",blocks:[[12288,12543],[19968,40879],[65280,65376]]},{name:"hangul",blocks:[[44032,55215]]}];function sa(r){for(var e=0;e=i[0]&&r<=i[1])return t.name}return null}var De=[];ft.forEach(r=>r.blocks.forEach(e=>De.push(...e)));function Gr(r){for(var e=0;e=De[e]&&r<=De[e+1])return!0;return!1}var r0=r=>r+" "+r,Q0=80,la=function(e,t){return"M95,"+(622+e+t)+` +c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14 +c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54 +c44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10 +s173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429 +c69,-144,104.5,-217.7,106.5,-221 +l`+e/2.075+" -"+e+` +c5.3,-9.3,12,-14,20,-14 +H400000v`+(40+e)+`H845.2724 +s-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7 +c-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z +M`+(834+e)+" "+t+"h400000v"+(40+e)+"h-400000z"},ua=function(e,t){return"M263,"+(601+e+t)+`c0.7,0,18,39.7,52,119 +c34,79.3,68.167,158.7,102.5,238c34.3,79.3,51.8,119.3,52.5,120 +c340,-704.7,510.7,-1060.3,512,-1067 +l`+e/2.084+" -"+e+` +c4.7,-7.3,11,-11,19,-11 +H40000v`+(40+e)+`H1012.3 +s-271.3,567,-271.3,567c-38.7,80.7,-84,175,-136,283c-52,108,-89.167,185.3,-111.5,232 +c-22.3,46.7,-33.8,70.3,-34.5,71c-4.7,4.7,-12.3,7,-23,7s-12,-1,-12,-1 +s-109,-253,-109,-253c-72.7,-168,-109.3,-252,-110,-252c-10.7,8,-22,16.7,-34,26 +c-22,17.3,-33.3,26,-34,26s-26,-26,-26,-26s76,-59,76,-59s76,-60,76,-60z +M`+(1001+e)+" "+t+"h400000v"+(40+e)+"h-400000z"},oa=function(e,t){return"M983 "+(10+e+t)+` +l`+e/3.13+" -"+e+` +c4,-6.7,10,-10,18,-10 H400000v`+(40+e)+` +H1013.1s-83.4,268,-264.1,840c-180.7,572,-277,876.3,-289,913c-4.7,4.7,-12.7,7,-24,7 +s-12,0,-12,0c-1.3,-3.3,-3.7,-11.7,-7,-25c-35.3,-125.3,-106.7,-373.3,-214,-744 +c-10,12,-21,25,-33,39s-32,39,-32,39c-6,-5.3,-15,-14,-27,-26s25,-30,25,-30 +c26.7,-32.7,52,-63,76,-91s52,-60,52,-60s208,722,208,722 +c56,-175.3,126.3,-397.3,211,-666c84.7,-268.7,153.8,-488.2,207.5,-658.5 +c53.7,-170.3,84.5,-266.8,92.5,-289.5z +M`+(1001+e)+" "+t+"h400000v"+(40+e)+"h-400000z"},ha=function(e,t){return"M424,"+(2398+e+t)+` +c-1.3,-0.7,-38.5,-172,-111.5,-514c-73,-342,-109.8,-513.3,-110.5,-514 +c0,-2,-10.7,14.3,-32,49c-4.7,7.3,-9.8,15.7,-15.5,25c-5.7,9.3,-9.8,16,-12.5,20 +s-5,7,-5,7c-4,-3.3,-8.3,-7.7,-13,-13s-13,-13,-13,-13s76,-122,76,-122s77,-121,77,-121 +s209,968,209,968c0,-2,84.7,-361.7,254,-1079c169.3,-717.3,254.7,-1077.7,256,-1081 +l`+e/4.223+" -"+e+`c4,-6.7,10,-10,18,-10 H400000 +v`+(40+e)+`H1014.6 +s-87.3,378.7,-272.6,1166c-185.3,787.3,-279.3,1182.3,-282,1185 +c-2,6,-10,9,-24,9 +c-8,0,-12,-0.7,-12,-2z M`+(1001+e)+" "+t+` +h400000v`+(40+e)+"h-400000z"},ma=function(e,t){return"M473,"+(2713+e+t)+` +c339.3,-1799.3,509.3,-2700,510,-2702 l`+e/5.298+" -"+e+` +c3.3,-7.3,9.3,-11,18,-11 H400000v`+(40+e)+`H1017.7 +s-90.5,478,-276.2,1466c-185.7,988,-279.5,1483,-281.5,1485c-2,6,-10,9,-24,9 +c-8,0,-12,-0.7,-12,-2c0,-1.3,-5.3,-32,-16,-92c-50.7,-293.3,-119.7,-693.3,-207,-1200 +c0,-1.3,-5.3,8.7,-16,30c-10.7,21.3,-21.3,42.7,-32,64s-16,33,-16,33s-26,-26,-26,-26 +s76,-153,76,-153s77,-151,77,-151c0.7,0.7,35.7,202,105,604c67.3,400.7,102,602.7,104, +606zM`+(1001+e)+" "+t+"h400000v"+(40+e)+"H1017.7z"},ca=function(e){var t=e/2;return"M400000 "+e+" H0 L"+t+" 0 l65 45 L145 "+(e-80)+" H400000z"},da=function(e,t,a){var i=a-54-t-e;return"M702 "+(e+t)+"H400000"+(40+e)+` +H742v`+i+`l-4 4-4 4c-.667.7 -2 1.5-4 2.5s-4.167 1.833-6.5 2.5-5.5 1-9.5 1 +h-12l-28-84c-16.667-52-96.667 -294.333-240-727l-212 -643 -85 170 +c-4-3.333-8.333-7.667-13 -13l-13-13l77-155 77-156c66 199.333 139 419.667 +219 661 l218 661zM702 `+t+"H400000v"+(40+e)+"H742z"},fa=function(e,t,a){t=1e3*t;var i="";switch(e){case"sqrtMain":i=la(t,Q0);break;case"sqrtSize1":i=ua(t,Q0);break;case"sqrtSize2":i=oa(t,Q0);break;case"sqrtSize3":i=ha(t,Q0);break;case"sqrtSize4":i=ma(t,Q0);break;case"sqrtTall":i=da(t,Q0,a)}return i},va=function(e,t){switch(e){case"⎜":return r0("M291 0 H417 V"+t+" H291z");case"∣":return r0("M145 0 H188 V"+t+" H145z");case"∥":return r0("M145 0 H188 V"+t+" H145z")+r0("M367 0 H410 V"+t+" H367z");case"⎟":return r0("M457 0 H583 V"+t+" H457z");case"⎢":return r0("M319 0 H403 V"+t+" H319z");case"⎥":return r0("M263 0 H347 V"+t+" H263z");case"⎪":return r0("M384 0 H504 V"+t+" H384z");case"⏐":return r0("M312 0 H355 V"+t+" H312z");case"‖":return r0("M257 0 H300 V"+t+" H257z")+r0("M478 0 H521 V"+t+" H478z");default:return""}},ar={doubleleftarrow:`M262 157 +l10-10c34-36 62.7-77 86-123 3.3-8 5-13.3 5-16 0-5.3-6.7-8-20-8-7.3 + 0-12.2.5-14.5 1.5-2.3 1-4.8 4.5-7.5 10.5-49.3 97.3-121.7 169.3-217 216-28 + 14-57.3 25-88 33-6.7 2-11 3.8-13 5.5-2 1.7-3 4.2-3 7.5s1 5.8 3 7.5 +c2 1.7 6.3 3.5 13 5.5 68 17.3 128.2 47.8 180.5 91.5 52.3 43.7 93.8 96.2 124.5 + 157.5 9.3 8 15.3 12.3 18 13h6c12-.7 18-4 18-10 0-2-1.7-7-5-15-23.3-46-52-87 +-86-123l-10-10h399738v-40H218c328 0 0 0 0 0l-10-8c-26.7-20-65.7-43-117-69 2.7 +-2 6-3.7 10-5 36.7-16 72.3-37.3 107-64l10-8h399782v-40z +m8 0v40h399730v-40zm0 194v40h399730v-40z`,doublerightarrow:`M399738 392l +-10 10c-34 36-62.7 77-86 123-3.3 8-5 13.3-5 16 0 5.3 6.7 8 20 8 7.3 0 12.2-.5 + 14.5-1.5 2.3-1 4.8-4.5 7.5-10.5 49.3-97.3 121.7-169.3 217-216 28-14 57.3-25 88 +-33 6.7-2 11-3.8 13-5.5 2-1.7 3-4.2 3-7.5s-1-5.8-3-7.5c-2-1.7-6.3-3.5-13-5.5-68 +-17.3-128.2-47.8-180.5-91.5-52.3-43.7-93.8-96.2-124.5-157.5-9.3-8-15.3-12.3-18 +-13h-6c-12 .7-18 4-18 10 0 2 1.7 7 5 15 23.3 46 52 87 86 123l10 10H0v40h399782 +c-328 0 0 0 0 0l10 8c26.7 20 65.7 43 117 69-2.7 2-6 3.7-10 5-36.7 16-72.3 37.3 +-107 64l-10 8H0v40zM0 157v40h399730v-40zm0 194v40h399730v-40z`,leftarrow:`M400000 241H110l3-3c68.7-52.7 113.7-120 + 135-202 4-14.7 6-23 6-25 0-7.3-7-11-21-11-8 0-13.2.8-15.5 2.5-2.3 1.7-4.2 5.8 +-5.5 12.5-1.3 4.7-2.7 10.3-4 17-12 48.7-34.8 92-68.5 130S65.3 228.3 18 247 +c-10 4-16 7.7-18 11 0 8.7 6 14.3 18 17 47.3 18.7 87.8 47 121.5 85S196 441.3 208 + 490c.7 2 1.3 5 2 9s1.2 6.7 1.5 8c.3 1.3 1 3.3 2 6s2.2 4.5 3.5 5.5c1.3 1 3.3 + 1.8 6 2.5s6 1 10 1c14 0 21-3.7 21-11 0-2-2-10.3-6-25-20-79.3-65-146.7-135-202 + l-3-3h399890zM100 241v40h399900v-40z`,leftbrace:`M6 548l-6-6v-35l6-11c56-104 135.3-181.3 238-232 57.3-28.7 117 +-45 179-50h399577v120H403c-43.3 7-81 15-113 26-100.7 33-179.7 91-237 174-2.7 + 5-6 9-10 13-.7 1-7.3 1-20 1H6z`,leftbraceunder:`M0 6l6-6h17c12.688 0 19.313.3 20 1 4 4 7.313 8.3 10 13 + 35.313 51.3 80.813 93.8 136.5 127.5 55.688 33.7 117.188 55.8 184.5 66.5.688 + 0 2 .3 4 1 18.688 2.7 76 4.3 172 5h399450v120H429l-6-1c-124.688-8-235-61.7 +-331-161C60.687 138.7 32.312 99.3 7 54L0 41V6z`,leftgroup:`M400000 80 +H435C64 80 168.3 229.4 21 260c-5.9 1.2-18 0-18 0-2 0-3-1-3-3v-38C76 61 257 0 + 435 0h399565z`,leftgroupunder:`M400000 262 +H435C64 262 168.3 112.6 21 82c-5.9-1.2-18 0-18 0-2 0-3 1-3 3v38c76 158 257 219 + 435 219h399565z`,leftharpoon:`M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3 +-3.3 10.2-9.5 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5 +-18.3 3-21-1.3-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7 +-196 228-6.7 4.7-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40z`,leftharpoonplus:`M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3-3.3 10.2-9.5 + 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5-18.3 3-21-1.3 +-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7-196 228-6.7 4.7 +-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40zM0 435v40h400000v-40z +m0 0v40h400000v-40z`,leftharpoondown:`M7 241c-4 4-6.333 8.667-7 14 0 5.333.667 9 2 11s5.333 + 5.333 12 10c90.667 54 156 130 196 228 3.333 10.667 6.333 16.333 9 17 2 .667 5 + 1 9 1h5c10.667 0 16.667-2 18-6 2-2.667 1-9.667-3-21-32-87.333-82.667-157.667 +-152-211l-3-3h399907v-40zM93 281 H400000 v-40L7 241z`,leftharpoondownplus:`M7 435c-4 4-6.3 8.7-7 14 0 5.3.7 9 2 11s5.3 5.3 12 + 10c90.7 54 156 130 196 228 3.3 10.7 6.3 16.3 9 17 2 .7 5 1 9 1h5c10.7 0 16.7 +-2 18-6 2-2.7 1-9.7-3-21-32-87.3-82.7-157.7-152-211l-3-3h399907v-40H7zm93 0 +v40h399900v-40zM0 241v40h399900v-40zm0 0v40h399900v-40z`,lefthook:`M400000 281 H103s-33-11.2-61-33.5S0 197.3 0 164s14.2-61.2 42.5 +-83.5C70.8 58.2 104 47 142 47 c16.7 0 25 6.7 25 20 0 12-8.7 18.7-26 20-40 3.3 +-68.7 15.7-86 37-10 12-15 25.3-15 40 0 22.7 9.8 40.7 29.5 54 19.7 13.3 43.5 21 + 71.5 23h399859zM103 281v-40h399897v40z`,leftlinesegment:r0("M40 281 V428 H0 V94 H40 V241 H400000 v40z"),leftbracketunder:r0("M0 0 h120 V290 H399995 v120 H0z"),leftbracketover:r0("M0 440 h120 V150 H399995 v-120 H0z"),leftmapsto:r0("M40 281 V448H0V74H40V241H400000v40z"),leftToFrom:`M0 147h400000v40H0zm0 214c68 40 115.7 95.7 143 167h22c15.3 0 23 +-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69-70-101l-7-8h399905v-40H95l7-8 +c28.7-32 52-65.7 70-101 10.7-23.3 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 265.3 + 68 321 0 361zm0-174v-40h399900v40zm100 154v40h399900v-40z`,longequal:r0("M0 50 h400000 v40H0z m0 194h40000v40H0z"),midbrace:`M200428 334 +c-100.7-8.3-195.3-44-280-108-55.3-42-101.7-93-139-153l-9-14c-2.7 4-5.7 8.7-9 14 +-53.3 86.7-123.7 153-211 199-66.7 36-137.3 56.3-212 62H0V214h199568c178.3-11.7 + 311.7-78.3 403-201 6-8 9.7-12 11-12 .7-.7 6.7-1 18-1s17.3.3 18 1c1.3 0 5 4 11 + 12 44.7 59.3 101.3 106.3 170 141s145.3 54.3 229 60h199572v120z`,midbraceunder:`M199572 214 +c100.7 8.3 195.3 44 280 108 55.3 42 101.7 93 139 153l9 14c2.7-4 5.7-8.7 9-14 + 53.3-86.7 123.7-153 211-199 66.7-36 137.3-56.3 212-62h199568v120H200432c-178.3 + 11.7-311.7 78.3-403 201-6 8-9.7 12-11 12-.7.7-6.7 1-18 1s-17.3-.3-18-1c-1.3 0 +-5-4-11-12-44.7-59.3-101.3-106.3-170-141s-145.3-54.3-229-60H0V214z`,oiintSize1:`M512.6 71.6c272.6 0 320.3 106.8 320.3 178.2 0 70.8-47.7 177.6 +-320.3 177.6S193.1 320.6 193.1 249.8c0-71.4 46.9-178.2 319.5-178.2z +m368.1 178.2c0-86.4-60.9-215.4-368.1-215.4-306.4 0-367.3 129-367.3 215.4 0 85.8 +60.9 214.8 367.3 214.8 307.2 0 368.1-129 368.1-214.8z`,oiintSize2:`M757.8 100.1c384.7 0 451.1 137.6 451.1 230 0 91.3-66.4 228.8 +-451.1 228.8-386.3 0-452.7-137.5-452.7-228.8 0-92.4 66.4-230 452.7-230z +m502.4 230c0-111.2-82.4-277.2-502.4-277.2s-504 166-504 277.2 +c0 110 84 276 504 276s502.4-166 502.4-276z`,oiiintSize1:`M681.4 71.6c408.9 0 480.5 106.8 480.5 178.2 0 70.8-71.6 177.6 +-480.5 177.6S202.1 320.6 202.1 249.8c0-71.4 70.5-178.2 479.3-178.2z +m525.8 178.2c0-86.4-86.8-215.4-525.7-215.4-437.9 0-524.7 129-524.7 215.4 0 +85.8 86.8 214.8 524.7 214.8 438.9 0 525.7-129 525.7-214.8z`,oiiintSize2:`M1021.2 53c603.6 0 707.8 165.8 707.8 277.2 0 110-104.2 275.8 +-707.8 275.8-606 0-710.2-165.8-710.2-275.8C311 218.8 415.2 53 1021.2 53z +m770.4 277.1c0-131.2-126.4-327.6-770.5-327.6S248.4 198.9 248.4 330.1 +c0 130 128.8 326.4 772.7 326.4s770.5-196.4 770.5-326.4z`,rightarrow:`M0 241v40h399891c-47.3 35.3-84 78-110 128 +-16.7 32-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20 + 11 8 0 13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7 + 39-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85 +-40.5-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5 +-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67 + 151.7 139 205zm0 0v40h399900v-40z`,rightbrace:`M400000 542l +-6 6h-17c-12.7 0-19.3-.3-20-1-4-4-7.3-8.3-10-13-35.3-51.3-80.8-93.8-136.5-127.5 +s-117.2-55.8-184.5-66.5c-.7 0-2-.3-4-1-18.7-2.7-76-4.3-172-5H0V214h399571l6 1 +c124.7 8 235 61.7 331 161 31.3 33.3 59.7 72.7 85 118l7 13v35z`,rightbraceunder:`M399994 0l6 6v35l-6 11c-56 104-135.3 181.3-238 232-57.3 + 28.7-117 45-179 50H-300V214h399897c43.3-7 81-15 113-26 100.7-33 179.7-91 237 +-174 2.7-5 6-9 10-13 .7-1 7.3-1 20-1h17z`,rightgroup:`M0 80h399565c371 0 266.7 149.4 414 180 5.9 1.2 18 0 18 0 2 0 + 3-1 3-3v-38c-76-158-257-219-435-219H0z`,rightgroupunder:`M0 262h399565c371 0 266.7-149.4 414-180 5.9-1.2 18 0 18 + 0 2 0 3 1 3 3v38c-76 158-257 219-435 219H0z`,rightharpoon:`M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3 +-3.7-15.3-11-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2 +-10.7 0-16.7 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58 + 69.2 92 94.5zm0 0v40h399900v-40z`,rightharpoonplus:`M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3-3.7-15.3-11 +-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2-10.7 0-16.7 + 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58 69.2 92 94.5z +m0 0v40h399900v-40z m100 194v40h399900v-40zm0 0v40h399900v-40z`,rightharpoondown:`M399747 511c0 7.3 6.7 11 20 11 8 0 13-.8 15-2.5s4.7-6.8 + 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3 8.5-5.8 9.5 +-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3-64.7 57-92 95 +-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 241v40h399900v-40z`,rightharpoondownplus:`M399747 705c0 7.3 6.7 11 20 11 8 0 13-.8 + 15-2.5s4.7-6.8 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3 + 8.5-5.8 9.5-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3 +-64.7 57-92 95-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 435v40h399900v-40z +m0-194v40h400000v-40zm0 0v40h400000v-40z`,righthook:`M399859 241c-764 0 0 0 0 0 40-3.3 68.7-15.7 86-37 10-12 15-25.3 + 15-40 0-22.7-9.8-40.7-29.5-54-19.7-13.3-43.5-21-71.5-23-17.3-1.3-26-8-26-20 0 +-13.3 8.7-20 26-20 38 0 71 11.2 99 33.5 0 0 7 5.6 21 16.7 14 11.2 21 33.5 21 + 66.8s-14 61.2-42 83.5c-28 22.3-61 33.5-99 33.5L0 241z M0 281v-40h399859v40z`,rightlinesegment:r0("M399960 241 V94 h40 V428 h-40 V281 H0 v-40z"),rightbracketunder:r0("M399995 0 h-120 V290 H0 v120 H400000z"),rightbracketover:r0("M399995 440 h-120 V150 H0 v-120 H399995z"),rightToFrom:`M400000 167c-70.7-42-118-97.7-142-167h-23c-15.3 0-23 .3-23 + 1 0 1.3 5.3 13.7 16 37 18 35.3 41.3 69 70 101l7 8H0v40h399905l-7 8c-28.7 32 +-52 65.7-70 101-10.7 23.3-16 35.7-16 37 0 .7 7.7 1 23 1h23c24-69.3 71.3-125 142 +-167z M100 147v40h399900v-40zM0 341v40h399900v-40z`,twoheadleftarrow:`M0 167c68 40 + 115.7 95.7 143 167h22c15.3 0 23-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69 +-70-101l-7-8h125l9 7c50.7 39.3 85 86 103 140h46c0-4.7-6.3-18.7-19-42-18-35.3 +-40-67.3-66-96l-9-9h399716v-40H284l9-9c26-28.7 48-60.7 66-96 12.7-23.333 19 +-37.333 19-42h-46c-18 54-52.3 100.7-103 140l-9 7H95l7-8c28.7-32 52-65.7 70-101 + 10.7-23.333 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 71.3 68 127 0 167z`,twoheadrightarrow:`M400000 167 +c-68-40-115.7-95.7-143-167h-22c-15.3 0-23 .3-23 1 0 1.3 5.3 13.7 16 37 18 35.3 + 41.3 69 70 101l7 8h-125l-9-7c-50.7-39.3-85-86-103-140h-46c0 4.7 6.3 18.7 19 42 + 18 35.3 40 67.3 66 96l9 9H0v40h399716l-9 9c-26 28.7-48 60.7-66 96-12.7 23.333 +-19 37.333-19 42h46c18-54 52.3-100.7 103-140l9-7h125l-7 8c-28.7 32-52 65.7-70 + 101-10.7 23.333-16 35.7-16 37 0 .7 7.7 1 23 1h22c27.3-71.3 75-127 143-167z`,tilde1:`M200 55.538c-77 0-168 73.953-177 73.953-3 0-7 +-2.175-9-5.437L2 97c-1-2-2-4-2-6 0-4 2-7 5-9l20-12C116 12 171 0 207 0c86 0 + 114 68 191 68 78 0 168-68 177-68 4 0 7 2 9 5l12 19c1 2.175 2 4.35 2 6.525 0 + 4.35-2 7.613-5 9.788l-19 13.05c-92 63.077-116.937 75.308-183 76.128 +-68.267.847-113-73.952-191-73.952z`,tilde2:`M344 55.266c-142 0-300.638 81.316-311.5 86.418 +-8.01 3.762-22.5 10.91-23.5 5.562L1 120c-1-2-1-3-1-4 0-5 3-9 8-10l18.4-9C160.9 + 31.9 283 0 358 0c148 0 188 122 331 122s314-97 326-97c4 0 8 2 10 7l7 21.114 +c1 2.14 1 3.21 1 4.28 0 5.347-3 9.626-7 10.696l-22.3 12.622C852.6 158.372 751 + 181.476 676 181.476c-149 0-189-126.21-332-126.21z`,tilde3:`M786 59C457 59 32 175.242 13 175.242c-6 0-10-3.457 +-11-10.37L.15 138c-1-7 3-12 10-13l19.2-6.4C378.4 40.7 634.3 0 804.3 0c337 0 + 411.8 157 746.8 157 328 0 754-112 773-112 5 0 10 3 11 9l1 14.075c1 8.066-.697 + 16.595-6.697 17.492l-21.052 7.31c-367.9 98.146-609.15 122.696-778.15 122.696 + -338 0-409-156.573-744-156.573z`,tilde4:`M786 58C457 58 32 177.487 13 177.487c-6 0-10-3.345 +-11-10.035L.15 143c-1-7 3-12 10-13l22-6.7C381.2 35 637.15 0 807.15 0c337 0 409 + 177 744 177 328 0 754-127 773-127 5 0 10 3 11 9l1 14.794c1 7.805-3 13.38-9 + 14.495l-20.7 5.574c-366.85 99.79-607.3 139.372-776.3 139.372-338 0-409 + -175.236-744-175.236z`,vec:`M377 20c0-5.333 1.833-10 5.5-14S391 0 397 0c4.667 0 8.667 1.667 12 5 +3.333 2.667 6.667 9 10 19 6.667 24.667 20.333 43.667 41 57 7.333 4.667 11 +10.667 11 18 0 6-1 10-3 12s-6.667 5-14 9c-28.667 14.667-53.667 35.667-75 63 +-1.333 1.333-3.167 3.5-5.5 6.5s-4 4.833-5 5.5c-1 .667-2.5 1.333-4.5 2s-4.333 1 +-7 1c-4.667 0-9.167-1.833-13.5-5.5S337 184 337 178c0-12.667 15.667-32.333 47-59 +H213l-171-1c-8.667-6-13-12.333-13-19 0-4.667 4.333-11.333 13-20h359 +c-16-25.333-24-45-24-59z`,widehat1:`M529 0h5l519 115c5 1 9 5 9 10 0 1-1 2-1 3l-4 22 +c-1 5-5 9-11 9h-2L532 67 19 159h-2c-5 0-9-4-11-9l-5-22c-1-6 2-12 8-13z`,widehat2:`M1181 0h2l1171 176c6 0 10 5 10 11l-2 23c-1 6-5 10 +-11 10h-1L1182 67 15 220h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z`,widehat3:`M1181 0h2l1171 236c6 0 10 5 10 11l-2 23c-1 6-5 10 +-11 10h-1L1182 67 15 280h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z`,widehat4:`M1181 0h2l1171 296c6 0 10 5 10 11l-2 23c-1 6-5 10 +-11 10h-1L1182 67 15 340h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z`,widecheck1:`M529,159h5l519,-115c5,-1,9,-5,9,-10c0,-1,-1,-2,-1,-3l-4,-22c-1, +-5,-5,-9,-11,-9h-2l-512,92l-513,-92h-2c-5,0,-9,4,-11,9l-5,22c-1,6,2,12,8,13z`,widecheck2:`M1181,220h2l1171,-176c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10, +-11,-10h-1l-1168,153l-1167,-153h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z`,widecheck3:`M1181,280h2l1171,-236c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10, +-11,-10h-1l-1168,213l-1167,-213h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z`,widecheck4:`M1181,340h2l1171,-296c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10, +-11,-10h-1l-1168,273l-1167,-273h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z`,baraboveleftarrow:`M400000 620h-399890l3 -3c68.7 -52.7 113.7 -120 135 -202 +c4 -14.7 6 -23 6 -25c0 -7.3 -7 -11 -21 -11c-8 0 -13.2 0.8 -15.5 2.5 +c-2.3 1.7 -4.2 5.8 -5.5 12.5c-1.3 4.7 -2.7 10.3 -4 17c-12 48.7 -34.8 92 -68.5 130 +s-74.2 66.3 -121.5 85c-10 4 -16 7.7 -18 11c0 8.7 6 14.3 18 17c47.3 18.7 87.8 47 +121.5 85s56.5 81.3 68.5 130c0.7 2 1.3 5 2 9s1.2 6.7 1.5 8c0.3 1.3 1 3.3 2 6 +s2.2 4.5 3.5 5.5c1.3 1 3.3 1.8 6 2.5s6 1 10 1c14 0 21 -3.7 21 -11 +c0 -2 -2 -10.3 -6 -25c-20 -79.3 -65 -146.7 -135 -202l-3 -3h399890z +M100 620v40h399900v-40z M0 241v40h399900v-40zM0 241v40h399900v-40z`,rightarrowabovebar:`M0 241v40h399891c-47.3 35.3-84 78-110 128-16.7 32 +-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20 11 8 0 +13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7 39 +-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85-40.5 +-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5 +-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67 +151.7 139 205zm96 379h399894v40H0zm0 0h399904v40H0z`,baraboveshortleftharpoon:`M507,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11 +c1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17 +c2,0.7,5,1,9,1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21 +c-32,-87.3,-82.7,-157.7,-152,-211c0,0,-3,-3,-3,-3l399351,0l0,-40 +c-398570,0,-399437,0,-399437,0z M593 435 v40 H399500 v-40z +M0 281 v-40 H399908 v40z M0 281 v-40 H399908 v40z`,rightharpoonaboveshortbar:`M0,241 l0,40c399126,0,399993,0,399993,0 +c4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199, +-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6 +c-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z +M0 241 v40 H399908 v-40z M0 475 v-40 H399500 v40z M0 475 v-40 H399500 v40z`,shortbaraboveleftharpoon:`M7,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11 +c1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17c2,0.7,5,1,9, +1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21c-32,-87.3,-82.7,-157.7, +-152,-211c0,0,-3,-3,-3,-3l399907,0l0,-40c-399126,0,-399993,0,-399993,0z +M93 435 v40 H400000 v-40z M500 241 v40 H400000 v-40z M500 241 v40 H400000 v-40z`,shortrightharpoonabovebar:`M53,241l0,40c398570,0,399437,0,399437,0 +c4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199, +-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6 +c-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z +M500 241 v40 H399408 v-40z M500 435 v40 H400000 v-40z`},pa=function(e,t){switch(e){case"lbrack":return"M403 1759 V84 H666 V0 H319 V1759 v"+t+` v1759 v84 h347 v-84 +H403z M403 1759 V0 H319 V1759 v`+t+" v1759 v84 h84z";case"rbrack":return"M347 1759 V0 H0 V84 H263 V1759 v"+t+` v1759 H0 v84 H347z +M347 1759 V0 H263 V1759 v`+t+" v1759 h84z";case"vert":return"M145 15 v585 v"+t+` v585 c2.667,10,9.667,15,21,15 +c10,0,16.667,-5,20,-15 v-585 v`+-t+` v-585 c-2.667,-10,-9.667,-15,-21,-15 +c-10,0,-16.667,5,-20,15z M188 15 H145 v585 v`+t+" v585 h43z";case"doublevert":return"M145 15 v585 v"+t+` v585 c2.667,10,9.667,15,21,15 +c10,0,16.667,-5,20,-15 v-585 v`+-t+` v-585 c-2.667,-10,-9.667,-15,-21,-15 +c-10,0,-16.667,5,-20,15z M188 15 H145 v585 v`+t+` v585 h43z +M367 15 v585 v`+t+` v585 c2.667,10,9.667,15,21,15 +c10,0,16.667,-5,20,-15 v-585 v`+-t+` v-585 c-2.667,-10,-9.667,-15,-21,-15 +c-10,0,-16.667,5,-20,15z M410 15 H367 v585 v`+t+" v585 h43z";case"lfloor":return"M319 602 V0 H403 V602 v"+t+` v1715 h263 v84 H319z +MM319 602 V0 H403 V602 v`+t+" v1715 H319z";case"rfloor":return"M319 602 V0 H403 V602 v"+t+` v1799 H0 v-84 H319z +MM319 602 V0 H403 V602 v`+t+" v1715 H319z";case"lceil":return"M403 1759 V84 H666 V0 H319 V1759 v"+t+` v602 h84z +M403 1759 V0 H319 V1759 v`+t+" v602 h84z";case"rceil":return"M347 1759 V0 H0 V84 H263 V1759 v"+t+` v602 h84z +M347 1759 V0 h-84 V1759 v`+t+" v602 h84z";case"lparen":return`M863,9c0,-2,-2,-5,-6,-9c0,0,-17,0,-17,0c-12.7,0,-19.3,0.3,-20,1 +c-5.3,5.3,-10.3,11,-15,17c-242.7,294.7,-395.3,682,-458,1162c-21.3,163.3,-33.3,349, +-36,557 l0,`+(t+84)+`c0.2,6,0,26,0,60c2,159.3,10,310.7,24,454c53.3,528,210, +949.7,470,1265c4.7,6,9.7,11.7,15,17c0.7,0.7,7,1,19,1c0,0,18,0,18,0c4,-4,6,-7,6,-9 +c0,-2.7,-3.3,-8.7,-10,-18c-135.3,-192.7,-235.5,-414.3,-300.5,-665c-65,-250.7,-102.5, +-544.7,-112.5,-882c-2,-104,-3,-167,-3,-189 +l0,-`+(t+92)+`c0,-162.7,5.7,-314,17,-454c20.7,-272,63.7,-513,129,-723c65.3, +-210,155.3,-396.3,270,-559c6.7,-9.3,10,-15.3,10,-18z`;case"rparen":return`M76,0c-16.7,0,-25,3,-25,9c0,2,2,6.3,6,13c21.3,28.7,42.3,60.3, +63,95c96.7,156.7,172.8,332.5,228.5,527.5c55.7,195,92.8,416.5,111.5,664.5 +c11.3,139.3,17,290.7,17,454c0,28,1.7,43,3.3,45l0,`+(t+9)+` +c-3,4,-3.3,16.7,-3.3,38c0,162,-5.7,313.7,-17,455c-18.7,248,-55.8,469.3,-111.5,664 +c-55.7,194.7,-131.8,370.3,-228.5,527c-20.7,34.7,-41.7,66.3,-63,95c-2,3.3,-4,7,-6,11 +c0,7.3,5.7,11,17,11c0,0,11,0,11,0c9.3,0,14.3,-0.3,15,-1c5.3,-5.3,10.3,-11,15,-17 +c242.7,-294.7,395.3,-681.7,458,-1161c21.3,-164.7,33.3,-350.7,36,-558 +l0,-`+(t+144)+`c-2,-159.3,-10,-310.7,-24,-454c-53.3,-528,-210,-949.7, +-470,-1265c-4.7,-6,-9.7,-11.7,-15,-17c-0.7,-0.7,-6.7,-1,-18,-1z`;default:throw new Error("Unknown stretchy delimiter.")}};function ga(r){return"toText"in r}class ae{constructor(e){this.children=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,this.children=e,this.classes=[],this.height=0,this.depth=0,this.maxFontSize=0,this.style={}}hasClass(e){return this.classes.includes(e)}toNode(){for(var e=document.createDocumentFragment(),t=0;t{if(ga(e))return e.toText();throw new Error("Expected MathDomNode with toText, got "+e.constructor.name)}).join("")}}var vt={pt:1,mm:7227/2540,cm:7227/254,in:72.27,bp:803/800,pc:12,dd:1238/1157,cc:14856/1157,nd:685/642,nc:1370/107,sp:1/65536,px:803/800},ba={ex:!0,em:!0,mu:!0},Ur=function(e){return typeof e!="string"&&(e=e.unit),e in vt||e in ba||e==="ex"},K=function(e,t){var a;if(e.unit in vt)a=vt[e.unit]/t.fontMetrics().ptPerEm/t.sizeMultiplier;else if(e.unit==="mu")a=t.fontMetrics().cssEmPerMu;else{var i;if(t.style.isTight()?i=t.havingStyle(t.style.text()):i=t,e.unit==="ex")a=i.fontMetrics().xHeight;else if(e.unit==="em")a=i.fontMetrics().quad;else throw new S("Invalid unit: '"+e.unit+"'");i!==t&&(a*=i.sizeMultiplier/t.sizeMultiplier)}return Math.min(e.number*a,t.maxSize)},A=function(e){return+e.toFixed(4)+"em"},L0=function(e){return e.filter(t=>t).join(" ")},It=function(e){var t="";for(var a of Object.keys(e)){var i=e[a];i!==void 0&&(t+=$1(a)+":"+i+";")}return t},Vr=function(e,t,a){if(this.classes=e||[],this.attributes={},this.height=0,this.depth=0,this.maxFontSize=0,this.style=a||{},t){t.style.isTight()&&this.classes.push("mtight");var i=t.getColor();i&&(this.style.color=i)}},Xr=function(e){var t=document.createElement(e);t.className=L0(this.classes),Object.assign(t.style,this.style);for(var a of Object.keys(this.attributes))t.setAttribute(a,this.attributes[a]);for(var i=0;i/=\x00-\x1f]/,Yr=function(e){var t="<"+e;this.classes.length&&(t+=' class="'+i0(L0(this.classes))+'"');var a=It(this.style);a&&(t+=' style="'+i0(a)+'"');for(var i of Object.keys(this.attributes)){if(ya.test(i))throw new S("Invalid attribute name '"+i+"'");t+=" "+i+'="'+i0(this.attributes[i])+'"'}t+=">";for(var s=0;s",t};class ie{constructor(e,t,a,i){this.children=void 0,this.attributes=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.width=void 0,this.maxFontSize=void 0,this.style=void 0,this.italic=void 0,Vr.call(this,e,a,i),this.children=t||[]}setAttribute(e,t){this.attributes[e]=t}hasClass(e){return this.classes.includes(e)}toNode(){return Xr.call(this,"span")}toMarkup(){return Yr.call(this,"span")}}class Fe{constructor(e,t,a,i){this.children=void 0,this.attributes=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,Vr.call(this,t,i),this.children=a||[],this.setAttribute("href",e)}setAttribute(e,t){this.attributes[e]=t}hasClass(e){return this.classes.includes(e)}toNode(){return Xr.call(this,"a")}toMarkup(){return Yr.call(this,"a")}}class xa{constructor(e,t,a){this.src=void 0,this.alt=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,this.alt=t,this.src=e,this.classes=["mord"],this.height=0,this.depth=0,this.maxFontSize=0,this.style=a}hasClass(e){return this.classes.includes(e)}toNode(){var e=document.createElement("img");return e.src=this.src,e.alt=this.alt,e.className="mord",Object.assign(e.style,this.style),e}toMarkup(){var e=''+i0(this.alt)+'0&&(t=document.createElement("span"),t.style.marginRight=A(this.italic)),this.classes.length>0&&(t=t||document.createElement("span"),t.className=L0(this.classes)),Object.keys(this.style).length>0&&(t=t||document.createElement("span"),Object.assign(t.style,this.style)),t?(t.appendChild(e),t):e}toMarkup(){var e=!1,t="0&&(a+="margin-right:"+A(this.italic)+";"),a+=It(this.style),a&&(e=!0,t+=' style="'+i0(a)+'"');var i=i0(this.text);return e?(t+=">",t+=i,t+="",t):i}}class C0{constructor(e,t){this.children=void 0,this.attributes=void 0,this.children=e||[],this.attributes=t||{}}toNode(){var e="http://www.w3.org/2000/svg",t=document.createElementNS(e,"svg");for(var a of Object.keys(this.attributes))t.setAttribute(a,this.attributes[a]);for(var i=0;i':''}}class pt{constructor(e){this.attributes=void 0,this.attributes=e||{}}toNode(){var e="http://www.w3.org/2000/svg",t=document.createElementNS(e,"line");for(var a of Object.keys(this.attributes))t.setAttribute(a,this.attributes[a]);return t}toMarkup(){var e=" but got "+String(r)+".")}var za=r=>r instanceof ie||r instanceof Fe||r instanceof ae,k0={"AMS-Regular":{32:[0,0,0,0,.25],65:[0,.68889,0,0,.72222],66:[0,.68889,0,0,.66667],67:[0,.68889,0,0,.72222],68:[0,.68889,0,0,.72222],69:[0,.68889,0,0,.66667],70:[0,.68889,0,0,.61111],71:[0,.68889,0,0,.77778],72:[0,.68889,0,0,.77778],73:[0,.68889,0,0,.38889],74:[.16667,.68889,0,0,.5],75:[0,.68889,0,0,.77778],76:[0,.68889,0,0,.66667],77:[0,.68889,0,0,.94445],78:[0,.68889,0,0,.72222],79:[.16667,.68889,0,0,.77778],80:[0,.68889,0,0,.61111],81:[.16667,.68889,0,0,.77778],82:[0,.68889,0,0,.72222],83:[0,.68889,0,0,.55556],84:[0,.68889,0,0,.66667],85:[0,.68889,0,0,.72222],86:[0,.68889,0,0,.72222],87:[0,.68889,0,0,1],88:[0,.68889,0,0,.72222],89:[0,.68889,0,0,.72222],90:[0,.68889,0,0,.66667],107:[0,.68889,0,0,.55556],160:[0,0,0,0,.25],165:[0,.675,.025,0,.75],174:[.15559,.69224,0,0,.94666],240:[0,.68889,0,0,.55556],295:[0,.68889,0,0,.54028],710:[0,.825,0,0,2.33334],732:[0,.9,0,0,2.33334],770:[0,.825,0,0,2.33334],771:[0,.9,0,0,2.33334],989:[.08167,.58167,0,0,.77778],1008:[0,.43056,.04028,0,.66667],8245:[0,.54986,0,0,.275],8463:[0,.68889,0,0,.54028],8487:[0,.68889,0,0,.72222],8498:[0,.68889,0,0,.55556],8502:[0,.68889,0,0,.66667],8503:[0,.68889,0,0,.44445],8504:[0,.68889,0,0,.66667],8513:[0,.68889,0,0,.63889],8592:[-.03598,.46402,0,0,.5],8594:[-.03598,.46402,0,0,.5],8602:[-.13313,.36687,0,0,1],8603:[-.13313,.36687,0,0,1],8606:[.01354,.52239,0,0,1],8608:[.01354,.52239,0,0,1],8610:[.01354,.52239,0,0,1.11111],8611:[.01354,.52239,0,0,1.11111],8619:[0,.54986,0,0,1],8620:[0,.54986,0,0,1],8621:[-.13313,.37788,0,0,1.38889],8622:[-.13313,.36687,0,0,1],8624:[0,.69224,0,0,.5],8625:[0,.69224,0,0,.5],8630:[0,.43056,0,0,1],8631:[0,.43056,0,0,1],8634:[.08198,.58198,0,0,.77778],8635:[.08198,.58198,0,0,.77778],8638:[.19444,.69224,0,0,.41667],8639:[.19444,.69224,0,0,.41667],8642:[.19444,.69224,0,0,.41667],8643:[.19444,.69224,0,0,.41667],8644:[.1808,.675,0,0,1],8646:[.1808,.675,0,0,1],8647:[.1808,.675,0,0,1],8648:[.19444,.69224,0,0,.83334],8649:[.1808,.675,0,0,1],8650:[.19444,.69224,0,0,.83334],8651:[.01354,.52239,0,0,1],8652:[.01354,.52239,0,0,1],8653:[-.13313,.36687,0,0,1],8654:[-.13313,.36687,0,0,1],8655:[-.13313,.36687,0,0,1],8666:[.13667,.63667,0,0,1],8667:[.13667,.63667,0,0,1],8669:[-.13313,.37788,0,0,1],8672:[-.064,.437,0,0,1.334],8674:[-.064,.437,0,0,1.334],8705:[0,.825,0,0,.5],8708:[0,.68889,0,0,.55556],8709:[.08167,.58167,0,0,.77778],8717:[0,.43056,0,0,.42917],8722:[-.03598,.46402,0,0,.5],8724:[.08198,.69224,0,0,.77778],8726:[.08167,.58167,0,0,.77778],8733:[0,.69224,0,0,.77778],8736:[0,.69224,0,0,.72222],8737:[0,.69224,0,0,.72222],8738:[.03517,.52239,0,0,.72222],8739:[.08167,.58167,0,0,.22222],8740:[.25142,.74111,0,0,.27778],8741:[.08167,.58167,0,0,.38889],8742:[.25142,.74111,0,0,.5],8756:[0,.69224,0,0,.66667],8757:[0,.69224,0,0,.66667],8764:[-.13313,.36687,0,0,.77778],8765:[-.13313,.37788,0,0,.77778],8769:[-.13313,.36687,0,0,.77778],8770:[-.03625,.46375,0,0,.77778],8774:[.30274,.79383,0,0,.77778],8776:[-.01688,.48312,0,0,.77778],8778:[.08167,.58167,0,0,.77778],8782:[.06062,.54986,0,0,.77778],8783:[.06062,.54986,0,0,.77778],8785:[.08198,.58198,0,0,.77778],8786:[.08198,.58198,0,0,.77778],8787:[.08198,.58198,0,0,.77778],8790:[0,.69224,0,0,.77778],8791:[.22958,.72958,0,0,.77778],8796:[.08198,.91667,0,0,.77778],8806:[.25583,.75583,0,0,.77778],8807:[.25583,.75583,0,0,.77778],8808:[.25142,.75726,0,0,.77778],8809:[.25142,.75726,0,0,.77778],8812:[.25583,.75583,0,0,.5],8814:[.20576,.70576,0,0,.77778],8815:[.20576,.70576,0,0,.77778],8816:[.30274,.79383,0,0,.77778],8817:[.30274,.79383,0,0,.77778],8818:[.22958,.72958,0,0,.77778],8819:[.22958,.72958,0,0,.77778],8822:[.1808,.675,0,0,.77778],8823:[.1808,.675,0,0,.77778],8828:[.13667,.63667,0,0,.77778],8829:[.13667,.63667,0,0,.77778],8830:[.22958,.72958,0,0,.77778],8831:[.22958,.72958,0,0,.77778],8832:[.20576,.70576,0,0,.77778],8833:[.20576,.70576,0,0,.77778],8840:[.30274,.79383,0,0,.77778],8841:[.30274,.79383,0,0,.77778],8842:[.13597,.63597,0,0,.77778],8843:[.13597,.63597,0,0,.77778],8847:[.03517,.54986,0,0,.77778],8848:[.03517,.54986,0,0,.77778],8858:[.08198,.58198,0,0,.77778],8859:[.08198,.58198,0,0,.77778],8861:[.08198,.58198,0,0,.77778],8862:[0,.675,0,0,.77778],8863:[0,.675,0,0,.77778],8864:[0,.675,0,0,.77778],8865:[0,.675,0,0,.77778],8872:[0,.69224,0,0,.61111],8873:[0,.69224,0,0,.72222],8874:[0,.69224,0,0,.88889],8876:[0,.68889,0,0,.61111],8877:[0,.68889,0,0,.61111],8878:[0,.68889,0,0,.72222],8879:[0,.68889,0,0,.72222],8882:[.03517,.54986,0,0,.77778],8883:[.03517,.54986,0,0,.77778],8884:[.13667,.63667,0,0,.77778],8885:[.13667,.63667,0,0,.77778],8888:[0,.54986,0,0,1.11111],8890:[.19444,.43056,0,0,.55556],8891:[.19444,.69224,0,0,.61111],8892:[.19444,.69224,0,0,.61111],8901:[0,.54986,0,0,.27778],8903:[.08167,.58167,0,0,.77778],8905:[.08167,.58167,0,0,.77778],8906:[.08167,.58167,0,0,.77778],8907:[0,.69224,0,0,.77778],8908:[0,.69224,0,0,.77778],8909:[-.03598,.46402,0,0,.77778],8910:[0,.54986,0,0,.76042],8911:[0,.54986,0,0,.76042],8912:[.03517,.54986,0,0,.77778],8913:[.03517,.54986,0,0,.77778],8914:[0,.54986,0,0,.66667],8915:[0,.54986,0,0,.66667],8916:[0,.69224,0,0,.66667],8918:[.0391,.5391,0,0,.77778],8919:[.0391,.5391,0,0,.77778],8920:[.03517,.54986,0,0,1.33334],8921:[.03517,.54986,0,0,1.33334],8922:[.38569,.88569,0,0,.77778],8923:[.38569,.88569,0,0,.77778],8926:[.13667,.63667,0,0,.77778],8927:[.13667,.63667,0,0,.77778],8928:[.30274,.79383,0,0,.77778],8929:[.30274,.79383,0,0,.77778],8934:[.23222,.74111,0,0,.77778],8935:[.23222,.74111,0,0,.77778],8936:[.23222,.74111,0,0,.77778],8937:[.23222,.74111,0,0,.77778],8938:[.20576,.70576,0,0,.77778],8939:[.20576,.70576,0,0,.77778],8940:[.30274,.79383,0,0,.77778],8941:[.30274,.79383,0,0,.77778],8994:[.19444,.69224,0,0,.77778],8995:[.19444,.69224,0,0,.77778],9416:[.15559,.69224,0,0,.90222],9484:[0,.69224,0,0,.5],9488:[0,.69224,0,0,.5],9492:[0,.37788,0,0,.5],9496:[0,.37788,0,0,.5],9585:[.19444,.68889,0,0,.88889],9586:[.19444,.74111,0,0,.88889],9632:[0,.675,0,0,.77778],9633:[0,.675,0,0,.77778],9650:[0,.54986,0,0,.72222],9651:[0,.54986,0,0,.72222],9654:[.03517,.54986,0,0,.77778],9660:[0,.54986,0,0,.72222],9661:[0,.54986,0,0,.72222],9664:[.03517,.54986,0,0,.77778],9674:[.11111,.69224,0,0,.66667],9733:[.19444,.69224,0,0,.94445],10003:[0,.69224,0,0,.83334],10016:[0,.69224,0,0,.83334],10731:[.11111,.69224,0,0,.66667],10846:[.19444,.75583,0,0,.61111],10877:[.13667,.63667,0,0,.77778],10878:[.13667,.63667,0,0,.77778],10885:[.25583,.75583,0,0,.77778],10886:[.25583,.75583,0,0,.77778],10887:[.13597,.63597,0,0,.77778],10888:[.13597,.63597,0,0,.77778],10889:[.26167,.75726,0,0,.77778],10890:[.26167,.75726,0,0,.77778],10891:[.48256,.98256,0,0,.77778],10892:[.48256,.98256,0,0,.77778],10901:[.13667,.63667,0,0,.77778],10902:[.13667,.63667,0,0,.77778],10933:[.25142,.75726,0,0,.77778],10934:[.25142,.75726,0,0,.77778],10935:[.26167,.75726,0,0,.77778],10936:[.26167,.75726,0,0,.77778],10937:[.26167,.75726,0,0,.77778],10938:[.26167,.75726,0,0,.77778],10949:[.25583,.75583,0,0,.77778],10950:[.25583,.75583,0,0,.77778],10955:[.28481,.79383,0,0,.77778],10956:[.28481,.79383,0,0,.77778],57350:[.08167,.58167,0,0,.22222],57351:[.08167,.58167,0,0,.38889],57352:[.08167,.58167,0,0,.77778],57353:[0,.43056,.04028,0,.66667],57356:[.25142,.75726,0,0,.77778],57357:[.25142,.75726,0,0,.77778],57358:[.41951,.91951,0,0,.77778],57359:[.30274,.79383,0,0,.77778],57360:[.30274,.79383,0,0,.77778],57361:[.41951,.91951,0,0,.77778],57366:[.25142,.75726,0,0,.77778],57367:[.25142,.75726,0,0,.77778],57368:[.25142,.75726,0,0,.77778],57369:[.25142,.75726,0,0,.77778],57370:[.13597,.63597,0,0,.77778],57371:[.13597,.63597,0,0,.77778]},"Caligraphic-Regular":{32:[0,0,0,0,.25],65:[0,.68333,0,.19445,.79847],66:[0,.68333,.03041,.13889,.65681],67:[0,.68333,.05834,.13889,.52653],68:[0,.68333,.02778,.08334,.77139],69:[0,.68333,.08944,.11111,.52778],70:[0,.68333,.09931,.11111,.71875],71:[.09722,.68333,.0593,.11111,.59487],72:[0,.68333,.00965,.11111,.84452],73:[0,.68333,.07382,0,.54452],74:[.09722,.68333,.18472,.16667,.67778],75:[0,.68333,.01445,.05556,.76195],76:[0,.68333,0,.13889,.68972],77:[0,.68333,0,.13889,1.2009],78:[0,.68333,.14736,.08334,.82049],79:[0,.68333,.02778,.11111,.79611],80:[0,.68333,.08222,.08334,.69556],81:[.09722,.68333,0,.11111,.81667],82:[0,.68333,0,.08334,.8475],83:[0,.68333,.075,.13889,.60556],84:[0,.68333,.25417,0,.54464],85:[0,.68333,.09931,.08334,.62583],86:[0,.68333,.08222,0,.61278],87:[0,.68333,.08222,.08334,.98778],88:[0,.68333,.14643,.13889,.7133],89:[.09722,.68333,.08222,.08334,.66834],90:[0,.68333,.07944,.13889,.72473],160:[0,0,0,0,.25]},"Fraktur-Regular":{32:[0,0,0,0,.25],33:[0,.69141,0,0,.29574],34:[0,.69141,0,0,.21471],38:[0,.69141,0,0,.73786],39:[0,.69141,0,0,.21201],40:[.24982,.74947,0,0,.38865],41:[.24982,.74947,0,0,.38865],42:[0,.62119,0,0,.27764],43:[.08319,.58283,0,0,.75623],44:[0,.10803,0,0,.27764],45:[.08319,.58283,0,0,.75623],46:[0,.10803,0,0,.27764],47:[.24982,.74947,0,0,.50181],48:[0,.47534,0,0,.50181],49:[0,.47534,0,0,.50181],50:[0,.47534,0,0,.50181],51:[.18906,.47534,0,0,.50181],52:[.18906,.47534,0,0,.50181],53:[.18906,.47534,0,0,.50181],54:[0,.69141,0,0,.50181],55:[.18906,.47534,0,0,.50181],56:[0,.69141,0,0,.50181],57:[.18906,.47534,0,0,.50181],58:[0,.47534,0,0,.21606],59:[.12604,.47534,0,0,.21606],61:[-.13099,.36866,0,0,.75623],63:[0,.69141,0,0,.36245],65:[0,.69141,0,0,.7176],66:[0,.69141,0,0,.88397],67:[0,.69141,0,0,.61254],68:[0,.69141,0,0,.83158],69:[0,.69141,0,0,.66278],70:[.12604,.69141,0,0,.61119],71:[0,.69141,0,0,.78539],72:[.06302,.69141,0,0,.7203],73:[0,.69141,0,0,.55448],74:[.12604,.69141,0,0,.55231],75:[0,.69141,0,0,.66845],76:[0,.69141,0,0,.66602],77:[0,.69141,0,0,1.04953],78:[0,.69141,0,0,.83212],79:[0,.69141,0,0,.82699],80:[.18906,.69141,0,0,.82753],81:[.03781,.69141,0,0,.82699],82:[0,.69141,0,0,.82807],83:[0,.69141,0,0,.82861],84:[0,.69141,0,0,.66899],85:[0,.69141,0,0,.64576],86:[0,.69141,0,0,.83131],87:[0,.69141,0,0,1.04602],88:[0,.69141,0,0,.71922],89:[.18906,.69141,0,0,.83293],90:[.12604,.69141,0,0,.60201],91:[.24982,.74947,0,0,.27764],93:[.24982,.74947,0,0,.27764],94:[0,.69141,0,0,.49965],97:[0,.47534,0,0,.50046],98:[0,.69141,0,0,.51315],99:[0,.47534,0,0,.38946],100:[0,.62119,0,0,.49857],101:[0,.47534,0,0,.40053],102:[.18906,.69141,0,0,.32626],103:[.18906,.47534,0,0,.5037],104:[.18906,.69141,0,0,.52126],105:[0,.69141,0,0,.27899],106:[0,.69141,0,0,.28088],107:[0,.69141,0,0,.38946],108:[0,.69141,0,0,.27953],109:[0,.47534,0,0,.76676],110:[0,.47534,0,0,.52666],111:[0,.47534,0,0,.48885],112:[.18906,.52396,0,0,.50046],113:[.18906,.47534,0,0,.48912],114:[0,.47534,0,0,.38919],115:[0,.47534,0,0,.44266],116:[0,.62119,0,0,.33301],117:[0,.47534,0,0,.5172],118:[0,.52396,0,0,.5118],119:[0,.52396,0,0,.77351],120:[.18906,.47534,0,0,.38865],121:[.18906,.47534,0,0,.49884],122:[.18906,.47534,0,0,.39054],160:[0,0,0,0,.25],8216:[0,.69141,0,0,.21471],8217:[0,.69141,0,0,.21471],58112:[0,.62119,0,0,.49749],58113:[0,.62119,0,0,.4983],58114:[.18906,.69141,0,0,.33328],58115:[.18906,.69141,0,0,.32923],58116:[.18906,.47534,0,0,.50343],58117:[0,.69141,0,0,.33301],58118:[0,.62119,0,0,.33409],58119:[0,.47534,0,0,.50073]},"Main-Bold":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.35],34:[0,.69444,0,0,.60278],35:[.19444,.69444,0,0,.95833],36:[.05556,.75,0,0,.575],37:[.05556,.75,0,0,.95833],38:[0,.69444,0,0,.89444],39:[0,.69444,0,0,.31944],40:[.25,.75,0,0,.44722],41:[.25,.75,0,0,.44722],42:[0,.75,0,0,.575],43:[.13333,.63333,0,0,.89444],44:[.19444,.15556,0,0,.31944],45:[0,.44444,0,0,.38333],46:[0,.15556,0,0,.31944],47:[.25,.75,0,0,.575],48:[0,.64444,0,0,.575],49:[0,.64444,0,0,.575],50:[0,.64444,0,0,.575],51:[0,.64444,0,0,.575],52:[0,.64444,0,0,.575],53:[0,.64444,0,0,.575],54:[0,.64444,0,0,.575],55:[0,.64444,0,0,.575],56:[0,.64444,0,0,.575],57:[0,.64444,0,0,.575],58:[0,.44444,0,0,.31944],59:[.19444,.44444,0,0,.31944],60:[.08556,.58556,0,0,.89444],61:[-.10889,.39111,0,0,.89444],62:[.08556,.58556,0,0,.89444],63:[0,.69444,0,0,.54305],64:[0,.69444,0,0,.89444],65:[0,.68611,0,0,.86944],66:[0,.68611,0,0,.81805],67:[0,.68611,0,0,.83055],68:[0,.68611,0,0,.88194],69:[0,.68611,0,0,.75555],70:[0,.68611,0,0,.72361],71:[0,.68611,0,0,.90416],72:[0,.68611,0,0,.9],73:[0,.68611,0,0,.43611],74:[0,.68611,0,0,.59444],75:[0,.68611,0,0,.90138],76:[0,.68611,0,0,.69166],77:[0,.68611,0,0,1.09166],78:[0,.68611,0,0,.9],79:[0,.68611,0,0,.86388],80:[0,.68611,0,0,.78611],81:[.19444,.68611,0,0,.86388],82:[0,.68611,0,0,.8625],83:[0,.68611,0,0,.63889],84:[0,.68611,0,0,.8],85:[0,.68611,0,0,.88472],86:[0,.68611,.01597,0,.86944],87:[0,.68611,.01597,0,1.18888],88:[0,.68611,0,0,.86944],89:[0,.68611,.02875,0,.86944],90:[0,.68611,0,0,.70277],91:[.25,.75,0,0,.31944],92:[.25,.75,0,0,.575],93:[.25,.75,0,0,.31944],94:[0,.69444,0,0,.575],95:[.31,.13444,.03194,0,.575],97:[0,.44444,0,0,.55902],98:[0,.69444,0,0,.63889],99:[0,.44444,0,0,.51111],100:[0,.69444,0,0,.63889],101:[0,.44444,0,0,.52708],102:[0,.69444,.10903,0,.35139],103:[.19444,.44444,.01597,0,.575],104:[0,.69444,0,0,.63889],105:[0,.69444,0,0,.31944],106:[.19444,.69444,0,0,.35139],107:[0,.69444,0,0,.60694],108:[0,.69444,0,0,.31944],109:[0,.44444,0,0,.95833],110:[0,.44444,0,0,.63889],111:[0,.44444,0,0,.575],112:[.19444,.44444,0,0,.63889],113:[.19444,.44444,0,0,.60694],114:[0,.44444,0,0,.47361],115:[0,.44444,0,0,.45361],116:[0,.63492,0,0,.44722],117:[0,.44444,0,0,.63889],118:[0,.44444,.01597,0,.60694],119:[0,.44444,.01597,0,.83055],120:[0,.44444,0,0,.60694],121:[.19444,.44444,.01597,0,.60694],122:[0,.44444,0,0,.51111],123:[.25,.75,0,0,.575],124:[.25,.75,0,0,.31944],125:[.25,.75,0,0,.575],126:[.35,.34444,0,0,.575],160:[0,0,0,0,.25],163:[0,.69444,0,0,.86853],168:[0,.69444,0,0,.575],172:[0,.44444,0,0,.76666],176:[0,.69444,0,0,.86944],177:[.13333,.63333,0,0,.89444],184:[.17014,0,0,0,.51111],198:[0,.68611,0,0,1.04166],215:[.13333,.63333,0,0,.89444],216:[.04861,.73472,0,0,.89444],223:[0,.69444,0,0,.59722],230:[0,.44444,0,0,.83055],247:[.13333,.63333,0,0,.89444],248:[.09722,.54167,0,0,.575],305:[0,.44444,0,0,.31944],338:[0,.68611,0,0,1.16944],339:[0,.44444,0,0,.89444],567:[.19444,.44444,0,0,.35139],710:[0,.69444,0,0,.575],711:[0,.63194,0,0,.575],713:[0,.59611,0,0,.575],714:[0,.69444,0,0,.575],715:[0,.69444,0,0,.575],728:[0,.69444,0,0,.575],729:[0,.69444,0,0,.31944],730:[0,.69444,0,0,.86944],732:[0,.69444,0,0,.575],733:[0,.69444,0,0,.575],915:[0,.68611,0,0,.69166],916:[0,.68611,0,0,.95833],920:[0,.68611,0,0,.89444],923:[0,.68611,0,0,.80555],926:[0,.68611,0,0,.76666],928:[0,.68611,0,0,.9],931:[0,.68611,0,0,.83055],933:[0,.68611,0,0,.89444],934:[0,.68611,0,0,.83055],936:[0,.68611,0,0,.89444],937:[0,.68611,0,0,.83055],8211:[0,.44444,.03194,0,.575],8212:[0,.44444,.03194,0,1.14999],8216:[0,.69444,0,0,.31944],8217:[0,.69444,0,0,.31944],8220:[0,.69444,0,0,.60278],8221:[0,.69444,0,0,.60278],8224:[.19444,.69444,0,0,.51111],8225:[.19444,.69444,0,0,.51111],8242:[0,.55556,0,0,.34444],8407:[0,.72444,.15486,0,.575],8463:[0,.69444,0,0,.66759],8465:[0,.69444,0,0,.83055],8467:[0,.69444,0,0,.47361],8472:[.19444,.44444,0,0,.74027],8476:[0,.69444,0,0,.83055],8501:[0,.69444,0,0,.70277],8592:[-.10889,.39111,0,0,1.14999],8593:[.19444,.69444,0,0,.575],8594:[-.10889,.39111,0,0,1.14999],8595:[.19444,.69444,0,0,.575],8596:[-.10889,.39111,0,0,1.14999],8597:[.25,.75,0,0,.575],8598:[.19444,.69444,0,0,1.14999],8599:[.19444,.69444,0,0,1.14999],8600:[.19444,.69444,0,0,1.14999],8601:[.19444,.69444,0,0,1.14999],8636:[-.10889,.39111,0,0,1.14999],8637:[-.10889,.39111,0,0,1.14999],8640:[-.10889,.39111,0,0,1.14999],8641:[-.10889,.39111,0,0,1.14999],8656:[-.10889,.39111,0,0,1.14999],8657:[.19444,.69444,0,0,.70277],8658:[-.10889,.39111,0,0,1.14999],8659:[.19444,.69444,0,0,.70277],8660:[-.10889,.39111,0,0,1.14999],8661:[.25,.75,0,0,.70277],8704:[0,.69444,0,0,.63889],8706:[0,.69444,.06389,0,.62847],8707:[0,.69444,0,0,.63889],8709:[.05556,.75,0,0,.575],8711:[0,.68611,0,0,.95833],8712:[.08556,.58556,0,0,.76666],8715:[.08556,.58556,0,0,.76666],8722:[.13333,.63333,0,0,.89444],8723:[.13333,.63333,0,0,.89444],8725:[.25,.75,0,0,.575],8726:[.25,.75,0,0,.575],8727:[-.02778,.47222,0,0,.575],8728:[-.02639,.47361,0,0,.575],8729:[-.02639,.47361,0,0,.575],8730:[.18,.82,0,0,.95833],8733:[0,.44444,0,0,.89444],8734:[0,.44444,0,0,1.14999],8736:[0,.69224,0,0,.72222],8739:[.25,.75,0,0,.31944],8741:[.25,.75,0,0,.575],8743:[0,.55556,0,0,.76666],8744:[0,.55556,0,0,.76666],8745:[0,.55556,0,0,.76666],8746:[0,.55556,0,0,.76666],8747:[.19444,.69444,.12778,0,.56875],8764:[-.10889,.39111,0,0,.89444],8768:[.19444,.69444,0,0,.31944],8771:[.00222,.50222,0,0,.89444],8773:[.027,.638,0,0,.894],8776:[.02444,.52444,0,0,.89444],8781:[.00222,.50222,0,0,.89444],8801:[.00222,.50222,0,0,.89444],8804:[.19667,.69667,0,0,.89444],8805:[.19667,.69667,0,0,.89444],8810:[.08556,.58556,0,0,1.14999],8811:[.08556,.58556,0,0,1.14999],8826:[.08556,.58556,0,0,.89444],8827:[.08556,.58556,0,0,.89444],8834:[.08556,.58556,0,0,.89444],8835:[.08556,.58556,0,0,.89444],8838:[.19667,.69667,0,0,.89444],8839:[.19667,.69667,0,0,.89444],8846:[0,.55556,0,0,.76666],8849:[.19667,.69667,0,0,.89444],8850:[.19667,.69667,0,0,.89444],8851:[0,.55556,0,0,.76666],8852:[0,.55556,0,0,.76666],8853:[.13333,.63333,0,0,.89444],8854:[.13333,.63333,0,0,.89444],8855:[.13333,.63333,0,0,.89444],8856:[.13333,.63333,0,0,.89444],8857:[.13333,.63333,0,0,.89444],8866:[0,.69444,0,0,.70277],8867:[0,.69444,0,0,.70277],8868:[0,.69444,0,0,.89444],8869:[0,.69444,0,0,.89444],8900:[-.02639,.47361,0,0,.575],8901:[-.02639,.47361,0,0,.31944],8902:[-.02778,.47222,0,0,.575],8968:[.25,.75,0,0,.51111],8969:[.25,.75,0,0,.51111],8970:[.25,.75,0,0,.51111],8971:[.25,.75,0,0,.51111],8994:[-.13889,.36111,0,0,1.14999],8995:[-.13889,.36111,0,0,1.14999],9651:[.19444,.69444,0,0,1.02222],9657:[-.02778,.47222,0,0,.575],9661:[.19444,.69444,0,0,1.02222],9667:[-.02778,.47222,0,0,.575],9711:[.19444,.69444,0,0,1.14999],9824:[.12963,.69444,0,0,.89444],9825:[.12963,.69444,0,0,.89444],9826:[.12963,.69444,0,0,.89444],9827:[.12963,.69444,0,0,.89444],9837:[0,.75,0,0,.44722],9838:[.19444,.69444,0,0,.44722],9839:[.19444,.69444,0,0,.44722],10216:[.25,.75,0,0,.44722],10217:[.25,.75,0,0,.44722],10815:[0,.68611,0,0,.9],10927:[.19667,.69667,0,0,.89444],10928:[.19667,.69667,0,0,.89444],57376:[.19444,.69444,0,0,0]},"Main-BoldItalic":{32:[0,0,0,0,.25],33:[0,.69444,.11417,0,.38611],34:[0,.69444,.07939,0,.62055],35:[.19444,.69444,.06833,0,.94444],37:[.05556,.75,.12861,0,.94444],38:[0,.69444,.08528,0,.88555],39:[0,.69444,.12945,0,.35555],40:[.25,.75,.15806,0,.47333],41:[.25,.75,.03306,0,.47333],42:[0,.75,.14333,0,.59111],43:[.10333,.60333,.03306,0,.88555],44:[.19444,.14722,0,0,.35555],45:[0,.44444,.02611,0,.41444],46:[0,.14722,0,0,.35555],47:[.25,.75,.15806,0,.59111],48:[0,.64444,.13167,0,.59111],49:[0,.64444,.13167,0,.59111],50:[0,.64444,.13167,0,.59111],51:[0,.64444,.13167,0,.59111],52:[.19444,.64444,.13167,0,.59111],53:[0,.64444,.13167,0,.59111],54:[0,.64444,.13167,0,.59111],55:[.19444,.64444,.13167,0,.59111],56:[0,.64444,.13167,0,.59111],57:[0,.64444,.13167,0,.59111],58:[0,.44444,.06695,0,.35555],59:[.19444,.44444,.06695,0,.35555],61:[-.10889,.39111,.06833,0,.88555],63:[0,.69444,.11472,0,.59111],64:[0,.69444,.09208,0,.88555],65:[0,.68611,0,0,.86555],66:[0,.68611,.0992,0,.81666],67:[0,.68611,.14208,0,.82666],68:[0,.68611,.09062,0,.87555],69:[0,.68611,.11431,0,.75666],70:[0,.68611,.12903,0,.72722],71:[0,.68611,.07347,0,.89527],72:[0,.68611,.17208,0,.8961],73:[0,.68611,.15681,0,.47166],74:[0,.68611,.145,0,.61055],75:[0,.68611,.14208,0,.89499],76:[0,.68611,0,0,.69777],77:[0,.68611,.17208,0,1.07277],78:[0,.68611,.17208,0,.8961],79:[0,.68611,.09062,0,.85499],80:[0,.68611,.0992,0,.78721],81:[.19444,.68611,.09062,0,.85499],82:[0,.68611,.02559,0,.85944],83:[0,.68611,.11264,0,.64999],84:[0,.68611,.12903,0,.7961],85:[0,.68611,.17208,0,.88083],86:[0,.68611,.18625,0,.86555],87:[0,.68611,.18625,0,1.15999],88:[0,.68611,.15681,0,.86555],89:[0,.68611,.19803,0,.86555],90:[0,.68611,.14208,0,.70888],91:[.25,.75,.1875,0,.35611],93:[.25,.75,.09972,0,.35611],94:[0,.69444,.06709,0,.59111],95:[.31,.13444,.09811,0,.59111],97:[0,.44444,.09426,0,.59111],98:[0,.69444,.07861,0,.53222],99:[0,.44444,.05222,0,.53222],100:[0,.69444,.10861,0,.59111],101:[0,.44444,.085,0,.53222],102:[.19444,.69444,.21778,0,.4],103:[.19444,.44444,.105,0,.53222],104:[0,.69444,.09426,0,.59111],105:[0,.69326,.11387,0,.35555],106:[.19444,.69326,.1672,0,.35555],107:[0,.69444,.11111,0,.53222],108:[0,.69444,.10861,0,.29666],109:[0,.44444,.09426,0,.94444],110:[0,.44444,.09426,0,.64999],111:[0,.44444,.07861,0,.59111],112:[.19444,.44444,.07861,0,.59111],113:[.19444,.44444,.105,0,.53222],114:[0,.44444,.11111,0,.50167],115:[0,.44444,.08167,0,.48694],116:[0,.63492,.09639,0,.385],117:[0,.44444,.09426,0,.62055],118:[0,.44444,.11111,0,.53222],119:[0,.44444,.11111,0,.76777],120:[0,.44444,.12583,0,.56055],121:[.19444,.44444,.105,0,.56166],122:[0,.44444,.13889,0,.49055],126:[.35,.34444,.11472,0,.59111],160:[0,0,0,0,.25],168:[0,.69444,.11473,0,.59111],176:[0,.69444,0,0,.94888],184:[.17014,0,0,0,.53222],198:[0,.68611,.11431,0,1.02277],216:[.04861,.73472,.09062,0,.88555],223:[.19444,.69444,.09736,0,.665],230:[0,.44444,.085,0,.82666],248:[.09722,.54167,.09458,0,.59111],305:[0,.44444,.09426,0,.35555],338:[0,.68611,.11431,0,1.14054],339:[0,.44444,.085,0,.82666],567:[.19444,.44444,.04611,0,.385],710:[0,.69444,.06709,0,.59111],711:[0,.63194,.08271,0,.59111],713:[0,.59444,.10444,0,.59111],714:[0,.69444,.08528,0,.59111],715:[0,.69444,0,0,.59111],728:[0,.69444,.10333,0,.59111],729:[0,.69444,.12945,0,.35555],730:[0,.69444,0,0,.94888],732:[0,.69444,.11472,0,.59111],733:[0,.69444,.11472,0,.59111],915:[0,.68611,.12903,0,.69777],916:[0,.68611,0,0,.94444],920:[0,.68611,.09062,0,.88555],923:[0,.68611,0,0,.80666],926:[0,.68611,.15092,0,.76777],928:[0,.68611,.17208,0,.8961],931:[0,.68611,.11431,0,.82666],933:[0,.68611,.10778,0,.88555],934:[0,.68611,.05632,0,.82666],936:[0,.68611,.10778,0,.88555],937:[0,.68611,.0992,0,.82666],8211:[0,.44444,.09811,0,.59111],8212:[0,.44444,.09811,0,1.18221],8216:[0,.69444,.12945,0,.35555],8217:[0,.69444,.12945,0,.35555],8220:[0,.69444,.16772,0,.62055],8221:[0,.69444,.07939,0,.62055]},"Main-Italic":{32:[0,0,0,0,.25],33:[0,.69444,.12417,0,.30667],34:[0,.69444,.06961,0,.51444],35:[.19444,.69444,.06616,0,.81777],37:[.05556,.75,.13639,0,.81777],38:[0,.69444,.09694,0,.76666],39:[0,.69444,.12417,0,.30667],40:[.25,.75,.16194,0,.40889],41:[.25,.75,.03694,0,.40889],42:[0,.75,.14917,0,.51111],43:[.05667,.56167,.03694,0,.76666],44:[.19444,.10556,0,0,.30667],45:[0,.43056,.02826,0,.35778],46:[0,.10556,0,0,.30667],47:[.25,.75,.16194,0,.51111],48:[0,.64444,.13556,0,.51111],49:[0,.64444,.13556,0,.51111],50:[0,.64444,.13556,0,.51111],51:[0,.64444,.13556,0,.51111],52:[.19444,.64444,.13556,0,.51111],53:[0,.64444,.13556,0,.51111],54:[0,.64444,.13556,0,.51111],55:[.19444,.64444,.13556,0,.51111],56:[0,.64444,.13556,0,.51111],57:[0,.64444,.13556,0,.51111],58:[0,.43056,.0582,0,.30667],59:[.19444,.43056,.0582,0,.30667],61:[-.13313,.36687,.06616,0,.76666],63:[0,.69444,.1225,0,.51111],64:[0,.69444,.09597,0,.76666],65:[0,.68333,0,0,.74333],66:[0,.68333,.10257,0,.70389],67:[0,.68333,.14528,0,.71555],68:[0,.68333,.09403,0,.755],69:[0,.68333,.12028,0,.67833],70:[0,.68333,.13305,0,.65277],71:[0,.68333,.08722,0,.77361],72:[0,.68333,.16389,0,.74333],73:[0,.68333,.15806,0,.38555],74:[0,.68333,.14028,0,.525],75:[0,.68333,.14528,0,.76888],76:[0,.68333,0,0,.62722],77:[0,.68333,.16389,0,.89666],78:[0,.68333,.16389,0,.74333],79:[0,.68333,.09403,0,.76666],80:[0,.68333,.10257,0,.67833],81:[.19444,.68333,.09403,0,.76666],82:[0,.68333,.03868,0,.72944],83:[0,.68333,.11972,0,.56222],84:[0,.68333,.13305,0,.71555],85:[0,.68333,.16389,0,.74333],86:[0,.68333,.18361,0,.74333],87:[0,.68333,.18361,0,.99888],88:[0,.68333,.15806,0,.74333],89:[0,.68333,.19383,0,.74333],90:[0,.68333,.14528,0,.61333],91:[.25,.75,.1875,0,.30667],93:[.25,.75,.10528,0,.30667],94:[0,.69444,.06646,0,.51111],95:[.31,.12056,.09208,0,.51111],97:[0,.43056,.07671,0,.51111],98:[0,.69444,.06312,0,.46],99:[0,.43056,.05653,0,.46],100:[0,.69444,.10333,0,.51111],101:[0,.43056,.07514,0,.46],102:[.19444,.69444,.21194,0,.30667],103:[.19444,.43056,.08847,0,.46],104:[0,.69444,.07671,0,.51111],105:[0,.65536,.1019,0,.30667],106:[.19444,.65536,.14467,0,.30667],107:[0,.69444,.10764,0,.46],108:[0,.69444,.10333,0,.25555],109:[0,.43056,.07671,0,.81777],110:[0,.43056,.07671,0,.56222],111:[0,.43056,.06312,0,.51111],112:[.19444,.43056,.06312,0,.51111],113:[.19444,.43056,.08847,0,.46],114:[0,.43056,.10764,0,.42166],115:[0,.43056,.08208,0,.40889],116:[0,.61508,.09486,0,.33222],117:[0,.43056,.07671,0,.53666],118:[0,.43056,.10764,0,.46],119:[0,.43056,.10764,0,.66444],120:[0,.43056,.12042,0,.46389],121:[.19444,.43056,.08847,0,.48555],122:[0,.43056,.12292,0,.40889],126:[.35,.31786,.11585,0,.51111],160:[0,0,0,0,.25],168:[0,.66786,.10474,0,.51111],176:[0,.69444,0,0,.83129],184:[.17014,0,0,0,.46],198:[0,.68333,.12028,0,.88277],216:[.04861,.73194,.09403,0,.76666],223:[.19444,.69444,.10514,0,.53666],230:[0,.43056,.07514,0,.71555],248:[.09722,.52778,.09194,0,.51111],338:[0,.68333,.12028,0,.98499],339:[0,.43056,.07514,0,.71555],710:[0,.69444,.06646,0,.51111],711:[0,.62847,.08295,0,.51111],713:[0,.56167,.10333,0,.51111],714:[0,.69444,.09694,0,.51111],715:[0,.69444,0,0,.51111],728:[0,.69444,.10806,0,.51111],729:[0,.66786,.11752,0,.30667],730:[0,.69444,0,0,.83129],732:[0,.66786,.11585,0,.51111],733:[0,.69444,.1225,0,.51111],915:[0,.68333,.13305,0,.62722],916:[0,.68333,0,0,.81777],920:[0,.68333,.09403,0,.76666],923:[0,.68333,0,0,.69222],926:[0,.68333,.15294,0,.66444],928:[0,.68333,.16389,0,.74333],931:[0,.68333,.12028,0,.71555],933:[0,.68333,.11111,0,.76666],934:[0,.68333,.05986,0,.71555],936:[0,.68333,.11111,0,.76666],937:[0,.68333,.10257,0,.71555],8211:[0,.43056,.09208,0,.51111],8212:[0,.43056,.09208,0,1.02222],8216:[0,.69444,.12417,0,.30667],8217:[0,.69444,.12417,0,.30667],8220:[0,.69444,.1685,0,.51444],8221:[0,.69444,.06961,0,.51444],8463:[0,.68889,0,0,.54028]},"Main-Regular":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.27778],34:[0,.69444,0,0,.5],35:[.19444,.69444,0,0,.83334],36:[.05556,.75,0,0,.5],37:[.05556,.75,0,0,.83334],38:[0,.69444,0,0,.77778],39:[0,.69444,0,0,.27778],40:[.25,.75,0,0,.38889],41:[.25,.75,0,0,.38889],42:[0,.75,0,0,.5],43:[.08333,.58333,0,0,.77778],44:[.19444,.10556,0,0,.27778],45:[0,.43056,0,0,.33333],46:[0,.10556,0,0,.27778],47:[.25,.75,0,0,.5],48:[0,.64444,0,0,.5],49:[0,.64444,0,0,.5],50:[0,.64444,0,0,.5],51:[0,.64444,0,0,.5],52:[0,.64444,0,0,.5],53:[0,.64444,0,0,.5],54:[0,.64444,0,0,.5],55:[0,.64444,0,0,.5],56:[0,.64444,0,0,.5],57:[0,.64444,0,0,.5],58:[0,.43056,0,0,.27778],59:[.19444,.43056,0,0,.27778],60:[.0391,.5391,0,0,.77778],61:[-.13313,.36687,0,0,.77778],62:[.0391,.5391,0,0,.77778],63:[0,.69444,0,0,.47222],64:[0,.69444,0,0,.77778],65:[0,.68333,0,0,.75],66:[0,.68333,0,0,.70834],67:[0,.68333,0,0,.72222],68:[0,.68333,0,0,.76389],69:[0,.68333,0,0,.68056],70:[0,.68333,0,0,.65278],71:[0,.68333,0,0,.78472],72:[0,.68333,0,0,.75],73:[0,.68333,0,0,.36111],74:[0,.68333,0,0,.51389],75:[0,.68333,0,0,.77778],76:[0,.68333,0,0,.625],77:[0,.68333,0,0,.91667],78:[0,.68333,0,0,.75],79:[0,.68333,0,0,.77778],80:[0,.68333,0,0,.68056],81:[.19444,.68333,0,0,.77778],82:[0,.68333,0,0,.73611],83:[0,.68333,0,0,.55556],84:[0,.68333,0,0,.72222],85:[0,.68333,0,0,.75],86:[0,.68333,.01389,0,.75],87:[0,.68333,.01389,0,1.02778],88:[0,.68333,0,0,.75],89:[0,.68333,.025,0,.75],90:[0,.68333,0,0,.61111],91:[.25,.75,0,0,.27778],92:[.25,.75,0,0,.5],93:[.25,.75,0,0,.27778],94:[0,.69444,0,0,.5],95:[.31,.12056,.02778,0,.5],97:[0,.43056,0,0,.5],98:[0,.69444,0,0,.55556],99:[0,.43056,0,0,.44445],100:[0,.69444,0,0,.55556],101:[0,.43056,0,0,.44445],102:[0,.69444,.07778,0,.30556],103:[.19444,.43056,.01389,0,.5],104:[0,.69444,0,0,.55556],105:[0,.66786,0,0,.27778],106:[.19444,.66786,0,0,.30556],107:[0,.69444,0,0,.52778],108:[0,.69444,0,0,.27778],109:[0,.43056,0,0,.83334],110:[0,.43056,0,0,.55556],111:[0,.43056,0,0,.5],112:[.19444,.43056,0,0,.55556],113:[.19444,.43056,0,0,.52778],114:[0,.43056,0,0,.39167],115:[0,.43056,0,0,.39445],116:[0,.61508,0,0,.38889],117:[0,.43056,0,0,.55556],118:[0,.43056,.01389,0,.52778],119:[0,.43056,.01389,0,.72222],120:[0,.43056,0,0,.52778],121:[.19444,.43056,.01389,0,.52778],122:[0,.43056,0,0,.44445],123:[.25,.75,0,0,.5],124:[.25,.75,0,0,.27778],125:[.25,.75,0,0,.5],126:[.35,.31786,0,0,.5],160:[0,0,0,0,.25],163:[0,.69444,0,0,.76909],167:[.19444,.69444,0,0,.44445],168:[0,.66786,0,0,.5],172:[0,.43056,0,0,.66667],176:[0,.69444,0,0,.75],177:[.08333,.58333,0,0,.77778],182:[.19444,.69444,0,0,.61111],184:[.17014,0,0,0,.44445],198:[0,.68333,0,0,.90278],215:[.08333,.58333,0,0,.77778],216:[.04861,.73194,0,0,.77778],223:[0,.69444,0,0,.5],230:[0,.43056,0,0,.72222],247:[.08333,.58333,0,0,.77778],248:[.09722,.52778,0,0,.5],305:[0,.43056,0,0,.27778],338:[0,.68333,0,0,1.01389],339:[0,.43056,0,0,.77778],567:[.19444,.43056,0,0,.30556],710:[0,.69444,0,0,.5],711:[0,.62847,0,0,.5],713:[0,.56778,0,0,.5],714:[0,.69444,0,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,0,0,.5],729:[0,.66786,0,0,.27778],730:[0,.69444,0,0,.75],732:[0,.66786,0,0,.5],733:[0,.69444,0,0,.5],915:[0,.68333,0,0,.625],916:[0,.68333,0,0,.83334],920:[0,.68333,0,0,.77778],923:[0,.68333,0,0,.69445],926:[0,.68333,0,0,.66667],928:[0,.68333,0,0,.75],931:[0,.68333,0,0,.72222],933:[0,.68333,0,0,.77778],934:[0,.68333,0,0,.72222],936:[0,.68333,0,0,.77778],937:[0,.68333,0,0,.72222],8211:[0,.43056,.02778,0,.5],8212:[0,.43056,.02778,0,1],8216:[0,.69444,0,0,.27778],8217:[0,.69444,0,0,.27778],8220:[0,.69444,0,0,.5],8221:[0,.69444,0,0,.5],8224:[.19444,.69444,0,0,.44445],8225:[.19444,.69444,0,0,.44445],8230:[0,.123,0,0,1.172],8242:[0,.55556,0,0,.275],8407:[0,.71444,.15382,0,.5],8463:[0,.68889,0,0,.54028],8465:[0,.69444,0,0,.72222],8467:[0,.69444,0,.11111,.41667],8472:[.19444,.43056,0,.11111,.63646],8476:[0,.69444,0,0,.72222],8501:[0,.69444,0,0,.61111],8592:[-.13313,.36687,0,0,1],8593:[.19444,.69444,0,0,.5],8594:[-.13313,.36687,0,0,1],8595:[.19444,.69444,0,0,.5],8596:[-.13313,.36687,0,0,1],8597:[.25,.75,0,0,.5],8598:[.19444,.69444,0,0,1],8599:[.19444,.69444,0,0,1],8600:[.19444,.69444,0,0,1],8601:[.19444,.69444,0,0,1],8614:[.011,.511,0,0,1],8617:[.011,.511,0,0,1.126],8618:[.011,.511,0,0,1.126],8636:[-.13313,.36687,0,0,1],8637:[-.13313,.36687,0,0,1],8640:[-.13313,.36687,0,0,1],8641:[-.13313,.36687,0,0,1],8652:[.011,.671,0,0,1],8656:[-.13313,.36687,0,0,1],8657:[.19444,.69444,0,0,.61111],8658:[-.13313,.36687,0,0,1],8659:[.19444,.69444,0,0,.61111],8660:[-.13313,.36687,0,0,1],8661:[.25,.75,0,0,.61111],8704:[0,.69444,0,0,.55556],8706:[0,.69444,.05556,.08334,.5309],8707:[0,.69444,0,0,.55556],8709:[.05556,.75,0,0,.5],8711:[0,.68333,0,0,.83334],8712:[.0391,.5391,0,0,.66667],8715:[.0391,.5391,0,0,.66667],8722:[.08333,.58333,0,0,.77778],8723:[.08333,.58333,0,0,.77778],8725:[.25,.75,0,0,.5],8726:[.25,.75,0,0,.5],8727:[-.03472,.46528,0,0,.5],8728:[-.05555,.44445,0,0,.5],8729:[-.05555,.44445,0,0,.5],8730:[.2,.8,0,0,.83334],8733:[0,.43056,0,0,.77778],8734:[0,.43056,0,0,1],8736:[0,.69224,0,0,.72222],8739:[.25,.75,0,0,.27778],8741:[.25,.75,0,0,.5],8743:[0,.55556,0,0,.66667],8744:[0,.55556,0,0,.66667],8745:[0,.55556,0,0,.66667],8746:[0,.55556,0,0,.66667],8747:[.19444,.69444,.11111,0,.41667],8764:[-.13313,.36687,0,0,.77778],8768:[.19444,.69444,0,0,.27778],8771:[-.03625,.46375,0,0,.77778],8773:[-.022,.589,0,0,.778],8776:[-.01688,.48312,0,0,.77778],8781:[-.03625,.46375,0,0,.77778],8784:[-.133,.673,0,0,.778],8801:[-.03625,.46375,0,0,.77778],8804:[.13597,.63597,0,0,.77778],8805:[.13597,.63597,0,0,.77778],8810:[.0391,.5391,0,0,1],8811:[.0391,.5391,0,0,1],8826:[.0391,.5391,0,0,.77778],8827:[.0391,.5391,0,0,.77778],8834:[.0391,.5391,0,0,.77778],8835:[.0391,.5391,0,0,.77778],8838:[.13597,.63597,0,0,.77778],8839:[.13597,.63597,0,0,.77778],8846:[0,.55556,0,0,.66667],8849:[.13597,.63597,0,0,.77778],8850:[.13597,.63597,0,0,.77778],8851:[0,.55556,0,0,.66667],8852:[0,.55556,0,0,.66667],8853:[.08333,.58333,0,0,.77778],8854:[.08333,.58333,0,0,.77778],8855:[.08333,.58333,0,0,.77778],8856:[.08333,.58333,0,0,.77778],8857:[.08333,.58333,0,0,.77778],8866:[0,.69444,0,0,.61111],8867:[0,.69444,0,0,.61111],8868:[0,.69444,0,0,.77778],8869:[0,.69444,0,0,.77778],8872:[.249,.75,0,0,.867],8900:[-.05555,.44445,0,0,.5],8901:[-.05555,.44445,0,0,.27778],8902:[-.03472,.46528,0,0,.5],8904:[.005,.505,0,0,.9],8942:[.03,.903,0,0,.278],8943:[-.19,.313,0,0,1.172],8945:[-.1,.823,0,0,1.282],8968:[.25,.75,0,0,.44445],8969:[.25,.75,0,0,.44445],8970:[.25,.75,0,0,.44445],8971:[.25,.75,0,0,.44445],8994:[-.14236,.35764,0,0,1],8995:[-.14236,.35764,0,0,1],9136:[.244,.744,0,0,.412],9137:[.244,.745,0,0,.412],9651:[.19444,.69444,0,0,.88889],9657:[-.03472,.46528,0,0,.5],9661:[.19444,.69444,0,0,.88889],9667:[-.03472,.46528,0,0,.5],9711:[.19444,.69444,0,0,1],9824:[.12963,.69444,0,0,.77778],9825:[.12963,.69444,0,0,.77778],9826:[.12963,.69444,0,0,.77778],9827:[.12963,.69444,0,0,.77778],9837:[0,.75,0,0,.38889],9838:[.19444,.69444,0,0,.38889],9839:[.19444,.69444,0,0,.38889],10216:[.25,.75,0,0,.38889],10217:[.25,.75,0,0,.38889],10222:[.244,.744,0,0,.412],10223:[.244,.745,0,0,.412],10229:[.011,.511,0,0,1.609],10230:[.011,.511,0,0,1.638],10231:[.011,.511,0,0,1.859],10232:[.024,.525,0,0,1.609],10233:[.024,.525,0,0,1.638],10234:[.024,.525,0,0,1.858],10236:[.011,.511,0,0,1.638],10815:[0,.68333,0,0,.75],10927:[.13597,.63597,0,0,.77778],10928:[.13597,.63597,0,0,.77778],57376:[.19444,.69444,0,0,0]},"Math-BoldItalic":{32:[0,0,0,0,.25],48:[0,.44444,0,0,.575],49:[0,.44444,0,0,.575],50:[0,.44444,0,0,.575],51:[.19444,.44444,0,0,.575],52:[.19444,.44444,0,0,.575],53:[.19444,.44444,0,0,.575],54:[0,.64444,0,0,.575],55:[.19444,.44444,0,0,.575],56:[0,.64444,0,0,.575],57:[.19444,.44444,0,0,.575],65:[0,.68611,0,0,.86944],66:[0,.68611,.04835,0,.8664],67:[0,.68611,.06979,0,.81694],68:[0,.68611,.03194,0,.93812],69:[0,.68611,.05451,0,.81007],70:[0,.68611,.15972,0,.68889],71:[0,.68611,0,0,.88673],72:[0,.68611,.08229,0,.98229],73:[0,.68611,.07778,0,.51111],74:[0,.68611,.10069,0,.63125],75:[0,.68611,.06979,0,.97118],76:[0,.68611,0,0,.75555],77:[0,.68611,.11424,0,1.14201],78:[0,.68611,.11424,0,.95034],79:[0,.68611,.03194,0,.83666],80:[0,.68611,.15972,0,.72309],81:[.19444,.68611,0,0,.86861],82:[0,.68611,.00421,0,.87235],83:[0,.68611,.05382,0,.69271],84:[0,.68611,.15972,0,.63663],85:[0,.68611,.11424,0,.80027],86:[0,.68611,.25555,0,.67778],87:[0,.68611,.15972,0,1.09305],88:[0,.68611,.07778,0,.94722],89:[0,.68611,.25555,0,.67458],90:[0,.68611,.06979,0,.77257],97:[0,.44444,0,0,.63287],98:[0,.69444,0,0,.52083],99:[0,.44444,0,0,.51342],100:[0,.69444,0,0,.60972],101:[0,.44444,0,0,.55361],102:[.19444,.69444,.11042,0,.56806],103:[.19444,.44444,.03704,0,.5449],104:[0,.69444,0,0,.66759],105:[0,.69326,0,0,.4048],106:[.19444,.69326,.0622,0,.47083],107:[0,.69444,.01852,0,.6037],108:[0,.69444,.0088,0,.34815],109:[0,.44444,0,0,1.0324],110:[0,.44444,0,0,.71296],111:[0,.44444,0,0,.58472],112:[.19444,.44444,0,0,.60092],113:[.19444,.44444,.03704,0,.54213],114:[0,.44444,.03194,0,.5287],115:[0,.44444,0,0,.53125],116:[0,.63492,0,0,.41528],117:[0,.44444,0,0,.68102],118:[0,.44444,.03704,0,.56666],119:[0,.44444,.02778,0,.83148],120:[0,.44444,0,0,.65903],121:[.19444,.44444,.03704,0,.59028],122:[0,.44444,.04213,0,.55509],160:[0,0,0,0,.25],915:[0,.68611,.15972,0,.65694],916:[0,.68611,0,0,.95833],920:[0,.68611,.03194,0,.86722],923:[0,.68611,0,0,.80555],926:[0,.68611,.07458,0,.84125],928:[0,.68611,.08229,0,.98229],931:[0,.68611,.05451,0,.88507],933:[0,.68611,.15972,0,.67083],934:[0,.68611,0,0,.76666],936:[0,.68611,.11653,0,.71402],937:[0,.68611,.04835,0,.8789],945:[0,.44444,0,0,.76064],946:[.19444,.69444,.03403,0,.65972],947:[.19444,.44444,.06389,0,.59003],948:[0,.69444,.03819,0,.52222],949:[0,.44444,0,0,.52882],950:[.19444,.69444,.06215,0,.50833],951:[.19444,.44444,.03704,0,.6],952:[0,.69444,.03194,0,.5618],953:[0,.44444,0,0,.41204],954:[0,.44444,0,0,.66759],955:[0,.69444,0,0,.67083],956:[.19444,.44444,0,0,.70787],957:[0,.44444,.06898,0,.57685],958:[.19444,.69444,.03021,0,.50833],959:[0,.44444,0,0,.58472],960:[0,.44444,.03704,0,.68241],961:[.19444,.44444,0,0,.6118],962:[.09722,.44444,.07917,0,.42361],963:[0,.44444,.03704,0,.68588],964:[0,.44444,.13472,0,.52083],965:[0,.44444,.03704,0,.63055],966:[.19444,.44444,0,0,.74722],967:[.19444,.44444,0,0,.71805],968:[.19444,.69444,.03704,0,.75833],969:[0,.44444,.03704,0,.71782],977:[0,.69444,0,0,.69155],981:[.19444,.69444,0,0,.7125],982:[0,.44444,.03194,0,.975],1009:[.19444,.44444,0,0,.6118],1013:[0,.44444,0,0,.48333],57649:[0,.44444,0,0,.39352],57911:[.19444,.44444,0,0,.43889]},"Math-Italic":{32:[0,0,0,0,.25],48:[0,.43056,0,0,.5],49:[0,.43056,0,0,.5],50:[0,.43056,0,0,.5],51:[.19444,.43056,0,0,.5],52:[.19444,.43056,0,0,.5],53:[.19444,.43056,0,0,.5],54:[0,.64444,0,0,.5],55:[.19444,.43056,0,0,.5],56:[0,.64444,0,0,.5],57:[.19444,.43056,0,0,.5],65:[0,.68333,0,.13889,.75],66:[0,.68333,.05017,.08334,.75851],67:[0,.68333,.07153,.08334,.71472],68:[0,.68333,.02778,.05556,.82792],69:[0,.68333,.05764,.08334,.7382],70:[0,.68333,.13889,.08334,.64306],71:[0,.68333,0,.08334,.78625],72:[0,.68333,.08125,.05556,.83125],73:[0,.68333,.07847,.11111,.43958],74:[0,.68333,.09618,.16667,.55451],75:[0,.68333,.07153,.05556,.84931],76:[0,.68333,0,.02778,.68056],77:[0,.68333,.10903,.08334,.97014],78:[0,.68333,.10903,.08334,.80347],79:[0,.68333,.02778,.08334,.76278],80:[0,.68333,.13889,.08334,.64201],81:[.19444,.68333,0,.08334,.79056],82:[0,.68333,.00773,.08334,.75929],83:[0,.68333,.05764,.08334,.6132],84:[0,.68333,.13889,.08334,.58438],85:[0,.68333,.10903,.02778,.68278],86:[0,.68333,.22222,0,.58333],87:[0,.68333,.13889,0,.94445],88:[0,.68333,.07847,.08334,.82847],89:[0,.68333,.22222,0,.58056],90:[0,.68333,.07153,.08334,.68264],97:[0,.43056,0,0,.52859],98:[0,.69444,0,0,.42917],99:[0,.43056,0,.05556,.43276],100:[0,.69444,0,.16667,.52049],101:[0,.43056,0,.05556,.46563],102:[.19444,.69444,.10764,.16667,.48959],103:[.19444,.43056,.03588,.02778,.47697],104:[0,.69444,0,0,.57616],105:[0,.65952,0,0,.34451],106:[.19444,.65952,.05724,0,.41181],107:[0,.69444,.03148,0,.5206],108:[0,.69444,.01968,.08334,.29838],109:[0,.43056,0,0,.87801],110:[0,.43056,0,0,.60023],111:[0,.43056,0,.05556,.48472],112:[.19444,.43056,0,.08334,.50313],113:[.19444,.43056,.03588,.08334,.44641],114:[0,.43056,.02778,.05556,.45116],115:[0,.43056,0,.05556,.46875],116:[0,.61508,0,.08334,.36111],117:[0,.43056,0,.02778,.57246],118:[0,.43056,.03588,.02778,.48472],119:[0,.43056,.02691,.08334,.71592],120:[0,.43056,0,.02778,.57153],121:[.19444,.43056,.03588,.05556,.49028],122:[0,.43056,.04398,.05556,.46505],160:[0,0,0,0,.25],915:[0,.68333,.13889,.08334,.61528],916:[0,.68333,0,.16667,.83334],920:[0,.68333,.02778,.08334,.76278],923:[0,.68333,0,.16667,.69445],926:[0,.68333,.07569,.08334,.74236],928:[0,.68333,.08125,.05556,.83125],931:[0,.68333,.05764,.08334,.77986],933:[0,.68333,.13889,.05556,.58333],934:[0,.68333,0,.08334,.66667],936:[0,.68333,.11,.05556,.61222],937:[0,.68333,.05017,.08334,.7724],945:[0,.43056,.0037,.02778,.6397],946:[.19444,.69444,.05278,.08334,.56563],947:[.19444,.43056,.05556,0,.51773],948:[0,.69444,.03785,.05556,.44444],949:[0,.43056,0,.08334,.46632],950:[.19444,.69444,.07378,.08334,.4375],951:[.19444,.43056,.03588,.05556,.49653],952:[0,.69444,.02778,.08334,.46944],953:[0,.43056,0,.05556,.35394],954:[0,.43056,0,0,.57616],955:[0,.69444,0,0,.58334],956:[.19444,.43056,0,.02778,.60255],957:[0,.43056,.06366,.02778,.49398],958:[.19444,.69444,.04601,.11111,.4375],959:[0,.43056,0,.05556,.48472],960:[0,.43056,.03588,0,.57003],961:[.19444,.43056,0,.08334,.51702],962:[.09722,.43056,.07986,.08334,.36285],963:[0,.43056,.03588,0,.57141],964:[0,.43056,.1132,.02778,.43715],965:[0,.43056,.03588,.02778,.54028],966:[.19444,.43056,0,.08334,.65417],967:[.19444,.43056,0,.05556,.62569],968:[.19444,.69444,.03588,.11111,.65139],969:[0,.43056,.03588,0,.62245],977:[0,.69444,0,.08334,.59144],981:[.19444,.69444,0,.08334,.59583],982:[0,.43056,.02778,0,.82813],1009:[.19444,.43056,0,.08334,.51702],1013:[0,.43056,0,.05556,.4059],57649:[0,.43056,0,.02778,.32246],57911:[.19444,.43056,0,.08334,.38403]},"SansSerif-Bold":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.36667],34:[0,.69444,0,0,.55834],35:[.19444,.69444,0,0,.91667],36:[.05556,.75,0,0,.55],37:[.05556,.75,0,0,1.02912],38:[0,.69444,0,0,.83056],39:[0,.69444,0,0,.30556],40:[.25,.75,0,0,.42778],41:[.25,.75,0,0,.42778],42:[0,.75,0,0,.55],43:[.11667,.61667,0,0,.85556],44:[.10556,.13056,0,0,.30556],45:[0,.45833,0,0,.36667],46:[0,.13056,0,0,.30556],47:[.25,.75,0,0,.55],48:[0,.69444,0,0,.55],49:[0,.69444,0,0,.55],50:[0,.69444,0,0,.55],51:[0,.69444,0,0,.55],52:[0,.69444,0,0,.55],53:[0,.69444,0,0,.55],54:[0,.69444,0,0,.55],55:[0,.69444,0,0,.55],56:[0,.69444,0,0,.55],57:[0,.69444,0,0,.55],58:[0,.45833,0,0,.30556],59:[.10556,.45833,0,0,.30556],61:[-.09375,.40625,0,0,.85556],63:[0,.69444,0,0,.51945],64:[0,.69444,0,0,.73334],65:[0,.69444,0,0,.73334],66:[0,.69444,0,0,.73334],67:[0,.69444,0,0,.70278],68:[0,.69444,0,0,.79445],69:[0,.69444,0,0,.64167],70:[0,.69444,0,0,.61111],71:[0,.69444,0,0,.73334],72:[0,.69444,0,0,.79445],73:[0,.69444,0,0,.33056],74:[0,.69444,0,0,.51945],75:[0,.69444,0,0,.76389],76:[0,.69444,0,0,.58056],77:[0,.69444,0,0,.97778],78:[0,.69444,0,0,.79445],79:[0,.69444,0,0,.79445],80:[0,.69444,0,0,.70278],81:[.10556,.69444,0,0,.79445],82:[0,.69444,0,0,.70278],83:[0,.69444,0,0,.61111],84:[0,.69444,0,0,.73334],85:[0,.69444,0,0,.76389],86:[0,.69444,.01528,0,.73334],87:[0,.69444,.01528,0,1.03889],88:[0,.69444,0,0,.73334],89:[0,.69444,.0275,0,.73334],90:[0,.69444,0,0,.67223],91:[.25,.75,0,0,.34306],93:[.25,.75,0,0,.34306],94:[0,.69444,0,0,.55],95:[.35,.10833,.03056,0,.55],97:[0,.45833,0,0,.525],98:[0,.69444,0,0,.56111],99:[0,.45833,0,0,.48889],100:[0,.69444,0,0,.56111],101:[0,.45833,0,0,.51111],102:[0,.69444,.07639,0,.33611],103:[.19444,.45833,.01528,0,.55],104:[0,.69444,0,0,.56111],105:[0,.69444,0,0,.25556],106:[.19444,.69444,0,0,.28611],107:[0,.69444,0,0,.53056],108:[0,.69444,0,0,.25556],109:[0,.45833,0,0,.86667],110:[0,.45833,0,0,.56111],111:[0,.45833,0,0,.55],112:[.19444,.45833,0,0,.56111],113:[.19444,.45833,0,0,.56111],114:[0,.45833,.01528,0,.37222],115:[0,.45833,0,0,.42167],116:[0,.58929,0,0,.40417],117:[0,.45833,0,0,.56111],118:[0,.45833,.01528,0,.5],119:[0,.45833,.01528,0,.74445],120:[0,.45833,0,0,.5],121:[.19444,.45833,.01528,0,.5],122:[0,.45833,0,0,.47639],126:[.35,.34444,0,0,.55],160:[0,0,0,0,.25],168:[0,.69444,0,0,.55],176:[0,.69444,0,0,.73334],180:[0,.69444,0,0,.55],184:[.17014,0,0,0,.48889],305:[0,.45833,0,0,.25556],567:[.19444,.45833,0,0,.28611],710:[0,.69444,0,0,.55],711:[0,.63542,0,0,.55],713:[0,.63778,0,0,.55],728:[0,.69444,0,0,.55],729:[0,.69444,0,0,.30556],730:[0,.69444,0,0,.73334],732:[0,.69444,0,0,.55],733:[0,.69444,0,0,.55],915:[0,.69444,0,0,.58056],916:[0,.69444,0,0,.91667],920:[0,.69444,0,0,.85556],923:[0,.69444,0,0,.67223],926:[0,.69444,0,0,.73334],928:[0,.69444,0,0,.79445],931:[0,.69444,0,0,.79445],933:[0,.69444,0,0,.85556],934:[0,.69444,0,0,.79445],936:[0,.69444,0,0,.85556],937:[0,.69444,0,0,.79445],8211:[0,.45833,.03056,0,.55],8212:[0,.45833,.03056,0,1.10001],8216:[0,.69444,0,0,.30556],8217:[0,.69444,0,0,.30556],8220:[0,.69444,0,0,.55834],8221:[0,.69444,0,0,.55834]},"SansSerif-Italic":{32:[0,0,0,0,.25],33:[0,.69444,.05733,0,.31945],34:[0,.69444,.00316,0,.5],35:[.19444,.69444,.05087,0,.83334],36:[.05556,.75,.11156,0,.5],37:[.05556,.75,.03126,0,.83334],38:[0,.69444,.03058,0,.75834],39:[0,.69444,.07816,0,.27778],40:[.25,.75,.13164,0,.38889],41:[.25,.75,.02536,0,.38889],42:[0,.75,.11775,0,.5],43:[.08333,.58333,.02536,0,.77778],44:[.125,.08333,0,0,.27778],45:[0,.44444,.01946,0,.33333],46:[0,.08333,0,0,.27778],47:[.25,.75,.13164,0,.5],48:[0,.65556,.11156,0,.5],49:[0,.65556,.11156,0,.5],50:[0,.65556,.11156,0,.5],51:[0,.65556,.11156,0,.5],52:[0,.65556,.11156,0,.5],53:[0,.65556,.11156,0,.5],54:[0,.65556,.11156,0,.5],55:[0,.65556,.11156,0,.5],56:[0,.65556,.11156,0,.5],57:[0,.65556,.11156,0,.5],58:[0,.44444,.02502,0,.27778],59:[.125,.44444,.02502,0,.27778],61:[-.13,.37,.05087,0,.77778],63:[0,.69444,.11809,0,.47222],64:[0,.69444,.07555,0,.66667],65:[0,.69444,0,0,.66667],66:[0,.69444,.08293,0,.66667],67:[0,.69444,.11983,0,.63889],68:[0,.69444,.07555,0,.72223],69:[0,.69444,.11983,0,.59722],70:[0,.69444,.13372,0,.56945],71:[0,.69444,.11983,0,.66667],72:[0,.69444,.08094,0,.70834],73:[0,.69444,.13372,0,.27778],74:[0,.69444,.08094,0,.47222],75:[0,.69444,.11983,0,.69445],76:[0,.69444,0,0,.54167],77:[0,.69444,.08094,0,.875],78:[0,.69444,.08094,0,.70834],79:[0,.69444,.07555,0,.73611],80:[0,.69444,.08293,0,.63889],81:[.125,.69444,.07555,0,.73611],82:[0,.69444,.08293,0,.64584],83:[0,.69444,.09205,0,.55556],84:[0,.69444,.13372,0,.68056],85:[0,.69444,.08094,0,.6875],86:[0,.69444,.1615,0,.66667],87:[0,.69444,.1615,0,.94445],88:[0,.69444,.13372,0,.66667],89:[0,.69444,.17261,0,.66667],90:[0,.69444,.11983,0,.61111],91:[.25,.75,.15942,0,.28889],93:[.25,.75,.08719,0,.28889],94:[0,.69444,.0799,0,.5],95:[.35,.09444,.08616,0,.5],97:[0,.44444,.00981,0,.48056],98:[0,.69444,.03057,0,.51667],99:[0,.44444,.08336,0,.44445],100:[0,.69444,.09483,0,.51667],101:[0,.44444,.06778,0,.44445],102:[0,.69444,.21705,0,.30556],103:[.19444,.44444,.10836,0,.5],104:[0,.69444,.01778,0,.51667],105:[0,.67937,.09718,0,.23889],106:[.19444,.67937,.09162,0,.26667],107:[0,.69444,.08336,0,.48889],108:[0,.69444,.09483,0,.23889],109:[0,.44444,.01778,0,.79445],110:[0,.44444,.01778,0,.51667],111:[0,.44444,.06613,0,.5],112:[.19444,.44444,.0389,0,.51667],113:[.19444,.44444,.04169,0,.51667],114:[0,.44444,.10836,0,.34167],115:[0,.44444,.0778,0,.38333],116:[0,.57143,.07225,0,.36111],117:[0,.44444,.04169,0,.51667],118:[0,.44444,.10836,0,.46111],119:[0,.44444,.10836,0,.68334],120:[0,.44444,.09169,0,.46111],121:[.19444,.44444,.10836,0,.46111],122:[0,.44444,.08752,0,.43472],126:[.35,.32659,.08826,0,.5],160:[0,0,0,0,.25],168:[0,.67937,.06385,0,.5],176:[0,.69444,0,0,.73752],184:[.17014,0,0,0,.44445],305:[0,.44444,.04169,0,.23889],567:[.19444,.44444,.04169,0,.26667],710:[0,.69444,.0799,0,.5],711:[0,.63194,.08432,0,.5],713:[0,.60889,.08776,0,.5],714:[0,.69444,.09205,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,.09483,0,.5],729:[0,.67937,.07774,0,.27778],730:[0,.69444,0,0,.73752],732:[0,.67659,.08826,0,.5],733:[0,.69444,.09205,0,.5],915:[0,.69444,.13372,0,.54167],916:[0,.69444,0,0,.83334],920:[0,.69444,.07555,0,.77778],923:[0,.69444,0,0,.61111],926:[0,.69444,.12816,0,.66667],928:[0,.69444,.08094,0,.70834],931:[0,.69444,.11983,0,.72222],933:[0,.69444,.09031,0,.77778],934:[0,.69444,.04603,0,.72222],936:[0,.69444,.09031,0,.77778],937:[0,.69444,.08293,0,.72222],8211:[0,.44444,.08616,0,.5],8212:[0,.44444,.08616,0,1],8216:[0,.69444,.07816,0,.27778],8217:[0,.69444,.07816,0,.27778],8220:[0,.69444,.14205,0,.5],8221:[0,.69444,.00316,0,.5]},"SansSerif-Regular":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.31945],34:[0,.69444,0,0,.5],35:[.19444,.69444,0,0,.83334],36:[.05556,.75,0,0,.5],37:[.05556,.75,0,0,.83334],38:[0,.69444,0,0,.75834],39:[0,.69444,0,0,.27778],40:[.25,.75,0,0,.38889],41:[.25,.75,0,0,.38889],42:[0,.75,0,0,.5],43:[.08333,.58333,0,0,.77778],44:[.125,.08333,0,0,.27778],45:[0,.44444,0,0,.33333],46:[0,.08333,0,0,.27778],47:[.25,.75,0,0,.5],48:[0,.65556,0,0,.5],49:[0,.65556,0,0,.5],50:[0,.65556,0,0,.5],51:[0,.65556,0,0,.5],52:[0,.65556,0,0,.5],53:[0,.65556,0,0,.5],54:[0,.65556,0,0,.5],55:[0,.65556,0,0,.5],56:[0,.65556,0,0,.5],57:[0,.65556,0,0,.5],58:[0,.44444,0,0,.27778],59:[.125,.44444,0,0,.27778],61:[-.13,.37,0,0,.77778],63:[0,.69444,0,0,.47222],64:[0,.69444,0,0,.66667],65:[0,.69444,0,0,.66667],66:[0,.69444,0,0,.66667],67:[0,.69444,0,0,.63889],68:[0,.69444,0,0,.72223],69:[0,.69444,0,0,.59722],70:[0,.69444,0,0,.56945],71:[0,.69444,0,0,.66667],72:[0,.69444,0,0,.70834],73:[0,.69444,0,0,.27778],74:[0,.69444,0,0,.47222],75:[0,.69444,0,0,.69445],76:[0,.69444,0,0,.54167],77:[0,.69444,0,0,.875],78:[0,.69444,0,0,.70834],79:[0,.69444,0,0,.73611],80:[0,.69444,0,0,.63889],81:[.125,.69444,0,0,.73611],82:[0,.69444,0,0,.64584],83:[0,.69444,0,0,.55556],84:[0,.69444,0,0,.68056],85:[0,.69444,0,0,.6875],86:[0,.69444,.01389,0,.66667],87:[0,.69444,.01389,0,.94445],88:[0,.69444,0,0,.66667],89:[0,.69444,.025,0,.66667],90:[0,.69444,0,0,.61111],91:[.25,.75,0,0,.28889],93:[.25,.75,0,0,.28889],94:[0,.69444,0,0,.5],95:[.35,.09444,.02778,0,.5],97:[0,.44444,0,0,.48056],98:[0,.69444,0,0,.51667],99:[0,.44444,0,0,.44445],100:[0,.69444,0,0,.51667],101:[0,.44444,0,0,.44445],102:[0,.69444,.06944,0,.30556],103:[.19444,.44444,.01389,0,.5],104:[0,.69444,0,0,.51667],105:[0,.67937,0,0,.23889],106:[.19444,.67937,0,0,.26667],107:[0,.69444,0,0,.48889],108:[0,.69444,0,0,.23889],109:[0,.44444,0,0,.79445],110:[0,.44444,0,0,.51667],111:[0,.44444,0,0,.5],112:[.19444,.44444,0,0,.51667],113:[.19444,.44444,0,0,.51667],114:[0,.44444,.01389,0,.34167],115:[0,.44444,0,0,.38333],116:[0,.57143,0,0,.36111],117:[0,.44444,0,0,.51667],118:[0,.44444,.01389,0,.46111],119:[0,.44444,.01389,0,.68334],120:[0,.44444,0,0,.46111],121:[.19444,.44444,.01389,0,.46111],122:[0,.44444,0,0,.43472],126:[.35,.32659,0,0,.5],160:[0,0,0,0,.25],168:[0,.67937,0,0,.5],176:[0,.69444,0,0,.66667],184:[.17014,0,0,0,.44445],305:[0,.44444,0,0,.23889],567:[.19444,.44444,0,0,.26667],710:[0,.69444,0,0,.5],711:[0,.63194,0,0,.5],713:[0,.60889,0,0,.5],714:[0,.69444,0,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,0,0,.5],729:[0,.67937,0,0,.27778],730:[0,.69444,0,0,.66667],732:[0,.67659,0,0,.5],733:[0,.69444,0,0,.5],915:[0,.69444,0,0,.54167],916:[0,.69444,0,0,.83334],920:[0,.69444,0,0,.77778],923:[0,.69444,0,0,.61111],926:[0,.69444,0,0,.66667],928:[0,.69444,0,0,.70834],931:[0,.69444,0,0,.72222],933:[0,.69444,0,0,.77778],934:[0,.69444,0,0,.72222],936:[0,.69444,0,0,.77778],937:[0,.69444,0,0,.72222],8211:[0,.44444,.02778,0,.5],8212:[0,.44444,.02778,0,1],8216:[0,.69444,0,0,.27778],8217:[0,.69444,0,0,.27778],8220:[0,.69444,0,0,.5],8221:[0,.69444,0,0,.5]},"Script-Regular":{32:[0,0,0,0,.25],65:[0,.7,.22925,0,.80253],66:[0,.7,.04087,0,.90757],67:[0,.7,.1689,0,.66619],68:[0,.7,.09371,0,.77443],69:[0,.7,.18583,0,.56162],70:[0,.7,.13634,0,.89544],71:[0,.7,.17322,0,.60961],72:[0,.7,.29694,0,.96919],73:[0,.7,.19189,0,.80907],74:[.27778,.7,.19189,0,1.05159],75:[0,.7,.31259,0,.91364],76:[0,.7,.19189,0,.87373],77:[0,.7,.15981,0,1.08031],78:[0,.7,.3525,0,.9015],79:[0,.7,.08078,0,.73787],80:[0,.7,.08078,0,1.01262],81:[0,.7,.03305,0,.88282],82:[0,.7,.06259,0,.85],83:[0,.7,.19189,0,.86767],84:[0,.7,.29087,0,.74697],85:[0,.7,.25815,0,.79996],86:[0,.7,.27523,0,.62204],87:[0,.7,.27523,0,.80532],88:[0,.7,.26006,0,.94445],89:[0,.7,.2939,0,.70961],90:[0,.7,.24037,0,.8212],160:[0,0,0,0,.25]},"Size1-Regular":{32:[0,0,0,0,.25],40:[.35001,.85,0,0,.45834],41:[.35001,.85,0,0,.45834],47:[.35001,.85,0,0,.57778],91:[.35001,.85,0,0,.41667],92:[.35001,.85,0,0,.57778],93:[.35001,.85,0,0,.41667],123:[.35001,.85,0,0,.58334],125:[.35001,.85,0,0,.58334],160:[0,0,0,0,.25],710:[0,.72222,0,0,.55556],732:[0,.72222,0,0,.55556],770:[0,.72222,0,0,.55556],771:[0,.72222,0,0,.55556],8214:[-99e-5,.601,0,0,.77778],8593:[1e-5,.6,0,0,.66667],8595:[1e-5,.6,0,0,.66667],8657:[1e-5,.6,0,0,.77778],8659:[1e-5,.6,0,0,.77778],8719:[.25001,.75,0,0,.94445],8720:[.25001,.75,0,0,.94445],8721:[.25001,.75,0,0,1.05556],8730:[.35001,.85,0,0,1],8739:[-.00599,.606,0,0,.33333],8741:[-.00599,.606,0,0,.55556],8747:[.30612,.805,.19445,0,.47222],8748:[.306,.805,.19445,0,.47222],8749:[.306,.805,.19445,0,.47222],8750:[.30612,.805,.19445,0,.47222],8896:[.25001,.75,0,0,.83334],8897:[.25001,.75,0,0,.83334],8898:[.25001,.75,0,0,.83334],8899:[.25001,.75,0,0,.83334],8968:[.35001,.85,0,0,.47222],8969:[.35001,.85,0,0,.47222],8970:[.35001,.85,0,0,.47222],8971:[.35001,.85,0,0,.47222],9168:[-99e-5,.601,0,0,.66667],10216:[.35001,.85,0,0,.47222],10217:[.35001,.85,0,0,.47222],10752:[.25001,.75,0,0,1.11111],10753:[.25001,.75,0,0,1.11111],10754:[.25001,.75,0,0,1.11111],10756:[.25001,.75,0,0,.83334],10758:[.25001,.75,0,0,.83334]},"Size2-Regular":{32:[0,0,0,0,.25],40:[.65002,1.15,0,0,.59722],41:[.65002,1.15,0,0,.59722],47:[.65002,1.15,0,0,.81111],91:[.65002,1.15,0,0,.47222],92:[.65002,1.15,0,0,.81111],93:[.65002,1.15,0,0,.47222],123:[.65002,1.15,0,0,.66667],125:[.65002,1.15,0,0,.66667],160:[0,0,0,0,.25],710:[0,.75,0,0,1],732:[0,.75,0,0,1],770:[0,.75,0,0,1],771:[0,.75,0,0,1],8719:[.55001,1.05,0,0,1.27778],8720:[.55001,1.05,0,0,1.27778],8721:[.55001,1.05,0,0,1.44445],8730:[.65002,1.15,0,0,1],8747:[.86225,1.36,.44445,0,.55556],8748:[.862,1.36,.44445,0,.55556],8749:[.862,1.36,.44445,0,.55556],8750:[.86225,1.36,.44445,0,.55556],8896:[.55001,1.05,0,0,1.11111],8897:[.55001,1.05,0,0,1.11111],8898:[.55001,1.05,0,0,1.11111],8899:[.55001,1.05,0,0,1.11111],8968:[.65002,1.15,0,0,.52778],8969:[.65002,1.15,0,0,.52778],8970:[.65002,1.15,0,0,.52778],8971:[.65002,1.15,0,0,.52778],10216:[.65002,1.15,0,0,.61111],10217:[.65002,1.15,0,0,.61111],10752:[.55001,1.05,0,0,1.51112],10753:[.55001,1.05,0,0,1.51112],10754:[.55001,1.05,0,0,1.51112],10756:[.55001,1.05,0,0,1.11111],10758:[.55001,1.05,0,0,1.11111]},"Size3-Regular":{32:[0,0,0,0,.25],40:[.95003,1.45,0,0,.73611],41:[.95003,1.45,0,0,.73611],47:[.95003,1.45,0,0,1.04445],91:[.95003,1.45,0,0,.52778],92:[.95003,1.45,0,0,1.04445],93:[.95003,1.45,0,0,.52778],123:[.95003,1.45,0,0,.75],125:[.95003,1.45,0,0,.75],160:[0,0,0,0,.25],710:[0,.75,0,0,1.44445],732:[0,.75,0,0,1.44445],770:[0,.75,0,0,1.44445],771:[0,.75,0,0,1.44445],8730:[.95003,1.45,0,0,1],8968:[.95003,1.45,0,0,.58334],8969:[.95003,1.45,0,0,.58334],8970:[.95003,1.45,0,0,.58334],8971:[.95003,1.45,0,0,.58334],10216:[.95003,1.45,0,0,.75],10217:[.95003,1.45,0,0,.75]},"Size4-Regular":{32:[0,0,0,0,.25],40:[1.25003,1.75,0,0,.79167],41:[1.25003,1.75,0,0,.79167],47:[1.25003,1.75,0,0,1.27778],91:[1.25003,1.75,0,0,.58334],92:[1.25003,1.75,0,0,1.27778],93:[1.25003,1.75,0,0,.58334],123:[1.25003,1.75,0,0,.80556],125:[1.25003,1.75,0,0,.80556],160:[0,0,0,0,.25],710:[0,.825,0,0,1.8889],732:[0,.825,0,0,1.8889],770:[0,.825,0,0,1.8889],771:[0,.825,0,0,1.8889],8730:[1.25003,1.75,0,0,1],8968:[1.25003,1.75,0,0,.63889],8969:[1.25003,1.75,0,0,.63889],8970:[1.25003,1.75,0,0,.63889],8971:[1.25003,1.75,0,0,.63889],9115:[.64502,1.155,0,0,.875],9116:[1e-5,.6,0,0,.875],9117:[.64502,1.155,0,0,.875],9118:[.64502,1.155,0,0,.875],9119:[1e-5,.6,0,0,.875],9120:[.64502,1.155,0,0,.875],9121:[.64502,1.155,0,0,.66667],9122:[-99e-5,.601,0,0,.66667],9123:[.64502,1.155,0,0,.66667],9124:[.64502,1.155,0,0,.66667],9125:[-99e-5,.601,0,0,.66667],9126:[.64502,1.155,0,0,.66667],9127:[1e-5,.9,0,0,.88889],9128:[.65002,1.15,0,0,.88889],9129:[.90001,0,0,0,.88889],9130:[0,.3,0,0,.88889],9131:[1e-5,.9,0,0,.88889],9132:[.65002,1.15,0,0,.88889],9133:[.90001,0,0,0,.88889],9143:[.88502,.915,0,0,1.05556],10216:[1.25003,1.75,0,0,.80556],10217:[1.25003,1.75,0,0,.80556],57344:[-.00499,.605,0,0,1.05556],57345:[-.00499,.605,0,0,1.05556],57680:[0,.12,0,0,.45],57681:[0,.12,0,0,.45],57682:[0,.12,0,0,.45],57683:[0,.12,0,0,.45]},"Typewriter-Regular":{32:[0,0,0,0,.525],33:[0,.61111,0,0,.525],34:[0,.61111,0,0,.525],35:[0,.61111,0,0,.525],36:[.08333,.69444,0,0,.525],37:[.08333,.69444,0,0,.525],38:[0,.61111,0,0,.525],39:[0,.61111,0,0,.525],40:[.08333,.69444,0,0,.525],41:[.08333,.69444,0,0,.525],42:[0,.52083,0,0,.525],43:[-.08056,.53055,0,0,.525],44:[.13889,.125,0,0,.525],45:[-.08056,.53055,0,0,.525],46:[0,.125,0,0,.525],47:[.08333,.69444,0,0,.525],48:[0,.61111,0,0,.525],49:[0,.61111,0,0,.525],50:[0,.61111,0,0,.525],51:[0,.61111,0,0,.525],52:[0,.61111,0,0,.525],53:[0,.61111,0,0,.525],54:[0,.61111,0,0,.525],55:[0,.61111,0,0,.525],56:[0,.61111,0,0,.525],57:[0,.61111,0,0,.525],58:[0,.43056,0,0,.525],59:[.13889,.43056,0,0,.525],60:[-.05556,.55556,0,0,.525],61:[-.19549,.41562,0,0,.525],62:[-.05556,.55556,0,0,.525],63:[0,.61111,0,0,.525],64:[0,.61111,0,0,.525],65:[0,.61111,0,0,.525],66:[0,.61111,0,0,.525],67:[0,.61111,0,0,.525],68:[0,.61111,0,0,.525],69:[0,.61111,0,0,.525],70:[0,.61111,0,0,.525],71:[0,.61111,0,0,.525],72:[0,.61111,0,0,.525],73:[0,.61111,0,0,.525],74:[0,.61111,0,0,.525],75:[0,.61111,0,0,.525],76:[0,.61111,0,0,.525],77:[0,.61111,0,0,.525],78:[0,.61111,0,0,.525],79:[0,.61111,0,0,.525],80:[0,.61111,0,0,.525],81:[.13889,.61111,0,0,.525],82:[0,.61111,0,0,.525],83:[0,.61111,0,0,.525],84:[0,.61111,0,0,.525],85:[0,.61111,0,0,.525],86:[0,.61111,0,0,.525],87:[0,.61111,0,0,.525],88:[0,.61111,0,0,.525],89:[0,.61111,0,0,.525],90:[0,.61111,0,0,.525],91:[.08333,.69444,0,0,.525],92:[.08333,.69444,0,0,.525],93:[.08333,.69444,0,0,.525],94:[0,.61111,0,0,.525],95:[.09514,0,0,0,.525],96:[0,.61111,0,0,.525],97:[0,.43056,0,0,.525],98:[0,.61111,0,0,.525],99:[0,.43056,0,0,.525],100:[0,.61111,0,0,.525],101:[0,.43056,0,0,.525],102:[0,.61111,0,0,.525],103:[.22222,.43056,0,0,.525],104:[0,.61111,0,0,.525],105:[0,.61111,0,0,.525],106:[.22222,.61111,0,0,.525],107:[0,.61111,0,0,.525],108:[0,.61111,0,0,.525],109:[0,.43056,0,0,.525],110:[0,.43056,0,0,.525],111:[0,.43056,0,0,.525],112:[.22222,.43056,0,0,.525],113:[.22222,.43056,0,0,.525],114:[0,.43056,0,0,.525],115:[0,.43056,0,0,.525],116:[0,.55358,0,0,.525],117:[0,.43056,0,0,.525],118:[0,.43056,0,0,.525],119:[0,.43056,0,0,.525],120:[0,.43056,0,0,.525],121:[.22222,.43056,0,0,.525],122:[0,.43056,0,0,.525],123:[.08333,.69444,0,0,.525],124:[.08333,.69444,0,0,.525],125:[.08333,.69444,0,0,.525],126:[0,.61111,0,0,.525],127:[0,.61111,0,0,.525],160:[0,0,0,0,.525],176:[0,.61111,0,0,.525],184:[.19445,0,0,0,.525],305:[0,.43056,0,0,.525],567:[.22222,.43056,0,0,.525],711:[0,.56597,0,0,.525],713:[0,.56555,0,0,.525],714:[0,.61111,0,0,.525],715:[0,.61111,0,0,.525],728:[0,.61111,0,0,.525],730:[0,.61111,0,0,.525],770:[0,.61111,0,0,.525],771:[0,.61111,0,0,.525],776:[0,.61111,0,0,.525],915:[0,.61111,0,0,.525],916:[0,.61111,0,0,.525],920:[0,.61111,0,0,.525],923:[0,.61111,0,0,.525],926:[0,.61111,0,0,.525],928:[0,.61111,0,0,.525],931:[0,.61111,0,0,.525],933:[0,.61111,0,0,.525],934:[0,.61111,0,0,.525],936:[0,.61111,0,0,.525],937:[0,.61111,0,0,.525],8216:[0,.61111,0,0,.525],8217:[0,.61111,0,0,.525],8242:[0,.61111,0,0,.525],9251:[.11111,.21944,0,0,.525]}},we={slant:[.25,.25,.25],space:[0,0,0],stretch:[0,0,0],shrink:[0,0,0],xHeight:[.431,.431,.431],quad:[1,1.171,1.472],extraSpace:[0,0,0],num1:[.677,.732,.925],num2:[.394,.384,.387],num3:[.444,.471,.504],denom1:[.686,.752,1.025],denom2:[.345,.344,.532],sup1:[.413,.503,.504],sup2:[.363,.431,.404],sup3:[.289,.286,.294],sub1:[.15,.143,.2],sub2:[.247,.286,.4],supDrop:[.386,.353,.494],subDrop:[.05,.071,.1],delim1:[2.39,1.7,1.98],delim2:[1.01,1.157,1.42],axisHeight:[.25,.25,.25],defaultRuleThickness:[.04,.049,.049],bigOpSpacing1:[.111,.111,.111],bigOpSpacing2:[.166,.166,.166],bigOpSpacing3:[.2,.2,.2],bigOpSpacing4:[.6,.611,.611],bigOpSpacing5:[.1,.143,.143],sqrtRuleThickness:[.04,.04,.04],ptPerEm:[10,10,10],doubleRuleSep:[.2,.2,.2],arrayRuleWidth:[.04,.04,.04],fboxsep:[.3,.3,.3],fboxrule:[.04,.04,.04]},ir={Å:"A",Ð:"D",Þ:"o",å:"a",ð:"d",þ:"o",А:"A",Б:"B",В:"B",Г:"F",Д:"A",Е:"E",Ж:"K",З:"3",И:"N",Й:"N",К:"K",Л:"N",М:"M",Н:"H",О:"O",П:"N",Р:"P",С:"C",Т:"T",У:"y",Ф:"O",Х:"X",Ц:"U",Ч:"h",Ш:"W",Щ:"W",Ъ:"B",Ы:"X",Ь:"B",Э:"3",Ю:"X",Я:"R",а:"a",б:"b",в:"a",г:"r",д:"y",е:"e",ж:"m",з:"e",и:"n",й:"n",к:"n",л:"n",м:"m",н:"n",о:"o",п:"n",р:"p",с:"c",т:"o",у:"y",ф:"b",х:"x",ц:"n",ч:"n",ш:"w",щ:"w",ъ:"a",ы:"m",ь:"a",э:"e",ю:"m",я:"r"};function Aa(r,e){k0[r]=e}function Nt(r,e,t){if(!k0[e])throw new Error("Font metrics not found for font: "+e+".");var a=r.charCodeAt(0),i=k0[e][a];if(!i&&r[0]in ir&&(a=ir[r[0]].charCodeAt(0),i=k0[e][a]),!i&&t==="text"&&Gr(a)&&(i=k0[e][77]),i)return{depth:i[0],height:i[1],italic:i[2],skew:i[3],width:i[4]}}var Je={};function Ma(r){var e;if(r>=5?e=0:r>=3?e=1:e=2,!Je[e]){var t=Je[e]={cssEmPerMu:we.quad[e]/18};for(var a in we)we.hasOwnProperty(a)&&(t[a]=we[a][e])}return Je[e]}var W={math:{},text:{}};function n(r,e,t,a,i,s){W[r][i]={font:e,group:t,replace:a},s&&a&&(W[r][a]=W[r][i])}var l="math",w="text",o="main",d="ams",j="accent-token",D="bin",u0="close",ne="inner",E="mathord",t0="op-token",f0="open",de="punct",f="rel",q0="spacing",g="textord";n(l,o,f,"≡","\\equiv",!0);n(l,o,f,"≺","\\prec",!0);n(l,o,f,"≻","\\succ",!0);n(l,o,f,"∼","\\sim",!0);n(l,o,f,"⊥","\\perp");n(l,o,f,"⪯","\\preceq",!0);n(l,o,f,"⪰","\\succeq",!0);n(l,o,f,"≃","\\simeq",!0);n(l,o,f,"∣","\\mid",!0);n(l,o,f,"≪","\\ll",!0);n(l,o,f,"≫","\\gg",!0);n(l,o,f,"≍","\\asymp",!0);n(l,o,f,"∥","\\parallel");n(l,o,f,"⋈","\\bowtie",!0);n(l,o,f,"⌣","\\smile",!0);n(l,o,f,"⊑","\\sqsubseteq",!0);n(l,o,f,"⊒","\\sqsupseteq",!0);n(l,o,f,"≐","\\doteq",!0);n(l,o,f,"⌢","\\frown",!0);n(l,o,f,"∋","\\ni",!0);n(l,o,f,"∝","\\propto",!0);n(l,o,f,"⊢","\\vdash",!0);n(l,o,f,"⊣","\\dashv",!0);n(l,o,f,"∋","\\owns");n(l,o,de,".","\\ldotp");n(l,o,de,"⋅","\\cdotp");n(l,o,de,"⋅","·");n(w,o,g,"⋅","·");n(l,o,g,"#","\\#");n(w,o,g,"#","\\#");n(l,o,g,"&","\\&");n(w,o,g,"&","\\&");n(l,o,g,"ℵ","\\aleph",!0);n(l,o,g,"∀","\\forall",!0);n(l,o,g,"ℏ","\\hbar",!0);n(l,o,g,"∃","\\exists",!0);n(l,o,g,"∇","\\nabla",!0);n(l,o,g,"♭","\\flat",!0);n(l,o,g,"ℓ","\\ell",!0);n(l,o,g,"♮","\\natural",!0);n(l,o,g,"♣","\\clubsuit",!0);n(l,o,g,"℘","\\wp",!0);n(l,o,g,"♯","\\sharp",!0);n(l,o,g,"♢","\\diamondsuit",!0);n(l,o,g,"ℜ","\\Re",!0);n(l,o,g,"♡","\\heartsuit",!0);n(l,o,g,"ℑ","\\Im",!0);n(l,o,g,"♠","\\spadesuit",!0);n(l,o,g,"§","\\S",!0);n(w,o,g,"§","\\S");n(l,o,g,"¶","\\P",!0);n(w,o,g,"¶","\\P");n(l,o,g,"†","\\dag");n(w,o,g,"†","\\dag");n(w,o,g,"†","\\textdagger");n(l,o,g,"‡","\\ddag");n(w,o,g,"‡","\\ddag");n(w,o,g,"‡","\\textdaggerdbl");n(l,o,u0,"⎱","\\rmoustache",!0);n(l,o,f0,"⎰","\\lmoustache",!0);n(l,o,u0,"⟯","\\rgroup",!0);n(l,o,f0,"⟮","\\lgroup",!0);n(l,o,D,"∓","\\mp",!0);n(l,o,D,"⊖","\\ominus",!0);n(l,o,D,"⊎","\\uplus",!0);n(l,o,D,"⊓","\\sqcap",!0);n(l,o,D,"∗","\\ast");n(l,o,D,"⊔","\\sqcup",!0);n(l,o,D,"◯","\\bigcirc",!0);n(l,o,D,"∙","\\bullet",!0);n(l,o,D,"‡","\\ddagger");n(l,o,D,"≀","\\wr",!0);n(l,o,D,"⨿","\\amalg");n(l,o,D,"&","\\And");n(l,o,f,"⟵","\\longleftarrow",!0);n(l,o,f,"⇐","\\Leftarrow",!0);n(l,o,f,"⟸","\\Longleftarrow",!0);n(l,o,f,"⟶","\\longrightarrow",!0);n(l,o,f,"⇒","\\Rightarrow",!0);n(l,o,f,"⟹","\\Longrightarrow",!0);n(l,o,f,"↔","\\leftrightarrow",!0);n(l,o,f,"⟷","\\longleftrightarrow",!0);n(l,o,f,"⇔","\\Leftrightarrow",!0);n(l,o,f,"⟺","\\Longleftrightarrow",!0);n(l,o,f,"↦","\\mapsto",!0);n(l,o,f,"⟼","\\longmapsto",!0);n(l,o,f,"↗","\\nearrow",!0);n(l,o,f,"↩","\\hookleftarrow",!0);n(l,o,f,"↪","\\hookrightarrow",!0);n(l,o,f,"↘","\\searrow",!0);n(l,o,f,"↼","\\leftharpoonup",!0);n(l,o,f,"⇀","\\rightharpoonup",!0);n(l,o,f,"↙","\\swarrow",!0);n(l,o,f,"↽","\\leftharpoondown",!0);n(l,o,f,"⇁","\\rightharpoondown",!0);n(l,o,f,"↖","\\nwarrow",!0);n(l,o,f,"⇌","\\rightleftharpoons",!0);n(l,d,f,"≮","\\nless",!0);n(l,d,f,"","\\@nleqslant");n(l,d,f,"","\\@nleqq");n(l,d,f,"⪇","\\lneq",!0);n(l,d,f,"≨","\\lneqq",!0);n(l,d,f,"","\\@lvertneqq");n(l,d,f,"⋦","\\lnsim",!0);n(l,d,f,"⪉","\\lnapprox",!0);n(l,d,f,"⊀","\\nprec",!0);n(l,d,f,"⋠","\\npreceq",!0);n(l,d,f,"⋨","\\precnsim",!0);n(l,d,f,"⪹","\\precnapprox",!0);n(l,d,f,"≁","\\nsim",!0);n(l,d,f,"","\\@nshortmid");n(l,d,f,"∤","\\nmid",!0);n(l,d,f,"⊬","\\nvdash",!0);n(l,d,f,"⊭","\\nvDash",!0);n(l,d,f,"⋪","\\ntriangleleft");n(l,d,f,"⋬","\\ntrianglelefteq",!0);n(l,d,f,"⊊","\\subsetneq",!0);n(l,d,f,"","\\@varsubsetneq");n(l,d,f,"⫋","\\subsetneqq",!0);n(l,d,f,"","\\@varsubsetneqq");n(l,d,f,"≯","\\ngtr",!0);n(l,d,f,"","\\@ngeqslant");n(l,d,f,"","\\@ngeqq");n(l,d,f,"⪈","\\gneq",!0);n(l,d,f,"≩","\\gneqq",!0);n(l,d,f,"","\\@gvertneqq");n(l,d,f,"⋧","\\gnsim",!0);n(l,d,f,"⪊","\\gnapprox",!0);n(l,d,f,"⊁","\\nsucc",!0);n(l,d,f,"⋡","\\nsucceq",!0);n(l,d,f,"⋩","\\succnsim",!0);n(l,d,f,"⪺","\\succnapprox",!0);n(l,d,f,"≆","\\ncong",!0);n(l,d,f,"","\\@nshortparallel");n(l,d,f,"∦","\\nparallel",!0);n(l,d,f,"⊯","\\nVDash",!0);n(l,d,f,"⋫","\\ntriangleright");n(l,d,f,"⋭","\\ntrianglerighteq",!0);n(l,d,f,"","\\@nsupseteqq");n(l,d,f,"⊋","\\supsetneq",!0);n(l,d,f,"","\\@varsupsetneq");n(l,d,f,"⫌","\\supsetneqq",!0);n(l,d,f,"","\\@varsupsetneqq");n(l,d,f,"⊮","\\nVdash",!0);n(l,d,f,"⪵","\\precneqq",!0);n(l,d,f,"⪶","\\succneqq",!0);n(l,d,f,"","\\@nsubseteqq");n(l,d,D,"⊴","\\unlhd");n(l,d,D,"⊵","\\unrhd");n(l,d,f,"↚","\\nleftarrow",!0);n(l,d,f,"↛","\\nrightarrow",!0);n(l,d,f,"⇍","\\nLeftarrow",!0);n(l,d,f,"⇏","\\nRightarrow",!0);n(l,d,f,"↮","\\nleftrightarrow",!0);n(l,d,f,"⇎","\\nLeftrightarrow",!0);n(l,d,f,"△","\\vartriangle");n(l,d,g,"ℏ","\\hslash");n(l,d,g,"▽","\\triangledown");n(l,d,g,"◊","\\lozenge");n(l,d,g,"Ⓢ","\\circledS");n(l,d,g,"®","\\circledR");n(w,d,g,"®","\\circledR");n(l,d,g,"∡","\\measuredangle",!0);n(l,d,g,"∄","\\nexists");n(l,d,g,"℧","\\mho");n(l,d,g,"Ⅎ","\\Finv",!0);n(l,d,g,"⅁","\\Game",!0);n(l,d,g,"‵","\\backprime");n(l,d,g,"▲","\\blacktriangle");n(l,d,g,"▼","\\blacktriangledown");n(l,d,g,"■","\\blacksquare");n(l,d,g,"⧫","\\blacklozenge");n(l,d,g,"★","\\bigstar");n(l,d,g,"∢","\\sphericalangle",!0);n(l,d,g,"∁","\\complement",!0);n(l,d,g,"ð","\\eth",!0);n(w,o,g,"ð","ð");n(l,d,g,"╱","\\diagup");n(l,d,g,"╲","\\diagdown");n(l,d,g,"□","\\square");n(l,d,g,"□","\\Box");n(l,d,g,"◊","\\Diamond");n(l,d,g,"¥","\\yen",!0);n(w,d,g,"¥","\\yen",!0);n(l,d,g,"✓","\\checkmark",!0);n(w,d,g,"✓","\\checkmark");n(l,d,g,"ℶ","\\beth",!0);n(l,d,g,"ℸ","\\daleth",!0);n(l,d,g,"ℷ","\\gimel",!0);n(l,d,g,"ϝ","\\digamma",!0);n(l,d,g,"ϰ","\\varkappa");n(l,d,f0,"┌","\\@ulcorner",!0);n(l,d,u0,"┐","\\@urcorner",!0);n(l,d,f0,"└","\\@llcorner",!0);n(l,d,u0,"┘","\\@lrcorner",!0);n(l,d,f,"≦","\\leqq",!0);n(l,d,f,"⩽","\\leqslant",!0);n(l,d,f,"⪕","\\eqslantless",!0);n(l,d,f,"≲","\\lesssim",!0);n(l,d,f,"⪅","\\lessapprox",!0);n(l,d,f,"≊","\\approxeq",!0);n(l,d,D,"⋖","\\lessdot");n(l,d,f,"⋘","\\lll",!0);n(l,d,f,"≶","\\lessgtr",!0);n(l,d,f,"⋚","\\lesseqgtr",!0);n(l,d,f,"⪋","\\lesseqqgtr",!0);n(l,d,f,"≑","\\doteqdot");n(l,d,f,"≓","\\risingdotseq",!0);n(l,d,f,"≒","\\fallingdotseq",!0);n(l,d,f,"∽","\\backsim",!0);n(l,d,f,"⋍","\\backsimeq",!0);n(l,d,f,"⫅","\\subseteqq",!0);n(l,d,f,"⋐","\\Subset",!0);n(l,d,f,"⊏","\\sqsubset",!0);n(l,d,f,"≼","\\preccurlyeq",!0);n(l,d,f,"⋞","\\curlyeqprec",!0);n(l,d,f,"≾","\\precsim",!0);n(l,d,f,"⪷","\\precapprox",!0);n(l,d,f,"⊲","\\vartriangleleft");n(l,d,f,"⊴","\\trianglelefteq");n(l,d,f,"⊨","\\vDash",!0);n(l,d,f,"⊪","\\Vvdash",!0);n(l,d,f,"⌣","\\smallsmile");n(l,d,f,"⌢","\\smallfrown");n(l,d,f,"≏","\\bumpeq",!0);n(l,d,f,"≎","\\Bumpeq",!0);n(l,d,f,"≧","\\geqq",!0);n(l,d,f,"⩾","\\geqslant",!0);n(l,d,f,"⪖","\\eqslantgtr",!0);n(l,d,f,"≳","\\gtrsim",!0);n(l,d,f,"⪆","\\gtrapprox",!0);n(l,d,D,"⋗","\\gtrdot");n(l,d,f,"⋙","\\ggg",!0);n(l,d,f,"≷","\\gtrless",!0);n(l,d,f,"⋛","\\gtreqless",!0);n(l,d,f,"⪌","\\gtreqqless",!0);n(l,d,f,"≖","\\eqcirc",!0);n(l,d,f,"≗","\\circeq",!0);n(l,d,f,"≜","\\triangleq",!0);n(l,d,f,"∼","\\thicksim");n(l,d,f,"≈","\\thickapprox");n(l,d,f,"⫆","\\supseteqq",!0);n(l,d,f,"⋑","\\Supset",!0);n(l,d,f,"⊐","\\sqsupset",!0);n(l,d,f,"≽","\\succcurlyeq",!0);n(l,d,f,"⋟","\\curlyeqsucc",!0);n(l,d,f,"≿","\\succsim",!0);n(l,d,f,"⪸","\\succapprox",!0);n(l,d,f,"⊳","\\vartriangleright");n(l,d,f,"⊵","\\trianglerighteq");n(l,d,f,"⊩","\\Vdash",!0);n(l,d,f,"∣","\\shortmid");n(l,d,f,"∥","\\shortparallel");n(l,d,f,"≬","\\between",!0);n(l,d,f,"⋔","\\pitchfork",!0);n(l,d,f,"∝","\\varpropto");n(l,d,f,"◀","\\blacktriangleleft");n(l,d,f,"∴","\\therefore",!0);n(l,d,f,"∍","\\backepsilon");n(l,d,f,"▶","\\blacktriangleright");n(l,d,f,"∵","\\because",!0);n(l,d,f,"⋘","\\llless");n(l,d,f,"⋙","\\gggtr");n(l,d,D,"⊲","\\lhd");n(l,d,D,"⊳","\\rhd");n(l,d,f,"≂","\\eqsim",!0);n(l,o,f,"⋈","\\Join");n(l,d,f,"≑","\\Doteq",!0);n(l,d,D,"∔","\\dotplus",!0);n(l,d,D,"∖","\\smallsetminus");n(l,d,D,"⋒","\\Cap",!0);n(l,d,D,"⋓","\\Cup",!0);n(l,d,D,"⩞","\\doublebarwedge",!0);n(l,d,D,"⊟","\\boxminus",!0);n(l,d,D,"⊞","\\boxplus",!0);n(l,d,D,"⋇","\\divideontimes",!0);n(l,d,D,"⋉","\\ltimes",!0);n(l,d,D,"⋊","\\rtimes",!0);n(l,d,D,"⋋","\\leftthreetimes",!0);n(l,d,D,"⋌","\\rightthreetimes",!0);n(l,d,D,"⋏","\\curlywedge",!0);n(l,d,D,"⋎","\\curlyvee",!0);n(l,d,D,"⊝","\\circleddash",!0);n(l,d,D,"⊛","\\circledast",!0);n(l,d,D,"⋅","\\centerdot");n(l,d,D,"⊺","\\intercal",!0);n(l,d,D,"⋒","\\doublecap");n(l,d,D,"⋓","\\doublecup");n(l,d,D,"⊠","\\boxtimes",!0);n(l,d,f,"⇢","\\dashrightarrow",!0);n(l,d,f,"⇠","\\dashleftarrow",!0);n(l,d,f,"⇇","\\leftleftarrows",!0);n(l,d,f,"⇆","\\leftrightarrows",!0);n(l,d,f,"⇚","\\Lleftarrow",!0);n(l,d,f,"↞","\\twoheadleftarrow",!0);n(l,d,f,"↢","\\leftarrowtail",!0);n(l,d,f,"↫","\\looparrowleft",!0);n(l,d,f,"⇋","\\leftrightharpoons",!0);n(l,d,f,"↶","\\curvearrowleft",!0);n(l,d,f,"↺","\\circlearrowleft",!0);n(l,d,f,"↰","\\Lsh",!0);n(l,d,f,"⇈","\\upuparrows",!0);n(l,d,f,"↿","\\upharpoonleft",!0);n(l,d,f,"⇃","\\downharpoonleft",!0);n(l,o,f,"⊶","\\origof",!0);n(l,o,f,"⊷","\\imageof",!0);n(l,d,f,"⊸","\\multimap",!0);n(l,d,f,"↭","\\leftrightsquigarrow",!0);n(l,d,f,"⇉","\\rightrightarrows",!0);n(l,d,f,"⇄","\\rightleftarrows",!0);n(l,d,f,"↠","\\twoheadrightarrow",!0);n(l,d,f,"↣","\\rightarrowtail",!0);n(l,d,f,"↬","\\looparrowright",!0);n(l,d,f,"↷","\\curvearrowright",!0);n(l,d,f,"↻","\\circlearrowright",!0);n(l,d,f,"↱","\\Rsh",!0);n(l,d,f,"⇊","\\downdownarrows",!0);n(l,d,f,"↾","\\upharpoonright",!0);n(l,d,f,"⇂","\\downharpoonright",!0);n(l,d,f,"⇝","\\rightsquigarrow",!0);n(l,d,f,"⇝","\\leadsto");n(l,d,f,"⇛","\\Rrightarrow",!0);n(l,d,f,"↾","\\restriction");n(l,o,g,"‘","`");n(l,o,g,"$","\\$");n(w,o,g,"$","\\$");n(w,o,g,"$","\\textdollar");n(l,o,g,"%","\\%");n(w,o,g,"%","\\%");n(l,o,g,"_","\\_");n(w,o,g,"_","\\_");n(w,o,g,"_","\\textunderscore");n(l,o,g,"∠","\\angle",!0);n(l,o,g,"∞","\\infty",!0);n(l,o,g,"′","\\prime");n(l,o,g,"△","\\triangle");n(l,o,g,"Γ","\\Gamma",!0);n(l,o,g,"Δ","\\Delta",!0);n(l,o,g,"Θ","\\Theta",!0);n(l,o,g,"Λ","\\Lambda",!0);n(l,o,g,"Ξ","\\Xi",!0);n(l,o,g,"Π","\\Pi",!0);n(l,o,g,"Σ","\\Sigma",!0);n(l,o,g,"Υ","\\Upsilon",!0);n(l,o,g,"Φ","\\Phi",!0);n(l,o,g,"Ψ","\\Psi",!0);n(l,o,g,"Ω","\\Omega",!0);n(l,o,g,"A","Α");n(l,o,g,"B","Β");n(l,o,g,"E","Ε");n(l,o,g,"Z","Ζ");n(l,o,g,"H","Η");n(l,o,g,"I","Ι");n(l,o,g,"K","Κ");n(l,o,g,"M","Μ");n(l,o,g,"N","Ν");n(l,o,g,"O","Ο");n(l,o,g,"P","Ρ");n(l,o,g,"T","Τ");n(l,o,g,"X","Χ");n(l,o,g,"¬","\\neg",!0);n(l,o,g,"¬","\\lnot");n(l,o,g,"⊤","\\top");n(l,o,g,"⊥","\\bot");n(l,o,g,"∅","\\emptyset");n(l,d,g,"∅","\\varnothing");n(l,o,E,"α","\\alpha",!0);n(l,o,E,"β","\\beta",!0);n(l,o,E,"γ","\\gamma",!0);n(l,o,E,"δ","\\delta",!0);n(l,o,E,"ϵ","\\epsilon",!0);n(l,o,E,"ζ","\\zeta",!0);n(l,o,E,"η","\\eta",!0);n(l,o,E,"θ","\\theta",!0);n(l,o,E,"ι","\\iota",!0);n(l,o,E,"κ","\\kappa",!0);n(l,o,E,"λ","\\lambda",!0);n(l,o,E,"μ","\\mu",!0);n(l,o,E,"ν","\\nu",!0);n(l,o,E,"ξ","\\xi",!0);n(l,o,E,"ο","\\omicron",!0);n(l,o,E,"π","\\pi",!0);n(l,o,E,"ρ","\\rho",!0);n(l,o,E,"σ","\\sigma",!0);n(l,o,E,"τ","\\tau",!0);n(l,o,E,"υ","\\upsilon",!0);n(l,o,E,"ϕ","\\phi",!0);n(l,o,E,"χ","\\chi",!0);n(l,o,E,"ψ","\\psi",!0);n(l,o,E,"ω","\\omega",!0);n(l,o,E,"ε","\\varepsilon",!0);n(l,o,E,"ϑ","\\vartheta",!0);n(l,o,E,"ϖ","\\varpi",!0);n(l,o,E,"ϱ","\\varrho",!0);n(l,o,E,"ς","\\varsigma",!0);n(l,o,E,"φ","\\varphi",!0);n(l,o,D,"∗","*",!0);n(l,o,D,"+","+");n(l,o,D,"−","-",!0);n(l,o,D,"⋅","\\cdot",!0);n(l,o,D,"∘","\\circ",!0);n(l,o,D,"÷","\\div",!0);n(l,o,D,"±","\\pm",!0);n(l,o,D,"×","\\times",!0);n(l,o,D,"∩","\\cap",!0);n(l,o,D,"∪","\\cup",!0);n(l,o,D,"∖","\\setminus",!0);n(l,o,D,"∧","\\land");n(l,o,D,"∨","\\lor");n(l,o,D,"∧","\\wedge",!0);n(l,o,D,"∨","\\vee",!0);n(l,o,g,"√","\\surd");n(l,o,f0,"⟨","\\langle",!0);n(l,o,f0,"∣","\\lvert");n(l,o,f0,"∥","\\lVert");n(l,o,u0,"?","?");n(l,o,u0,"!","!");n(l,o,u0,"⟩","\\rangle",!0);n(l,o,u0,"∣","\\rvert");n(l,o,u0,"∥","\\rVert");n(l,o,f,"=","=");n(l,o,f,":",":");n(l,o,f,"≈","\\approx",!0);n(l,o,f,"≅","\\cong",!0);n(l,o,f,"≥","\\ge");n(l,o,f,"≥","\\geq",!0);n(l,o,f,"←","\\gets");n(l,o,f,">","\\gt",!0);n(l,o,f,"∈","\\in",!0);n(l,o,f,"","\\@not");n(l,o,f,"⊂","\\subset",!0);n(l,o,f,"⊃","\\supset",!0);n(l,o,f,"⊆","\\subseteq",!0);n(l,o,f,"⊇","\\supseteq",!0);n(l,d,f,"⊈","\\nsubseteq",!0);n(l,d,f,"⊉","\\nsupseteq",!0);n(l,o,f,"⊨","\\models");n(l,o,f,"←","\\leftarrow",!0);n(l,o,f,"≤","\\le");n(l,o,f,"≤","\\leq",!0);n(l,o,f,"<","\\lt",!0);n(l,o,f,"→","\\rightarrow",!0);n(l,o,f,"→","\\to");n(l,d,f,"≱","\\ngeq",!0);n(l,d,f,"≰","\\nleq",!0);n(l,o,q0," ","\\ ");n(l,o,q0," ","\\space");n(l,o,q0," ","\\nobreakspace");n(w,o,q0," ","\\ ");n(w,o,q0," "," ");n(w,o,q0," ","\\space");n(w,o,q0," ","\\nobreakspace");n(l,o,q0,"","\\nobreak");n(l,o,q0,"","\\allowbreak");n(l,o,de,",",",");n(l,o,de,";",";");n(l,d,D,"⊼","\\barwedge",!0);n(l,d,D,"⊻","\\veebar",!0);n(l,o,D,"⊙","\\odot",!0);n(l,o,D,"⊕","\\oplus",!0);n(l,o,D,"⊗","\\otimes",!0);n(l,o,g,"∂","\\partial",!0);n(l,o,D,"⊘","\\oslash",!0);n(l,d,D,"⊚","\\circledcirc",!0);n(l,d,D,"⊡","\\boxdot",!0);n(l,o,D,"△","\\bigtriangleup");n(l,o,D,"▽","\\bigtriangledown");n(l,o,D,"†","\\dagger");n(l,o,D,"⋄","\\diamond");n(l,o,D,"⋆","\\star");n(l,o,D,"◃","\\triangleleft");n(l,o,D,"▹","\\triangleright");n(l,o,f0,"{","\\{");n(w,o,g,"{","\\{");n(w,o,g,"{","\\textbraceleft");n(l,o,u0,"}","\\}");n(w,o,g,"}","\\}");n(w,o,g,"}","\\textbraceright");n(l,o,f0,"{","\\lbrace");n(l,o,u0,"}","\\rbrace");n(l,o,f0,"[","\\lbrack",!0);n(w,o,g,"[","\\lbrack",!0);n(l,o,u0,"]","\\rbrack",!0);n(w,o,g,"]","\\rbrack",!0);n(l,o,f0,"(","\\lparen",!0);n(l,o,u0,")","\\rparen",!0);n(w,o,g,"<","\\textless",!0);n(w,o,g,">","\\textgreater",!0);n(l,o,f0,"⌊","\\lfloor",!0);n(l,o,u0,"⌋","\\rfloor",!0);n(l,o,f0,"⌈","\\lceil",!0);n(l,o,u0,"⌉","\\rceil",!0);n(l,o,g,"\\","\\backslash");n(l,o,g,"∣","|");n(l,o,g,"∣","\\vert");n(w,o,g,"|","\\textbar",!0);n(l,o,g,"∥","\\|");n(l,o,g,"∥","\\Vert");n(w,o,g,"∥","\\textbardbl");n(w,o,g,"~","\\textasciitilde");n(w,o,g,"\\","\\textbackslash");n(w,o,g,"^","\\textasciicircum");n(l,o,f,"↑","\\uparrow",!0);n(l,o,f,"⇑","\\Uparrow",!0);n(l,o,f,"↓","\\downarrow",!0);n(l,o,f,"⇓","\\Downarrow",!0);n(l,o,f,"↕","\\updownarrow",!0);n(l,o,f,"⇕","\\Updownarrow",!0);n(l,o,t0,"∐","\\coprod");n(l,o,t0,"⋁","\\bigvee");n(l,o,t0,"⋀","\\bigwedge");n(l,o,t0,"⨄","\\biguplus");n(l,o,t0,"⋂","\\bigcap");n(l,o,t0,"⋃","\\bigcup");n(l,o,t0,"∫","\\int");n(l,o,t0,"∫","\\intop");n(l,o,t0,"∬","\\iint");n(l,o,t0,"∭","\\iiint");n(l,o,t0,"∏","\\prod");n(l,o,t0,"∑","\\sum");n(l,o,t0,"⨂","\\bigotimes");n(l,o,t0,"⨁","\\bigoplus");n(l,o,t0,"⨀","\\bigodot");n(l,o,t0,"∮","\\oint");n(l,o,t0,"∯","\\oiint");n(l,o,t0,"∰","\\oiiint");n(l,o,t0,"⨆","\\bigsqcup");n(l,o,t0,"∫","\\smallint");n(w,o,ne,"…","\\textellipsis");n(l,o,ne,"…","\\mathellipsis");n(w,o,ne,"…","\\ldots",!0);n(l,o,ne,"…","\\ldots",!0);n(l,o,ne,"⋯","\\@cdots",!0);n(l,o,ne,"⋱","\\ddots",!0);n(l,o,g,"⋮","\\varvdots");n(w,o,g,"⋮","\\varvdots");n(l,o,j,"ˊ","\\acute");n(l,o,j,"ˋ","\\grave");n(l,o,j,"¨","\\ddot");n(l,o,j,"~","\\tilde");n(l,o,j,"ˉ","\\bar");n(l,o,j,"˘","\\breve");n(l,o,j,"ˇ","\\check");n(l,o,j,"^","\\hat");n(l,o,j,"⃗","\\vec");n(l,o,j,"˙","\\dot");n(l,o,j,"˚","\\mathring");n(l,o,E,"","\\@imath");n(l,o,E,"","\\@jmath");n(l,o,g,"ı","ı");n(l,o,g,"ȷ","ȷ");n(w,o,g,"ı","\\i",!0);n(w,o,g,"ȷ","\\j",!0);n(w,o,g,"ß","\\ss",!0);n(w,o,g,"æ","\\ae",!0);n(w,o,g,"œ","\\oe",!0);n(w,o,g,"ø","\\o",!0);n(w,o,g,"Æ","\\AE",!0);n(w,o,g,"Œ","\\OE",!0);n(w,o,g,"Ø","\\O",!0);n(w,o,j,"ˊ","\\'");n(w,o,j,"ˋ","\\`");n(w,o,j,"ˆ","\\^");n(w,o,j,"˜","\\~");n(w,o,j,"ˉ","\\=");n(w,o,j,"˘","\\u");n(w,o,j,"˙","\\.");n(w,o,j,"¸","\\c");n(w,o,j,"˚","\\r");n(w,o,j,"ˇ","\\v");n(w,o,j,"¨",'\\"');n(w,o,j,"˝","\\H");n(w,o,j,"◯","\\textcircled");var $r={"--":!0,"---":!0,"``":!0,"''":!0};n(w,o,g,"–","--",!0);n(w,o,g,"–","\\textendash");n(w,o,g,"—","---",!0);n(w,o,g,"—","\\textemdash");n(w,o,g,"‘","`",!0);n(w,o,g,"‘","\\textquoteleft");n(w,o,g,"’","'",!0);n(w,o,g,"’","\\textquoteright");n(w,o,g,"“","``",!0);n(w,o,g,"“","\\textquotedblleft");n(w,o,g,"”","''",!0);n(w,o,g,"”","\\textquotedblright");n(l,o,g,"°","\\degree",!0);n(w,o,g,"°","\\degree");n(w,o,g,"°","\\textdegree",!0);n(l,o,g,"£","\\pounds");n(l,o,g,"£","\\mathsterling",!0);n(w,o,g,"£","\\pounds");n(w,o,g,"£","\\textsterling",!0);n(l,d,g,"✠","\\maltese");n(w,d,g,"✠","\\maltese");var nr='0123456789/@."';for(var Qe=0;Qe{var e=r.charCodeAt(0),t=r.charCodeAt(1),a=(e-55296)*1024+(t-56320)+65536;if(119808<=a&&a<120484){var i=Math.floor((a-119808)/26);return vr[i]}else if(120782<=a&&a<=120831){var s=Math.floor((a-120782)/10);return Ba[s]}else{if(a===120485||a===120486)return vr[0];if(120486{if(L0(r.classes)!==L0(e.classes)||r.skew!==e.skew||r.maxFontSize!==e.maxFontSize||r.italic!==0&&r.hasClass("mathnormal"))return!1;if(r.classes.length===1){var t=r.classes[0];if(t==="mbin"||t==="mord")return!1}for(var a of Object.keys(r.style))if(r.style[a]!==e.style[a])return!1;for(var i of Object.keys(e.style))if(r.style[i]!==e.style[i])return!1;return!0},Wr=r=>{for(var e=0;et&&(t=u.height),u.depth>a&&(a=u.depth),u.maxFontSize>i&&(i=u.maxFontSize)}e.height=t,e.depth=a,e.maxFontSize=i},k=function(e,t,a,i){var s=new ie(e,t,a,i);return Ht(s),s},G0=(r,e,t,a)=>new ie(r,e,t,a),te=function(e,t,a){var i=k([e],[],t);return i.height=Math.max(a||t.fontMetrics().defaultRuleThickness,t.minRuleThickness),i.style.borderBottomWidth=A(i.height),i.maxFontSize=1,i},Ea=function(e,t,a,i){var s=new Fe(e,t,a,i);return Ht(s),s},E0=function(e){var t=new ae(e);return Ht(t),t},re=function(e,t){return e instanceof ae?k([],[e],t):e},Ra=function(e){if(e.positionType==="individualShift"){for(var t=e.children,a=[t[0]],i=-t[0].shift-t[0].elem.depth,s=i,u=1;u{var t=k(["mspace"],[],e),a=K(r,e);return t.style.marginRight=A(a),t},ze=(r,e,t)=>{var a,i;switch(r){case"amsrm":a="AMS";break;case"textrm":a="Main";break;case"textsf":a="SansSerif";break;case"texttt":a="Typewriter";break;default:a=r}return e==="textbf"&&t==="textit"?i="BoldItalic":e==="textbf"?i="Bold":t==="textit"?i="Italic":i="Regular",a+"-"+i},kt={mathbf:{variant:"bold",fontName:"Main-Bold"},mathrm:{variant:"normal",fontName:"Main-Regular"},textit:{variant:"italic",fontName:"Main-Italic"},mathit:{variant:"italic",fontName:"Main-Italic"},mathnormal:{variant:"italic",fontName:"Math-Italic"},mathsfit:{variant:"sans-serif-italic",fontName:"SansSerif-Italic"},mathbb:{variant:"double-struck",fontName:"AMS-Regular"},mathcal:{variant:"script",fontName:"Caligraphic-Regular"},mathfrak:{variant:"fraktur",fontName:"Fraktur-Regular"},mathscr:{variant:"script",fontName:"Script-Regular"},mathsf:{variant:"sans-serif",fontName:"SansSerif-Regular"},mathtt:{variant:"monospace",fontName:"Typewriter-Regular"}},Zr={vec:["vec",.471,.714],oiintSize1:["oiintSize1",.957,.499],oiintSize2:["oiintSize2",1.472,.659],oiiintSize1:["oiiintSize1",1.304,.499],oiiintSize2:["oiiintSize2",1.98,.659]},Kr=function(e,t){var[a,i,s]=Zr[e],u=new P0(a),h=new C0([u],{width:A(i),height:A(s),style:"width:"+A(i),viewBox:"0 0 "+1e3*i+" "+1e3*s,preserveAspectRatio:"xMinYMin"}),c=G0(["overlay"],[h],t);return c.height=s,c.style.height=A(s),c.style.width=A(i),c},Z={number:3,unit:"mu"},Y0={number:4,unit:"mu"},M0={number:5,unit:"mu"},Ia={mord:{mop:Z,mbin:Y0,mrel:M0,minner:Z},mop:{mord:Z,mop:Z,mrel:M0,minner:Z},mbin:{mord:Y0,mop:Y0,mopen:Y0,minner:Y0},mrel:{mord:M0,mop:M0,mopen:M0,minner:M0},mopen:{},mclose:{mop:Z,mbin:Y0,mrel:M0,minner:Z},mpunct:{mord:Z,mop:Z,mrel:M0,mopen:Z,mclose:Z,mpunct:Z,minner:Z},minner:{mord:Z,mop:Z,mbin:Y0,mrel:M0,mopen:Z,mpunct:Z,minner:Z}},Na={mord:{mop:Z},mop:{mord:Z,mop:Z},mbin:{},mrel:{},mopen:{},mclose:{mop:Z},mpunct:{},minner:{mop:Z}},Jr={},Re={},Ie={};function B(r){for(var{type:e,names:t,props:a,handler:i,htmlBuilder:s,mathmlBuilder:u}=r,h={type:e,numArgs:a.numArgs,argTypes:a.argTypes,allowedInArgument:!!a.allowedInArgument,allowedInText:!!a.allowedInText,allowedInMath:a.allowedInMath===void 0?!0:a.allowedInMath,numOptionalArgs:a.numOptionalArgs||0,infix:!!a.infix,primitive:!!a.primitive,handler:i},c=0;c{var q=M.classes[0],C=T.classes[0];q==="mbin"&&Ha.has(C)?M.classes[0]="mord":C==="mbin"&&Fa.has(q)&&(T.classes[0]="mord")},{node:b},x,y),St(s,(T,M)=>{var q,C,R=At(M),F=At(T),L=R&&F?T.hasClass("mtight")?(q=Na[R])==null?void 0:q[F]:(C=Ia[R])==null?void 0:C[F]:null;if(L)return jr(L,v)},{node:b},x,y),s},St=function(e,t,a,i,s){i&&e.push(i);for(var u=0;ux=>{e.splice(b+1,0,x),u++})(u)}i&&e.pop()},Qr=function(e){return e instanceof ae||e instanceof Fe||e instanceof ie&&e.hasClass("enclosing")?e:null},zt=function(e,t){var a=Qr(e);if(a){var i=a.children;if(i.length){if(t==="right")return zt(i[i.length-1],"right");if(t==="left")return zt(i[0],"left")}}return e},At=function(e,t){if(!e)return null;t&&(e=zt(e,t));var a=e.classes[0];return La[a]||null},ce=function(e,t){var a=["nulldelimiter"].concat(e.baseSizingClasses());return k(t.concat(a))},X=function(e,t,a){if(!e)return k();if(Re[e.type]){var i=Re[e.type](e,t);if(a&&t.size!==a.size){i=k(t.sizingClasses(a),[i],t);var s=t.sizeMultiplier/a.sizeMultiplier;i.height*=s,i.depth*=s}return i}else throw new S("Got group of unknown type: '"+e.type+"'")};function Ae(r,e){var t=k(["base"],r,e),a=k(["strut"]);return a.style.height=A(t.height+t.depth),t.depth&&(a.style.verticalAlign=A(-t.depth)),t.children.unshift(a),t}function Mt(r,e){var t=null;r.length===1&&r[0].type==="tag"&&(t=r[0].tag,r=r[0].body);var a=a0(r,e,"root"),i;a.length===2&&a[1].hasClass("tag")&&(i=a.pop());for(var s=[],u=[],h=0;h0&&(s.push(Ae(u,e)),u=[]),s.push(a[h]));u.length>0&&s.push(Ae(u,e));var v;t?(v=Ae(a0(t,e,!0),e),v.classes=["tag"],s.push(v)):i&&s.push(i);var p=k(["katex-html"],s);if(p.setAttribute("aria-hidden","true"),v){var b=v.children[0];b.style.height=A(p.height+p.depth),p.depth&&(b.style.verticalAlign=A(-p.depth))}return p}function _r(r){return new ae(r)}class z{constructor(e,t,a){this.type=void 0,this.attributes=void 0,this.children=void 0,this.classes=void 0,this.type=e,this.attributes={},this.children=t||[],this.classes=a||[]}setAttribute(e,t){this.attributes[e]=t}getAttribute(e){return this.attributes[e]}toNode(){var e=document.createElementNS("http://www.w3.org/1998/Math/MathML",this.type);for(var t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&e.setAttribute(t,this.attributes[t]);this.classes.length>0&&(e.className=L0(this.classes));for(var a=0;a0&&(e+=' class ="'+i0(L0(this.classes))+'"'),e+=">";for(var a=0;a",e}toText(){return this.children.map(e=>e.toText()).join("")}}class e0{constructor(e){this.text=void 0,this.text=e}toNode(){return document.createTextNode(this.text)}toMarkup(){return i0(this.toText())}toText(){return this.text}}class e1{constructor(e){this.width=void 0,this.character=void 0,this.width=e,e>=.05555&&e<=.05556?this.character=" ":e>=.1666&&e<=.1667?this.character=" ":e>=.2222&&e<=.2223?this.character=" ":e>=.2777&&e<=.2778?this.character="  ":e>=-.05556&&e<=-.05555?this.character=" ⁣":e>=-.1667&&e<=-.1666?this.character=" ⁣":e>=-.2223&&e<=-.2222?this.character=" ⁣":e>=-.2778&&e<=-.2777?this.character=" ⁣":this.character=null}toNode(){if(this.character)return document.createTextNode(this.character);var e=document.createElementNS("http://www.w3.org/1998/Math/MathML","mspace");return e.setAttribute("width",A(this.width)),e}toMarkup(){return this.character?""+this.character+"":''}toText(){return this.character?this.character:" "}}var Pa=new Set(["\\imath","\\jmath"]),Ga=new Set(["mrow","mtable"]),g0=function(e,t,a){return W[t][e]&&W[t][e].replace&&e.charCodeAt(0)!==55349&&!($r.hasOwnProperty(e)&&a&&(a.fontFamily&&a.fontFamily.slice(4,6)==="tt"||a.font&&a.font.slice(4,6)==="tt"))&&(e=W[t][e].replace),new e0(e)},Ot=function(e){return e.length===1?e[0]:new z("mrow",e)},Ua={mathit:"italic",boldsymbol:r=>r.type==="textord"?"bold":"bold-italic",mathbf:"bold",mathbb:"double-struck",mathsfit:"sans-serif-italic",mathfrak:"fraktur",mathscr:"script",mathcal:"script",mathsf:"sans-serif",mathtt:"monospace"},Lt=(r,e)=>{if(r.mode==="text"){if(e.fontFamily==="texttt")return"monospace";if(e.fontFamily==="textsf")return e.fontShape==="textit"&&e.fontWeight==="textbf"?"sans-serif-bold-italic":e.fontShape==="textit"?"sans-serif-italic":e.fontWeight==="textbf"?"bold-sans-serif":"sans-serif";if(e.fontShape==="textit"&&e.fontWeight==="textbf")return"bold-italic";if(e.fontShape==="textit")return"italic";if(e.fontWeight==="textbf")return"bold"}var t=e.font;if(!t||t==="mathnormal")return null;var a=r.mode,i=Ua[t];if(i)return typeof i=="function"?i(r):i;var s=r.text;if(Pa.has(s))return null;if(W[a][s]){var u=W[a][s].replace;u&&(s=u)}var h=kt[t].fontName;return Nt(s,h,a)?kt[t].variant:null};function rt(r){if(!r)return!1;if(r.type==="mi"&&r.children.length===1){var e=r.children[0];return e instanceof e0&&e.text==="."}else if(r.type==="mo"&&r.children.length===1&&r.getAttribute("separator")==="true"&&r.getAttribute("lspace")==="0em"&&r.getAttribute("rspace")==="0em"){var t=r.children[0];return t instanceof e0&&t.text===","}else return!1}var v0=function(e,t,a){if(e.length===1){var i=$(e[0],t);return a&&i instanceof z&&i.type==="mo"&&(i.setAttribute("lspace","0em"),i.setAttribute("rspace","0em")),[i]}for(var s=[],u,h=0;h=1&&(u.type==="mn"||rt(u))){var v=c.children[0];v instanceof z&&v.type==="mn"&&(v.children=[...u.children,...v.children],s.pop())}else if(u.type==="mi"&&u.children.length===1){var p=u.children[0];if(p instanceof e0&&p.text==="̸"&&(c.type==="mo"||c.type==="mi"||c.type==="mn")){var b=c.children[0];b instanceof e0&&b.text.length>0&&(b.text=b.text.slice(0,1)+"̸"+b.text.slice(1),s.pop())}}}s.push(c),u=c}return s},U0=function(e,t,a){return Ot(v0(e,t,a))},$=function(e,t){if(!e)return new z("mrow");if(Ie[e.type])return Ie[e.type](e,t);throw new S("Got group of unknown type: '"+e.type+"'")};function pr(r,e,t,a,i){var s=v0(r,t),u;s.length===1&&s[0]instanceof z&&Ga.has(s[0].type)?u=s[0]:u=new z("mrow",s);var h=new z("annotation",[new e0(e)]);h.setAttribute("encoding","application/x-tex");var c=new z("semantics",[u,h]),v=new z("math",[c]);v.setAttribute("xmlns","http://www.w3.org/1998/Math/MathML"),a&&v.setAttribute("display","block");var p=i?"katex":"katex-mathml";return k([p],[v])}var Va=[[1,1,1],[2,1,1],[3,1,1],[4,2,1],[5,2,1],[6,3,1],[7,4,2],[8,6,3],[9,7,6],[10,8,7],[11,10,9]],gr=[.5,.6,.7,.8,.9,1,1.2,1.44,1.728,2.074,2.488],br=function(e,t){return t.size<2?e:Va[e-1][t.size-1]};class T0{constructor(e){this.style=void 0,this.color=void 0,this.size=void 0,this.textSize=void 0,this.phantom=void 0,this.font=void 0,this.fontFamily=void 0,this.fontWeight=void 0,this.fontShape=void 0,this.sizeMultiplier=void 0,this.maxSize=void 0,this.minRuleThickness=void 0,this._fontMetrics=void 0,this.style=e.style,this.color=e.color,this.size=e.size||T0.BASESIZE,this.textSize=e.textSize||this.size,this.phantom=!!e.phantom,this.font=e.font||"",this.fontFamily=e.fontFamily||"",this.fontWeight=e.fontWeight||"",this.fontShape=e.fontShape||"",this.sizeMultiplier=gr[this.size-1],this.maxSize=e.maxSize,this.minRuleThickness=e.minRuleThickness,this._fontMetrics=void 0}extend(e){var t={style:this.style,size:this.size,textSize:this.textSize,color:this.color,phantom:this.phantom,font:this.font,fontFamily:this.fontFamily,fontWeight:this.fontWeight,fontShape:this.fontShape,maxSize:this.maxSize,minRuleThickness:this.minRuleThickness};return Object.assign(t,e),new T0(t)}havingStyle(e){return this.style===e?this:this.extend({style:e,size:br(this.textSize,e)})}havingCrampedStyle(){return this.havingStyle(this.style.cramp())}havingSize(e){return this.size===e&&this.textSize===e?this:this.extend({style:this.style.text(),size:e,textSize:e,sizeMultiplier:gr[e-1]})}havingBaseStyle(e){e=e||this.style.text();var t=br(T0.BASESIZE,e);return this.size===t&&this.textSize===T0.BASESIZE&&this.style===e?this:this.extend({style:e,size:t})}havingBaseSizing(){var e;switch(this.style.id){case 4:case 5:e=3;break;case 6:case 7:e=1;break;default:e=6}return this.extend({style:this.style.text(),size:e})}withColor(e){return this.extend({color:e})}withPhantom(){return this.extend({phantom:!0})}withFont(e){return this.extend({font:e})}withTextFontFamily(e){return this.extend({fontFamily:e,font:""})}withTextFontWeight(e){return this.extend({fontWeight:e,font:""})}withTextFontShape(e){return this.extend({fontShape:e,font:""})}sizingClasses(e){return e.size!==this.size?["sizing","reset-size"+e.size,"size"+this.size]:[]}baseSizingClasses(){return this.size!==T0.BASESIZE?["sizing","reset-size"+this.size,"size"+T0.BASESIZE]:[]}fontMetrics(){return this._fontMetrics||(this._fontMetrics=Ma(this.size)),this._fontMetrics}getColor(){return this.phantom?"transparent":this.color}}T0.BASESIZE=6;var t1=function(e){return new T0({style:e.displayMode?N.DISPLAY:N.TEXT,maxSize:e.maxSize,minRuleThickness:e.minRuleThickness})},r1=function(e,t){if(t.displayMode){var a=["katex-display"];t.leqno&&a.push("leqno"),t.fleqn&&a.push("fleqn"),e=k(a,[e])}return e},Xa=function(e,t,a){var i=t1(a),s;if(a.output==="mathml")return pr(e,t,i,a.displayMode,!0);if(a.output==="html"){var u=Mt(e,i);s=k(["katex"],[u])}else{var h=pr(e,t,i,a.displayMode,!1),c=Mt(e,i);s=k(["katex"],[h,c])}return r1(s,a)},Ya=function(e,t,a){var i=t1(a),s=Mt(e,i),u=k(["katex"],[s]);return r1(u,a)},$a={widehat:"^",widecheck:"ˇ",widetilde:"~",utilde:"~",overleftarrow:"←",underleftarrow:"←",xleftarrow:"←",overrightarrow:"→",underrightarrow:"→",xrightarrow:"→",underbrace:"⏟",overbrace:"⏞",underbracket:"⎵",overbracket:"⎴",overgroup:"⏠",undergroup:"⏡",overleftrightarrow:"↔",underleftrightarrow:"↔",xleftrightarrow:"↔",Overrightarrow:"⇒",xRightarrow:"⇒",overleftharpoon:"↼",xleftharpoonup:"↼",overrightharpoon:"⇀",xrightharpoonup:"⇀",xLeftarrow:"⇐",xLeftrightarrow:"⇔",xhookleftarrow:"↩",xhookrightarrow:"↪",xmapsto:"↦",xrightharpoondown:"⇁",xleftharpoondown:"↽",xrightleftharpoons:"⇌",xleftrightharpoons:"⇋",xtwoheadleftarrow:"↞",xtwoheadrightarrow:"↠",xlongequal:"=",xtofrom:"⇄",xrightleftarrows:"⇄",xrightequilibrium:"⇌",xleftequilibrium:"⇋","\\cdrightarrow":"→","\\cdleftarrow":"←","\\cdlongequal":"="},Le=function(e){var t=new z("mo",[new e0($a[e.replace(/^\\/,"")])]);return t.setAttribute("stretchy","true"),t},Wa={overrightarrow:[["rightarrow"],.888,522,"xMaxYMin"],overleftarrow:[["leftarrow"],.888,522,"xMinYMin"],underrightarrow:[["rightarrow"],.888,522,"xMaxYMin"],underleftarrow:[["leftarrow"],.888,522,"xMinYMin"],xrightarrow:[["rightarrow"],1.469,522,"xMaxYMin"],"\\cdrightarrow":[["rightarrow"],3,522,"xMaxYMin"],xleftarrow:[["leftarrow"],1.469,522,"xMinYMin"],"\\cdleftarrow":[["leftarrow"],3,522,"xMinYMin"],Overrightarrow:[["doublerightarrow"],.888,560,"xMaxYMin"],xRightarrow:[["doublerightarrow"],1.526,560,"xMaxYMin"],xLeftarrow:[["doubleleftarrow"],1.526,560,"xMinYMin"],overleftharpoon:[["leftharpoon"],.888,522,"xMinYMin"],xleftharpoonup:[["leftharpoon"],.888,522,"xMinYMin"],xleftharpoondown:[["leftharpoondown"],.888,522,"xMinYMin"],overrightharpoon:[["rightharpoon"],.888,522,"xMaxYMin"],xrightharpoonup:[["rightharpoon"],.888,522,"xMaxYMin"],xrightharpoondown:[["rightharpoondown"],.888,522,"xMaxYMin"],xlongequal:[["longequal"],.888,334,"xMinYMin"],"\\cdlongequal":[["longequal"],3,334,"xMinYMin"],xtwoheadleftarrow:[["twoheadleftarrow"],.888,334,"xMinYMin"],xtwoheadrightarrow:[["twoheadrightarrow"],.888,334,"xMaxYMin"],overleftrightarrow:[["leftarrow","rightarrow"],.888,522],overbrace:[["leftbrace","midbrace","rightbrace"],1.6,548],underbrace:[["leftbraceunder","midbraceunder","rightbraceunder"],1.6,548],underleftrightarrow:[["leftarrow","rightarrow"],.888,522],xleftrightarrow:[["leftarrow","rightarrow"],1.75,522],xLeftrightarrow:[["doubleleftarrow","doublerightarrow"],1.75,560],xrightleftharpoons:[["leftharpoondownplus","rightharpoonplus"],1.75,716],xleftrightharpoons:[["leftharpoonplus","rightharpoondownplus"],1.75,716],xhookleftarrow:[["leftarrow","righthook"],1.08,522],xhookrightarrow:[["lefthook","rightarrow"],1.08,522],overlinesegment:[["leftlinesegment","rightlinesegment"],.888,522],underlinesegment:[["leftlinesegment","rightlinesegment"],.888,522],overbracket:[["leftbracketover","rightbracketover"],1.6,440],underbracket:[["leftbracketunder","rightbracketunder"],1.6,410],overgroup:[["leftgroup","rightgroup"],.888,342],undergroup:[["leftgroupunder","rightgroupunder"],.888,342],xmapsto:[["leftmapsto","rightarrow"],1.5,522],xtofrom:[["leftToFrom","rightToFrom"],1.75,528],xrightleftarrows:[["baraboveleftarrow","rightarrowabovebar"],1.75,901],xrightequilibrium:[["baraboveshortleftharpoon","rightharpoonaboveshortbar"],1.75,716],xleftequilibrium:[["shortbaraboveleftharpoon","shortrightharpoonabovebar"],1.75,716]},ja=new Set(["widehat","widecheck","widetilde","utilde"]),Pe=function(e,t){function a(){var h=4e5,c=e.label.slice(1);if(ja.has(c)&&"base"in e){var v=e.base.type==="ordgroup"?e.base.body.length:1,p,b,x;if(v>5)c==="widehat"||c==="widecheck"?(p=420,h=2364,x=.42,b=c+"4"):(p=312,h=2340,x=.34,b="tilde4");else{var y=[1,1,2,2,3,3][v];c==="widehat"||c==="widecheck"?(h=[0,1062,2364,2364,2364][y],p=[0,239,300,360,420][y],x=[0,.24,.3,.3,.36,.42][y],b=c+y):(h=[0,600,1033,2339,2340][y],p=[0,260,286,306,312][y],x=[0,.26,.286,.3,.306,.34][y],b="tilde"+y)}var T=new P0(b),M=new C0([T],{width:"100%",height:A(x),viewBox:"0 0 "+h+" "+p,preserveAspectRatio:"none"});return{span:G0([],[M],t),minWidth:0,height:x}}else{var q=[],C=Wa[c];if(!C)throw new Error('No SVG data for "'+c+'".');var[R,F,L]=C,O=L/1e3,P=R.length,G,Y;if(P===1){if(C.length!==4)throw new Error('Expected 4-tuple for single-path SVG data "'+c+'".');G=["hide-tail"],Y=[C[3]]}else if(P===2)G=["halfarrow-left","halfarrow-right"],Y=["xMinYMin","xMaxYMin"];else if(P===3)G=["brace-left","brace-center","brace-right"],Y=["xMinYMin","xMidYMin","xMaxYMin"];else throw new Error(`Correct katexImagesData or update code here to support + `+P+" children.");for(var U=0;U0&&(i.style.minWidth=A(s)),i},Za=function(e,t,a,i,s){var u,h=e.height+e.depth+a+i;if(/fbox|color|angl/.test(t)){if(u=k(["stretchy",t],[],s),t==="fbox"){var c=s.color&&s.getColor();c&&(u.style.borderColor=c)}}else{var v=[];/^[bx]cancel$/.test(t)&&v.push(new pt({x1:"0",y1:"0",x2:"100%",y2:"100%","stroke-width":"0.046em"})),/^x?cancel$/.test(t)&&v.push(new pt({x1:"0",y1:"100%",x2:"100%",y2:"0","stroke-width":"0.046em"}));var p=new C0(v,{width:"100%",height:A(h)});u=G0([],[p],s)}return u.height=h,u.style.height=A(h),u},Ka={bin:1,close:1,inner:1,open:1,punct:1,rel:1},Ja={"accent-token":1,mathord:1,"op-token":1,spacing:1,textord:1};function Qa(r){return r in Ka}function H(r,e){if(!r||r.type!==e)throw new Error("Expected node of type "+e+", but got "+(r?"node of type "+r.type:String(r)));return r}function Ge(r){var e=Ue(r);if(!e)throw new Error("Expected node of symbol group type, but got "+(r?"node of type "+r.type:String(r)));return e}function Ue(r){return r&&(r.type==="atom"||Ja.hasOwnProperty(r.type))?r:null}var a1=r=>{if(r instanceof d0)return r;if(za(r)&&r.children.length===1)return a1(r.children[0])},Pt=(r,e)=>{var t,a,i;r&&r.type==="supsub"?(a=H(r.base,"accent"),t=a.base,r.base=t,i=Sa(X(r,e)),r.base=a):(a=H(r,"accent"),t=a.base);var s=X(t,e.havingCrampedStyle()),u=a.isShifty&&D0(t),h=0;if(u){var c,v;h=(c=(v=a1(s))==null?void 0:v.skew)!=null?c:0}var p=a.label==="\\c",b=p?s.height+s.depth:Math.min(s.height,e.fontMetrics().xHeight),x;if(a.isStretchy)x=Pe(a,e),x=V({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"elem",elem:x,wrapperClasses:["svg-align"],wrapperStyle:h>0?{width:"calc(100% - "+A(2*h)+")",marginLeft:A(2*h)}:void 0}]});else{var y,T;a.label==="\\vec"?(y=Kr("vec",e),T=Zr.vec[1]):(y=Oe({mode:a.mode,text:a.label},e,"textord"),y=ka(y),y.italic=0,T=y.width,p&&(b+=y.depth)),x=k(["accent-body"],[y]);var M=a.label==="\\textcircled";M&&(x.classes.push("accent-full"),b=s.height);var q=h;M||(q-=T/2),x.style.left=A(q),a.label==="\\textcircled"&&(x.style.top=".2em"),x=V({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"kern",size:-b},{type:"elem",elem:x}]})}var C=k(["mord","accent"],[x],e);return i?(i.children[0]=C,i.height=Math.max(C.height,i.height),i.classes[0]="mord",i):C},i1=(r,e)=>{var t=r.isStretchy?Le(r.label):new z("mo",[g0(r.label,r.mode)]),a=new z("mover",[$(r.base,e),t]);return a.setAttribute("accent","true"),a},_a=new RegExp(["\\acute","\\grave","\\ddot","\\tilde","\\bar","\\breve","\\check","\\hat","\\vec","\\dot","\\mathring"].map(r=>"\\"+r).join("|"));B({type:"accent",names:["\\acute","\\grave","\\ddot","\\tilde","\\bar","\\breve","\\check","\\hat","\\vec","\\dot","\\mathring","\\widecheck","\\widehat","\\widetilde","\\overrightarrow","\\overleftarrow","\\Overrightarrow","\\overleftrightarrow","\\overgroup","\\overlinesegment","\\overleftharpoon","\\overrightharpoon"],props:{numArgs:1},handler:(r,e)=>{var t=Ne(e[0]),a=!_a.test(r.funcName),i=!a||r.funcName==="\\widehat"||r.funcName==="\\widetilde"||r.funcName==="\\widecheck";return{type:"accent",mode:r.parser.mode,label:r.funcName,isStretchy:a,isShifty:i,base:t}},htmlBuilder:Pt,mathmlBuilder:i1});B({type:"accent",names:["\\'","\\`","\\^","\\~","\\=","\\u","\\.",'\\"',"\\c","\\r","\\H","\\v","\\textcircled"],props:{numArgs:1,allowedInText:!0,allowedInMath:!0,argTypes:["primitive"]},handler:(r,e)=>{var t=e[0],a=r.parser.mode;return a==="math"&&(r.parser.settings.reportNonstrict("mathVsTextAccents","LaTeX's accent "+r.funcName+" works only in text mode"),a="text"),{type:"accent",mode:a,label:r.funcName,isStretchy:!1,isShifty:!0,base:t}},htmlBuilder:Pt,mathmlBuilder:i1});B({type:"accentUnder",names:["\\underleftarrow","\\underrightarrow","\\underleftrightarrow","\\undergroup","\\underlinesegment","\\utilde"],props:{numArgs:1},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=e[0];return{type:"accentUnder",mode:t.mode,label:a,base:i}},htmlBuilder:(r,e)=>{var t=X(r.base,e),a=Pe(r,e),i=r.label==="\\utilde"?.12:0,s=V({positionType:"top",positionData:t.height,children:[{type:"elem",elem:a,wrapperClasses:["svg-align"]},{type:"kern",size:i},{type:"elem",elem:t}]});return k(["mord","accentunder"],[s],e)},mathmlBuilder:(r,e)=>{var t=Le(r.label),a=new z("munder",[$(r.base,e),t]);return a.setAttribute("accentunder","true"),a}});var Me=r=>{var e=new z("mpadded",r?[r]:[]);return e.setAttribute("width","+0.6em"),e.setAttribute("lspace","0.3em"),e};B({type:"xArrow",names:["\\xleftarrow","\\xrightarrow","\\xLeftarrow","\\xRightarrow","\\xleftrightarrow","\\xLeftrightarrow","\\xhookleftarrow","\\xhookrightarrow","\\xmapsto","\\xrightharpoondown","\\xrightharpoonup","\\xleftharpoondown","\\xleftharpoonup","\\xrightleftharpoons","\\xleftrightharpoons","\\xlongequal","\\xtwoheadrightarrow","\\xtwoheadleftarrow","\\xtofrom","\\xrightleftarrows","\\xrightequilibrium","\\xleftequilibrium","\\\\cdrightarrow","\\\\cdleftarrow","\\\\cdlongequal"],props:{numArgs:1,numOptionalArgs:1},handler(r,e,t){var{parser:a,funcName:i}=r;return{type:"xArrow",mode:a.mode,label:i,body:e[0],below:t[0]}},htmlBuilder(r,e){var t=e.style,a=e.havingStyle(t.sup()),i=re(X(r.body,a,e),e),s=r.label.slice(0,2)==="\\x"?"x":"cd";i.classes.push(s+"-arrow-pad");var u;r.below&&(a=e.havingStyle(t.sub()),u=re(X(r.below,a,e),e),u.classes.push(s+"-arrow-pad"));var h=Pe(r,e),c=-e.fontMetrics().axisHeight+.5*h.height,v=-e.fontMetrics().axisHeight-.5*h.height-.111;(i.depth>.25||r.label==="\\xleftequilibrium")&&(v-=i.depth);var p;if(u){var b=-e.fontMetrics().axisHeight+u.height+.5*h.height+.111;p=V({positionType:"individualShift",children:[{type:"elem",elem:i,shift:v},{type:"elem",elem:h,shift:c,wrapperClasses:["svg-align"]},{type:"elem",elem:u,shift:b}]})}else p=V({positionType:"individualShift",children:[{type:"elem",elem:i,shift:v},{type:"elem",elem:h,shift:c,wrapperClasses:["svg-align"]}]});return k(["mrel","x-arrow"],[p],e)},mathmlBuilder(r,e){var t=Le(r.label);t.setAttribute("minsize",r.label.charAt(0)==="x"?"1.75em":"3.0em");var a;if(r.body){var i=Me($(r.body,e));if(r.below){var s=Me($(r.below,e));a=new z("munderover",[t,s,i])}else a=new z("mover",[t,i])}else if(r.below){var u=Me($(r.below,e));a=new z("munder",[t,u])}else a=Me(),a=new z("mover",[t,a]);return a}});function n1(r,e){var t=a0(r.body,e,!0);return k([r.mclass],t,e)}function s1(r,e){var t,a=v0(r.body,e);return r.mclass==="minner"?t=new z("mpadded",a):r.mclass==="mord"?r.isCharacterBox?(t=a[0],t.type="mi"):t=new z("mi",a):(r.isCharacterBox?(t=a[0],t.type="mo"):t=new z("mo",a),r.mclass==="mbin"?(t.attributes.lspace="0.22em",t.attributes.rspace="0.22em"):r.mclass==="mpunct"?(t.attributes.lspace="0em",t.attributes.rspace="0.17em"):r.mclass==="mopen"||r.mclass==="mclose"?(t.attributes.lspace="0em",t.attributes.rspace="0em"):r.mclass==="minner"&&(t.attributes.lspace="0.0556em",t.attributes.width="+0.1111em")),t}B({type:"mclass",names:["\\mathord","\\mathbin","\\mathrel","\\mathopen","\\mathclose","\\mathpunct","\\mathinner"],props:{numArgs:1,primitive:!0},handler(r,e){var{parser:t,funcName:a}=r,i=e[0];return{type:"mclass",mode:t.mode,mclass:"m"+a.slice(5),body:_(i),isCharacterBox:D0(i)}},htmlBuilder:n1,mathmlBuilder:s1});var Ve=r=>{var e=r.type==="ordgroup"&&r.body.length?r.body[0]:r;return e.type==="atom"&&(e.family==="bin"||e.family==="rel")?"m"+e.family:"mord"};B({type:"mclass",names:["\\@binrel"],props:{numArgs:2},handler(r,e){var{parser:t}=r;return{type:"mclass",mode:t.mode,mclass:Ve(e[0]),body:_(e[1]),isCharacterBox:D0(e[1])}}});B({type:"mclass",names:["\\stackrel","\\overset","\\underset"],props:{numArgs:2},handler(r,e){var{parser:t,funcName:a}=r,i=e[1],s=e[0],u;a!=="\\stackrel"?u=Ve(i):u="mrel";var h={type:"op",mode:i.mode,limits:!0,alwaysHandleSupSub:!0,parentIsSupSub:!1,symbol:!1,suppressBaseShift:a!=="\\stackrel",body:_(i)},c={type:"supsub",mode:s.mode,base:h,sup:a==="\\underset"?null:s,sub:a==="\\underset"?s:null};return{type:"mclass",mode:t.mode,mclass:u,body:[c],isCharacterBox:D0(c)}},htmlBuilder:n1,mathmlBuilder:s1});B({type:"pmb",names:["\\pmb"],props:{numArgs:1,allowedInText:!0},handler(r,e){var{parser:t}=r;return{type:"pmb",mode:t.mode,mclass:Ve(e[0]),body:_(e[0])}},htmlBuilder(r,e){var t=a0(r.body,e,!0),a=k([r.mclass],t,e);return a.style.textShadow="0.02em 0.01em 0.04px",a},mathmlBuilder(r,e){var t=v0(r.body,e),a=new z("mstyle",t);return a.setAttribute("style","text-shadow: 0.02em 0.01em 0.04px"),a}});var e4={">":"\\\\cdrightarrow","<":"\\\\cdleftarrow","=":"\\\\cdlongequal",A:"\\uparrow",V:"\\downarrow","|":"\\Vert",".":"no arrow"},yr=()=>({type:"styling",body:[],mode:"math",style:"display",resetFont:!0}),xr=r=>r.type==="textord"&&r.text==="@",t4=(r,e)=>(r.type==="mathord"||r.type==="atom")&&r.text===e;function r4(r,e,t){var a=e4[r];switch(a){case"\\\\cdrightarrow":case"\\\\cdleftarrow":return t.callFunction(a,[e[0]],[e[1]]);case"\\uparrow":case"\\downarrow":{var i=t.callFunction("\\\\cdleft",[e[0]],[]),s={type:"atom",text:a,mode:"math",family:"rel"},u=t.callFunction("\\Big",[s],[]),h=t.callFunction("\\\\cdright",[e[1]],[]),c={type:"ordgroup",mode:"math",body:[i,u,h]};return t.callFunction("\\\\cdparent",[c],[])}case"\\\\cdlongequal":return t.callFunction("\\\\cdlongequal",[],[]);case"\\Vert":{var v={type:"textord",text:"\\Vert",mode:"math"};return t.callFunction("\\Big",[v],[])}default:return{type:"textord",text:" ",mode:"math"}}}function a4(r){var e=[];for(r.gullet.beginGroup(),r.gullet.macros.set("\\cr","\\\\\\relax"),r.gullet.beginGroup();;){e.push(r.parseExpression(!1,"\\\\")),r.gullet.endGroup(),r.gullet.beginGroup();var t=r.fetch().text;if(t==="&"||t==="\\\\")r.consume();else if(t==="\\end"){e[e.length-1].length===0&&e.pop();break}else throw new S("Expected \\\\ or \\cr or \\end",r.nextToken)}for(var a=[],i=[a],s=0;sAV".includes(v))for(var b=0;b<2;b++){for(var x=!0,y=c+1;yAV=|." after @',u[c]);var T=r4(v,p,r),M={type:"styling",body:[T],mode:"math",style:"display",resetFont:!0};a.push(M),h=yr()}s%2===0?a.push(h):a.shift(),a=[],i.push(a)}r.gullet.endGroup(),r.gullet.endGroup();var q=new Array(i[0].length).fill({type:"align",align:"c",pregap:.25,postgap:.25});return{type:"array",mode:"math",body:i,arraystretch:1,addJot:!0,rowGaps:[null],cols:q,colSeparationType:"CD",hLinesBeforeRow:new Array(i.length+1).fill([])}}B({type:"cdlabel",names:["\\\\cdleft","\\\\cdright"],props:{numArgs:1},handler(r,e){var{parser:t,funcName:a}=r;return{type:"cdlabel",mode:t.mode,side:a.slice(4),label:e[0]}},htmlBuilder(r,e){var t=e.havingStyle(e.style.sup()),a=re(X(r.label,t,e),e);return a.classes.push("cd-label-"+r.side),a.style.bottom=A(.8-a.depth),a.height=0,a.depth=0,a},mathmlBuilder(r,e){var t=new z("mrow",[$(r.label,e)]);return t=new z("mpadded",[t]),t.setAttribute("width","0"),r.side==="left"&&t.setAttribute("lspace","-1width"),t.setAttribute("voffset","0.7em"),t=new z("mstyle",[t]),t.setAttribute("displaystyle","false"),t.setAttribute("scriptlevel","1"),t}});B({type:"cdlabelparent",names:["\\\\cdparent"],props:{numArgs:1},handler(r,e){var{parser:t}=r;return{type:"cdlabelparent",mode:t.mode,fragment:e[0]}},htmlBuilder(r,e){var t=re(X(r.fragment,e),e);return t.classes.push("cd-vert-arrow"),t},mathmlBuilder(r,e){return new z("mrow",[$(r.fragment,e)])}});B({type:"textord",names:["\\@char"],props:{numArgs:1,allowedInText:!0},handler(r,e){for(var{parser:t}=r,a=H(e[0],"ordgroup"),i=a.body,s="",u=0;u=1114111)throw new S("\\@char with invalid code point "+s);return c<=65535?v=String.fromCharCode(c):(c-=65536,v=String.fromCharCode((c>>10)+55296,(c&1023)+56320)),{type:"textord",mode:t.mode,text:v}}});var l1=(r,e)=>{var t=a0(r.body,e.withColor(r.color),!1);return E0(t)},u1=(r,e)=>{var t=v0(r.body,e.withColor(r.color)),a=new z("mstyle",t);return a.setAttribute("mathcolor",r.color),a};B({type:"color",names:["\\textcolor"],props:{numArgs:2,allowedInText:!0,argTypes:["color","original"]},handler(r,e){var{parser:t}=r,a=H(e[0],"color-token").color,i=e[1];return{type:"color",mode:t.mode,color:a,body:_(i)}},htmlBuilder:l1,mathmlBuilder:u1});B({type:"color",names:["\\color"],props:{numArgs:1,allowedInText:!0,argTypes:["color"]},handler(r,e){var{parser:t,breakOnTokenText:a}=r,i=H(e[0],"color-token").color;t.gullet.macros.set("\\current@color",i);var s=t.parseExpression(!0,a);return{type:"color",mode:t.mode,color:i,body:s}},htmlBuilder:l1,mathmlBuilder:u1});B({type:"cr",names:["\\\\"],props:{numArgs:0,numOptionalArgs:0,allowedInText:!0},handler(r,e,t){var{parser:a}=r,i=a.gullet.future().text==="["?a.parseSizeGroup(!0):null,s=!a.settings.displayMode||!a.settings.useStrictBehavior("newLineInDisplayMode","In LaTeX, \\\\ or \\newline does nothing in display mode");return{type:"cr",mode:a.mode,newLine:s,size:i&&H(i,"size").value}},htmlBuilder(r,e){var t=k(["mspace"],[],e);return r.newLine&&(t.classes.push("newline"),r.size&&(t.style.marginTop=A(K(r.size,e)))),t},mathmlBuilder(r,e){var t=new z("mspace");return r.newLine&&(t.setAttribute("linebreak","newline"),r.size&&t.setAttribute("height",A(K(r.size,e)))),t}});var Tt={"\\global":"\\global","\\long":"\\\\globallong","\\\\globallong":"\\\\globallong","\\def":"\\gdef","\\gdef":"\\gdef","\\edef":"\\xdef","\\xdef":"\\xdef","\\let":"\\\\globallet","\\futurelet":"\\\\globalfuture"},o1=r=>{var e=r.text;if(/^(?:[\\{}$&#^_]|EOF)$/.test(e))throw new S("Expected a control sequence",r);return e},i4=r=>{var e=r.gullet.popToken();return e.text==="="&&(e=r.gullet.popToken(),e.text===" "&&(e=r.gullet.popToken())),e},h1=(r,e,t,a)=>{var i=r.gullet.macros.get(t.text);i==null&&(t.noexpand=!0,i={tokens:[t],numArgs:0,unexpandable:!r.gullet.isExpandable(t.text)}),r.gullet.macros.set(e,i,a)};B({type:"internal",names:["\\global","\\long","\\\\globallong"],props:{numArgs:0,allowedInText:!0},handler(r){var{parser:e,funcName:t}=r;e.consumeSpaces();var a=e.fetch();if(Tt[a.text])return(t==="\\global"||t==="\\\\globallong")&&(a.text=Tt[a.text]),H(e.parseFunction(),"internal");throw new S("Invalid token after macro prefix",a)}});B({type:"internal",names:["\\def","\\gdef","\\edef","\\xdef"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(r){var{parser:e,funcName:t}=r,a=e.gullet.popToken(),i=a.text;if(/^(?:[\\{}$&#^_]|EOF)$/.test(i))throw new S("Expected a control sequence",a);for(var s=0,u,h=[[]];e.gullet.future().text!=="{";)if(a=e.gullet.popToken(),a.text==="#"){if(e.gullet.future().text==="{"){u=e.gullet.future(),h[s].push("{");break}if(a=e.gullet.popToken(),!/^[1-9]$/.test(a.text))throw new S('Invalid argument number "'+a.text+'"');if(parseInt(a.text)!==s+1)throw new S('Argument number "'+a.text+'" out of order');s++,h.push([])}else{if(a.text==="EOF")throw new S("Expected a macro definition");h[s].push(a.text)}var{tokens:c}=e.gullet.consumeArg();return u&&c.unshift(u),(t==="\\edef"||t==="\\xdef")&&(c=e.gullet.expandTokens(c),c.reverse()),e.gullet.macros.set(i,{tokens:c,numArgs:s,delimiters:h},t===Tt[t]),{type:"internal",mode:e.mode}}});B({type:"internal",names:["\\let","\\\\globallet"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(r){var{parser:e,funcName:t}=r,a=o1(e.gullet.popToken());e.gullet.consumeSpaces();var i=i4(e);return h1(e,a,i,t==="\\\\globallet"),{type:"internal",mode:e.mode}}});B({type:"internal",names:["\\futurelet","\\\\globalfuture"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(r){var{parser:e,funcName:t}=r,a=o1(e.gullet.popToken()),i=e.gullet.popToken(),s=e.gullet.popToken();return h1(e,a,s,t==="\\\\globalfuture"),e.gullet.pushToken(s),e.gullet.pushToken(i),{type:"internal",mode:e.mode}}});var oe=function(e,t,a){var i=W.math[e]&&W.math[e].replace,s=Nt(i||e,t,a);if(!s)throw new Error("Unsupported symbol "+e+" and font size "+t+".");return s},Gt=function(e,t,a,i){var s=a.havingBaseStyle(t),u=k(i.concat(s.sizingClasses(a)),[e],a),h=s.sizeMultiplier/a.sizeMultiplier;return u.height*=h,u.depth*=h,u.maxFontSize=s.sizeMultiplier,u},m1=function(e,t,a){var i=t.havingBaseStyle(a),s=(1-t.sizeMultiplier/i.sizeMultiplier)*t.fontMetrics().axisHeight;e.classes.push("delimcenter"),e.style.top=A(s),e.height-=s,e.depth+=s},n4=function(e,t,a,i,s,u){var h=s0(e,"Main-Regular",s,i),c=Gt(h,t,i,u);return m1(c,i,t),c},s4=function(e,t,a,i){return s0(e,"Size"+t+"-Regular",a,i)},c1=function(e,t,a,i,s,u){var h=s4(e,t,s,i),c=Gt(k(["delimsizing","size"+t],[h],i),N.TEXT,i,u);return a&&m1(c,i,N.TEXT),c},at=function(e,t,a){var i;t==="Size1-Regular"?i="delim-size1":i="delim-size4";var s=k(["delimsizinginner",i],[k([],[s0(e,t,a)])]);return{type:"elem",elem:s}},it=function(e,t,a){var i=k0["Size4-Regular"][e.charCodeAt(0)]?k0["Size4-Regular"][e.charCodeAt(0)][4]:k0["Size1-Regular"][e.charCodeAt(0)][4],s=new P0("inner",va(e,Math.round(1e3*t))),u=new C0([s],{width:A(i),height:A(t),style:"width:"+A(i),viewBox:"0 0 "+1e3*i+" "+Math.round(1e3*t),preserveAspectRatio:"xMinYMin"}),h=G0([],[u],a);return h.height=t,h.style.height=A(t),h.style.width=A(i),{type:"elem",elem:h}},Bt=.008,Te={type:"kern",size:-1*Bt},l4=new Set(["|","\\lvert","\\rvert","\\vert"]),u4=new Set(["\\|","\\lVert","\\rVert","\\Vert"]),d1=function(e,t,a,i,s,u){var h,c,v,p,b="",x=0;h=v=p=e,c=null;var y="Size1-Regular";e==="\\uparrow"?v=p="⏐":e==="\\Uparrow"?v=p="‖":e==="\\downarrow"?h=v="⏐":e==="\\Downarrow"?h=v="‖":e==="\\updownarrow"?(h="\\uparrow",v="⏐",p="\\downarrow"):e==="\\Updownarrow"?(h="\\Uparrow",v="‖",p="\\Downarrow"):l4.has(e)?(v="∣",b="vert",x=333):u4.has(e)?(v="∥",b="doublevert",x=556):e==="["||e==="\\lbrack"?(h="⎡",v="⎢",p="⎣",y="Size4-Regular",b="lbrack",x=667):e==="]"||e==="\\rbrack"?(h="⎤",v="⎥",p="⎦",y="Size4-Regular",b="rbrack",x=667):e==="\\lfloor"||e==="⌊"?(v=h="⎢",p="⎣",y="Size4-Regular",b="lfloor",x=667):e==="\\lceil"||e==="⌈"?(h="⎡",v=p="⎢",y="Size4-Regular",b="lceil",x=667):e==="\\rfloor"||e==="⌋"?(v=h="⎥",p="⎦",y="Size4-Regular",b="rfloor",x=667):e==="\\rceil"||e==="⌉"?(h="⎤",v=p="⎥",y="Size4-Regular",b="rceil",x=667):e==="("||e==="\\lparen"?(h="⎛",v="⎜",p="⎝",y="Size4-Regular",b="lparen",x=875):e===")"||e==="\\rparen"?(h="⎞",v="⎟",p="⎠",y="Size4-Regular",b="rparen",x=875):e==="\\{"||e==="\\lbrace"?(h="⎧",c="⎨",p="⎩",v="⎪",y="Size4-Regular"):e==="\\}"||e==="\\rbrace"?(h="⎫",c="⎬",p="⎭",v="⎪",y="Size4-Regular"):e==="\\lgroup"||e==="⟮"?(h="⎧",p="⎩",v="⎪",y="Size4-Regular"):e==="\\rgroup"||e==="⟯"?(h="⎫",p="⎭",v="⎪",y="Size4-Regular"):e==="\\lmoustache"||e==="⎰"?(h="⎧",p="⎭",v="⎪",y="Size4-Regular"):(e==="\\rmoustache"||e==="⎱")&&(h="⎫",p="⎩",v="⎪",y="Size4-Regular");var T=oe(h,y,s),M=T.height+T.depth,q=oe(v,y,s),C=q.height+q.depth,R=oe(p,y,s),F=R.height+R.depth,L=0,O=1;if(c!==null){var P=oe(c,y,s);L=P.height+P.depth,O=2}var G=M+F+L,Y=Math.max(0,Math.ceil((t-G)/(O*C))),U=G+Y*O*C,o0=i.fontMetrics().axisHeight;a&&(o0*=i.sizeMultiplier);var m0=U/2-o0,Q=[];if(b.length>0){var le=U-M-F,x0=Math.round(U*1e3),b0=pa(b,Math.round(le*1e3)),R0=new P0(b,b0),j0=A(x/1e3),Z0=A(x0/1e3),Ze=new C0([R0],{width:j0,height:Z0,viewBox:"0 0 "+x+" "+x0}),I0=G0([],[Ze],i);I0.height=x0/1e3,I0.style.width=j0,I0.style.height=Z0,Q.push({type:"elem",elem:I0})}else{if(Q.push(at(p,y,s)),Q.push(Te),c===null){var N0=U-M-F+2*Bt;Q.push(it(v,N0,i))}else{var ue=(U-M-F-L)/2+2*Bt;Q.push(it(v,ue,i)),Q.push(Te),Q.push(at(c,y,s)),Q.push(Te),Q.push(it(v,ue,i))}Q.push(Te),Q.push(at(h,y,s))}var y0=i.havingBaseStyle(N.TEXT),ve=V({positionType:"bottom",positionData:m0,children:Q});return Gt(k(["delimsizing","mult"],[ve],y0),N.TEXT,i,u)},nt=80,st=.08,lt=function(e,t,a,i,s){var u=fa(e,i,a),h=new P0(e,u),c=new C0([h],{width:"400em",height:A(t),viewBox:"0 0 400000 "+a,preserveAspectRatio:"xMinYMin slice"});return G0(["hide-tail"],[c],s)},o4=function(e,t){var a=t.havingBaseSizing(),i=b1("\\surd",e*a.sizeMultiplier,g1,a),s=a.sizeMultiplier,u=Math.max(0,t.minRuleThickness-t.fontMetrics().sqrtRuleThickness),h,c,v,p,b;return i.type==="small"?(p=1e3+1e3*u+nt,e<1?s=1:e<1.4&&(s=.7),c=(1+u+st)/s,v=(1+u)/s,h=lt("sqrtMain",c,p,u,t),h.style.minWidth="0.853em",b=.833/s):i.type==="large"?(p=(1e3+nt)*he[i.size],v=(he[i.size]+u)/s,c=(he[i.size]+u+st)/s,h=lt("sqrtSize"+i.size,c,p,u,t),h.style.minWidth="1.02em",b=1/s):(c=e+u+st,v=e+u,p=Math.floor(1e3*e+u)+nt,h=lt("sqrtTall",c,p,u,t),h.style.minWidth="0.742em",b=1.056),h.height=v,h.style.height=A(c),{span:h,advanceWidth:b,ruleWidth:(t.fontMetrics().sqrtRuleThickness+u)*s}},f1=new Set(["(","\\lparen",")","\\rparen","[","\\lbrack","]","\\rbrack","\\{","\\lbrace","\\}","\\rbrace","\\lfloor","\\rfloor","⌊","⌋","\\lceil","\\rceil","⌈","⌉","\\surd"]),h4=new Set(["\\uparrow","\\downarrow","\\updownarrow","\\Uparrow","\\Downarrow","\\Updownarrow","|","\\|","\\vert","\\Vert","\\lvert","\\rvert","\\lVert","\\rVert","\\lgroup","\\rgroup","⟮","⟯","\\lmoustache","\\rmoustache","⎰","⎱"]),v1=new Set(["<",">","\\langle","\\rangle","/","\\backslash","\\lt","\\gt"]),he=[0,1.2,1.8,2.4,3],p1=function(e,t,a,i,s){if(e==="<"||e==="\\lt"||e==="⟨"?e="\\langle":(e===">"||e==="\\gt"||e==="⟩")&&(e="\\rangle"),f1.has(e)||v1.has(e))return c1(e,t,!1,a,i,s);if(h4.has(e))return d1(e,he[t],!1,a,i,s);throw new S("Illegal delimiter: '"+e+"'")},m4=[{type:"small",style:N.SCRIPTSCRIPT},{type:"small",style:N.SCRIPT},{type:"small",style:N.TEXT},{type:"large",size:1},{type:"large",size:2},{type:"large",size:3},{type:"large",size:4}],c4=[{type:"small",style:N.SCRIPTSCRIPT},{type:"small",style:N.SCRIPT},{type:"small",style:N.TEXT},{type:"stack"}],g1=[{type:"small",style:N.SCRIPTSCRIPT},{type:"small",style:N.SCRIPT},{type:"small",style:N.TEXT},{type:"large",size:1},{type:"large",size:2},{type:"large",size:3},{type:"large",size:4},{type:"stack"}],d4=function(e){if(e.type==="small")return"Main-Regular";if(e.type==="large")return"Size"+e.size+"-Regular";if(e.type==="stack")return"Size4-Regular";var t=e.type;throw new Error("Add support for delim type '"+t+"' here.")},b1=function(e,t,a,i){for(var s=Math.min(2,3-i.style.size),u=s;ut)return h}return a[a.length-1]},Ct=function(e,t,a,i,s,u){e==="<"||e==="\\lt"||e==="⟨"?e="\\langle":(e===">"||e==="\\gt"||e==="⟩")&&(e="\\rangle");var h;v1.has(e)?h=m4:f1.has(e)?h=g1:h=c4;var c=b1(e,t,h,i);return c.type==="small"?n4(e,c.style,a,i,s,u):c.type==="large"?c1(e,c.size,a,i,s,u):d1(e,t,a,i,s,u)},ut=function(e,t,a,i,s,u){var h=i.fontMetrics().axisHeight*i.sizeMultiplier,c=901,v=5/i.fontMetrics().ptPerEm,p=Math.max(t-h,a+h),b=Math.max(p/500*c,2*p-v);return Ct(e,b,!0,i,s,u)},wr={"\\bigl":{mclass:"mopen",size:1},"\\Bigl":{mclass:"mopen",size:2},"\\biggl":{mclass:"mopen",size:3},"\\Biggl":{mclass:"mopen",size:4},"\\bigr":{mclass:"mclose",size:1},"\\Bigr":{mclass:"mclose",size:2},"\\biggr":{mclass:"mclose",size:3},"\\Biggr":{mclass:"mclose",size:4},"\\bigm":{mclass:"mrel",size:1},"\\Bigm":{mclass:"mrel",size:2},"\\biggm":{mclass:"mrel",size:3},"\\Biggm":{mclass:"mrel",size:4},"\\big":{mclass:"mord",size:1},"\\Big":{mclass:"mord",size:2},"\\bigg":{mclass:"mord",size:3},"\\Bigg":{mclass:"mord",size:4}},f4=new Set(["(","\\lparen",")","\\rparen","[","\\lbrack","]","\\rbrack","\\{","\\lbrace","\\}","\\rbrace","\\lfloor","\\rfloor","⌊","⌋","\\lceil","\\rceil","⌈","⌉","<",">","\\langle","⟨","\\rangle","⟩","\\lt","\\gt","\\lvert","\\rvert","\\lVert","\\rVert","\\lgroup","\\rgroup","⟮","⟯","\\lmoustache","\\rmoustache","⎰","⎱","/","\\backslash","|","\\vert","\\|","\\Vert","\\uparrow","\\Uparrow","\\downarrow","\\Downarrow","\\updownarrow","\\Updownarrow","."]);function kr(r){return"isMiddle"in r}function Xe(r,e){var t=Ue(r);if(t&&f4.has(t.text))return t;throw t?new S("Invalid delimiter '"+t.text+"' after '"+e.funcName+"'",r):new S("Invalid delimiter type '"+r.type+"'",r)}B({type:"delimsizing",names:["\\bigl","\\Bigl","\\biggl","\\Biggl","\\bigr","\\Bigr","\\biggr","\\Biggr","\\bigm","\\Bigm","\\biggm","\\Biggm","\\big","\\Big","\\bigg","\\Bigg"],props:{numArgs:1,argTypes:["primitive"]},handler:(r,e)=>{var t=Xe(e[0],r);return{type:"delimsizing",mode:r.parser.mode,size:wr[r.funcName].size,mclass:wr[r.funcName].mclass,delim:t.text}},htmlBuilder:(r,e)=>r.delim==="."?k([r.mclass]):p1(r.delim,r.size,e,r.mode,[r.mclass]),mathmlBuilder:r=>{var e=[];r.delim!=="."&&e.push(g0(r.delim,r.mode));var t=new z("mo",e);r.mclass==="mopen"||r.mclass==="mclose"?t.setAttribute("fence","true"):t.setAttribute("fence","false"),t.setAttribute("stretchy","true");var a=A(he[r.size]);return t.setAttribute("minsize",a),t.setAttribute("maxsize",a),t}});function Sr(r){if(!r.body)throw new Error("Bug: The leftright ParseNode wasn't fully parsed.")}B({type:"leftright-right",names:["\\right"],props:{numArgs:1,primitive:!0},handler:(r,e)=>{var t=r.parser.gullet.macros.get("\\current@color");if(t&&typeof t!="string")throw new S("\\current@color set to non-string in \\right");return{type:"leftright-right",mode:r.parser.mode,delim:Xe(e[0],r).text,color:t}}});B({type:"leftright",names:["\\left"],props:{numArgs:1,primitive:!0},handler:(r,e)=>{var t=Xe(e[0],r),a=r.parser;++a.leftrightDepth;var i=a.parseExpression(!1);--a.leftrightDepth,a.expect("\\right",!1);var s=H(a.parseFunction(),"leftright-right");return{type:"leftright",mode:a.mode,body:i,left:t.text,right:s.delim,rightColor:s.color}},htmlBuilder:(r,e)=>{Sr(r);for(var t=a0(r.body,e,!0,["mopen","mclose"]),a=0,i=0,s=!1,u=0;u{Sr(r);var t=v0(r.body,e);if(r.left!=="."){var a=new z("mo",[g0(r.left,r.mode)]);a.setAttribute("fence","true"),t.unshift(a)}if(r.right!=="."){var i=new z("mo",[g0(r.right,r.mode)]);i.setAttribute("fence","true"),r.rightColor&&i.setAttribute("mathcolor",r.rightColor),t.push(i)}return Ot(t)}});B({type:"middle",names:["\\middle"],props:{numArgs:1,primitive:!0},handler:(r,e)=>{var t=Xe(e[0],r);if(!r.parser.leftrightDepth)throw new S("\\middle without preceding \\left",t);return{type:"middle",mode:r.parser.mode,delim:t.text}},htmlBuilder:(r,e)=>{var t;return r.delim==="."?t=ce(e,[]):(t=p1(r.delim,1,e,r.mode,[]),t.isMiddle={delim:r.delim,options:e}),t},mathmlBuilder:(r,e)=>{var t=r.delim==="\\vert"||r.delim==="|"?g0("|","text"):g0(r.delim,r.mode),a=new z("mo",[t]);return a.setAttribute("fence","true"),a.setAttribute("lspace","0.05em"),a.setAttribute("rspace","0.05em"),a}});var Ye=(r,e)=>{var t=re(X(r.body,e),e),a=r.label.slice(1),i=e.sizeMultiplier,s,u,h=D0(r.body);if(a==="sout")s=k(["stretchy","sout"]),s.height=e.fontMetrics().defaultRuleThickness/i,u=-.5*e.fontMetrics().xHeight;else if(a==="phase"){var c=K({number:.6,unit:"pt"},e),v=K({number:.35,unit:"ex"},e),p=e.havingBaseSizing();i=i/p.sizeMultiplier;var b=t.height+t.depth+c+v;t.style.paddingLeft=A(b/2+c);var x=Math.floor(1e3*b*i),y=ca(x),T=new C0([new P0("phase",y)],{width:"400em",height:A(x/1e3),viewBox:"0 0 400000 "+x,preserveAspectRatio:"xMinYMin slice"});s=G0(["hide-tail"],[T],e),s.style.height=A(b),u=t.depth+c+v}else{/cancel/.test(a)?h||t.classes.push("cancel-pad"):a==="angl"?t.classes.push("anglpad"):t.classes.push("boxpad");var M,q,C=0;/box/.test(a)?(C=Math.max(e.fontMetrics().fboxrule,e.minRuleThickness),M=e.fontMetrics().fboxsep+(a==="colorbox"?0:C),q=M):a==="angl"?(C=Math.max(e.fontMetrics().defaultRuleThickness,e.minRuleThickness),M=4*C,q=Math.max(0,.25-t.depth)):(M=h?.2:0,q=M),s=Za(t,a,M,q,e),/fbox|boxed|fcolorbox/.test(a)?(s.style.borderStyle="solid",s.style.borderWidth=A(C)):a==="angl"&&C!==.049&&(s.style.borderTopWidth=A(C),s.style.borderRightWidth=A(C)),u=t.depth+q,r.backgroundColor&&(s.style.backgroundColor=r.backgroundColor,r.borderColor&&(s.style.borderColor=r.borderColor))}var R;if(r.backgroundColor)R=V({positionType:"individualShift",children:[{type:"elem",elem:s,shift:u},{type:"elem",elem:t,shift:0}]});else{var F=/cancel|phase/.test(a)?["svg-align"]:[];R=V({positionType:"individualShift",children:[{type:"elem",elem:t,shift:0},{type:"elem",elem:s,shift:u,wrapperClasses:F}]})}return/cancel/.test(a)&&(R.height=t.height,R.depth=t.depth),/cancel/.test(a)&&!h?k(["mord","cancel-lap"],[R],e):k(["mord"],[R],e)},$e=(r,e)=>{var t,a=new z(r.label.includes("colorbox")?"mpadded":"menclose",[$(r.body,e)]);switch(r.label){case"\\cancel":a.setAttribute("notation","updiagonalstrike");break;case"\\bcancel":a.setAttribute("notation","downdiagonalstrike");break;case"\\phase":a.setAttribute("notation","phasorangle");break;case"\\sout":a.setAttribute("notation","horizontalstrike");break;case"\\fbox":a.setAttribute("notation","box");break;case"\\angl":a.setAttribute("notation","actuarial");break;case"\\fcolorbox":case"\\colorbox":if(t=e.fontMetrics().fboxsep*e.fontMetrics().ptPerEm,a.setAttribute("width","+"+2*t+"pt"),a.setAttribute("height","+"+2*t+"pt"),a.setAttribute("lspace",t+"pt"),a.setAttribute("voffset",t+"pt"),r.label==="\\fcolorbox"){var i=Math.max(e.fontMetrics().fboxrule,e.minRuleThickness);a.setAttribute("style","border: "+A(i)+" solid "+r.borderColor)}break;case"\\xcancel":a.setAttribute("notation","updiagonalstrike downdiagonalstrike");break}return r.backgroundColor&&a.setAttribute("mathbackground",r.backgroundColor),a};B({type:"enclose",names:["\\colorbox"],props:{numArgs:2,allowedInText:!0,argTypes:["color","hbox"]},handler(r,e,t){var{parser:a,funcName:i}=r,s=H(e[0],"color-token").color,u=e[1];return{type:"enclose",mode:a.mode,label:i,backgroundColor:s,body:u}},htmlBuilder:Ye,mathmlBuilder:$e});B({type:"enclose",names:["\\fcolorbox"],props:{numArgs:3,allowedInText:!0,argTypes:["color","color","hbox"]},handler(r,e,t){var{parser:a,funcName:i}=r,s=H(e[0],"color-token").color,u=H(e[1],"color-token").color,h=e[2];return{type:"enclose",mode:a.mode,label:i,backgroundColor:u,borderColor:s,body:h}},htmlBuilder:Ye,mathmlBuilder:$e});B({type:"enclose",names:["\\fbox"],props:{numArgs:1,argTypes:["hbox"],allowedInText:!0},handler(r,e){var{parser:t}=r;return{type:"enclose",mode:t.mode,label:"\\fbox",body:e[0]}}});B({type:"enclose",names:["\\cancel","\\bcancel","\\xcancel","\\phase"],props:{numArgs:1},handler(r,e){var{parser:t,funcName:a}=r,i=e[0];return{type:"enclose",mode:t.mode,label:a,body:i}},htmlBuilder:Ye,mathmlBuilder:$e});B({type:"enclose",names:["\\sout"],props:{numArgs:1,allowedInText:!0},handler(r,e){var{parser:t,funcName:a}=r;t.mode==="math"&&t.settings.reportNonstrict("mathVsSout","LaTeX's \\sout works only in text mode");var i=e[0];return{type:"enclose",mode:t.mode,label:a,body:i}},htmlBuilder:Ye,mathmlBuilder:$e});B({type:"enclose",names:["\\angl"],props:{numArgs:1,argTypes:["hbox"],allowedInText:!1},handler(r,e){var{parser:t}=r;return{type:"enclose",mode:t.mode,label:"\\angl",body:e[0]}}});var y1={};function S0(r){for(var{type:e,names:t,props:a,handler:i,htmlBuilder:s,mathmlBuilder:u}=r,h={type:e,numArgs:a.numArgs||0,allowedInText:!1,numOptionalArgs:0,handler:i},c=0;c{var e=r.parser.settings;if(!e.displayMode)throw new S("{"+r.envName+"} can be used only in display mode.")},v4=new Set(["gather","gather*"]);function Ut(r){if(!r.includes("ed"))return!r.includes("*")}function V0(r,e,t){var{hskipBeforeAndAfter:a,addJot:i,cols:s,arraystretch:u,colSeparationType:h,autoTag:c,singleRow:v,emptySingleRow:p,maxNumCols:b,leqno:x}=e;if(r.gullet.beginGroup(),v||r.gullet.macros.set("\\cr","\\\\\\relax"),!u){var y=r.gullet.expandMacroAsText("\\arraystretch");if(y==null)u=1;else if(u=parseFloat(y),!u||u<0)throw new S("Invalid \\arraystretch: "+y)}r.gullet.beginGroup();var T=[],M=[T],q=[],C=[],R=c!=null?[]:void 0;function F(){c&&r.gullet.macros.set("\\@eqnsw","1",!0)}function L(){R&&(r.gullet.macros.get("\\df@tag")?(R.push(r.subparse([new c0("\\df@tag")])),r.gullet.macros.set("\\df@tag",void 0,!0)):R.push(!!c&&r.gullet.macros.get("\\@eqnsw")==="1"))}for(F(),C.push(zr(r));;){var O=r.parseExpression(!1,v?"\\end":"\\\\");r.gullet.endGroup(),r.gullet.beginGroup();var P={type:"ordgroup",mode:r.mode,body:O};t&&(P={type:"styling",mode:r.mode,style:t,resetFont:!0,body:[P]}),T.push(P);var G=r.fetch().text;if(G==="&"){if(b&&T.length===b){if(v||h)throw new S("Too many tab characters: &",r.nextToken);r.settings.reportNonstrict("textEnv","Too few columns specified in the {array} column argument.")}r.consume()}else if(G==="\\end"){L(),T.length===1&&P.type==="styling"&&P.body.length===1&&P.body[0].type==="ordgroup"&&P.body[0].body.length===0&&(M.length>1||!p)&&M.pop(),C.length0&&(F+=.25),v.push({pos:F,isDashed:ye[xe]})}for(L(u[0]),a=0;a0&&(m0+=R,Gye))for(a=0;a=h)){var J0=void 0;if(i>0||e.hskipBeforeAndAfter){var Kt,Jt;J0=(Kt=(Jt=y0)==null?void 0:Jt.pregap)!=null?Kt:x,J0!==0&&(b0=k(["arraycolsep"],[]),b0.style.width=A(J0),x0.push(b0))}var Qt=[];for(a=0;a0){for(var G1=te("hline",t,p),U1=te("hdashline",t,p),Ke=[{type:"elem",elem:be,shift:0}];v.length>0;){var tr=v.pop(),rr=tr.pos-Q;tr.isDashed?Ke.push({type:"elem",elem:U1,shift:rr}):Ke.push({type:"elem",elem:G1,shift:rr})}be=V({positionType:"individualShift",children:Ke})}if(j0.length===0)return k(["mord"],[be],t);var V1=V({positionType:"individualShift",children:j0}),X1=k(["tag"],[V1],t);return E0([be,X1])},p4={c:"center ",l:"left ",r:"right "},A0=function(e,t){for(var a=[],i=new z("mtd",[],["mtr-glue"]),s=new z("mtd",[],["mml-eqn-num"]),u=0;u0){var T=e.cols,M="",q=!1,C=0,R=T.length;T[0].type==="separator"&&(x+="top ",C=1),T[T.length-1].type==="separator"&&(x+="bottom ",R-=1);for(var F=C;F0?"left ":"",x+=U[U.length-1].length>0?"right ":"";for(var o0=1;o00&&y&&(q=1),a[T]={type:"align",align:M,pregap:q,postgap:0}}return u.colSeparationType=y?"align":"alignat",u};S0({type:"array",names:["array","darray"],props:{numArgs:1},handler(r,e){var t=Ue(e[0]),a=t?[e[0]]:H(e[0],"ordgroup").body,i=a.map(function(u){var h=Ge(u),c=h.text;if("lcr".includes(c))return{type:"align",align:c};if(c==="|")return{type:"separator",separator:"|"};if(c===":")return{type:"separator",separator:":"};throw new S("Unknown column alignment: "+c,u)}),s={cols:i,hskipBeforeAndAfter:!0,maxNumCols:i.length};return V0(r.parser,s,Vt(r.envName))},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["matrix","pmatrix","bmatrix","Bmatrix","vmatrix","Vmatrix","matrix*","pmatrix*","bmatrix*","Bmatrix*","vmatrix*","Vmatrix*"],props:{numArgs:0},handler(r){var e={matrix:null,pmatrix:["(",")"],bmatrix:["[","]"],Bmatrix:["\\{","\\}"],vmatrix:["|","|"],Vmatrix:["\\Vert","\\Vert"]}[r.envName.replace("*","")],t="c",a={hskipBeforeAndAfter:!1,cols:[{type:"align",align:t}]};if(r.envName.charAt(r.envName.length-1)==="*"){var i=r.parser;if(i.consumeSpaces(),i.fetch().text==="["){if(i.consume(),i.consumeSpaces(),t=i.fetch().text,!"lcr".includes(t))throw new S("Expected l or c or r",i.nextToken);i.consume(),i.consumeSpaces(),i.expect("]"),i.consume(),a.cols=[{type:"align",align:t}]}}var s=V0(r.parser,a,Vt(r.envName)),u=Math.max(0,...s.body.map(h=>h.length));return s.cols=new Array(u).fill({type:"align",align:t}),e?{type:"leftright",mode:r.mode,body:[s],left:e[0],right:e[1],rightColor:void 0}:s},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["smallmatrix"],props:{numArgs:0},handler(r){var e={arraystretch:.5},t=V0(r.parser,e,"script");return t.colSeparationType="small",t},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["subarray"],props:{numArgs:1},handler(r,e){var t=Ue(e[0]),a=t?[e[0]]:H(e[0],"ordgroup").body,i=a.map(function(h){var c=Ge(h),v=c.text;if("lc".includes(v))return{type:"align",align:v};throw new S("Unknown column alignment: "+v,h)});if(i.length>1)throw new S("{subarray} can contain only one column");var s={cols:i,hskipBeforeAndAfter:!1,arraystretch:.5},u=V0(r.parser,s,"script");if(u.body.length>0&&u.body[0].length>1)throw new S("{subarray} can contain only one column");return u},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["cases","dcases","rcases","drcases"],props:{numArgs:0},handler(r){var e={arraystretch:1.2,cols:[{type:"align",align:"l",pregap:0,postgap:1},{type:"align",align:"l",pregap:0,postgap:0}]},t=V0(r.parser,e,Vt(r.envName));return{type:"leftright",mode:r.mode,body:[t],left:r.envName.includes("r")?".":"\\{",right:r.envName.includes("r")?"\\}":".",rightColor:void 0}},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["align","align*","aligned","split"],props:{numArgs:0},handler:w1,htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["gathered","gather","gather*"],props:{numArgs:0},handler(r){v4.has(r.envName)&&We(r);var e={cols:[{type:"align",align:"c"}],addJot:!0,colSeparationType:"gather",autoTag:Ut(r.envName),emptySingleRow:!0,leqno:r.parser.settings.leqno};return V0(r.parser,e,"display")},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["alignat","alignat*","alignedat"],props:{numArgs:1},handler:w1,htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["equation","equation*"],props:{numArgs:0},handler(r){We(r);var e={autoTag:Ut(r.envName),emptySingleRow:!0,singleRow:!0,maxNumCols:1,leqno:r.parser.settings.leqno};return V0(r.parser,e,"display")},htmlBuilder:z0,mathmlBuilder:A0});S0({type:"array",names:["CD"],props:{numArgs:0},handler(r){return We(r),a4(r.parser)},htmlBuilder:z0,mathmlBuilder:A0});m("\\nonumber","\\gdef\\@eqnsw{0}");m("\\notag","\\nonumber");B({type:"text",names:["\\hline","\\hdashline"],props:{numArgs:0,allowedInText:!0,allowedInMath:!0},handler(r,e){throw new S(r.funcName+" valid only within array environment")}});var Ar=y1;B({type:"environment",names:["\\begin","\\end"],props:{numArgs:1,argTypes:["text"]},handler(r,e){var{parser:t,funcName:a}=r,i=e[0];if(i.type!=="ordgroup")throw new S("Invalid environment name",i);for(var s="",u=0;u{var t=r.font,a=e.withFont(t);return X(r.body,a)},S1=(r,e)=>{var t=r.font,a=e.withFont(t);return $(r.body,a)},Mr={"\\Bbb":"\\mathbb","\\bold":"\\mathbf","\\frak":"\\mathfrak"};B({type:"font",names:["\\mathrm","\\mathit","\\mathbf","\\mathnormal","\\mathsfit","\\mathbb","\\mathcal","\\mathfrak","\\mathscr","\\mathsf","\\mathtt","\\Bbb","\\bold","\\frak"],props:{numArgs:1,allowedInArgument:!0},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=Ne(e[0]),s=a;return s in Mr&&(s=Mr[s]),{type:"font",mode:t.mode,font:s.slice(1),body:i}},htmlBuilder:k1,mathmlBuilder:S1});B({type:"mclass",names:["\\boldsymbol","\\bm"],props:{numArgs:1},handler:(r,e)=>{var{parser:t}=r,a=e[0];return{type:"mclass",mode:t.mode,mclass:Ve(a),body:[{type:"font",mode:t.mode,font:"boldsymbol",body:a}],isCharacterBox:D0(a)}}});B({type:"font",names:["\\rm","\\sf","\\tt","\\bf","\\it","\\cal"],props:{numArgs:0,allowedInText:!0},handler:(r,e)=>{var{parser:t,funcName:a,breakOnTokenText:i}=r,{mode:s}=t,u=t.parseExpression(!0,i);return{type:"font",mode:s,font:"math"+a.slice(1),body:{type:"ordgroup",mode:t.mode,body:u}}},htmlBuilder:k1,mathmlBuilder:S1});var g4=(r,e)=>{var t=e.style,a=t.fracNum(),i=t.fracDen(),s;s=e.havingStyle(a);var u=X(r.numer,s,e);if(r.continued){var h=8.5/e.fontMetrics().ptPerEm,c=3.5/e.fontMetrics().ptPerEm;u.height=u.height0?T=3*x:T=7*x,M=e.fontMetrics().denom1):(b>0?(y=e.fontMetrics().num2,T=x):(y=e.fontMetrics().num3,T=3*x),M=e.fontMetrics().denom2);var q;if(p){var R=e.fontMetrics().axisHeight;y-u.depth-(R+.5*b){var t=new z("mfrac",[$(r.numer,e),$(r.denom,e)]);if(!r.hasBarLine)t.setAttribute("linethickness","0px");else if(r.barSize){var a=K(r.barSize,e);t.setAttribute("linethickness",A(a))}if(r.leftDelim!=null||r.rightDelim!=null){var i=[];if(r.leftDelim!=null){var s=new z("mo",[new e0(r.leftDelim.replace("\\",""))]);s.setAttribute("fence","true"),i.push(s)}if(i.push(t),r.rightDelim!=null){var u=new z("mo",[new e0(r.rightDelim.replace("\\",""))]);u.setAttribute("fence","true"),i.push(u)}return Ot(i)}return t},z1=(r,e)=>{if(!e)return r;var t={type:"styling",mode:r.mode,style:e,body:[r]};return t};B({type:"genfrac",names:["\\cfrac","\\dfrac","\\frac","\\tfrac","\\dbinom","\\binom","\\tbinom","\\\\atopfrac","\\\\bracefrac","\\\\brackfrac"],props:{numArgs:2,allowedInArgument:!0},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=e[0],s=e[1],u,h=null,c=null;switch(a){case"\\cfrac":case"\\dfrac":case"\\frac":case"\\tfrac":u=!0;break;case"\\\\atopfrac":u=!1;break;case"\\dbinom":case"\\binom":case"\\tbinom":u=!1,h="(",c=")";break;case"\\\\bracefrac":u=!1,h="\\{",c="\\}";break;case"\\\\brackfrac":u=!1,h="[",c="]";break;default:throw new Error("Unrecognized genfrac command")}var v=a==="\\cfrac",p=null;return v||a.startsWith("\\d")?p="display":a.startsWith("\\t")&&(p="text"),z1({type:"genfrac",mode:t.mode,numer:i,denom:s,continued:v,hasBarLine:u,leftDelim:h,rightDelim:c,barSize:null},p)},htmlBuilder:g4,mathmlBuilder:b4});B({type:"infix",names:["\\over","\\choose","\\atop","\\brace","\\brack"],props:{numArgs:0,infix:!0},handler(r){var{parser:e,funcName:t,token:a}=r,i;switch(t){case"\\over":i="\\frac";break;case"\\choose":i="\\binom";break;case"\\atop":i="\\\\atopfrac";break;case"\\brace":i="\\\\bracefrac";break;case"\\brack":i="\\\\brackfrac";break;default:throw new Error("Unrecognized infix genfrac command")}return{type:"infix",mode:e.mode,replaceWith:i,token:a}}});var Tr=["display","text","script","scriptscript"],Br=function(e){var t=null;return e.length>0&&(t=e,t=t==="."?null:t),t};B({type:"genfrac",names:["\\genfrac"],props:{numArgs:6,allowedInArgument:!0,argTypes:["math","math","size","text","math","math"]},handler(r,e){var{parser:t}=r,a=e[4],i=e[5],s=Ne(e[0]),u=s.type==="atom"&&s.family==="open"?Br(s.text):null,h=Ne(e[1]),c=h.type==="atom"&&h.family==="close"?Br(h.text):null,v=H(e[2],"size"),p,b=null;v.isBlank?p=!0:(b=v.value,p=b.number>0);var x=null,y=e[3];if(y.type==="ordgroup"){if(y.body.length>0){var T=H(y.body[0],"textord");x=Tr[Number(T.text)]}}else y=H(y,"textord"),x=Tr[Number(y.text)];return z1({type:"genfrac",mode:t.mode,numer:a,denom:i,continued:!1,hasBarLine:p,barSize:b,leftDelim:u,rightDelim:c},x)}});B({type:"infix",names:["\\above"],props:{numArgs:1,argTypes:["size"],infix:!0},handler(r,e){var{parser:t,funcName:a,token:i}=r;return{type:"infix",mode:t.mode,replaceWith:"\\\\abovefrac",size:H(e[0],"size").value,token:i}}});B({type:"genfrac",names:["\\\\abovefrac"],props:{numArgs:3,argTypes:["math","size","math"]},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=e[0],s=H(e[1],"infix").size;if(!s)throw new Error("\\\\abovefrac expected size, but got "+String(s));var u=e[2],h=s.number>0;return{type:"genfrac",mode:t.mode,numer:i,denom:u,continued:!1,hasBarLine:h,barSize:s,leftDelim:null,rightDelim:null}}});var A1=(r,e)=>{var t=e.style,a,i;r.type==="supsub"?(a=r.sup?X(r.sup,e.havingStyle(t.sup()),e):X(r.sub,e.havingStyle(t.sub()),e),i=H(r.base,"horizBrace")):i=H(r,"horizBrace");var s=X(i.base,e.havingBaseStyle(N.DISPLAY)),u=Pe(i,e),h;if(i.isOver?h=V({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"kern",size:.1},{type:"elem",elem:u,wrapperClasses:["svg-align"]}]}):h=V({positionType:"bottom",positionData:s.depth+.1+u.height,children:[{type:"elem",elem:u,wrapperClasses:["svg-align"]},{type:"kern",size:.1},{type:"elem",elem:s}]}),a){var c=k(["minner",i.isOver?"mover":"munder"],[h],e);i.isOver?h=V({positionType:"firstBaseline",children:[{type:"elem",elem:c},{type:"kern",size:.2},{type:"elem",elem:a}]}):h=V({positionType:"bottom",positionData:c.depth+.2+a.height+a.depth,children:[{type:"elem",elem:a},{type:"kern",size:.2},{type:"elem",elem:c}]})}return k(["minner",i.isOver?"mover":"munder"],[h],e)},y4=(r,e)=>{var t=Le(r.label);return new z(r.isOver?"mover":"munder",[$(r.base,e),t])};B({type:"horizBrace",names:["\\overbrace","\\underbrace","\\overbracket","\\underbracket"],props:{numArgs:1},handler(r,e){var{parser:t,funcName:a}=r;return{type:"horizBrace",mode:t.mode,label:a,isOver:a.includes("\\over"),base:e[0]}},htmlBuilder:A1,mathmlBuilder:y4});B({type:"href",names:["\\href"],props:{numArgs:2,argTypes:["url","original"],allowedInText:!0},handler:(r,e)=>{var{parser:t}=r,a=e[1],i=H(e[0],"url").url;return t.settings.isTrusted({command:"\\href",url:i})?{type:"href",mode:t.mode,href:i,body:_(a)}:t.formatUnsupportedCmd("\\href")},htmlBuilder:(r,e)=>{var t=a0(r.body,e,!1);return Ea(r.href,[],t,e)},mathmlBuilder:(r,e)=>{var t=U0(r.body,e);return t instanceof z||(t=new z("mrow",[t])),t.setAttribute("href",r.href),t}});B({type:"href",names:["\\url"],props:{numArgs:1,argTypes:["url"],allowedInText:!0},handler:(r,e)=>{var{parser:t}=r,a=H(e[0],"url").url;if(!t.settings.isTrusted({command:"\\url",url:a}))return t.formatUnsupportedCmd("\\url");for(var i=[],s=0;s{var{parser:t,funcName:a,token:i}=r,s=H(e[0],"raw").string,u=e[1];t.settings.strict&&t.settings.reportNonstrict("htmlExtension","HTML extension is disabled on strict mode");var h,c={};switch(a){case"\\htmlClass":c.class=s,h={command:"\\htmlClass",class:s};break;case"\\htmlId":c.id=s,h={command:"\\htmlId",id:s};break;case"\\htmlStyle":c.style=s,h={command:"\\htmlStyle",style:s};break;case"\\htmlData":{for(var v=s.split(","),p=0;p{var t=a0(r.body,e,!1),a=["enclosing"];r.attributes.class&&a.push(...r.attributes.class.trim().split(/\s+/));var i=k(a,t,e);for(var s in r.attributes)s!=="class"&&r.attributes.hasOwnProperty(s)&&i.setAttribute(s,r.attributes[s]);return i},mathmlBuilder:(r,e)=>U0(r.body,e)});B({type:"htmlmathml",names:["\\html@mathml"],props:{numArgs:2,allowedInArgument:!0,allowedInText:!0},handler:(r,e)=>{var{parser:t}=r;return{type:"htmlmathml",mode:t.mode,html:_(e[0]),mathml:_(e[1])}},htmlBuilder:(r,e)=>{var t=a0(r.html,e,!1);return E0(t)},mathmlBuilder:(r,e)=>U0(r.mathml,e)});var ot=function(e){if(/^[-+]? *(\d+(\.\d*)?|\.\d+)$/.test(e))return{number:+e,unit:"bp"};var t=/([-+]?) *(\d+(?:\.\d*)?|\.\d+) *([a-z]{2})/.exec(e);if(!t)throw new S("Invalid size: '"+e+"' in \\includegraphics");var a={number:+(t[1]+t[2]),unit:t[3]};if(!Ur(a))throw new S("Invalid unit: '"+a.unit+"' in \\includegraphics.");return a};B({type:"includegraphics",names:["\\includegraphics"],props:{numArgs:1,numOptionalArgs:1,argTypes:["raw","url"],allowedInText:!1},handler:(r,e,t)=>{var{parser:a}=r,i={number:0,unit:"em"},s={number:.9,unit:"em"},u={number:0,unit:"em"},h="";if(t[0])for(var c=H(t[0],"raw").string,v=c.split(","),p=0;p{var t=K(r.height,e),a=0;r.totalheight.number>0&&(a=K(r.totalheight,e)-t);var i=0;r.width.number>0&&(i=K(r.width,e));var s={height:A(t+a)};i>0&&(s.width=A(i)),a>0&&(s.verticalAlign=A(-a));var u=new xa(r.src,r.alt,s);return u.height=t,u.depth=a,u},mathmlBuilder:(r,e)=>{var t=new z("mglyph",[]);t.setAttribute("alt",r.alt);var a=K(r.height,e),i=0;if(r.totalheight.number>0&&(i=K(r.totalheight,e)-a,t.setAttribute("valign",A(-i))),t.setAttribute("height",A(a+i)),r.width.number>0){var s=K(r.width,e);t.setAttribute("width",A(s))}return t.setAttribute("src",r.src),t}});B({type:"kern",names:["\\kern","\\mkern","\\hskip","\\mskip"],props:{numArgs:1,argTypes:["size"],primitive:!0,allowedInText:!0},handler(r,e){var{parser:t,funcName:a}=r,i=H(e[0],"size");if(t.settings.strict){var s=a[1]==="m",u=i.value.unit==="mu";s?(u||t.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+a+" supports only mu units, "+("not "+i.value.unit+" units")),t.mode!=="math"&&t.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+a+" works only in math mode")):u&&t.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+a+" doesn't support mu units")}return{type:"kern",mode:t.mode,dimension:i.value}},htmlBuilder(r,e){return jr(r.dimension,e)},mathmlBuilder(r,e){var t=K(r.dimension,e);return new e1(t)}});B({type:"lap",names:["\\mathllap","\\mathrlap","\\mathclap"],props:{numArgs:1,allowedInText:!0},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=e[0];return{type:"lap",mode:t.mode,alignment:a.slice(5),body:i}},htmlBuilder:(r,e)=>{var t;r.alignment==="clap"?(t=k([],[X(r.body,e)]),t=k(["inner"],[t],e)):t=k(["inner"],[X(r.body,e)]);var a=k(["fix"],[]),i=k([r.alignment],[t,a],e),s=k(["strut"]);return s.style.height=A(i.height+i.depth),i.depth&&(s.style.verticalAlign=A(-i.depth)),i.children.unshift(s),i=k(["thinbox"],[i],e),k(["mord","vbox"],[i],e)},mathmlBuilder:(r,e)=>{var t=new z("mpadded",[$(r.body,e)]);if(r.alignment!=="rlap"){var a=r.alignment==="llap"?"-1":"-0.5";t.setAttribute("lspace",a+"width")}return t.setAttribute("width","0px"),t}});B({type:"styling",names:["\\(","$"],props:{numArgs:0,allowedInText:!0,allowedInMath:!1},handler(r,e){var{funcName:t,parser:a}=r,i=a.mode;a.switchMode("math");var s=t==="\\("?"\\)":"$",u=a.parseExpression(!1,s);return a.expect(s),a.switchMode(i),{type:"styling",mode:a.mode,style:"text",resetFont:!0,body:u}}});B({type:"text",names:["\\)","\\]"],props:{numArgs:0,allowedInText:!0,allowedInMath:!1},handler(r,e){throw new S("Mismatched "+r.funcName)}});var Cr=(r,e)=>{switch(e.style.size){case N.DISPLAY.size:return r.display;case N.TEXT.size:return r.text;case N.SCRIPT.size:return r.script;case N.SCRIPTSCRIPT.size:return r.scriptscript;default:return r.text}};B({type:"mathchoice",names:["\\mathchoice"],props:{numArgs:4,primitive:!0},handler:(r,e)=>{var{parser:t}=r;return{type:"mathchoice",mode:t.mode,display:_(e[0]),text:_(e[1]),script:_(e[2]),scriptscript:_(e[3])}},htmlBuilder:(r,e)=>{var t=Cr(r,e),a=a0(t,e,!1);return E0(a)},mathmlBuilder:(r,e)=>{var t=Cr(r,e);return U0(t,e)}});var M1=(r,e,t,a,i,s,u)=>{r=k([],[r]);var h=t&&D0(t),c,v;if(e){var p=X(e,a.havingStyle(i.sup()),a);v={elem:p,kern:Math.max(a.fontMetrics().bigOpSpacing1,a.fontMetrics().bigOpSpacing3-p.depth)}}if(t){var b=X(t,a.havingStyle(i.sub()),a);c={elem:b,kern:Math.max(a.fontMetrics().bigOpSpacing2,a.fontMetrics().bigOpSpacing4-b.height)}}var x;if(v&&c){var y=a.fontMetrics().bigOpSpacing5+c.elem.height+c.elem.depth+c.kern+r.depth+u;x=V({positionType:"bottom",positionData:y,children:[{type:"kern",size:a.fontMetrics().bigOpSpacing5},{type:"elem",elem:c.elem,marginLeft:A(-s)},{type:"kern",size:c.kern},{type:"elem",elem:r},{type:"kern",size:v.kern},{type:"elem",elem:v.elem,marginLeft:A(s)},{type:"kern",size:a.fontMetrics().bigOpSpacing5}]})}else if(c){var T=r.height-u;x=V({positionType:"top",positionData:T,children:[{type:"kern",size:a.fontMetrics().bigOpSpacing5},{type:"elem",elem:c.elem,marginLeft:A(-s)},{type:"kern",size:c.kern},{type:"elem",elem:r}]})}else if(v){var M=r.depth+u;x=V({positionType:"bottom",positionData:M,children:[{type:"elem",elem:r},{type:"kern",size:v.kern},{type:"elem",elem:v.elem,marginLeft:A(s)},{type:"kern",size:a.fontMetrics().bigOpSpacing5}]})}else return r;var q=[x];if(c&&s!==0&&!h){var C=k(["mspace"],[],a);C.style.marginRight=A(s),q.unshift(C)}return k(["mop","op-limits"],q,a)},T1=new Set(["\\smallint"]),se=(r,e)=>{var t,a,i=!1,s;r.type==="supsub"?(t=r.sup,a=r.sub,s=H(r.base,"op"),i=!0):s=H(r,"op");var u=e.style,h=!1;u.size===N.DISPLAY.size&&s.symbol&&!T1.has(s.name)&&(h=!0);var c,v;if(s.symbol){var p=h?"Size2-Regular":"Size1-Regular",b="";if((s.name==="\\oiint"||s.name==="\\oiiint")&&(b=s.name.slice(1),s.name=b==="oiint"?"\\iint":"\\iiint"),c=s0(s.name,p,"math",e,["mop","op-symbol",h?"large-op":"small-op"]),v=c.italic,b.length>0){var x=Kr(b+"Size"+(h?"2":"1"),e);c=V({positionType:"individualShift",children:[{type:"elem",elem:c,shift:0},{type:"elem",elem:x,shift:h?.08:0}]}),s.name="\\"+b,c.classes.unshift("mop"),c.italic=v}}else if(s.body){var y=a0(s.body,e,!0);y.length===1&&y[0]instanceof d0?(c=y[0],c.classes[0]="mop"):c=k(["mop"],y,e)}else{for(var T=[],M=1;M{var t;if(r.symbol)t=new z("mo",[g0(r.name,r.mode)]),T1.has(r.name)&&t.setAttribute("largeop","false");else if(r.body)t=new z("mo",v0(r.body,e));else{t=new z("mi",[new e0(r.name.slice(1))]);var a=new z("mo",[g0("⁡","text")]);r.parentIsSupSub?t=new z("mrow",[t,a]):t=_r([t,a])}return t},x4={"∏":"\\prod","∐":"\\coprod","∑":"\\sum","⋀":"\\bigwedge","⋁":"\\bigvee","⋂":"\\bigcap","⋃":"\\bigcup","⨀":"\\bigodot","⨁":"\\bigoplus","⨂":"\\bigotimes","⨄":"\\biguplus","⨆":"\\bigsqcup"};B({type:"op",names:["\\coprod","\\bigvee","\\bigwedge","\\biguplus","\\bigcap","\\bigcup","\\intop","\\prod","\\sum","\\bigotimes","\\bigoplus","\\bigodot","\\bigsqcup","\\smallint","∏","∐","∑","⋀","⋁","⋂","⋃","⨀","⨁","⨂","⨄","⨆"],props:{numArgs:0},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=a;return i.length===1&&(i=x4[i]),{type:"op",mode:t.mode,limits:!0,parentIsSupSub:!1,symbol:!0,name:i}},htmlBuilder:se,mathmlBuilder:fe});B({type:"op",names:["\\mathop"],props:{numArgs:1,primitive:!0},handler:(r,e)=>{var{parser:t}=r,a=e[0];return{type:"op",mode:t.mode,limits:!1,parentIsSupSub:!1,symbol:!1,body:_(a)}},htmlBuilder:se,mathmlBuilder:fe});var w4={"∫":"\\int","∬":"\\iint","∭":"\\iiint","∮":"\\oint","∯":"\\oiint","∰":"\\oiiint"};B({type:"op",names:["\\arcsin","\\arccos","\\arctan","\\arctg","\\arcctg","\\arg","\\ch","\\cos","\\cosec","\\cosh","\\cot","\\cotg","\\coth","\\csc","\\ctg","\\cth","\\deg","\\dim","\\exp","\\hom","\\ker","\\lg","\\ln","\\log","\\sec","\\sin","\\sinh","\\sh","\\tan","\\tanh","\\tg","\\th"],props:{numArgs:0},handler(r){var{parser:e,funcName:t}=r;return{type:"op",mode:e.mode,limits:!1,parentIsSupSub:!1,symbol:!1,name:t}},htmlBuilder:se,mathmlBuilder:fe});B({type:"op",names:["\\det","\\gcd","\\inf","\\lim","\\max","\\min","\\Pr","\\sup"],props:{numArgs:0},handler(r){var{parser:e,funcName:t}=r;return{type:"op",mode:e.mode,limits:!0,parentIsSupSub:!1,symbol:!1,name:t}},htmlBuilder:se,mathmlBuilder:fe});B({type:"op",names:["\\int","\\iint","\\iiint","\\oint","\\oiint","\\oiiint","∫","∬","∭","∮","∯","∰"],props:{numArgs:0,allowedInArgument:!0},handler(r){var{parser:e,funcName:t}=r,a=t;return a.length===1&&(a=w4[a]),{type:"op",mode:e.mode,limits:!1,parentIsSupSub:!1,symbol:!0,name:a}},htmlBuilder:se,mathmlBuilder:fe});var B1=(r,e)=>{var t,a,i=!1,s;r.type==="supsub"?(t=r.sup,a=r.sub,s=H(r.base,"operatorname"),i=!0):s=H(r,"operatorname");var u;if(s.body.length>0){for(var h=s.body.map(b=>{var x="text"in b?b.text:void 0;return typeof x=="string"?{type:"textord",mode:b.mode,text:x}:b}),c=a0(h,e.withFont("mathrm"),!0),v=0;v{for(var t=v0(r.body,e.withFont("mathrm")),a=!0,i=0;ip.toText()).join("");t=[new e0(h)]}var c=new z("mi",t);c.setAttribute("mathvariant","normal");var v=new z("mo",[g0("⁡","text")]);return r.parentIsSupSub?new z("mrow",[c,v]):_r([c,v])};B({type:"operatorname",names:["\\operatorname@","\\operatornamewithlimits"],props:{numArgs:1},handler:(r,e)=>{var{parser:t,funcName:a}=r,i=e[0];return{type:"operatorname",mode:t.mode,body:_(i),alwaysHandleSupSub:a==="\\operatornamewithlimits",limits:!1,parentIsSupSub:!1}},htmlBuilder:B1,mathmlBuilder:k4});m("\\operatorname","\\@ifstar\\operatornamewithlimits\\operatorname@");W0({type:"ordgroup",htmlBuilder(r,e){return r.semisimple?E0(a0(r.body,e,!1)):k(["mord"],a0(r.body,e,!0),e)},mathmlBuilder(r,e){return U0(r.body,e,!0)}});B({type:"overline",names:["\\overline"],props:{numArgs:1},handler(r,e){var{parser:t}=r,a=e[0];return{type:"overline",mode:t.mode,body:a}},htmlBuilder(r,e){var t=X(r.body,e.havingCrampedStyle()),a=te("overline-line",e),i=e.fontMetrics().defaultRuleThickness,s=V({positionType:"firstBaseline",children:[{type:"elem",elem:t},{type:"kern",size:3*i},{type:"elem",elem:a},{type:"kern",size:i}]});return k(["mord","overline"],[s],e)},mathmlBuilder(r,e){var t=new z("mo",[new e0("‾")]);t.setAttribute("stretchy","true");var a=new z("mover",[$(r.body,e),t]);return a.setAttribute("accent","true"),a}});B({type:"phantom",names:["\\phantom"],props:{numArgs:1,allowedInText:!0},handler:(r,e)=>{var{parser:t}=r,a=e[0];return{type:"phantom",mode:t.mode,body:_(a)}},htmlBuilder:(r,e)=>{var t=a0(r.body,e.withPhantom(),!1);return E0(t)},mathmlBuilder:(r,e)=>{var t=v0(r.body,e);return new z("mphantom",t)}});m("\\hphantom","\\smash{\\phantom{#1}}");B({type:"vphantom",names:["\\vphantom"],props:{numArgs:1,allowedInText:!0},handler:(r,e)=>{var{parser:t}=r,a=e[0];return{type:"vphantom",mode:t.mode,body:a}},htmlBuilder:(r,e)=>{var t=k(["inner"],[X(r.body,e.withPhantom())]),a=k(["fix"],[]);return k(["mord","rlap"],[t,a],e)},mathmlBuilder:(r,e)=>{var t=v0(_(r.body),e),a=new z("mphantom",t),i=new z("mpadded",[a]);return i.setAttribute("width","0px"),i}});B({type:"raisebox",names:["\\raisebox"],props:{numArgs:2,argTypes:["size","hbox"],allowedInText:!0},handler(r,e){var{parser:t}=r,a=H(e[0],"size").value,i=e[1];return{type:"raisebox",mode:t.mode,dy:a,body:i}},htmlBuilder(r,e){var t=X(r.body,e),a=K(r.dy,e);return V({positionType:"shift",positionData:-a,children:[{type:"elem",elem:t}]})},mathmlBuilder(r,e){var t=new z("mpadded",[$(r.body,e)]),a=r.dy.number+r.dy.unit;return t.setAttribute("voffset",a),t}});B({type:"internal",names:["\\relax"],props:{numArgs:0,allowedInText:!0,allowedInArgument:!0},handler(r){var{parser:e}=r;return{type:"internal",mode:e.mode}}});B({type:"rule",names:["\\rule"],props:{numArgs:2,numOptionalArgs:1,allowedInText:!0,allowedInMath:!0,argTypes:["size","size","size"]},handler(r,e,t){var{parser:a}=r,i=t[0],s=H(e[0],"size"),u=H(e[1],"size");return{type:"rule",mode:a.mode,shift:i&&H(i,"size").value,width:s.value,height:u.value}},htmlBuilder(r,e){var t=k(["mord","rule"],[],e),a=K(r.width,e),i=K(r.height,e),s=r.shift?K(r.shift,e):0;return t.style.borderRightWidth=A(a),t.style.borderTopWidth=A(i),t.style.bottom=A(s),t.width=a,t.height=i+s,t.depth=-s,t.maxFontSize=i*1.125*e.sizeMultiplier,t},mathmlBuilder(r,e){var t=K(r.width,e),a=K(r.height,e),i=r.shift?K(r.shift,e):0,s=e.color&&e.getColor()||"black",u=new z("mspace");u.setAttribute("mathbackground",s),u.setAttribute("width",A(t)),u.setAttribute("height",A(a));var h=new z("mpadded",[u]);return i>=0?h.setAttribute("height",A(i)):(h.setAttribute("height",A(i)),h.setAttribute("depth",A(-i))),h.setAttribute("voffset",A(i)),h}});function C1(r,e,t){for(var a=a0(r,e,!1),i=e.sizeMultiplier/t.sizeMultiplier,s=0;s{var t=e.havingSize(r.size);return C1(r.body,t,e)};B({type:"sizing",names:Dr,props:{numArgs:0,allowedInText:!0},handler:(r,e)=>{var{breakOnTokenText:t,funcName:a,parser:i}=r,s=i.parseExpression(!1,t);return{type:"sizing",mode:i.mode,size:Dr.indexOf(a)+1,body:s}},htmlBuilder:S4,mathmlBuilder:(r,e)=>{var t=e.havingSize(r.size),a=v0(r.body,t),i=new z("mstyle",a);return i.setAttribute("mathsize",A(t.sizeMultiplier)),i}});B({type:"smash",names:["\\smash"],props:{numArgs:1,numOptionalArgs:1,allowedInText:!0},handler:(r,e,t)=>{var{parser:a}=r,i=!1,s=!1,u=t[0]&&H(t[0],"ordgroup");if(u)for(var h,c=0;c{var t=k([],[X(r.body,e)]);if(!r.smashHeight&&!r.smashDepth)return t;if(r.smashHeight&&(t.height=0),r.smashDepth&&(t.depth=0),r.smashHeight&&r.smashDepth)return k(["mord","smash"],[t],e);if(t.children)for(var a=0;a{var t=new z("mpadded",[$(r.body,e)]);return r.smashHeight&&t.setAttribute("height","0px"),r.smashDepth&&t.setAttribute("depth","0px"),t}});B({type:"sqrt",names:["\\sqrt"],props:{numArgs:1,numOptionalArgs:1},handler(r,e,t){var{parser:a}=r,i=t[0],s=e[0];return{type:"sqrt",mode:a.mode,body:s,index:i}},htmlBuilder(r,e){var t=X(r.body,e.havingCrampedStyle());t.height===0&&(t.height=e.fontMetrics().xHeight),t=re(t,e);var a=e.fontMetrics(),i=a.defaultRuleThickness,s=i;e.style.idt.height+t.depth+u&&(u=(u+b-t.height-t.depth)/2);var x=c.height-t.height-u-v;t.style.paddingLeft=A(p);var y=V({positionType:"firstBaseline",children:[{type:"elem",elem:t,wrapperClasses:["svg-align"]},{type:"kern",size:-(t.height+x)},{type:"elem",elem:c},{type:"kern",size:v}]});if(r.index){var T=e.havingStyle(N.SCRIPTSCRIPT),M=X(r.index,T,e),q=.6*(y.height-y.depth),C=V({positionType:"shift",positionData:-q,children:[{type:"elem",elem:M}]}),R=k(["root"],[C]);return k(["mord","sqrt"],[R,y],e)}else return k(["mord","sqrt"],[y],e)},mathmlBuilder(r,e){var{body:t,index:a}=r;return a?new z("mroot",[$(t,e),$(a,e)]):new z("msqrt",[$(t,e)])}});var Dt={display:N.DISPLAY,text:N.TEXT,script:N.SCRIPT,scriptscript:N.SCRIPTSCRIPT};function z4(r){return r in Dt}B({type:"styling",names:["\\displaystyle","\\textstyle","\\scriptstyle","\\scriptscriptstyle"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(r,e){var{breakOnTokenText:t,funcName:a,parser:i}=r,s=i.parseExpression(!0,t),u=a.slice(1,a.length-5);if(!z4(u))throw new Error("Unknown style: "+u);return{type:"styling",mode:i.mode,style:u,body:s}},htmlBuilder(r,e){var t=Dt[r.style],a=e.havingStyle(t);return r.resetFont&&(a=a.withFont("")),C1(r.body,a,e)},mathmlBuilder(r,e){var t=Dt[r.style],a=e.havingStyle(t);r.resetFont&&(a=a.withFont(""));var i=v0(r.body,a),s=new z("mstyle",i),u={display:["0","true"],text:["0","false"],script:["1","false"],scriptscript:["2","false"]},h=u[r.style];return s.setAttribute("scriptlevel",h[0]),s.setAttribute("displaystyle",h[1]),s}});var A4=function(e,t){var a=e.base;if(a)if(a.type==="op"){var i=a.limits&&(t.style.size===N.DISPLAY.size||a.alwaysHandleSupSub);return i?se:null}else if(a.type==="operatorname"){var s=a.alwaysHandleSupSub&&(t.style.size===N.DISPLAY.size||a.limits);return s?B1:null}else{if(a.type==="accent")return D0(a.base)?Pt:null;if(a.type==="horizBrace"){var u=!e.sub;return u===a.isOver?A1:null}else return null}else return null};W0({type:"supsub",htmlBuilder(r,e){var t=A4(r,e);if(t)return t(r,e);var{base:a,sup:i,sub:s}=r,u=X(a,e),h,c,v=e.fontMetrics(),p=0,b=0,x=a&&D0(a);if(i){var y=e.havingStyle(e.style.sup());h=X(i,y,e),x||(p=u.height-y.fontMetrics().supDrop*y.sizeMultiplier/e.sizeMultiplier)}if(s){var T=e.havingStyle(e.style.sub());c=X(s,T,e),x||(b=u.depth+T.fontMetrics().subDrop*T.sizeMultiplier/e.sizeMultiplier)}var M;e.style===N.DISPLAY?M=v.sup1:e.style.cramped?M=v.sup3:M=v.sup2;var q=e.sizeMultiplier,C=A(.5/v.ptPerEm/q),R=null;if(c){var F=r.base&&r.base.type==="op"&&r.base.name&&(r.base.name==="\\oiint"||r.base.name==="\\oiiint");if(u instanceof d0||F){var L;R=A(-((L=u.italic)!=null?L:0))}}var O;if(h&&c){p=Math.max(p,M,h.depth+.25*v.xHeight),b=Math.max(b,v.sub2);var P=v.defaultRuleThickness,G=4*P;if(p-h.depth-(c.height-b)0&&(p+=Y,b-=Y)}var U=[{type:"elem",elem:c,shift:b,marginRight:C,marginLeft:R},{type:"elem",elem:h,shift:-p,marginRight:C}];O=V({positionType:"individualShift",children:U})}else if(c){b=Math.max(b,v.sub1,c.height-.8*v.xHeight);var o0=[{type:"elem",elem:c,marginLeft:R,marginRight:C}];O=V({positionType:"shift",positionData:b,children:o0})}else if(h)p=Math.max(p,M,h.depth+.25*v.xHeight),O=V({positionType:"shift",positionData:-p,children:[{type:"elem",elem:h,marginRight:C}]});else throw new Error("supsub must have either sup or sub.");var m0=At(u,"right")||"mord";return k([m0],[u,k(["msupsub"],[O])],e)},mathmlBuilder(r,e){var t=!1,a,i;r.base&&r.base.type==="horizBrace"&&(i=!!r.sup,i===r.base.isOver&&(t=!0,a=r.base.isOver)),r.base&&(r.base.type==="op"||r.base.type==="operatorname")&&(r.base.parentIsSupSub=!0);var s=[$(r.base,e)];r.sub&&s.push($(r.sub,e)),r.sup&&s.push($(r.sup,e));var u;if(t)u=a?"mover":"munder";else if(r.sub)if(r.sup){var v=r.base;v&&v.type==="op"&&v.limits&&e.style===N.DISPLAY||v&&v.type==="operatorname"&&v.alwaysHandleSupSub&&(e.style===N.DISPLAY||v.limits)?u="munderover":u="msubsup"}else{var c=r.base;c&&c.type==="op"&&c.limits&&(e.style===N.DISPLAY||c.alwaysHandleSupSub)||c&&c.type==="operatorname"&&c.alwaysHandleSupSub&&(c.limits||e.style===N.DISPLAY)?u="munder":u="msub"}else{var h=r.base;h&&h.type==="op"&&h.limits&&(e.style===N.DISPLAY||h.alwaysHandleSupSub)||h&&h.type==="operatorname"&&h.alwaysHandleSupSub&&(h.limits||e.style===N.DISPLAY)?u="mover":u="msup"}return new z(u,s)}});W0({type:"atom",htmlBuilder(r,e){return Ft(r.text,r.mode,e,["m"+r.family])},mathmlBuilder(r,e){var t=new z("mo",[g0(r.text,r.mode)]);if(r.family==="bin"){var a=Lt(r,e);a==="bold-italic"&&t.setAttribute("mathvariant",a)}else r.family==="punct"?t.setAttribute("separator","true"):(r.family==="open"||r.family==="close")&&t.setAttribute("stretchy","false");return t}});var D1={mi:"italic",mn:"normal",mtext:"normal"};W0({type:"mathord",htmlBuilder(r,e){return Oe(r,e,"mathord")},mathmlBuilder(r,e){var t=new z("mi",[g0(r.text,r.mode,e)]),a=Lt(r,e)||"italic";return a!==D1[t.type]&&t.setAttribute("mathvariant",a),t}});W0({type:"textord",htmlBuilder(r,e){return Oe(r,e,"textord")},mathmlBuilder(r,e){var t=g0(r.text,r.mode,e),a=Lt(r,e)||"normal",i;return r.mode==="text"?i=new z("mtext",[t]):/[0-9]/.test(r.text)?i=new z("mn",[t]):r.text==="\\prime"?i=new z("mo",[t]):i=new z("mi",[t]),a!==D1[i.type]&&i.setAttribute("mathvariant",a),i}});var ht={"\\nobreak":"nobreak","\\allowbreak":"allowbreak"},mt={" ":{},"\\ ":{},"~":{className:"nobreak"},"\\space":{},"\\nobreakspace":{className:"nobreak"}};W0({type:"spacing",htmlBuilder(r,e){if(mt.hasOwnProperty(r.text)){var t=mt[r.text].className||"";if(r.mode==="text"){var a=Oe(r,e,"textord");return a.classes.push(t),a}else return k(["mspace",t],[Ft(r.text,r.mode,e)],e)}else{if(ht.hasOwnProperty(r.text))return k(["mspace",ht[r.text]],[],e);throw new S('Unknown type of space "'+r.text+'"')}},mathmlBuilder(r,e){var t;if(mt.hasOwnProperty(r.text))t=new z("mtext",[new e0(" ")]);else{if(ht.hasOwnProperty(r.text))return new z("mspace");throw new S('Unknown type of space "'+r.text+'"')}return t}});var qr=()=>{var r=new z("mtd",[]);return r.setAttribute("width","50%"),r};W0({type:"tag",mathmlBuilder(r,e){var t=new z("mtable",[new z("mtr",[qr(),new z("mtd",[U0(r.body,e)]),qr(),new z("mtd",[U0(r.tag,e)])])]);return t.setAttribute("width","100%"),t}});var Er={"\\text":void 0,"\\textrm":"textrm","\\textsf":"textsf","\\texttt":"texttt","\\textnormal":"textrm"},Rr={"\\textbf":"textbf","\\textmd":"textmd"},M4={"\\textit":"textit","\\textup":"textup"},Ir=(r,e)=>{var t=r.font;if(t){if(Er[t])return e.withTextFontFamily(Er[t]);if(Rr[t])return e.withTextFontWeight(Rr[t]);if(t==="\\emph")return e.fontShape==="textit"?e.withTextFontShape("textup"):e.withTextFontShape("textit")}else return e;return e.withTextFontShape(M4[t])};B({type:"text",names:["\\text","\\textrm","\\textsf","\\texttt","\\textnormal","\\textbf","\\textmd","\\textit","\\textup","\\emph"],props:{numArgs:1,argTypes:["text"],allowedInArgument:!0,allowedInText:!0},handler(r,e){var{parser:t,funcName:a}=r,i=e[0];return{type:"text",mode:t.mode,body:_(i),font:a}},htmlBuilder(r,e){var t=Ir(r,e),a=a0(r.body,t,!0);return k(["mord","text"],a,t)},mathmlBuilder(r,e){var t=Ir(r,e);return U0(r.body,t)}});B({type:"underline",names:["\\underline"],props:{numArgs:1,allowedInText:!0},handler(r,e){var{parser:t}=r;return{type:"underline",mode:t.mode,body:e[0]}},htmlBuilder(r,e){var t=X(r.body,e),a=te("underline-line",e),i=e.fontMetrics().defaultRuleThickness,s=V({positionType:"top",positionData:t.height,children:[{type:"kern",size:i},{type:"elem",elem:a},{type:"kern",size:3*i},{type:"elem",elem:t}]});return k(["mord","underline"],[s],e)},mathmlBuilder(r,e){var t=new z("mo",[new e0("‾")]);t.setAttribute("stretchy","true");var a=new z("munder",[$(r.body,e),t]);return a.setAttribute("accentunder","true"),a}});B({type:"vcenter",names:["\\vcenter"],props:{numArgs:1,argTypes:["original"],allowedInText:!1},handler(r,e){var{parser:t}=r;return{type:"vcenter",mode:t.mode,body:e[0]}},htmlBuilder(r,e){var t=X(r.body,e),a=e.fontMetrics().axisHeight,i=.5*(t.height-a-(t.depth+a));return V({positionType:"shift",positionData:i,children:[{type:"elem",elem:t}]})},mathmlBuilder(r,e){var t=new z("mpadded",[$(r.body,e)],["vcenter"]);return new z("mrow",[t])}});B({type:"verb",names:["\\verb"],props:{numArgs:0,allowedInText:!0},handler(r,e,t){throw new S("\\verb ended by end of line instead of matching delimiter")},htmlBuilder(r,e){for(var t=Nr(r),a=[],i=e.havingStyle(e.style.text()),s=0;sr.body.replace(/ /g,r.star?"␣":" "),O0=Jr,q1=`[ \r + ]`,T4="\\\\[a-zA-Z@]+",B4="\\\\[^\uD800-\uDFFF]",C4="("+T4+")"+q1+"*",D4=`\\\\( +|[ \r ]+ +?)[ \r ]*`,qt="[̀-ͯ]",q4=new RegExp(qt+"+$"),E4="("+q1+"+)|"+(D4+"|")+"([!-\\[\\]-‧‪-퟿豈-￿]"+(qt+"*")+"|[\uD800-\uDBFF][\uDC00-\uDFFF]"+(qt+"*")+"|\\\\verb\\*([^]).*?\\4|\\\\verb([^*a-zA-Z]).*?\\5"+("|"+C4)+("|"+B4+")");class Fr{constructor(e,t){this.input=void 0,this.settings=void 0,this.tokenRegex=void 0,this.catcodes=void 0,this.input=e,this.settings=t,this.tokenRegex=new RegExp(E4,"g"),this.catcodes={"%":14,"~":13}}setCatcode(e,t){this.catcodes[e]=t}lex(){var e=this.input,t=this.tokenRegex.lastIndex;if(t===e.length)return new c0("EOF",new h0(this,t,t));var a=this.tokenRegex.exec(e);if(a===null||a.index!==t)throw new S("Unexpected character: '"+e[t]+"'",new c0(e[t],new h0(this,t,t+1)));var i=a[6]||a[3]||(a[2]?"\\ ":" ");if(this.catcodes[i]===14){var s=e.indexOf(` +`,this.tokenRegex.lastIndex);return s===-1?(this.tokenRegex.lastIndex=e.length,this.settings.reportNonstrict("commentAtEnd","% comment has no terminating newline; LaTeX would fail because of commenting the end of math mode (e.g. $)")):this.tokenRegex.lastIndex=s+1,this.lex()}return new c0(i,new h0(this,t,this.tokenRegex.lastIndex))}}class R4{constructor(e,t){e===void 0&&(e={}),t===void 0&&(t={}),this.current=void 0,this.builtins=void 0,this.undefStack=void 0,this.current=t,this.builtins=e,this.undefStack=[]}beginGroup(){this.undefStack.push({})}endGroup(){if(this.undefStack.length===0)throw new S("Unbalanced namespace destruction: attempt to pop global namespace; please report this as a bug");var e=this.undefStack.pop();for(var t in e)e.hasOwnProperty(t)&&(e[t]==null?delete this.current[t]:this.current[t]=e[t])}endGroups(){for(;this.undefStack.length>0;)this.endGroup()}has(e){return this.current.hasOwnProperty(e)||this.builtins.hasOwnProperty(e)}get(e){return this.current.hasOwnProperty(e)?this.current[e]:this.builtins[e]}set(e,t,a){if(a===void 0&&(a=!1),a){for(var i=0;i0&&(this.undefStack[this.undefStack.length-1][e]=t)}else{var s=this.undefStack[this.undefStack.length-1];s&&!s.hasOwnProperty(e)&&(s[e]=this.current[e])}t==null?delete this.current[e]:this.current[e]=t}}var I4=x1;m("\\noexpand",function(r){var e=r.popToken();return r.isExpandable(e.text)&&(e.noexpand=!0,e.treatAsRelax=!0),{tokens:[e],numArgs:0}});m("\\expandafter",function(r){var e=r.popToken();return r.expandOnce(!0),{tokens:[e],numArgs:0}});m("\\@firstoftwo",function(r){var e=r.consumeArgs(2);return{tokens:e[0],numArgs:0}});m("\\@secondoftwo",function(r){var e=r.consumeArgs(2);return{tokens:e[1],numArgs:0}});m("\\@ifnextchar",function(r){var e=r.consumeArgs(3);r.consumeSpaces();var t=r.future();return e[0].length===1&&e[0][0].text===t.text?{tokens:e[1],numArgs:0}:{tokens:e[2],numArgs:0}});m("\\@ifstar","\\@ifnextchar *{\\@firstoftwo{#1}}");m("\\TextOrMath",function(r){var e=r.consumeArgs(2);return r.mode==="text"?{tokens:e[0],numArgs:0}:{tokens:e[1],numArgs:0}});var Hr={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,a:10,A:10,b:11,B:11,c:12,C:12,d:13,D:13,e:14,E:14,f:15,F:15};m("\\char",function(r){var e=r.popToken(),t,a=0;if(e.text==="'")t=8,e=r.popToken();else if(e.text==='"')t=16,e=r.popToken();else if(e.text==="`")if(e=r.popToken(),e.text[0]==="\\")a=e.text.charCodeAt(1);else{if(e.text==="EOF")throw new S("\\char` missing argument");a=e.text.charCodeAt(0)}else t=10;if(t){if(a=Hr[e.text],a==null||a>=t)throw new S("Invalid base-"+t+" digit "+e.text);for(var i;(i=Hr[r.future().text])!=null&&i{var i=r.consumeArg().tokens;if(i.length!==1)throw new S("\\newcommand's first argument must be a macro name");var s=i[0].text,u=r.isDefined(s);if(u&&!e)throw new S("\\newcommand{"+s+"} attempting to redefine "+(s+"; use \\renewcommand"));if(!u&&!t)throw new S("\\renewcommand{"+s+"} when command "+s+" does not yet exist; use \\newcommand");var h=0;if(i=r.consumeArg().tokens,i.length===1&&i[0].text==="["){for(var c="",v=r.expandNextToken();v.text!=="]"&&v.text!=="EOF";)c+=v.text,v=r.expandNextToken();if(!c.match(/^\s*[0-9]+\s*$/))throw new S("Invalid number of arguments: "+c);h=parseInt(c),i=r.consumeArg().tokens}return u&&a||r.macros.set(s,{tokens:i,numArgs:h}),""};m("\\newcommand",r=>Xt(r,!1,!0,!1));m("\\renewcommand",r=>Xt(r,!0,!1,!1));m("\\providecommand",r=>Xt(r,!0,!0,!0));m("\\message",r=>{var e=r.consumeArgs(1)[0];return console.log(e.reverse().map(t=>t.text).join("")),""});m("\\errmessage",r=>{var e=r.consumeArgs(1)[0];return console.error(e.reverse().map(t=>t.text).join("")),""});m("\\show",r=>{var e=r.popToken(),t=e.text;return console.log(e,r.macros.get(t),O0[t],W.math[t],W.text[t]),""});m("\\bgroup","{");m("\\egroup","}");m("~","\\nobreakspace");m("\\lq","`");m("\\rq","'");m("\\aa","\\r a");m("\\AA","\\r A");m("\\textcopyright","\\html@mathml{\\textcircled{c}}{\\char`©}");m("\\copyright","\\TextOrMath{\\textcopyright}{\\text{\\textcopyright}}");m("\\textregistered","\\html@mathml{\\textcircled{\\scriptsize R}}{\\char`®}");m("ℬ","\\mathscr{B}");m("ℰ","\\mathscr{E}");m("ℱ","\\mathscr{F}");m("ℋ","\\mathscr{H}");m("ℐ","\\mathscr{I}");m("ℒ","\\mathscr{L}");m("ℳ","\\mathscr{M}");m("ℛ","\\mathscr{R}");m("ℭ","\\mathfrak{C}");m("ℌ","\\mathfrak{H}");m("ℨ","\\mathfrak{Z}");m("\\Bbbk","\\Bbb{k}");m("\\llap","\\mathllap{\\textrm{#1}}");m("\\rlap","\\mathrlap{\\textrm{#1}}");m("\\clap","\\mathclap{\\textrm{#1}}");m("\\mathstrut","\\vphantom{(}");m("\\underbar","\\underline{\\text{#1}}");m("\\not",'\\html@mathml{\\mathrel{\\mathrlap\\@not}\\nobreak}{\\char"338}');m("\\neq","\\html@mathml{\\mathrel{\\not=}}{\\mathrel{\\char`≠}}");m("\\ne","\\neq");m("≠","\\neq");m("\\notin","\\html@mathml{\\mathrel{{\\in}\\mathllap{/\\mskip1mu}}}{\\mathrel{\\char`∉}}");m("∉","\\notin");m("≘","\\html@mathml{\\mathrel{=\\kern{-1em}\\raisebox{0.4em}{$\\scriptsize\\frown$}}}{\\mathrel{\\char`≘}}");m("≙","\\html@mathml{\\stackrel{\\tiny\\wedge}{=}}{\\mathrel{\\char`≘}}");m("≚","\\html@mathml{\\stackrel{\\tiny\\vee}{=}}{\\mathrel{\\char`≚}}");m("≛","\\html@mathml{\\stackrel{\\scriptsize\\star}{=}}{\\mathrel{\\char`≛}}");m("≝","\\html@mathml{\\stackrel{\\tiny\\mathrm{def}}{=}}{\\mathrel{\\char`≝}}");m("≞","\\html@mathml{\\stackrel{\\tiny\\mathrm{m}}{=}}{\\mathrel{\\char`≞}}");m("≟","\\html@mathml{\\stackrel{\\tiny?}{=}}{\\mathrel{\\char`≟}}");m("⟂","\\perp");m("‼","\\mathclose{!\\mkern-0.8mu!}");m("∌","\\notni");m("⌜","\\ulcorner");m("⌝","\\urcorner");m("⌞","\\llcorner");m("⌟","\\lrcorner");m("©","\\copyright");m("®","\\textregistered");m("\\ulcorner",'\\html@mathml{\\@ulcorner}{\\mathop{\\char"231c}}');m("\\urcorner",'\\html@mathml{\\@urcorner}{\\mathop{\\char"231d}}');m("\\llcorner",'\\html@mathml{\\@llcorner}{\\mathop{\\char"231e}}');m("\\lrcorner",'\\html@mathml{\\@lrcorner}{\\mathop{\\char"231f}}');m("\\vdots","{\\varvdots\\rule{0pt}{15pt}}");m("⋮","\\vdots");m("\\varGamma","\\mathit{\\Gamma}");m("\\varDelta","\\mathit{\\Delta}");m("\\varTheta","\\mathit{\\Theta}");m("\\varLambda","\\mathit{\\Lambda}");m("\\varXi","\\mathit{\\Xi}");m("\\varPi","\\mathit{\\Pi}");m("\\varSigma","\\mathit{\\Sigma}");m("\\varUpsilon","\\mathit{\\Upsilon}");m("\\varPhi","\\mathit{\\Phi}");m("\\varPsi","\\mathit{\\Psi}");m("\\varOmega","\\mathit{\\Omega}");m("\\substack","\\begin{subarray}{c}#1\\end{subarray}");m("\\colon","\\nobreak\\mskip2mu\\mathpunct{}\\mathchoice{\\mkern-3mu}{\\mkern-3mu}{}{}{:}\\mskip6mu\\relax");m("\\boxed","\\fbox{$\\displaystyle{#1}$}");m("\\iff","\\DOTSB\\;\\Longleftrightarrow\\;");m("\\implies","\\DOTSB\\;\\Longrightarrow\\;");m("\\impliedby","\\DOTSB\\;\\Longleftarrow\\;");m("\\dddot","{\\overset{\\raisebox{-0.1ex}{\\normalsize ...}}{#1}}");m("\\ddddot","{\\overset{\\raisebox{-0.1ex}{\\normalsize ....}}{#1}}");var Or={",":"\\dotsc","\\not":"\\dotsb","+":"\\dotsb","=":"\\dotsb","<":"\\dotsb",">":"\\dotsb","-":"\\dotsb","*":"\\dotsb",":":"\\dotsb","\\DOTSB":"\\dotsb","\\coprod":"\\dotsb","\\bigvee":"\\dotsb","\\bigwedge":"\\dotsb","\\biguplus":"\\dotsb","\\bigcap":"\\dotsb","\\bigcup":"\\dotsb","\\prod":"\\dotsb","\\sum":"\\dotsb","\\bigotimes":"\\dotsb","\\bigoplus":"\\dotsb","\\bigodot":"\\dotsb","\\bigsqcup":"\\dotsb","\\And":"\\dotsb","\\longrightarrow":"\\dotsb","\\Longrightarrow":"\\dotsb","\\longleftarrow":"\\dotsb","\\Longleftarrow":"\\dotsb","\\longleftrightarrow":"\\dotsb","\\Longleftrightarrow":"\\dotsb","\\mapsto":"\\dotsb","\\longmapsto":"\\dotsb","\\hookrightarrow":"\\dotsb","\\doteq":"\\dotsb","\\mathbin":"\\dotsb","\\mathrel":"\\dotsb","\\relbar":"\\dotsb","\\Relbar":"\\dotsb","\\xrightarrow":"\\dotsb","\\xleftarrow":"\\dotsb","\\DOTSI":"\\dotsi","\\int":"\\dotsi","\\oint":"\\dotsi","\\iint":"\\dotsi","\\iiint":"\\dotsi","\\iiiint":"\\dotsi","\\idotsint":"\\dotsi","\\DOTSX":"\\dotsx"},N4=new Set(["bin","rel"]);m("\\dots",function(r){var e="\\dotso",t=r.expandAfterFuture().text;return t in Or?e=Or[t]:(t.slice(0,4)==="\\not"||t in W.math&&N4.has(W.math[t].group))&&(e="\\dotsb"),e});var Yt={")":!0,"]":!0,"\\rbrack":!0,"\\}":!0,"\\rbrace":!0,"\\rangle":!0,"\\rceil":!0,"\\rfloor":!0,"\\rgroup":!0,"\\rmoustache":!0,"\\right":!0,"\\bigr":!0,"\\biggr":!0,"\\Bigr":!0,"\\Biggr":!0,$:!0,";":!0,".":!0,",":!0};m("\\dotso",function(r){var e=r.future().text;return e in Yt?"\\ldots\\,":"\\ldots"});m("\\dotsc",function(r){var e=r.future().text;return e in Yt&&e!==","?"\\ldots\\,":"\\ldots"});m("\\cdots",function(r){var e=r.future().text;return e in Yt?"\\@cdots\\,":"\\@cdots"});m("\\dotsb","\\cdots");m("\\dotsm","\\cdots");m("\\dotsi","\\!\\cdots");m("\\dotsx","\\ldots\\,");m("\\DOTSI","\\relax");m("\\DOTSB","\\relax");m("\\DOTSX","\\relax");m("\\tmspace","\\TextOrMath{\\kern#1#3}{\\mskip#1#2}\\relax");m("\\,","\\tmspace+{3mu}{.1667em}");m("\\thinspace","\\,");m("\\>","\\mskip{4mu}");m("\\:","\\tmspace+{4mu}{.2222em}");m("\\medspace","\\:");m("\\;","\\tmspace+{5mu}{.2777em}");m("\\thickspace","\\;");m("\\!","\\tmspace-{3mu}{.1667em}");m("\\negthinspace","\\!");m("\\negmedspace","\\tmspace-{4mu}{.2222em}");m("\\negthickspace","\\tmspace-{5mu}{.277em}");m("\\enspace","\\kern.5em ");m("\\enskip","\\hskip.5em\\relax");m("\\quad","\\hskip1em\\relax");m("\\qquad","\\hskip2em\\relax");m("\\tag","\\@ifstar\\tag@literal\\tag@paren");m("\\tag@paren","\\tag@literal{({#1})}");m("\\tag@literal",r=>{if(r.macros.get("\\df@tag"))throw new S("Multiple \\tag");return"\\gdef\\df@tag{\\text{#1}}"});m("\\bmod","\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}\\mathbin{\\rm mod}\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}");m("\\pod","\\allowbreak\\mathchoice{\\mkern18mu}{\\mkern8mu}{\\mkern8mu}{\\mkern8mu}(#1)");m("\\pmod","\\pod{{\\rm mod}\\mkern6mu#1}");m("\\mod","\\allowbreak\\mathchoice{\\mkern18mu}{\\mkern12mu}{\\mkern12mu}{\\mkern12mu}{\\rm mod}\\,\\,#1");m("\\newline","\\\\\\relax");m("\\TeX","\\textrm{\\html@mathml{T\\kern-.1667em\\raisebox{-.5ex}{E}\\kern-.125emX}{TeX}}");var E1=A(k0["Main-Regular"][84][1]-.7*k0["Main-Regular"][65][1]);m("\\LaTeX","\\textrm{\\html@mathml{"+("L\\kern-.36em\\raisebox{"+E1+"}{\\scriptstyle A}")+"\\kern-.15em\\TeX}{LaTeX}}");m("\\KaTeX","\\textrm{\\html@mathml{"+("K\\kern-.17em\\raisebox{"+E1+"}{\\scriptstyle A}")+"\\kern-.15em\\TeX}{KaTeX}}");m("\\hspace","\\@ifstar\\@hspacer\\@hspace");m("\\@hspace","\\hskip #1\\relax");m("\\@hspacer","\\rule{0pt}{0pt}\\hskip #1\\relax");m("\\ordinarycolon",":");m("\\vcentcolon","\\mathrel{\\mathop\\ordinarycolon}");m("\\dblcolon",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-.9mu}\\vcentcolon}}{\\mathop{\\char"2237}}');m("\\coloneqq",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}=}}{\\mathop{\\char"2254}}');m("\\Coloneqq",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}=}}{\\mathop{\\char"2237\\char"3d}}');m("\\coloneq",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}}{\\mathop{\\char"3a\\char"2212}}');m("\\Coloneq",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}}{\\mathop{\\char"2237\\char"2212}}');m("\\eqqcolon",'\\html@mathml{\\mathrel{=\\mathrel{\\mkern-1.2mu}\\vcentcolon}}{\\mathop{\\char"2255}}');m("\\Eqqcolon",'\\html@mathml{\\mathrel{=\\mathrel{\\mkern-1.2mu}\\dblcolon}}{\\mathop{\\char"3d\\char"2237}}');m("\\eqcolon",'\\html@mathml{\\mathrel{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\vcentcolon}}{\\mathop{\\char"2239}}');m("\\Eqcolon",'\\html@mathml{\\mathrel{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\dblcolon}}{\\mathop{\\char"2212\\char"2237}}');m("\\colonapprox",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\approx}}{\\mathop{\\char"3a\\char"2248}}');m("\\Colonapprox",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\approx}}{\\mathop{\\char"2237\\char"2248}}');m("\\colonsim",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\sim}}{\\mathop{\\char"3a\\char"223c}}');m("\\Colonsim",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\sim}}{\\mathop{\\char"2237\\char"223c}}');m("∷","\\dblcolon");m("∹","\\eqcolon");m("≔","\\coloneqq");m("≕","\\eqqcolon");m("⩴","\\Coloneqq");m("\\ratio","\\vcentcolon");m("\\coloncolon","\\dblcolon");m("\\colonequals","\\coloneqq");m("\\coloncolonequals","\\Coloneqq");m("\\equalscolon","\\eqqcolon");m("\\equalscoloncolon","\\Eqqcolon");m("\\colonminus","\\coloneq");m("\\coloncolonminus","\\Coloneq");m("\\minuscolon","\\eqcolon");m("\\minuscoloncolon","\\Eqcolon");m("\\coloncolonapprox","\\Colonapprox");m("\\coloncolonsim","\\Colonsim");m("\\simcolon","\\mathrel{\\sim\\mathrel{\\mkern-1.2mu}\\vcentcolon}");m("\\simcoloncolon","\\mathrel{\\sim\\mathrel{\\mkern-1.2mu}\\dblcolon}");m("\\approxcolon","\\mathrel{\\approx\\mathrel{\\mkern-1.2mu}\\vcentcolon}");m("\\approxcoloncolon","\\mathrel{\\approx\\mathrel{\\mkern-1.2mu}\\dblcolon}");m("\\notni","\\html@mathml{\\not\\ni}{\\mathrel{\\char`∌}}");m("\\limsup","\\DOTSB\\operatorname*{lim\\,sup}");m("\\liminf","\\DOTSB\\operatorname*{lim\\,inf}");m("\\injlim","\\DOTSB\\operatorname*{inj\\,lim}");m("\\projlim","\\DOTSB\\operatorname*{proj\\,lim}");m("\\varlimsup","\\DOTSB\\operatorname*{\\overline{lim}}");m("\\varliminf","\\DOTSB\\operatorname*{\\underline{lim}}");m("\\varinjlim","\\DOTSB\\operatorname*{\\underrightarrow{lim}}");m("\\varprojlim","\\DOTSB\\operatorname*{\\underleftarrow{lim}}");m("\\gvertneqq","\\html@mathml{\\@gvertneqq}{≩}");m("\\lvertneqq","\\html@mathml{\\@lvertneqq}{≨}");m("\\ngeqq","\\html@mathml{\\@ngeqq}{≱}");m("\\ngeqslant","\\html@mathml{\\@ngeqslant}{≱}");m("\\nleqq","\\html@mathml{\\@nleqq}{≰}");m("\\nleqslant","\\html@mathml{\\@nleqslant}{≰}");m("\\nshortmid","\\html@mathml{\\@nshortmid}{∤}");m("\\nshortparallel","\\html@mathml{\\@nshortparallel}{∦}");m("\\nsubseteqq","\\html@mathml{\\@nsubseteqq}{⊈}");m("\\nsupseteqq","\\html@mathml{\\@nsupseteqq}{⊉}");m("\\varsubsetneq","\\html@mathml{\\@varsubsetneq}{⊊}");m("\\varsubsetneqq","\\html@mathml{\\@varsubsetneqq}{⫋}");m("\\varsupsetneq","\\html@mathml{\\@varsupsetneq}{⊋}");m("\\varsupsetneqq","\\html@mathml{\\@varsupsetneqq}{⫌}");m("\\imath","\\html@mathml{\\@imath}{ı}");m("\\jmath","\\html@mathml{\\@jmath}{ȷ}");m("\\llbracket","\\html@mathml{\\mathopen{[\\mkern-3.2mu[}}{\\mathopen{\\char`⟦}}");m("\\rrbracket","\\html@mathml{\\mathclose{]\\mkern-3.2mu]}}{\\mathclose{\\char`⟧}}");m("⟦","\\llbracket");m("⟧","\\rrbracket");m("\\lBrace","\\html@mathml{\\mathopen{\\{\\mkern-3.2mu[}}{\\mathopen{\\char`⦃}}");m("\\rBrace","\\html@mathml{\\mathclose{]\\mkern-3.2mu\\}}}{\\mathclose{\\char`⦄}}");m("⦃","\\lBrace");m("⦄","\\rBrace");m("\\minuso","\\mathbin{\\html@mathml{{\\mathrlap{\\mathchoice{\\kern{0.145em}}{\\kern{0.145em}}{\\kern{0.1015em}}{\\kern{0.0725em}}\\circ}{-}}}{\\char`⦵}}");m("⦵","\\minuso");m("\\darr","\\downarrow");m("\\dArr","\\Downarrow");m("\\Darr","\\Downarrow");m("\\lang","\\langle");m("\\rang","\\rangle");m("\\uarr","\\uparrow");m("\\uArr","\\Uparrow");m("\\Uarr","\\Uparrow");m("\\N","\\mathbb{N}");m("\\R","\\mathbb{R}");m("\\Z","\\mathbb{Z}");m("\\alef","\\aleph");m("\\alefsym","\\aleph");m("\\Alpha","\\mathrm{A}");m("\\Beta","\\mathrm{B}");m("\\bull","\\bullet");m("\\Chi","\\mathrm{X}");m("\\clubs","\\clubsuit");m("\\cnums","\\mathbb{C}");m("\\Complex","\\mathbb{C}");m("\\Dagger","\\ddagger");m("\\diamonds","\\diamondsuit");m("\\empty","\\emptyset");m("\\Epsilon","\\mathrm{E}");m("\\Eta","\\mathrm{H}");m("\\exist","\\exists");m("\\harr","\\leftrightarrow");m("\\hArr","\\Leftrightarrow");m("\\Harr","\\Leftrightarrow");m("\\hearts","\\heartsuit");m("\\image","\\Im");m("\\infin","\\infty");m("\\Iota","\\mathrm{I}");m("\\isin","\\in");m("\\Kappa","\\mathrm{K}");m("\\larr","\\leftarrow");m("\\lArr","\\Leftarrow");m("\\Larr","\\Leftarrow");m("\\lrarr","\\leftrightarrow");m("\\lrArr","\\Leftrightarrow");m("\\Lrarr","\\Leftrightarrow");m("\\Mu","\\mathrm{M}");m("\\natnums","\\mathbb{N}");m("\\Nu","\\mathrm{N}");m("\\Omicron","\\mathrm{O}");m("\\plusmn","\\pm");m("\\rarr","\\rightarrow");m("\\rArr","\\Rightarrow");m("\\Rarr","\\Rightarrow");m("\\real","\\Re");m("\\reals","\\mathbb{R}");m("\\Reals","\\mathbb{R}");m("\\Rho","\\mathrm{P}");m("\\sdot","\\cdot");m("\\sect","\\S");m("\\spades","\\spadesuit");m("\\sub","\\subset");m("\\sube","\\subseteq");m("\\supe","\\supseteq");m("\\Tau","\\mathrm{T}");m("\\thetasym","\\vartheta");m("\\weierp","\\wp");m("\\Zeta","\\mathrm{Z}");m("\\argmin","\\DOTSB\\operatorname*{arg\\,min}");m("\\argmax","\\DOTSB\\operatorname*{arg\\,max}");m("\\plim","\\DOTSB\\mathop{\\operatorname{plim}}\\limits");m("\\bra","\\mathinner{\\langle{#1}|}");m("\\ket","\\mathinner{|{#1}\\rangle}");m("\\braket","\\mathinner{\\langle{#1}\\rangle}");m("\\Bra","\\left\\langle#1\\right|");m("\\Ket","\\left|#1\\right\\rangle");var R1=r=>e=>{var t=e.consumeArg().tokens,a=e.consumeArg().tokens,i=e.consumeArg().tokens,s=e.consumeArg().tokens,u=e.macros.get("|"),h=e.macros.get("\\|");e.macros.beginGroup();var c=b=>x=>{r&&(x.macros.set("|",u),i.length&&x.macros.set("\\|",h));var y=b;if(!b&&i.length){var T=x.future();T.text==="|"&&(x.popToken(),y=!0)}return{tokens:y?i:a,numArgs:0}};e.macros.set("|",c(!1)),i.length&&e.macros.set("\\|",c(!0));var v=e.consumeArg().tokens,p=e.expandTokens([...s,...v,...t]);return e.macros.endGroup(),{tokens:p.reverse(),numArgs:0}};m("\\bra@ket",R1(!1));m("\\bra@set",R1(!0));m("\\Braket","\\bra@ket{\\left\\langle}{\\,\\middle\\vert\\,}{\\,\\middle\\vert\\,}{\\right\\rangle}");m("\\Set","\\bra@set{\\left\\{\\:}{\\;\\middle\\vert\\;}{\\;\\middle\\Vert\\;}{\\:\\right\\}}");m("\\set","\\bra@set{\\{\\,}{\\mid}{}{\\,\\}}");m("\\angln","{\\angl n}");m("\\blue","\\textcolor{##6495ed}{#1}");m("\\orange","\\textcolor{##ffa500}{#1}");m("\\pink","\\textcolor{##ff00af}{#1}");m("\\red","\\textcolor{##df0030}{#1}");m("\\green","\\textcolor{##28ae7b}{#1}");m("\\gray","\\textcolor{gray}{#1}");m("\\purple","\\textcolor{##9d38bd}{#1}");m("\\blueA","\\textcolor{##ccfaff}{#1}");m("\\blueB","\\textcolor{##80f6ff}{#1}");m("\\blueC","\\textcolor{##63d9ea}{#1}");m("\\blueD","\\textcolor{##11accd}{#1}");m("\\blueE","\\textcolor{##0c7f99}{#1}");m("\\tealA","\\textcolor{##94fff5}{#1}");m("\\tealB","\\textcolor{##26edd5}{#1}");m("\\tealC","\\textcolor{##01d1c1}{#1}");m("\\tealD","\\textcolor{##01a995}{#1}");m("\\tealE","\\textcolor{##208170}{#1}");m("\\greenA","\\textcolor{##b6ffb0}{#1}");m("\\greenB","\\textcolor{##8af281}{#1}");m("\\greenC","\\textcolor{##74cf70}{#1}");m("\\greenD","\\textcolor{##1fab54}{#1}");m("\\greenE","\\textcolor{##0d923f}{#1}");m("\\goldA","\\textcolor{##ffd0a9}{#1}");m("\\goldB","\\textcolor{##ffbb71}{#1}");m("\\goldC","\\textcolor{##ff9c39}{#1}");m("\\goldD","\\textcolor{##e07d10}{#1}");m("\\goldE","\\textcolor{##a75a05}{#1}");m("\\redA","\\textcolor{##fca9a9}{#1}");m("\\redB","\\textcolor{##ff8482}{#1}");m("\\redC","\\textcolor{##f9685d}{#1}");m("\\redD","\\textcolor{##e84d39}{#1}");m("\\redE","\\textcolor{##bc2612}{#1}");m("\\maroonA","\\textcolor{##ffbde0}{#1}");m("\\maroonB","\\textcolor{##ff92c6}{#1}");m("\\maroonC","\\textcolor{##ed5fa6}{#1}");m("\\maroonD","\\textcolor{##ca337c}{#1}");m("\\maroonE","\\textcolor{##9e034e}{#1}");m("\\purpleA","\\textcolor{##ddd7ff}{#1}");m("\\purpleB","\\textcolor{##c6b9fc}{#1}");m("\\purpleC","\\textcolor{##aa87ff}{#1}");m("\\purpleD","\\textcolor{##7854ab}{#1}");m("\\purpleE","\\textcolor{##543b78}{#1}");m("\\mintA","\\textcolor{##f5f9e8}{#1}");m("\\mintB","\\textcolor{##edf2df}{#1}");m("\\mintC","\\textcolor{##e0e5cc}{#1}");m("\\grayA","\\textcolor{##f6f7f7}{#1}");m("\\grayB","\\textcolor{##f0f1f2}{#1}");m("\\grayC","\\textcolor{##e3e5e6}{#1}");m("\\grayD","\\textcolor{##d6d8da}{#1}");m("\\grayE","\\textcolor{##babec2}{#1}");m("\\grayF","\\textcolor{##888d93}{#1}");m("\\grayG","\\textcolor{##626569}{#1}");m("\\grayH","\\textcolor{##3b3e40}{#1}");m("\\grayI","\\textcolor{##21242c}{#1}");m("\\kaBlue","\\textcolor{##314453}{#1}");m("\\kaGreen","\\textcolor{##71B307}{#1}");var I1={"^":!0,_:!0,"\\limits":!0,"\\nolimits":!0};class F4{constructor(e,t,a){this.settings=void 0,this.expansionCount=void 0,this.lexer=void 0,this.macros=void 0,this.stack=void 0,this.mode=void 0,this.settings=t,this.expansionCount=0,this.feed(e),this.macros=new R4(I4,t.macros),this.mode=a,this.stack=[]}feed(e){this.lexer=new Fr(e,this.settings)}switchMode(e){this.mode=e}beginGroup(){this.macros.beginGroup()}endGroup(){this.macros.endGroup()}endGroups(){this.macros.endGroups()}future(){return this.stack.length===0&&this.pushToken(this.lexer.lex()),this.stack[this.stack.length-1]}popToken(){return this.future(),this.stack.pop()}pushToken(e){this.stack.push(e)}pushTokens(e){this.stack.push(...e)}scanArgument(e){var t,a,i;if(e){if(this.consumeSpaces(),this.future().text!=="[")return null;t=this.popToken(),{tokens:i,end:a}=this.consumeArg(["]"])}else({tokens:i,start:t,end:a}=this.consumeArg());return this.pushToken(new c0("EOF",a.loc)),this.pushTokens(i),new c0("",h0.range(t,a))}consumeSpaces(){for(;;){var e=this.future();if(e.text===" ")this.stack.pop();else break}}consumeArg(e){var t=[],a=e&&e.length>0;a||this.consumeSpaces();var i=this.future(),s,u=0,h=0;do{if(s=this.popToken(),t.push(s),s.text==="{")++u;else if(s.text==="}"){if(--u,u===-1)throw new S("Extra }",s)}else if(s.text==="EOF")throw new S("Unexpected end of input in a macro argument, expected '"+(e&&a?e[h]:"}")+"'",s);if(e&&a)if((u===0||u===1&&e[h]==="{")&&s.text===e[h]){if(++h,h===e.length){t.splice(-h,h);break}}else h=0}while(u!==0||a);return i.text==="{"&&t[t.length-1].text==="}"&&(t.pop(),t.shift()),t.reverse(),{tokens:t,start:i,end:s}}consumeArgs(e,t){if(t){if(t.length!==e+1)throw new S("The length of delimiters doesn't match the number of args!");for(var a=t[0],i=0;ithis.settings.maxExpand)throw new S("Too many expansions: infinite loop or need to increase maxExpand setting")}expandOnce(e){var t=this.popToken(),a=t.text,i=t.noexpand?null:this._getExpansion(a);if(i==null||e&&i.unexpandable){if(e&&i==null&&a[0]==="\\"&&!this.isDefined(a))throw new S("Undefined control sequence: "+a);return this.pushToken(t),!1}this.countExpansion(1);var s=i.tokens,u=this.consumeArgs(i.numArgs,i.delimiters);if(i.numArgs){s=s.slice();for(var h=s.length-1;h>=0;--h){var c=s[h];if(c.text==="#"){if(h===0)throw new S("Incomplete placeholder at end of macro body",c);if(c=s[--h],c.text==="#")s.splice(h+1,1);else if(/^[1-9]$/.test(c.text))s.splice(h,2,...u[+c.text-1]);else throw new S("Not a valid argument number",c)}}}return this.pushTokens(s),s.length}expandAfterFuture(){return this.expandOnce(),this.future()}expandNextToken(){for(;;)if(this.expandOnce()===!1){var e=this.stack.pop();return e.treatAsRelax&&(e.text="\\relax"),e}}expandMacro(e){return this.macros.has(e)?this.expandTokens([new c0(e)]):void 0}expandTokens(e){var t=[],a=this.stack.length;for(this.pushTokens(e);this.stack.length>a;)if(this.expandOnce(!0)===!1){var i=this.stack.pop();i.treatAsRelax&&(i.noexpand=!1,i.treatAsRelax=!1),t.push(i)}return this.countExpansion(t.length),t}expandMacroAsText(e){var t=this.expandMacro(e);return t&&t.map(a=>a.text).join("")}_getExpansion(e){var t=this.macros.get(e);if(t==null)return t;if(e.length===1){var a=this.lexer.catcodes[e];if(a!=null&&a!==13)return}var i=typeof t=="function"?t(this):t;if(typeof i=="string"){var s=0;if(i.includes("#"))for(var u=i.replace(/##/g,"");u.includes("#"+(s+1));)++s;for(var h=new Fr(i,this.settings),c=[],v=h.lex();v.text!=="EOF";)c.push(v),v=h.lex();c.reverse();var p={tokens:c,numArgs:s};return p}return i}isDefined(e){return this.macros.has(e)||O0.hasOwnProperty(e)||W.math.hasOwnProperty(e)||W.text.hasOwnProperty(e)||I1.hasOwnProperty(e)}isExpandable(e){var t=this.macros.get(e);return t!=null?typeof t=="string"||typeof t=="function"||!t.unexpandable:O0.hasOwnProperty(e)&&!O0[e].primitive}}var Lr=/^[₊₋₌₍₎₀₁₂₃₄₅₆₇₈₉ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓᵦᵧᵨᵩᵪ]/,Be=Object.freeze({"₊":"+","₋":"-","₌":"=","₍":"(","₎":")","₀":"0","₁":"1","₂":"2","₃":"3","₄":"4","₅":"5","₆":"6","₇":"7","₈":"8","₉":"9","ₐ":"a","ₑ":"e","ₕ":"h","ᵢ":"i","ⱼ":"j","ₖ":"k","ₗ":"l","ₘ":"m","ₙ":"n","ₒ":"o","ₚ":"p","ᵣ":"r","ₛ":"s","ₜ":"t","ᵤ":"u","ᵥ":"v","ₓ":"x","ᵦ":"β","ᵧ":"γ","ᵨ":"ρ","ᵩ":"ϕ","ᵪ":"χ","⁺":"+","⁻":"-","⁼":"=","⁽":"(","⁾":")","⁰":"0","¹":"1","²":"2","³":"3","⁴":"4","⁵":"5","⁶":"6","⁷":"7","⁸":"8","⁹":"9","ᴬ":"A","ᴮ":"B","ᴰ":"D","ᴱ":"E","ᴳ":"G","ᴴ":"H","ᴵ":"I","ᴶ":"J","ᴷ":"K","ᴸ":"L","ᴹ":"M","ᴺ":"N","ᴼ":"O","ᴾ":"P","ᴿ":"R","ᵀ":"T","ᵁ":"U","ⱽ":"V","ᵂ":"W","ᵃ":"a","ᵇ":"b","ᶜ":"c","ᵈ":"d","ᵉ":"e","ᶠ":"f","ᵍ":"g",ʰ:"h","ⁱ":"i",ʲ:"j","ᵏ":"k",ˡ:"l","ᵐ":"m",ⁿ:"n","ᵒ":"o","ᵖ":"p",ʳ:"r",ˢ:"s","ᵗ":"t","ᵘ":"u","ᵛ":"v",ʷ:"w",ˣ:"x",ʸ:"y","ᶻ":"z","ᵝ":"β","ᵞ":"γ","ᵟ":"δ","ᵠ":"ϕ","ᵡ":"χ","ᶿ":"θ"}),ct={"́":{text:"\\'",math:"\\acute"},"̀":{text:"\\`",math:"\\grave"},"̈":{text:'\\"',math:"\\ddot"},"̃":{text:"\\~",math:"\\tilde"},"̄":{text:"\\=",math:"\\bar"},"̆":{text:"\\u",math:"\\breve"},"̌":{text:"\\v",math:"\\check"},"̂":{text:"\\^",math:"\\hat"},"̇":{text:"\\.",math:"\\dot"},"̊":{text:"\\r",math:"\\mathring"},"̋":{text:"\\H"},"̧":{text:"\\c"}},Pr={á:"á",à:"à",ä:"ä",ǟ:"ǟ",ã:"ã",ā:"ā",ă:"ă",ắ:"ắ",ằ:"ằ",ẵ:"ẵ",ǎ:"ǎ",â:"â",ấ:"ấ",ầ:"ầ",ẫ:"ẫ",ȧ:"ȧ",ǡ:"ǡ",å:"å",ǻ:"ǻ",ḃ:"ḃ",ć:"ć",ḉ:"ḉ",č:"č",ĉ:"ĉ",ċ:"ċ",ç:"ç",ď:"ď",ḋ:"ḋ",ḑ:"ḑ",é:"é",è:"è",ë:"ë",ẽ:"ẽ",ē:"ē",ḗ:"ḗ",ḕ:"ḕ",ĕ:"ĕ",ḝ:"ḝ",ě:"ě",ê:"ê",ế:"ế",ề:"ề",ễ:"ễ",ė:"ė",ȩ:"ȩ",ḟ:"ḟ",ǵ:"ǵ",ḡ:"ḡ",ğ:"ğ",ǧ:"ǧ",ĝ:"ĝ",ġ:"ġ",ģ:"ģ",ḧ:"ḧ",ȟ:"ȟ",ĥ:"ĥ",ḣ:"ḣ",ḩ:"ḩ",í:"í",ì:"ì",ï:"ï",ḯ:"ḯ",ĩ:"ĩ",ī:"ī",ĭ:"ĭ",ǐ:"ǐ",î:"î",ǰ:"ǰ",ĵ:"ĵ",ḱ:"ḱ",ǩ:"ǩ",ķ:"ķ",ĺ:"ĺ",ľ:"ľ",ļ:"ļ",ḿ:"ḿ",ṁ:"ṁ",ń:"ń",ǹ:"ǹ",ñ:"ñ",ň:"ň",ṅ:"ṅ",ņ:"ņ",ó:"ó",ò:"ò",ö:"ö",ȫ:"ȫ",õ:"õ",ṍ:"ṍ",ṏ:"ṏ",ȭ:"ȭ",ō:"ō",ṓ:"ṓ",ṑ:"ṑ",ŏ:"ŏ",ǒ:"ǒ",ô:"ô",ố:"ố",ồ:"ồ",ỗ:"ỗ",ȯ:"ȯ",ȱ:"ȱ",ő:"ő",ṕ:"ṕ",ṗ:"ṗ",ŕ:"ŕ",ř:"ř",ṙ:"ṙ",ŗ:"ŗ",ś:"ś",ṥ:"ṥ",š:"š",ṧ:"ṧ",ŝ:"ŝ",ṡ:"ṡ",ş:"ş",ẗ:"ẗ",ť:"ť",ṫ:"ṫ",ţ:"ţ",ú:"ú",ù:"ù",ü:"ü",ǘ:"ǘ",ǜ:"ǜ",ǖ:"ǖ",ǚ:"ǚ",ũ:"ũ",ṹ:"ṹ",ū:"ū",ṻ:"ṻ",ŭ:"ŭ",ǔ:"ǔ",û:"û",ů:"ů",ű:"ű",ṽ:"ṽ",ẃ:"ẃ",ẁ:"ẁ",ẅ:"ẅ",ŵ:"ŵ",ẇ:"ẇ",ẘ:"ẘ",ẍ:"ẍ",ẋ:"ẋ",ý:"ý",ỳ:"ỳ",ÿ:"ÿ",ỹ:"ỹ",ȳ:"ȳ",ŷ:"ŷ",ẏ:"ẏ",ẙ:"ẙ",ź:"ź",ž:"ž",ẑ:"ẑ",ż:"ż",Á:"Á",À:"À",Ä:"Ä",Ǟ:"Ǟ",Ã:"Ã",Ā:"Ā",Ă:"Ă",Ắ:"Ắ",Ằ:"Ằ",Ẵ:"Ẵ",Ǎ:"Ǎ",Â:"Â",Ấ:"Ấ",Ầ:"Ầ",Ẫ:"Ẫ",Ȧ:"Ȧ",Ǡ:"Ǡ",Å:"Å",Ǻ:"Ǻ",Ḃ:"Ḃ",Ć:"Ć",Ḉ:"Ḉ",Č:"Č",Ĉ:"Ĉ",Ċ:"Ċ",Ç:"Ç",Ď:"Ď",Ḋ:"Ḋ",Ḑ:"Ḑ",É:"É",È:"È",Ë:"Ë",Ẽ:"Ẽ",Ē:"Ē",Ḗ:"Ḗ",Ḕ:"Ḕ",Ĕ:"Ĕ",Ḝ:"Ḝ",Ě:"Ě",Ê:"Ê",Ế:"Ế",Ề:"Ề",Ễ:"Ễ",Ė:"Ė",Ȩ:"Ȩ",Ḟ:"Ḟ",Ǵ:"Ǵ",Ḡ:"Ḡ",Ğ:"Ğ",Ǧ:"Ǧ",Ĝ:"Ĝ",Ġ:"Ġ",Ģ:"Ģ",Ḧ:"Ḧ",Ȟ:"Ȟ",Ĥ:"Ĥ",Ḣ:"Ḣ",Ḩ:"Ḩ",Í:"Í",Ì:"Ì",Ï:"Ï",Ḯ:"Ḯ",Ĩ:"Ĩ",Ī:"Ī",Ĭ:"Ĭ",Ǐ:"Ǐ",Î:"Î",İ:"İ",Ĵ:"Ĵ",Ḱ:"Ḱ",Ǩ:"Ǩ",Ķ:"Ķ",Ĺ:"Ĺ",Ľ:"Ľ",Ļ:"Ļ",Ḿ:"Ḿ",Ṁ:"Ṁ",Ń:"Ń",Ǹ:"Ǹ",Ñ:"Ñ",Ň:"Ň",Ṅ:"Ṅ",Ņ:"Ņ",Ó:"Ó",Ò:"Ò",Ö:"Ö",Ȫ:"Ȫ",Õ:"Õ",Ṍ:"Ṍ",Ṏ:"Ṏ",Ȭ:"Ȭ",Ō:"Ō",Ṓ:"Ṓ",Ṑ:"Ṑ",Ŏ:"Ŏ",Ǒ:"Ǒ",Ô:"Ô",Ố:"Ố",Ồ:"Ồ",Ỗ:"Ỗ",Ȯ:"Ȯ",Ȱ:"Ȱ",Ő:"Ő",Ṕ:"Ṕ",Ṗ:"Ṗ",Ŕ:"Ŕ",Ř:"Ř",Ṙ:"Ṙ",Ŗ:"Ŗ",Ś:"Ś",Ṥ:"Ṥ",Š:"Š",Ṧ:"Ṧ",Ŝ:"Ŝ",Ṡ:"Ṡ",Ş:"Ş",Ť:"Ť",Ṫ:"Ṫ",Ţ:"Ţ",Ú:"Ú",Ù:"Ù",Ü:"Ü",Ǘ:"Ǘ",Ǜ:"Ǜ",Ǖ:"Ǖ",Ǚ:"Ǚ",Ũ:"Ũ",Ṹ:"Ṹ",Ū:"Ū",Ṻ:"Ṻ",Ŭ:"Ŭ",Ǔ:"Ǔ",Û:"Û",Ů:"Ů",Ű:"Ű",Ṽ:"Ṽ",Ẃ:"Ẃ",Ẁ:"Ẁ",Ẅ:"Ẅ",Ŵ:"Ŵ",Ẇ:"Ẇ",Ẍ:"Ẍ",Ẋ:"Ẋ",Ý:"Ý",Ỳ:"Ỳ",Ÿ:"Ÿ",Ỹ:"Ỹ",Ȳ:"Ȳ",Ŷ:"Ŷ",Ẏ:"Ẏ",Ź:"Ź",Ž:"Ž",Ẑ:"Ẑ",Ż:"Ż",ά:"ά",ὰ:"ὰ",ᾱ:"ᾱ",ᾰ:"ᾰ",έ:"έ",ὲ:"ὲ",ή:"ή",ὴ:"ὴ",ί:"ί",ὶ:"ὶ",ϊ:"ϊ",ΐ:"ΐ",ῒ:"ῒ",ῑ:"ῑ",ῐ:"ῐ",ό:"ό",ὸ:"ὸ",ύ:"ύ",ὺ:"ὺ",ϋ:"ϋ",ΰ:"ΰ",ῢ:"ῢ",ῡ:"ῡ",ῠ:"ῠ",ώ:"ώ",ὼ:"ὼ",Ύ:"Ύ",Ὺ:"Ὺ",Ϋ:"Ϋ",Ῡ:"Ῡ",Ῠ:"Ῠ",Ώ:"Ώ",Ὼ:"Ὼ"};class je{constructor(e,t){this.mode=void 0,this.gullet=void 0,this.settings=void 0,this.leftrightDepth=void 0,this.nextToken=void 0,this.mode="math",this.gullet=new F4(e,t,this.mode),this.settings=t,this.leftrightDepth=0,this.nextToken=null}expect(e,t){if(t===void 0&&(t=!0),this.fetch().text!==e)throw new S("Expected '"+e+"', got '"+this.fetch().text+"'",this.fetch());t&&this.consume()}consume(){this.nextToken=null}fetch(){return this.nextToken==null&&(this.nextToken=this.gullet.expandNextToken()),this.nextToken}switchMode(e){this.mode=e,this.gullet.switchMode(e)}parse(){this.settings.globalGroup||this.gullet.beginGroup(),this.settings.colorIsTextColor&&this.gullet.macros.set("\\color","\\textcolor");try{var e=this.parseExpression(!1);return this.expect("EOF"),this.settings.globalGroup||this.gullet.endGroup(),e}finally{this.gullet.endGroups()}}subparse(e){var t=this.nextToken;this.consume(),this.gullet.pushToken(new c0("}")),this.gullet.pushTokens(e);var a=this.parseExpression(!1);return this.expect("}"),this.nextToken=t,a}parseExpression(e,t){for(var a=[];;){this.mode==="math"&&this.consumeSpaces();var i=this.fetch();if(je.endOfExpression.has(i.text)||t&&i.text===t||e&&O0[i.text]&&O0[i.text].infix)break;var s=this.parseAtom(t);if(s){if(s.type==="internal")continue}else break;a.push(s)}return this.mode==="text"&&this.formLigatures(a),this.handleInfixNodes(a)}handleInfixNodes(e){for(var t=-1,a,i=0;i=128)this.settings.strict&&(Gr(t.charCodeAt(0))?this.mode==="math"&&this.settings.reportNonstrict("unicodeTextInMathMode",'Unicode text character "'+t[0]+'" used in math mode',e):this.settings.reportNonstrict("unknownSymbol",'Unrecognized Unicode character "'+t[0]+'"'+(" ("+t.charCodeAt(0)+")"),e)),u={type:"textord",mode:"text",loc:h0.range(e),text:t};else return null;if(this.consume(),s)for(var p=0;p1?r[i-1]:void 0,a=i>2?r[2]:void 0;for(o=e.length>3&&typeof o=="function"?(i--,o):void 0,a&&k(r[0],r[1],a)&&(o=i<3?void 0:o,i=1),n=Object(n);++t2?n[2]:void 0;for(i&&k(n[0],n[1],i)&&(t=1);++r-1?i[o?n[a]:a]:void 0}}var Mt=Math.max;function Rt(e,n,r){var t=e==null?0:e.length;if(!t)return-1;var i=r==null?0:ir(r);return i<0&&(i=Mt(t+i,0)),Dn(e,N(n),i)}var le=At(Rt);function ln(e,n){var r=-1,t=U(e)?Array(e.length):[];return Yn(e,function(i,o,a){t[++r]=n(i,o,a)}),t}function g(e,n){var r=T(e)?S:ln;return r(e,N(n))}function St(e,n){return e==null?e:Ke(e,ze(n),H)}function $t(e,n){return e&&Je(e,ze(n))}function Ft(e,n){return e>n}var Bt=Object.prototype,Gt=Bt.hasOwnProperty;function Dt(e,n){return e!=null&&Gt.call(e,n)}function hn(e,n){return e!=null&&Vn(e,n,Dt)}function vn(e,n){return en||o&&a&&f&&!u&&!d||t&&a&&f||!r&&f||!i)return 1;if(!t&&!o&&!d&&e=u)return f;var d=r[t];return f*(d=="desc"?-1:1)}}return e.index-n.index}function Xt(e,n,r){n.length?n=S(n,function(o){return T(o)?function(a){return Qe(a,o.length===1?o[0]:o)}:o}):n=[se];var t=-1;n=S(n,de(N));var i=ln(e,function(o,a,u){var f=S(n,function(d){return d(o)});return{criteria:f,index:++t,value:o}});return Ut(i,function(o,a){return qt(o,a,r)})}function Ht(e,n){return Vt(e,n,function(r,t){return Wn(e,t)})}var Y=pr(function(e,n){return e==null?{}:Ht(e,n)}),Kt=Math.ceil,zt=Math.max;function Jt(e,n,r,t){for(var i=-1,o=zt(Kt((n-e)/(r||1)),0),a=Array(o);o--;)a[++i]=e,e+=r;return a}function Zt(e){return function(n,r,t){return t&&typeof t!="number"&&k(n,r,t)&&(r=t=void 0),n=$(n),r===void 0?(r=n,n=0):r=$(r),t=t===void 0?n1&&k(e,n[0],n[1])?n=[]:r>2&&k(n[0],n[1],n[2])&&(n=[n[0]]),Xt(e,qe(n),[])}),Qt=0;function pe(e){var n=++Qt;return qn(e)+n}function ei(e,n,r){for(var t=-1,i=e.length,o=n.length,a={};++t0;--u)if(a=n[u].dequeue(),a){t=t.concat(J(e,n,r,a,!0));break}}}return t}function J(e,n,r,t,i){var o=i?[]:void 0;return c(e.inEdges(t.v),function(a){var u=e.edge(a),f=e.node(a.v);i&&o.push({v:a.v,w:a.w}),f.out-=u,ae(n,r,f)}),c(e.outEdges(t.v),function(a){var u=e.edge(a),f=a.w,d=e.node(f);d.in-=u,ae(n,r,d)}),e.removeNode(t.v),o}function ui(e,n){var r=new x,t=0,i=0;c(e.nodes(),function(u){r.setNode(u,{v:u,in:0,out:0})}),c(e.edges(),function(u){var f=r.edge(u.v,u.w)||0,d=n(u),s=f+d;r.setEdge(u.v,u.w,s),i=Math.max(i,r.node(u.v).out+=d),t=Math.max(t,r.node(u.w).in+=d)});var o=L(i+t+3).map(function(){return new ri}),a=t+1;return c(r.nodes(),function(u){ae(o,a,r.node(u))}),{graph:r,buckets:o,zeroIdx:a}}function ae(e,n,r){r.out?r.in?e[r.out-r.in+n].enqueue(r):e[e.length-1].enqueue(r):e[0].enqueue(r)}function fi(e){var n=e.graph().acyclicer==="greedy"?ai(e,r(e)):di(e);c(n,function(t){var i=e.edge(t);e.removeEdge(t),i.forwardName=t.name,i.reversed=!0,e.setEdge(t.w,t.v,i,pe("rev"))});function r(t){return function(i){return t.edge(i).weight}}}function di(e){var n=[],r={},t={};function i(o){Object.prototype.hasOwnProperty.call(t,o)||(t[o]=!0,r[o]=!0,c(e.outEdges(o),function(a){Object.prototype.hasOwnProperty.call(r,a.w)?n.push(a):i(a.w)}),delete r[o])}return c(e.nodes(),i),n}function si(e){c(e.edges(),function(n){var r=e.edge(n);if(r.reversed){e.removeEdge(n);var t=r.forwardName;delete r.reversed,delete r.forwardName,e.setEdge(n.w,n.v,r,t)}})}function I(e,n,r,t){var i;do i=pe(t);while(e.hasNode(i));return r.dummy=n,e.setNode(i,r),i}function ci(e){var n=new x().setGraph(e.graph());return c(e.nodes(),function(r){n.setNode(r,e.node(r))}),c(e.edges(),function(r){var t=n.edge(r.v,r.w)||{weight:0,minlen:1},i=e.edge(r);n.setEdge(r.v,r.w,{weight:t.weight+i.weight,minlen:Math.max(t.minlen,i.minlen)})}),n}function pn(e){var n=new x({multigraph:e.isMultigraph()}).setGraph(e.graph());return c(e.nodes(),function(r){e.children(r).length||n.setNode(r,e.node(r))}),c(e.edges(),function(r){n.setEdge(r,e.edge(r))}),n}function Re(e,n){var r=e.x,t=e.y,i=n.x-r,o=n.y-t,a=e.width/2,u=e.height/2;if(!i&&!o)throw new Error("Not possible to find intersection inside of the rectangle");var f,d;return Math.abs(o)*a>Math.abs(i)*u?(o<0&&(u=-u),f=u*i/o,d=u):(i<0&&(a=-a),f=a,d=a*o/i),{x:r+f,y:t+d}}function z(e){var n=g(L(bn(e)+1),function(){return[]});return c(e.nodes(),function(r){var t=e.node(r),i=t.rank;m(i)||(n[i][t.order]=r)}),n}function li(e){var n=j(g(e.nodes(),function(r){return e.node(r).rank}));c(e.nodes(),function(r){var t=e.node(r);hn(t,"rank")&&(t.rank-=n)})}function hi(e){var n=j(g(e.nodes(),function(o){return e.node(o).rank})),r=[];c(e.nodes(),function(o){var a=e.node(o).rank-n;r[a]||(r[a]=[]),r[a].push(o)});var t=0,i=e.graph().nodeRankFactor;c(r,function(o,a){m(o)&&a%i!==0?--t:t&&c(o,function(u){e.node(u).rank+=t})})}function Se(e,n,r,t){var i={width:0,height:0};return arguments.length>=4&&(i.rank=r,i.order=t),I(e,"border",i,n)}function bn(e){return O(g(e.nodes(),function(n){var r=e.node(n).rank;if(!m(r))return r}))}function vi(e,n){var r={lhs:[],rhs:[]};return c(e,function(t){n(t)?r.lhs.push(t):r.rhs.push(t)}),r}function pi(e,n){return n()}function bi(e){function n(r){var t=e.children(r),i=e.node(r);if(t.length&&c(t,n),Object.prototype.hasOwnProperty.call(i,"minRank")){i.borderLeft=[],i.borderRight=[];for(var o=i.minRank,a=i.maxRank+1;oa.lim&&(u=a,f=!0);var d=M(n.edges(),function(s){return f===Be(e,e.node(s.v),u)&&f!==Be(e,e.node(s.w),u)});return ve(d,function(s){return A(n,s)})}function Pn(e,n,r,t){var i=r.v,o=r.w;e.removeEdge(i,o),e.setEdge(t.v,t.w,{}),ge(e),we(e,n),ki(e,n)}function ki(e,n){var r=le(e.nodes(),function(i){return!n.node(i).parent}),t=Ii(e,r);t=t.slice(1),c(t,function(i){var o=e.node(i).parent,a=n.edge(i,o),u=!1;a||(a=n.edge(o,i),u=!0),n.node(i).rank=n.node(o).rank+(u?a.minlen:-a.minlen)})}function ji(e,n,r){return e.hasEdge(n,r)}function Be(e,n,r){return r.low<=n.lim&&n.lim<=r.lim}function Ai(e){switch(e.graph().ranker){case"network-simplex":Ge(e);break;case"tight-tree":Ri(e);break;case"longest-path":Mi(e);break;default:Ge(e)}}var Mi=be;function Ri(e){be(e),gn(e)}function Ge(e){E(e)}function Si(e){var n=I(e,"root",{},"_root"),r=$i(e),t=O(P(r))-1,i=2*t+1;e.graph().nestingRoot=n,c(e.edges(),function(a){e.edge(a).minlen*=i});var o=Fi(e)+1;c(e.children(),function(a){Ln(e,n,i,o,t,r,a)}),e.graph().nodeRankFactor=i}function Ln(e,n,r,t,i,o,a){var u=e.children(a);if(!u.length){a!==n&&e.setEdge(n,a,{weight:0,minlen:r});return}var f=Se(e,"_bt"),d=Se(e,"_bb"),s=e.node(a);e.setParent(f,a),s.borderTop=f,e.setParent(d,a),s.borderBottom=d,c(u,function(l){Ln(e,n,r,t,i,o,l);var h=e.node(l),p=h.borderTop?h.borderTop:l,v=h.borderBottom?h.borderBottom:l,w=h.borderTop?t:2*t,_=p!==v?1:i-o[a]+1;e.setEdge(f,p,{weight:w,minlen:_,nestingEdge:!0}),e.setEdge(v,d,{weight:w,minlen:_,nestingEdge:!0})}),e.parent(a)||e.setEdge(n,f,{weight:0,minlen:i+o[a]})}function $i(e){var n={};function r(t,i){var o=e.children(t);o&&o.length&&c(o,function(a){r(a,i+1)}),n[t]=i}return c(e.children(),function(t){r(t,1)}),n}function Fi(e){return W(e.edges(),function(n,r){return n+e.edge(r).weight},0)}function Bi(e){var n=e.graph();e.removeNode(n.nestingRoot),delete n.nestingRoot,c(e.edges(),function(r){var t=e.edge(r);t.nestingEdge&&e.removeEdge(r)})}function Gi(e,n,r){var t={},i;c(r,function(o){for(var a=e.parent(o),u,f;a;){if(u=e.parent(a),u?(f=t[u],t[u]=a):(f=i,i=a),f&&f!==a){n.setEdge(f,a);return}a=u}})}function Di(e,n,r){var t=Yi(e),i=new x({compound:!0}).setGraph({root:t}).setDefaultNodeLabel(function(o){return e.node(o)});return c(e.nodes(),function(o){var a=e.node(o),u=e.parent(o);(a.rank===n||a.minRank<=n&&n<=a.maxRank)&&(i.setNode(o),i.setParent(o,u||t),c(e[r](o),function(f){var d=f.v===o?f.w:f.v,s=i.edge(d,o),l=m(s)?0:s.weight;i.setEdge(d,o,{weight:e.edge(f).weight+l})}),Object.prototype.hasOwnProperty.call(a,"minRank")&&i.setNode(o,{borderLeft:a.borderLeft[n],borderRight:a.borderRight[n]}))}),i}function Yi(e){for(var n;e.hasNode(n=pe("_root")););return n}function Vi(e,n){for(var r=0,t=1;t0;)s%2&&(l+=u[s+1]),s=s-1>>1,u[s]+=d.weight;f+=d.weight*l})),f}function Wi(e){var n={},r=M(e.nodes(),function(u){return!e.children(u).length}),t=O(g(r,function(u){return e.node(u).rank})),i=g(L(t+1),function(){return[]});function o(u){if(!hn(n,u)){n[u]=!0;var f=e.node(u);i[f.rank].push(u),c(e.successors(u),o)}}var a=R(r,function(u){return e.node(u).rank});return c(a,o),i}function qi(e,n){return g(n,function(r){var t=e.inEdges(r);if(t.length){var i=W(t,function(o,a){var u=e.edge(a),f=e.node(a.v);return{sum:o.sum+u.weight*f.order,weight:o.weight+u.weight}},{sum:0,weight:0});return{v:r,barycenter:i.sum/i.weight,weight:i.weight}}else return{v:r}})}function Xi(e,n){var r={};c(e,function(i,o){var a=r[i.v]={indegree:0,in:[],out:[],vs:[i.v],i:o};m(i.barycenter)||(a.barycenter=i.barycenter,a.weight=i.weight)}),c(n.edges(),function(i){var o=r[i.v],a=r[i.w];!m(o)&&!m(a)&&(a.indegree++,o.out.push(r[i.w]))});var t=M(r,function(i){return!i.indegree});return Hi(t)}function Hi(e){var n=[];function r(o){return function(a){a.merged||(m(a.barycenter)||m(o.barycenter)||a.barycenter>=o.barycenter)&&Ki(o,a)}}function t(o){return function(a){a.in.push(o),--a.indegree===0&&e.push(a)}}for(;e.length;){var i=e.pop();n.push(i),c(i.in.reverse(),r(i)),c(i.out,t(i))}return g(M(n,function(o){return!o.merged}),function(o){return Y(o,["vs","i","barycenter","weight"])})}function Ki(e,n){var r=0,t=0;e.weight&&(r+=e.barycenter*e.weight,t+=e.weight),n.weight&&(r+=n.barycenter*n.weight,t+=n.weight),e.vs=n.vs.concat(e.vs),e.barycenter=r/t,e.weight=t,e.i=Math.min(n.i,e.i),n.merged=!0}function zi(e,n){var r=vi(e,function(s){return Object.prototype.hasOwnProperty.call(s,"barycenter")}),t=r.lhs,i=R(r.rhs,function(s){return-s.i}),o=[],a=0,u=0,f=0;t.sort(Ji(!!n)),f=De(o,i,f),c(t,function(s){f+=s.vs.length,o.push(s.vs),a+=s.barycenter*s.weight,u+=s.weight,f=De(o,i,f)});var d={vs:C(o)};return u&&(d.barycenter=a/u,d.weight=u),d}function De(e,n,r){for(var t;n.length&&(t=D(n)).i<=r;)n.pop(),e.push(t.vs),r++;return r}function Ji(e){return function(n,r){return n.barycenterr.barycenter?1:e?r.i-n.i:n.i-r.i}}function Nn(e,n,r,t){var i=e.children(n),o=e.node(n),a=o?o.borderLeft:void 0,u=o?o.borderRight:void 0,f={};a&&(i=M(i,function(v){return v!==a&&v!==u}));var d=qi(e,i);c(d,function(v){if(e.children(v.v).length){var w=Nn(e,v.v,r,t);f[v.v]=w,Object.prototype.hasOwnProperty.call(w,"barycenter")&&Qi(v,w)}});var s=Xi(d,r);Zi(s,f);var l=zi(s,t);if(a&&(l.vs=C([a,l.vs,u]),e.predecessors(a).length)){var h=e.node(e.predecessors(a)[0]),p=e.node(e.predecessors(u)[0]);Object.prototype.hasOwnProperty.call(l,"barycenter")||(l.barycenter=0,l.weight=0),l.barycenter=(l.barycenter*l.weight+h.order+p.order)/(l.weight+2),l.weight+=2}return l}function Zi(e,n){c(e,function(r){r.vs=C(r.vs.map(function(t){return n[t]?n[t].vs:t}))})}function Qi(e,n){m(e.barycenter)?(e.barycenter=n.barycenter,e.weight=n.weight):(e.barycenter=(e.barycenter*e.weight+n.barycenter*n.weight)/(e.weight+n.weight),e.weight+=n.weight)}function ea(e){var n=bn(e),r=Ye(e,L(1,n+1),"inEdges"),t=Ye(e,L(n-1,-1,-1),"outEdges"),i=Wi(e);Ve(e,i);for(var o=Number.POSITIVE_INFINITY,a,u=0,f=0;f<4;++u,++f){na(u%2?r:t,u%4>=2),i=z(e);var d=Vi(e,i);da||u>n[f].lim));for(d=f,f=t;(f=e.parent(f))!==d;)o.push(f);return{path:i.concat(o.reverse()),lca:d}}function ia(e){var n={},r=0;function t(i){var o=r;c(e.children(i),t),n[i]={low:o,lim:r++}}return c(e.children(),t),n}function aa(e,n){var r={};function t(i,o){var a=0,u=0,f=i.length,d=D(o);return c(o,function(s,l){var h=ua(e,s),p=h?e.node(h).order:f;(h||s===d)&&(c(o.slice(u,l+1),function(v){c(e.predecessors(v),function(w){var _=e.node(w),me=_.order;(med)&&Cn(r,h,s)})})}function i(o,a){var u=-1,f,d=0;return c(a,function(s,l){if(e.node(s).dummy==="border"){var h=e.predecessors(s);h.length&&(f=e.node(h[0]).order,t(a,d,l,u,f),d=l,u=f)}t(a,d,a.length,f,o.length)}),a}return W(n,i),r}function ua(e,n){if(e.node(n).dummy)return le(e.predecessors(n),function(r){return e.node(r).dummy})}function Cn(e,n,r){if(n>r){var t=n;n=r,r=t}Object.prototype.hasOwnProperty.call(e,n)||Object.defineProperty(e,n,{enumerable:!0,configurable:!0,value:{},writable:!0});var i=e[n];Object.defineProperty(i,r,{enumerable:!0,configurable:!0,value:!0,writable:!0})}function fa(e,n,r){if(n>r){var t=n;n=r,r=t}return!!e[n]&&Object.prototype.hasOwnProperty.call(e[n],r)}function da(e,n,r,t){var i={},o={},a={};return c(n,function(u){c(u,function(f,d){i[f]=f,o[f]=f,a[f]=d})}),c(n,function(u){var f=-1;c(u,function(d){var s=t(d);if(s.length){s=R(s,function(w){return a[w]});for(var l=(s.length-1)/2,h=Math.floor(l),p=Math.ceil(l);h<=p;++h){var v=s[h];o[d]===d&&f{var t=r(" buildLayoutGraph",()=>_a(e));r(" runLayout",()=>ya(t,r)),r(" updateInputGraph",()=>xa(e,t))})}function ya(e,n){n(" makeSpaceForEdgeLabels",()=>ka(e)),n(" removeSelfEdges",()=>Ga(e)),n(" acyclic",()=>fi(e)),n(" nestingGraph.run",()=>Si(e)),n(" rank",()=>Ai(pn(e))),n(" injectEdgeLabelProxies",()=>ja(e)),n(" removeEmptyRanks",()=>hi(e)),n(" nestingGraph.cleanup",()=>Bi(e)),n(" normalizeRanks",()=>li(e)),n(" assignRankMinMax",()=>Aa(e)),n(" removeEdgeLabelProxies",()=>Ma(e)),n(" normalize.run",()=>xi(e)),n(" parentDummyChains",()=>ra(e)),n(" addBorderSegments",()=>bi(e)),n(" order",()=>ea(e)),n(" insertSelfEdges",()=>Da(e)),n(" adjustCoordinateSystem",()=>wi(e)),n(" position",()=>ga(e)),n(" positionSelfEdges",()=>Ya(e)),n(" removeBorderNodes",()=>Ba(e)),n(" normalize.undo",()=>Ei(e)),n(" fixupEdgeLabelCoords",()=>$a(e)),n(" undoCoordinateSystem",()=>gi(e)),n(" translateGraph",()=>Ra(e)),n(" assignNodeIntersects",()=>Sa(e)),n(" reversePoints",()=>Fa(e)),n(" acyclic.undo",()=>si(e))}function xa(e,n){c(e.nodes(),function(r){var t=e.node(r),i=n.node(r);t&&(t.x=i.x,t.y=i.y,n.children(r).length&&(t.width=i.width,t.height=i.height))}),c(e.edges(),function(r){var t=e.edge(r),i=n.edge(r);t.points=i.points,Object.prototype.hasOwnProperty.call(i,"x")&&(t.x=i.x,t.y=i.y)}),e.graph().width=n.graph().width,e.graph().height=n.graph().height}var Oa=["nodesep","edgesep","ranksep","marginx","marginy"],Ea={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},Ta=["acyclicer","ranker","rankdir","align"],Pa=["width","height"],La={width:0,height:0},Na=["minlen","weight","width","height","labeloffset"],Ca={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},Ia=["labelpos"];function _a(e){var n=new x({multigraph:!0,compound:!0}),r=ne(e.graph());return n.setGraph(ie({},Ea,ee(r,Oa),Y(r,Ta))),c(e.nodes(),function(t){var i=ne(e.node(t));n.setNode(t,_t(ee(i,Pa),La)),n.setParent(t,e.parent(t))}),c(e.edges(),function(t){var i=ne(e.edge(t));n.setEdge(t,ie({},Ca,ee(i,Na),Y(i,Ia)))}),n}function ka(e){var n=e.graph();n.ranksep/=2,c(e.edges(),function(r){var t=e.edge(r);t.minlen*=2,t.labelpos.toLowerCase()!=="c"&&(n.rankdir==="TB"||n.rankdir==="BT"?t.width+=t.labeloffset:t.height+=t.labeloffset)})}function ja(e){c(e.edges(),function(n){var r=e.edge(n);if(r.width&&r.height){var t=e.node(n.v),i=e.node(n.w),o={rank:(i.rank-t.rank)/2+t.rank,e:n};I(e,"edge-proxy",o,"_ep")}})}function Aa(e){var n=0;c(e.nodes(),function(r){var t=e.node(r);t.borderTop&&(t.minRank=e.node(t.borderTop).rank,t.maxRank=e.node(t.borderBottom).rank,n=O(n,t.maxRank))}),e.graph().maxRank=n}function Ma(e){c(e.nodes(),function(n){var r=e.node(n);r.dummy==="edge-proxy"&&(e.edge(r.e).labelRank=r.rank,e.removeNode(n))})}function Ra(e){var n=Number.POSITIVE_INFINITY,r=0,t=Number.POSITIVE_INFINITY,i=0,o=e.graph(),a=o.marginx||0,u=o.marginy||0;function f(d){var s=d.x,l=d.y,h=d.width,p=d.height;n=Math.min(n,s-h/2),r=Math.max(r,s+h/2),t=Math.min(t,l-p/2),i=Math.max(i,l+p/2)}c(e.nodes(),function(d){f(e.node(d))}),c(e.edges(),function(d){var s=e.edge(d);Object.prototype.hasOwnProperty.call(s,"x")&&f(s)}),n-=a,t-=u,c(e.nodes(),function(d){var s=e.node(d);s.x-=n,s.y-=t}),c(e.edges(),function(d){var s=e.edge(d);c(s.points,function(l){l.x-=n,l.y-=t}),Object.prototype.hasOwnProperty.call(s,"x")&&(s.x-=n),Object.prototype.hasOwnProperty.call(s,"y")&&(s.y-=t)}),o.width=r-n+a,o.height=i-t+u}function Sa(e){c(e.edges(),function(n){var r=e.edge(n),t=e.node(n.v),i=e.node(n.w),o,a;r.points?(o=r.points[0],a=r.points[r.points.length-1]):(r.points=[],o=i,a=t),r.points.unshift(Re(t,o)),r.points.push(Re(i,a))})}function $a(e){c(e.edges(),function(n){var r=e.edge(n);if(Object.prototype.hasOwnProperty.call(r,"x"))switch((r.labelpos==="l"||r.labelpos==="r")&&(r.width-=r.labeloffset),r.labelpos){case"l":r.x-=r.width/2+r.labeloffset;break;case"r":r.x+=r.width/2+r.labeloffset;break}})}function Fa(e){c(e.edges(),function(n){var r=e.edge(n);r.reversed&&r.points.reverse()})}function Ba(e){c(e.nodes(),function(n){if(e.children(n).length){var r=e.node(n),t=e.node(r.borderTop),i=e.node(r.borderBottom),o=e.node(D(r.borderLeft)),a=e.node(D(r.borderRight));r.width=Math.abs(a.x-o.x),r.height=Math.abs(i.y-t.y),r.x=o.x+r.width/2,r.y=t.y+r.height/2}}),c(e.nodes(),function(n){e.node(n).dummy==="border"&&e.removeNode(n)})}function Ga(e){c(e.edges(),function(n){if(n.v===n.w){var r=e.node(n.v);r.selfEdges||(r.selfEdges=[]),r.selfEdges.push({e:n,label:e.edge(n)}),e.removeEdge(n)}})}function Da(e){var n=z(e);c(n,function(r){var t=0;c(r,function(i,o){var a=e.node(i);a.order=o+t,c(a.selfEdges,function(u){I(e,"selfedge",{width:u.label.width,height:u.label.height,rank:a.rank,order:o+ ++t,e:u.e,label:u.label},"_se")}),delete a.selfEdges})})}function Ya(e){c(e.nodes(),function(n){var r=e.node(n);if(r.dummy==="selfedge"){var t=e.node(r.e.v),i=t.x+t.width/2,o=t.y,a=r.x-i,u=t.height/2;e.setEdge(r.e,r.label),e.removeNode(n),r.label.points=[{x:i+2*a/3,y:o-u},{x:i+5*a/6,y:o-u},{x:i+a,y:o},{x:i+5*a/6,y:o+u},{x:i+2*a/3,y:o+u}],r.label.x=r.x,r.label.y=r.y}})}function ee(e,n){return K(Y(e,n),Number)}function ne(e){var n={};return c(e,function(r,t){n[t.toLowerCase()]=r}),n}export{Ua as l}; diff --git a/packages/tempo/public/v4/assets/chunks/linear.D7HjFZ5V.js b/packages/tempo/public/v4/assets/chunks/linear.D7HjFZ5V.js new file mode 100644 index 00000000..e3c3cb48 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/linear.D7HjFZ5V.js @@ -0,0 +1 @@ +import{ba as j,bb as p,bc as w,bd as k,be as q}from"../app.CbekdYod.js";import{i as D}from"./init.Gi6I4Gst.js";import{e as g,f as F,a as z,b as B}from"./defaultLocale.DX6XiGOO.js";function M(n,r){return n==null||r==null?NaN:nr?1:n>=r?0:NaN}function I(n,r){return n==null||r==null?NaN:rn?1:r>=n?0:NaN}function R(n){let r,t,e;n.length!==2?(r=M,t=(o,c)=>M(n(o),c),e=(o,c)=>n(o)-c):(r=n===M||n===I?n:P,t=n,e=n);function u(o,c,i=0,h=o.length){if(i>>1;t(o[l],c)<0?i=l+1:h=l}while(i>>1;t(o[l],c)<=0?i=l+1:h=l}while(ii&&e(o[l-1],c)>-e(o[l],c)?l-1:l}return{left:u,center:a,right:f}}function P(){return 0}function V(n){return n===null?NaN:+n}const $=R(M),x=$.right;R(V).center;const O=Math.sqrt(50),T=Math.sqrt(10),C=Math.sqrt(2);function v(n,r,t){const e=(r-n)/Math.max(0,t),u=Math.floor(Math.log10(e)),f=e/Math.pow(10,u),a=f>=O?10:f>=T?5:f>=C?2:1;let o,c,i;return u<0?(i=Math.pow(10,-u)/a,o=Math.round(n*i),c=Math.round(r*i),o/ir&&--c,i=-i):(i=Math.pow(10,u)*a,o=Math.round(n/i),c=Math.round(r/i),o*ir&&--c),c0))return[];if(n===r)return[n];const e=r=u))return[];const o=f-u+1,c=new Array(o);if(e)if(a<0)for(let i=0;ir&&(t=n,n=r,r=t),function(e){return Math.max(n,Math.min(r,e))}}function nn(n,r,t){var e=n[0],u=n[1],f=r[0],a=r[1];return u2?rn:nn,c=i=null,l}function l(s){return s==null||isNaN(s=+s)?f:(c||(c=o(n.map(e),r,t)))(e(a(s)))}return l.invert=function(s){return a(u((i||(i=o(r,n.map(e),p)))(s)))},l.domain=function(s){return arguments.length?(n=Array.from(s,_),h()):n.slice()},l.range=function(s){return arguments.length?(r=Array.from(s),h()):r.slice()},l.rangeRound=function(s){return r=Array.from(s),t=U,h()},l.clamp=function(s){return arguments.length?(a=s?!0:m,h()):a!==m},l.interpolate=function(s){return arguments.length?(t=s,h()):t},l.unknown=function(s){return arguments.length?(f=s,l):f},function(s,S){return e=s,u=S,h()}}function un(){return tn()(m,m)}function an(n,r,t,e){var u=G(n,r,t),f;switch(e=F(e??",f"),e.type){case"s":{var a=Math.max(Math.abs(n),Math.abs(r));return e.precision==null&&!isNaN(f=X(u,a))&&(e.precision=f),z(e,a)}case"":case"e":case"g":case"p":case"r":{e.precision==null&&!isNaN(f=Y(u,Math.max(Math.abs(n),Math.abs(r))))&&(e.precision=f-(e.type==="e"));break}case"f":case"%":{e.precision==null&&!isNaN(f=W(u))&&(e.precision=f-(e.type==="%")*2);break}}return B(e)}function on(n){var r=n.domain;return n.ticks=function(t){var e=r();return E(e[0],e[e.length-1],t??10)},n.tickFormat=function(t,e){var u=r();return an(u[0],u[u.length-1],t??10,e)},n.nice=function(t){t==null&&(t=10);var e=r(),u=0,f=e.length-1,a=e[u],o=e[f],c,i,h=10;for(o0;){if(i=y(a,o,t),i===c)return e[u]=a,e[f]=o,r(e);if(i>0)a=Math.floor(a/i)*i,o=Math.ceil(o/i)*i;else if(i<0)a=Math.ceil(a*i)/i,o=Math.floor(o*i)/i;else break;c=i}return n},n}function fn(){var n=un();return n.copy=function(){return en(n,fn())},D.apply(n,arguments),on(n)}export{en as a,R as b,un as c,fn as l,G as t}; diff --git a/packages/tempo/public/v4/assets/chunks/mindmap-definition-YA3MSWOX.Cc4iPRg4.js b/packages/tempo/public/v4/assets/chunks/mindmap-definition-YA3MSWOX.Cc4iPRg4.js new file mode 100644 index 00000000..b38982c2 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/mindmap-definition-YA3MSWOX.Cc4iPRg4.js @@ -0,0 +1,96 @@ +import{g as oe}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as ae}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as l,l as C,x as ce,y as le,A as he,E as G,c as B,i as F,b4 as de,ac as ge,ad as ue,ae as pe}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";const E=[];for(let e=0;e<256;++e)E.push((e+256).toString(16).slice(1));function fe(e,n=0){return(E[e[n+0]]+E[e[n+1]]+E[e[n+2]]+E[e[n+3]]+"-"+E[e[n+4]]+E[e[n+5]]+"-"+E[e[n+6]]+E[e[n+7]]+"-"+E[e[n+8]]+E[e[n+9]]+"-"+E[e[n+10]]+E[e[n+11]]+E[e[n+12]]+E[e[n+13]]+E[e[n+14]]+E[e[n+15]]).toLowerCase()}const me=new Uint8Array(16);function ye(){return crypto.getRandomValues(me)}function Ee(e,n,g){return crypto.randomUUID?crypto.randomUUID():_e(e)}function _e(e,n,g){e=e||{};const a=e.random??e.rng?.()??ye();if(a.length<16)throw new Error("Random bytes length must be >= 16");return a[6]=a[6]&15|64,a[8]=a[8]&63|128,fe(a)}var Y=(function(){var e=l(function(D,s,i,o){for(i=i||{},o=D.length;o--;i[D[o]]=s);return i},"o"),n=[1,4],g=[1,13],a=[1,12],t=[1,15],h=[1,16],f=[1,20],m=[1,19],_=[6,7,8],T=[1,26],I=[1,24],w=[1,25],d=[6,7,11],R=[1,6,13,15,16,19,22],q=[1,33],J=[1,34],A=[1,6,7,11,13,15,16,19,22],j={trace:l(function(){},"trace"),yy:{},symbols_:{error:2,start:3,mindMap:4,spaceLines:5,SPACELINE:6,NL:7,MINDMAP:8,document:9,stop:10,EOF:11,statement:12,SPACELIST:13,node:14,ICON:15,CLASS:16,nodeWithId:17,nodeWithoutId:18,NODE_DSTART:19,NODE_DESCR:20,NODE_DEND:21,NODE_ID:22,$accept:0,$end:1},terminals_:{2:"error",6:"SPACELINE",7:"NL",8:"MINDMAP",11:"EOF",13:"SPACELIST",15:"ICON",16:"CLASS",19:"NODE_DSTART",20:"NODE_DESCR",21:"NODE_DEND",22:"NODE_ID"},productions_:[0,[3,1],[3,2],[5,1],[5,2],[5,2],[4,2],[4,3],[10,1],[10,1],[10,1],[10,2],[10,2],[9,3],[9,2],[12,2],[12,2],[12,2],[12,1],[12,1],[12,1],[12,1],[12,1],[14,1],[14,1],[18,3],[17,1],[17,4]],performAction:l(function(s,i,o,c,p,r,$){var u=r.length-1;switch(p){case 6:case 7:return c;case 8:c.getLogger().trace("Stop NL ");break;case 9:c.getLogger().trace("Stop EOF ");break;case 11:c.getLogger().trace("Stop NL2 ");break;case 12:c.getLogger().trace("Stop EOF2 ");break;case 15:c.getLogger().info("Node: ",r[u].id),c.addNode(r[u-1].length,r[u].id,r[u].descr,r[u].type);break;case 16:c.getLogger().trace("Icon: ",r[u]),c.decorateNode({icon:r[u]});break;case 17:case 21:c.decorateNode({class:r[u]});break;case 18:c.getLogger().trace("SPACELIST");break;case 19:c.getLogger().trace("Node: ",r[u].id),c.addNode(0,r[u].id,r[u].descr,r[u].type);break;case 20:c.decorateNode({icon:r[u]});break;case 25:c.getLogger().trace("node found ..",r[u-2]),this.$={id:r[u-1],descr:r[u-1],type:c.getType(r[u-2],r[u])};break;case 26:this.$={id:r[u],descr:r[u],type:c.nodeType.DEFAULT};break;case 27:c.getLogger().trace("node found ..",r[u-3]),this.$={id:r[u-3],descr:r[u-1],type:c.getType(r[u-2],r[u])};break}},"anonymous"),table:[{3:1,4:2,5:3,6:[1,5],8:n},{1:[3]},{1:[2,1]},{4:6,6:[1,7],7:[1,8],8:n},{6:g,7:[1,10],9:9,12:11,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},e(_,[2,3]),{1:[2,2]},e(_,[2,4]),e(_,[2,5]),{1:[2,6],6:g,12:21,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},{6:g,9:22,12:11,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},{6:T,7:I,10:23,11:w},e(d,[2,22],{17:17,18:18,14:27,15:[1,28],16:[1,29],19:f,22:m}),e(d,[2,18]),e(d,[2,19]),e(d,[2,20]),e(d,[2,21]),e(d,[2,23]),e(d,[2,24]),e(d,[2,26],{19:[1,30]}),{20:[1,31]},{6:T,7:I,10:32,11:w},{1:[2,7],6:g,12:21,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},e(R,[2,14],{7:q,11:J}),e(A,[2,8]),e(A,[2,9]),e(A,[2,10]),e(d,[2,15]),e(d,[2,16]),e(d,[2,17]),{20:[1,35]},{21:[1,36]},e(R,[2,13],{7:q,11:J}),e(A,[2,11]),e(A,[2,12]),{21:[1,37]},e(d,[2,25]),e(d,[2,27])],defaultActions:{2:[2,1],6:[2,2]},parseError:l(function(s,i){if(i.recoverable)this.trace(s);else{var o=new Error(s);throw o.hash=i,o}},"parseError"),parse:l(function(s){var i=this,o=[0],c=[],p=[null],r=[],$=this.table,u="",M=0,K=0,ne=2,Q=1,ie=r.slice.call(arguments,1),y=Object.create(this.lexer),L={yy:{}};for(var H in this.yy)Object.prototype.hasOwnProperty.call(this.yy,H)&&(L.yy[H]=this.yy[H]);y.setInput(s,L.yy),L.yy.lexer=y,L.yy.parser=this,typeof y.yylloc>"u"&&(y.yylloc={});var W=y.yylloc;r.push(W);var se=y.options&&y.options.ranges;typeof L.yy.parseError=="function"?this.parseError=L.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function re(k){o.length=o.length-2*k,p.length=p.length-k,r.length=r.length-k}l(re,"popStack");function Z(){var k;return k=c.pop()||y.lex()||Q,typeof k!="number"&&(k instanceof Array&&(c=k,k=c.pop()),k=i.symbols_[k]||k),k}l(Z,"lex");for(var b,v,S,z,O={},U,x,ee,V;;){if(v=o[o.length-1],this.defaultActions[v]?S=this.defaultActions[v]:((b===null||typeof b>"u")&&(b=Z()),S=$[v]&&$[v][b]),typeof S>"u"||!S.length||!S[0]){var X="";V=[];for(U in $[v])this.terminals_[U]&&U>ne&&V.push("'"+this.terminals_[U]+"'");y.showPosition?X="Parse error on line "+(M+1)+`: +`+y.showPosition()+` +Expecting `+V.join(", ")+", got '"+(this.terminals_[b]||b)+"'":X="Parse error on line "+(M+1)+": Unexpected "+(b==Q?"end of input":"'"+(this.terminals_[b]||b)+"'"),this.parseError(X,{text:y.match,token:this.terminals_[b]||b,line:y.yylineno,loc:W,expected:V})}if(S[0]instanceof Array&&S.length>1)throw new Error("Parse Error: multiple actions possible at state: "+v+", token: "+b);switch(S[0]){case 1:o.push(b),p.push(y.yytext),r.push(y.yylloc),o.push(S[1]),b=null,K=y.yyleng,u=y.yytext,M=y.yylineno,W=y.yylloc;break;case 2:if(x=this.productions_[S[1]][1],O.$=p[p.length-x],O._$={first_line:r[r.length-(x||1)].first_line,last_line:r[r.length-1].last_line,first_column:r[r.length-(x||1)].first_column,last_column:r[r.length-1].last_column},se&&(O._$.range=[r[r.length-(x||1)].range[0],r[r.length-1].range[1]]),z=this.performAction.apply(O,[u,K,M,L.yy,S[1],p,r].concat(ie)),typeof z<"u")return z;x&&(o=o.slice(0,-1*x*2),p=p.slice(0,-1*x),r=r.slice(0,-1*x)),o.push(this.productions_[S[1]][0]),p.push(O.$),r.push(O._$),ee=$[o[o.length-2]][o[o.length-1]],o.push(ee);break;case 3:return!0}}return!0},"parse")},te=(function(){var D={EOF:1,parseError:l(function(i,o){if(this.yy.parser)this.yy.parser.parseError(i,o);else throw new Error(i)},"parseError"),setInput:l(function(s,i){return this.yy=i||this.yy||{},this._input=s,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:l(function(){var s=this._input[0];this.yytext+=s,this.yyleng++,this.offset++,this.match+=s,this.matched+=s;var i=s.match(/(?:\r\n?|\n).*/g);return i?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),s},"input"),unput:l(function(s){var i=s.length,o=s.split(/(?:\r\n?|\n)/g);this._input=s+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-i),this.offset-=i;var c=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),o.length-1&&(this.yylineno-=o.length-1);var p=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:o?(o.length===c.length?this.yylloc.first_column:0)+c[c.length-o.length].length-o[0].length:this.yylloc.first_column-i},this.options.ranges&&(this.yylloc.range=[p[0],p[0]+this.yyleng-i]),this.yyleng=this.yytext.length,this},"unput"),more:l(function(){return this._more=!0,this},"more"),reject:l(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:l(function(s){this.unput(this.match.slice(s))},"less"),pastInput:l(function(){var s=this.matched.substr(0,this.matched.length-this.match.length);return(s.length>20?"...":"")+s.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:l(function(){var s=this.match;return s.length<20&&(s+=this._input.substr(0,20-s.length)),(s.substr(0,20)+(s.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:l(function(){var s=this.pastInput(),i=new Array(s.length+1).join("-");return s+this.upcomingInput()+` +`+i+"^"},"showPosition"),test_match:l(function(s,i){var o,c,p;if(this.options.backtrack_lexer&&(p={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(p.yylloc.range=this.yylloc.range.slice(0))),c=s[0].match(/(?:\r\n?|\n).*/g),c&&(this.yylineno+=c.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:c?c[c.length-1].length-c[c.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+s[0].length},this.yytext+=s[0],this.match+=s[0],this.matches=s,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(s[0].length),this.matched+=s[0],o=this.performAction.call(this,this.yy,this,i,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),o)return o;if(this._backtrack){for(var r in p)this[r]=p[r];return!1}return!1},"test_match"),next:l(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var s,i,o,c;this._more||(this.yytext="",this.match="");for(var p=this._currentRules(),r=0;ri[0].length)){if(i=o,c=r,this.options.backtrack_lexer){if(s=this.test_match(o,p[r]),s!==!1)return s;if(this._backtrack){i=!1;continue}else return!1}else if(!this.options.flex)break}return i?(s=this.test_match(i,p[c]),s!==!1?s:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:l(function(){var i=this.next();return i||this.lex()},"lex"),begin:l(function(i){this.conditionStack.push(i)},"begin"),popState:l(function(){var i=this.conditionStack.length-1;return i>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:l(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:l(function(i){return i=this.conditionStack.length-1-Math.abs(i||0),i>=0?this.conditionStack[i]:"INITIAL"},"topState"),pushState:l(function(i){this.begin(i)},"pushState"),stateStackSize:l(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:l(function(i,o,c,p){switch(c){case 0:return i.getLogger().trace("Found comment",o.yytext),6;case 1:return 8;case 2:this.begin("CLASS");break;case 3:return this.popState(),16;case 4:this.popState();break;case 5:i.getLogger().trace("Begin icon"),this.begin("ICON");break;case 6:return i.getLogger().trace("SPACELINE"),6;case 7:return 7;case 8:return 15;case 9:i.getLogger().trace("end icon"),this.popState();break;case 10:return i.getLogger().trace("Exploding node"),this.begin("NODE"),19;case 11:return i.getLogger().trace("Cloud"),this.begin("NODE"),19;case 12:return i.getLogger().trace("Explosion Bang"),this.begin("NODE"),19;case 13:return i.getLogger().trace("Cloud Bang"),this.begin("NODE"),19;case 14:return this.begin("NODE"),19;case 15:return this.begin("NODE"),19;case 16:return this.begin("NODE"),19;case 17:return this.begin("NODE"),19;case 18:return 13;case 19:return 22;case 20:return 11;case 21:this.begin("NSTR2");break;case 22:return"NODE_DESCR";case 23:this.popState();break;case 24:i.getLogger().trace("Starting NSTR"),this.begin("NSTR");break;case 25:return i.getLogger().trace("description:",o.yytext),"NODE_DESCR";case 26:this.popState();break;case 27:return this.popState(),i.getLogger().trace("node end ))"),"NODE_DEND";case 28:return this.popState(),i.getLogger().trace("node end )"),"NODE_DEND";case 29:return this.popState(),i.getLogger().trace("node end ...",o.yytext),"NODE_DEND";case 30:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 31:return this.popState(),i.getLogger().trace("node end (-"),"NODE_DEND";case 32:return this.popState(),i.getLogger().trace("node end (-"),"NODE_DEND";case 33:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 34:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 35:return i.getLogger().trace("Long description:",o.yytext),20;case 36:return i.getLogger().trace("Long description:",o.yytext),20}},"anonymous"),rules:[/^(?:\s*%%.*)/i,/^(?:mindmap\b)/i,/^(?::::)/i,/^(?:.+)/i,/^(?:\n)/i,/^(?:::icon\()/i,/^(?:[\s]+[\n])/i,/^(?:[\n]+)/i,/^(?:[^\)]+)/i,/^(?:\))/i,/^(?:-\))/i,/^(?:\(-)/i,/^(?:\)\))/i,/^(?:\))/i,/^(?:\(\()/i,/^(?:\{\{)/i,/^(?:\()/i,/^(?:\[)/i,/^(?:[\s]+)/i,/^(?:[^\(\[\n\)\{\}]+)/i,/^(?:$)/i,/^(?:["][`])/i,/^(?:[^`"]+)/i,/^(?:[`]["])/i,/^(?:["])/i,/^(?:[^"]+)/i,/^(?:["])/i,/^(?:[\)]\))/i,/^(?:[\)])/i,/^(?:[\]])/i,/^(?:\}\})/i,/^(?:\(-)/i,/^(?:-\))/i,/^(?:\(\()/i,/^(?:\()/i,/^(?:[^\)\]\(\}]+)/i,/^(?:.+(?!\(\())/i],conditions:{CLASS:{rules:[3,4],inclusive:!1},ICON:{rules:[8,9],inclusive:!1},NSTR2:{rules:[22,23],inclusive:!1},NSTR:{rules:[25,26],inclusive:!1},NODE:{rules:[21,24,27,28,29,30,31,32,33,34,35,36],inclusive:!1},INITIAL:{rules:[0,1,2,5,6,7,10,11,12,13,14,15,16,17,18,19,20],inclusive:!0}}};return D})();j.lexer=te;function P(){this.yy={}}return l(P,"Parser"),P.prototype=j,j.Parser=P,new P})();Y.parser=Y;var be=Y,ke=12,N={DEFAULT:0,NO_BORDER:0,ROUNDED_RECT:1,RECT:2,CIRCLE:3,CLOUD:4,BANG:5,HEXAGON:6},Se=class{constructor(){this.nodes=[],this.count=0,this.elements={},this.getLogger=this.getLogger.bind(this),this.nodeType=N,this.clear(),this.getType=this.getType.bind(this),this.getElementById=this.getElementById.bind(this),this.getParent=this.getParent.bind(this),this.getMindmap=this.getMindmap.bind(this),this.addNode=this.addNode.bind(this),this.decorateNode=this.decorateNode.bind(this)}static{l(this,"MindmapDB")}clear(){this.nodes=[],this.count=0,this.elements={},this.baseLevel=void 0}getParent(e){for(let n=this.nodes.length-1;n>=0;n--)if(this.nodes[n].level0?this.nodes[0]:null}addNode(e,n,g,a){C.info("addNode",e,n,g,a);let t=!1;this.nodes.length===0?(this.baseLevel=e,e=0,t=!0):this.baseLevel!==void 0&&(e=e-this.baseLevel,t=!1);const h=B();let f=h.mindmap?.padding??G.mindmap.padding;switch(a){case this.nodeType.ROUNDED_RECT:case this.nodeType.RECT:case this.nodeType.HEXAGON:f*=2;break}const m={id:this.count++,nodeId:F(n,h),level:e,descr:F(g,h),type:a,children:[],width:h.mindmap?.maxNodeWidth??G.mindmap.maxNodeWidth,padding:f,isRoot:t},_=this.getParent(e);if(_)_.children.push(m),this.nodes.push(m);else if(t)this.nodes.push(m);else throw new Error(`There can be only one root. No parent could be found for ("${m.descr}")`)}getType(e,n){switch(C.debug("In get type",e,n),e){case"[":return this.nodeType.RECT;case"(":return n===")"?this.nodeType.ROUNDED_RECT:this.nodeType.CLOUD;case"((":return this.nodeType.CIRCLE;case")":return this.nodeType.CLOUD;case"))":return this.nodeType.BANG;case"{{":return this.nodeType.HEXAGON;default:return this.nodeType.DEFAULT}}setElementForId(e,n){this.elements[e]=n}getElementById(e){return this.elements[e]}decorateNode(e){if(!e)return;const n=B(),g=this.nodes[this.nodes.length-1];e.icon&&(g.icon=F(e.icon,n)),e.class&&(g.class=F(e.class,n))}type2Str(e){switch(e){case this.nodeType.DEFAULT:return"no-border";case this.nodeType.RECT:return"rect";case this.nodeType.ROUNDED_RECT:return"rounded-rect";case this.nodeType.CIRCLE:return"circle";case this.nodeType.CLOUD:return"cloud";case this.nodeType.BANG:return"bang";case this.nodeType.HEXAGON:return"hexgon";default:return"no-border"}}assignSections(e,n){if(e.level===0?e.section=void 0:e.section=n,e.children)for(const[g,a]of e.children.entries()){const t=e.level===0?g%(ke-1):n;this.assignSections(a,t)}}flattenNodes(e,n){const g=B(),a=["mindmap-node"];e.isRoot===!0?a.push("section-root","section--1"):e.section!==void 0&&a.push(`section-${e.section}`),e.class&&a.push(e.class);const t=a.join(" "),h=l(m=>{const T=(g.theme?.toLowerCase()??"").includes("redux");switch(m){case N.CIRCLE:return"mindmapCircle";case N.RECT:return"rect";case N.ROUNDED_RECT:return"rounded";case N.CLOUD:return"cloud";case N.BANG:return"bang";case N.HEXAGON:return"hexagon";case N.DEFAULT:return T?"rounded":"defaultMindmapNode";case N.NO_BORDER:default:return"rect"}},"getShapeFromType"),f={id:e.id.toString(),domId:"node_"+e.id.toString(),label:e.descr,labelType:"markdown",isGroup:!1,shape:h(e.type),width:e.width,height:e.height??0,padding:e.padding,cssClasses:t,cssStyles:[],look:g.look,icon:e.icon,x:e.x,y:e.y,level:e.level,nodeId:e.nodeId,type:e.type,section:e.section};if(n.push(f),e.children)for(const m of e.children)this.flattenNodes(m,n)}generateEdges(e,n){if(!e.children)return;const g=B();for(const a of e.children){let t="edge";a.section!==void 0&&(t+=` section-edge-${a.section}`);const h=e.level+1;t+=` edge-depth-${h}`;const f={id:`edge_${e.id}_${a.id}`,start:e.id.toString(),end:a.id.toString(),type:"normal",curve:"basis",thickness:"normal",look:g.look,classes:t,depth:e.level,section:a.section};n.push(f),this.generateEdges(a,n)}}getData(){const e=this.getMindmap(),n=B(),a=de().layout!==void 0,t=n;if(a||(t.layout="cose-bilkent"),!e)return{nodes:[],edges:[],config:t};C.debug("getData: mindmapRoot",e,n),this.assignSections(e);const h=[],f=[];this.flattenNodes(e,h),this.generateEdges(e,f),C.debug(`getData: processed ${h.length} nodes and ${f.length} edges`);const m=new Map;for(const _ of h)m.set(_.id,{shape:_.shape,width:_.width,height:_.height,padding:_.padding});return{nodes:h,edges:f,config:t,rootNode:e,markers:["point"],direction:"TB",nodeSpacing:50,rankSpacing:50,shapes:Object.fromEntries(m),type:"mindmap",diagramId:"mindmap-"+Ee()}}getLogger(){return C}},xe=l(async(e,n,g,a)=>{C.debug(`Rendering mindmap diagram +`+e);const t=a.db,h=t.getData(),f=oe(n,h.config.securityLevel);if(h.type=a.type,h.layoutAlgorithm=ce(h.config.layout,{fallback:"cose-bilkent"}),h.diagramId=n,!t.getMindmap())return;h.nodes.forEach(d=>{d.shape==="rounded"?(d.radius=15,d.taper=15,d.stroke="none",d.width=0,d.padding=15):d.shape==="circle"?d.padding=10:d.shape==="rect"?(d.width=0,d.padding=10):d.shape==="hexagon"&&(d.width=0,d.height=0)}),await le(h,f);const{themeVariables:_}=he(),{useGradient:T,gradientStart:I,gradientStop:w}=_;if(T&&I&&w){const d=f.attr("id"),R=f.append("defs").append("linearGradient").attr("id",`${d}-gradient`).attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");R.append("stop").attr("offset","0%").attr("stop-color",I).attr("stop-opacity",1),R.append("stop").attr("offset","100%").attr("stop-color",w).attr("stop-opacity",1)}ae(f,h.config.mindmap?.padding??G.mindmap.padding,"mindmapDiagram",h.config.mindmap?.useMaxWidth??G.mindmap.useMaxWidth)},"draw"),Ne={draw:xe},De=l(e=>{const{theme:n,look:g}=e;let a="";for(let t=0;t{let a="";for(let t=0;t{const{theme:n}=e,g=e.svgId,a=e.dropShadow?e.dropShadow.replace("url(#drop-shadow)",`url(${g}-drop-shadow)`):"none";return` + .edge { + stroke-width: 3; + } + ${De(e)} + .section-root rect, .section-root path, .section-root circle, .section-root polygon { + fill: ${e.git0}; + } + .section-root text { + fill: ${e.gitBranchLabel0}; + } + .section-root span { + color: ${n?.includes("redux")?e.nodeBorder:e.gitBranchLabel0}; + } + .icon-container { + height:100%; + display: flex; + justify-content: center; + align-items: center; + } + .edge { + fill: none; + } + .mindmap-node-label { + dy: 1em; + alignment-baseline: middle; + text-anchor: middle; + dominant-baseline: middle; + text-align: center; + } + [data-look="neo"].mindmap-node { + filter: ${a}; + } + [data-look="neo"].mindmap-node.section-root rect, [data-look="neo"].mindmap-node.section-root path, [data-look="neo"].mindmap-node.section-root circle, [data-look="neo"].mindmap-node.section-root polygon { + fill: ${n?.includes("redux")?e.mainBkg:e.git0}; + } + [data-look="neo"].mindmap-node.section-root .text-inner-tspan { + fill: ${n?.includes("redux")?e.nodeBorder:e["cScaleLabel"+(n==="neutral"?1:0)]}; + } + ${e.useGradient&&g&&e.mainBkg?Le(e.THEME_COLOR_LIMIT,g,e.mainBkg):""} +`},"getStyles"),Te=ve,Ae={get db(){return new Se},renderer:Ne,parser:be,styles:Te};export{Ae as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/ordinal.BYWQX77i.js b/packages/tempo/public/v4/assets/chunks/ordinal.BYWQX77i.js new file mode 100644 index 00000000..1f7977b7 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/ordinal.BYWQX77i.js @@ -0,0 +1 @@ +import{i as a}from"./init.Gi6I4Gst.js";class o extends Map{constructor(n,t=g){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:t}}),n!=null)for(const[r,s]of n)this.set(r,s)}get(n){return super.get(c(this,n))}has(n){return super.has(c(this,n))}set(n,t){return super.set(l(this,n),t)}delete(n){return super.delete(p(this,n))}}function c({_intern:e,_key:n},t){const r=n(t);return e.has(r)?e.get(r):t}function l({_intern:e,_key:n},t){const r=n(t);return e.has(r)?e.get(r):(e.set(r,t),t)}function p({_intern:e,_key:n},t){const r=n(t);return e.has(r)&&(t=e.get(r),e.delete(r)),t}function g(e){return e!==null&&typeof e=="object"?e.valueOf():e}const f=Symbol("implicit");function h(){var e=new o,n=[],t=[],r=f;function s(u){let i=e.get(u);if(i===void 0){if(r!==f)return r;e.set(u,i=n.push(u)-1)}return t[i%t.length]}return s.domain=function(u){if(!arguments.length)return n.slice();n=[],e=new o;for(const i of u)e.has(i)||e.set(i,n.push(i)-1);return s},s.range=function(u){return arguments.length?(t=Array.from(u),s):t.slice()},s.unknown=function(u){return arguments.length?(r=u,s):r},s.copy=function(){return h(n,t).unknown(r)},a.apply(s,arguments),s}export{h as o}; diff --git a/packages/tempo/public/v4/assets/chunks/pegDiagram-XKGWAZYB.kTxCBLbr.js b/packages/tempo/public/v4/assets/chunks/pegDiagram-XKGWAZYB.kTxCBLbr.js new file mode 100644 index 00000000..80187b32 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/pegDiagram-XKGWAZYB.kTxCBLbr.js @@ -0,0 +1 @@ +import{g as l,r as m,d as a}from"./chunk-SVP7TREG.tNKCi1Yy.js";import{p}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as t,l as o}from"../app.CbekdYod.js";import{M as u,d as c}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var f=c().RailroadPeg.parser.LangiumParser,i=t(e=>{const r=e.alternatives.map(d);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformOrderedChoice"),d=t(e=>{const r=e.elements.map(P);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformSequence"),P=t(e=>{const r=g(e.suffix);return e.operator?{type:"special",text:e.operator==="&"?`&${s(r)}`:`!${s(r)}`}:r},"transformPrefix"),s=t(e=>{switch(e.type){case"terminal":return`"${e.value}"`;case"nonterminal":return e.name;case"special":return e.text;default:return"(...)"}},"nodeToLabel"),g=t(e=>{const r=v(e.primary);if(!e.operator)return r;switch(e.operator){case"?":return{type:"optional",element:r};case"*":return{type:"repetition",element:r,min:0,max:1/0};case"+":return{type:"repetition",element:r,min:1,max:1/0};default:throw new Error(`Unsupported PEG suffix operator: ${e.operator}`)}},"transformSuffix"),v=t(e=>{switch(e.$type){case"PegLiteral":return{type:"terminal",value:e.value};case"PegIdentifier":return{type:"nonterminal",name:e.name};case"PegGroup":return i(e.element);case"PegAny":return{type:"special",text:e.dot};default:throw new Error(`Unsupported PEG primary node: ${e.$type}`)}},"transformPrimary"),y=t(e=>({name:e.name,definition:i(e.definition)}),"transformRule"),h=t(e=>{p(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(y(r)))},"populateDb"),b={parse:t(e=>{a.clear(),o.debug("[PEG Parser] Starting Langium parse");const r=f.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new u(r);const n=r.value;o.debug("[PEG Parser] Parsed rules:",n.rules.length),h(n),o.debug("[PEG Parser] Parse complete")},"parse"),parser:{yy:a}},L={parser:b,db:a,renderer:m,styles:l};export{L as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/pieDiagram-E7YTZNPT.C7NYDYqu.js b/packages/tempo/public/v4/assets/chunks/pieDiagram-E7YTZNPT.C7NYDYqu.js new file mode 100644 index 00000000..f5ceec24 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/pieDiagram-E7YTZNPT.C7NYDYqu.js @@ -0,0 +1,39 @@ +import{p as at}from"./chunk-JWPE2WC7.5yopTNlD.js";import{S as T,K as P,b3 as rt,g as nt,s as it,a as ot,b as st,q as lt,p as ct,_ as g,l as B,c as ut,D as dt,G as gt,a2 as pt,d as ht,r as ft,E as mt}from"../app.CbekdYod.js";import{p as vt}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import{d as X}from"./arc.BFiNID6s.js";import{o as xt}from"./ordinal.BYWQX77i.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./init.Gi6I4Gst.js";function St(t,n){return nt?1:n>=t?0:NaN}function yt(t){return t}function wt(){var t=yt,n=St,y=null,b=T(0),l=T(P),p=T(0);function i(e){var r,s=(e=rt(e)).length,h,w,$=0,f=new Array(s),o=new Array(s),D=+b.apply(this,arguments),z=Math.min(P,Math.max(-P,l.apply(this,arguments)-D)),k,L=Math.min(Math.abs(z)/s,p.apply(this,arguments)),u=L*(z<0?-1:1),A;for(r=0;r0&&($+=A);for(n!=null?f.sort(function(M,m){return n(o[M],o[m])}):y!=null&&f.sort(function(M,m){return y(e[M],e[m])}),r=0,w=$?(z-s*u)/$:0;r0?A*w:0)+u,o[h]={data:e[h],index:r,value:A,startAngle:D,endAngle:k,padAngle:L};return o}return i.value=function(e){return arguments.length?(t=typeof e=="function"?e:T(+e),i):t},i.sortValues=function(e){return arguments.length?(n=e,y=null,i):n},i.sort=function(e){return arguments.length?(y=e,n=null,i):y},i.startAngle=function(e){return arguments.length?(b=typeof e=="function"?e:T(+e),i):b},i.endAngle=function(e){return arguments.length?(l=typeof e=="function"?e:T(+e),i):l},i.padAngle=function(e){return arguments.length?(p=typeof e=="function"?e:T(+e),i):p},i}var At=mt.pie,I={sections:new Map,showData:!1},F=I.sections,V=I.showData,Ct=structuredClone(At),$t=g(()=>structuredClone(Ct),"getConfig"),Dt=g(()=>{F=new Map,V=I.showData,ft()},"clear"),Tt=g(({label:t,value:n})=>{if(n<0)throw new Error(`"${t}" has invalid value: ${n}. Negative values are not allowed in pie charts. All slice values must be >= 0.`);F.has(t)||(F.set(t,n),B.debug(`added new section: ${t}, with value: ${n}`))},"addSection"),bt=g(()=>F,"getSections"),kt=g(t=>{V=t},"setShowData"),Et=g(()=>V,"getShowData"),Z={getConfig:$t,clear:Dt,setDiagramTitle:ct,getDiagramTitle:lt,setAccTitle:st,getAccTitle:ot,setAccDescription:it,getAccDescription:nt,addSection:Tt,getSections:bt,setShowData:kt,getShowData:Et},zt=g((t,n)=>{at(t,n),n.setShowData(t.showData),t.sections.map(n.addSection)},"populateDb"),Mt={parse:g(async t=>{const n=await vt("pie",t);B.debug(n),zt(n,Z)},"parse")},Rt=g(t=>` + .pieCircle{ + stroke: ${t.pieStrokeColor}; + stroke-width : ${t.pieStrokeWidth}; + opacity : ${t.pieOpacity}; + } + .pieCircle.highlighted{ + scale: 1.05; + opacity: 1; + } + .pieCircle.highlightedOnHover:hover{ + transition-duration: 250ms; + scale: 1.05; + opacity: 1; + } + .pieOuterCircle{ + stroke: ${t.pieOuterStrokeColor}; + stroke-width: ${t.pieOuterStrokeWidth}; + fill: none; + } + .pieTitleText { + text-anchor: middle; + font-size: ${t.pieTitleTextSize}; + fill: ${t.pieTitleTextColor}; + font-family: ${t.fontFamily}; + } + .slice { + font-family: ${t.fontFamily}; + fill: ${t.pieSectionTextColor}; + font-size:${t.pieSectionTextSize}; + // fill: white; + } + .legend text { + fill: ${t.pieLegendTextColor}; + font-family: ${t.fontFamily}; + font-size: ${t.pieLegendTextSize}; + } +`,"getStyles"),Lt=Rt,Wt=g(t=>{const n=[...t.values()].reduce((l,p)=>l+p,0),y=[...t.entries()].map(([l,p])=>({label:l,value:p})).filter(l=>l.value/n*100>=1);return wt().value(l=>l.value).sort(null)(y)},"createPieArcs"),_t=g((t,n,y,b)=>{B.debug(`rendering pie chart +`+t);const l=b.db,p=ut(),i=dt(l.getConfig(),p.pie),e=40,r=18,s=4,h=450,w=h,$=gt(n),f=$.append("g");f.attr("transform","translate("+w/2+","+h/2+")");const{themeVariables:o}=p;let[D]=pt(o.pieOuterStrokeWidth);D??=2;const z=i.legendPosition,k=i.textPosition,L=i.donutHole>0&&i.donutHole<=.9?i.donutHole:0,u=Math.min(w,h)/2-e,A=X().innerRadius(L*u).outerRadius(u),M=X().innerRadius(u*k).outerRadius(u*k),m=f.append("g");m.append("circle").attr("cx",0).attr("cy",0).attr("r",u+D/2).attr("class","pieOuterCircle");const W=l.getSections(),J=Wt(W),Q=[o.pie1,o.pie2,o.pie3,o.pie4,o.pie5,o.pie6,o.pie7,o.pie8,o.pie9,o.pie10,o.pie11,o.pie12];let G=0;W.forEach(a=>{G+=a});const U=J.filter(a=>(a.data.value/G*100).toFixed(0)!=="0"),H=xt(Q).domain([...W.keys()]);m.selectAll("mySlices").data(U).enter().append("path").attr("d",A).attr("fill",a=>H(a.data.label)).attr("class",a=>{let c="pieCircle";return i.highlightSlice==="hover"?c+=" highlightedOnHover":i.highlightSlice===a.data.label&&(c+=" highlighted"),c}),m.selectAll("mySlices").data(U).enter().append("text").text(a=>(a.data.value/G*100).toFixed(0)+"%").attr("transform",a=>"translate("+M.centroid(a)+")").style("text-anchor","middle").attr("class","slice");const Y=f.append("text").text(l.getDiagramTitle()).attr("x",0).attr("y",-400/2).attr("class","pieTitleText"),R=[...W.entries()].map(([a,c])=>({label:a,value:c})),C=f.selectAll(".legend").data(R).enter().append("g").attr("class","legend");C.append("rect").attr("width",r).attr("height",r).style("fill",a=>H(a.label)).style("stroke",a=>H(a.label)),C.append("text").attr("x",r+s).attr("y",r-s).text(a=>l.getShowData()?`${a.label} [${a.value}]`:a.label);const E=Math.max(...C.selectAll("text").nodes().map(a=>a?.getBoundingClientRect().width??0));let _=h,N=w+e;const d=r+s,O=R.length*d;switch(z){case"center":C.attr("transform",(a,c)=>{const v=d*R.length/2,x=-E/2-(r+s),S=c*d-v;return"translate("+x+","+S+")"});break;case"top":_+=O,C.attr("transform",(a,c)=>{const v=u,x=-E/2-(r+s),S=c*d-v;return`translate(${x}, ${S})`}),m.attr("transform",()=>`translate(0, ${O+d})`);break;case"bottom":_+=O,C.attr("transform",(a,c)=>{const v=-u-d,x=-E/2-(r+s),S=c*d-v;return"translate("+x+","+S+")"});break;case"left":N+=r+s+E,C.attr("transform",(a,c)=>{const v=d*R.length/2,x=-u-(r+s),S=c*d-v;return"translate("+x+","+S+")"}),m.attr("transform",()=>`translate(${E+r+s}, 0)`);break;default:N+=r+s+E,C.attr("transform",(a,c)=>{const v=d*R.length/2,x=12*r,S=c*d-v;return"translate("+x+","+S+")"});break}const j=Y.node()?.getBoundingClientRect().width??0,tt=w/2-j/2,et=w/2+j/2,q=Math.min(0,tt),K=Math.max(N,et)-q;$.attr("viewBox",`${q} 0 ${K} ${_}`),ht($,_,K,i.useMaxWidth)},"draw"),Ft={draw:_t},jt={parser:Mt,db:Z,renderer:Ft,styles:Lt};export{jt as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/plugin-logo.C-aHx2mi.js b/packages/tempo/public/v4/assets/chunks/plugin-logo.C-aHx2mi.js new file mode 100644 index 00000000..708a9ea8 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/plugin-logo.C-aHx2mi.js @@ -0,0 +1 @@ +const o="/magma/v4/plugin-logo.svg";export{o as _}; diff --git a/packages/tempo/public/v4/assets/chunks/quadrantDiagram-AXDQQJYC.Cm2_JhFa.js b/packages/tempo/public/v4/assets/chunks/quadrantDiagram-AXDQQJYC.Cm2_JhFa.js new file mode 100644 index 00000000..d55823da --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/quadrantDiagram-AXDQQJYC.Cm2_JhFa.js @@ -0,0 +1,7 @@ +import{s as Se,g as _e,q as ee,p as Ae,a as ke,b as Fe,_ as r,c as Et,l as qt,j as vt,d as Pe,r as ve,E as z,i as Ce,X as Le}from"../app.CbekdYod.js";import{l as te}from"./linear.D7HjFZ5V.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./init.Gi6I4Gst.js";import"./defaultLocale.DX6XiGOO.js";var Ct=(function(){var t=r(function(Y,s,l,u){for(l=l||{},u=Y.length;u--;l[Y[u]]=s);return l},"o"),a=[1,3],p=[1,4],f=[1,5],o=[1,6],x=[1,7],_=[1,4,5,10,12,13,14,15,18,25,35,37,39,41,42,48,50,51,52,53,54,55,56,57,60,61,63,64,65,66,67],h=[1,4,5,10,12,13,14,15,18,25,28,35,37,39,41,42,48,50,51,52,53,54,55,56,57,60,61,63,64,65,66,67],c=[55,56,57],S=[2,36],m=[1,37],b=[1,36],y=[1,38],T=[1,35],q=[1,43],g=[1,41],k=[1,45],ct=[1,14],dt=[1,23],ut=[1,18],xt=[1,19],ot=[1,20],bt=[1,21],lt=[1,22],i=[1,24],Dt=[1,25],zt=[1,26],Vt=[1,27],It=[1,28],wt=[1,29],U=[1,32],Q=[1,33],F=[1,34],P=[1,39],v=[1,40],C=[1,42],L=[1,44],X=[1,63],H=[1,62],E=[4,5,8,10,12,13,14,15,18,44,47,49,55,56,57,63,64,65,66,67],Bt=[1,66],Rt=[1,67],Nt=[1,68],Wt=[1,69],Ut=[1,70],Qt=[1,71],Ot=[1,72],Xt=[1,73],Ht=[1,74],Mt=[1,75],Yt=[1,76],jt=[1,77],w=[4,5,6,7,8,9,10,11,12,13,14,15,18],K=[1,91],Z=[1,92],J=[1,93],$=[1,100],tt=[1,94],et=[1,97],it=[1,95],at=[1,96],nt=[1,98],st=[1,99],St=[1,103],Gt=[10,55,56,57],N=[4,5,6,8,10,11,13,17,18,19,20,55,56,57],_t={trace:r(function(){},"trace"),yy:{},symbols_:{error:2,idStringToken:3,ALPHA:4,NUM:5,NODE_STRING:6,DOWN:7,MINUS:8,DEFAULT:9,COMMA:10,COLON:11,AMP:12,BRKT:13,MULT:14,UNICODE_TEXT:15,styleComponent:16,UNIT:17,SPACE:18,STYLE:19,PCT:20,idString:21,style:22,stylesOpt:23,classDefStatement:24,CLASSDEF:25,start:26,eol:27,QUADRANT:28,document:29,line:30,statement:31,axisDetails:32,quadrantDetails:33,points:34,title:35,title_value:36,acc_title:37,acc_title_value:38,acc_descr:39,acc_descr_value:40,acc_descr_multiline_value:41,section:42,text:43,point_start:44,point_x:45,point_y:46,class_name:47,"X-AXIS":48,"AXIS-TEXT-DELIMITER":49,"Y-AXIS":50,QUADRANT_1:51,QUADRANT_2:52,QUADRANT_3:53,QUADRANT_4:54,NEWLINE:55,SEMI:56,EOF:57,alphaNumToken:58,textNoTagsToken:59,STR:60,MD_STR:61,alphaNum:62,PUNCTUATION:63,PLUS:64,EQUALS:65,DOT:66,UNDERSCORE:67,$accept:0,$end:1},terminals_:{2:"error",4:"ALPHA",5:"NUM",6:"NODE_STRING",7:"DOWN",8:"MINUS",9:"DEFAULT",10:"COMMA",11:"COLON",12:"AMP",13:"BRKT",14:"MULT",15:"UNICODE_TEXT",17:"UNIT",18:"SPACE",19:"STYLE",20:"PCT",25:"CLASSDEF",28:"QUADRANT",35:"title",36:"title_value",37:"acc_title",38:"acc_title_value",39:"acc_descr",40:"acc_descr_value",41:"acc_descr_multiline_value",42:"section",44:"point_start",45:"point_x",46:"point_y",47:"class_name",48:"X-AXIS",49:"AXIS-TEXT-DELIMITER",50:"Y-AXIS",51:"QUADRANT_1",52:"QUADRANT_2",53:"QUADRANT_3",54:"QUADRANT_4",55:"NEWLINE",56:"SEMI",57:"EOF",60:"STR",61:"MD_STR",63:"PUNCTUATION",64:"PLUS",65:"EQUALS",66:"DOT",67:"UNDERSCORE"},productions_:[0,[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[3,1],[16,1],[16,1],[16,1],[16,1],[16,1],[16,1],[16,1],[16,1],[16,1],[16,1],[21,1],[21,2],[22,1],[22,2],[23,1],[23,3],[24,5],[26,2],[26,2],[26,2],[29,0],[29,2],[30,2],[31,0],[31,1],[31,2],[31,1],[31,1],[31,1],[31,2],[31,2],[31,2],[31,1],[31,1],[34,4],[34,5],[34,5],[34,6],[32,4],[32,3],[32,2],[32,4],[32,3],[32,2],[33,2],[33,2],[33,2],[33,2],[27,1],[27,1],[27,1],[43,1],[43,2],[43,1],[43,1],[62,1],[62,2],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[59,1],[59,1],[59,1]],performAction:r(function(s,l,u,d,A,e,ht){var n=e.length-1;switch(A){case 23:this.$=e[n];break;case 24:this.$=e[n-1]+""+e[n];break;case 26:this.$=e[n-1]+e[n];break;case 27:this.$=[e[n].trim()];break;case 28:e[n-2].push(e[n].trim()),this.$=e[n-2];break;case 29:this.$=e[n-4],d.addClass(e[n-2],e[n]);break;case 37:this.$=[];break;case 42:this.$=e[n].trim(),d.setDiagramTitle(this.$);break;case 43:this.$=e[n].trim(),d.setAccTitle(this.$);break;case 44:case 45:this.$=e[n].trim(),d.setAccDescription(this.$);break;case 46:d.addSection(e[n].substr(8)),this.$=e[n].substr(8);break;case 47:d.addPoint(e[n-3],"",e[n-1],e[n],[]);break;case 48:d.addPoint(e[n-4],e[n-3],e[n-1],e[n],[]);break;case 49:d.addPoint(e[n-4],"",e[n-2],e[n-1],e[n]);break;case 50:d.addPoint(e[n-5],e[n-4],e[n-2],e[n-1],e[n]);break;case 51:d.setXAxisLeftText(e[n-2]),d.setXAxisRightText(e[n]);break;case 52:e[n-1].text+=" ⟶ ",d.setXAxisLeftText(e[n-1]);break;case 53:d.setXAxisLeftText(e[n]);break;case 54:d.setYAxisBottomText(e[n-2]),d.setYAxisTopText(e[n]);break;case 55:e[n-1].text+=" ⟶ ",d.setYAxisBottomText(e[n-1]);break;case 56:d.setYAxisBottomText(e[n]);break;case 57:d.setQuadrant1Text(e[n]);break;case 58:d.setQuadrant2Text(e[n]);break;case 59:d.setQuadrant3Text(e[n]);break;case 60:d.setQuadrant4Text(e[n]);break;case 64:this.$={text:e[n],type:"text"};break;case 65:this.$={text:e[n-1].text+""+e[n],type:e[n-1].type};break;case 66:this.$={text:e[n],type:"text"};break;case 67:this.$={text:e[n],type:"markdown"};break;case 68:this.$=e[n];break;case 69:this.$=e[n-1]+""+e[n];break}},"anonymous"),table:[{18:a,26:1,27:2,28:p,55:f,56:o,57:x},{1:[3]},{18:a,26:8,27:2,28:p,55:f,56:o,57:x},{18:a,26:9,27:2,28:p,55:f,56:o,57:x},t(_,[2,33],{29:10}),t(h,[2,61]),t(h,[2,62]),t(h,[2,63]),{1:[2,30]},{1:[2,31]},t(c,S,{30:11,31:12,24:13,32:15,33:16,34:17,43:30,58:31,1:[2,32],4:m,5:b,10:y,12:T,13:q,14:g,15:k,18:ct,25:dt,35:ut,37:xt,39:ot,41:bt,42:lt,48:i,50:Dt,51:zt,52:Vt,53:It,54:wt,60:U,61:Q,63:F,64:P,65:v,66:C,67:L}),t(_,[2,34]),{27:46,55:f,56:o,57:x},t(c,[2,37]),t(c,S,{24:13,32:15,33:16,34:17,43:30,58:31,31:47,4:m,5:b,10:y,12:T,13:q,14:g,15:k,18:ct,25:dt,35:ut,37:xt,39:ot,41:bt,42:lt,48:i,50:Dt,51:zt,52:Vt,53:It,54:wt,60:U,61:Q,63:F,64:P,65:v,66:C,67:L}),t(c,[2,39]),t(c,[2,40]),t(c,[2,41]),{36:[1,48]},{38:[1,49]},{40:[1,50]},t(c,[2,45]),t(c,[2,46]),{18:[1,51]},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:52,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:53,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:54,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:55,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:56,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,10:y,12:T,13:q,14:g,15:k,43:57,58:31,60:U,61:Q,63:F,64:P,65:v,66:C,67:L},{4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,44:[1,58],47:[1,59],58:61,59:60,63:F,64:P,65:v,66:C,67:L},t(E,[2,64]),t(E,[2,66]),t(E,[2,67]),t(E,[2,70]),t(E,[2,71]),t(E,[2,72]),t(E,[2,73]),t(E,[2,74]),t(E,[2,75]),t(E,[2,76]),t(E,[2,77]),t(E,[2,78]),t(E,[2,79]),t(E,[2,80]),t(E,[2,81]),t(_,[2,35]),t(c,[2,38]),t(c,[2,42]),t(c,[2,43]),t(c,[2,44]),{3:65,4:Bt,5:Rt,6:Nt,7:Wt,8:Ut,9:Qt,10:Ot,11:Xt,12:Ht,13:Mt,14:Yt,15:jt,21:64},t(c,[2,53],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,49:[1,78],63:F,64:P,65:v,66:C,67:L}),t(c,[2,56],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,49:[1,79],63:F,64:P,65:v,66:C,67:L}),t(c,[2,57],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),t(c,[2,58],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),t(c,[2,59],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),t(c,[2,60],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),{45:[1,80]},{44:[1,81]},t(E,[2,65]),t(E,[2,82]),t(E,[2,83]),t(E,[2,84]),{3:83,4:Bt,5:Rt,6:Nt,7:Wt,8:Ut,9:Qt,10:Ot,11:Xt,12:Ht,13:Mt,14:Yt,15:jt,18:[1,82]},t(w,[2,23]),t(w,[2,1]),t(w,[2,2]),t(w,[2,3]),t(w,[2,4]),t(w,[2,5]),t(w,[2,6]),t(w,[2,7]),t(w,[2,8]),t(w,[2,9]),t(w,[2,10]),t(w,[2,11]),t(w,[2,12]),t(c,[2,52],{58:31,43:84,4:m,5:b,10:y,12:T,13:q,14:g,15:k,60:U,61:Q,63:F,64:P,65:v,66:C,67:L}),t(c,[2,55],{58:31,43:85,4:m,5:b,10:y,12:T,13:q,14:g,15:k,60:U,61:Q,63:F,64:P,65:v,66:C,67:L}),{46:[1,86]},{45:[1,87]},{4:K,5:Z,6:J,8:$,11:tt,13:et,16:90,17:it,18:at,19:nt,20:st,22:89,23:88},t(w,[2,24]),t(c,[2,51],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),t(c,[2,54],{59:60,58:61,4:m,5:b,8:X,10:y,12:T,13:q,14:g,15:k,18:H,63:F,64:P,65:v,66:C,67:L}),t(c,[2,47],{22:89,16:90,23:101,4:K,5:Z,6:J,8:$,11:tt,13:et,17:it,18:at,19:nt,20:st}),{46:[1,102]},t(c,[2,29],{10:St}),t(Gt,[2,27],{16:104,4:K,5:Z,6:J,8:$,11:tt,13:et,17:it,18:at,19:nt,20:st}),t(N,[2,25]),t(N,[2,13]),t(N,[2,14]),t(N,[2,15]),t(N,[2,16]),t(N,[2,17]),t(N,[2,18]),t(N,[2,19]),t(N,[2,20]),t(N,[2,21]),t(N,[2,22]),t(c,[2,49],{10:St}),t(c,[2,48],{22:89,16:90,23:105,4:K,5:Z,6:J,8:$,11:tt,13:et,17:it,18:at,19:nt,20:st}),{4:K,5:Z,6:J,8:$,11:tt,13:et,16:90,17:it,18:at,19:nt,20:st,22:106},t(N,[2,26]),t(c,[2,50],{10:St}),t(Gt,[2,28],{16:104,4:K,5:Z,6:J,8:$,11:tt,13:et,17:it,18:at,19:nt,20:st})],defaultActions:{8:[2,30],9:[2,31]},parseError:r(function(s,l){if(l.recoverable)this.trace(s);else{var u=new Error(s);throw u.hash=l,u}},"parseError"),parse:r(function(s){var l=this,u=[0],d=[],A=[null],e=[],ht=this.table,n="",gt=0,Kt=0,Te=2,Zt=1,qe=e.slice.call(arguments,1),D=Object.create(this.lexer),j={yy:{}};for(var At in this.yy)Object.prototype.hasOwnProperty.call(this.yy,At)&&(j.yy[At]=this.yy[At]);D.setInput(s,j.yy),j.yy.lexer=D,j.yy.parser=this,typeof D.yylloc>"u"&&(D.yylloc={});var kt=D.yylloc;e.push(kt);var me=D.options&&D.options.ranges;typeof j.yy.parseError=="function"?this.parseError=j.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function be(R){u.length=u.length-2*R,A.length=A.length-R,e.length=e.length-R}r(be,"popStack");function Jt(){var R;return R=d.pop()||D.lex()||Zt,typeof R!="number"&&(R instanceof Array&&(d=R,R=d.pop()),R=l.symbols_[R]||R),R}r(Jt,"lex");for(var B,G,W,Ft,rt={},pt,M,$t,yt;;){if(G=u[u.length-1],this.defaultActions[G]?W=this.defaultActions[G]:((B===null||typeof B>"u")&&(B=Jt()),W=ht[G]&&ht[G][B]),typeof W>"u"||!W.length||!W[0]){var Pt="";yt=[];for(pt in ht[G])this.terminals_[pt]&&pt>Te&&yt.push("'"+this.terminals_[pt]+"'");D.showPosition?Pt="Parse error on line "+(gt+1)+`: +`+D.showPosition()+` +Expecting `+yt.join(", ")+", got '"+(this.terminals_[B]||B)+"'":Pt="Parse error on line "+(gt+1)+": Unexpected "+(B==Zt?"end of input":"'"+(this.terminals_[B]||B)+"'"),this.parseError(Pt,{text:D.match,token:this.terminals_[B]||B,line:D.yylineno,loc:kt,expected:yt})}if(W[0]instanceof Array&&W.length>1)throw new Error("Parse Error: multiple actions possible at state: "+G+", token: "+B);switch(W[0]){case 1:u.push(B),A.push(D.yytext),e.push(D.yylloc),u.push(W[1]),B=null,Kt=D.yyleng,n=D.yytext,gt=D.yylineno,kt=D.yylloc;break;case 2:if(M=this.productions_[W[1]][1],rt.$=A[A.length-M],rt._$={first_line:e[e.length-(M||1)].first_line,last_line:e[e.length-1].last_line,first_column:e[e.length-(M||1)].first_column,last_column:e[e.length-1].last_column},me&&(rt._$.range=[e[e.length-(M||1)].range[0],e[e.length-1].range[1]]),Ft=this.performAction.apply(rt,[n,Kt,gt,j.yy,W[1],A,e].concat(qe)),typeof Ft<"u")return Ft;M&&(u=u.slice(0,-1*M*2),A=A.slice(0,-1*M),e=e.slice(0,-1*M)),u.push(this.productions_[W[1]][0]),A.push(rt.$),e.push(rt._$),$t=ht[u[u.length-2]][u[u.length-1]],u.push($t);break;case 3:return!0}}return!0},"parse")},ye=(function(){var Y={EOF:1,parseError:r(function(l,u){if(this.yy.parser)this.yy.parser.parseError(l,u);else throw new Error(l)},"parseError"),setInput:r(function(s,l){return this.yy=l||this.yy||{},this._input=s,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:r(function(){var s=this._input[0];this.yytext+=s,this.yyleng++,this.offset++,this.match+=s,this.matched+=s;var l=s.match(/(?:\r\n?|\n).*/g);return l?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),s},"input"),unput:r(function(s){var l=s.length,u=s.split(/(?:\r\n?|\n)/g);this._input=s+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-l),this.offset-=l;var d=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),u.length-1&&(this.yylineno-=u.length-1);var A=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:u?(u.length===d.length?this.yylloc.first_column:0)+d[d.length-u.length].length-u[0].length:this.yylloc.first_column-l},this.options.ranges&&(this.yylloc.range=[A[0],A[0]+this.yyleng-l]),this.yyleng=this.yytext.length,this},"unput"),more:r(function(){return this._more=!0,this},"more"),reject:r(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:r(function(s){this.unput(this.match.slice(s))},"less"),pastInput:r(function(){var s=this.matched.substr(0,this.matched.length-this.match.length);return(s.length>20?"...":"")+s.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:r(function(){var s=this.match;return s.length<20&&(s+=this._input.substr(0,20-s.length)),(s.substr(0,20)+(s.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:r(function(){var s=this.pastInput(),l=new Array(s.length+1).join("-");return s+this.upcomingInput()+` +`+l+"^"},"showPosition"),test_match:r(function(s,l){var u,d,A;if(this.options.backtrack_lexer&&(A={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(A.yylloc.range=this.yylloc.range.slice(0))),d=s[0].match(/(?:\r\n?|\n).*/g),d&&(this.yylineno+=d.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:d?d[d.length-1].length-d[d.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+s[0].length},this.yytext+=s[0],this.match+=s[0],this.matches=s,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(s[0].length),this.matched+=s[0],u=this.performAction.call(this,this.yy,this,l,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),u)return u;if(this._backtrack){for(var e in A)this[e]=A[e];return!1}return!1},"test_match"),next:r(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var s,l,u,d;this._more||(this.yytext="",this.match="");for(var A=this._currentRules(),e=0;el[0].length)){if(l=u,d=e,this.options.backtrack_lexer){if(s=this.test_match(u,A[e]),s!==!1)return s;if(this._backtrack){l=!1;continue}else return!1}else if(!this.options.flex)break}return l?(s=this.test_match(l,A[d]),s!==!1?s:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:r(function(){var l=this.next();return l||this.lex()},"lex"),begin:r(function(l){this.conditionStack.push(l)},"begin"),popState:r(function(){var l=this.conditionStack.length-1;return l>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:r(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:r(function(l){return l=this.conditionStack.length-1-Math.abs(l||0),l>=0?this.conditionStack[l]:"INITIAL"},"topState"),pushState:r(function(l){this.begin(l)},"pushState"),stateStackSize:r(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:r(function(l,u,d,A){switch(d){case 0:break;case 1:break;case 2:return 55;case 3:break;case 4:return this.begin("title"),35;case 5:return this.popState(),"title_value";case 6:return this.begin("acc_title"),37;case 7:return this.popState(),"acc_title_value";case 8:return this.begin("acc_descr"),39;case 9:return this.popState(),"acc_descr_value";case 10:this.begin("acc_descr_multiline");break;case 11:this.popState();break;case 12:return"acc_descr_multiline_value";case 13:return 48;case 14:return 50;case 15:return 49;case 16:return 51;case 17:return 52;case 18:return 53;case 19:return 54;case 20:return 25;case 21:this.begin("md_string");break;case 22:return"MD_STR";case 23:this.popState();break;case 24:this.begin("string");break;case 25:this.popState();break;case 26:return"STR";case 27:this.begin("class_name");break;case 28:return this.popState(),47;case 29:return this.begin("point_start"),44;case 30:return this.begin("point_x"),45;case 31:this.popState();break;case 32:this.popState(),this.begin("point_y");break;case 33:return this.popState(),46;case 34:return 28;case 35:return 4;case 36:return 15;case 37:return 11;case 38:return 64;case 39:return 10;case 40:return 65;case 41:return 65;case 42:return 14;case 43:return 13;case 44:return 67;case 45:return 66;case 46:return 12;case 47:return 8;case 48:return 5;case 49:return 18;case 50:return 56;case 51:return 63;case 52:return 57}},"anonymous"),rules:[/^(?:%%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:[\n\r]+)/i,/^(?:%%[^\n]*)/i,/^(?:title\b)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?: *x-axis *)/i,/^(?: *y-axis *)/i,/^(?: *--+> *)/i,/^(?: *quadrant-1 *)/i,/^(?: *quadrant-2 *)/i,/^(?: *quadrant-3 *)/i,/^(?: *quadrant-4 *)/i,/^(?:classDef\b)/i,/^(?:["][`])/i,/^(?:[^`"]+)/i,/^(?:[`]["])/i,/^(?:["])/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?::::)/i,/^(?:^\w+)/i,/^(?:\s*:\s*\[\s*)/i,/^(?:(1)|(0(.\d+)?))/i,/^(?:\s*\] *)/i,/^(?:\s*,\s*)/i,/^(?:(1)|(0(.\d+)?))/i,/^(?: *quadrantChart *)/i,/^(?:[A-Za-z]+)/i,/^(?:[^\x00-\x7F]+)/i,/^(?::)/i,/^(?:\+)/i,/^(?:,)/i,/^(?:=)/i,/^(?:=)/i,/^(?:\*)/i,/^(?:#)/i,/^(?:[\_])/i,/^(?:\.)/i,/^(?:&)/i,/^(?:-)/i,/^(?:[0-9]+)/i,/^(?:\s)/i,/^(?:;)/i,/^(?:[!"#$%&'*+,-.`?\\_/])/i,/^(?:$)/i],conditions:{class_name:{rules:[28],inclusive:!1},point_y:{rules:[33],inclusive:!1},point_x:{rules:[32],inclusive:!1},point_start:{rules:[30,31],inclusive:!1},acc_descr_multiline:{rules:[11,12],inclusive:!1},acc_descr:{rules:[9],inclusive:!1},acc_title:{rules:[7],inclusive:!1},title:{rules:[5],inclusive:!1},md_string:{rules:[22,23],inclusive:!1},string:{rules:[25,26],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,6,8,10,13,14,15,16,17,18,19,20,21,24,27,29,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52],inclusive:!0}}};return Y})();_t.lexer=ye;function ft(){this.yy={}}return r(ft,"Parser"),ft.prototype=_t,_t.Parser=ft,new ft})();Ct.parser=Ct;var Ee=Ct,I=Le(),De=class{constructor(){this.classes=new Map,this.config=this.getDefaultConfig(),this.themeConfig=this.getDefaultThemeConfig(),this.data=this.getDefaultData()}static{r(this,"QuadrantBuilder")}getDefaultData(){return{titleText:"",quadrant1Text:"",quadrant2Text:"",quadrant3Text:"",quadrant4Text:"",xAxisLeftText:"",xAxisRightText:"",yAxisBottomText:"",yAxisTopText:"",points:[]}}getDefaultConfig(){return{showXAxis:!0,showYAxis:!0,showTitle:!0,chartHeight:z.quadrantChart?.chartWidth||500,chartWidth:z.quadrantChart?.chartHeight||500,titlePadding:z.quadrantChart?.titlePadding||10,titleFontSize:z.quadrantChart?.titleFontSize||20,quadrantPadding:z.quadrantChart?.quadrantPadding||5,xAxisLabelPadding:z.quadrantChart?.xAxisLabelPadding||5,yAxisLabelPadding:z.quadrantChart?.yAxisLabelPadding||5,xAxisLabelFontSize:z.quadrantChart?.xAxisLabelFontSize||16,yAxisLabelFontSize:z.quadrantChart?.yAxisLabelFontSize||16,quadrantLabelFontSize:z.quadrantChart?.quadrantLabelFontSize||16,quadrantTextTopPadding:z.quadrantChart?.quadrantTextTopPadding||5,pointTextPadding:z.quadrantChart?.pointTextPadding||5,pointLabelFontSize:z.quadrantChart?.pointLabelFontSize||12,pointRadius:z.quadrantChart?.pointRadius||5,xAxisPosition:z.quadrantChart?.xAxisPosition||"top",yAxisPosition:z.quadrantChart?.yAxisPosition||"left",quadrantInternalBorderStrokeWidth:z.quadrantChart?.quadrantInternalBorderStrokeWidth||1,quadrantExternalBorderStrokeWidth:z.quadrantChart?.quadrantExternalBorderStrokeWidth||2}}getDefaultThemeConfig(){return{quadrant1Fill:I.quadrant1Fill,quadrant2Fill:I.quadrant2Fill,quadrant3Fill:I.quadrant3Fill,quadrant4Fill:I.quadrant4Fill,quadrant1TextFill:I.quadrant1TextFill,quadrant2TextFill:I.quadrant2TextFill,quadrant3TextFill:I.quadrant3TextFill,quadrant4TextFill:I.quadrant4TextFill,quadrantPointFill:I.quadrantPointFill,quadrantPointTextFill:I.quadrantPointTextFill,quadrantXAxisTextFill:I.quadrantXAxisTextFill,quadrantYAxisTextFill:I.quadrantYAxisTextFill,quadrantTitleFill:I.quadrantTitleFill,quadrantInternalBorderStrokeFill:I.quadrantInternalBorderStrokeFill,quadrantExternalBorderStrokeFill:I.quadrantExternalBorderStrokeFill}}clear(){this.config=this.getDefaultConfig(),this.themeConfig=this.getDefaultThemeConfig(),this.data=this.getDefaultData(),this.classes=new Map,qt.info("clear called")}setData(t){this.data={...this.data,...t}}addPoints(t){this.data.points=[...t,...this.data.points]}addClass(t,a){this.classes.set(t,a)}setConfig(t){qt.trace("setConfig called with: ",t),this.config={...this.config,...t}}setThemeConfig(t){qt.trace("setThemeConfig called with: ",t),this.themeConfig={...this.themeConfig,...t}}calculateSpace(t,a,p,f){const o=this.config.xAxisLabelPadding*2+this.config.xAxisLabelFontSize,x={top:t==="top"&&a?o:0,bottom:t==="bottom"&&a?o:0},_=this.config.yAxisLabelPadding*2+this.config.yAxisLabelFontSize,h={left:this.config.yAxisPosition==="left"&&p?_:0,right:this.config.yAxisPosition==="right"&&p?_:0},c=this.config.titleFontSize+this.config.titlePadding*2,S={top:f?c:0},m=this.config.quadrantPadding+h.left,b=this.config.quadrantPadding+x.top+S.top,y=this.config.chartWidth-this.config.quadrantPadding*2-h.left-h.right,T=this.config.chartHeight-this.config.quadrantPadding*2-x.top-x.bottom-S.top,q=y/2,g=T/2;return{xAxisSpace:x,yAxisSpace:h,titleSpace:S,quadrantSpace:{quadrantLeft:m,quadrantTop:b,quadrantWidth:y,quadrantHalfWidth:q,quadrantHeight:T,quadrantHalfHeight:g}}}getAxisLabels(t,a,p,f){const{quadrantSpace:o,titleSpace:x}=f,{quadrantHalfHeight:_,quadrantHeight:h,quadrantLeft:c,quadrantHalfWidth:S,quadrantTop:m,quadrantWidth:b}=o,y=!!this.data.xAxisRightText,T=!!this.data.yAxisTopText,q=[];return this.data.xAxisLeftText&&a&&q.push({text:this.data.xAxisLeftText,fill:this.themeConfig.quadrantXAxisTextFill,x:c+(y?S/2:0),y:t==="top"?this.config.xAxisLabelPadding+x.top:this.config.xAxisLabelPadding+m+h+this.config.quadrantPadding,fontSize:this.config.xAxisLabelFontSize,verticalPos:y?"center":"left",horizontalPos:"top",rotation:0}),this.data.xAxisRightText&&a&&q.push({text:this.data.xAxisRightText,fill:this.themeConfig.quadrantXAxisTextFill,x:c+S+(y?S/2:0),y:t==="top"?this.config.xAxisLabelPadding+x.top:this.config.xAxisLabelPadding+m+h+this.config.quadrantPadding,fontSize:this.config.xAxisLabelFontSize,verticalPos:y?"center":"left",horizontalPos:"top",rotation:0}),this.data.yAxisBottomText&&p&&q.push({text:this.data.yAxisBottomText,fill:this.themeConfig.quadrantYAxisTextFill,x:this.config.yAxisPosition==="left"?this.config.yAxisLabelPadding:this.config.yAxisLabelPadding+c+b+this.config.quadrantPadding,y:m+h-(T?_/2:0),fontSize:this.config.yAxisLabelFontSize,verticalPos:T?"center":"left",horizontalPos:"top",rotation:-90}),this.data.yAxisTopText&&p&&q.push({text:this.data.yAxisTopText,fill:this.themeConfig.quadrantYAxisTextFill,x:this.config.yAxisPosition==="left"?this.config.yAxisLabelPadding:this.config.yAxisLabelPadding+c+b+this.config.quadrantPadding,y:m+_-(T?_/2:0),fontSize:this.config.yAxisLabelFontSize,verticalPos:T?"center":"left",horizontalPos:"top",rotation:-90}),q}getQuadrants(t){const{quadrantSpace:a}=t,{quadrantHalfHeight:p,quadrantLeft:f,quadrantHalfWidth:o,quadrantTop:x}=a,_=[{text:{text:this.data.quadrant1Text,fill:this.themeConfig.quadrant1TextFill,x:0,y:0,fontSize:this.config.quadrantLabelFontSize,verticalPos:"center",horizontalPos:"middle",rotation:0},x:f+o,y:x,width:o,height:p,fill:this.themeConfig.quadrant1Fill},{text:{text:this.data.quadrant2Text,fill:this.themeConfig.quadrant2TextFill,x:0,y:0,fontSize:this.config.quadrantLabelFontSize,verticalPos:"center",horizontalPos:"middle",rotation:0},x:f,y:x,width:o,height:p,fill:this.themeConfig.quadrant2Fill},{text:{text:this.data.quadrant3Text,fill:this.themeConfig.quadrant3TextFill,x:0,y:0,fontSize:this.config.quadrantLabelFontSize,verticalPos:"center",horizontalPos:"middle",rotation:0},x:f,y:x+p,width:o,height:p,fill:this.themeConfig.quadrant3Fill},{text:{text:this.data.quadrant4Text,fill:this.themeConfig.quadrant4TextFill,x:0,y:0,fontSize:this.config.quadrantLabelFontSize,verticalPos:"center",horizontalPos:"middle",rotation:0},x:f+o,y:x+p,width:o,height:p,fill:this.themeConfig.quadrant4Fill}];for(const h of _)h.text.x=h.x+h.width/2,this.data.points.length===0?(h.text.y=h.y+h.height/2,h.text.horizontalPos="middle"):(h.text.y=h.y+this.config.quadrantTextTopPadding,h.text.horizontalPos="top");return _}getQuadrantPoints(t){const{quadrantSpace:a}=t,{quadrantHeight:p,quadrantLeft:f,quadrantTop:o,quadrantWidth:x}=a,_=te().domain([0,1]).range([f,x+f]),h=te().domain([0,1]).range([p+o,o]);return this.data.points.map(S=>{const m=this.classes.get(S.className);return m&&(S={...m,...S}),{x:_(S.x),y:h(S.y),fill:S.color??this.themeConfig.quadrantPointFill,radius:S.radius??this.config.pointRadius,text:{text:S.text,fill:this.themeConfig.quadrantPointTextFill,x:_(S.x),y:h(S.y)+this.config.pointTextPadding,verticalPos:"center",horizontalPos:"top",fontSize:this.config.pointLabelFontSize,rotation:0},strokeColor:S.strokeColor??this.themeConfig.quadrantPointFill,strokeWidth:S.strokeWidth??"0px"}})}getBorders(t){const a=this.config.quadrantExternalBorderStrokeWidth/2,{quadrantSpace:p}=t,{quadrantHalfHeight:f,quadrantHeight:o,quadrantLeft:x,quadrantHalfWidth:_,quadrantTop:h,quadrantWidth:c}=p;return[{strokeFill:this.themeConfig.quadrantExternalBorderStrokeFill,strokeWidth:this.config.quadrantExternalBorderStrokeWidth,x1:x-a,y1:h,x2:x+c+a,y2:h},{strokeFill:this.themeConfig.quadrantExternalBorderStrokeFill,strokeWidth:this.config.quadrantExternalBorderStrokeWidth,x1:x+c,y1:h+a,x2:x+c,y2:h+o-a},{strokeFill:this.themeConfig.quadrantExternalBorderStrokeFill,strokeWidth:this.config.quadrantExternalBorderStrokeWidth,x1:x-a,y1:h+o,x2:x+c+a,y2:h+o},{strokeFill:this.themeConfig.quadrantExternalBorderStrokeFill,strokeWidth:this.config.quadrantExternalBorderStrokeWidth,x1:x,y1:h+a,x2:x,y2:h+o-a},{strokeFill:this.themeConfig.quadrantInternalBorderStrokeFill,strokeWidth:this.config.quadrantInternalBorderStrokeWidth,x1:x+_,y1:h+a,x2:x+_,y2:h+o-a},{strokeFill:this.themeConfig.quadrantInternalBorderStrokeFill,strokeWidth:this.config.quadrantInternalBorderStrokeWidth,x1:x+a,y1:h+f,x2:x+c-a,y2:h+f}]}getTitle(t){if(t)return{text:this.data.titleText,fill:this.themeConfig.quadrantTitleFill,fontSize:this.config.titleFontSize,horizontalPos:"top",verticalPos:"center",rotation:0,y:this.config.titlePadding,x:this.config.chartWidth/2}}build(){const t=this.config.showXAxis&&!!(this.data.xAxisLeftText||this.data.xAxisRightText),a=this.config.showYAxis&&!!(this.data.yAxisTopText||this.data.yAxisBottomText),p=this.config.showTitle&&!!this.data.titleText,f=this.data.points.length>0?"bottom":this.config.xAxisPosition,o=this.calculateSpace(f,t,a,p);return{points:this.getQuadrantPoints(o),quadrants:this.getQuadrants(o),axisLabels:this.getAxisLabels(f,t,a,o),borderLines:this.getBorders(o),title:this.getTitle(p)}}},Tt=class extends Error{static{r(this,"InvalidStyleError")}constructor(t,a,p){super(`value for ${t} ${a} is invalid, please use a valid ${p}`),this.name="InvalidStyleError"}};function Lt(t){return!/^#?([\dA-Fa-f]{6}|[\dA-Fa-f]{3})$/.test(t)}r(Lt,"validateHexCode");function ie(t){return!/^\d+$/.test(t)}r(ie,"validateNumber");function ae(t){return!/^\d+px$/.test(t)}r(ae,"validateSizeInPixels");function O(t){return Ce(t.trim(),Et())}r(O,"textSanitizer");var V=new De;function ne(t){V.setData({quadrant1Text:O(t.text)})}r(ne,"setQuadrant1Text");function se(t){V.setData({quadrant2Text:O(t.text)})}r(se,"setQuadrant2Text");function re(t){V.setData({quadrant3Text:O(t.text)})}r(re,"setQuadrant3Text");function oe(t){V.setData({quadrant4Text:O(t.text)})}r(oe,"setQuadrant4Text");function le(t){V.setData({xAxisLeftText:O(t.text)})}r(le,"setXAxisLeftText");function he(t){V.setData({xAxisRightText:O(t.text)})}r(he,"setXAxisRightText");function ce(t){V.setData({yAxisTopText:O(t.text)})}r(ce,"setYAxisTopText");function de(t){V.setData({yAxisBottomText:O(t.text)})}r(de,"setYAxisBottomText");function mt(t){const a={};for(const p of t){const[f,o]=p.trim().split(/\s*:\s*/);if(f==="radius"){if(ie(o))throw new Tt(f,o,"number");a.radius=parseInt(o)}else if(f==="color"){if(Lt(o))throw new Tt(f,o,"hex code");a.color=o}else if(f==="stroke-color"){if(Lt(o))throw new Tt(f,o,"hex code");a.strokeColor=o}else if(f==="stroke-width"){if(ae(o))throw new Tt(f,o,"number of pixels (eg. 10px)");a.strokeWidth=o}else throw new Error(`style named ${f} is not supported.`)}return a}r(mt,"parseStyles");function ue(t,a,p,f,o){const x=mt(o);V.addPoints([{x:p,y:f,text:O(t.text),className:a,...x}])}r(ue,"addPoint");function xe(t,a){V.addClass(t,mt(a))}r(xe,"addClass");function fe(t){V.setConfig({chartWidth:t})}r(fe,"setWidth");function ge(t){V.setConfig({chartHeight:t})}r(ge,"setHeight");function pe(){const t=Et(),{themeVariables:a,quadrantChart:p}=t;return p&&V.setConfig(p),V.setThemeConfig({quadrant1Fill:a.quadrant1Fill,quadrant2Fill:a.quadrant2Fill,quadrant3Fill:a.quadrant3Fill,quadrant4Fill:a.quadrant4Fill,quadrant1TextFill:a.quadrant1TextFill,quadrant2TextFill:a.quadrant2TextFill,quadrant3TextFill:a.quadrant3TextFill,quadrant4TextFill:a.quadrant4TextFill,quadrantPointFill:a.quadrantPointFill,quadrantPointTextFill:a.quadrantPointTextFill,quadrantXAxisTextFill:a.quadrantXAxisTextFill,quadrantYAxisTextFill:a.quadrantYAxisTextFill,quadrantExternalBorderStrokeFill:a.quadrantExternalBorderStrokeFill,quadrantInternalBorderStrokeFill:a.quadrantInternalBorderStrokeFill,quadrantTitleFill:a.quadrantTitleFill}),V.setData({titleText:ee()}),V.build()}r(pe,"getQuadrantData");var ze=r(function(){V.clear(),ve()},"clear"),Ve={setWidth:fe,setHeight:ge,setQuadrant1Text:ne,setQuadrant2Text:se,setQuadrant3Text:re,setQuadrant4Text:oe,setXAxisLeftText:le,setXAxisRightText:he,setYAxisTopText:ce,setYAxisBottomText:de,parseStyles:mt,addPoint:ue,addClass:xe,getQuadrantData:pe,clear:ze,setAccTitle:Fe,getAccTitle:ke,setDiagramTitle:Ae,getDiagramTitle:ee,getAccDescription:_e,setAccDescription:Se},Ie=r((t,a,p,f)=>{function o(i){return i==="top"?"hanging":"middle"}r(o,"getDominantBaseLine");function x(i){return i==="left"?"start":"middle"}r(x,"getTextAnchor");function _(i){return`translate(${i.x}, ${i.y}) rotate(${i.rotation||0})`}r(_,"getTransformation");const h=Et();qt.debug(`Rendering quadrant chart +`+t);const c=h.securityLevel;let S;c==="sandbox"&&(S=vt("#i"+a));const b=(c==="sandbox"?vt(S.nodes()[0].contentDocument.body):vt("body")).select(`[id="${a}"]`),y=b.append("g").attr("class","main"),T=h.quadrantChart?.chartWidth??500,q=h.quadrantChart?.chartHeight??500;Pe(b,q,T,h.quadrantChart?.useMaxWidth??!0),b.attr("viewBox","0 0 "+T+" "+q),f.db.setHeight(q),f.db.setWidth(T);const g=f.db.getQuadrantData(),k=y.append("g").attr("class","quadrants"),ct=y.append("g").attr("class","border"),dt=y.append("g").attr("class","data-points"),ut=y.append("g").attr("class","labels"),xt=y.append("g").attr("class","title");g.title&&xt.append("text").attr("x",0).attr("y",0).attr("fill",g.title.fill).attr("font-size",g.title.fontSize).attr("dominant-baseline",o(g.title.horizontalPos)).attr("text-anchor",x(g.title.verticalPos)).attr("transform",_(g.title)).text(g.title.text),g.borderLines&&ct.selectAll("line").data(g.borderLines).enter().append("line").attr("x1",i=>i.x1).attr("y1",i=>i.y1).attr("x2",i=>i.x2).attr("y2",i=>i.y2).style("stroke",i=>i.strokeFill).style("stroke-width",i=>i.strokeWidth);const ot=k.selectAll("g.quadrant").data(g.quadrants).enter().append("g").attr("class","quadrant");ot.append("rect").attr("x",i=>i.x).attr("y",i=>i.y).attr("width",i=>i.width).attr("height",i=>i.height).attr("fill",i=>i.fill),ot.append("text").attr("x",0).attr("y",0).attr("fill",i=>i.text.fill).attr("font-size",i=>i.text.fontSize).attr("dominant-baseline",i=>o(i.text.horizontalPos)).attr("text-anchor",i=>x(i.text.verticalPos)).attr("transform",i=>_(i.text)).text(i=>i.text.text),ut.selectAll("g.label").data(g.axisLabels).enter().append("g").attr("class","label").append("text").attr("x",0).attr("y",0).text(i=>i.text).attr("fill",i=>i.fill).attr("font-size",i=>i.fontSize).attr("dominant-baseline",i=>o(i.horizontalPos)).attr("text-anchor",i=>x(i.verticalPos)).attr("transform",i=>_(i));const lt=dt.selectAll("g.data-point").data(g.points).enter().append("g").attr("class","data-point");lt.append("circle").attr("cx",i=>i.x).attr("cy",i=>i.y).attr("r",i=>i.radius).attr("fill",i=>i.fill).attr("stroke",i=>i.strokeColor).attr("stroke-width",i=>i.strokeWidth),lt.append("text").attr("x",0).attr("y",0).text(i=>i.text.text).attr("fill",i=>i.text.fill).attr("font-size",i=>i.text.fontSize).attr("dominant-baseline",i=>o(i.text.horizontalPos)).attr("text-anchor",i=>x(i.text.verticalPos)).attr("transform",i=>_(i.text))},"draw"),we={draw:Ie},Oe={parser:Ee,db:Ve,renderer:we,styles:r(()=>"","styles")};export{Oe as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/railroadDiagram-O6MQD6OU.CLUHLRPG.js b/packages/tempo/public/v4/assets/chunks/railroadDiagram-O6MQD6OU.CLUHLRPG.js new file mode 100644 index 00000000..d8642408 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/railroadDiagram-O6MQD6OU.CLUHLRPG.js @@ -0,0 +1 @@ +import{g as s,r as l,d as t}from"./chunk-SVP7TREG.tNKCi1Yy.js";import{p as m}from"./chunk-JWPE2WC7.5yopTNlD.js";import{_ as n,l as i}from"../app.CbekdYod.js";import{M as p,c as u}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var d=u().Railroad.parser.LangiumParser,a=n(e=>{switch(e.$type){case"RailroadTerminalExpr":return{type:"terminal",value:e.value};case"RailroadNonTerminalExpr":return{type:"nonterminal",name:e.name};case"RailroadSpecialExpr":return{type:"special",text:e.text};case"RailroadSequenceExpr":{const r=e.elements.map(a);return r.length===1?r[0]:{type:"sequence",elements:r}}case"RailroadChoiceExpr":{const r=e.alternatives.map(a);return r.length===1?r[0]:{type:"choice",alternatives:r}}case"RailroadOptionalExpr":return{type:"optional",element:a(e.element)};case"RailroadOneOrMoreExpr":return{type:"repetition",element:a(e.element),min:1,max:1/0};case"RailroadZeroOrMoreExpr":return{type:"repetition",element:a(e.element),min:0,max:1/0};default:throw new Error(`Unsupported railroad expression: ${e.$type}`)}},"transformExpression"),c=n(e=>({name:e.name,definition:a(e.definition)}),"transformRule"),g=n(e=>{m(e,t),e.title&&t.setTitle(e.title),e.rules.map(r=>t.addRule(c(r)))},"populateDb"),y={parse:n(e=>{t.clear(),i.debug("[Railroad Parser] Starting Langium parse");const r=d.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new p(r);const o=r.value;i.debug("[Railroad Parser] Parsed rules:",o.rules.length),g(o),i.debug("[Railroad Parser] Parse complete")},"parse"),parser:{yy:t}},P={parser:y,db:t,renderer:l,styles:s};export{P as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/requirementDiagram-BXWQKSXE.BhCYrhyS.js b/packages/tempo/public/v4/assets/chunks/requirementDiagram-BXWQKSXE.BhCYrhyS.js new file mode 100644 index 00000000..ef4b077c --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/requirementDiagram-BXWQKSXE.BhCYrhyS.js @@ -0,0 +1,84 @@ +import{g as ze}from"./chunk-XXDRQBXY.C52oJrTB.js";import{s as Ge}from"./chunk-POPQ4Y6H.DEs7vhGS.js";import{_ as u,A as Ye,b as Xe,a as Je,s as Ze,g as et,p as tt,q as st,c as Te,l as Ne,r as it,v as rt,x as nt,y as at,z as lt}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var qe=(function(){var e=u(function($,r,n,l){for(n=n||{},l=$.length;l--;n[$[l]]=r);return n},"o"),f=[1,3],h=[1,4],o=[1,5],i=[1,6],c=[5,6,8,9,11,13,21,22,23,24,41,42,43,44,45,46,54,72,74,77,89,90],_=[1,22],E=[2,7],g=[1,26],S=[1,27],k=[1,28],q=[1,29],C=[1,33],A=[1,34],V=[1,35],v=[1,36],L=[1,37],x=[1,38],O=[1,24],w=[1,31],D=[1,32],M=[1,30],p=[1,39],R=[1,40],d=[5,8,9,11,13,21,22,23,24,41,42,43,44,45,46,54,72,74,77,89,90],P=[1,61],X=[89,90],Ce=[5,8,9,11,13,21,22,23,24,27,29,41,42,43,44,45,46,54,61,63,72,74,75,76,77,80,81,82,83,84,85,86,87,88,89,90],de=[27,29],Ae=[1,70],Ve=[1,71],ve=[1,72],Le=[1,73],xe=[1,74],Oe=[1,75],we=[1,76],Z=[1,83],U=[1,80],ee=[1,84],te=[1,85],se=[1,86],ie=[1,87],re=[1,88],ne=[1,89],ae=[1,90],le=[1,91],ce=[1,92],Ee=[5,8,9,11,13,21,22,23,24,27,41,42,43,44,45,46,54,72,74,75,76,77,80,81,82,83,84,85,86,87,88,89,90],Y=[63,64],De=[1,101],Me=[5,8,9,11,13,21,22,23,24,41,42,43,44,45,46,54,72,74,76,77,89,90],T=[5,8,9,11,13,21,22,23,24,41,42,43,44,45,46,54,72,74,75,76,77,80,81,82,83,84,85,86,87,88,89,90],B=[1,110],Q=[1,106],H=[1,107],K=[1,108],W=[1,109],j=[1,111],oe=[1,116],he=[1,117],ue=[1,114],fe=[1,115],_e={trace:u(function(){},"trace"),yy:{},symbols_:{error:2,start:3,directive:4,NEWLINE:5,RD:6,diagram:7,EOF:8,acc_title:9,acc_title_value:10,acc_descr:11,acc_descr_value:12,acc_descr_multiline_value:13,requirementDef:14,elementDef:15,relationshipDef:16,direction:17,styleStatement:18,classDefStatement:19,classStatement:20,direction_tb:21,direction_bt:22,direction_rl:23,direction_lr:24,requirementType:25,requirementName:26,STRUCT_START:27,requirementBody:28,STYLE_SEPARATOR:29,idList:30,ID:31,COLONSEP:32,id:33,TEXT:34,text:35,RISK:36,riskLevel:37,VERIFYMTHD:38,verifyType:39,STRUCT_STOP:40,REQUIREMENT:41,FUNCTIONAL_REQUIREMENT:42,INTERFACE_REQUIREMENT:43,PERFORMANCE_REQUIREMENT:44,PHYSICAL_REQUIREMENT:45,DESIGN_CONSTRAINT:46,LOW_RISK:47,MED_RISK:48,HIGH_RISK:49,VERIFY_ANALYSIS:50,VERIFY_DEMONSTRATION:51,VERIFY_INSPECTION:52,VERIFY_TEST:53,ELEMENT:54,elementName:55,elementBody:56,TYPE:57,type:58,DOCREF:59,ref:60,END_ARROW_L:61,relationship:62,LINE:63,END_ARROW_R:64,CONTAINS:65,COPIES:66,DERIVES:67,SATISFIES:68,VERIFIES:69,REFINES:70,TRACES:71,CLASSDEF:72,stylesOpt:73,CLASS:74,ALPHA:75,COMMA:76,STYLE:77,style:78,styleComponent:79,NUM:80,COLON:81,UNIT:82,SPACE:83,BRKT:84,PCT:85,MINUS:86,LABEL:87,SEMICOLON:88,unqString:89,qString:90,$accept:0,$end:1},terminals_:{2:"error",5:"NEWLINE",6:"RD",8:"EOF",9:"acc_title",10:"acc_title_value",11:"acc_descr",12:"acc_descr_value",13:"acc_descr_multiline_value",21:"direction_tb",22:"direction_bt",23:"direction_rl",24:"direction_lr",27:"STRUCT_START",29:"STYLE_SEPARATOR",31:"ID",32:"COLONSEP",34:"TEXT",36:"RISK",38:"VERIFYMTHD",40:"STRUCT_STOP",41:"REQUIREMENT",42:"FUNCTIONAL_REQUIREMENT",43:"INTERFACE_REQUIREMENT",44:"PERFORMANCE_REQUIREMENT",45:"PHYSICAL_REQUIREMENT",46:"DESIGN_CONSTRAINT",47:"LOW_RISK",48:"MED_RISK",49:"HIGH_RISK",50:"VERIFY_ANALYSIS",51:"VERIFY_DEMONSTRATION",52:"VERIFY_INSPECTION",53:"VERIFY_TEST",54:"ELEMENT",57:"TYPE",59:"DOCREF",61:"END_ARROW_L",63:"LINE",64:"END_ARROW_R",65:"CONTAINS",66:"COPIES",67:"DERIVES",68:"SATISFIES",69:"VERIFIES",70:"REFINES",71:"TRACES",72:"CLASSDEF",74:"CLASS",75:"ALPHA",76:"COMMA",77:"STYLE",80:"NUM",81:"COLON",82:"UNIT",83:"SPACE",84:"BRKT",85:"PCT",86:"MINUS",87:"LABEL",88:"SEMICOLON",89:"unqString",90:"qString"},productions_:[0,[3,3],[3,2],[3,4],[4,2],[4,2],[4,1],[7,0],[7,2],[7,2],[7,2],[7,2],[7,2],[7,2],[7,2],[7,2],[7,2],[17,1],[17,1],[17,1],[17,1],[14,5],[14,7],[28,5],[28,5],[28,5],[28,5],[28,2],[28,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[37,1],[37,1],[37,1],[39,1],[39,1],[39,1],[39,1],[15,5],[15,7],[56,5],[56,5],[56,2],[56,1],[16,5],[16,5],[62,1],[62,1],[62,1],[62,1],[62,1],[62,1],[62,1],[19,3],[20,3],[20,3],[30,1],[30,3],[30,1],[30,3],[18,3],[73,1],[73,3],[78,1],[78,2],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[26,1],[26,1],[33,1],[33,1],[35,1],[35,1],[55,1],[55,1],[58,1],[58,1],[60,1],[60,1]],performAction:u(function(r,n,l,s,m,t,me){var a=t.length-1;switch(m){case 4:this.$=t[a].trim(),s.setAccTitle(this.$);break;case 5:case 6:this.$=t[a].trim(),s.setAccDescription(this.$);break;case 7:this.$=[];break;case 17:s.setDirection("TB");break;case 18:s.setDirection("BT");break;case 19:s.setDirection("RL");break;case 20:s.setDirection("LR");break;case 21:s.addRequirement(t[a-3],t[a-4]);break;case 22:s.addRequirement(t[a-5],t[a-6]),s.setClass([t[a-5]],t[a-3]);break;case 23:s.setNewReqId(t[a-2]);break;case 24:s.setNewReqText(t[a-2]);break;case 25:s.setNewReqRisk(t[a-2]);break;case 26:s.setNewReqVerifyMethod(t[a-2]);break;case 29:this.$=s.RequirementType.REQUIREMENT;break;case 30:this.$=s.RequirementType.FUNCTIONAL_REQUIREMENT;break;case 31:this.$=s.RequirementType.INTERFACE_REQUIREMENT;break;case 32:this.$=s.RequirementType.PERFORMANCE_REQUIREMENT;break;case 33:this.$=s.RequirementType.PHYSICAL_REQUIREMENT;break;case 34:this.$=s.RequirementType.DESIGN_CONSTRAINT;break;case 35:this.$=s.RiskLevel.LOW_RISK;break;case 36:this.$=s.RiskLevel.MED_RISK;break;case 37:this.$=s.RiskLevel.HIGH_RISK;break;case 38:this.$=s.VerifyType.VERIFY_ANALYSIS;break;case 39:this.$=s.VerifyType.VERIFY_DEMONSTRATION;break;case 40:this.$=s.VerifyType.VERIFY_INSPECTION;break;case 41:this.$=s.VerifyType.VERIFY_TEST;break;case 42:s.addElement(t[a-3]);break;case 43:s.addElement(t[a-5]),s.setClass([t[a-5]],t[a-3]);break;case 44:s.setNewElementType(t[a-2]);break;case 45:s.setNewElementDocRef(t[a-2]);break;case 48:s.addRelationship(t[a-2],t[a],t[a-4]);break;case 49:s.addRelationship(t[a-2],t[a-4],t[a]);break;case 50:this.$=s.Relationships.CONTAINS;break;case 51:this.$=s.Relationships.COPIES;break;case 52:this.$=s.Relationships.DERIVES;break;case 53:this.$=s.Relationships.SATISFIES;break;case 54:this.$=s.Relationships.VERIFIES;break;case 55:this.$=s.Relationships.REFINES;break;case 56:this.$=s.Relationships.TRACES;break;case 57:this.$=t[a-2],s.defineClass(t[a-1],t[a]);break;case 58:s.setClass(t[a-1],t[a]);break;case 59:s.setClass([t[a-2]],t[a]);break;case 60:case 62:this.$=[t[a]];break;case 61:case 63:this.$=t[a-2].concat([t[a]]);break;case 64:this.$=t[a-2],s.setCssStyle(t[a-1],t[a]);break;case 65:this.$=[t[a]];break;case 66:t[a-2].push(t[a]),this.$=t[a-2];break;case 68:this.$=t[a-1]+t[a];break}},"anonymous"),table:[{3:1,4:2,6:f,9:h,11:o,13:i},{1:[3]},{3:8,4:2,5:[1,7],6:f,9:h,11:o,13:i},{5:[1,9]},{10:[1,10]},{12:[1,11]},e(c,[2,6]),{3:12,4:2,6:f,9:h,11:o,13:i},{1:[2,2]},{4:17,5:_,7:13,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},e(c,[2,4]),e(c,[2,5]),{1:[2,1]},{8:[1,41]},{4:17,5:_,7:42,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:43,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:44,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:45,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:46,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:47,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:48,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:49,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{4:17,5:_,7:50,8:E,9:h,11:o,13:i,14:14,15:15,16:16,17:18,18:19,19:20,20:21,21:g,22:S,23:k,24:q,25:23,33:25,41:C,42:A,43:V,44:v,45:L,46:x,54:O,72:w,74:D,77:M,89:p,90:R},{26:51,89:[1,52],90:[1,53]},{55:54,89:[1,55],90:[1,56]},{29:[1,59],61:[1,57],63:[1,58]},e(d,[2,17]),e(d,[2,18]),e(d,[2,19]),e(d,[2,20]),{30:60,33:62,75:P,89:p,90:R},{30:63,33:62,75:P,89:p,90:R},{30:64,33:62,75:P,89:p,90:R},e(X,[2,29]),e(X,[2,30]),e(X,[2,31]),e(X,[2,32]),e(X,[2,33]),e(X,[2,34]),e(Ce,[2,81]),e(Ce,[2,82]),{1:[2,3]},{8:[2,8]},{8:[2,9]},{8:[2,10]},{8:[2,11]},{8:[2,12]},{8:[2,13]},{8:[2,14]},{8:[2,15]},{8:[2,16]},{27:[1,65],29:[1,66]},e(de,[2,79]),e(de,[2,80]),{27:[1,67],29:[1,68]},e(de,[2,85]),e(de,[2,86]),{62:69,65:Ae,66:Ve,67:ve,68:Le,69:xe,70:Oe,71:we},{62:77,65:Ae,66:Ve,67:ve,68:Le,69:xe,70:Oe,71:we},{30:78,33:62,75:P,89:p,90:R},{73:79,75:Z,76:U,78:81,79:82,80:ee,81:te,82:se,83:ie,84:re,85:ne,86:ae,87:le,88:ce},e(Ee,[2,60]),e(Ee,[2,62]),{73:93,75:Z,76:U,78:81,79:82,80:ee,81:te,82:se,83:ie,84:re,85:ne,86:ae,87:le,88:ce},{30:94,33:62,75:P,76:U,89:p,90:R},{5:[1,95]},{30:96,33:62,75:P,89:p,90:R},{5:[1,97]},{30:98,33:62,75:P,89:p,90:R},{63:[1,99]},e(Y,[2,50]),e(Y,[2,51]),e(Y,[2,52]),e(Y,[2,53]),e(Y,[2,54]),e(Y,[2,55]),e(Y,[2,56]),{64:[1,100]},e(d,[2,59],{76:U}),e(d,[2,64],{76:De}),{33:103,75:[1,102],89:p,90:R},e(Me,[2,65],{79:104,75:Z,80:ee,81:te,82:se,83:ie,84:re,85:ne,86:ae,87:le,88:ce}),e(T,[2,67]),e(T,[2,69]),e(T,[2,70]),e(T,[2,71]),e(T,[2,72]),e(T,[2,73]),e(T,[2,74]),e(T,[2,75]),e(T,[2,76]),e(T,[2,77]),e(T,[2,78]),e(d,[2,57],{76:De}),e(d,[2,58],{76:U}),{5:B,28:105,31:Q,34:H,36:K,38:W,40:j},{27:[1,112],76:U},{5:oe,40:he,56:113,57:ue,59:fe},{27:[1,118],76:U},{33:119,89:p,90:R},{33:120,89:p,90:R},{75:Z,78:121,79:82,80:ee,81:te,82:se,83:ie,84:re,85:ne,86:ae,87:le,88:ce},e(Ee,[2,61]),e(Ee,[2,63]),e(T,[2,68]),e(d,[2,21]),{32:[1,122]},{32:[1,123]},{32:[1,124]},{32:[1,125]},{5:B,28:126,31:Q,34:H,36:K,38:W,40:j},e(d,[2,28]),{5:[1,127]},e(d,[2,42]),{32:[1,128]},{32:[1,129]},{5:oe,40:he,56:130,57:ue,59:fe},e(d,[2,47]),{5:[1,131]},e(d,[2,48]),e(d,[2,49]),e(Me,[2,66],{79:104,75:Z,80:ee,81:te,82:se,83:ie,84:re,85:ne,86:ae,87:le,88:ce}),{33:132,89:p,90:R},{35:133,89:[1,134],90:[1,135]},{37:136,47:[1,137],48:[1,138],49:[1,139]},{39:140,50:[1,141],51:[1,142],52:[1,143],53:[1,144]},e(d,[2,27]),{5:B,28:145,31:Q,34:H,36:K,38:W,40:j},{58:146,89:[1,147],90:[1,148]},{60:149,89:[1,150],90:[1,151]},e(d,[2,46]),{5:oe,40:he,56:152,57:ue,59:fe},{5:[1,153]},{5:[1,154]},{5:[2,83]},{5:[2,84]},{5:[1,155]},{5:[2,35]},{5:[2,36]},{5:[2,37]},{5:[1,156]},{5:[2,38]},{5:[2,39]},{5:[2,40]},{5:[2,41]},e(d,[2,22]),{5:[1,157]},{5:[2,87]},{5:[2,88]},{5:[1,158]},{5:[2,89]},{5:[2,90]},e(d,[2,43]),{5:B,28:159,31:Q,34:H,36:K,38:W,40:j},{5:B,28:160,31:Q,34:H,36:K,38:W,40:j},{5:B,28:161,31:Q,34:H,36:K,38:W,40:j},{5:B,28:162,31:Q,34:H,36:K,38:W,40:j},{5:oe,40:he,56:163,57:ue,59:fe},{5:oe,40:he,56:164,57:ue,59:fe},e(d,[2,23]),e(d,[2,24]),e(d,[2,25]),e(d,[2,26]),e(d,[2,44]),e(d,[2,45])],defaultActions:{8:[2,2],12:[2,1],41:[2,3],42:[2,8],43:[2,9],44:[2,10],45:[2,11],46:[2,12],47:[2,13],48:[2,14],49:[2,15],50:[2,16],134:[2,83],135:[2,84],137:[2,35],138:[2,36],139:[2,37],141:[2,38],142:[2,39],143:[2,40],144:[2,41],147:[2,87],148:[2,88],150:[2,89],151:[2,90]},parseError:u(function(r,n){if(n.recoverable)this.trace(r);else{var l=new Error(r);throw l.hash=n,l}},"parseError"),parse:u(function(r){var n=this,l=[0],s=[],m=[null],t=[],me=this.table,a="",Re=0,Fe=0,He=2,$e=1,Ke=t.slice.call(arguments,1),y=Object.create(this.lexer),z={yy:{}};for(var Se in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Se)&&(z.yy[Se]=this.yy[Se]);y.setInput(r,z.yy),z.yy.lexer=y,z.yy.parser=this,typeof y.yylloc>"u"&&(y.yylloc={});var be=y.yylloc;t.push(be);var We=y.options&&y.options.ranges;typeof z.yy.parseError=="function"?this.parseError=z.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function je(I){l.length=l.length-2*I,m.length=m.length-I,t.length=t.length-I}u(je,"popStack");function Pe(){var I;return I=s.pop()||y.lex()||$e,typeof I!="number"&&(I instanceof Array&&(s=I,I=s.pop()),I=n.symbols_[I]||I),I}u(Pe,"lex");for(var b,G,N,Ie,J={},ge,F,Ue,ye;;){if(G=l[l.length-1],this.defaultActions[G]?N=this.defaultActions[G]:((b===null||typeof b>"u")&&(b=Pe()),N=me[G]&&me[G][b]),typeof N>"u"||!N.length||!N[0]){var ke="";ye=[];for(ge in me[G])this.terminals_[ge]&&ge>He&&ye.push("'"+this.terminals_[ge]+"'");y.showPosition?ke="Parse error on line "+(Re+1)+`: +`+y.showPosition()+` +Expecting `+ye.join(", ")+", got '"+(this.terminals_[b]||b)+"'":ke="Parse error on line "+(Re+1)+": Unexpected "+(b==$e?"end of input":"'"+(this.terminals_[b]||b)+"'"),this.parseError(ke,{text:y.match,token:this.terminals_[b]||b,line:y.yylineno,loc:be,expected:ye})}if(N[0]instanceof Array&&N.length>1)throw new Error("Parse Error: multiple actions possible at state: "+G+", token: "+b);switch(N[0]){case 1:l.push(b),m.push(y.yytext),t.push(y.yylloc),l.push(N[1]),b=null,Fe=y.yyleng,a=y.yytext,Re=y.yylineno,be=y.yylloc;break;case 2:if(F=this.productions_[N[1]][1],J.$=m[m.length-F],J._$={first_line:t[t.length-(F||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(F||1)].first_column,last_column:t[t.length-1].last_column},We&&(J._$.range=[t[t.length-(F||1)].range[0],t[t.length-1].range[1]]),Ie=this.performAction.apply(J,[a,Fe,Re,z.yy,N[1],m,t].concat(Ke)),typeof Ie<"u")return Ie;F&&(l=l.slice(0,-1*F*2),m=m.slice(0,-1*F),t=t.slice(0,-1*F)),l.push(this.productions_[N[1]][0]),m.push(J.$),t.push(J._$),Ue=me[l[l.length-2]][l[l.length-1]],l.push(Ue);break;case 3:return!0}}return!0},"parse")},Qe=(function(){var $={EOF:1,parseError:u(function(n,l){if(this.yy.parser)this.yy.parser.parseError(n,l);else throw new Error(n)},"parseError"),setInput:u(function(r,n){return this.yy=n||this.yy||{},this._input=r,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:u(function(){var r=this._input[0];this.yytext+=r,this.yyleng++,this.offset++,this.match+=r,this.matched+=r;var n=r.match(/(?:\r\n?|\n).*/g);return n?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),r},"input"),unput:u(function(r){var n=r.length,l=r.split(/(?:\r\n?|\n)/g);this._input=r+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-n),this.offset-=n;var s=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),l.length-1&&(this.yylineno-=l.length-1);var m=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:l?(l.length===s.length?this.yylloc.first_column:0)+s[s.length-l.length].length-l[0].length:this.yylloc.first_column-n},this.options.ranges&&(this.yylloc.range=[m[0],m[0]+this.yyleng-n]),this.yyleng=this.yytext.length,this},"unput"),more:u(function(){return this._more=!0,this},"more"),reject:u(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:u(function(r){this.unput(this.match.slice(r))},"less"),pastInput:u(function(){var r=this.matched.substr(0,this.matched.length-this.match.length);return(r.length>20?"...":"")+r.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:u(function(){var r=this.match;return r.length<20&&(r+=this._input.substr(0,20-r.length)),(r.substr(0,20)+(r.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:u(function(){var r=this.pastInput(),n=new Array(r.length+1).join("-");return r+this.upcomingInput()+` +`+n+"^"},"showPosition"),test_match:u(function(r,n){var l,s,m;if(this.options.backtrack_lexer&&(m={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(m.yylloc.range=this.yylloc.range.slice(0))),s=r[0].match(/(?:\r\n?|\n).*/g),s&&(this.yylineno+=s.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:s?s[s.length-1].length-s[s.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+r[0].length},this.yytext+=r[0],this.match+=r[0],this.matches=r,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(r[0].length),this.matched+=r[0],l=this.performAction.call(this,this.yy,this,n,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),l)return l;if(this._backtrack){for(var t in m)this[t]=m[t];return!1}return!1},"test_match"),next:u(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var r,n,l,s;this._more||(this.yytext="",this.match="");for(var m=this._currentRules(),t=0;tn[0].length)){if(n=l,s=t,this.options.backtrack_lexer){if(r=this.test_match(l,m[t]),r!==!1)return r;if(this._backtrack){n=!1;continue}else return!1}else if(!this.options.flex)break}return n?(r=this.test_match(n,m[s]),r!==!1?r:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:u(function(){var n=this.next();return n||this.lex()},"lex"),begin:u(function(n){this.conditionStack.push(n)},"begin"),popState:u(function(){var n=this.conditionStack.length-1;return n>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:u(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:u(function(n){return n=this.conditionStack.length-1-Math.abs(n||0),n>=0?this.conditionStack[n]:"INITIAL"},"topState"),pushState:u(function(n){this.begin(n)},"pushState"),stateStackSize:u(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:u(function(n,l,s,m){switch(s){case 0:return"title";case 1:return this.begin("acc_title"),9;case 2:return this.popState(),"acc_title_value";case 3:return this.begin("acc_descr"),11;case 4:return this.popState(),"acc_descr_value";case 5:this.begin("acc_descr_multiline");break;case 6:this.popState();break;case 7:return"acc_descr_multiline_value";case 8:return 21;case 9:return 22;case 10:return 23;case 11:return 24;case 12:return 5;case 13:break;case 14:break;case 15:break;case 16:return 8;case 17:return 6;case 18:return 27;case 19:return 40;case 20:return 29;case 21:return 32;case 22:return 31;case 23:return 34;case 24:return 36;case 25:return 38;case 26:return 41;case 27:return 42;case 28:return 43;case 29:return 44;case 30:return 45;case 31:return 46;case 32:return 47;case 33:return 48;case 34:return 49;case 35:return 50;case 36:return 51;case 37:return 52;case 38:return 53;case 39:return 54;case 40:return 65;case 41:return 66;case 42:return 67;case 43:return 68;case 44:return 69;case 45:return 70;case 46:return 71;case 47:return 57;case 48:return 59;case 49:return this.begin("style"),77;case 50:return 75;case 51:return 81;case 52:return 88;case 53:return"PERCENT";case 54:return 86;case 55:return 84;case 56:break;case 57:this.begin("string");break;case 58:this.popState();break;case 59:return this.begin("style"),72;case 60:return this.begin("style"),74;case 61:return 61;case 62:return 64;case 63:return 63;case 64:this.begin("string");break;case 65:this.popState();break;case 66:return"qString";case 67:return l.yytext=l.yytext.trim(),89;case 68:return 75;case 69:return 80;case 70:return 76}},"anonymous"),rules:[/^(?:title\s[^#\n;]+)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:.*direction\s+TB[^\n]*)/i,/^(?:.*direction\s+BT[^\n]*)/i,/^(?:.*direction\s+RL[^\n]*)/i,/^(?:.*direction\s+LR[^\n]*)/i,/^(?:(\r?\n)+)/i,/^(?:\s+)/i,/^(?:#[^\n]*)/i,/^(?:%[^\n]*)/i,/^(?:$)/i,/^(?:requirementDiagram\b)/i,/^(?:\{)/i,/^(?:\})/i,/^(?::{3})/i,/^(?::)/i,/^(?:id\b)/i,/^(?:text\b)/i,/^(?:risk\b)/i,/^(?:verifyMethod\b)/i,/^(?:requirement\b)/i,/^(?:functionalRequirement\b)/i,/^(?:interfaceRequirement\b)/i,/^(?:performanceRequirement\b)/i,/^(?:physicalRequirement\b)/i,/^(?:designConstraint\b)/i,/^(?:low\b)/i,/^(?:medium\b)/i,/^(?:high\b)/i,/^(?:analysis\b)/i,/^(?:demonstration\b)/i,/^(?:inspection\b)/i,/^(?:test\b)/i,/^(?:element\b)/i,/^(?:contains\b)/i,/^(?:copies\b)/i,/^(?:derives\b)/i,/^(?:satisfies\b)/i,/^(?:verifies\b)/i,/^(?:refines\b)/i,/^(?:traces\b)/i,/^(?:type\b)/i,/^(?:docref\b)/i,/^(?:style\b)/i,/^(?:\w+)/i,/^(?::)/i,/^(?:;)/i,/^(?:%)/i,/^(?:-)/i,/^(?:#)/i,/^(?: )/i,/^(?:["])/i,/^(?:\n)/i,/^(?:classDef\b)/i,/^(?:class\b)/i,/^(?:<-)/i,/^(?:->)/i,/^(?:-)/i,/^(?:["])/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:[\w][^:,\r\n\{\<\>\-\=]*)/i,/^(?:\w+)/i,/^(?:[0-9]+)/i,/^(?:,)/i],conditions:{acc_descr_multiline:{rules:[6,7,68,69,70],inclusive:!1},acc_descr:{rules:[4,68,69,70],inclusive:!1},acc_title:{rules:[2,68,69,70],inclusive:!1},style:{rules:[50,51,52,53,54,55,56,57,58,68,69,70],inclusive:!1},unqString:{rules:[68,69,70],inclusive:!1},token:{rules:[68,69,70],inclusive:!1},string:{rules:[65,66,68,69,70],inclusive:!1},INITIAL:{rules:[0,1,3,5,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,59,60,61,62,63,64,67,68,69,70],inclusive:!0}}};return $})();_e.lexer=Qe;function pe(){this.yy={}}return u(pe,"Parser"),pe.prototype=_e,_e.Parser=pe,new pe})();qe.parser=qe;var ct=qe,ot=class{constructor(){this.relations=[],this.latestRequirement=this.getInitialRequirement(),this.requirements=new Map,this.latestElement=this.getInitialElement(),this.elements=new Map,this.classes=new Map,this.direction="TB",this.RequirementType={REQUIREMENT:"Requirement",FUNCTIONAL_REQUIREMENT:"Functional Requirement",INTERFACE_REQUIREMENT:"Interface Requirement",PERFORMANCE_REQUIREMENT:"Performance Requirement",PHYSICAL_REQUIREMENT:"Physical Requirement",DESIGN_CONSTRAINT:"Design Constraint"},this.RiskLevel={LOW_RISK:"Low",MED_RISK:"Medium",HIGH_RISK:"High"},this.VerifyType={VERIFY_ANALYSIS:"Analysis",VERIFY_DEMONSTRATION:"Demonstration",VERIFY_INSPECTION:"Inspection",VERIFY_TEST:"Test"},this.Relationships={CONTAINS:"contains",COPIES:"copies",DERIVES:"derives",SATISFIES:"satisfies",VERIFIES:"verifies",REFINES:"refines",TRACES:"traces"},this.setAccTitle=Xe,this.getAccTitle=Je,this.setAccDescription=Ze,this.getAccDescription=et,this.setDiagramTitle=tt,this.getDiagramTitle=st,this.getConfig=u(()=>Te().requirement,"getConfig"),this.clear(),this.setDirection=this.setDirection.bind(this),this.addRequirement=this.addRequirement.bind(this),this.setNewReqId=this.setNewReqId.bind(this),this.setNewReqRisk=this.setNewReqRisk.bind(this),this.setNewReqText=this.setNewReqText.bind(this),this.setNewReqVerifyMethod=this.setNewReqVerifyMethod.bind(this),this.addElement=this.addElement.bind(this),this.setNewElementType=this.setNewElementType.bind(this),this.setNewElementDocRef=this.setNewElementDocRef.bind(this),this.addRelationship=this.addRelationship.bind(this),this.setCssStyle=this.setCssStyle.bind(this),this.setClass=this.setClass.bind(this),this.defineClass=this.defineClass.bind(this),this.setAccTitle=this.setAccTitle.bind(this),this.setAccDescription=this.setAccDescription.bind(this)}static{u(this,"RequirementDB")}getDirection(){return this.direction}setDirection(e){this.direction=e}resetLatestRequirement(){this.latestRequirement=this.getInitialRequirement()}resetLatestElement(){this.latestElement=this.getInitialElement()}getInitialRequirement(){return{requirementId:"",text:"",risk:"",verifyMethod:"",name:"",type:"",cssStyles:[],classes:["default"]}}getInitialElement(){return{name:"",type:"",docRef:"",cssStyles:[],classes:["default"]}}addRequirement(e,f){return this.requirements.has(e)||this.requirements.set(e,{name:e,type:f,requirementId:this.latestRequirement.requirementId,text:this.latestRequirement.text,risk:this.latestRequirement.risk,verifyMethod:this.latestRequirement.verifyMethod,cssStyles:[],classes:["default"]}),this.resetLatestRequirement(),this.requirements.get(e)}getRequirements(){return this.requirements}setNewReqId(e){this.latestRequirement!==void 0&&(this.latestRequirement.requirementId=e)}setNewReqText(e){this.latestRequirement!==void 0&&(this.latestRequirement.text=e)}setNewReqRisk(e){this.latestRequirement!==void 0&&(this.latestRequirement.risk=e)}setNewReqVerifyMethod(e){this.latestRequirement!==void 0&&(this.latestRequirement.verifyMethod=e)}addElement(e){return this.elements.has(e)||(this.elements.set(e,{name:e,type:this.latestElement.type,docRef:this.latestElement.docRef,cssStyles:[],classes:["default"]}),Ne.info("Added new element: ",e)),this.resetLatestElement(),this.elements.get(e)}getElements(){return this.elements}setNewElementType(e){this.latestElement!==void 0&&(this.latestElement.type=e)}setNewElementDocRef(e){this.latestElement!==void 0&&(this.latestElement.docRef=e)}addRelationship(e,f,h){this.relations.push({type:e,src:f,dst:h})}getRelationships(){return this.relations}clear(){this.relations=[],this.resetLatestRequirement(),this.requirements=new Map,this.resetLatestElement(),this.elements=new Map,this.classes=new Map,it()}setCssStyle(e,f){for(const h of e){const o=this.requirements.get(h)??this.elements.get(h);if(!f||!o)return;for(const i of f)i.includes(",")?o.cssStyles.push(...i.split(",")):o.cssStyles.push(i)}}setClass(e,f){for(const h of e){const o=this.requirements.get(h)??this.elements.get(h);if(o)for(const i of f){o.classes.push(i);const c=this.classes.get(i)?.styles;c&&o.cssStyles.push(...c)}}}defineClass(e,f){for(const h of e){let o=this.classes.get(h);o===void 0&&(o={id:h,styles:[],textStyles:[]},this.classes.set(h,o)),f&&f.forEach(function(i){if(/color/.exec(i)){const c=i.replace("fill","bgFill");o.textStyles.push(c)}o.styles.push(i)}),this.requirements.forEach(i=>{i.classes.includes(h)&&i.cssStyles.push(...f.flatMap(c=>c.split(",")))}),this.elements.forEach(i=>{i.classes.includes(h)&&i.cssStyles.push(...f.flatMap(c=>c.split(",")))})}}getClasses(){return this.classes}getData(){const e=Te(),f=[],h=[];for(const i of this.requirements.values()){const c=i;c.id=i.name,c.cssStyles=i.cssStyles,c.cssClasses=i.classes.join(" "),c.shape="requirementBox",c.look=e.look,c.colorIndex=f.length,f.push(c)}for(const i of this.elements.values()){const c=i;c.shape="requirementBox",c.look=e.look,c.id=i.name,c.cssStyles=i.cssStyles,c.cssClasses=i.classes.join(" "),c.colorIndex=f.length,f.push(c)}let o=0;for(const i of this.relations){const c=i.type===this.Relationships.CONTAINS,_={id:`${i.src}-${i.dst}-${o++}`,start:this.requirements.get(i.src)?.name??this.elements.get(i.src)?.name,end:this.requirements.get(i.dst)?.name??this.elements.get(i.dst)?.name,label:`<<${i.type}>>`,classes:"relationshipLine",style:["fill:none",c?"":"stroke-dasharray: 10,7"],labelpos:"c",thickness:"normal",type:"normal",pattern:c?"normal":"dashed",arrowTypeStart:c?"requirement_contains":"",arrowTypeEnd:c?"":"requirement_arrow",look:e.look,labelType:"markdown"};h.push(_)}return{nodes:f,edges:h,other:{},config:e,direction:this.getDirection()}}},ht=u(e=>{const f=Ye(),{themeVariables:h,look:o}=f,{bkgColorArray:i,borderColorArray:c}=h;if(!c?.length)return"";let _="";for(let E=0;E{const f=Ye(),{look:h,themeVariables:o}=f,{requirementEdgeLabelBackground:i}=o;return` + ${ht(e)} + marker { + fill: ${e.relationColor}; + stroke: ${e.relationColor}; + } + + marker.cross { + stroke: ${e.lineColor}; + } + + svg { + font-family: ${e.fontFamily}; + font-size: ${e.fontSize}; + } + + .reqBox { + fill: ${e.requirementBackground}; + fill-opacity: 1.0; + stroke: ${e.requirementBorderColor}; + stroke-width: ${e.requirementBorderSize}; + } + + .reqTitle, .reqLabel{ + fill: ${e.requirementTextColor}; + } + .reqLabelBox { + fill: ${e.relationLabelBackground}; + fill-opacity: 1.0; + } + + .req-title-line { + stroke: ${e.requirementBorderColor}; + stroke-width: ${e.requirementBorderSize}; + } + .relationshipLine { + stroke: ${e.relationColor}; + stroke-width: ${h==="neo"?e.strokeWidth:"1px"}; + } + .relationshipLabel { + fill: ${e.relationLabelColor}; + } + .edgeLabel { + background-color: ${e.edgeLabelBackground}; + } + .edgeLabel .label rect { + fill: ${e.edgeLabelBackground}; + } + .edgeLabel .label text { + fill: ${e.relationLabelColor}; + } + .divider { + stroke: ${e.nodeBorder}; + stroke-width: 1; + } + .label { + font-family: ${e.fontFamily}; + color: ${e.nodeTextColor||e.textColor}; + } + .label text,span { + fill: ${e.nodeTextColor||e.textColor}; + color: ${e.nodeTextColor||e.textColor}; + } + .labelBkg { + background-color: ${i??e.edgeLabelBackground}; + } + +`},"getStyles"),ft=ut,Be={};rt(Be,{draw:()=>mt});var mt=u(async function(e,f,h,o){Ne.info("REF0:"),Ne.info("Drawing requirement diagram (unified)",f);const{securityLevel:i,state:c,layout:_,look:E}=Te(),g=o.db.getData(),S=ze(f,i);g.type=o.type,g.layoutAlgorithm=nt(_),g.nodeSpacing=c?.nodeSpacing??50,g.rankSpacing=c?.rankSpacing??50,g.markers=E==="neo"?["requirement_contains_neo","requirement_arrow_neo"]:["requirement_contains","requirement_arrow"],g.diagramId=f,await at(g,S);const k=8;lt.insertTitle(S,"requirementDiagramTitleText",c?.titleTopMargin??25,o.db.getDiagramTitle()),Ge(S,k,"requirementDiagram",c?.useMaxWidth??!0)},"draw"),yt={parser:ct,get db(){return new ot},renderer:Be,styles:ft};export{yt as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/sankeyDiagram-P5KCCOFB.Dat3kWim.js b/packages/tempo/public/v4/assets/chunks/sankeyDiagram-P5KCCOFB.Dat3kWim.js new file mode 100644 index 00000000..dd035a35 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/sankeyDiagram-P5KCCOFB.Dat3kWim.js @@ -0,0 +1,40 @@ +import{p as kt,q as mt,s as xt,g as _t,b as vt,a as bt,_ as y,c as ot,b9 as St,j as G,af as wt,r as Lt,k as Et}from"../app.CbekdYod.js";import{o as At}from"./ordinal.BYWQX77i.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./init.Gi6I4Gst.js";function Tt(t){for(var i=t.length/6|0,s=new Array(i),l=0;l=l)&&(s=l);else{let l=-1;for(let u of t)(u=i(u,++l,t))!=null&&(s=u)&&(s=u)}return s}function dt(t,i){let s;if(i===void 0)for(const l of t)l!=null&&(s>l||s===void 0&&l>=l)&&(s=l);else{let l=-1;for(let u of t)(u=i(u,++l,t))!=null&&(s>u||s===void 0&&u>=u)&&(s=u)}return s}function J(t,i){let s=0;if(i===void 0)for(let l of t)(l=+l)&&(s+=l);else{let l=-1;for(let u of t)(u=+i(u,++l,t))&&(s+=u)}return s}function Nt(t){return t.target.depth}function Ct(t){return t.depth}function Pt(t,i){return i-1-t.height}function gt(t,i){return t.sourceLinks.length?t.depth:i-1}function It(t){return t.targetLinks.length?t.depth:t.sourceLinks.length?dt(t.sourceLinks,Nt)-1:0}function Y(t){return function(){return t}}function lt(t,i){return q(t.source,i.source)||t.index-i.index}function ct(t,i){return q(t.target,i.target)||t.index-i.index}function q(t,i){return t.y0-i.y0}function tt(t){return t.value}function Ot(t){return t.index}function $t(t){return t.nodes}function jt(t){return t.links}function ut(t,i){const s=t.get(i);if(!s)throw new Error("missing: "+i);return s}function ht({nodes:t}){for(const i of t){let s=i.y0,l=s;for(const u of i.sourceLinks)u.y0=s+u.width/2,s+=u.width;for(const u of i.targetLinks)u.y1=l+u.width/2,l+=u.width}}function Dt(){let t=0,i=0,s=1,l=1,u=24,x=8,g,k=Ot,o=gt,a,h,m=$t,_=jt,d=6;function v(){const n={nodes:m.apply(null,arguments),links:_.apply(null,arguments)};return T(n),A(n),M(n),I(n),S(n),ht(n),n}v.update=function(n){return ht(n),n},v.nodeId=function(n){return arguments.length?(k=typeof n=="function"?n:Y(n),v):k},v.nodeAlign=function(n){return arguments.length?(o=typeof n=="function"?n:Y(n),v):o},v.nodeSort=function(n){return arguments.length?(a=n,v):a},v.nodeWidth=function(n){return arguments.length?(u=+n,v):u},v.nodePadding=function(n){return arguments.length?(x=g=+n,v):x},v.nodes=function(n){return arguments.length?(m=typeof n=="function"?n:Y(n),v):m},v.links=function(n){return arguments.length?(_=typeof n=="function"?n:Y(n),v):_},v.linkSort=function(n){return arguments.length?(h=n,v):h},v.size=function(n){return arguments.length?(t=i=0,s=+n[0],l=+n[1],v):[s-t,l-i]},v.extent=function(n){return arguments.length?(t=+n[0][0],s=+n[1][0],i=+n[0][1],l=+n[1][1],v):[[t,i],[s,l]]},v.iterations=function(n){return arguments.length?(d=+n,v):d};function T({nodes:n,links:f}){for(const[e,r]of n.entries())r.index=e,r.sourceLinks=[],r.targetLinks=[];const c=new Map(n.map((e,r)=>[k(e,r,n),e]));for(const[e,r]of f.entries()){r.index=e;let{source:p,target:b}=r;typeof p!="object"&&(p=r.source=ut(c,p)),typeof b!="object"&&(b=r.target=ut(c,b)),p.sourceLinks.push(r),b.targetLinks.push(r)}if(h!=null)for(const{sourceLinks:e,targetLinks:r}of n)e.sort(h),r.sort(h)}function A({nodes:n}){for(const f of n)f.value=f.fixedValue===void 0?Math.max(J(f.sourceLinks,tt),J(f.targetLinks,tt)):f.fixedValue}function M({nodes:n}){const f=n.length;let c=new Set(n),e=new Set,r=0;for(;c.size;){for(const p of c){p.depth=r;for(const{target:b}of p.sourceLinks)e.add(b)}if(++r>f)throw new Error("circular link");c=e,e=new Set}}function I({nodes:n}){const f=n.length;let c=new Set(n),e=new Set,r=0;for(;c.size;){for(const p of c){p.height=r;for(const{source:b}of p.targetLinks)e.add(b)}if(++r>f)throw new Error("circular link");c=e,e=new Set}}function N({nodes:n}){const f=at(n,r=>r.depth)+1,c=(s-t-u)/(f-1),e=new Array(f);for(const r of n){const p=Math.max(0,Math.min(f-1,Math.floor(o.call(null,r,f))));r.layer=p,r.x0=t+p*c,r.x1=r.x0+u,e[p]?e[p].push(r):e[p]=[r]}if(a)for(const r of e)r.sort(a);return e}function $(n){const f=dt(n,c=>(l-i-(c.length-1)*g)/J(c,tt));for(const c of n){let e=i;for(const r of c){r.y0=e,r.y1=e+r.value*f,e=r.y1+g;for(const p of r.sourceLinks)p.width=p.value*f}e=(l-e+g)/(c.length+1);for(let r=0;rc.length)-1)),$(f);for(let c=0;c0))continue;let V=(L/z-b.y0)*f;b.y0+=V,b.y1+=V,D(b)}a===void 0&&p.sort(q),j(p,c)}}function F(n,f,c){for(let e=n.length,r=e-2;r>=0;--r){const p=n[r];for(const b of p){let L=0,z=0;for(const{target:W,value:Z}of b.sourceLinks){let U=Z*(W.layer-b.layer);L+=E(b,W)*U,z+=U}if(!(z>0))continue;let V=(L/z-b.y0)*f;b.y0+=V,b.y1+=V,D(b)}a===void 0&&p.sort(q),j(p,c)}}function j(n,f){const c=n.length>>1,e=n[c];O(n,e.y0-g,c-1,f),R(n,e.y1+g,c+1,f),O(n,l,n.length-1,f),R(n,i,0,f)}function R(n,f,c,e){for(;c1e-6&&(r.y0+=p,r.y1+=p),f=r.y1+g}}function O(n,f,c,e){for(;c>=0;--c){const r=n[c],p=(r.y1-f)*e;p>1e-6&&(r.y0-=p,r.y1-=p),f=r.y0-g}}function D({sourceLinks:n,targetLinks:f}){if(h===void 0){for(const{source:{sourceLinks:c}}of f)c.sort(ct);for(const{target:{targetLinks:c}}of n)c.sort(lt)}}function w(n){if(h===void 0)for(const{sourceLinks:f,targetLinks:c}of n)f.sort(ct),c.sort(lt)}function P(n,f){let c=n.y0-(n.sourceLinks.length-1)*g/2;for(const{target:e,width:r}of n.sourceLinks){if(e===f)break;c+=r+g}for(const{source:e,width:r}of f.targetLinks){if(e===n)break;c-=r}return c}function E(n,f){let c=f.y0-(f.targetLinks.length-1)*g/2;for(const{source:e,width:r}of f.targetLinks){if(e===n)break;c+=r+g}for(const{target:e,width:r}of n.sourceLinks){if(e===f)break;c-=r}return c}return v}var et=Math.PI,nt=2*et,B=1e-6,zt=nt-B;function it(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function pt(){return new it}it.prototype=pt.prototype={constructor:it,moveTo:function(t,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+i)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,i){this._+="L"+(this._x1=+t)+","+(this._y1=+i)},quadraticCurveTo:function(t,i,s,l){this._+="Q"+ +t+","+ +i+","+(this._x1=+s)+","+(this._y1=+l)},bezierCurveTo:function(t,i,s,l,u,x){this._+="C"+ +t+","+ +i+","+ +s+","+ +l+","+(this._x1=+u)+","+(this._y1=+x)},arcTo:function(t,i,s,l,u){t=+t,i=+i,s=+s,l=+l,u=+u;var x=this._x1,g=this._y1,k=s-t,o=l-i,a=x-t,h=g-i,m=a*a+h*h;if(u<0)throw new Error("negative radius: "+u);if(this._x1===null)this._+="M"+(this._x1=t)+","+(this._y1=i);else if(m>B)if(!(Math.abs(h*k-o*a)>B)||!u)this._+="L"+(this._x1=t)+","+(this._y1=i);else{var _=s-x,d=l-g,v=k*k+o*o,T=_*_+d*d,A=Math.sqrt(v),M=Math.sqrt(m),I=u*Math.tan((et-Math.acos((v+m-T)/(2*A*M)))/2),N=I/M,$=I/A;Math.abs(N-1)>B&&(this._+="L"+(t+N*a)+","+(i+N*h)),this._+="A"+u+","+u+",0,0,"+ +(h*_>a*d)+","+(this._x1=t+$*k)+","+(this._y1=i+$*o)}},arc:function(t,i,s,l,u,x){t=+t,i=+i,s=+s,x=!!x;var g=s*Math.cos(l),k=s*Math.sin(l),o=t+g,a=i+k,h=1^x,m=x?l-u:u-l;if(s<0)throw new Error("negative radius: "+s);this._x1===null?this._+="M"+o+","+a:(Math.abs(this._x1-o)>B||Math.abs(this._y1-a)>B)&&(this._+="L"+o+","+a),s&&(m<0&&(m=m%nt+nt),m>zt?this._+="A"+s+","+s+",0,1,"+h+","+(t-g)+","+(i-k)+"A"+s+","+s+",0,1,"+h+","+(this._x1=o)+","+(this._y1=a):m>B&&(this._+="A"+s+","+s+",0,"+ +(m>=et)+","+h+","+(this._x1=t+s*Math.cos(u))+","+(this._y1=i+s*Math.sin(u))))},rect:function(t,i,s,l){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+i)+"h"+ +s+"v"+ +l+"h"+-s+"Z"},toString:function(){return this._}};function ft(t){return function(){return t}}function Bt(t){return t[0]}function Ft(t){return t[1]}var Rt=Array.prototype.slice;function Vt(t){return t.source}function Wt(t){return t.target}function Ut(t){var i=Vt,s=Wt,l=Bt,u=Ft,x=null;function g(){var k,o=Rt.call(arguments),a=i.apply(this,o),h=s.apply(this,o);if(x||(x=k=pt()),t(x,+l.apply(this,(o[0]=a,o)),+u.apply(this,o),+l.apply(this,(o[0]=h,o)),+u.apply(this,o)),k)return x=null,k+""||null}return g.source=function(k){return arguments.length?(i=k,g):i},g.target=function(k){return arguments.length?(s=k,g):s},g.x=function(k){return arguments.length?(l=typeof k=="function"?k:ft(+k),g):l},g.y=function(k){return arguments.length?(u=typeof k=="function"?k:ft(+k),g):u},g.context=function(k){return arguments.length?(x=k??null,g):x},g}function Gt(t,i,s,l,u){t.moveTo(i,s),t.bezierCurveTo(i=(i+l)/2,s,i,u,l,u)}function Yt(){return Ut(Gt)}function qt(t){return[t.source.x1,t.y0]}function Ht(t){return[t.target.x0,t.y1]}function Xt(){return Yt().source(qt).target(Ht)}var rt=(function(){var t=y(function(k,o,a,h){for(a=a||{},h=k.length;h--;a[k[h]]=o);return a},"o"),i=[1,9],s=[1,10],l=[1,5,10,12],u={trace:y(function(){},"trace"),yy:{},symbols_:{error:2,start:3,SANKEY:4,NEWLINE:5,csv:6,opt_eof:7,record:8,csv_tail:9,EOF:10,"field[source]":11,COMMA:12,"field[target]":13,"field[value]":14,field:15,escaped:16,non_escaped:17,DQUOTE:18,ESCAPED_TEXT:19,NON_ESCAPED_TEXT:20,$accept:0,$end:1},terminals_:{2:"error",4:"SANKEY",5:"NEWLINE",10:"EOF",11:"field[source]",12:"COMMA",13:"field[target]",14:"field[value]",18:"DQUOTE",19:"ESCAPED_TEXT",20:"NON_ESCAPED_TEXT"},productions_:[0,[3,4],[6,2],[9,2],[9,0],[7,1],[7,0],[8,5],[15,1],[15,1],[16,3],[17,1]],performAction:y(function(o,a,h,m,_,d,v){var T=d.length-1;switch(_){case 7:const A=m.findOrCreateNode(d[T-4].trim().replaceAll('""','"')),M=m.findOrCreateNode(d[T-2].trim().replaceAll('""','"')),I=parseFloat(d[T].trim());m.addLink(A,M,I);break;case 8:case 9:case 11:this.$=d[T];break;case 10:this.$=d[T-1];break}},"anonymous"),table:[{3:1,4:[1,2]},{1:[3]},{5:[1,3]},{6:4,8:5,15:6,16:7,17:8,18:i,20:s},{1:[2,6],7:11,10:[1,12]},t(s,[2,4],{9:13,5:[1,14]}),{12:[1,15]},t(l,[2,8]),t(l,[2,9]),{19:[1,16]},t(l,[2,11]),{1:[2,1]},{1:[2,5]},t(s,[2,2]),{6:17,8:5,15:6,16:7,17:8,18:i,20:s},{15:18,16:7,17:8,18:i,20:s},{18:[1,19]},t(s,[2,3]),{12:[1,20]},t(l,[2,10]),{15:21,16:7,17:8,18:i,20:s},t([1,5,10],[2,7])],defaultActions:{11:[2,1],12:[2,5]},parseError:y(function(o,a){if(a.recoverable)this.trace(o);else{var h=new Error(o);throw h.hash=a,h}},"parseError"),parse:y(function(o){var a=this,h=[0],m=[],_=[null],d=[],v=this.table,T="",A=0,M=0,I=2,N=1,$=d.slice.call(arguments,1),S=Object.create(this.lexer),C={yy:{}};for(var F in this.yy)Object.prototype.hasOwnProperty.call(this.yy,F)&&(C.yy[F]=this.yy[F]);S.setInput(o,C.yy),C.yy.lexer=S,C.yy.parser=this,typeof S.yylloc>"u"&&(S.yylloc={});var j=S.yylloc;d.push(j);var R=S.options&&S.options.ranges;typeof C.yy.parseError=="function"?this.parseError=C.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function O(L){h.length=h.length-2*L,_.length=_.length-L,d.length=d.length-L}y(O,"popStack");function D(){var L;return L=m.pop()||S.lex()||N,typeof L!="number"&&(L instanceof Array&&(m=L,L=m.pop()),L=a.symbols_[L]||L),L}y(D,"lex");for(var w,P,E,n,f={},c,e,r,p;;){if(P=h[h.length-1],this.defaultActions[P]?E=this.defaultActions[P]:((w===null||typeof w>"u")&&(w=D()),E=v[P]&&v[P][w]),typeof E>"u"||!E.length||!E[0]){var b="";p=[];for(c in v[P])this.terminals_[c]&&c>I&&p.push("'"+this.terminals_[c]+"'");S.showPosition?b="Parse error on line "+(A+1)+`: +`+S.showPosition()+` +Expecting `+p.join(", ")+", got '"+(this.terminals_[w]||w)+"'":b="Parse error on line "+(A+1)+": Unexpected "+(w==N?"end of input":"'"+(this.terminals_[w]||w)+"'"),this.parseError(b,{text:S.match,token:this.terminals_[w]||w,line:S.yylineno,loc:j,expected:p})}if(E[0]instanceof Array&&E.length>1)throw new Error("Parse Error: multiple actions possible at state: "+P+", token: "+w);switch(E[0]){case 1:h.push(w),_.push(S.yytext),d.push(S.yylloc),h.push(E[1]),w=null,M=S.yyleng,T=S.yytext,A=S.yylineno,j=S.yylloc;break;case 2:if(e=this.productions_[E[1]][1],f.$=_[_.length-e],f._$={first_line:d[d.length-(e||1)].first_line,last_line:d[d.length-1].last_line,first_column:d[d.length-(e||1)].first_column,last_column:d[d.length-1].last_column},R&&(f._$.range=[d[d.length-(e||1)].range[0],d[d.length-1].range[1]]),n=this.performAction.apply(f,[T,M,A,C.yy,E[1],_,d].concat($)),typeof n<"u")return n;e&&(h=h.slice(0,-1*e*2),_=_.slice(0,-1*e),d=d.slice(0,-1*e)),h.push(this.productions_[E[1]][0]),_.push(f.$),d.push(f._$),r=v[h[h.length-2]][h[h.length-1]],h.push(r);break;case 3:return!0}}return!0},"parse")},x=(function(){var k={EOF:1,parseError:y(function(a,h){if(this.yy.parser)this.yy.parser.parseError(a,h);else throw new Error(a)},"parseError"),setInput:y(function(o,a){return this.yy=a||this.yy||{},this._input=o,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:y(function(){var o=this._input[0];this.yytext+=o,this.yyleng++,this.offset++,this.match+=o,this.matched+=o;var a=o.match(/(?:\r\n?|\n).*/g);return a?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),o},"input"),unput:y(function(o){var a=o.length,h=o.split(/(?:\r\n?|\n)/g);this._input=o+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-a),this.offset-=a;var m=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),h.length-1&&(this.yylineno-=h.length-1);var _=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:h?(h.length===m.length?this.yylloc.first_column:0)+m[m.length-h.length].length-h[0].length:this.yylloc.first_column-a},this.options.ranges&&(this.yylloc.range=[_[0],_[0]+this.yyleng-a]),this.yyleng=this.yytext.length,this},"unput"),more:y(function(){return this._more=!0,this},"more"),reject:y(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:y(function(o){this.unput(this.match.slice(o))},"less"),pastInput:y(function(){var o=this.matched.substr(0,this.matched.length-this.match.length);return(o.length>20?"...":"")+o.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:y(function(){var o=this.match;return o.length<20&&(o+=this._input.substr(0,20-o.length)),(o.substr(0,20)+(o.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:y(function(){var o=this.pastInput(),a=new Array(o.length+1).join("-");return o+this.upcomingInput()+` +`+a+"^"},"showPosition"),test_match:y(function(o,a){var h,m,_;if(this.options.backtrack_lexer&&(_={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(_.yylloc.range=this.yylloc.range.slice(0))),m=o[0].match(/(?:\r\n?|\n).*/g),m&&(this.yylineno+=m.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:m?m[m.length-1].length-m[m.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+o[0].length},this.yytext+=o[0],this.match+=o[0],this.matches=o,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(o[0].length),this.matched+=o[0],h=this.performAction.call(this,this.yy,this,a,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),h)return h;if(this._backtrack){for(var d in _)this[d]=_[d];return!1}return!1},"test_match"),next:y(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var o,a,h,m;this._more||(this.yytext="",this.match="");for(var _=this._currentRules(),d=0;d<_.length;d++)if(h=this._input.match(this.rules[_[d]]),h&&(!a||h[0].length>a[0].length)){if(a=h,m=d,this.options.backtrack_lexer){if(o=this.test_match(h,_[d]),o!==!1)return o;if(this._backtrack){a=!1;continue}else return!1}else if(!this.options.flex)break}return a?(o=this.test_match(a,_[m]),o!==!1?o:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:y(function(){var a=this.next();return a||this.lex()},"lex"),begin:y(function(a){this.conditionStack.push(a)},"begin"),popState:y(function(){var a=this.conditionStack.length-1;return a>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:y(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:y(function(a){return a=this.conditionStack.length-1-Math.abs(a||0),a>=0?this.conditionStack[a]:"INITIAL"},"topState"),pushState:y(function(a){this.begin(a)},"pushState"),stateStackSize:y(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:y(function(a,h,m,_){switch(m){case 0:return this.pushState("csv"),4;case 1:return this.pushState("csv"),4;case 2:return 10;case 3:return 5;case 4:return 12;case 5:return this.pushState("escaped_text"),18;case 6:return 20;case 7:return this.popState("escaped_text"),18;case 8:return 19}},"anonymous"),rules:[/^(?:sankey-beta\b)/i,/^(?:sankey\b)/i,/^(?:$)/i,/^(?:((\u000D\u000A)|(\u000A)))/i,/^(?:(\u002C))/i,/^(?:(\u0022))/i,/^(?:([\u0020-\u0021\u0023-\u002B\u002D-\u007E])*)/i,/^(?:(\u0022)(?!(\u0022)))/i,/^(?:(([\u0020-\u0021\u0023-\u002B\u002D-\u007E])|(\u002C)|(\u000D)|(\u000A)|(\u0022)(\u0022))*)/i],conditions:{csv:{rules:[2,3,4,5,6,7,8],inclusive:!1},escaped_text:{rules:[7,8],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8],inclusive:!0}}};return k})();u.lexer=x;function g(){this.yy={}}return y(g,"Parser"),g.prototype=u,u.Parser=g,new g})();rt.parser=rt;var H=rt,Q=[],K=[],X=new Map,Qt=y(()=>{Q=[],K=[],X=new Map,Lt()},"clear"),Kt=class{constructor(t,i,s=0){this.source=t,this.target=i,this.value=s}static{y(this,"SankeyLink")}},Zt=y((t,i,s)=>{Q.push(new Kt(t,i,s))},"addLink"),Jt=class{constructor(t){this.ID=t}static{y(this,"SankeyNode")}},te=y(t=>{t=Et.sanitizeText(t,ot());let i=X.get(t);return i===void 0&&(i=new Jt(t),X.set(t,i),K.push(i)),i},"findOrCreateNode"),ee=y(()=>K,"getNodes"),ne=y(()=>Q,"getLinks"),ie=y(()=>({nodes:K.map(t=>({id:t.ID})),links:Q.map(t=>({source:t.source.ID,target:t.target.ID,value:t.value}))}),"getGraph"),re={nodesMap:X,getConfig:y(()=>ot().sankey,"getConfig"),getNodes:ee,getLinks:ne,getGraph:ie,addLink:Zt,findOrCreateNode:te,getAccTitle:bt,setAccTitle:vt,getAccDescription:_t,setAccDescription:xt,getDiagramTitle:mt,setDiagramTitle:kt,clear:Qt},yt=class st{static{y(this,"Uid")}static{this.count=0}static next(i){return new st(i+ ++st.count)}constructor(i){this.id=i,this.href=`#${i}`}toString(){return"url("+this.href+")"}},se={left:Ct,right:Pt,center:It,justify:gt},oe=y(t=>{let i=0,s=0;for(const l of t){const u=l.value??0;u>i&&(i=u,s=l.layer??0)}return s},"findCentralNodeLayer"),ae=y(function(t,i,s,l){const{securityLevel:u,sankey:x}=ot(),g=St.sankey;let k;u==="sandbox"&&(k=G("#i"+i));const o=u==="sandbox"?G(k.nodes()[0].contentDocument.body):G("body"),a=u==="sandbox"?o.select(`[id="${i}"]`):G(`[id="${i}"]`),h=x?.width??g.width,m=x?.height??g.width,_=x?.useMaxWidth??g.useMaxWidth,d=x?.nodeAlignment??g.nodeAlignment,v=x?.prefix??g.prefix,T=x?.suffix??g.suffix,A=x?.showValues??g.showValues,M=x?.nodeWidth??g.nodeWidth??10,I=x?.nodePadding??g.nodePadding??12,N=x?.labelStyle??g.labelStyle??"legacy",$=x?.nodeColors??{},S=l.db.getGraph(),C=se[d];Dt().nodeId(e=>e.id).nodeWidth(M).nodePadding(I+(A?15:0)).nodeAlign(C).extent([[0,0],[h,m]])(S);const j=oe(S.nodes),R=At(Mt),O=y(e=>$[e]??R(e),"getNodeColor");a.append("g").attr("class","nodes").selectAll(".node").data(S.nodes).join("g").attr("class","node").attr("id",e=>(e.uid=yt.next("node-")).id).attr("transform",function(e){return"translate("+e.x0+","+e.y0+")"}).attr("x",e=>e.x0).attr("y",e=>e.y0).append("rect").attr("height",e=>e.y1-e.y0).attr("width",e=>e.x1-e.x0).attr("fill",e=>O(e.id));const D=y(({id:e,value:r})=>A?`${e} +${v}${Math.round(r*100)/100}${T}`:e,"getText"),w=y(e=>N==="outlined"?(e.layer??0)P.selectAll(e?`.${e}`:"text").data(S.nodes).join("text").attr("class",e??null).attr("x",r=>w(r).x).attr("y",r=>(r.y1+r.y0)/2).attr("dy",`${A?"0":"0.35"}em`).attr("text-anchor",r=>w(r).anchor).text(D),"appendLabel");N==="outlined"?(E("sankey-label-bg"),E("sankey-label-fg")):E();const n=a.append("g").attr("class","links").attr("fill","none").attr("stroke-opacity",.5).selectAll(".link").data(S.links).join("g").attr("class","link").style("mix-blend-mode","multiply"),f=x?.linkColor??"gradient";if(f==="gradient"){const e=n.append("linearGradient").attr("id",r=>(r.uid=yt.next("linearGradient-")).id).attr("gradientUnits","userSpaceOnUse").attr("x1",r=>r.source.x1).attr("x2",r=>r.target.x0);e.append("stop").attr("offset","0%").attr("stop-color",r=>O(r.source.id)),e.append("stop").attr("offset","100%").attr("stop-color",r=>O(r.target.id))}let c;switch(f){case"gradient":c=y(e=>e.uid,"coloring");break;case"source":c=y(e=>O(e.source.id),"coloring");break;case"target":c=y(e=>O(e.target.id),"coloring");break;default:c=f}n.append("path").attr("d",Xt()).attr("stroke",c).attr("stroke-width",e=>Math.max(1,e.width)),wt(void 0,a,0,_)},"draw"),le={draw:ae},ce=y(t=>t.replaceAll(/^[^\S\n\r]+|[^\S\n\r]+$/g,"").replaceAll(/([\n\r])+/g,` +`).trim(),"prepareTextForParsing"),ue=y(t=>`.label { + font-family: ${t.fontFamily}; + } + + .node-labels { + font-family: ${t.fontFamily}; + } + + /* Outlined label style - background stroke for better readability */ + .sankey-label-bg { + stroke: ${t.mainBkg||t.background||"#fff"}; + stroke-width: 4px; + stroke-linejoin: round; + paint-order: stroke; + } + + /* Foreground label text */ + .sankey-label-fg { + fill: ${t.textColor}; + } + + /* Node styling */ + .node rect { + shape-rendering: crispEdges; + } + + /* Link styling */ + .link { + fill: none; + stroke-opacity: 0.5; + mix-blend-mode: multiply; + } +`,"getStyles"),he=ue,fe=H.parse.bind(H);H.parse=t=>fe(ce(t));var me={styles:he,parser:H,db:re,renderer:le};export{me as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/sequenceDiagram-WJ2MYXX4.9pY_tZ7u.js b/packages/tempo/public/v4/assets/chunks/sequenceDiagram-WJ2MYXX4.9pY_tZ7u.js new file mode 100644 index 00000000..1b62571a --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/sequenceDiagram-WJ2MYXX4.9pY_tZ7u.js @@ -0,0 +1,162 @@ +import{I as tr}from"./chunk-2Q5K7J3B.3yPGAHkH.js";import{_ as x,Y as er,c as $,j as Vt,l as at,o as Ce,d as rr,e as ar,k as N,b as ke,s as sr,p as ir,a as nr,g as or,q as cr,Z as lr,$ as hr,r as dr,i as Yt,z as Z,a0 as Q,a1 as Pt,a2 as Me,a3 as Tr,A as Kt,a4 as pr,a5 as Be}from"../app.CbekdYod.js";import{a as Er,g as ae,b as dt,d as ur,c as se,e as ie}from"./chunk-F27PBJKO.CcniKEe6.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var te=(function(){var e=x(function(ut,S,v,P){for(v=v||{},P=ut.length;P--;v[ut[P]]=S);return v},"o"),t=[1,2],a=[1,3],r=[1,4],i=[2,4],n=[1,9],s=[1,11],o=[1,12],u=[1,14],d=[1,15],p=[1,17],_=[1,18],E=[1,19],O=[1,25],T=[1,26],g=[1,27],f=[1,28],I=[1,29],L=[1,30],b=[1,31],w=[1,32],A=[1,33],D=[1,34],M=[1,35],V=[1,36],W=[1,37],U=[1,38],G=[1,39],X=[1,40],nt=[1,42],j=[1,43],H=[1,44],st=[1,45],tt=[1,46],Y=[1,47],C=[1,4,5,10,14,15,17,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,48,49,50,51,53,54,56,61,62,63,64,73],At=[1,74],kt=[1,80],m=[1,81],k=[1,82],lt=[1,83],et=[1,84],K=[1,85],Ot=[1,86],ne=[1,87],oe=[1,88],ce=[1,89],le=[1,90],he=[1,91],de=[1,92],Te=[1,93],pe=[1,94],Ee=[1,95],ue=[1,96],fe=[1,97],_e=[1,98],ge=[1,99],xe=[1,100],Ie=[1,101],ye=[1,102],Re=[1,103],Oe=[1,104],Le=[1,105],be=[2,78],St=[4,5,17,51,53,54],Dt=[4,5,10,14,15,17,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,51,53,54,56,61,62,63,64,73],me=[4,5,10,14,15,17,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,50,51,53,54,56,61,62,63,64,73],Ut=[4,5,10,14,15,17,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,49,51,53,54,56,61,62,63,64,73],Ae=[4,5,10,14,15,17,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,48,51,53,54,56,61,62,63,64,73],Gt=[5,52],F=[70,71,72,73],ot=[1,151],Xt={trace:x(function(){},"trace"),yy:{},symbols_:{error:2,start:3,SPACE:4,NEWLINE:5,SD:6,document:7,line:8,statement:9,INVALID:10,box_section:11,box_line:12,participant_statement:13,create:14,box:15,restOfLine:16,end:17,signal:18,autonumber:19,NUM:20,off:21,activate:22,actor:23,deactivate:24,note_statement:25,links_statement:26,link_statement:27,properties_statement:28,details_statement:29,title:30,legacy_title:31,acc_title:32,acc_title_value:33,acc_descr:34,acc_descr_value:35,acc_descr_multiline_value:36,loop:37,rect:38,opt:39,alt:40,else_sections:41,par:42,par_sections:43,par_over:44,critical:45,option_sections:46,break:47,option:48,and:49,else:50,participant:51,AS:52,participant_actor:53,destroy:54,actor_with_config:55,note:56,placement:57,text2:58,over:59,actor_pair:60,links:61,link:62,properties:63,details:64,spaceList:65,",":66,left_of:67,right_of:68,signaltype:69,"+":70,"-":71,"()":72,ACTOR:73,config_object:74,CONFIG_START:75,CONFIG_CONTENT:76,CONFIG_END:77,SOLID_OPEN_ARROW:78,DOTTED_OPEN_ARROW:79,SOLID_ARROW:80,SOLID_ARROW_TOP:81,SOLID_ARROW_BOTTOM:82,STICK_ARROW_TOP:83,STICK_ARROW_BOTTOM:84,SOLID_ARROW_TOP_DOTTED:85,SOLID_ARROW_BOTTOM_DOTTED:86,STICK_ARROW_TOP_DOTTED:87,STICK_ARROW_BOTTOM_DOTTED:88,SOLID_ARROW_TOP_REVERSE:89,SOLID_ARROW_BOTTOM_REVERSE:90,STICK_ARROW_TOP_REVERSE:91,STICK_ARROW_BOTTOM_REVERSE:92,SOLID_ARROW_TOP_REVERSE_DOTTED:93,SOLID_ARROW_BOTTOM_REVERSE_DOTTED:94,STICK_ARROW_TOP_REVERSE_DOTTED:95,STICK_ARROW_BOTTOM_REVERSE_DOTTED:96,BIDIRECTIONAL_SOLID_ARROW:97,DOTTED_ARROW:98,BIDIRECTIONAL_DOTTED_ARROW:99,SOLID_CROSS:100,DOTTED_CROSS:101,SOLID_POINT:102,DOTTED_POINT:103,TXT:104,$accept:0,$end:1},terminals_:{2:"error",4:"SPACE",5:"NEWLINE",6:"SD",10:"INVALID",14:"create",15:"box",16:"restOfLine",17:"end",19:"autonumber",20:"NUM",21:"off",22:"activate",24:"deactivate",30:"title",31:"legacy_title",32:"acc_title",33:"acc_title_value",34:"acc_descr",35:"acc_descr_value",36:"acc_descr_multiline_value",37:"loop",38:"rect",39:"opt",40:"alt",42:"par",44:"par_over",45:"critical",47:"break",48:"option",49:"and",50:"else",51:"participant",52:"AS",53:"participant_actor",54:"destroy",56:"note",59:"over",61:"links",62:"link",63:"properties",64:"details",66:",",67:"left_of",68:"right_of",70:"+",71:"-",72:"()",73:"ACTOR",75:"CONFIG_START",76:"CONFIG_CONTENT",77:"CONFIG_END",78:"SOLID_OPEN_ARROW",79:"DOTTED_OPEN_ARROW",80:"SOLID_ARROW",81:"SOLID_ARROW_TOP",82:"SOLID_ARROW_BOTTOM",83:"STICK_ARROW_TOP",84:"STICK_ARROW_BOTTOM",85:"SOLID_ARROW_TOP_DOTTED",86:"SOLID_ARROW_BOTTOM_DOTTED",87:"STICK_ARROW_TOP_DOTTED",88:"STICK_ARROW_BOTTOM_DOTTED",89:"SOLID_ARROW_TOP_REVERSE",90:"SOLID_ARROW_BOTTOM_REVERSE",91:"STICK_ARROW_TOP_REVERSE",92:"STICK_ARROW_BOTTOM_REVERSE",93:"SOLID_ARROW_TOP_REVERSE_DOTTED",94:"SOLID_ARROW_BOTTOM_REVERSE_DOTTED",95:"STICK_ARROW_TOP_REVERSE_DOTTED",96:"STICK_ARROW_BOTTOM_REVERSE_DOTTED",97:"BIDIRECTIONAL_SOLID_ARROW",98:"DOTTED_ARROW",99:"BIDIRECTIONAL_DOTTED_ARROW",100:"SOLID_CROSS",101:"DOTTED_CROSS",102:"SOLID_POINT",103:"DOTTED_POINT",104:"TXT"},productions_:[0,[3,2],[3,2],[3,2],[7,0],[7,2],[8,2],[8,1],[8,1],[8,1],[11,0],[11,2],[12,2],[12,1],[12,1],[9,1],[9,2],[9,4],[9,2],[9,4],[9,3],[9,3],[9,2],[9,3],[9,3],[9,2],[9,2],[9,2],[9,2],[9,2],[9,1],[9,1],[9,2],[9,2],[9,1],[9,4],[9,4],[9,4],[9,4],[9,4],[9,4],[9,4],[9,4],[46,1],[46,4],[43,1],[43,4],[41,1],[41,4],[13,5],[13,3],[13,5],[13,3],[13,3],[13,5],[13,3],[13,5],[13,3],[25,4],[25,4],[26,3],[27,3],[28,3],[29,3],[65,2],[65,1],[60,3],[60,1],[57,1],[57,1],[18,5],[18,5],[18,5],[18,5],[18,6],[18,4],[55,2],[74,3],[23,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[69,1],[58,1]],performAction:x(function(S,v,P,y,z,c,wt){var h=c.length-1;switch(z){case 3:return y.apply(c[h]),c[h];case 4:case 10:this.$=[];break;case 5:case 11:c[h-1].push(c[h]),this.$=c[h-1];break;case 6:case 7:case 12:case 13:this.$=c[h];break;case 8:case 9:case 14:this.$=[];break;case 16:c[h].type="createParticipant",this.$=c[h];break;case 17:c[h-1].unshift({type:"boxStart",boxData:y.parseBoxData(c[h-2])}),c[h-1].push({type:"boxEnd",boxText:c[h-2]}),this.$=c[h-1];break;case 19:this.$={type:"sequenceIndex",sequenceIndex:Number(c[h-2]),sequenceIndexStep:Number(c[h-1]),sequenceVisible:!0,signalType:y.LINETYPE.AUTONUMBER};break;case 20:this.$={type:"sequenceIndex",sequenceIndex:Number(c[h-1]),sequenceIndexStep:1,sequenceVisible:!0,signalType:y.LINETYPE.AUTONUMBER};break;case 21:this.$={type:"sequenceIndex",sequenceVisible:!1,signalType:y.LINETYPE.AUTONUMBER};break;case 22:this.$={type:"sequenceIndex",sequenceVisible:!0,signalType:y.LINETYPE.AUTONUMBER};break;case 23:this.$={type:"activeStart",signalType:y.LINETYPE.ACTIVE_START,actor:c[h-1].actor};break;case 24:this.$={type:"activeEnd",signalType:y.LINETYPE.ACTIVE_END,actor:c[h-1].actor};break;case 30:y.setDiagramTitle(c[h].substring(6)),this.$=c[h].substring(6);break;case 31:y.setDiagramTitle(c[h].substring(7)),this.$=c[h].substring(7);break;case 32:this.$=c[h].trim(),y.setAccTitle(this.$);break;case 33:case 34:this.$=c[h].trim(),y.setAccDescription(this.$);break;case 35:c[h-1].unshift({type:"loopStart",loopText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.LOOP_START}),c[h-1].push({type:"loopEnd",loopText:c[h-2],signalType:y.LINETYPE.LOOP_END}),this.$=c[h-1];break;case 36:c[h-1].unshift({type:"rectStart",color:y.parseMessage(c[h-2]),signalType:y.LINETYPE.RECT_START}),c[h-1].push({type:"rectEnd",color:y.parseMessage(c[h-2]),signalType:y.LINETYPE.RECT_END}),this.$=c[h-1];break;case 37:c[h-1].unshift({type:"optStart",optText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.OPT_START}),c[h-1].push({type:"optEnd",optText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.OPT_END}),this.$=c[h-1];break;case 38:c[h-1].unshift({type:"altStart",altText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.ALT_START}),c[h-1].push({type:"altEnd",signalType:y.LINETYPE.ALT_END}),this.$=c[h-1];break;case 39:c[h-1].unshift({type:"parStart",parText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.PAR_START}),c[h-1].push({type:"parEnd",signalType:y.LINETYPE.PAR_END}),this.$=c[h-1];break;case 40:c[h-1].unshift({type:"parStart",parText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.PAR_OVER_START}),c[h-1].push({type:"parEnd",signalType:y.LINETYPE.PAR_END}),this.$=c[h-1];break;case 41:c[h-1].unshift({type:"criticalStart",criticalText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.CRITICAL_START}),c[h-1].push({type:"criticalEnd",signalType:y.LINETYPE.CRITICAL_END}),this.$=c[h-1];break;case 42:c[h-1].unshift({type:"breakStart",breakText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.BREAK_START}),c[h-1].push({type:"breakEnd",optText:y.parseMessage(c[h-2]),signalType:y.LINETYPE.BREAK_END}),this.$=c[h-1];break;case 44:this.$=c[h-3].concat([{type:"option",optionText:y.parseMessage(c[h-1]),signalType:y.LINETYPE.CRITICAL_OPTION},c[h]]);break;case 46:this.$=c[h-3].concat([{type:"and",parText:y.parseMessage(c[h-1]),signalType:y.LINETYPE.PAR_AND},c[h]]);break;case 48:this.$=c[h-3].concat([{type:"else",altText:y.parseMessage(c[h-1]),signalType:y.LINETYPE.ALT_ELSE},c[h]]);break;case 49:c[h-3].draw="participant",c[h-3].type="addParticipant",c[h-3].description=y.parseMessage(c[h-1]),this.$=c[h-3];break;case 50:c[h-1].draw="participant",c[h-1].type="addParticipant",this.$=c[h-1];break;case 51:c[h-3].draw="actor",c[h-3].type="addParticipant",c[h-3].description=y.parseMessage(c[h-1]),this.$=c[h-3];break;case 52:case 57:c[h-1].draw="actor",c[h-1].type="addParticipant",this.$=c[h-1];break;case 53:c[h-1].type="destroyParticipant",this.$=c[h-1];break;case 54:c[h-3].draw="participant",c[h-3].type="addParticipant",c[h-3].description=y.parseMessage(c[h-1]),this.$=c[h-3];break;case 55:c[h-1].draw="participant",c[h-1].type="addParticipant",this.$=c[h-1];break;case 56:c[h-3].draw="actor",c[h-3].type="addParticipant",c[h-3].description=y.parseMessage(c[h-1]),this.$=c[h-3];break;case 58:this.$=[c[h-1],{type:"addNote",placement:c[h-2],actor:c[h-1].actor,text:c[h]}];break;case 59:c[h-2]=[].concat(c[h-1],c[h-1]).slice(0,2),c[h-2][0]=c[h-2][0].actor,c[h-2][1]=c[h-2][1].actor,this.$=[c[h-1],{type:"addNote",placement:y.PLACEMENT.OVER,actor:c[h-2].slice(0,2),text:c[h]}];break;case 60:this.$=[c[h-1],{type:"addLinks",actor:c[h-1].actor,text:c[h]}];break;case 61:this.$=[c[h-1],{type:"addALink",actor:c[h-1].actor,text:c[h]}];break;case 62:this.$=[c[h-1],{type:"addProperties",actor:c[h-1].actor,text:c[h]}];break;case 63:this.$=[c[h-1],{type:"addDetails",actor:c[h-1].actor,text:c[h]}];break;case 66:this.$=[c[h-2],c[h]];break;case 67:this.$=c[h];break;case 68:this.$=y.PLACEMENT.LEFTOF;break;case 69:this.$=y.PLACEMENT.RIGHTOF;break;case 70:this.$=[c[h-4],c[h-1],{type:"addMessage",from:c[h-4].actor,to:c[h-1].actor,signalType:c[h-3],msg:c[h],activate:!0},{type:"activeStart",signalType:y.LINETYPE.ACTIVE_START,actor:c[h-1].actor}];break;case 71:this.$=[c[h-4],c[h-1],{type:"addMessage",from:c[h-4].actor,to:c[h-1].actor,signalType:c[h-3],msg:c[h]},{type:"activeEnd",signalType:y.LINETYPE.ACTIVE_END,actor:c[h-4].actor}];break;case 72:this.$=[c[h-4],c[h-1],{type:"addMessage",from:c[h-4].actor,to:c[h-1].actor,signalType:c[h-3],msg:c[h],activate:!0,centralConnection:y.LINETYPE.CENTRAL_CONNECTION},{type:"centralConnection",signalType:y.LINETYPE.CENTRAL_CONNECTION,actor:c[h-1].actor}];break;case 73:this.$=[c[h-4],c[h-1],{type:"addMessage",from:c[h-4].actor,to:c[h-1].actor,signalType:c[h-2],msg:c[h],activate:!1,centralConnection:y.LINETYPE.CENTRAL_CONNECTION_REVERSE},{type:"centralConnectionReverse",signalType:y.LINETYPE.CENTRAL_CONNECTION_REVERSE,actor:c[h-4].actor}];break;case 74:this.$=[c[h-5],c[h-1],{type:"addMessage",from:c[h-5].actor,to:c[h-1].actor,signalType:c[h-3],msg:c[h],activate:!0,centralConnection:y.LINETYPE.CENTRAL_CONNECTION_DUAL},{type:"centralConnection",signalType:y.LINETYPE.CENTRAL_CONNECTION,actor:c[h-1].actor},{type:"centralConnectionReverse",signalType:y.LINETYPE.CENTRAL_CONNECTION_REVERSE,actor:c[h-5].actor}];break;case 75:this.$=[c[h-3],c[h-1],{type:"addMessage",from:c[h-3].actor,to:c[h-1].actor,signalType:c[h-2],msg:c[h]}];break;case 76:this.$={type:"addParticipant",actor:c[h-1],config:c[h]};break;case 77:this.$=c[h-1].trim();break;case 78:this.$={type:"addParticipant",actor:c[h]};break;case 79:this.$=y.LINETYPE.SOLID_OPEN;break;case 80:this.$=y.LINETYPE.DOTTED_OPEN;break;case 81:this.$=y.LINETYPE.SOLID;break;case 82:this.$=y.LINETYPE.SOLID_TOP;break;case 83:this.$=y.LINETYPE.SOLID_BOTTOM;break;case 84:this.$=y.LINETYPE.STICK_TOP;break;case 85:this.$=y.LINETYPE.STICK_BOTTOM;break;case 86:this.$=y.LINETYPE.SOLID_TOP_DOTTED;break;case 87:this.$=y.LINETYPE.SOLID_BOTTOM_DOTTED;break;case 88:this.$=y.LINETYPE.STICK_TOP_DOTTED;break;case 89:this.$=y.LINETYPE.STICK_BOTTOM_DOTTED;break;case 90:this.$=y.LINETYPE.SOLID_ARROW_TOP_REVERSE;break;case 91:this.$=y.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE;break;case 92:this.$=y.LINETYPE.STICK_ARROW_TOP_REVERSE;break;case 93:this.$=y.LINETYPE.STICK_ARROW_BOTTOM_REVERSE;break;case 94:this.$=y.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED;break;case 95:this.$=y.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED;break;case 96:this.$=y.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED;break;case 97:this.$=y.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED;break;case 98:this.$=y.LINETYPE.BIDIRECTIONAL_SOLID;break;case 99:this.$=y.LINETYPE.DOTTED;break;case 100:this.$=y.LINETYPE.BIDIRECTIONAL_DOTTED;break;case 101:this.$=y.LINETYPE.SOLID_CROSS;break;case 102:this.$=y.LINETYPE.DOTTED_CROSS;break;case 103:this.$=y.LINETYPE.SOLID_POINT;break;case 104:this.$=y.LINETYPE.DOTTED_POINT;break;case 105:this.$=y.parseMessage(c[h].trim().substring(1));break}},"anonymous"),table:[{3:1,4:t,5:a,6:r},{1:[3]},{3:5,4:t,5:a,6:r},{3:6,4:t,5:a,6:r},e([1,4,5,10,14,15,19,22,24,30,31,32,34,36,37,38,39,40,42,44,45,47,51,53,54,56,61,62,63,64,73],i,{7:7}),{1:[2,1]},{1:[2,2]},{1:[2,3],4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},e(C,[2,5]),{9:48,13:13,14:u,15:d,18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},e(C,[2,7]),e(C,[2,8]),e(C,[2,9]),e(C,[2,15]),{13:49,51:U,53:G,54:X},{16:[1,50]},{5:[1,51]},{5:[1,54],20:[1,52],21:[1,53]},{23:55,73:Y},{23:56,73:Y},{5:[1,57]},{5:[1,58]},{5:[1,59]},{5:[1,60]},{5:[1,61]},e(C,[2,30]),e(C,[2,31]),{33:[1,62]},{35:[1,63]},e(C,[2,34]),{16:[1,64]},{16:[1,65]},{16:[1,66]},{16:[1,67]},{16:[1,68]},{16:[1,69]},{16:[1,70]},{16:[1,71]},{23:72,55:73,73:At},{23:75,55:76,73:At},{23:77,73:Y},{69:78,72:[1,79],78:kt,79:m,80:k,81:lt,82:et,83:K,84:Ot,85:ne,86:oe,87:ce,88:le,89:he,90:de,91:Te,92:pe,93:Ee,94:ue,95:fe,96:_e,97:ge,98:xe,99:Ie,100:ye,101:Re,102:Oe,103:Le},{57:106,59:[1,107],67:[1,108],68:[1,109]},{23:110,73:Y},{23:111,73:Y},{23:112,73:Y},{23:113,73:Y},e([5,66,72,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104],be),e(C,[2,6]),e(C,[2,16]),e(St,[2,10],{11:114}),e(C,[2,18]),{5:[1,116],20:[1,115]},{5:[1,117]},e(C,[2,22]),{5:[1,118]},{5:[1,119]},e(C,[2,25]),e(C,[2,26]),e(C,[2,27]),e(C,[2,28]),e(C,[2,29]),e(C,[2,32]),e(C,[2,33]),e(Dt,i,{7:120}),e(Dt,i,{7:121}),e(Dt,i,{7:122}),e(me,i,{41:123,7:124}),e(Ut,i,{43:125,7:126}),e(Ut,i,{7:126,43:127}),e(Ae,i,{46:128,7:129}),e(Dt,i,{7:130}),{5:[1,132],52:[1,131]},{5:[1,134],52:[1,133]},e(Gt,be,{74:135,75:[1,136]}),{5:[1,138],52:[1,137]},{5:[1,140],52:[1,139]},{5:[1,141]},{23:145,70:[1,142],71:[1,143],72:[1,144],73:Y},{69:146,78:kt,79:m,80:k,81:lt,82:et,83:K,84:Ot,85:ne,86:oe,87:ce,88:le,89:he,90:de,91:Te,92:pe,93:Ee,94:ue,95:fe,96:_e,97:ge,98:xe,99:Ie,100:ye,101:Re,102:Oe,103:Le},e(F,[2,79]),e(F,[2,80]),e(F,[2,81]),e(F,[2,82]),e(F,[2,83]),e(F,[2,84]),e(F,[2,85]),e(F,[2,86]),e(F,[2,87]),e(F,[2,88]),e(F,[2,89]),e(F,[2,90]),e(F,[2,91]),e(F,[2,92]),e(F,[2,93]),e(F,[2,94]),e(F,[2,95]),e(F,[2,96]),e(F,[2,97]),e(F,[2,98]),e(F,[2,99]),e(F,[2,100]),e(F,[2,101]),e(F,[2,102]),e(F,[2,103]),e(F,[2,104]),{23:147,73:Y},{23:149,60:148,73:Y},{73:[2,68]},{73:[2,69]},{58:150,104:ot},{58:152,104:ot},{58:153,104:ot},{58:154,104:ot},{4:[1,157],5:[1,159],12:156,13:158,17:[1,155],51:U,53:G,54:X},{5:[1,160]},e(C,[2,20]),e(C,[2,21]),e(C,[2,23]),e(C,[2,24]),{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[1,161],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[1,162],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[1,163],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{17:[1,164]},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[2,47],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,50:[1,165],51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{17:[1,166]},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[2,45],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,49:[1,167],51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{17:[1,168]},{17:[1,169]},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[2,43],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,48:[1,170],51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{4:n,5:s,8:8,9:10,10:o,13:13,14:u,15:d,17:[1,171],18:16,19:p,22:_,23:41,24:E,25:20,26:21,27:22,28:23,29:24,30:O,31:T,32:g,34:f,36:I,37:L,38:b,39:w,40:A,42:D,44:M,45:V,47:W,51:U,53:G,54:X,56:nt,61:j,62:H,63:st,64:tt,73:Y},{16:[1,172]},e(C,[2,50]),{16:[1,173]},e(C,[2,55]),e(Gt,[2,76]),{76:[1,174]},{16:[1,175]},e(C,[2,52]),{16:[1,176]},e(C,[2,57]),e(C,[2,53]),{23:177,73:Y},{23:178,73:Y},{23:179,73:Y},{58:180,104:ot},{23:181,72:[1,182],73:Y},{58:183,104:ot},{58:184,104:ot},{66:[1,185],104:[2,67]},{5:[2,60]},{5:[2,105]},{5:[2,61]},{5:[2,62]},{5:[2,63]},e(C,[2,17]),e(St,[2,11]),{13:186,51:U,53:G,54:X},e(St,[2,13]),e(St,[2,14]),e(C,[2,19]),e(C,[2,35]),e(C,[2,36]),e(C,[2,37]),e(C,[2,38]),{16:[1,187]},e(C,[2,39]),{16:[1,188]},e(C,[2,40]),e(C,[2,41]),{16:[1,189]},e(C,[2,42]),{5:[1,190]},{5:[1,191]},{77:[1,192]},{5:[1,193]},{5:[1,194]},{58:195,104:ot},{58:196,104:ot},{58:197,104:ot},{5:[2,75]},{58:198,104:ot},{23:199,73:Y},{5:[2,58]},{5:[2,59]},{23:200,73:Y},e(St,[2,12]),e(me,i,{7:124,41:201}),e(Ut,i,{7:126,43:202}),e(Ae,i,{7:129,46:203}),e(C,[2,49]),e(C,[2,54]),e(Gt,[2,77]),e(C,[2,51]),e(C,[2,56]),{5:[2,70]},{5:[2,71]},{5:[2,72]},{5:[2,73]},{58:204,104:ot},{104:[2,66]},{17:[2,48]},{17:[2,46]},{17:[2,44]},{5:[2,74]}],defaultActions:{5:[2,1],6:[2,2],108:[2,68],109:[2,69],150:[2,60],151:[2,105],152:[2,61],153:[2,62],154:[2,63],180:[2,75],183:[2,58],184:[2,59],195:[2,70],196:[2,71],197:[2,72],198:[2,73],200:[2,66],201:[2,48],202:[2,46],203:[2,44],204:[2,74]},parseError:x(function(S,v){if(v.recoverable)this.trace(S);else{var P=new Error(S);throw P.hash=v,P}},"parseError"),parse:x(function(S){var v=this,P=[0],y=[],z=[null],c=[],wt=this.table,h="",Ct=0,Se=0,Ze=2,we=1,Qe=c.slice.call(arguments,1),J=Object.create(this.lexer),gt={yy:{}};for(var Jt in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Jt)&&(gt.yy[Jt]=this.yy[Jt]);J.setInput(S,gt.yy),gt.yy.lexer=J,gt.yy.parser=this,typeof J.yylloc>"u"&&(J.yylloc={});var Zt=J.yylloc;c.push(Zt);var $e=J.options&&J.options.ranges;typeof gt.yy.parseError=="function"?this.parseError=gt.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function je(it){P.length=P.length-2*it,z.length=z.length-it,c.length=c.length-it}x(je,"popStack");function Ne(){var it;return it=y.pop()||J.lex()||we,typeof it!="number"&&(it instanceof Array&&(y=it,it=y.pop()),it=v.symbols_[it]||it),it}x(Ne,"lex");for(var rt,xt,ct,Qt,Lt={},Mt,Tt,Pe,Bt;;){if(xt=P[P.length-1],this.defaultActions[xt]?ct=this.defaultActions[xt]:((rt===null||typeof rt>"u")&&(rt=Ne()),ct=wt[xt]&&wt[xt][rt]),typeof ct>"u"||!ct.length||!ct[0]){var $t="";Bt=[];for(Mt in wt[xt])this.terminals_[Mt]&&Mt>Ze&&Bt.push("'"+this.terminals_[Mt]+"'");J.showPosition?$t="Parse error on line "+(Ct+1)+`: +`+J.showPosition()+` +Expecting `+Bt.join(", ")+", got '"+(this.terminals_[rt]||rt)+"'":$t="Parse error on line "+(Ct+1)+": Unexpected "+(rt==we?"end of input":"'"+(this.terminals_[rt]||rt)+"'"),this.parseError($t,{text:J.match,token:this.terminals_[rt]||rt,line:J.yylineno,loc:Zt,expected:Bt})}if(ct[0]instanceof Array&&ct.length>1)throw new Error("Parse Error: multiple actions possible at state: "+xt+", token: "+rt);switch(ct[0]){case 1:P.push(rt),z.push(J.yytext),c.push(J.yylloc),P.push(ct[1]),rt=null,Se=J.yyleng,h=J.yytext,Ct=J.yylineno,Zt=J.yylloc;break;case 2:if(Tt=this.productions_[ct[1]][1],Lt.$=z[z.length-Tt],Lt._$={first_line:c[c.length-(Tt||1)].first_line,last_line:c[c.length-1].last_line,first_column:c[c.length-(Tt||1)].first_column,last_column:c[c.length-1].last_column},$e&&(Lt._$.range=[c[c.length-(Tt||1)].range[0],c[c.length-1].range[1]]),Qt=this.performAction.apply(Lt,[h,Se,Ct,gt.yy,ct[1],z,c].concat(Qe)),typeof Qt<"u")return Qt;Tt&&(P=P.slice(0,-1*Tt*2),z=z.slice(0,-1*Tt),c=c.slice(0,-1*Tt)),P.push(this.productions_[ct[1]][0]),z.push(Lt.$),c.push(Lt._$),Pe=wt[P[P.length-2]][P[P.length-1]],P.push(Pe);break;case 3:return!0}}return!0},"parse")},Je=(function(){var ut={EOF:1,parseError:x(function(v,P){if(this.yy.parser)this.yy.parser.parseError(v,P);else throw new Error(v)},"parseError"),setInput:x(function(S,v){return this.yy=v||this.yy||{},this._input=S,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:x(function(){var S=this._input[0];this.yytext+=S,this.yyleng++,this.offset++,this.match+=S,this.matched+=S;var v=S.match(/(?:\r\n?|\n).*/g);return v?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),S},"input"),unput:x(function(S){var v=S.length,P=S.split(/(?:\r\n?|\n)/g);this._input=S+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-v),this.offset-=v;var y=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),P.length-1&&(this.yylineno-=P.length-1);var z=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:P?(P.length===y.length?this.yylloc.first_column:0)+y[y.length-P.length].length-P[0].length:this.yylloc.first_column-v},this.options.ranges&&(this.yylloc.range=[z[0],z[0]+this.yyleng-v]),this.yyleng=this.yytext.length,this},"unput"),more:x(function(){return this._more=!0,this},"more"),reject:x(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:x(function(S){this.unput(this.match.slice(S))},"less"),pastInput:x(function(){var S=this.matched.substr(0,this.matched.length-this.match.length);return(S.length>20?"...":"")+S.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:x(function(){var S=this.match;return S.length<20&&(S+=this._input.substr(0,20-S.length)),(S.substr(0,20)+(S.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:x(function(){var S=this.pastInput(),v=new Array(S.length+1).join("-");return S+this.upcomingInput()+` +`+v+"^"},"showPosition"),test_match:x(function(S,v){var P,y,z;if(this.options.backtrack_lexer&&(z={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(z.yylloc.range=this.yylloc.range.slice(0))),y=S[0].match(/(?:\r\n?|\n).*/g),y&&(this.yylineno+=y.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:y?y[y.length-1].length-y[y.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+S[0].length},this.yytext+=S[0],this.match+=S[0],this.matches=S,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(S[0].length),this.matched+=S[0],P=this.performAction.call(this,this.yy,this,v,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),P)return P;if(this._backtrack){for(var c in z)this[c]=z[c];return!1}return!1},"test_match"),next:x(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var S,v,P,y;this._more||(this.yytext="",this.match="");for(var z=this._currentRules(),c=0;cv[0].length)){if(v=P,y=c,this.options.backtrack_lexer){if(S=this.test_match(P,z[c]),S!==!1)return S;if(this._backtrack){v=!1;continue}else return!1}else if(!this.options.flex)break}return v?(S=this.test_match(v,z[y]),S!==!1?S:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:x(function(){var v=this.next();return v||this.lex()},"lex"),begin:x(function(v){this.conditionStack.push(v)},"begin"),popState:x(function(){var v=this.conditionStack.length-1;return v>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:x(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:x(function(v){return v=this.conditionStack.length-1-Math.abs(v||0),v>=0?this.conditionStack[v]:"INITIAL"},"topState"),pushState:x(function(v){this.begin(v)},"pushState"),stateStackSize:x(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:x(function(v,P,y,z){switch(y){case 0:return 5;case 1:break;case 2:break;case 3:break;case 4:break;case 5:break;case 6:return 20;case 7:return this.begin("CONFIG"),75;case 8:return 76;case 9:return this.popState(),this.begin("ALIAS"),77;case 10:return this.popState(),this.popState(),77;case 11:return P.yytext=P.yytext.trim(),73;case 12:return P.yytext=P.yytext.trim(),this.begin("ALIAS"),73;case 13:return P.yytext=P.yytext.trim(),this.popState(),73;case 14:return this.popState(),10;case 15:return P.yytext=P.yytext.trim(),this.popState(),10;case 16:return this.begin("LINE"),15;case 17:return this.begin("ID"),51;case 18:return this.begin("ID"),53;case 19:return 14;case 20:return this.begin("ID"),54;case 21:return this.popState(),this.popState(),this.begin("LINE"),52;case 22:return this.popState(),this.popState(),5;case 23:return this.begin("LINE"),37;case 24:return this.begin("LINE"),38;case 25:return this.begin("LINE"),39;case 26:return this.begin("LINE"),40;case 27:return this.begin("LINE"),50;case 28:return this.begin("LINE"),42;case 29:return this.begin("LINE"),44;case 30:return this.begin("LINE"),49;case 31:return this.begin("LINE"),45;case 32:return this.begin("LINE"),48;case 33:return this.begin("LINE"),47;case 34:return this.popState(),16;case 35:return 17;case 36:return 67;case 37:return 68;case 38:return 61;case 39:return 62;case 40:return 63;case 41:return 64;case 42:return 59;case 43:return 56;case 44:return this.begin("ID"),22;case 45:return this.begin("ID"),24;case 46:return 30;case 47:return 31;case 48:return this.begin("acc_title"),32;case 49:return this.popState(),"acc_title_value";case 50:return this.begin("acc_descr"),34;case 51:return this.popState(),"acc_descr_value";case 52:this.begin("acc_descr_multiline");break;case 53:this.popState();break;case 54:return"acc_descr_multiline_value";case 55:return 6;case 56:return 19;case 57:return 21;case 58:return 66;case 59:return 5;case 60:return P.yytext=P.yytext.trim(),73;case 61:return 80;case 62:return 97;case 63:return 98;case 64:return 99;case 65:return 78;case 66:return 79;case 67:return 100;case 68:return 101;case 69:return 102;case 70:return 103;case 71:return 85;case 72:return 86;case 73:return 87;case 74:return 88;case 75:return 93;case 76:return 94;case 77:return 95;case 78:return 96;case 79:return 81;case 80:return 82;case 81:return 83;case 82:return 84;case 83:return 89;case 84:return 90;case 85:return 91;case 86:return 92;case 87:return 104;case 88:return 104;case 89:return 70;case 90:return 71;case 91:return 72;case 92:return 5;case 93:return 10}},"anonymous"),rules:[/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?:((?!\n)\s)+)/i,/^(?:#[^\n]*)/i,/^(?:%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:([0-9]+(\.[0-9]{1,2})?|\.[0-9]{1,2})(?=[ \n]+))/i,/^(?:@\{)/i,/^(?:[^\}]+)/i,/^(?:\}(?=\s+as\s))/i,/^(?:\})/i,/^(?:[^\<->\->:\n,;@\s]+(?=@\{))/i,/^(?:[^<>:\n,;@\s]+(?=\s+as\s))/i,/^(?:[^<>:\n,;@]+(?=\s*[\n;#]|$))/i,/^(?:[^<>:\n,;@]*<[^\n]*)/i,/^(?:[^\n]+)/i,/^(?:box\b)/i,/^(?:participant\b)/i,/^(?:actor\b)/i,/^(?:create\b)/i,/^(?:destroy\b)/i,/^(?:as\b)/i,/^(?:(?:))/i,/^(?:loop\b)/i,/^(?:rect\b)/i,/^(?:opt\b)/i,/^(?:alt\b)/i,/^(?:else\b)/i,/^(?:par\b)/i,/^(?:par_over\b)/i,/^(?:and\b)/i,/^(?:critical\b)/i,/^(?:option\b)/i,/^(?:break\b)/i,/^(?:(?:[:]?(?:no)?wrap)?[^#\n;]*)/i,/^(?:end\b)/i,/^(?:left of\b)/i,/^(?:right of\b)/i,/^(?:links\b)/i,/^(?:link\b)/i,/^(?:properties\b)/i,/^(?:details\b)/i,/^(?:over\b)/i,/^(?:note\b)/i,/^(?:activate\b)/i,/^(?:deactivate\b)/i,/^(?:title\s[^#\n;]+)/i,/^(?:title:\s[^#\n;]+)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:sequenceDiagram\b)/i,/^(?:autonumber\b)/i,/^(?:off\b)/i,/^(?:,)/i,/^(?:;)/i,/^(?:[^\/\\\+\()\+<\->\->:\n,;]+((?!(-x|--x|-\)|--\)|-\|\\|-\\|-\/|-\/\/|-\|\/|\/\|-|\\\|-|\/\/-|\\\\-|\/\|-|--\|\\|--|\(\)))[\-]*[^\+<\->\->:\n,;]+)*)/i,/^(?:->>)/i,/^(?:<<->>)/i,/^(?:-->>)/i,/^(?:<<-->>)/i,/^(?:->)/i,/^(?:-->)/i,/^(?:-[x])/i,/^(?:--[x])/i,/^(?:-[\)])/i,/^(?:--[\)])/i,/^(?:--\|\\)/i,/^(?:--\|\/)/i,/^(?:--\\\\)/i,/^(?:--\/\/)/i,/^(?:\/\|--)/i,/^(?:\\\|--)/i,/^(?:\/\/--)/i,/^(?:\\\\--)/i,/^(?:-\|\\)/i,/^(?:-\|\/)/i,/^(?:-\\\\)/i,/^(?:-\/\/)/i,/^(?:\/\|-)/i,/^(?:\\\|-)/i,/^(?:\/\/-)/i,/^(?:\\\\-)/i,/^(?::(?:(?:no)?wrap)?[^#\n;]*)/i,/^(?::)/i,/^(?:\+)/i,/^(?:-)/i,/^(?:\(\))/i,/^(?:$)/i,/^(?:.)/i],conditions:{acc_descr_multiline:{rules:[53,54],inclusive:!1},acc_descr:{rules:[51],inclusive:!1},acc_title:{rules:[49],inclusive:!1},ID:{rules:[2,3,7,11,12,13,14,15],inclusive:!1},ALIAS:{rules:[2,3,21,22],inclusive:!1},LINE:{rules:[2,3,34],inclusive:!1},CONFIG:{rules:[8,9,10],inclusive:!1},CONFIG_DATA:{rules:[],inclusive:!1},INITIAL:{rules:[0,1,3,4,5,6,16,17,18,19,20,23,24,25,26,27,28,29,30,31,32,33,35,36,37,38,39,40,41,42,43,44,45,46,47,48,50,52,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93],inclusive:!0}}};return ut})();Xt.lexer=Je;function vt(){this.yy={}}return x(vt,"Parser"),vt.prototype=Xt,Xt.Parser=vt,new vt})();te.parser=te;var fr=te,_r={SOLID:0,DOTTED:1,NOTE:2,SOLID_CROSS:3,DOTTED_CROSS:4,SOLID_OPEN:5,DOTTED_OPEN:6,LOOP_START:10,LOOP_END:11,ALT_START:12,ALT_ELSE:13,ALT_END:14,OPT_START:15,OPT_END:16,ACTIVE_START:17,ACTIVE_END:18,PAR_START:19,PAR_AND:20,PAR_END:21,RECT_START:22,RECT_END:23,SOLID_POINT:24,DOTTED_POINT:25,AUTONUMBER:26,CRITICAL_START:27,CRITICAL_OPTION:28,CRITICAL_END:29,BREAK_START:30,BREAK_END:31,PAR_OVER_START:32,BIDIRECTIONAL_SOLID:33,BIDIRECTIONAL_DOTTED:34,SOLID_TOP:41,SOLID_BOTTOM:42,STICK_TOP:43,STICK_BOTTOM:44,SOLID_ARROW_TOP_REVERSE:45,SOLID_ARROW_BOTTOM_REVERSE:46,STICK_ARROW_TOP_REVERSE:47,STICK_ARROW_BOTTOM_REVERSE:48,SOLID_TOP_DOTTED:51,SOLID_BOTTOM_DOTTED:52,STICK_TOP_DOTTED:53,STICK_BOTTOM_DOTTED:54,SOLID_ARROW_TOP_REVERSE_DOTTED:55,SOLID_ARROW_BOTTOM_REVERSE_DOTTED:56,STICK_ARROW_TOP_REVERSE_DOTTED:57,STICK_ARROW_BOTTOM_REVERSE_DOTTED:58,CENTRAL_CONNECTION:59,CENTRAL_CONNECTION_REVERSE:60,CENTRAL_CONNECTION_DUAL:61},gr={FILLED:0,OPEN:1},xr={LEFTOF:0,RIGHTOF:1,OVER:2},Wt={ACTOR:"actor",CONTROL:"control",DATABASE:"database",ENTITY:"entity"},Ir=class{constructor(){this.state=new tr(()=>({prevActor:void 0,actors:new Map,createdActors:new Map,destroyedActors:new Map,boxes:[],messages:[],notes:[],sequenceNumbersEnabled:!1,wrapEnabled:void 0,currentBox:void 0,lastCreated:void 0,lastDestroyed:void 0})),this.setAccTitle=ke,this.setAccDescription=sr,this.setDiagramTitle=ir,this.getAccTitle=nr,this.getAccDescription=or,this.getDiagramTitle=cr,this.apply=this.apply.bind(this),this.parseBoxData=this.parseBoxData.bind(this),this.parseMessage=this.parseMessage.bind(this),this.clear(),this.setWrap($().wrap),this.LINETYPE=_r,this.ARROWTYPE=gr,this.PLACEMENT=xr}static{x(this,"SequenceDB")}addBox(e){this.state.records.boxes.push({name:e.text,wrap:e.wrap??this.autoWrap(),fill:e.color,actorKeys:[]}),this.state.records.currentBox=this.state.records.boxes.slice(-1)[0]}addActor(e,t,a,r,i){let n=this.state.records.currentBox,s;if(i!==void 0){let u;i.includes(` +`)?u=i+` +`:u=`{ +`+i+` +}`,s=lr(u,{schema:hr})}r=s?.type??r,s?.alias&&(!a||a.text===t)&&(a={text:s.alias,wrap:a?.wrap,type:r});const o=this.state.records.actors.get(e);if(o){if(this.state.records.currentBox&&o.box&&this.state.records.currentBox!==o.box)throw new Error(`A same participant should only be defined in one Box: ${o.name} can't be in '${o.box.name}' and in '${this.state.records.currentBox.name}' at the same time.`);if(n=o.box?o.box:this.state.records.currentBox,o.box=n,o&&t===o.name&&a==null)return}if(a?.text==null&&(a={text:t,type:r}),(r==null||a.text==null)&&(a={text:t,type:r}),this.state.records.actors.set(e,{box:n,name:t,description:a.text,wrap:a.wrap??this.autoWrap(),prevActor:this.state.records.prevActor,links:{},properties:{},actorCnt:null,rectData:null,type:r??"participant"}),this.state.records.prevActor){const u=this.state.records.actors.get(this.state.records.prevActor);u&&(u.nextActor=e)}this.state.records.currentBox&&this.state.records.currentBox.actorKeys.push(e),this.state.records.prevActor=e}activationCount(e){let t,a=0;if(!e)return 0;for(t=0;t>-",token:"->>-",line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["'ACTIVE_PARTICIPANT'"]},o}return this.state.records.messages.push({id:this.state.records.messages.length.toString(),from:e,to:t,message:a?.text??"",wrap:a?.wrap??this.autoWrap(),type:r,activate:i,centralConnection:n??0}),!0}hasAtLeastOneBox(){return this.state.records.boxes.length>0}hasAtLeastOneBoxWithTitle(){return this.state.records.boxes.some(e=>e.name)}getMessages(){return this.state.records.messages}getBoxes(){return this.state.records.boxes}getActors(){return this.state.records.actors}getCreatedActors(){return this.state.records.createdActors}getDestroyedActors(){return this.state.records.destroyedActors}getActor(e){return this.state.records.actors.get(e)}getActorKeys(){return[...this.state.records.actors.keys()]}enableSequenceNumbers(){this.state.records.sequenceNumbersEnabled=!0}disableSequenceNumbers(){this.state.records.sequenceNumbersEnabled=!1}showSequenceNumbers(){return this.state.records.sequenceNumbersEnabled}setWrap(e){this.state.records.wrapEnabled=e}extractWrap(e){if(e===void 0)return{};e=e.trim();const t=/^:?wrap:/.exec(e)!==null?!0:/^:?nowrap:/.exec(e)!==null?!1:void 0;return{cleanedText:(t===void 0?e:e.replace(/^:?(?:no)?wrap:/,"")).trim(),wrap:t}}autoWrap(){return this.state.records.wrapEnabled!==void 0?this.state.records.wrapEnabled:$().sequence?.wrap??!1}clear(){this.state.reset(),dr()}parseMessage(e){const t=e.trim(),{wrap:a,cleanedText:r}=this.extractWrap(t),i={text:r,wrap:a};return at.debug(`parseMessage: ${JSON.stringify(i)}`),i}parseBoxData(e){const t=/^((?:rgba?|hsla?)\s*\(.*\)|\w*)(.*)$/.exec(e);let a=t?.[1]?t[1].trim():"transparent",r=t?.[2]?t[2].trim():void 0;if(window?.CSS)window.CSS.supports("color",a)||(a="transparent",r=e.trim());else{const s=new Option().style;s.color=a,s.color!==a&&(a="transparent",r=e.trim())}const{wrap:i,cleanedText:n}=this.extractWrap(r);return{text:n?Yt(n,$()):void 0,color:a,wrap:i}}addNote(e,t,a){const r={actor:e,placement:t,message:a.text,wrap:a.wrap??this.autoWrap()},i=[].concat(e,e);this.state.records.notes.push(r),this.state.records.messages.push({id:this.state.records.messages.length.toString(),from:i[0],to:i[1],message:a.text,wrap:a.wrap??this.autoWrap(),type:this.LINETYPE.NOTE,placement:t})}addLinks(e,t){const a=this.getActor(e);try{let r=Yt(t.text,$());r=r.replace(/=/g,"="),r=r.replace(/&/g,"&");const i=JSON.parse(r);this.insertLinks(a,i)}catch(r){at.error("error while parsing actor link text",r)}}addALink(e,t){const a=this.getActor(e);try{const r={};let i=Yt(t.text,$());const n=i.indexOf("@");i=i.replace(/=/g,"="),i=i.replace(/&/g,"&");const s=i.slice(0,n-1).trim(),o=i.slice(n+1).trim();r[s]=o,this.insertLinks(a,r)}catch(r){at.error("error while parsing actor link text",r)}}insertLinks(e,t){if(e.links==null)e.links=t;else for(const a in t)e.links[a]=t[a]}addProperties(e,t){const a=this.getActor(e);try{const r=Yt(t.text,$()),i=JSON.parse(r);this.insertProperties(a,i)}catch(r){at.error("error while parsing actor properties text",r)}}insertProperties(e,t){if(e.properties==null)e.properties=t;else for(const a in t)e.properties[a]=t[a]}boxEnd(){this.state.records.currentBox=void 0}addDetails(e,t){const a=this.getActor(e),r=document.getElementById(t.text);try{const i=r.innerHTML,n=JSON.parse(i);n.properties&&this.insertProperties(a,n.properties),n.links&&this.insertLinks(a,n.links)}catch(i){at.error("error while parsing actor details text",i)}}getActorProperty(e,t){if(e?.properties!==void 0)return e.properties[t]}apply(e){if(Array.isArray(e))e.forEach(t=>{this.apply(t)});else switch(e.type){case"sequenceIndex":this.state.records.messages.push({id:this.state.records.messages.length.toString(),from:void 0,to:void 0,message:{start:e.sequenceIndex,step:e.sequenceIndexStep,visible:e.sequenceVisible},wrap:!1,type:e.signalType});break;case"addParticipant":this.addActor(e.actor,e.actor,e.description,e.draw,e.config);break;case"createParticipant":if(this.state.records.actors.has(e.actor))throw new Error("It is not possible to have actors with the same id, even if one is destroyed before the next is created. Use 'AS' aliases to simulate the behavior");this.state.records.lastCreated=e.actor,this.addActor(e.actor,e.actor,e.description,e.draw,e.config),this.state.records.createdActors.set(e.actor,this.state.records.messages.length);break;case"destroyParticipant":this.state.records.lastDestroyed=e.actor,this.state.records.destroyedActors.set(e.actor,this.state.records.messages.length);break;case"activeStart":this.addSignal(e.actor,void 0,void 0,e.signalType);break;case"centralConnection":this.addSignal(e.actor,void 0,void 0,e.signalType);break;case"centralConnectionReverse":this.addSignal(e.actor,void 0,void 0,e.signalType);break;case"activeEnd":this.addSignal(e.actor,void 0,void 0,e.signalType);break;case"addNote":this.addNote(e.actor,e.placement,e.text);break;case"addLinks":this.addLinks(e.actor,e.text);break;case"addALink":this.addALink(e.actor,e.text);break;case"addProperties":this.addProperties(e.actor,e.text);break;case"addDetails":this.addDetails(e.actor,e.text);break;case"addMessage":if(this.state.records.lastCreated){if(e.to!==this.state.records.lastCreated)throw new Error("The created participant "+this.state.records.lastCreated.name+" does not have an associated creating message after its declaration. Please check the sequence diagram.");this.state.records.lastCreated=void 0}else if(this.state.records.lastDestroyed){if(e.to!==this.state.records.lastDestroyed&&e.from!==this.state.records.lastDestroyed)throw new Error("The destroyed participant "+this.state.records.lastDestroyed.name+" does not have an associated destroying message after its declaration. Please check the sequence diagram.");this.state.records.lastDestroyed=void 0}this.addSignal(e.from,e.to,e.msg,e.signalType,e.activate,e.centralConnection);break;case"boxStart":this.addBox(e.boxData);break;case"boxEnd":this.boxEnd();break;case"loopStart":this.addSignal(void 0,void 0,e.loopText,e.signalType);break;case"loopEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"rectStart":this.addSignal(void 0,void 0,e.color,e.signalType);break;case"rectEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"optStart":this.addSignal(void 0,void 0,e.optText,e.signalType);break;case"optEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"altStart":this.addSignal(void 0,void 0,e.altText,e.signalType);break;case"else":this.addSignal(void 0,void 0,e.altText,e.signalType);break;case"altEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"setAccTitle":ke(e.text);break;case"parStart":this.addSignal(void 0,void 0,e.parText,e.signalType);break;case"and":this.addSignal(void 0,void 0,e.parText,e.signalType);break;case"parEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"criticalStart":this.addSignal(void 0,void 0,e.criticalText,e.signalType);break;case"option":this.addSignal(void 0,void 0,e.optionText,e.signalType);break;case"criticalEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break;case"breakStart":this.addSignal(void 0,void 0,e.breakText,e.signalType);break;case"breakEnd":this.addSignal(void 0,void 0,void 0,e.signalType);break}}getConfig(){return $().sequence}},yr=x(e=>{const t=e.dropShadow??"none",{look:a}=$();return`.actor { + stroke: ${e.actorBorder}; + fill: ${e.actorBkg}; + stroke-width: ${e.strokeWidth??1}; + } + + rect.actor.outer-path[data-look="neo"] { + filter: ${t}; + } + + rect.note[data-look="neo"] { + stroke:${e.noteBorderColor}; + fill:${e.noteBkgColor}; + filter: ${t}; + } + + text.actor > tspan { + fill: ${e.actorTextColor}; + stroke: none; + } + + .actor-line { + stroke: ${e.actorLineColor}; + } + + .innerArc { + stroke-width: 1.5; + stroke-dasharray: none; + } + + .messageLine0 { + stroke-width: 1.5; + stroke-dasharray: none; + stroke: ${e.signalColor}; + } + + .messageLine1 { + stroke-width: 1.5; + stroke-dasharray: 2, 2; + stroke: ${e.signalColor}; + } + + [id$="-arrowhead"] path { + fill: ${e.signalColor}; + stroke: ${e.signalColor}; + } + + .sequenceNumber { + fill: ${e.sequenceNumberColor}; + } + + [id$="-sequencenumber"] { + fill: ${e.signalColor}; + } + + [id$="-crosshead"] path { + fill: ${e.signalColor}; + stroke: ${e.signalColor}; + } + + .messageText { + fill: ${e.signalTextColor}; + stroke: none; + } + + .labelBox { + stroke: ${e.labelBoxBorderColor}; + fill: ${e.labelBoxBkgColor}; + filter: ${a==="neo"?t:"none"}; + } + + .labelText, .labelText > tspan { + fill: ${e.labelTextColor}; + stroke: none; + } + + .loopText, .loopText > tspan { + fill: ${e.loopTextColor}; + stroke: none; + } + + .sectionTitle, .sectionTitle > tspan { + fill: ${e.loopTextColor}; + stroke: none; + } + + .loopLine { + stroke-width: 2px; + stroke-dasharray: 2, 2; + stroke: ${e.labelBoxBorderColor}; + fill: ${e.labelBoxBorderColor}; + } + + .note { + //stroke: #decc93; + stroke: ${e.noteBorderColor}; + fill: ${e.noteBkgColor}; + } + + .noteText, .noteText > tspan { + fill: ${e.noteTextColor}; + stroke: none; + ${e.noteFontWeight?`font-weight: ${e.noteFontWeight};`:""} + } + + .activation0 { + fill: ${e.activationBkgColor}; + stroke: ${e.activationBorderColor}; + } + + .activation1 { + fill: ${e.activationBkgColor}; + stroke: ${e.activationBorderColor}; + } + + .activation2 { + fill: ${e.activationBkgColor}; + stroke: ${e.activationBorderColor}; + } + + .actorPopupMenu { + position: absolute; + } + + .actorPopupMenuPanel { + position: absolute; + fill: ${e.actorBkg}; + box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2); + filter: drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4)); +} + .actor-man circle, line { + fill: ${e.actorBkg}; + stroke-width: 2px; + } + + g rect.rect { + filter: ${t}; + stroke: ${e.nodeBorder}; + } +`},"getStyles"),Rr=yr,It=36,ft="actor-top",_t="actor-bottom",qt="actor-box",yt="actor-man",pt=new Set(["redux-color","redux-dark-color"]),Nt=x(function(e,t){const a=ur(e,t);return Kt().look==="neo"&&a.attr("data-look","neo"),a},"drawRect"),Or=x(function(e,t,a,r,i){if(t.links===void 0||t.links===null||Object.keys(t.links).length===0)return{height:0,width:0};const n=t.links,s=t.actorCnt,o=t.rectData;var u="none";i&&(u="block !important");const d=e.append("g");d.attr("id","actor"+s+"_popup"),d.attr("class","actorPopupMenu"),d.attr("display",u);var p="";o.class!==void 0&&(p=" "+o.class);let _=o.width>a?o.width:a;const E=d.append("rect");if(E.attr("class","actorPopupMenuPanel"+p),E.attr("x",o.x),E.attr("y",o.height),E.attr("fill",o.fill),E.attr("stroke",o.stroke),E.attr("width",_),E.attr("height",o.height),E.attr("rx",o.rx),E.attr("ry",o.ry),n!=null){var O=20;for(let f in n){var T=d.append("a"),g=Ce(n[f]);T.attr("xlink:href",g),T.attr("target","_blank"),Ur(r)(f,T,o.x+10,o.height+O,_,20,{class:"actor"},r),O+=30}}return E.attr("height",O),{height:o.height+O,width:_}},"drawPopup"),Ht=x(function(e){return"var pu = document.getElementById('"+e+"'); if (pu != null) { pu.style.display = pu.style.display == 'block' ? 'none' : 'block'; }"},"popupMenuToggle"),Ft=x(async function(e,t,a=null){let r=e.append("foreignObject");const i=await Be(t.text,Kt()),s=r.append("xhtml:div").attr("style","width: fit-content;").attr("xmlns","http://www.w3.org/1999/xhtml").html(i).node().getBoundingClientRect();if(r.attr("height",Math.round(s.height)).attr("width",Math.round(s.width)),t.class==="noteText"){const o=e.node().firstChild;o.setAttribute("height",s.height+2*t.textMargin);const u=o.getBBox();r.attr("x",Math.round(u.x+u.width/2-s.width/2)).attr("y",Math.round(u.y+u.height/2-s.height/2))}else if(a){let{startx:o,stopx:u,starty:d}=a;if(o>u){const p=o;o=u,u=p}r.attr("x",Math.round(o+Math.abs(o-u)/2-s.width/2)),t.class==="loopText"?r.attr("y",Math.round(d)):r.attr("y",Math.round(d-s.height))}return[r]},"drawKatex"),mt=x(function(e,t){let a=0,r=0;const i=t.text.split(N.lineBreakRegex),[n,s]=Me(t.fontSize);let o=[],u=0,d=x(()=>t.y,"yfunc");if(t.valign!==void 0&&t.textMargin!==void 0&&t.textMargin>0)switch(t.valign){case"top":case"start":d=x(()=>Math.round(t.y+t.textMargin),"yfunc");break;case"middle":case"center":d=x(()=>Math.round(t.y+(a+r+t.textMargin)/2),"yfunc");break;case"bottom":case"end":d=x(()=>Math.round(t.y+(a+r+2*t.textMargin)-t.textMargin),"yfunc");break}if(t.anchor!==void 0&&t.textMargin!==void 0&&t.width!==void 0)switch(t.anchor){case"left":case"start":t.x=Math.round(t.x+t.textMargin),t.anchor="start",t.dominantBaseline="middle",t.alignmentBaseline="middle";break;case"middle":case"center":t.x=Math.round(t.x+t.width/2),t.anchor="middle",t.dominantBaseline="middle",t.alignmentBaseline="middle";break;case"right":case"end":t.x=Math.round(t.x+t.width-t.textMargin),t.anchor="end",t.dominantBaseline="middle",t.alignmentBaseline="middle";break}for(let[p,_]of i.entries()){t.textMargin!==void 0&&t.textMargin===0&&n!==void 0&&(u=p*n);const E=e.append("text");E.attr("x",t.x),E.attr("y",d()),t.anchor!==void 0&&E.attr("text-anchor",t.anchor).attr("dominant-baseline",t.dominantBaseline).attr("alignment-baseline",t.alignmentBaseline),t.fontFamily!==void 0&&E.style("font-family",t.fontFamily),s!==void 0&&E.style("font-size",s),t.fontWeight!==void 0&&E.style("font-weight",t.fontWeight),t.fill!==void 0&&E.attr("fill",t.fill),t.class!==void 0&&E.attr("class",t.class),t.dy!==void 0?E.attr("dy",t.dy):u!==0&&E.attr("dy",u);const O=_||Tr;if(t.tspan){const T=E.append("tspan");T.attr("x",t.x),t.fill!==void 0&&T.attr("fill",t.fill),T.text(O)}else E.text(O);t.valign!==void 0&&t.textMargin!==void 0&&t.textMargin>0&&(r+=(E._groups||E)[0][0].getBBox().height,a=r),o.push(E)}return o},"drawText"),Ve=x(function(e,t){function a(i,n,s,o,u){return i+","+n+" "+(i+s)+","+n+" "+(i+s)+","+(n+o-u)+" "+(i+s-u*1.2)+","+(n+o)+" "+i+","+(n+o)}x(a,"genPoints");const r=e.append("polygon");return r.attr("points",a(t.x,t.y,t.width,t.height,7)),r.attr("class","labelBox"),t.y=t.y+t.height/2,mt(e,t),r},"drawLabel"),B=-1,Ye=x((e,t,a,r)=>{e.select&&a.forEach(i=>{const n=t.get(i),s=e.select("#actor"+n.actorCnt);!r.mirrorActors&&n.stopy?s.attr("y2",n.stopy+n.height/2):r.mirrorActors&&s.attr("y2",n.stopy)})},"fixLifeLineHeights"),Lr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+t.height,{look:u,theme:d,themeVariables:p}=a,{bkgColorArray:_,borderColorArray:E}=p,O=e.append("g").lower();var T=O;r||(B++,Object.keys(t.links||{}).length&&!a.forceMenus&&T.attr("onclick",Ht(`actor${B}_popup`)).attr("cursor","pointer"),T.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),T=O.append("g"),t.actorCnt=B,t.links!=null&&T.attr("id","root-"+B),u==="neo"&&T.attr("data-look","neo"));const g=dt();var f="actor";t.properties?.class?f=t.properties.class:g.fill="#eaeaea",r?f+=` ${_t}`:f+=` ${ft}`,g.x=t.x,g.y=n,g.width=t.width,g.height=t.height,g.class=f,g.rx=3,g.ry=3,g.name=t.name,u==="neo"&&(g.rx=6,g.ry=6);const I=Nt(T,g),L=i.get(t.name)??0;if(pt.has(d)&&(I.style("stroke",E[L%E.length]),I.style("fill",_[L%E.length])),u==="neo"&&I.attr("filter","url(#drop-shadow)"),t.rectData=g,t.properties?.icon){const w=t.properties.icon.trim();w.charAt(0)==="@"?se(T,g.x+g.width-20,g.y+10,w.substr(1)):ie(T,g.x+g.width-20,g.y+10,w)}r||(T.attr("data-et","participant"),T.attr("data-type","participant"),T.attr("data-id",t.name)),Et(a,Q(t.description))(t.description,T,g.x,g.y,g.width,g.height,{class:`actor ${qt}`},a);let b=t.height;if(I.node){const w=I.node().getBBox();t.height=w.height,b=w.height}return b},"drawActorTypeParticipant"),br=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+t.height,{look:u,theme:d,themeVariables:p}=a,{bkgColorArray:_,borderColorArray:E}=p,O=e.append("g").lower();var T=O;r||(B++,Object.keys(t.links||{}).length&&!a.forceMenus&&T.attr("onclick",Ht(`actor${B}_popup`)).attr("cursor","pointer"),T.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),T=O.append("g"),t.actorCnt=B,t.links!=null&&T.attr("id","root-"+B),u==="neo"&&T.attr("data-look","neo"));const g=dt();var f="actor";t.properties?.class?f=t.properties.class:g.fill="#eaeaea",r?f+=` ${_t}`:f+=` ${ft}`,g.x=t.x,g.y=n,g.width=t.width,g.height=t.height,g.class=f,g.name=t.name;const I=6,L={...g,x:g.x+-I,y:g.y+ +I,class:"actor"},b=Nt(T,g),w=Nt(T,L);t.rectData=g,u==="neo"&&T.attr("filter","url(#drop-shadow)");const A=i.get(t.name)??0;if(pt.has(d)&&(b.style("stroke",E[A%E.length]),b.style("fill",_[A%E.length]),w.style("stroke",E[A%E.length]),w.style("fill",_[A%E.length])),t.properties?.icon){const M=t.properties.icon.trim();M.charAt(0)==="@"?se(T,g.x+g.width-20,g.y+10,M.substr(1)):ie(T,g.x+g.width-20,g.y+10,M)}Et(a,Q(t.description))(t.description,T,g.x-I,g.y+I,g.width,g.height,{class:`actor ${qt}`},a);let D=t.height;if(b.node){const M=b.node().getBBox();t.height=M.height,D=M.height}return r||(T.attr("data-et","participant"),T.attr("data-type","collections"),T.attr("data-id",t.name)),D},"drawActorTypeCollections"),mr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+t.height,{look:u,theme:d,themeVariables:p}=a,{bkgColorArray:_,borderColorArray:E}=p,O=e.append("g").lower();let T=O;r||(B++,Object.keys(t.links||{}).length&&!a.forceMenus&&T.attr("onclick",Ht(`actor${B}_popup`)).attr("cursor","pointer"),T.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),T=O.append("g"),t.actorCnt=B,t.links!=null&&T.attr("id","root-"+B),u==="neo"&&T.attr("data-look","neo"));const g=dt();let f="actor";t.properties?.class?f=t.properties.class:g.fill="#eaeaea",r?f+=` ${_t}`:f+=` ${ft}`,T.attr("class",f),g.x=t.x,g.y=n,g.width=t.width,g.height=t.height,g.name=t.name;const I=g.height/2,L=I/(2.5+g.height/50),b=T.append("g"),w=T.append("g"),A=`M ${g.x},${g.y+I} + a ${L},${I} 0 0 0 0,${g.height} + h ${g.width-2*L} + a ${L},${I} 0 0 0 0,-${g.height} + Z + `;b.append("path").attr("d",A),w.append("path").attr("d",`M ${g.x},${g.y+I} + a ${L},${I} 0 0 0 0,${g.height}`),b.attr("transform",`translate(${L}, ${-(g.height/2)})`),w.attr("transform",`translate(${g.width-L}, ${-g.height/2})`),t.rectData=g,u==="neo"&&b.attr("filter","url(#drop-shadow)");const D=i.get(t.name)??0;if(pt.has(d)&&(b.style("stroke",E[D%E.length]),b.style("fill",_[D%E.length]),w.style("stroke",E[D%E.length]),w.style("fill",_[D%E.length])),t.properties?.icon){const W=t.properties.icon.trim(),U=g.x+g.width-20,G=g.y+10;W.charAt(0)==="@"?se(T,U,G,W.substr(1)):ie(T,U,G,W)}Et(a,Q(t.description))(t.description,T,g.x,g.y,g.width,g.height,{class:`actor ${qt}`},a);let M=t.height;const V=b.select("path:last-child");if(V.node()){const W=V.node().getBBox();t.height=W.height,M=W.height}return r||(T.attr("data-et","participant"),T.attr("data-type","queue"),T.attr("data-id",t.name)),M},"drawActorTypeQueue"),Ar=x(function(e,t,a,r,i,n){const s=r?t.stopy:t.starty,o=t.x+t.width/2,u=s+75,{look:d,theme:p,themeVariables:_}=a,{bkgColorArray:E,borderColorArray:O,actorBorder:T,actorBkg:g}=_,f=e.append("g").lower();r||(B++,f.append("line").attr("id","actor"+B).attr("x1",o).attr("y1",u).attr("x2",o).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),t.actorCnt=B);const I=e.append("g");let L=yt;r?L+=` ${_t}`:L+=` ${ft}`,I.attr("class",L),I.attr("name",t.name);const b=dt();b.x=t.x,b.y=s,b.fill="#eaeaea",b.width=t.width,b.height=t.height,b.class="actor";const w=t.x+t.width/2,A=s+32,D=22;I.append("defs").append("marker").attr("id",i+"-filled-head-control").attr("refX",11).attr("refY",5.8).attr("markerWidth",20).attr("markerHeight",28).attr("orient","172.5").attr("stroke-width",1.2).append("path").attr("d","M 14.4 5.6 L 7.2 10.4 L 8.8 5.6 L 7.2 0.8 Z"),I.append("circle").attr("cx",w).attr("cy",A).attr("r",D).attr("filter",`${d==="neo"?"url(#drop-shadow)":""}`),I.append("line").attr("marker-end","url(#"+i+"-filled-head-control)").attr("transform",`translate(${w}, ${A-D})`);const M=n.get(t.name)??0;pt.has(p)?(I.style("stroke",O[M%O.length]),I.style("fill",E[M%O.length])):(I.style("stroke",T),I.style("fill",g));const V=I.node().getBBox();return t.height=V.height+2*(a?.sequence?.labelBoxHeight??0),Et(a,Q(t.description))(t.description,I,b.x,b.y+D+(r?5:12),b.width,b.height,{class:`actor ${yt}`},a),r||(I.attr("data-et","participant"),I.attr("data-type","control"),I.attr("data-id",t.name)),t.height},"drawActorTypeControl"),Sr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+75,{look:u,theme:d,themeVariables:p}=a,{bkgColorArray:_,borderColorArray:E}=p,O=e.append("g").lower(),T=e.append("g");let g="actor";r?g+=` ${_t}`:g+=` ${ft}`,T.attr("class",g),T.attr("name",t.name);const f=dt();f.x=t.x,f.y=n,f.fill="#eaeaea",f.width=t.width,f.height=t.height,f.class="actor";const I=t.x+t.width/2,L=n+(r?10:25),b=22;T.append("circle").attr("cx",I).attr("cy",L).attr("r",b).attr("width",t.width).attr("height",t.height),T.append("line").attr("x1",I-b).attr("x2",I+b).attr("y1",L+b).attr("y2",L+b).attr("stroke-width",2),u==="neo"&&T.attr("filter","url(#drop-shadow)");const w=i.get(t.name)??0;pt.has(d)&&(T.style("stroke",E[w%E.length]),T.style("fill",_[w%E.length]));const A=T.node().getBBox();return t.height=A.height+(a?.sequence?.labelBoxHeight??0),r||(B++,O.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),t.actorCnt=B),Et(a,Q(t.description))(t.description,T,f.x,f.y+(r?15:30),f.width,f.height,{class:`actor ${yt}`},a),r?T.attr("transform",`translate(0, ${b})`):(T.attr("transform",`translate(0, ${b/2-5})`),T.attr("data-et","participant"),T.attr("data-type","entity"),T.attr("data-id",t.name)),t.height},"drawActorTypeEntity"),wr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+t.height+2*a.boxTextMargin,{theme:u,themeVariables:d,look:p}=a,{bkgColorArray:_,borderColorArray:E,actorBorder:O}=d,T=e.append("g").lower();let g=T;r||(B++,Object.keys(t.links||{}).length&&!a.forceMenus&&g.attr("onclick",Ht(`actor${B}_popup`)).attr("cursor","pointer"),g.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),g=T.append("g"),t.actorCnt=B,t.links!=null&&g.attr("id","root-"+B),p==="neo"&&g.attr("data-look","neo"));const f=dt();let I="actor";t.properties?.class?I=t.properties.class:f.fill="#eaeaea",r?I+=` ${_t}`:I+=` ${ft}`,f.x=t.x,f.y=n,f.width=t.width,f.height=t.height,f.class=I,f.name=t.name,f.x=t.x,f.y=n;const L=f.width/3,b=f.width/3,w=L/2,A=w/(2.5+L/50),D=g.append("g");D.attr("class",I);const M=` + M ${f.x},${f.y+A} + a ${w},${A} 0 0 0 ${L},0 + a ${w},${A} 0 0 0 -${L},0 + l 0,${b-2*A} + a ${w},${A} 0 0 0 ${L},0 + l 0,-${b-2*A} +`;D.append("path").attr("d",M),p==="neo"&&D.attr("filter","url(#drop-shadow)");const V=i.get(t.name)??0;pt.has(u)?(D.style("stroke",E[V%E.length]),D.style("fill",_[V%E.length])):D.style("stroke",O),D.attr("transform",`translate(${L}, ${A})`),t.rectData=f,Et(a,Q(t.description))(t.description,g,f.x,f.y+35,f.width,f.height,{class:`actor ${qt}`},a);const W=D.select("path:last-child");if(W.node()){const U=W.node().getBBox();t.height=U.height+(a.sequence.labelBoxHeight??0)}return r||(g.attr("data-et","participant"),g.attr("data-type","database"),g.attr("data-id",t.name)),t.height},"drawActorTypeDatabase"),Nr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+80,u=22,d=e.append("g").lower(),{look:p,theme:_,themeVariables:E}=a,{bkgColorArray:O,borderColorArray:T,actorBorder:g}=E;r||(B++,d.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),t.actorCnt=B);const f=e.append("g");let I=yt;r?I+=` ${_t}`:I+=` ${ft}`,f.attr("class",I),f.attr("name",t.name);const L=dt();L.x=t.x,L.y=n,L.fill="#eaeaea",L.width=t.width,L.height=t.height,L.class="actor",f.append("line").attr("id","actor-man-torso"+B).attr("x1",t.x+t.width/2-u*2.5).attr("y1",n+12).attr("x2",t.x+t.width/2-15).attr("y2",n+12),f.append("line").attr("id","actor-man-arms"+B).attr("x1",t.x+t.width/2-u*2.5).attr("y1",n+2).attr("x2",t.x+t.width/2-u*2.5).attr("y2",n+22),f.append("circle").attr("cx",t.x+t.width/2).attr("cy",n+12).attr("r",u),p==="neo"&&f.attr("filter","url(#drop-shadow)");const b=i.get(t.name)??0;pt.has(_)?(f.style("stroke",T[b%T.length]),f.style("fill",O[b%T.length])):f.style("stroke",g);const w=f.node().getBBox();return t.height=w.height+(a.sequence.labelBoxHeight??0),Et(a,Q(t.description))(t.description,f,L.x,L.y+15,L.width,L.height,{class:`actor ${yt}`},a),f.attr("transform",`translate(0,${u/2+10})`),r||(f.attr("data-et","participant"),f.attr("data-type","boundary"),f.attr("data-id",t.name)),t.height},"drawActorTypeBoundary"),Pr=x(function(e,t,a,r,i){const n=r?t.stopy:t.starty,s=t.x+t.width/2,o=n+80,{look:u,theme:d,themeVariables:p}=a,{bkgColorArray:_,borderColorArray:E,actorBorder:O}=p,T=e.append("g").lower();r||(B++,T.append("line").attr("id","actor"+B).attr("x1",s).attr("y1",o).attr("x2",s).attr("y2",2e3).attr("class","actor-line 200").attr("stroke-width","0.5px").attr("stroke","#999").attr("name",t.name).attr("data-et","life-line").attr("data-id",t.name),t.actorCnt=B);const g=e.append("g");let f=yt;r?f+=` ${_t}`:f+=` ${ft}`,g.attr("class",f),g.attr("name",t.name),r||g.attr("data-et","participant").attr("data-type","actor").attr("data-id",t.name);const I=u==="neo"?.5:1,L=u==="neo"?n+(1-I)*30:n;g.append("line").attr("id","actor-man-torso"+B).attr("x1",s).attr("y1",L+25*I).attr("x2",s).attr("y2",L+45*I),g.append("line").attr("id","actor-man-arms"+B).attr("x1",s-It/2*I).attr("y1",L+33*I).attr("x2",s+It/2*I).attr("y2",L+33*I),g.append("line").attr("x1",s-It/2*I).attr("y1",L+60*I).attr("x2",s).attr("y2",L+45*I),g.append("line").attr("x1",s).attr("y1",L+45*I).attr("x2",s+(It/2-2)*I).attr("y2",L+60*I);const b=g.append("circle");b.attr("cx",t.x+t.width/2),b.attr("cy",L+10*I),b.attr("r",15*I),b.attr("width",t.width*I),b.attr("height",t.height*I);const w=g.node().getBBox();t.height=w.height;const A=dt();A.x=t.x,A.y=L,A.fill="#eaeaea",A.width=t.width,A.height=t.height/I,A.class="actor",A.rx=3,A.ry=3;const D=i.get(t.name)??0;return pt.has(d)?(g.style("stroke",E[D%E.length]),g.style("fill",_[D%E.length])):g.style("stroke",O),Et(a,Q(t.description))(t.description,g,A.x,L+35*I-(u==="neo"?10:0),A.width,A.height,{class:`actor ${yt}`},a),t.height},"drawActorTypeActor"),kr=x(async function(e,t,a,r,i,n,s){const o=s??new Map([...n.db.getActors().values()].map((u,d)=>[u.name,d]));switch(t.type){case"actor":return await Pr(e,t,a,r,o);case"participant":return await Lr(e,t,a,r,o);case"boundary":return await Nr(e,t,a,r,o);case"control":return await Ar(e,t,a,r,i,o);case"entity":return await Sr(e,t,a,r,o);case"database":return await wr(e,t,a,r,o);case"collections":return await br(e,t,a,r,o);case"queue":return await mr(e,t,a,r,o)}},"drawActor"),Dr=x(function(e,t,a){const i=e.append("g");We(i,t),t.name&&Et(a)(t.name,i,t.x,t.y+a.boxTextMargin+(t.textMaxHeight||0)/2,t.width,0,{class:"text"},a),i.lower()},"drawBox"),vr=x(function(e){return e.append("g")},"anchorElement"),Cr=x(function(e,t,a,r,i,n,s){const{theme:o,themeVariables:u}=r,{bkgColorArray:d,borderColorArray:p,mainBkg:_}=u,E=dt(),O=t.anchored,T=t.actor;E.x=t.startx,E.y=t.starty,E.class="activation"+i%3,E.width=t.stopx-t.startx,E.height=a-t.starty;const g=Nt(O,E),I=(s??new Map([...n.db.getActors().values()].map((L,b)=>[L.name,b]))).get(T)??0;pt.has(o)&&(g.style("stroke",p[I%p.length]),g.style("fill",d[I%p.length]??_))},"drawActivation"),Mr=x(async function(e,t,a,r,i){const{boxMargin:n,boxTextMargin:s,labelBoxHeight:o,labelBoxWidth:u,messageFontFamily:d,messageFontSize:p,messageFontWeight:_}=r,E=e.append("g").attr("data-et","control-structure").attr("data-id","i"+i.id),O=x(function(f,I,L,b){return E.append("line").attr("x1",f).attr("y1",I).attr("x2",L).attr("y2",b).attr("class","loopLine")},"drawLoopLine");O(t.startx,t.starty,t.stopx,t.starty),O(t.stopx,t.starty,t.stopx,t.stopy),O(t.startx,t.stopy,t.stopx,t.stopy),O(t.startx,t.starty,t.startx,t.stopy),t.sections!==void 0&&t.sections.forEach(function(f){O(t.startx,f.y,t.stopx,f.y).style("stroke-dasharray","3, 3")});let T=ae();T.text=a,T.x=t.startx,T.y=t.starty,T.fontFamily=d,T.fontSize=p,T.fontWeight=_,T.anchor="middle",T.valign="middle",T.tspan=!1,T.width=Math.max(u??0,50),T.height=o+(r.look==="neo"?15:0)||20,T.textMargin=s,T.class="labelText",Ve(E,T),T=Ke(),T.text=t.title,T.x=t.startx+u/2+(t.stopx-t.startx)/2,T.y=t.starty+n+s,T.anchor="middle",T.valign="middle",T.textMargin=s,T.class="loopText",T.fontFamily=d,T.fontSize=p,T.fontWeight=_,T.wrap=!0;let g=Q(T.text)?await Ft(E,T,t):mt(E,T);if(t.sectionTitles!==void 0){for(const[f,I]of Object.entries(t.sectionTitles))if(I.message){T.text=I.message,T.x=t.startx+(t.stopx-t.startx)/2,T.y=t.sections[f].y+n+s,T.class="sectionTitle",T.anchor="middle",T.valign="middle",T.tspan=!1,T.fontFamily=d,T.fontSize=p,T.fontWeight=_,T.wrap=t.wrap,Q(T.text)?(t.starty=t.sections[f].y,await Ft(E,T,t)):mt(E,T);let L=Math.round(g.map(b=>(b._groups||b)[0][0].getBBox().height).reduce((b,w)=>b+w));t.sections[f].height+=L-(n+s)}}return t.height=Math.round(t.stopy-t.starty),E},"drawLoop"),We=x(function(e,t){Er(e,t)},"drawBackgroundRect"),Br=x(function(e,t){e.append("defs").append("symbol").attr("id",t+"-database").attr("fill-rule","evenodd").attr("clip-rule","evenodd").append("path").attr("transform","scale(.5)").attr("d","M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z")},"insertDatabaseIcon"),Vr=x(function(e,t){e.append("defs").append("symbol").attr("id",t+"-computer").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z")},"insertComputerIcon"),Yr=x(function(e,t){e.append("defs").append("symbol").attr("id",t+"-clock").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z")},"insertClockIcon"),Wr=x(function(e,t){e.append("defs").append("marker").attr("id",t+"-arrowhead").attr("refX",7.9).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto-start-reverse").append("path").attr("d","M -1 0 L 10 5 L 0 10 z")},"insertArrowHead"),Kr=x(function(e,t){e.append("defs").append("marker").attr("id",t+"-filled-head").attr("refX",15.5).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},"insertArrowFilledHead"),Fr=x(function(e,t){e.append("defs").append("marker").attr("id",t+"-sequencenumber").attr("refX",15).attr("refY",15).attr("markerWidth",60).attr("markerHeight",40).attr("orient","auto").append("circle").attr("cx",15).attr("cy",15).attr("r",6)},"insertSequenceNumber"),qr=x(function(e,t){e.append("defs").append("marker").attr("id",t+"-crosshead").attr("markerWidth",15).attr("markerHeight",8).attr("orient","auto").attr("refX",4).attr("refY",4.5).append("path").attr("fill","none").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1pt").attr("d","M 1,2 L 6,7 M 6,2 L 1,7")},"insertArrowCrossHead"),Hr=x(function(e,t){const{theme:a}=t;e.append("defs").append("filter").attr("id","drop-shadow").attr("height","130%").attr("width","130%").append("feDropShadow").attr("dx","4").attr("dy","4").attr("stdDeviation",0).attr("flood-opacity","0.06").attr("flood-color",`${a==="redux"||a==="redux-color"?"#000000":"#FFFFFF"}`)},"insertDropShadow"),Ke=x(function(){return{x:0,y:0,fill:void 0,anchor:void 0,style:"#666",width:void 0,height:void 0,textMargin:0,rx:0,ry:0,tspan:!0,valign:void 0}},"getTextObj"),zr=x(function(){return{x:0,y:0,fill:"#EDF2AE",stroke:"#666",width:100,anchor:"start",height:100,rx:0,ry:0}},"getNoteRect"),Et=(function(){function e(n,s,o,u,d,p,_){const E=s.append("text").attr("x",o+d/2).attr("y",u+p/2+5).style("text-anchor","middle").text(n);i(E,_)}x(e,"byText");function t(n,s,o,u,d,p,_,E){const{actorFontSize:O,actorFontFamily:T,actorFontWeight:g}=E,[f,I]=Me(O),L=n.split(N.lineBreakRegex);for(let b=0;be.height||0))+(this.loops.length===0?0:this.loops.map(e=>e.height||0).reduce((e,t)=>e+t))+(this.messages.length===0?0:this.messages.map(e=>e.height||0).reduce((e,t)=>e+t))+(this.notes.length===0?0:this.notes.map(e=>e.height||0).reduce((e,t)=>e+t))},"getHeight"),clear:x(function(){this.actors=[],this.boxes=[],this.loops=[],this.messages=[],this.notes=[]},"clear"),addBox:x(function(e){this.boxes.push(e)},"addBox"),addActor:x(function(e){this.actors.push(e)},"addActor"),addLoop:x(function(e){this.loops.push(e)},"addLoop"),addMessage:x(function(e){this.messages.push(e)},"addMessage"),addNote:x(function(e){this.notes.push(e)},"addNote"),lastActor:x(function(){return this.actors[this.actors.length-1]},"lastActor"),lastLoop:x(function(){return this.loops[this.loops.length-1]},"lastLoop"),lastMessage:x(function(){return this.messages[this.messages.length-1]},"lastMessage"),lastNote:x(function(){return this.notes[this.notes.length-1]},"lastNote"),actors:[],boxes:[],loops:[],messages:[],notes:[]},init:x(function(){this.sequenceItems=[],this.activations=[],this.models.clear(),this.data={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0},this.verticalPos=0,He($())},"init"),updateVal:x(function(e,t,a,r){e[t]===void 0?e[t]=a:e[t]=r(a,e[t])},"updateVal"),updateBounds:x(function(e,t,a,r){const i=this;let n=0;function s(o){return x(function(d){n++;const p=i.sequenceItems.length-n+1;i.updateVal(d,"starty",t-p*l.boxMargin,Math.min),i.updateVal(d,"stopy",r+p*l.boxMargin,Math.max),i.updateVal(R.data,"startx",e-p*l.boxMargin,Math.min),i.updateVal(R.data,"stopx",a+p*l.boxMargin,Math.max),o!=="activation"&&(i.updateVal(d,"startx",e-p*l.boxMargin,Math.min),i.updateVal(d,"stopx",a+p*l.boxMargin,Math.max),i.updateVal(R.data,"starty",t-p*l.boxMargin,Math.min),i.updateVal(R.data,"stopy",r+p*l.boxMargin,Math.max))},"updateItemBounds")}x(s,"updateFn"),this.sequenceItems.forEach(s()),this.activations.forEach(s("activation"))},"updateBounds"),insert:x(function(e,t,a,r){const i=N.getMin(e,a),n=N.getMax(e,a),s=N.getMin(t,r),o=N.getMax(t,r);this.updateVal(R.data,"startx",i,Math.min),this.updateVal(R.data,"starty",s,Math.min),this.updateVal(R.data,"stopx",n,Math.max),this.updateVal(R.data,"stopy",o,Math.max),this.updateBounds(i,s,n,o)},"insert"),newActivation:x(function(e,t,a){const r=a.get(e.from),i=zt(e.from).length||0,n=r.x+r.width/2+(i-1)*l.activationWidth/2;this.activations.push({startx:n,starty:this.verticalPos+2,stopx:n+l.activationWidth,stopy:void 0,actor:e.from,anchored:q.anchorElement(t)})},"newActivation"),endActivation:x(function(e){const t=this.activations.map(function(a){return a.actor}).lastIndexOf(e.from);return this.activations.splice(t,1)[0]},"endActivation"),createLoop:x(function(e={message:void 0,wrap:!1,width:void 0},t){return{startx:void 0,starty:this.verticalPos,stopx:void 0,stopy:void 0,title:e.message,wrap:e.wrap,width:e.width,height:0,fill:t}},"createLoop"),newLoop:x(function(e={message:void 0,wrap:!1,width:void 0},t){this.sequenceItems.push(this.createLoop(e,t))},"newLoop"),endLoop:x(function(){return this.sequenceItems.pop()},"endLoop"),isLoopOverlap:x(function(){return this.sequenceItems.length?this.sequenceItems[this.sequenceItems.length-1].overlap:!1},"isLoopOverlap"),addSectionToLoop:x(function(e){const t=this.sequenceItems.pop();t.sections=t.sections||[],t.sectionTitles=t.sectionTitles||[],t.sections.push({y:R.getVerticalPos(),height:0}),t.sectionTitles.push(e),this.sequenceItems.push(t)},"addSectionToLoop"),saveVerticalPos:x(function(){this.isLoopOverlap()&&(this.savedVerticalPos=this.verticalPos)},"saveVerticalPos"),resetVerticalPos:x(function(){this.isLoopOverlap()&&(this.verticalPos=this.savedVerticalPos)},"resetVerticalPos"),bumpVerticalPos:x(function(e){this.verticalPos=this.verticalPos+e,this.data.stopy=N.getMax(this.data.stopy,this.verticalPos)},"bumpVerticalPos"),getVerticalPos:x(function(){return this.verticalPos},"getVerticalPos"),getBounds:x(function(){return{bounds:this.data,models:this.models}},"getBounds")},Qr=x(async function(e,t,a){R.bumpVerticalPos(l.boxMargin),t.height=l.boxMargin,t.starty=R.getVerticalPos();const r=dt();r.x=t.startx,r.y=t.starty,r.width=t.width||l.width,r.class="note";const i=e.append("g");i.attr("data-et","note"),i.attr("data-id","i"+a);const n=q.drawRect(i,r),s=ae();s.x=t.startx,s.y=t.starty,s.width=r.width,s.dy="1em",s.text=t.message,s.class="noteText",s.fontFamily=l.noteFontFamily,s.fontSize=l.noteFontSize,s.fontWeight=l.noteFontWeight,s.anchor=l.noteAlign,s.textMargin=l.noteMargin,s.valign="center";const o=Q(s.text)?await Ft(i,s):mt(i,s),u=Math.round(o.map(d=>(d._groups||d)[0][0].getBBox().height).reduce((d,p)=>d+p));n.attr("height",u+2*l.noteMargin),t.height+=u+2*l.noteMargin,R.bumpVerticalPos(u+2*l.noteMargin),t.stopy=t.starty+u+2*l.noteMargin,t.stopx=t.startx+r.width,R.insert(t.startx,t.starty,t.stopx,t.stopy),R.models.addNote(t)},"drawNote"),De=x(function(e,t,a,r,i,n,s){const o=r.db.getActors(),u=o.get(t.from),d=o.get(t.to),p=a.sequenceVisible;let _=u.x+u.width/2,E=d.x+d.width/2;const O=_<=E,T=Xe(t,r),g=e.append("g"),f=16.5,I=x((D,M)=>{const V=D?f:-f;return M?-V:V},"getCircleOffset"),L=x(D=>{g.append("circle").attr("cx",D).attr("cy",s).attr("r",5).attr("width",10).attr("height",10)},"drawCircle"),{CENTRAL_CONNECTION:b,CENTRAL_CONNECTION_REVERSE:w,CENTRAL_CONNECTION_DUAL:A}=r.db.LINETYPE;if(p)switch(t.centralConnection){case b:T&&(E+=I(O,!0));break;case w:T||(_+=I(O,!1));break;case A:T?E+=I(O,!0):_+=I(O,!1);break}switch(t.centralConnection){case b:L(E);break;case w:L(_);break;case A:L(_),L(E);break}},"drawCentralConnection"),Rt=x(e=>({fontFamily:e.messageFontFamily,fontSize:e.messageFontSize,fontWeight:e.messageFontWeight}),"messageFont"),bt=x(e=>({fontFamily:e.noteFontFamily,fontSize:e.noteFontSize,fontWeight:e.noteFontWeight}),"noteFont"),ee=x(e=>({fontFamily:e.actorFontFamily,fontSize:e.actorFontSize,fontWeight:e.actorFontWeight}),"actorFont");async function Fe(e,t){R.bumpVerticalPos(10);const{startx:a,stopx:r,message:i}=t,n=N.splitBreaks(i).length,s=Q(i),o=s?await Pt(i,$()):Z.calculateTextDimensions(i,Rt(l));if(!s){const _=o.height/n;t.height+=_,R.bumpVerticalPos(_)}let u,d=o.height-10;const p=o.width;if(a===r){u=R.getVerticalPos()+d,l.rightAngles||(d+=l.boxMargin,u=R.getVerticalPos()+d),d+=30;const _=N.getMax(p/2,l.width/2);R.insert(a-_,R.getVerticalPos()-10+d,r+_,R.getVerticalPos()+30+d)}else d+=l.boxMargin,u=R.getVerticalPos()+d,R.insert(a,u-10,r,u);return R.bumpVerticalPos(d),t.height+=d,t.stopy=t.starty+t.height,R.insert(t.fromBounds,t.starty,t.toBounds,t.stopy),u}x(Fe,"boundMessage");var $r=x(async function(e,t,a,r,i,n){const{startx:s,stopx:o,starty:u,message:d,type:p,sequenceIndex:_,sequenceVisible:E}=t,O=Z.calculateTextDimensions(d,Rt(l)),T=ae();T.x=Math.min(s,o),T.y=u+10,T.width=Math.abs(o-s),T.class="messageText",T.dy="1em",T.text=d,T.fontFamily=l.messageFontFamily,T.fontSize=l.messageFontSize,T.fontWeight=l.messageFontWeight,T.anchor=l.messageAlign,T.valign="center",T.textMargin=l.wrapPadding,T.tspan=!1,Q(T.text)?await Ft(e,T,{startx:s,stopx:o,starty:a}):mt(e,T);const g=O.width;let f;if(s===o){const L=E||l.showSequenceNumbers,b=Xe(i,r),w=ia(i,r),A=s+(L&&(b||w)?10:0);l.rightAngles?f=e.append("path").attr("d",`M ${A},${a} H ${s+N.getMax(l.width/2,g/2)} V ${a+25} H ${s}`):f=e.append("path").attr("d","M "+A+","+a+" C "+(A+60)+","+(a-10)+" "+(s+60)+","+(a+30)+" "+s+","+(a+20)),jt(i,r)&&De(e,i,t,r,s,o,a)}else f=e.append("line"),f.attr("x1",s),f.attr("y1",a),f.attr("x2",o),f.attr("y2",a),jt(i,r)&&De(e,i,t,r,s,o,a);p===r.db.LINETYPE.DOTTED||p===r.db.LINETYPE.DOTTED_CROSS||p===r.db.LINETYPE.DOTTED_POINT||p===r.db.LINETYPE.DOTTED_OPEN||p===r.db.LINETYPE.BIDIRECTIONAL_DOTTED||p===r.db.LINETYPE.SOLID_TOP_DOTTED||p===r.db.LINETYPE.SOLID_BOTTOM_DOTTED||p===r.db.LINETYPE.STICK_TOP_DOTTED||p===r.db.LINETYPE.STICK_BOTTOM_DOTTED||p===r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED||p===r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED||p===r.db.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED||p===r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED?(f.style("stroke-dasharray","3, 3"),f.attr("class","messageLine1")):f.attr("class","messageLine0"),f.attr("data-et","message"),f.attr("data-id","i"+t.id),f.attr("data-from",t.from),f.attr("data-to",t.to);let I="";if(l.arrowMarkerAbsolute&&(I=pr(!0)),f.attr("stroke-width",2),f.attr("stroke","none"),f.style("fill","none"),(p===r.db.LINETYPE.SOLID_TOP||p===r.db.LINETYPE.SOLID_TOP_DOTTED)&&f.attr("marker-end","url("+I+"#"+n+"-solidTopArrowHead)"),(p===r.db.LINETYPE.SOLID_BOTTOM||p===r.db.LINETYPE.SOLID_BOTTOM_DOTTED)&&f.attr("marker-end","url("+I+"#"+n+"-solidBottomArrowHead)"),(p===r.db.LINETYPE.STICK_TOP||p===r.db.LINETYPE.STICK_TOP_DOTTED)&&f.attr("marker-end","url("+I+"#"+n+"-stickTopArrowHead)"),(p===r.db.LINETYPE.STICK_BOTTOM||p===r.db.LINETYPE.STICK_BOTTOM_DOTTED)&&f.attr("marker-end","url("+I+"#"+n+"-stickBottomArrowHead)"),(p===r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE||p===r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED)&&f.attr("marker-start","url("+I+"#"+n+"-solidBottomArrowHead)"),(p===r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE||p===r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED)&&f.attr("marker-start","url("+I+"#"+n+"-solidTopArrowHead)"),(p===r.db.LINETYPE.STICK_ARROW_TOP_REVERSE||p===r.db.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED)&&f.attr("marker-start","url("+I+"#"+n+"-stickBottomArrowHead)"),(p===r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE||p===r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED)&&f.attr("marker-start","url("+I+"#"+n+"-stickTopArrowHead)"),(p===r.db.LINETYPE.SOLID||p===r.db.LINETYPE.DOTTED)&&f.attr("marker-end","url("+I+"#"+n+"-arrowhead)"),(p===r.db.LINETYPE.BIDIRECTIONAL_SOLID||p===r.db.LINETYPE.BIDIRECTIONAL_DOTTED)&&(f.attr("marker-start","url("+I+"#"+n+"-arrowhead)"),f.attr("marker-end","url("+I+"#"+n+"-arrowhead)")),(p===r.db.LINETYPE.SOLID_POINT||p===r.db.LINETYPE.DOTTED_POINT)&&f.attr("marker-end","url("+I+"#"+n+"-filled-head)"),(p===r.db.LINETYPE.SOLID_CROSS||p===r.db.LINETYPE.DOTTED_CROSS)&&f.attr("marker-end","url("+I+"#"+n+"-crosshead)"),E||l.showSequenceNumbers){const L=p===r.db.LINETYPE.BIDIRECTIONAL_SOLID||p===r.db.LINETYPE.BIDIRECTIONAL_DOTTED,b=p===r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE||p===r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED||p===r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE||p===r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED||p===r.db.LINETYPE.STICK_ARROW_TOP_REVERSE||p===r.db.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED||p===r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE||p===r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED,w=6,A=jt(i,r);let D=s,M=o;L?(ss?M=o-2*w:(M=o-w,D+=i?.centralConnection===r.db.LINETYPE.CENTRAL_CONNECTION_DUAL||i?.centralConnection===r.db.LINETYPE.CENTRAL_CONNECTION_REVERSE?-7.5:0),M+=A?15:0,f.attr("x2",M),f.attr("x1",D)):f.attr("x1",s+w);let V=0;const W=s===o,U=s<=o;W?V=t.fromBounds+1:b?V=U?t.toBounds-1:t.fromBounds+1:V=U?t.fromBounds+1:t.toBounds-1;let G="12px";const X=_.toString().length;X>5?G="7px":X>3&&(G="9px"),e.append("line").attr("x1",V).attr("y1",a).attr("x2",V).attr("y2",a).attr("stroke-width",0).attr("marker-start","url("+I+"#"+n+"-sequencenumber)"),e.append("text").attr("x",V).attr("y",a+4).attr("font-family","sans-serif").attr("font-size",G).attr("text-anchor","middle").attr("class","sequenceNumber").text(_)}},"drawMessage"),jr=x(function(e,t,a,r,i,n,s){let o=0,u=0,d,p=0;for(const _ of r){const E=t.get(_),O=E.box;d&&d!=O&&(s||R.models.addBox(d),u+=l.boxMargin+d.margin),O&&O!=d&&(s||(O.x=o+u,O.y=i),u+=O.margin),E.width=N.getMax(E.width||l.width,l.width),E.height=N.getMax(E.height||l.height,l.height),E.margin=E.margin||l.actorMargin,p=N.getMax(p,E.height),a.get(E.name)&&(u+=E.width/2),E.x=o+u,E.starty=R.getVerticalPos(),R.insert(E.x,i,E.x+E.width,E.height),o+=E.width+u,E.box&&(E.box.width=o+O.margin-E.box.x),u=E.margin,d=E.box,R.models.addActor(E)}d&&!s&&R.models.addBox(d),R.bumpVerticalPos(p)},"addActorRenderingData"),re=x(async function(e,t,a,r,i,n,s){if(r){let o=0;R.bumpVerticalPos(l.boxMargin*2);for(const u of a){const d=t.get(u);d.stopy||(d.stopy=R.getVerticalPos());const p=await q.drawActor(e,d,l,!0,i,n,s);o=N.getMax(o,p)}R.bumpVerticalPos(o+l.boxMargin)}else for(const o of a){const u=t.get(o);await q.drawActor(e,u,l,!1,i,n,s)}},"drawActors"),qe=x(function(e,t,a,r){let i=0,n=0;for(const s of a){const o=t.get(s),u=ea(o),d=q.drawPopup(e,o,u,l,l.forceMenus,r);d.height>i&&(i=d.height),d.width+o.x>n&&(n=d.width+o.x)}return{maxHeight:i,maxWidth:n}},"drawActorsPopup"),He=x(function(e){ar(l,e),e.fontFamily&&(l.actorFontFamily=l.noteFontFamily=l.messageFontFamily=e.fontFamily),e.fontSize&&(l.actorFontSize=l.noteFontSize=l.messageFontSize=e.fontSize),e.fontWeight&&(l.actorFontWeight=l.noteFontWeight=l.messageFontWeight=e.fontWeight)},"setConf"),zt=x(function(e){return R.activations.filter(function(t){return t.actor===e})},"actorActivations"),ve=x(function(e,t){const a=t.get(e),r=zt(e),i=r.reduce(function(s,o){return N.getMin(s,o.startx)},a.x+a.width/2-1),n=r.reduce(function(s,o){return N.getMax(s,o.stopx)},a.x+a.width/2+1);return[i,n]},"activationBounds");function ht(e,t,a,r,i){R.bumpVerticalPos(a);let n=r;if(t.id&&t.message&&e[t.id]){const s=e[t.id].width,o=Rt(l);t.message=Z.wrapLabel(`[${t.message}]`,s-2*l.wrapPadding,o),t.width=s,t.wrap=!0;const u=Z.calculateTextDimensions(t.message,o),d=N.getMax(u.height,l.labelBoxHeight);n=r+d,at.debug(`${d} - ${t.message}`)}i(t),R.bumpVerticalPos(n)}x(ht,"adjustLoopHeightForWrap");function ze(e,t,a,r,i,n,s){function o(p,_){p.x{m.add(k.from),m.add(k.to)}),f=f.filter(k=>m.has(k))}const D=new Map(f.map((m,k)=>[E.get(m)?.name??m,k]));jr(_,E,O,f,0,I,!1);const M=await oa(I,E,A,r);q.insertArrowHead(_,t),q.insertArrowCrossHead(_,t),q.insertArrowFilledHead(_,t),q.insertSequenceNumber(_,t),q.insertSolidTopArrowHead(_,t),q.insertSolidBottomArrowHead(_,t),q.insertStickTopArrowHead(_,t),q.insertStickBottomArrowHead(_,t),s==="neo"&&q.insertDropShadow(_,l);function V(m,k){const lt=R.endActivation(m);lt.starty+18>k&&(lt.starty=k-6,k+=12),q.drawActivation(_,lt,k,l,zt(m.from).length,r,D),R.insert(lt.startx,k-10,lt.stopx,k)}x(V,"activeEnd");let W=1,U=1;const G=[],X=[];let nt=0;for(const m of I){let k,lt,et;switch(m.type){case r.db.LINETYPE.NOTE:R.resetVerticalPos(),lt=m.noteModel,await Qr(_,lt,m.id);break;case r.db.LINETYPE.ACTIVE_START:R.newActivation(m,_,E);break;case r.db.LINETYPE.CENTRAL_CONNECTION:R.newActivation(m,_,E);break;case r.db.LINETYPE.CENTRAL_CONNECTION_REVERSE:R.newActivation(m,_,E);break;case r.db.LINETYPE.ACTIVE_END:V(m,R.getVerticalPos());break;case r.db.LINETYPE.LOOP_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K));break;case r.db.LINETYPE.LOOP_END:k=R.endLoop(),await q.drawLoop(_,k,"loop",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;case r.db.LINETYPE.RECT_START:ht(M,m,l.boxMargin,l.boxMargin,K=>{let Ot=K.message;Ot||(Ot=o?.rectBkgColor||o?.actorBkg||"rgba(128, 128, 128, 0.5)"),R.newLoop(void 0,Ot)});break;case r.db.LINETYPE.RECT_END:k=R.endLoop(),X.push(k),R.models.addLoop(k),R.bumpVerticalPos(k.stopy-R.getVerticalPos());break;case r.db.LINETYPE.OPT_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K));break;case r.db.LINETYPE.OPT_END:k=R.endLoop(),await q.drawLoop(_,k,"opt",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;case r.db.LINETYPE.ALT_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K));break;case r.db.LINETYPE.ALT_ELSE:ht(M,m,l.boxMargin+l.boxTextMargin,l.boxMargin,K=>R.addSectionToLoop(K));break;case r.db.LINETYPE.ALT_END:k=R.endLoop(),await q.drawLoop(_,k,"alt",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;case r.db.LINETYPE.PAR_START:case r.db.LINETYPE.PAR_OVER_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K)),R.saveVerticalPos();break;case r.db.LINETYPE.PAR_AND:ht(M,m,l.boxMargin+l.boxTextMargin,l.boxMargin,K=>R.addSectionToLoop(K));break;case r.db.LINETYPE.PAR_END:k=R.endLoop(),await q.drawLoop(_,k,"par",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;case r.db.LINETYPE.AUTONUMBER:W=m.message.start||W,U=m.message.step||U,m.message.visible?r.db.enableSequenceNumbers():r.db.disableSequenceNumbers();break;case r.db.LINETYPE.CRITICAL_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K));break;case r.db.LINETYPE.CRITICAL_OPTION:ht(M,m,l.boxMargin+l.boxTextMargin,l.boxMargin,K=>R.addSectionToLoop(K));break;case r.db.LINETYPE.CRITICAL_END:k=R.endLoop(),await q.drawLoop(_,k,"critical",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;case r.db.LINETYPE.BREAK_START:ht(M,m,l.boxMargin,l.boxMargin+l.boxTextMargin,K=>R.newLoop(K));break;case r.db.LINETYPE.BREAK_END:k=R.endLoop(),await q.drawLoop(_,k,"break",l,m),R.bumpVerticalPos(k.stopy-R.getVerticalPos()),R.models.addLoop(k);break;default:try{et=m.msgModel,et.starty=R.getVerticalPos(),et.sequenceIndex=W,et.sequenceVisible=r.db.showSequenceNumbers(),et.id=m.id,et.from=m.from,et.to=m.to;const K=await Fe(_,et);ze(m,et,K,nt,E,O,T),G.push({messageModel:et,lineStartY:K,msg:m}),R.models.addMessage(et)}catch(K){at.error("error while drawing message",K)}}[r.db.LINETYPE.SOLID_OPEN,r.db.LINETYPE.DOTTED_OPEN,r.db.LINETYPE.SOLID,r.db.LINETYPE.SOLID_TOP,r.db.LINETYPE.SOLID_BOTTOM,r.db.LINETYPE.STICK_TOP,r.db.LINETYPE.STICK_BOTTOM,r.db.LINETYPE.SOLID_TOP_DOTTED,r.db.LINETYPE.SOLID_BOTTOM_DOTTED,r.db.LINETYPE.STICK_TOP_DOTTED,r.db.LINETYPE.STICK_BOTTOM_DOTTED,r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE,r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE,r.db.LINETYPE.STICK_ARROW_TOP_REVERSE,r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE,r.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED,r.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED,r.db.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED,r.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED,r.db.LINETYPE.DOTTED,r.db.LINETYPE.SOLID_CROSS,r.db.LINETYPE.DOTTED_CROSS,r.db.LINETYPE.SOLID_POINT,r.db.LINETYPE.DOTTED_POINT,r.db.LINETYPE.BIDIRECTIONAL_SOLID,r.db.LINETYPE.BIDIRECTIONAL_DOTTED].includes(m.type)&&(W=Math.round((W+U)*100)/100),nt++}at.debug("createdActors",O),at.debug("destroyedActors",T),await re(_,E,f,!1,t,r,D);for(const m of G)await $r(_,m.messageModel,m.lineStartY,r,m.msg,t);l.mirrorActors&&await re(_,E,f,!0,t,r,D),X.forEach(m=>q.drawBackgroundRect(_,m)),Ye(_,E,f,l);for(const m of R.models.boxes){m.height=R.getVerticalPos()-m.y,R.insert(m.x,m.y,m.x+m.width,m.height);const k=l.boxMargin*2;m.startx=m.x-k,m.starty=m.y-k*.25,m.stopx=m.startx+m.width+2*k,m.stopy=m.starty+m.height+k*.75,m.stroke="rgb(0,0,0, 0.5)",q.drawBox(_,m,l)}b&&R.bumpVerticalPos(l.boxMargin);const j=qe(_,E,f,p),{bounds:H}=R.getBounds();H.startx===void 0&&(H.startx=0),H.starty===void 0&&(H.starty=0),H.stopx===void 0&&(H.stopx=0),H.stopy===void 0&&(H.stopy=0);let st=H.stopy-H.starty;st{const s=Rt(l);let o=n.actorKeys.reduce((_,E)=>_+=e.get(E).width+(e.get(E).margin||0),0);const u=l.boxMargin*8;o+=u,o-=2*l.boxTextMargin,n.wrap&&(n.name=Z.wrapLabel(n.name,o-2*l.wrapPadding,s));const d=Z.calculateTextDimensions(n.name,s);i=N.getMax(d.height,i);const p=N.getMax(o,d.width+2*l.wrapPadding);if(n.margin=l.boxTextMargin,on.textMaxHeight=i),N.getMax(r,l.height)}x(Ge,"calculateActorMargins");var ra=x(async function(e,t,a){const r=t.get(e.from),i=t.get(e.to),n=r.x,s=i.x,o=e.wrap&&e.message;let u=Q(e.message)?await Pt(e.message,$()):Z.calculateTextDimensions(o?Z.wrapLabel(e.message,l.width,bt(l)):e.message,bt(l));const d={width:o?l.width:N.getMax(l.width,u.width+2*l.noteMargin),height:0,startx:r.x,stopx:0,starty:0,stopy:0,message:e.message};return e.placement===a.db.PLACEMENT.RIGHTOF?(d.width=o?N.getMax(l.width,u.width):N.getMax(r.width/2+i.width/2,u.width+2*l.noteMargin),d.startx=n+(r.width+l.actorMargin)/2):e.placement===a.db.PLACEMENT.LEFTOF?(d.width=o?N.getMax(l.width,u.width+2*l.noteMargin):N.getMax(r.width/2+i.width/2,u.width+2*l.noteMargin),d.startx=n-d.width+(r.width-l.actorMargin)/2):e.to===e.from?(u=Z.calculateTextDimensions(o?Z.wrapLabel(e.message,N.getMax(l.width,r.width),bt(l)):e.message,bt(l)),d.width=o?N.getMax(l.width,r.width):N.getMax(r.width,l.width,u.width+2*l.noteMargin),d.startx=n+(r.width-d.width)/2):(d.width=Math.abs(n+r.width/2-(s+i.width/2))+l.actorMargin,d.startx=n2,E=x(f=>u?-f:f,"adjustValue");e.from===e.to?p=d:(e.activate&&!_&&(p+=E(l.activationWidth/2-1)),[a.db.LINETYPE.SOLID_OPEN,a.db.LINETYPE.DOTTED_OPEN,a.db.LINETYPE.STICK_TOP,a.db.LINETYPE.STICK_BOTTOM,a.db.LINETYPE.STICK_TOP_DOTTED,a.db.LINETYPE.STICK_BOTTOM_DOTTED,a.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED,a.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED,a.db.LINETYPE.STICK_ARROW_TOP_REVERSE,a.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE,a.db.LINETYPE.STICK_ARROW_TOP_REVERSE_DOTTED,a.db.LINETYPE.STICK_ARROW_BOTTOM_REVERSE_DOTTED,a.db.LINETYPE.SOLID_ARROW_TOP_REVERSE,a.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE].includes(e.type)||(p+=E(3)),[a.db.LINETYPE.BIDIRECTIONAL_SOLID,a.db.LINETYPE.BIDIRECTIONAL_DOTTED,a.db.LINETYPE.SOLID_ARROW_TOP_REVERSE_DOTTED,a.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE_DOTTED,a.db.LINETYPE.SOLID_ARROW_TOP_REVERSE,a.db.LINETYPE.SOLID_ARROW_BOTTOM_REVERSE].includes(e.type)&&(d-=E(3)));const O=[i,n,s,o],T=Math.abs(d-p);e.wrap&&e.message&&(e.message=Z.wrapLabel(e.message,N.getMax(T+2*l.wrapPadding,l.width),Rt(l)));const g=Z.calculateTextDimensions(e.message,Rt(l));return{width:N.getMax(e.wrap?0:g.width+2*l.wrapPadding,T+2*l.wrapPadding,l.width),height:0,startx:d,stopx:p,starty:0,stopy:0,message:e.message,type:e.type,wrap:e.wrap,fromBounds:Math.min.apply(null,O),toBounds:Math.max.apply(null,O)}},"buildMessageModel"),oa=x(async function(e,t,a,r){const i={},n=[];let s,o,u;for(const d of e){switch(d.type){case r.db.LINETYPE.LOOP_START:case r.db.LINETYPE.ALT_START:case r.db.LINETYPE.OPT_START:case r.db.LINETYPE.PAR_START:case r.db.LINETYPE.PAR_OVER_START:case r.db.LINETYPE.CRITICAL_START:case r.db.LINETYPE.BREAK_START:n.push({id:d.id,msg:d.message,from:Number.MAX_SAFE_INTEGER,to:Number.MIN_SAFE_INTEGER,width:0});break;case r.db.LINETYPE.ALT_ELSE:case r.db.LINETYPE.PAR_AND:case r.db.LINETYPE.CRITICAL_OPTION:d.message&&(s=n.pop(),i[s.id]=s,i[d.id]=s,n.push(s));break;case r.db.LINETYPE.LOOP_END:case r.db.LINETYPE.ALT_END:case r.db.LINETYPE.OPT_END:case r.db.LINETYPE.PAR_END:case r.db.LINETYPE.CRITICAL_END:case r.db.LINETYPE.BREAK_END:s=n.pop(),i[s.id]=s;break;case r.db.LINETYPE.ACTIVE_START:{const _=t.get(d.from?d.from:d.to.actor),E=zt(d.from?d.from:d.to.actor).length,O=_.x+_.width/2+(E-1)*l.activationWidth/2,T={startx:O,stopx:O+l.activationWidth,actor:d.from,enabled:!0};R.activations.push(T)}break;case r.db.LINETYPE.ACTIVE_END:{const _=R.activations.map(E=>E.actor).lastIndexOf(d.from);R.activations.splice(_,1).splice(0,1)}break}d.placement!==void 0?(o=await ra(d,t,r),d.noteModel=o,n.forEach(_=>{s=_,s.from=N.getMin(s.from,o.startx),s.to=N.getMax(s.to,o.startx+o.width),s.width=N.getMax(s.width,Math.abs(s.from-s.to))-l.labelBoxWidth})):(u=na(d,t,r),d.msgModel=u,u.startx&&u.stopx&&n.length>0&&n.forEach(_=>{if(s=_,u.startx===u.stopx){const E=t.get(d.from),O=t.get(d.to);s.from=N.getMin(E.x-u.width/2,E.x-E.width/2,s.from),s.to=N.getMax(O.x+u.width/2,O.x+E.width/2,s.to),s.width=N.getMax(s.width,Math.abs(s.to-s.from))-l.labelBoxWidth}else s.from=N.getMin(u.startx,s.from),s.to=N.getMax(u.stopx,s.to),s.width=N.getMax(s.width,u.width)-l.labelBoxWidth}))}return R.activations=[],at.debug("Loop type widths:",i),i},"calculateLoopBounds"),ca={bounds:R,drawActors:re,drawActorsPopup:qe,setConf:He,draw:ta},Ea={parser:fr,get db(){return new Ir},renderer:ca,styles:Rr,init:x(e=>{e.sequence||(e.sequence={}),e.wrap&&(e.sequence.wrap=e.wrap,er({sequence:{wrap:e.wrap}}))},"init")};export{Ea as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/sizeCapture-INFHLROL.Dsb_Hwxo.js b/packages/tempo/public/v4/assets/chunks/sizeCapture-INFHLROL.Dsb_Hwxo.js new file mode 100644 index 00000000..b79a8f50 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/sizeCapture-INFHLROL.Dsb_Hwxo.js @@ -0,0 +1 @@ +import{_ as o}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var p=1;function i(){if(!(typeof globalThis>"u"))return globalThis}o(i,"getCaptureGlobal");function c(){return!!i()?.mermaidCaptureSizes}o(c,"shouldCaptureSizes");function u(){return typeof location>"u"?"browser-dev":`${location.pathname}${location.search}`}o(u,"capturedFromLocation");function d(n,r){const t=i();if(!t)return;const e=r.node(),s=((e&&"ownerSVGElement"in e?e.ownerSVGElement:null)??e)?.id??"(unknown)";t.mermaidCapturedSizes??=[];const a={svgId:s,sizes:n};t.mermaidCapturedSizes.push(a),t.mermaidLastCapturedSizes=a}o(d,"emitCapturedSizes");function m(n,r){const t=[];for(const e of r.nodes)e.isGroup||t.push({id:e.id,width:e.width??0,height:e.height??0});t.length!==0&&d({metadata:{captureVersion:p,capturedAt:new Date().toISOString(),capturedFrom:u()},nodes:t},n)}o(m,"captureNodeSizes");export{m as captureNodeSizes,c as shouldCaptureSizes}; diff --git a/packages/tempo/public/v4/assets/chunks/stateDiagram-D77RDMKH.teR48ecX.js b/packages/tempo/public/v4/assets/chunks/stateDiagram-D77RDMKH.teR48ecX.js new file mode 100644 index 00000000..0f45dbd6 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/stateDiagram-D77RDMKH.teR48ecX.js @@ -0,0 +1 @@ +import{s as R,a as W,S as N}from"./chunk-IMKFNOWR.GyfNfwKa.js";import{_ as f,c as t,j as H,l as S,d as P,a8 as _,k as z,a9 as U,aa as C,a4 as F,z as O}from"../app.CbekdYod.js";import{l as J}from"./layout.Bj1YlMtA.js";import"./chunk-XXDRQBXY.C52oJrTB.js";import"./chunk-POPQ4Y6H.DEs7vhGS.js";import"./chunk-F27PBJKO.CcniKEe6.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var X=f(e=>e.append("circle").attr("class","start-state").attr("r",t().state.sizeUnit).attr("cx",t().state.padding+t().state.sizeUnit).attr("cy",t().state.padding+t().state.sizeUnit),"drawStartState"),D=f(e=>e.append("line").style("stroke","grey").style("stroke-dasharray","3").attr("x1",t().state.textHeight).attr("class","divider").attr("x2",t().state.textHeight*2).attr("y1",0).attr("y2",0),"drawDivider"),Y=f((e,i)=>{const d=e.append("text").attr("x",2*t().state.padding).attr("y",t().state.textHeight+2*t().state.padding).attr("font-size",t().state.fontSize).attr("class","state-title").text(i.id),c=d.node().getBBox();return e.insert("rect",":first-child").attr("x",t().state.padding).attr("y",t().state.padding).attr("width",c.width+2*t().state.padding).attr("height",c.height+2*t().state.padding).attr("rx",t().state.radius),d},"drawSimpleState"),I=f((e,i)=>{const d=f(function(o,B,y){const v=o.append("tspan").attr("x",2*t().state.padding).text(B);y||v.attr("dy",t().state.textHeight)},"addTspan"),n=e.append("text").attr("x",2*t().state.padding).attr("y",t().state.textHeight+1.3*t().state.padding).attr("font-size",t().state.fontSize).attr("class","state-title").text(i.descriptions[0]).node().getBBox(),l=n.height,p=e.append("text").attr("x",t().state.padding).attr("y",l+t().state.padding*.4+t().state.dividerMargin+t().state.textHeight).attr("class","state-description");let a=!0,s=!0;i.descriptions.forEach(function(o){a||(d(p,o,s),s=!1),a=!1});const m=e.append("line").attr("x1",t().state.padding).attr("y1",t().state.padding+l+t().state.dividerMargin/2).attr("y2",t().state.padding+l+t().state.dividerMargin/2).attr("class","descr-divider"),x=p.node().getBBox(),g=Math.max(x.width,n.width);return m.attr("x2",g+3*t().state.padding),e.insert("rect",":first-child").attr("x",t().state.padding).attr("y",t().state.padding).attr("width",g+2*t().state.padding).attr("height",x.height+l+2*t().state.padding).attr("rx",t().state.radius),e},"drawDescrState"),$=f((e,i,d)=>{const c=t().state.padding,n=2*t().state.padding,l=e.node().getBBox(),p=l.width,a=l.x,s=e.append("text").attr("x",0).attr("y",t().state.titleShift).attr("font-size",t().state.fontSize).attr("class","state-title").text(i.id),x=s.node().getBBox().width+n;let g=Math.max(x,p);g===p&&(g=g+n);let o;const B=e.node().getBBox();i.doc,o=a-c,x>p&&(o=(p-g)/2+c),Math.abs(a-B.x)p&&(o=a-(x-p)/2);const y=1-t().state.textHeight;return e.insert("rect",":first-child").attr("x",o).attr("y",y).attr("class",d?"alt-composit":"composit").attr("width",g).attr("height",B.height+t().state.textHeight+t().state.titleShift+1).attr("rx","0"),s.attr("x",o+c),x<=p&&s.attr("x",a+(g-n)/2-x/2+c),e.insert("rect",":first-child").attr("x",o).attr("y",t().state.titleShift-t().state.textHeight-t().state.padding).attr("width",g).attr("height",t().state.textHeight*3).attr("rx",t().state.radius),e.insert("rect",":first-child").attr("x",o).attr("y",t().state.titleShift-t().state.textHeight-t().state.padding).attr("width",g).attr("height",B.height+3+2*t().state.textHeight).attr("rx",t().state.radius),e},"addTitleAndBox"),j=f(e=>(e.append("circle").attr("class","end-state-outer").attr("r",t().state.sizeUnit+t().state.miniPadding).attr("cx",t().state.padding+t().state.sizeUnit+t().state.miniPadding).attr("cy",t().state.padding+t().state.sizeUnit+t().state.miniPadding),e.append("circle").attr("class","end-state-inner").attr("r",t().state.sizeUnit).attr("cx",t().state.padding+t().state.sizeUnit+2).attr("cy",t().state.padding+t().state.sizeUnit+2)),"drawEndState"),q=f((e,i)=>{let d=t().state.forkWidth,c=t().state.forkHeight;if(i.parentId){let n=d;d=c,c=n}return e.append("rect").style("stroke","black").style("fill","black").attr("width",d).attr("height",c).attr("x",t().state.padding).attr("y",t().state.padding)},"drawForkJoinState"),Z=f((e,i,d,c)=>{let n=0;const l=c.append("text");l.style("text-anchor","start"),l.attr("class","noteText");let p=e.replace(/\r\n/g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ");p=p.replace(/\n/g,"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ");const a=p.split(z.lineBreakRegex);let s=1.25*t().state.noteMargin;for(const m of a){const x=m.trim();if(x.length>0){const g=l.append("tspan");if(g.text(x),s===0){const o=g.node().getBBox();s+=o.height}n+=s,g.attr("x",i+t().state.noteMargin),g.attr("y",d+n+1.25*t().state.noteMargin)}}return{textWidth:l.node().getBBox().width,textHeight:n}},"_drawLongText"),K=f((e,i)=>{i.attr("class","state-note");const d=i.append("rect").attr("x",0).attr("y",t().state.padding),c=i.append("g"),{textWidth:n,textHeight:l}=Z(e,0,0,c);return d.attr("height",l+2*t().state.noteMargin),d.attr("width",n+t().state.noteMargin*2),d},"drawNote"),L=f(function(e,i){const d=i.id,c={id:d,label:i.id,width:0,height:0},n=e.append("g").attr("id",d).attr("class","stateGroup");i.type==="start"&&X(n),i.type==="end"&&j(n),(i.type==="fork"||i.type==="join")&&q(n,i),i.type==="note"&&K(i.note.text,n),i.type==="divider"&&D(n),i.type==="default"&&i.descriptions.length===0&&Y(n,i),i.type==="default"&&i.descriptions.length>0&&I(n,i);const l=n.node().getBBox();return c.width=l.width+2*t().state.padding,c.height=l.height+2*t().state.padding,c},"drawState"),A=0,Q=f(function(e,i,d){const c=f(function(s){switch(s){case N.relationType.AGGREGATION:return"aggregation";case N.relationType.EXTENSION:return"extension";case N.relationType.COMPOSITION:return"composition";case N.relationType.DEPENDENCY:return"dependency"}},"getRelationType");i.points=i.points.filter(s=>!Number.isNaN(s.y));const n=i.points,l=U().x(function(s){return s.x}).y(function(s){return s.y}).curve(C),p=e.append("path").attr("d",l(n)).attr("id","edge"+A).attr("class","transition");let a="";if(t().state.arrowMarkerAbsolute&&(a=F(!0)),p.attr("marker-end","url("+a+"#"+c(N.relationType.DEPENDENCY)+"End)"),d.title!==void 0){const s=e.append("g").attr("class","stateLabel"),{x:m,y:x}=O.calcLabelPosition(i.points),g=z.getRows(d.title);let o=0;const B=[];let y=0,v=0;for(let u=0;u<=g.length;u++){const h=s.append("text").attr("text-anchor","middle").text(g[u]).attr("x",m).attr("y",x+o),w=h.node().getBBox();y=Math.max(y,w.width),v=Math.min(v,w.x),S.info(w.x,m,x+o),o===0&&(o=h.node().getBBox().height,S.info("Title height",o,x)),B.push(h)}let k=o*g.length;if(g.length>1){const u=(g.length-1)*o*.5;B.forEach((h,w)=>h.attr("y",x+w*o-u)),k=o*g.length}const r=s.node().getBBox();s.insert("rect",":first-child").attr("class","box").attr("x",m-y/2-t().state.padding/2).attr("y",x-k/2-t().state.padding/2-3.5).attr("width",y+t().state.padding).attr("height",k+t().state.padding),S.info(r)}A++},"drawEdge"),b,T={},V=f(function(){},"setConf"),tt=f(function(e){e.append("defs").append("marker").attr("id","dependencyEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 19,7 L9,13 L14,7 L9,1 Z")},"insertMarkers"),et=f(function(e,i,d,c){b=t().state;const n=t().securityLevel;let l;n==="sandbox"&&(l=H("#i"+i));const p=n==="sandbox"?H(l.nodes()[0].contentDocument.body):H("body"),a=n==="sandbox"?l.nodes()[0].contentDocument:document;S.debug("Rendering diagram "+e);const s=p.select(`[id='${i}']`);tt(s);const m=c.db.getRootDoc(),x=s.append("g").attr("id",i+"-root");G(m,x,void 0,!1,p,a,c);const g=b.padding,o=s.node().getBBox(),B=o.width+g*2,y=o.height+g*2,v=B*1.75;P(s,y,v,b.useMaxWidth),s.attr("viewBox",`${o.x-b.padding} ${o.y-b.padding} `+B+" "+y)},"draw"),at=f(e=>e?e.length*b.fontSizeFactor:1,"getLabelWidth"),G=f((e,i,d,c,n,l,p)=>{const a=new _({compound:!0,multigraph:!0});let s,m=!0;for(s=0;s{const w=h.parentElement;let E=0,M=0;w&&(w.parentElement&&(E=w.parentElement.getBBox().width),M=parseInt(w.getAttribute("data-x-shift"),10),Number.isNaN(M)&&(M=0)),h.setAttribute("x1",0-M+8),h.setAttribute("x2",E-M-8)})):S.debug("No Node "+r+": "+JSON.stringify(a.node(r)))});let v=y.getBBox();a.edges().forEach(function(r){r!==void 0&&a.edge(r)!==void 0&&(S.debug("Edge "+r.v+" -> "+r.w+": "+JSON.stringify(a.edge(r))),Q(i,a.edge(r),a.edge(r).relation))}),v=y.getBBox();const k={id:d||"root",label:d||"root",width:0,height:0};return k.width=v.width+2*b.padding,k.height=v.height+2*b.padding,S.debug("Doc rendered",k,a),k},"renderDoc"),it={setConf:V,draw:et},ht={parser:W,get db(){return new N(1)},renderer:it,styles:R,init:f(e=>{e.state||(e.state={}),e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},"init")};export{ht as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/stateDiagram-v2-MP3YSRHH.ij9DA5rL.js b/packages/tempo/public/v4/assets/chunks/stateDiagram-v2-MP3YSRHH.ij9DA5rL.js new file mode 100644 index 00000000..fdf17716 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/stateDiagram-v2-MP3YSRHH.ij9DA5rL.js @@ -0,0 +1 @@ +import{s as r,b as e,a,S as s}from"./chunk-IMKFNOWR.GyfNfwKa.js";import{_ as i}from"../app.CbekdYod.js";import"./chunk-XXDRQBXY.C52oJrTB.js";import"./chunk-POPQ4Y6H.DEs7vhGS.js";import"./chunk-F27PBJKO.CcniKEe6.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var n={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{n as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/swimlanes-42K2YHIH.DzZBAVKe.js b/packages/tempo/public/v4/assets/chunks/swimlanes-42K2YHIH.DzZBAVKe.js new file mode 100644 index 00000000..5e96b68b --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/swimlanes-42K2YHIH.DzZBAVKe.js @@ -0,0 +1 @@ +import{aq as Cr,l as In,_ as d,aB as To}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var Ao=5,Xe=1e-5,Ye=1e-6;function Ue(t){const e=[];for(let n=0;n=1-Ye||C<=Ye||C>=1-Ye?null:{point:{x:t.x+x*s,y:t.y+x*r},tA:x,tB:C}}d(Bo,"segmentIntersection");function Sn(t){return Math.abs(t.b.x-t.a.x)>=Math.abs(t.b.y-t.a.y)}d(Sn,"isHorizontalSeg");function ko(t){const e=[];for(let n=0;n=Math.abs(n)?e>=0?1:0:n>=0?1:0}d(Fo,"getArcSweepFlag");var vr=.001;function _o(t,e){if(t.length<2)return t.map(r=>({...r}));const n=t.map(r=>({...r})),o=e.arrowTypeStart&&To[e.arrowTypeStart];if(o){const r=t[0],a=t[1],l=Math.atan2(a.y-r.y,a.x-r.x);n[0].x=r.x+o*Math.cos(l),n[0].y=r.y+o*Math.sin(l)}const s=e.arrowTypeEnd&&To[e.arrowTypeEnd];if(s){const r=t.length,a=t[r-2],l=t[r-1],f=Math.atan2(l.y-a.y,l.x-a.x);n[r-1].x=l.x-s*Math.cos(f),n[r-1].y=l.y-s*Math.sin(f)}return n}d(_o,"applyMarkerOffsets");function Do(t,e,n,o,s){const r=t.point.x,a=t.point.y,l={x:r-e*t.r,y:a-n*t.r},f={x:r+e*t.r,y:a+n*t.r},i=[`L${Ae(l)}`];return s==="arc"?i.push(`A${re(t.r)},${re(t.r)} 0 0 ${o} ${Ae(f)}`):i.push(`M${Ae(f)}`),i}d(Do,"emitJump");function Cn(t,e,n,o){const s=e.x-t.x,r=e.y-t.y,a=n.x-e.x,l=n.y-e.y,f=Math.hypot(s,r),i=Math.hypot(a,l);if(f0){const E=Cn(s[i-1],s[i],s[i+1]??s[i],Ao);E&&(c=E.cutLen)}let y=x,v=null;r&&iE.t-T.t);for(const E of M)E.r=Math.min(E.r,E.d-c,y-E.d);for(let E=0;ET){const m=T/2;M[E].r=Math.min(M[E].r,m),M[E+1].r=Math.min(M[E+1].r,m)}}for(const E of M)E.r=2?o:null}catch{return null}}d(Go,"decodeDataPoints");function $o(t,e,n){if(!n.enabled)return;const o=t.node();if(!o)return;const s=new Map;for(const i of e)s.set(i.id,i);const r=[],a=new Map;for(const i of e){const g=typeof CSS<"u"&&CSS.escape?CSS.escape(i.id):i.id,x=o.querySelector(`path[data-id="${g}"]`);if(!x)continue;a.set(i.id,x);const h=Go(x.getAttribute("data-points"))??i.points;r.push({...i,points:h})}const l=ko(r);if(l.length===0)return;const f=new Map;for(const i of l){const g=f.get(i.jumpEdgeId)??[];g.push(i),f.set(i.jumpEdgeId,g)}for(const i of r){const g=f.get(i.id);if(!g||g.length===0)continue;const C=s.get(i.id)?.curve;if(C!==void 0&&!Yo(C))continue;const h=a.get(i.id);if(!h)continue;if(C===void 0){const E=h.getAttribute("d")??"";if(!Xo(E))continue}const p=h.getAttribute("style")??"",c=/stroke-dasharray\s*:\s*0\s+([\d.]+)\s+[\d.]+\s+([\d.]+)/.exec(p),y=c?Number.parseFloat(c[1]):null,v=c?Number.parseFloat(c[2]):null,M=Ho(i,g,n);if(h.setAttribute("d",M),y!==null&&v!==null&&typeof h.getTotalLength=="function"){const E=h.getTotalLength(),T=Math.max(0,E-y-v),m=`0 ${y} ${T} ${v}`,I=p.replace(/stroke-dasharray\s*:[^;]*;?/g,`stroke-dasharray: ${m};`).replace(/;\s*;+/g,";");h.setAttribute("style",I)}}}d($o,"applyLineJumpsToSvg");function zo(t,{measure:e}){const n=t.config?.swimlane?.lineHops;if(n===!1)return;const o=n==="gap"?"gap":"arc",s=t.edges.filter(r=>Array.isArray(r.points)&&r.points.length>=2).map(r=>({id:r.id,points:r.points,curve:r.curve,arrowTypeStart:r.arrowTypeStart,arrowTypeEnd:r.arrowTypeEnd}));$o(e.groups.edgePaths,s,{enabled:!0,jumpRadius:6,jumpStyle:o})}d(zo,"applySwimlaneLineJumps");var yn="__swimlane_default__",Lr=21,wo=20;function vn(t){return Math.max(t.padding??wo,wo)}d(vn,"topLaneHorizontalPadding");function Vo(t){const{x:e,y:n,width:o,height:s}=t,r=t.swimlaneContentTop;if(typeof e!="number"||typeof n!="number"||typeof o!="number"||typeof s!="number"||typeof r!="number"||!Number.isFinite(e)||!Number.isFinite(n)||!Number.isFinite(o)||!Number.isFinite(s)||!Number.isFinite(r)||o<=0||s<=0){delete t.groupTitleRect;return}const a=n-s/2,l=Math.min(r,n+s/2),f=Math.min(Lr,Math.max(0,l-a)),i=a+f;if(i<=a){delete t.groupTitleRect;return}t.groupTitleRect={left:e-o/2,right:e+o/2,top:a,bottom:i}}d(Vo,"assignTopLaneTitleRect");function jo(t){const e=t.direction,n=t.nodes??=[];for(const r of t.nodes??[])r.isGroup&&!r.parentId&&(r.shape="swimlane",e&&(r.direction=e));const o=n.filter(r=>!r.isGroup&&!r.parentId);if(o.length===0)return;let s=n.find(r=>r.id===yn);s?s.isGroup&&(s.shape="swimlane",e&&(s.direction=e)):(s={id:yn,label:"",isGroup:!0,shape:"swimlane",padding:20,...e?{direction:e}:{}},n.push(s));for(const r of o)r.parentId=yn}d(jo,"prepareLayoutForSwimlanes");function Uo(t){const e=new Map;for(const f of t.nodes??[])e.set(f.id,f);const n=[];for(const f of t.edges??[]){const i=typeof f.start=="string"?f.start:void 0,g=typeof f.end=="string"?f.end:void 0;!i||!g||f.labelNodeId||n.push({id:f.id,src:i,dst:g,ref:f})}const o=t.nodes??[],s=o.filter(f=>f.isGroup),r=o.filter(f=>!f.isGroup);return{nodes:[...[...s].reverse(),...r].map(f=>f.id),edges:n,layout:t,nodeById:e}}d(Uo,"toGraphView");function Wo(t,e,n,o){const{layout:s}=t,r=t.nodeById,a=o?.layerGap??100,l=o?.nodeGap??40;let f=0;for(const C of e.layers){let h=0;for(const p of C){const c=r.get(p);if(!c){h++;continue}c.layer=f,c.order=h;const y=n.x[p]??h*l,v=n.y[p]??f*a;c.x=y,c.y=v,h++}f++}const i=s.nodes??[],g=new Map,x=[];for(const C of i){if(!C?.isGroup)continue;C.parentId||x.push(C);const h=i.filter(M=>M.parentId===C.id);let p=1/0,c=-1/0,y=1/0,v=-1/0;for(const M of h){const E=M.x??n.x[M.id],T=M.y??n.y[M.id],m=M.width??0,I=M.height??0;E!=null&&T!=null&&(p=Math.min(p,E-m/2),c=Math.max(c,E+m/2),y=Math.min(y,T-I/2),v=Math.max(v,T+I/2))}if(p===1/0||y===1/0)C.x=C.x??0,C.y=C.y??0,C.width=C.width??0,C.height=C.height??0;else{const M=C.padding??20,E=C.parentId?M:2*vn(C),T=M,m=Math.max(0,c-p)+E,I=Math.max(0,v-y)+T,w=(p+c)/2,R=(y+v)/2;C.x=w,C.y=R,C.width=m,C.height=I,g.set(C.id,{minX:p,maxX:c,minY:y,maxY:v})}}if(x.length>0&&g.size>0){let C=1/0,h=-1/0,p=0;for(const c of x){const y=c.padding??20;y>p&&(p=y);const v=g.get(c.id);v&&(C=Math.min(C,v.minY),h=Math.max(h,v.maxY))}if(C!==1/0&&h!==-1/0){const c=Math.max(0,h-C),v=Math.max(p,36),M=c+2*v,E=(C+h)/2;for(const k of x)k.y=E,k.height=M,k.swimlaneContentTop=C;const T=[...x].sort((k,O)=>{const F=k.x??0,H=O.x??0;return F-H}),m=[],I=[],w=[];for(const k of T){const O=g.get(k.id);if(!O)continue;const F=Math.max(0,O.maxX-O.minX)+2*vn(k),H=(O.minX+O.maxX)/2;m.push(k.id),I.push(H),w.push(F)}const R=m.length;if(R>0){const k=new Map;if(R===1)k.set(m[0],w[0]);else{const O=[];for(let j=0;j0&&s>0?{cx:e,cy:n,rect:we(e,n,o,s)}:void 0}d(eo,"measuredNodeRect");function no(t){if(t.isGroup)return;const e=eo(t);return e?{id:String(t.id??""),cx:e.cx,cy:e.cy,rect:e.rect}:void 0}d(no,"nodeBoundsInfoFor");function oe(t,e,n=_t){return Math.abs(t.x-e.x)n}d(Tt,"isHorizontalSegment");function At(t,e,n=_t){return ft(t,e,n)&&Math.abs(t.y-e.y)>n}d(At,"isVerticalSegment");function zt(t,e,n,o){return Math.max(0,Math.min(Math.max(t,e),Math.max(n,o))-Math.max(Math.min(t,e),Math.min(n,o)))}d(zt,"overlapLength");function ce(t,e,n=_t){return t.horizontal&&e.horizontal&&ht(t.a,e.a,n)?zt(t.a.x,t.b.x,e.a.x,e.b.x):t.vertical&&e.vertical&&ft(t.a,e.a,n)?zt(t.a.y,t.b.y,e.a.y,e.b.y):0}d(ce,"sameAxisSegmentOverlapLength");function Re(t,e=_t){const n=[];for(let o=0;o0?n[n.length-1]:void 0;(!s||!oe(s,o,e))&&n.push({x:o.x,y:o.y})}return n}d(pt,"dedupeConsecutivePoints");function oo(t,e=_t){if(!t||t.length!==4)return;const[n,o,s,r]=t;return Tt(n,o,e)&&At(o,s,e)&&Tt(s,r,e)?{kind:"HVH",p0:n,p1:o,p2:s,p3:r}:At(n,o,e)&&Tt(o,s,e)&&At(s,r,e)?{kind:"VHV",p0:n,p1:o,p2:s,p3:r}:void 0}d(oo,"classifyThreeSegmentRoute");function on(t,e,n,o=0){const s=Math.min(t.x,e.x),r=Math.max(t.x,e.x),a=Math.min(t.y,e.y),l=Math.max(t.y,e.y);return r>n.left-o&&sn.top-o&&ae.left+n&&t.xe.top+n&&t.y=e.right&&t.top<=e.top&&t.bottom>=e.bottom}d(qo,"rectContainsRect");function We(t,e){return t.lefte.left&&t.tope.top}d(We,"rectsOverlap");function Ln(t,e){return{left:t.left-e,right:t.right+e,top:t.top-e,bottom:t.bottom+e}}d(Ln,"inflateRect");function we(t,e,n,o){return{left:t-n/2,right:t+n/2,top:e-o/2,bottom:e+o/2}}d(we,"rectFromCenterSize");function qt(t){return eo(t)?.rect}d(qt,"rectOfNodeBounds");function Ie(t,e){switch(e){case"top":return{x:t.cx,y:t.rect.top};case"bottom":return{x:t.cx,y:t.rect.bottom};case"left":return{x:t.rect.left,y:t.cy};case"right":return{x:t.rect.right,y:t.cy}}}d(Ie,"portForRectSide");function ro(t,e,n,o,s,r=_t){const a=e==="left"||e==="right",l=o==="left"||o==="right";if(a&&l){if(e==="right"&&o==="left"&&t.xn.x){if(ht(t,n,r))return[t,n];const x=(t.x+n.x)/2;return[t,{x,y:t.y},{x,y:n.y},n]}if(e===o){if(ht(t,n,r))return;const x=e==="left"?Math.min(t.x,n.x)-s:Math.max(t.x,n.x)+s;return[t,{x,y:t.y},{x,y:n.y},n]}return}if(!a&&!l){if(e===o){if(ft(t,n,r))return;const C=e==="top"?Math.min(t.y,n.y)-s:Math.max(t.y,n.y)+s;return[t,{x:t.x,y:C},{x:n.x,y:C},n]}if(!(e==="bottom"&&o==="top"&&t.yn.y))return;if(ft(t,n,r))return[t,n];const x=(t.y+n.y)/2;return[t,{x:t.x,y:x},{x:n.x,y:x},n]}if(a&&!l){const g=e==="right"&&n.x>t.x||e==="left"&&n.xn.y;return g&&x?[t,{x:n.x,y:t.y},n]:void 0}const f=e==="bottom"&&n.y>t.y||e==="top"&&n.yn.x;return f&&i?[t,{x:t.x,y:n.y},n]:void 0}d(ro,"buildOrthogonalPortPath");function io(t,e,n,o){return e==="left"||e==="right"?[t,{x:o,y:t.y},{x:o,y:n.y},n]:[t,{x:t.x,y:o},{x:n.x,y:o},n]}d(io,"buildSameSideTrackPath");function sn(t){const e=new Map,n=[];for(const o of t){if(o.isEdgeLabel)continue;const s=no(o);s&&(e.set(s.id,s),n.push({id:s.id,rect:s.rect}))}return{nodeInfoById:e,realNodeRects:n}}d(sn,"collectRealNodeBounds");function me(t){const e=[],n=[];for(const o of t){const s=no(o);if(!s)continue;const r={id:s.id,rect:s.rect};o.isEdgeLabel?n.push(r):e.push(r)}return{realNodeRects:e,labelNodeRects:n}}d(me,"collectNodeRectEntries");function Jo(t,{includeEdgeLabels:e=!0}={}){const n=[];for(const o of t){if(o.isGroup||!e&&o.isEdgeLabel)continue;const s=o.x??0,r=o.y??0,a=o.width??0,l=o.height??0;n.push({nodeId:o.id,...we(s,r,a,l)})}return n}d(Jo,"collectLayoutNodeRects");function co(t,e,n=_t){const o=t.start,s=t.end;if(!o||!s)return;const r=e.get(o),a=e.get(s);if(!(!r||!a))return{srcId:o,dstId:s,srcInfo:r,dstInfo:a,collinearX:Math.abs(r.cx-a.cx)p||Cv)return!1;const M=Math.abs(c-g.a.x)s:r&&l&&ht(t,n,s)?zt(t.x,e.x,n.x,o.x)>s:!1}d(Zo,"sameAxisSegmentsOverlap");function Ke(t,e,n,o,{epsilon:s=_t,skipDegenerateOther:r=!1}={}){for(const a of n){if(a===o||a.isLayoutOnly)continue;const l=a.points;if(!(!l||l.length<2))for(let f=0;fC+s&&pc+s&&xo+_t&&t=2?e[e.length-2]:void 0,f=(a?ft(a,s):!1)?{x:s.x,y:r.y}:{x:r.x,y:s.y};e.push(f)}e.push(r)}const n=[];for(const o of e){const s=n[n.length-1];(!s||!oe(s,o))&&n.push(o)}return n}d(qe,"orthogonalizePolyline");function ae(t){if(t.length<3)return t;let e=[...t];for(let n=0;n<32;n++){const o=ts(e);if(e=o.points,!o.changed)break}return e}d(ae,"simplifyPolyline");var nt=.001,Tr=.5,Ro=4;function lo(t,e,n){const o=t;if(o.isLayoutOnly||!o.points||o.points.length=0&&s=t.length)return t;const r=s-o;if(r<0||r>=t.length)return t;const a=es(t[s],t[r],e);return n?[a,...t.slice(s)]:[...t.slice(0,s+1),a]}d(Tn,"clipEndpoint");function ns(t,e){for(const n of t){const o=lo(n,e,2);if(!o)continue;let s=[...o.points];o.srcRect&&(s=Tn(s,o.srcRect,!0)),o.dstRect&&(s=Tn(s,o.dstRect,!1)),s=ae(qe(s)),s=fo(s,o.srcRect,o.dstRect),o.edge.points=ae(qe(s))}}d(ns,"clipEdgeEndpointsToNodeBoundaries");function An(t,e,n,o=!1){if(ht(t,e,nt)){if(e.yn.bottom+nt)return e;if(o){if(t.xn.right+nt)return{x:n.right,y:t.y}}return{x:Math.abs(e.x-n.left)<=Math.abs(e.x-n.right)?n.left:n.right,y:t.y}}if(ft(t,e,nt)){if(e.xn.right+nt)return e;if(o){if(t.yn.bottom+nt)return{x:t.x,y:n.bottom}}const s=Math.abs(e.y-n.top)<=Math.abs(e.y-n.bottom);return{x:t.x,y:s?n.top:n.bottom}}return e}d(An,"snapEndpointToBoundary");function Je(t,e,n){const o=t[e];for(let s=e+n;s>=0&&so.lo)),n=Math.min(...t.map(o=>o.hi));if(!(e>n))return{lo:e,hi:n}}d(os,"intersectRanges");function Rn(t,e){return e==="left"||e==="right"?Ze(t.top,t.bottom):Ze(t.left,t.right)}d(Rn,"clearanceRangeForSide");function Qe(t,e,n){const o=t.y>=n.top-nt&&t.y<=n.bottom+nt,s=t.x>=n.left-nt&&t.x<=n.right+nt;if(ht(t,e,nt)&&o){if(Math.abs(t.x-n.left)0?os(r):void 0}d(ss,"straightClearanceRange");function Nn(t,e,n,o,s){const r=ss(t,e,n,o,s);if(!r)return;const a=s?t.y:t.x,l=Math.min(r.hi,Math.max(r.lo,a));if(!(Math.abs(l-a)({...l}));for(let l=e;l>=0&&l=n.left-nt&&Math.max(t.x,e.x)<=n.right+nt,s=Math.min(t.y,e.y)>=n.top-nt&&Math.max(t.y,e.y)<=n.bottom+nt;if(Math.abs(t.y-n.top)o.bottom+nt;case"left":return ht(e,n,nt)&&n.xo.right+nt}}d(Bn,"leavesOutward");function kn(t,e,n){if(t.length<3)return t;if(n){const r=Pn(t[0],t[1],e);return r&&Bn(r,t[1],t[2],e)?t.slice(1):t}const o=t.length-1,s=Pn(t[o-1],t[o],e);return s&&Bn(s,t[o-1],t[o-2],e)?t.slice(0,o):t}d(kn,"collapseOwnBorderStub");function cs(t,e,n){let o=t;if(e){const r=Je(o,0,1);if(r){const a=An(r,o[0],e);a!==o[0]&&(o=[a,...o.slice(1)])}o=kn(o,e,!0)}if(n){const r=o.length-1,a=Je(o,r,-1);if(a){const l=An(a,o[r],n,!0);l!==o[r]&&(o=[...o.slice(0,r),l])}o=kn(o,n,!1)}const s=fo(o,e,n);return s!==o||o.length===2?s:(e&&(o=On(o,e,!0)),n&&(o=On(o,n,!1)),o)}d(cs,"snapAndCollapseEndpoints");function Fn(t,e){for(const n of t){const o=lo(n,e,2);if(!o)continue;const s=pt(o.points,nt),r=cs(s,o.srcRect,o.dstRect);if(r.length<3){o.edge.points=r;continue}const a=[r[0],{...r[0]},...r.slice(1,-1),r[r.length-1],{...r[r.length-1]}];o.edge.points=a}}d(Fn,"prepareEdgeEndpointsForRenderer");function uo(t){return new Map(t.map(e=>[e.id,e]))}d(uo,"buildNodeMap");function as(t,e){let n=t.parentId,o=null;for(;n;){const s=e.get(n);if(!s?.isGroup)break;o=s.id,n=s.parentId}return o}d(as,"resolveTopLevelGroupId");function _n(t,e){let n=0,o=t.parentId;for(;o;){const s=e.get(o);if(!s?.isGroup)break;n++,o=s.parentId}return n}d(_n,"groupDepth");function ho(t){let e=1/0,n=-1/0,o=1/0,s=-1/0;for(const r of t){const a=r.x,l=r.y;if(typeof a!="number"||typeof l!="number")continue;const f=r.width??0,i=r.height??0;e=Math.min(e,a-f/2),n=Math.max(n,a+f/2),o=Math.min(o,l-i/2),s=Math.max(s,l+i/2)}return e===1/0||o===1/0?null:{minX:e,maxX:n,minY:o,maxY:s}}d(ho,"boundsForChildren");function ls(t,e){const n=t.padding??20;t.x=(e.minX+e.maxX)/2,t.y=(e.minY+e.maxY)/2,t.width=Math.max(0,e.maxX-e.minX)+n,t.height=Math.max(0,e.maxY-e.minY)+n}d(ls,"applyGroupBounds");function fs(t){const e=uo(t),n=t.filter(o=>o.isGroup&&o.parentId).sort((o,s)=>_n(s,e)-_n(o,e));for(const o of n){const s=t.filter(a=>a.parentId===o.id),r=ho(s);r&&ls(o,r)}}d(fs,"recomputeNestedGroupBounds");function tn(t,e){const n=t.nodes??[],o=t.edges??[],s=n.filter(f=>!f.isGroup);let r=1/0,a=-1/0;for(const f of s){const i=f[e];typeof i=="number"&&(r=Math.min(r,i),a=Math.max(a,i))}if(!Number.isFinite(r)||!Number.isFinite(a))return!1;const l=d(f=>r+a-f,"mirror");for(const f of n){const i=f[e];typeof i=="number"&&(f[e]=l(i));const g=f.groupTitleRect;g&&(f.groupTitleRect=e==="x"?{...g,left:l(g.right),right:l(g.left)}:{...g,top:l(g.bottom),bottom:l(g.top)})}for(const f of o)for(const i of f.points??[])i[e]=l(i[e]);return!0}d(tn,"mirrorAxis");function ds(t){return(t.nodes??[]).some(n=>!n.isGroup)?tn(t,"y"):!0}d(ds,"applyBtDirectionTransform");function us(t,e="LR"){const n=t.nodes??[],o=t.edges??[],s=n.filter(P=>!P.isGroup);let r=1/0,a=1/0;for(const P of s){const G=P.x??0,j=P.y??0;G0?Math.max(1,g/x):1;for(const P of s){const G=P.x??0,J=((P.y??0)-a)*C+l,dt=G-r;P.x=J,P.y=dt}for(const P of o)if(P.points)for(const G of P.points){const j=G.x,dt=(G.y-a)*C+l,mt=j-r;G.x=dt,G.y=mt}fs(n);const h=n.filter(P=>P.isGroup&&!P.parentId);if(h.length===0)return e==="RL"&&tn(t,"x"),!0;const p=uo(n),c=new Map;for(const P of n){if(P.isGroup)continue;const G=as(P,p);if(!G)continue;const j=c.get(G)??[];j.push(P),c.set(G,j)}let y=0;for(const P of h){const G=P.padding??0;G>y&&(y=G)}const v=[];let M=1/0,E=-1/0;for(const P of h){const G=c.get(P.id)??[],j=ho(G);j&&(M=Math.min(M,j.minX),E=Math.max(E,j.maxX),v.push({lane:P,contentTop:j.minY,contentBottom:j.maxY,centerY:(j.minY+j.maxY)/2}))}if(M===1/0||E===-1/0)return!0;const T=Math.max(0,E-M),m=Math.max(y,10),I=T+2*m,w=l+I,O=(M+E)/2-I/2-l,F=O+w/2,H=Math.max(y,l);v.sort((P,G)=>P.centerY-G.centerY);for(let P=0;PC.cy?v.bottom:v.top,H=C.cx+M;if(H<=v.left+se||H>=v.right-se)continue;E={x:H,y:F},T={x:H,y:l.y},m={x:l.x,y:l.y}}else{const F=h.cx>C.cx?v.right:v.left,H=C.cy+M;if(H<=v.top+se||H>=v.bottom-se)continue;E={x:F,y:H},T={x:l.x,y:H},m={x:l.x,y:l.y}}const I=oe(E,T,se),w=oe(T,m,se);if(I&&w||!I&&wt(E,T,o,[g],1)||!w&&wt(T,m,o,[x],1))continue;const R=!I&&Ke(E,T,t,s,{epsilon:se,skipDegenerateOther:!0}),k=!w&&Ke(T,m,t,s,{epsilon:se,skipDegenerateOther:!0});if(!(R||k)){I?y=[T,m]:w?y=[E,T]:y=[E,T,m];break}}y&&(s.points=y)}}d(hs,"portSwapToLShape");function gs(t,e){const{realNodeRects:r,labelNodeRects:a}=me(e.values());for(const l of t){if(l.isLayoutOnly)continue;const f=l.points;if(!f||f.length<4)continue;const i=pt(f,.001);if(i.length<4)continue;const g=i.length-1,x=i[g],C=i[g-1],h=i[g-2],p=x.x-C.x,c=x.y-C.y,y=Math.hypot(p,c);if(y>=10||y<.001)continue;const v=C.x-h.x,M=C.y-h.y;if(Math.hypot(v,M)<.001)continue;const T=Tt(C,x,.001),m=At(C,x,.001),I=Tt(h,C,.001),w=At(h,C,.001);if(!(T&&w||m&&I))continue;const R=l.end,k=l.start,O=R?e.get(R):void 0;if(!O)continue;const F=O.x??0,H=O.y??0,P=qt(O);if(!P)continue;let G,j;if(w){const W=M<0;G={x:F,y:h.y},j={x:F,y:W?P.bottom:P.top}}else{const W=v>0;G={x:h.x,y:H},j={x:W?P.right:P.left,y:H}}if(wt(G,j,r,R?[R]:[],-2)||wt(G,j,a,[],-2))continue;if(k){const W=e.get(k),et=W?qt(W):void 0;if(et&&so(G,et,2))continue}const J=d((W,et)=>`${W.x.toFixed(3)},${W.y.toFixed(3)}|${et.x.toFixed(3)},${et.y.toFixed(3)}`,"ownSegmentKey"),dt=new Set;for(let W=0;W{for(const at of t){if(at===l||at.isLayoutOnly)continue;const gt=at.points;if(!(!gt||gt.length<2))for(let xt=0;xt=0){const W=i[g-3],et=[k,R].filter(at=>!!at);if(wt(W,G,r,et,-2)||mt(W,G))continue}const Pt=[...i.slice(0,g-2),G,j];l.points=Pt;const Q=l.labelNodeId;if(Q){const W=e.get(Q);if(W){const et=W.width??0,at=W.height??0;if(et>0&&at>0){let gt,xt,vt=-1;for(let Vt=0;Vt=et+2||de&&te>=at+2)&&te>vt&&(vt=te,gt=(jt.x+Ut.x)/2,xt=(jt.y+Ut.y)/2)}gt!==void 0&&xt!==void 0&&(W.x=gt,W.y=xt)}}}}}d(gs,"collapseShortTerminalStub");var Z=.001,Ft=8,it=Re,xn=d((t,e)=>ft(t,e,Z)||ht(t,e,Z),"orthogonallyAligned");function ps(t,e){const s=d((h,p)=>{const c=h.x??0,y=h.y??0,v=p.x-c,M=p.y-y;let E=(h.width??0)/2,T=(h.height??0)/2;return Math.abs(M)*E>Math.abs(v)*T?(M<0&&(T=-T),{x:c+(M===0?0:T*v/M),y:y+T}):(v<0&&(E=-E),{x:c+E,y:y+(v===0?0:E*M/v)})},"rectIntersect"),r=d((h,p)=>{const c=pt(h.points??[]);if(c.length<2)return;const y=p?h.start:h.end,v=y?e.get(y):void 0,M=v?qt(v):void 0;if(!v||!y||!M)return;const E=p?c[0]:c[c.length-1],T=p?c[1]:c[c.length-2],m=s(v,E);let I=E;if(xn(T,m)&&(I=T),ft(m,I,Z))return{edge:h,edgeId:String(h.id??""),nodeId:y,atStart:p,orientation:"V",coord:m.x,min:Math.min(m.y,I.y),max:Math.max(m.y,I.y),boundary:m,railEnd:I,rect:M};if(ht(m,I,Z))return{edge:h,edgeId:String(h.id??""),nodeId:y,atStart:p,orientation:"H",coord:m.y,min:Math.min(m.x,I.x),max:Math.max(m.x,I.x),boundary:m,railEnd:I,rect:M}},"terminalLaneFor"),a=d((h,p)=>Math.max(0,Math.min(h.max,p.max)-Math.max(h.min,p.min)),"projectedOverlapLength"),l=d((h,p)=>h.nodeId!==p.nodeId||h.orientation!==p.orientation?!1:h.orientation==="H"?(Math.abs(h.boundary.x-h.rect.left)<1||Math.abs(h.boundary.x-h.rect.right)<1)&&ft(h.boundary,p.boundary,1):(Math.abs(h.boundary.y-h.rect.top)<1||Math.abs(h.boundary.y-h.rect.bottom)<1)&&ht(h.boundary,p.boundary,1),"sameTerminalFace"),f=d((h,p)=>h.nodeId!==p.nodeId||h.orientation!==p.orientation?!1:a(h,p)>=Ft&&Math.abs(h.coord-p.coord)<.5,"exactTerminalLaneConflict"),i=d((h,p)=>{if(h.nodeId!==p.nodeId||h.orientation!==p.orientation||h.orientation!=="H"||h.atStart===p.atStart)return!1;const c=a(h,p);if(c2*y?!1:l(h,p)&&Math.abs(h.coord-p.coord)<16},"nearTerminalLaneConflict"),g=d((h,p)=>{const c=pt(h.edge.points??[]);if(c.length<2)return;const y=h.orientation==="V"?{x:h.boundary.x+p,y:h.boundary.y}:{x:h.boundary.x,y:h.boundary.y+p},v=h.orientation==="V"?{x:h.railEnd.x+p,y:h.railEnd.y}:{x:h.railEnd.x,y:h.railEnd.y+p};if(!d(()=>Math.abs(h.boundary.y-h.rect.top)<1||Math.abs(h.boundary.y-h.rect.bottom)<1?ht(y,h.boundary,Z)&&y.x>=h.rect.left+1&&y.x<=h.rect.right-1:Math.abs(h.boundary.x-h.rect.left)<1||Math.abs(h.boundary.x-h.rect.right)<1?ft(y,h.boundary,Z)&&y.y>=h.rect.top+1&&y.y<=h.rect.bottom-1:!1,"boundaryStaysOnSameFace")())return;if(h.atStart){const I=c.length>1&&oe(c[1],h.railEnd,Z),w=c.slice(I?2:1),R=w[0];return R&&!xn(R,v)?void 0:[y,v,...w]}const E=c.length>1&&oe(c[c.length-2],h.railEnd,Z),T=c.slice(0,E?-2:-1),m=T[T.length-1];if(!(m&&!xn(m,v)))return[...T,v,y]},"shiftedCandidate"),x=d(h=>{const p=h.edge,c=pt(p.points??[]);if(c.length!==2)return!1;const y=p.start,v=p.end,M=y?e.get(y):void 0,E=v?e.get(v):void 0;if(!M||!E)return!1;const T=M.x??0,m=M.y??0,I=E.x??0,w=E.y??0,[R,k]=c;return ht(R,k,Z)&&Math.abs(m-w)<1&&Math.abs(T-I)>1||ft(R,k,Z)&&Math.abs(T-I)<1&&Math.abs(m-w)>1},"laneIsStraightCollinearConnector"),C=[-7,7,-14,14,-21,21];for(let h=0;h<8;h++){const p=t.filter(y=>!y.isLayoutOnly).flatMap(y=>[r(y,!0),r(y,!1)]).filter(y=>!!y);let c=!1;for(let y=0;y{const R=x(I),k=x(w);return R!==k?Number(R)-Number(k):+!w.atStart-+!I.atStart});for(const I of m){for(const w of C){const R=g(I,w);if(!R)continue;const k=r({...I.edge,points:R},I.atStart);if(!(!k||p.some(O=>O.edge!==I.edge&&(f(k,O)||T&&i(k,O))))){I.edge.points=R,c=!0;break}}if(c)break}}if(!c)return}}d(ps,"separateSharedRenderedTerminalLanes");function ms(t,e){const{realNodeRects:o,labelNodeRects:s}=me(e.values()),r=d((l,f)=>{const i=l.start,g=l.end,x=it(f);if(x.length!==f.length-1)return!1;const C=[i,g].filter(h=>!!h);for(const h of x)if(wt(h.a,h.b,o,C,-2)||wt(h.a,h.b,s,[],-2))return!1;for(const h of t){if(h===l||h.isLayoutOnly)continue;const p=h.points;if(!(!p||p.length<2)){for(const c of x)for(const y of it(pt(p)))if(ce(c,y,.5)>=Ft||le(c.a,c.b,y.a,y.b,Z))return!1}}return!0},"candidateIsSafe"),a=d((l,f)=>{if(f+4>=l.length)return;const i=l[f],g=l[f+1],x=l[f+2],C=l[f+3],h=l[f+4],p=Tt(i,g)&&At(g,x)&&Tt(x,C)&&At(C,h)&&ft(i,C,Z)&&ft(i,h,Z)&&ft(g,x,Z)&&(g.x-i.x)*(C.x-x.x)<0,c=At(i,g)&&Tt(g,x)&&At(x,C)&&Tt(C,h)&&ht(i,C,Z)&&ht(i,h,Z)&&ht(g,x,Z)&&(g.y-i.y)*(C.y-x.y)<0;if(p||c)return pt([...l.slice(0,f+1),h,...l.slice(f+5)]);if(f+5>=l.length)return;const y=l[f+5],v=At(i,g)&&Tt(g,x)&&At(x,C)&&Tt(C,h)&&At(h,y)&&ft(i,h,Z)&&ft(i,y,Z)&&ft(x,C,Z)&&(x.x-g.x)*(h.x-C.x)<0,M=Tt(i,g)&&At(g,x)&&Tt(x,C)&&At(C,h)&&Tt(h,y)&&ht(i,h,Z)&&ht(i,y,Z)&&ht(x,C,Z)&&(x.y-g.y)*(h.y-C.y)<0;if(!(!v&&!M))return pt([...l.slice(0,f+1),y,...l.slice(f+6)])},"withoutDogleg");for(let l=0;l<8;l++){let f=!1;for(const i of t){if(i.isLayoutOnly)continue;const g=pt(i.points??[]);for(let x=0;x<=g.length-5;x++){const C=a(g,x);if(!(!C||!r(i,C))){i.points=C,f=!0;break}}if(f)break}if(!f)return}}d(ms,"collapseRedundantRectangularDoglegs");function Dn(t,e){const{realNodeRects:r,labelNodeRects:a}=me(e.values()),l=t.filter(p=>!p.isLayoutOnly),f=d((p,c,y)=>pt(p===c?y??[]:p.points??[]),"pointsFor"),i=d((p,c)=>{let y=0;for(let v=0;v{const c=it(p);if(c.length!==3)return;const y=c[1];if(!(c[0].horizontal===y.horizontal||c[2].horizontal===y.horizontal))return{index:y.index,horizontal:y.horizontal,vertical:y.vertical,segment:y}},"middleRail"),x=d((p,c)=>{const y=[p.start,p.end].filter(v=>!!v);return r.filter(v=>{if(y.includes(v.id))return!1;const M=v.rect;return c.horizontal?zt(c.a.x,c.b.x,M.left,M.right)>=Ft&&c.a.y>=M.top-2&&c.a.y<=M.bottom+2:zt(c.a.y,c.b.y,M.top,M.bottom)>=Ft&&c.a.x>=M.left-2&&c.a.x<=M.right+2})},"blockingRectsFor"),C=d((p,c,y)=>{const v=p.map(E=>({...E}));if(c.horizontal)v[c.index].y=y,v[c.index+1].y=y;else if(c.vertical)v[c.index].x=y,v[c.index+1].x=y;else return;const M=ae(pt(v));return it(M).length===M.length-1?M:void 0},"candidateByMovingRail"),h=d((p,c,y)=>{const v=[p.start,p.end].filter(E=>!!E),M=it(c);if(M.length!==c.length-1)return!1;for(const E of M)if(wt(E.a,E.b,r,v,-2)||wt(E.a,E.b,a,[],-2))return!1;for(const E of l)if(E!==p){for(const T of M)for(const m of it(f(E)))if(ce(T,m,.5)>=Ft)return!1}return i(p,c)<=y},"candidateIsSafe");for(let p=0;p<8;p++){const c=i();let y=!1;for(const v of l){const M=f(v),E=g(M);if(!E)continue;const T=x(v,E.segment);if(T.length===0)continue;const m=E.horizontal?[Math.min(...T.map(I=>I.rect.top))-20,Math.max(...T.map(I=>I.rect.bottom))+20]:[Math.min(...T.map(I=>I.rect.left))-20,Math.max(...T.map(I=>I.rect.right))+20];for(const I of m){const w=C(M,E.segment,I);if(!(!w||!h(v,w,c))){v.points=w,y=!0;break}}if(y)break}if(!y)return}}d(Dn,"liftObstacleHuggingSameSideRails");function Hn(t,e){const o=d(f=>{const i=f.groupTitleRect;if(!(!i||typeof i.left!="number"||typeof i.right!="number"||typeof i.top!="number"||typeof i.bottom!="number"||!Number.isFinite(i.left)||!Number.isFinite(i.right)||!Number.isFinite(i.top)||!Number.isFinite(i.bottom)||i.right<=i.left||i.bottom<=i.top))return{left:i.left,right:i.right,top:i.top,bottom:i.bottom}},"validTitleRect"),s=d(f=>{if(!f.isGroup||f.parentId)return;const i=f.direction,g=typeof i=="string"?i.toUpperCase():"";if(g==="LR"||g==="RL"||g==="BT")return;const x=o(f),C=f.y,h=f.height;if(!x||typeof C!="number"||typeof h!="number"||!Number.isFinite(C)||!Number.isFinite(h)||h<=0)return;const p=x.right-x.left,c=x.bottom-x.top;if(!(c<=0||p{if(!f.horizontal)return!1;const g=f.a.y;return g<=i.top+Z||g>=i.bottom-Z?!1:zt(f.a.x,f.b.x,i.left,i.right)>=Ft},"horizontalSegmentIntersectsTitle"),a=[...e.values()].map(s).filter(f=>!!f);if(a.length===0)return;let l=0;for(const f of t){if(f.isLayoutOnly)continue;const i=pt(f.points??[]);for(const g of it(i))for(const x of a)r(g,x.rect)&&(l=Math.max(l,x.rect.bottom-g.a.y+4))}if(!(l<=Z))for(const f of a){const i=f.node.y,g=f.node.height;typeof i!="number"||typeof g!="number"||!Number.isFinite(i)||!Number.isFinite(g)||g<=0||(f.node.y=i-l/2,f.node.height=g+l,f.node.groupTitleRect={...f.rect,top:f.rect.top-l,bottom:f.rect.bottom-l})}}d(Hn,"liftTopLaneTitleBandsAboveRails");function Xn(t,e){const o=d(i=>{const g=i.groupTitleRect;if(!(!g||typeof g.left!="number"||typeof g.right!="number"||typeof g.top!="number"||typeof g.bottom!="number"||!Number.isFinite(g.left)||!Number.isFinite(g.right)||!Number.isFinite(g.top)||!Number.isFinite(g.bottom)||g.right<=g.left||g.bottom<=g.top))return{left:g.left,right:g.right,top:g.top,bottom:g.bottom}},"validTitleRect"),s=d(i=>{if(!i.isGroup||i.parentId||i.direction!=="LR")return;const x=o(i),C=i.x,h=i.width;if(!x||typeof C!="number"||typeof h!="number"||!Number.isFinite(C)||!Number.isFinite(h)||h<=0)return;const p=x.right-x.left,c=x.bottom-x.top;if(!(p<=0||c{if(!i.vertical)return!1;const x=i.a.x;return x<=g.left+Z||x>=g.right-Z?!1:zt(i.a.y,i.b.y,g.top,g.bottom)>=Ft},"verticalSegmentIntersectsTitle"),a=d((i,g)=>{if(!i.horizontal)return!1;const x=i.a.y;return x<=g.top+Z||x>=g.bottom-Z?!1:zt(i.a.x,i.b.x,g.left,g.right)>=Ft},"horizontalSegmentIntersectsTitle"),l=[...e.values()].map(s).filter(i=>!!i);if(l.length===0)return;let f=0;for(const i of t){if(i.isLayoutOnly)continue;const g=pt(i.points??[]);for(const x of it(g))for(const C of l)if(r(x,C.rect))f=Math.max(f,C.rect.right-x.a.x+4);else if(a(x,C.rect)){const h=Math.min(x.a.x,x.b.x);f=Math.max(f,C.rect.right-h+4)}}if(!(f<=Z))for(const i of l){const g=i.node.x,x=i.node.width;typeof g!="number"||typeof x!="number"||!Number.isFinite(g)||!Number.isFinite(x)||x<=0||(i.node.x=g-f/2,i.node.width=x+f,i.node.groupTitleRect={...i.rect,left:i.rect.left-f,right:i.rect.right-f})}}d(Xn,"shiftLeftLaneTitleBandsLeftOfRails");function ys(t,e){const{realNodeRects:o}=me(e.values()),s=t.filter(p=>!p.isLayoutOnly),r=d((p,c=new Map)=>pt(c.get(p)??p.points??[]),"replacementPointsFor"),a=d((p=new Map)=>{let c=0;for(let y=0;ys.reduce((c,y)=>c+Qt(r(y,p)),0),"totalBends"),f=d(p=>{const c=r(p);if(c.length<4)return;const y=c[c.length-2],v=c[c.length-1];if(!(!Tt(y,v,Z)&&!At(y,v,Z)))return{tailStart:y,terminal:v}},"terminalTailFor"),i=d((p,c)=>{const y=r(p);if(y.length<3)return;const v=y[0],M=y[1];let E;if(Tt(v,M,Z))E={x:M.x,y:c.tailStart.y};else if(At(v,M,Z))E={x:c.tailStart.x,y:M.y};else return;const T=ae(pt([v,M,E,c.tailStart,c.terminal]));return it(T).length===T.length-1?T:void 0},"candidateWithDestinationTail"),g=d((p,c)=>{const y=[p.start,p.end].filter(v=>!!v);for(const v of it(c))if(wt(v.a,v.b,o,y,-2))return!0;return!1},"pathHasNodeHit"),x=d((p,c,y)=>{for(const v of s)if(v!==p){for(const M of it(c))for(const E of it(r(v,y)))if(ce(M,E,.5)>=Ft)return!0}return!1},"pathHasSharedTrack"),C=d((p,c,y)=>!g(p,c)&&!x(p,c,y),"candidateIsSafe"),h=d(()=>{const p=new Map;for(const c of s){const y=c.end;if(!y||!e.has(y)||r(c).length<4)continue;const M=p.get(y)??[];M.push(c),p.set(y,M)}return p},"edgesByDestination");for(let p=0;p<4;p++){const c=a();if(c===0)return;const y=l();let v,M=c,E=y;for(const T of h().values())for(let m=0;m=c||G>M||G===M&&j>=E||(v=P,M=G,E=j)}if(!v)return;for(const[T,m]of v)T.points=m}}d(ys,"swapDestinationTerminalTailsToReduceCrossings");function xs(t,e){const{realNodeRects:r,labelNodeRects:a}=me(e.values()),l=t.filter(T=>!T.isLayoutOnly),f=d((T,m=new Map)=>pt(m.get(T)??T.points??[]),"replacementPointsFor"),i=d((T=new Map)=>{let m=0;for(let I=0;Il.reduce((m,I)=>m+Qt(f(I,T)),0),"totalBends"),x=d(T=>{const m=T.start,I=T.end,w=m?e.get(m):void 0,R=I?e.get(I):void 0,k=w?qt(w):void 0,O=R?qt(R):void 0;return k&&O?{src:k,dst:O}:void 0},"endpointRectsFor"),C=d((T,m,I)=>{if(I.index<=0||I.index+1>=m.length-1)return;const w=x(T);if(w){if(I.vertical){const R=I.a.x,k=Math.min(w.src.left,w.dst.left),O=Math.max(w.src.right,w.dst.right),F=RO+Z?"right":void 0;return F?{edge:T,points:m,segmentIndex:I.index,axis:"vertical",side:F,coord:R,min:Math.min(I.a.y,I.b.y),max:Math.max(I.a.y,I.b.y)}:void 0}if(I.horizontal){const R=I.a.y,k=Math.min(w.src.top,w.dst.top),O=Math.max(w.src.bottom,w.dst.bottom),F=RO+Z?"bottom":void 0;return F?{edge:T,points:m,segmentIndex:I.index,axis:"horizontal",side:F,coord:R,min:Math.min(I.a.x,I.b.x),max:Math.max(I.a.x,I.b.x)}:void 0}}},"externalRailForSegment"),h=d(()=>{const T=[];for(const m of l){const I=f(m);for(const w of it(I)){const R=C(m,I,w);R&&T.push(R)}}return T},"collectExternalRails"),p=d((T,m)=>T.edge!==m.edge&&T.axis===m.axis&&T.side===m.side&&zt(T.min,T.max,m.min,m.max)>=Ft,"railsInteract"),c=d(T=>{const m=[],I=new Set;for(const w of T){if(I.has(w))continue;const R=[w],k=[];for(I.add(w);R.length>0;){const O=R.pop();k.push(O);for(const F of T)!I.has(F)&&p(O,F)&&(I.add(F),R.push(F))}k.length>1&&m.push(k)}return m},"connectedComponents"),y=d(T=>{const m=[];for(const I of T)m.some(w=>Math.abs(w-I.coord){const m=T.map(R=>R.coord),I=y(T),w=[];if(T.length<=6){const R=new Array(I.length).fill(!1),k=[],O=d(()=>{if(k.length===T.length){k.some((F,H)=>Math.abs(F-m[H])>=Z)&&w.push([...k]);return}for(const[F,H]of I.entries())R[F]||(R[F]=!0,k.push(H),O(),k.pop(),R[F]=!1)},"visit");return O(),w}for(let R=0;R{const I=new Map;for(const[R,k]of T.entries()){const O=m[R],F=I.get(k.edge)??k.points.map(H=>({x:H.x,y:H.y}));k.axis==="vertical"?(F[k.segmentIndex].x=O,F[k.segmentIndex+1].x=O):(F[k.segmentIndex].y=O,F[k.segmentIndex+1].y=O),I.set(k.edge,F)}const w=new Map;for(const[R,k]of I){const O=ae(pt(k));if(it(O).length!==O.length-1)return;w.set(R,O)}return w},"replacementsForAssignment"),E=d(T=>{for(const[m,I]of T){const w=[m.start,m.end].filter(R=>!!R);for(const R of it(I))if(wt(R.a,R.b,r,w,-2)||wt(R.a,R.b,a,[],-2))return!1}for(let m=0;m=Ft)return!1}}return!0},"candidateIsSafe");for(let T=0;T<4;T++){const m=i();if(m===0)return;let I,w=m,R=g(),k=Number.POSITIVE_INFINITY;for(const O of c(h()))for(const F of v(O)){const H=M(O,F);if(!H||!E(H))continue;const P=i(H);if(P>=m)continue;const G=g(H),j=O.reduce((J,dt,mt)=>J+Math.abs(F[mt]-dt.coord),0);P>w||P===w&&(G>R||G===R&&j>=k)||(I=H,w=P,R=G,k=j)}if(!I)return;for(const[O,F]of I)O.points=F}}d(xs,"reassignCrossingExternalRailChannels");function bs(t,e){const{realNodeRects:o,labelNodeRects:s}=me(e.values()),r=t.filter(h=>!h.isLayoutOnly),a=d((h,p,c)=>pt(h===p?c??[]:h.points??[]),"pointsFor"),l=d(h=>it(h).reduce((p,c)=>{const y=c.a.x-c.b.x,v=c.a.y-c.b.y;return p+Math.hypot(y,v)},0),"pathLength"),f=d((h,p)=>{let c=0;for(let y=0;y{if(h.horizontal){const c=h.a.y;return(Math.abs(c-p.top)<1||Math.abs(c-p.bottom)<1)&&zt(h.a.x,h.b.x,p.left,p.right)>=Ft}if(h.vertical){const c=h.a.x;return(Math.abs(c-p.left)<1||Math.abs(c-p.right)<1)&&zt(h.a.y,h.b.y,p.top,p.bottom)>=Ft}return!1},"segmentRunsAlongRectBorder"),g=d(h=>{const p=[h.start,h.end].filter(y=>!!y),c=[];for(const y of p){const v=e.get(y),M=v?qt(v):void 0;M&&c.push(M)}return c},"endpointRectsFor"),x=d((h,p)=>{if(p+3>=h.length)return[];const c=h[p],y=h[p+1],v=h[p+2],M=h[p+3],E=Tt(c,y,Z)&&At(y,v,Z)&&Tt(v,M,Z),T=At(c,y,Z)&&Tt(y,v,Z)&&At(v,M,Z);if(!E&&!T)return[];if(!(E?Math.sign(y.x-c.x)!==Math.sign(M.x-v.x):Math.sign(y.y-c.y)!==Math.sign(M.y-v.y)))return[];const I=ft(c,M,Z)||ht(c,M,Z)?[]:[{x:c.x,y:M.y},{x:M.x,y:c.y}],w=I.length===0?[[...h.slice(0,p+1),...h.slice(p+3)]]:I.map(k=>[...h.slice(0,p+1),k,...h.slice(p+3)]),R=new Set;return w.map(k=>ae(pt(k))).filter(k=>{if(it(k).length!==k.length-1||!k.some(F=>oe(F,M,Z)))return!1;const O=k.map(F=>`${F.x.toFixed(3)},${F.y.toFixed(3)}`).join("|");return R.has(O)?!1:(R.add(O),!0)})},"shortcutCandidatesAt"),C=d((h,p,c)=>{const y=[h.start,h.end].filter(M=>!!M),v=g(h);for(const M of it(p))if(wt(M.a,M.b,o,y,-2)||wt(M.a,M.b,s,[],-2)||v.some(E=>i(M,E)))return!1;for(const M of r)if(M!==h){for(const E of it(p))for(const T of it(a(M)))if(ce(E,T,.5)>=Ft)return!1}return f(h,p)<=c},"candidateIsSafe");for(let h=0;h<8;h++){const p=f();let c,y,v=p,M=Number.POSITIVE_INFINITY,E=Number.POSITIVE_INFINITY;for(const T of r){const m=a(T),I=Qt(m,Z),w=l(m);for(let R=0;R<=m.length-4;R++)for(const k of x(m,R)){const O=Qt(k,Z),F=l(k);if(!(Ov||P===v&&(O>M||O===M&&F>=E)||(c=T,y=k,v=P,M=O,E=F)}}if(!c||!y)return;c.points=y}}d(bs,"shortcutRedundantOrthogonalJogs");function Ms(t,e){const a=[];for(const N of e.values()){if(N.isGroup||N.isEdgeLabel)continue;const _=N.x??0,D=N.y??0,V=qt(N);V&&a.push({id:String(N.id??""),cx:_,cy:D,rect:V})}if(a.length===0)return;const l=new Map(a.map(N=>[N.id,N])),f=a.map(N=>({id:N.id,rect:N.rect})),i=["top","bottom","left","right"],g={top:Math.min(...a.map(N=>N.rect.top))-20,bottom:Math.max(...a.map(N=>N.rect.bottom))+20,left:Math.min(...a.map(N=>N.rect.left))-20,right:Math.max(...a.map(N=>N.rect.right))+20},x=t.filter(N=>!N.isLayoutOnly),C=new Map(x.map((N,_)=>[N,_])),h=d(N=>{const _=N==="left"||N==="top"?-1:1,D=[];for(let V=0;V<=2;V++)D.push(g[N]+_*20*V);return D},"outwardTracksForSide"),p=d((N,_=new Map)=>pt(_.get(N)??N.points??[]),"replacementPointsFor"),c=d((N,_)=>{let D=0;for(const V of N)for(const u of _)le(V.a,V.b,u.a,u.b,Z)&&D++;return D},"crossingCountBetweenSegments"),y=d((N,_)=>c(it(N),it(_)),"crossingCountBetweenPaths"),v=d((N=new Map)=>{let _=0;const D=[],V=new Set,u=[],b=d(S=>{V.has(S)||(V.add(S),u.push(S))},"addEdge");for(let S=0;S0&&(_+=q,D.push({first:L,second:U,count:q}),b(L),b(U))}}return u.sort((S,L)=>(C.get(S)??0)-(C.get(L)??0)),{count:_,pairs:D,edgeSet:V,edges:u}},"crossingSnapshot"),M=d((N,_)=>{const D=new Set(_.keys());if(D.size===0)return N.count;let V=0;for(const b of N.pairs)(D.has(b.first)||D.has(b.second))&&(V+=b.count);let u=0;for(let b=0;b{const _=new Map;for(const u of N.pairs){const b=_.get(u.first)??new Set;b.add(u.second),_.set(u.first,b);const S=_.get(u.second)??new Set;S.add(u.first),_.set(u.second,S)}const D=[],V=new Set;for(const u of N.edges){if(V.has(u))continue;const b=[u],S=[];for(V.add(u);b.length>0;){const L=b.pop();S.push(L);for(const A of _.get(L)??[])V.has(A)||(V.add(A),b.push(A))}S.sort((L,A)=>(C.get(L)??0)-(C.get(A)??0)),S.length>1&&D.push(S)}return D},"crossingComponents"),T=d(N=>[N.start,N.end].filter(_=>!!_),"endpointIdsFor"),m=d(N=>{const _=[];for(const D of E(N)){const V=new Set(D),u=new Set(D.flatMap(S=>T(S))),b=[...D];for(const S of x)V.has(S)||T(S).some(L=>u.has(L))&&b.push(S);b.sort((S,L)=>(C.get(S)??0)-(C.get(L)??0)),_.push(b)}return _},"pairSearchGroups"),I=d((N,_,D)=>M(N,new Map([[_,D]])),"crossingCountWithSingleReplacement"),w=d(N=>{const _=new Map;for(const D of N.pairs)_.set(D.first,(_.get(D.first)??0)+D.count),_.set(D.second,(_.get(D.second)??0)+D.count);return _},"currentCrossingsByEdge"),R=d(N=>N.slice(1).reduce((_,D,V)=>{const u=N[V];return _+Math.abs(D.x-u.x)+Math.abs(D.y-u.y)},0),"pathLength"),k=d((N=new Map)=>x.reduce((_,D)=>_+Qt(p(D,N)),0),"totalBends"),O=d((N=new Map)=>x.reduce((_,D)=>_+R(p(D,N)),0),"totalLength"),F=d((N,_,D=new Map)=>{const V=it(_);for(const u of x)if(u!==N){for(const b of V)for(const S of it(p(u,D)))if(ce(b,S,.5)>=Ft)return!0}return!1},"pathHasSegmentConflict"),H=d((N,_)=>{const D=[N.start,N.end].filter(V=>!!V);for(const V of it(_))if(wt(V.a,V.b,f,D,-2))return!0;return!1},"pathHitsNode"),P=d((N,_)=>{const D=ae(pt(_));it(D).length===D.length-1&&N.push(D)},"pushOrthogonalCandidate"),G=d(N=>N==="left"||N==="right","sideIsHorizontal"),j=d((N,_,D)=>{switch(_){case"left":return Math.min(N.x,D.x)-20;case"right":return Math.max(N.x,D.x)+20;case"top":return Math.min(N.y,D.y)-20;case"bottom":return Math.max(N.y,D.y)+20}},"localTrackForSameSide"),J=d((N,_,D,V)=>{const u=D==="left"||D==="top"?-1:1,b=[j(_,D,V),g[D]];for(const S of b)for(let L=0;L<=2;L++)P(N,io(_,D,V,S+u*20*L))},"addSameSideCandidates"),dt=d((N,_,D,V,u)=>{for(const b of h(D))for(const S of h(u))P(N,[_,{x:b,y:_.y},{x:b,y:S},{x:V.x,y:S},V])},"addHorizontalToVerticalCandidates"),mt=d((N,_,D,V,u)=>{for(const b of h(D))for(const S of h(u))P(N,[_,{x:_.x,y:b},{x:S,y:b},{x:S,y:V.y},V])},"addVerticalToHorizontalCandidates"),kt=d((N,_,D,V,u)=>{const b=[...h("top"),...h("bottom")];for(const S of h(D))for(const L of h(u))for(const A of b)P(N,[_,{x:S,y:_.y},{x:S,y:A},{x:L,y:A},{x:L,y:V.y},V])},"addHorizontalPairCandidates"),Pt=d((N,_,D,V,u)=>{const b=[...h("left"),...h("right")];for(const S of h(D))for(const L of h(u))for(const A of b)P(N,[_,{x:_.x,y:S},{x:A,y:S},{x:A,y:L},{x:V.x,y:L},V])},"addVerticalPairCandidates"),Q=d(N=>{const _=new Set;return N.map(D=>pt(D)).filter(D=>{const V=D.map(u=>`${u.x.toFixed(3)},${u.y.toFixed(3)}`).join("|");return _.has(V)||D.length<2?!1:(_.add(V),!0)})},"dedupeCandidatePaths"),W=d((N,_,D,V)=>{const u=[],b=ro(N,_,D,V,20,Z);b&&P(u,b),_===V&&J(u,N,_,D);const S=G(_),L=G(V);return S&&!L?dt(u,N,_,D,V):!S&&L?mt(u,N,_,D,V):S?kt(u,N,_,D,V):Pt(u,N,_,D,V),Q(u)},"buildCandidatesForSides"),et=d((N,_,D,V)=>{const u=[...h("left"),...h("right")],b=[...h("top"),...h("bottom")];for(const S of i){const L=Ie(V,S),A=S==="top"||S==="bottom"?h(S):b;for(const B of u){P(N,[_,D,{x:B,y:D.y},{x:B,y:L.y},L]);for(const U of A)P(N,[_,D,{x:B,y:D.y},{x:B,y:U},{x:L.x,y:U},L])}}},"addVerticalDepartureOuterTrackCandidates"),at=d((N,_,D,V)=>{const u=[...h("left"),...h("right")],b=[...h("top"),...h("bottom")];for(const S of i){const L=Ie(V,S),A=S==="left"||S==="right"?h(S):u;for(const B of b){P(N,[_,D,{x:D.x,y:B},{x:L.x,y:B},L]);for(const U of A)P(N,[_,D,{x:D.x,y:B},{x:U,y:B},{x:U,y:L.y},L])}}},"addHorizontalDepartureOuterTrackCandidates"),gt=d(N=>{const _=N.start,D=N.end,V=D?l.get(D):void 0;if(!_||!V)return[];const u=pt(N.points??[]);if(u.length<4)return[];const b=u[0],S=u[1],L=[];return At(b,S,Z)?et(L,b,S,V):Tt(b,S,Z)&&at(L,b,S,V),L},"terminalPreservingOuterTrackCandidates"),xt=d(N=>{const _=N.start,D=N.end,V=_?l.get(_):void 0,u=D?l.get(D):void 0;if(!V||!u)return[];const b=[];for(const S of i){const L=Ie(V,S);for(const A of i)b.push(...W(L,S,Ie(u,A),A))}return b.push(...gt(N)),b},"candidatePathsFor"),vt=d(()=>new Map(x.map(N=>[N,it(p(N))])),"currentSegmentsByEdge"),Vt=d((N,_,D)=>{const V=new Set;for(const u of x){if(u===N)continue;const b=D.get(u)??it(p(u));_.some(S=>b.some(L=>ce(S,L,.5)>=Ft))&&V.add(u)}return V},"sharedTrackConflictsFor"),jt=d((N,_,D,V)=>{const u=new Set;return xt(N).map(S=>ae(pt(S))).filter(S=>{if(H(N,S))return!1;const L=S.map(A=>`${A.x.toFixed(3)},${A.y.toFixed(3)}`).join("|");return u.has(L)||S.length<2?!1:(u.add(L),!0)}).map(S=>{const L=it(S);let A=0;for(const B of x)B!==N&&(A+=c(L,D.get(B)??it(p(B))));return{candidate:S,candidateSegments:L,crossings:_.count-(V.get(N)??0)+A,bends:Qt(S,Z),totalBends:Qt(S),length:R(S)}}).filter(({crossings:S})=>S<=_.count).sort((S,L)=>S.crossings-L.crossings||S.bends-L.bends||S.length-L.length).slice(0,48).map(S=>({path:S.candidate,segments:S.candidateSegments,sharedTrackConflicts:Vt(N,S.candidateSegments,D),totalBends:S.totalBends,length:S.length}))},"pairCandidatesFor"),Ut=d((N,_,D,V,u,b)=>{let S=0;for(const A of N.pairs)(A.first===_||A.second===_||A.first===V||A.second===V)&&(S+=A.count);let L=c(D.segments,u.segments);for(const A of x){if(A===_||A===V)continue;const B=b.get(A)??it(p(A));L+=c(D.segments,B)+c(u.segments,B)}return N.count-S+L},"pairCrossingCount"),te=d((N,_)=>{for(const D of N.sharedTrackConflicts)if(D!==_)return!1;return!0},"conflictsOnlyWith"),Se=d((N,_)=>N.segments.some(D=>_.segments.some(V=>ce(D,V,.5)>=Ft)),"candidatesShareTrack"),de=d((N,_,D,V)=>te(_,D.edge)&&te(V,N.edge)&&!Se(_,V),"pairCandidatesAreCompatible"),Ce=d((N,_,D,V,u)=>{const b=Ut(N.current,_.edge,D,V.edge,u,N.baseSegments);if(!(b>=N.current.count))return{replacements:new Map([[_.edge,D.path],[V.edge,u.path]]),crossings:b,bends:N.currentBends-(N.baseBendsByEdge.get(_.edge)??0)-(N.baseBendsByEdge.get(V.edge)??0)+D.totalBends+u.totalBends,length:N.currentLength-(N.baseLengthByEdge.get(_.edge)??0)-(N.baseLengthByEdge.get(V.edge)??0)+D.length+u.length}},"scorePairReplacement"),an=d((N,_)=>N.crossings<_.crossings||N.crossings===_.crossings&&(N.bends<_.bends||N.bends===_.bends&&N.length<_.length),"pairScoreIsBetter"),ln=d((N,_,D,V)=>{let u=V;for(const b of _.candidates)for(const S of D.candidates){if(!de(_,b,D,S))continue;const L=Ce(N,_,b,D,S);L&&an(L,u)&&(u=L)}return u},"bestScoreForOptionPair"),fn=d(N=>{const _=k(),D=O(),V=vt(),u=w(N),b=new Map(x.map(q=>[q,Qt(p(q))])),S=new Map(x.map(q=>[q,R(p(q))])),L=new Map,A=m(N);for(const q of A)for(const z of q){if(L.has(z))continue;const Y=jt(z,N,V,u);Y.length>0&&L.set(z,{edge:z,candidates:Y})}let B={replacements:new Map,crossings:N.count,bends:_,length:D};const U={current:N,currentBends:_,currentLength:D,baseBendsByEdge:b,baseLengthByEdge:S,baseSegments:V};for(const q of A){const z=new Set(q.filter(ot=>N.edgeSet.has(ot))),Y=q.map(ot=>L.get(ot)).filter(ot=>!!ot);for(let ot=0;ot0?B.replacements:void 0},"bestPairedReplacement");for(let N=0;N<4;N++){const _=v(),D=_.count;if(D===0)return;let V,u,b=D,S=Number.POSITIVE_INFINITY;for(const A of _.edges){const B=Qt(p(A),Z);for(const U of xt(A)){const q=H(A,U),z=!q&&F(A,U),Y=I(_,A,U),ot=Qt(U,Z);q||z||!(Yb||Y===b&&ot>=S||(V=A,u=U,b=Y,S=ot)}}if(V&&u){V.points=u;continue}const L=fn(_);if(!L)return;for(const[A,B]of L)A.points=B}}d(Ms,"resolveRenderedOrthogonalCrossings");var pe=.001,Rr=8;function Is(t,e){const{nodeInfoById:n,realNodeRects:o}=sn(e),s=["top","bottom","left","right"],r=20,a={top:Math.min(...o.map(c=>c.rect.top))-r,bottom:Math.max(...o.map(c=>c.rect.bottom))+r,left:Math.min(...o.map(c=>c.rect.left))-r,right:Math.max(...o.map(c=>c.rect.right))+r},l=d((c,y,v,M)=>{const E=[],T=ro(c,y,v,M,r,pe);return T&&E.push(T),y===M&&E.push(io(c,y,v,a[y])),E},"buildOrthogonalPathCandidates"),f=d((c,y)=>{for(let v=0;v{let M=0;const E=Re(c,pe),T=y.start,m=y.end;for(const I of t){if(I===y||I.isLayoutOnly)continue;const w=I.start,R=I.end;if(!v&&T&&m&&(w===T||w===m||R===T||R===m))continue;const k=I.points;if(!(!k||k.length<2))for(const O of E)for(const F of Re(k,pe)){if(ao(O.a,O.b,F.a,F.b,pe,pe)){M++;continue}ce(O,F,pe)>=Rr&&M++}}return M},"pathConflictCount"),g=4,x=d((c,y)=>{const v=Math.abs(c.y-y.rect.top),M=Math.abs(c.y-y.rect.bottom),E=Math.abs(c.x-y.rect.left),T=Math.abs(c.x-y.rect.right);let m="top",I=v;return M{const M=C.get(c)??[];M.push({side:y,edgeId:v}),C.set(c,M)},"addFaceClaim");for(const c of t){if(c.isLayoutOnly)continue;const y=c.points??[];if(y.length<1)continue;const v=c.id??"",M=c.start,E=c.end;if(M){const T=n.get(M);T&&h(M,x(y[0],T),v)}if(E){const T=n.get(E);T&&h(E,x(y[y.length-1],T),v)}}const p=d((c,y,v)=>C.get(c)?.some(M=>M.edgeId!==v&&M.side===y)??!1,"faceIsClaimed");for(const c of t){if(c.isLayoutOnly)continue;const y=c.points;if(!y||y.length<2)continue;const v=Qt(y,pe);if(v0){const mt=i(J,c,!0);if(mt>O||mt===O&&dt>=F)continue;O=mt,F=dt,k=J;continue}i(J,c)>R||dtG.edgeId!==I));const P=C.get(E);P&&C.set(E,P.filter(G=>G.edgeId!==I)),h(M,x(k[0],T),I),h(E,x(k[k.length-1],m),I)}}}d(Is,"simplifyDetouredEdges");var Kt=.001,No=10,$e=7;function Yn(t,e){const n=e?0:t.length-1,o=e?1:-1,s=t[n],r=t[n+o];if(!s||!r)return;const a=r.x-s.x,l=r.y-s.y;if(!(Math.abs(a)+Math.abs(l)r&&We(t,Ss(r)))}d(Gn,"labelOverlapsOwnMarker");function Ve(t,e){const n=[];for(const p of t){if(p.isLayoutOnly)continue;const c=p.points;if(!(!c||c.length<2))for(let y=0;y{const y=Ln(c,r);for(const{nodeId:v,rect:M}of o)if(v!==p&&We(y,M))return!0;return!1},"labelOverlapsForeignNode"),i=d((p,c)=>{const y=Ln(c,r);for(const v of n)if(v.edgeId!==p&&on(v.p1,v.p2,y))return!0;return!1},"labelOverlapsForeignEdge"),g=d((p,c,y)=>f(p,y)||i(c,y),"labelOverlapsAnything"),x=[],C=d(p=>{for(const{id:c,rect:y}of s)if(qo(y,p))return c},"findContainingLane"),h=d((p,c)=>x.some(y=>y.labelId!==p&&We(c,y.rect)),"overlapsPlacedLabel");for(const p of t){if(p.isLayoutOnly)continue;const c=p.labelNodeId;if(!c)continue;const y=e.get(c);if(!y)continue;const v=p.points;if(!v||v.length<2)continue;const M=y.width??0,E=y.height??0;if(M<=0||E<=0)continue;const T=[];for(let Q=0;Q=Kt&>>=Kt||T.push({idx:Q,length:at+gt,orientation:at>=Kt?"horizontal":"vertical",midX:(W.x+et.x)/2,midY:(W.y+et.y)/2})}if(T.length===0)continue;const m=T.length>=3?T.filter(Q=>Q.idx>0&&Q.idx0?m:T,w=M>=E?"horizontal":"vertical",R=d(Q=>[...Q].sort((W,et)=>{const at=W.orientation===w,gt=et.orientation===w;if(at!==gt)return at?-1:1;const xt=W.length>=(W.orientation==="horizontal"?M:E)+2,vt=et.length>=(et.orientation==="horizontal"?M:E)+2;return xt!==vt?xt?-1:1:et.length-W.length}),"rankSegments"),k=T[0],O=T[T.length-1],F=[.5,.25,.75,.05,.95,.15,.85,.1,.9],H=d((Q,W)=>{const et=v[Q.idx],at=v[Q.idx+1];return{midX:et.x+(at.x-et.x)*W,midY:et.y+(at.y-et.y)*W}},"anchorAtT"),P=d((Q,W,et)=>Math.min(et,Math.max(W,Q)),"clamp"),G=d((Q,W)=>Q.midX>=W.left-Kt&&Q.midX<=W.right+Kt&&Q.midY>=W.top-Kt&&Q.midY<=W.bottom+Kt,"pointInsideRectInclusive"),j=d(Q=>{const W=we(Q.midX,Q.midY,M,E),et=C(W);if(et)return{laneId:et,anchor:Q,rect:W};const at=s.find(({rect:te})=>G(Q,te));if(!at)return;const gt=at.rect.left+M/2+a,xt=at.rect.right-M/2-a,vt=at.rect.top+E/2+a,Vt=at.rect.bottom-E/2-a;if(gt>xt||vt>Vt)return;const jt={midX:P(Q.midX,gt,xt),midY:P(Q.midY,vt,Vt)},Ut=we(jt.midX,jt.midY,M,E);return G(Q,Ut)?{laneId:at.id,anchor:jt,rect:Ut}:void 0},"placementForAnchor"),J=d((Q,W,et)=>Q.orientation==="horizontal"?Math.abs(W.midX-et.x):Math.abs(W.midY-et.y),"distanceAlongSegment"),dt=d((Q,W)=>{const at=(Q.orientation==="horizontal"?M/2:E/2)+l;if(Q===k){const gt=v[Q.idx];if(J(Q,W,gt)+Kt{const W=R(Q);for(const et of W)for(const at of F){const gt=H(et,at);if(!dt(et,gt))continue;const xt=j(gt);if(xt&&!Gn(xt.rect,v)&&!h(c,xt.rect)&&!g(c,p.id,xt.rect))return{laneId:xt.laneId,anchor:xt.anchor}}},"tryPool"),kt=d((Q,W,et=!1)=>{const at=R(Q);for(const gt of at){const xt={midX:gt.midX,midY:gt.midY};if(W&&!dt(gt,xt))continue;const vt=j(xt);if(vt&&!Gn(vt.rect,v)&&!h(c,vt.rect)&&!f(c,vt.rect)&&(et||!i(p.id,vt.rect)))return{laneId:vt.laneId,anchor:vt.anchor}}},"findLaneContainingFallback"),Pt=mt(I)??(I.lengthet.labelId===c);W>=0?x[W]={labelId:c,rect:Q}:x.push({labelId:c,rect:Q})}}}d(Ve,"anchorLabelsToPolyline");var bn=1e-6,Nr=8,Oo=Nr/2,Or=3;function $n(t,e){return t{const g=$n(l,f);let x=0;const C=d(h=>{if(!h)return;const p=s.get(h);if(!p)return;const c=i==="x"?p.w/2:p.h/2;c>x&&(x=c)},"consider");C(a.labelNodeId);for(const h of t){if(h===a||h.isLayoutOnly)continue;const p=h.start,c=h.end;!p||!c||$n(p,c)===g&&C(h.labelNodeId)}return x>0?x+Or:0},"labelClearanceFor");for(const a of t){if(a.isLayoutOnly)continue;const l=a.points;if(!oo(l,bn))continue;const f=co(a,n,bn);if(!f)continue;const{srcId:i,dstId:g,srcInfo:x,dstInfo:C,collinearX:h,collinearY:p}=f;if(h===p)continue;let c,y;if(h){const m=C.cy>x.cy;c={x:x.cx,y:m?x.rect.bottom:x.rect.top},y={x:C.cx,y:m?C.rect.top:C.rect.bottom}}else{const m=C.cx>x.cx;c={x:m?x.rect.right:x.rect.left,y:x.cy},y={x:m?C.rect.left:C.rect.right,y:C.cy}}if(wt(c,y,o,[i,g],1))continue;const M=r(a,i,g,h?"x":"y"),E=M>Oo?M:Oo,T=[0,E,-E];for(const m of T){const I={...c},w={...y};if(h){if(I.x+=m,w.x+=m,I.x<=x.rect.left||I.x>=x.rect.right||w.x<=C.rect.left||w.x>=C.rect.right)continue}else if(I.y+=m,w.y+=m,I.y<=x.rect.top||I.y>=x.rect.bottom||w.y<=C.rect.top||w.y>=C.rect.bottom)continue;if(!wt(I,w,o,[i,g],1)&&!Ke(I,w,t,a,{epsilon:bn})){a.points=[I,w];break}}}}d(Cs,"straightenCollinearSiblingDetours");function zn(t,e){const{realNodeRects:f,labelNodeRects:i}=me(e.values()),g=d((m,I)=>Re(I,.001).map(w=>({...w,edge:m,interior:w.index>=1&&w.index<=I.length-3})),"segmentsFor"),x=d(()=>{const m=[];for(const I of t){if(I.isLayoutOnly)continue;const w=I.points;!w||w.length<2||m.push(...g(I,pt(w)))}return m},"allSegments"),C=d((m,I)=>m.horizontal&&I.horizontal?zt(m.a.x,m.b.x,I.a.x,I.b.x)>=8&&Math.abs(m.a.y-I.a.y)<7:m.vertical&&I.vertical?zt(m.a.y,m.b.y,I.a.y,I.b.y)>=8&&Math.abs(m.a.x-I.a.x)<7:!1,"hasCrowdedParallelTrack"),h=d((m,I)=>{const w=m.start,R=m.end,k=g(m,I);if(k.length!==I.length-1)return!1;const O=[w,R].filter(H=>!!H),F=m.labelNodeId?[m.labelNodeId]:[];for(const H of k)if(wt(H.a,H.b,f,O,-2)||wt(H.a,H.b,i,F,-2))return!1;for(const H of t){if(H===m||H.isLayoutOnly)continue;const P=H.points;if(!(!P||P.length<2)){for(const G of k)for(const j of g(H,pt(P)))if(C(G,j)||le(G.a,G.b,j.a,j.b,.001))return!1}}return!0},"candidateIsSafe"),p=d((m,I)=>{const w=pt(m.edge.points??[]);if(w.length<4||m.index>=w.length-1)return;const R=w.map(k=>({...k}));if(m.horizontal)R[m.index].y+=I,R[m.index+1].y+=I;else if(m.vertical)R[m.index].x+=I,R[m.index+1].x+=I;else return;return g(m.edge,R).length===R.length-1?R:void 0},"shiftedCandidate"),c=d((m,I)=>({x:m.x??(I.left+I.right)/2,y:m.y??(I.top+I.bottom)/2}),"nodeCenter"),y=d(m=>{const I=m.edge,w=pt(I.points??[]);if(w.length!==4||m.index!==1)return;const R=I.start?e.get(I.start):void 0,k=I.end?e.get(I.end):void 0,O=R?qt(R):void 0,F=k?qt(k):void 0,H=w.slice(m.index+2);if(!(!R||!k||!O||!F||H.length===0))return{sourceCenter:c(R,O),targetCenter:c(k,F),sourceRect:O,tail:H}},"sourceDetourContextFor"),v=d((m,I,w,R,k,O)=>{const F=R.y>=w.y,H=F?k.bottom:k.top,P=H+(F?20:-20);if(F&&m.b.y<=P+.001||!F&&m.b.y>=P-.001)return;const G=m.a.x+I;return pt([{x:w.x,y:H},{x:w.x,y:P},{x:G,y:P},{x:G,y:m.b.y},...O],.001)},"verticalSourceDetour"),M=d((m,I,w,R,k,O)=>{const F=R.x>=w.x,H=F?k.right:k.left,P=H+(F?20:-20);if(F&&m.b.x<=P+.001||!F&&m.b.x>=P-.001)return;const G=m.a.y+I;return pt([{x:H,y:w.y},{x:P,y:w.y},{x:P,y:G},{x:m.b.x,y:G},...O],.001)},"horizontalSourceDetour"),E=d((m,I)=>{const w=y(m);if(w){if(m.vertical)return v(m,I,w.sourceCenter,w.targetCenter,w.sourceRect,w.tail);if(m.horizontal)return M(m,I,w.sourceCenter,w.targetCenter,w.sourceRect,w.tail)}},"sourceDetourCandidate"),T=[-7,7,-14,14,-21,21];for(let m=0;m<12;m++){const I=x();let w=!1;for(let R=0;RP.interior);for(const P of H){for(const G of T){const j=p(P,G);if(j&&h(P.edge,j)){P.edge.points=j,w=!0;break}const J=E(P,G);if(J&&h(P.edge,J)){P.edge.points=J,w=!0;break}}if(w)break}}if(!w)return}}d(zn,"nudgeSharedInteriorSubpaths");function vs(t,e,n,o){const s=e.x-t.x,r=e.y-t.y,a=o.x-n.x,l=o.y-n.y,f=s*l-r*a;if(Math.abs(f)<1e-10)return!1;const i=n.x-t.x,g=n.y-t.y,x=(i*l-g*a)/f,C=(i*r-g*s)/f,h=.01;return x>h&&x<1-h&&C>h&&C<1-h}d(vs,"segmentsIntersect");function Ls(t){const e=t.nodes??[],n=t.edges??[],o=[];if(!n.length||!e.length)return o;const s=Jo(e),r=[];for(const l of n){if(l.isLayoutOnly)continue;const f=l.points;if(!f||f.length<2)continue;const i=l.start,g=l.end,x=l.labelNodeId,C=l.id??`${i}->${g}`;for(const h of s)if(!(h.nodeId===i||h.nodeId===g)&&!(x&&h.nodeId===x)){for(let p=0;p0){const l=o.filter(i=>i.type==="edge-node-overlap").length,f=o.filter(i=>i.type==="edge-edge-crossing").length;In.warn(`[SWIMLANE_VALIDATE] ${o.length} issue(s) detected: ${l} edge-node overlap(s), ${f} edge crossing(s)`);for(const i of o)In.warn(`[SWIMLANE_VALIDATE] ${i.type}: ${i.detail}`)}return o}d(Ls,"validateSwimlanesLayout");function Es(t,e){const n=t.nodes??[],o=t.edges??[],s=n.filter(l=>!l.isGroup);if((e==="LR"||e==="RL")&&s.length>0&&!us(t,e)||e==="BT"&&s.length>0&&!ds(t))return;for(const l of o){if(l.isLayoutOnly)continue;const f=l.points;!f||f.length<2||(l.points=ae(qe(f)))}Is(o,n),Cs(o,n),hs(o,n);const r=new Map;for(const l of n)r.set(String(l.id),l);Ve(o,r),ns(o,r),gs(o,r),zn(o,r),ps(o,r),ms(o,r),Dn(o,r),ys(o,r);const a=d(()=>{Ms(o,r),xs(o,r),bs(o,r),Ve(o,r),Fn(o,r),Dn(o,r),Ve(o,r),Fn(o,r)},"finalizeRenderedEdges");a(),zn(o,r),a(),Hn(o,r),Xn(o,r),Hn(o,r),Xn(o,r)}d(Es,"postProcessSwimlaneLayout");function ye(t){const e=new Map(t.nodeById),n=new Set,o=[];for(const r of t.edges){if(!e.has(r.src)||!e.has(r.dst))continue;const a=`${r.id}:${r.src}->${r.dst}`;n.has(a)||(n.add(a),o.push(r))}return{nodes:[...e.keys()],edges:o,layout:t.layout,nodeById:e}}d(ye,"normalizeGraph");function go(t,e){return t.edges.filter(n=>n.dst===e)}d(go,"incoming");function Ts(t){const e=new Map;for(const n of t.nodes)e.set(n,[]);for(const n of t.edges)e.get(n.src).push(n.dst);return e}d(Ts,"buildSuccessorMap");function po(t){const e=Ts(t);for(const n of e.values())n.sort((o,s)=>o.localeCompare(s));return e}d(po,"buildSortedSuccessorMap");function mo(t){const e=new Map;for(const n of t.nodes)e.set(n,0);for(const n of t.edges)e.set(n.dst,(e.get(n.dst)??0)+1);return e}d(mo,"buildInDegreeMap");function yo(t){return[...t.entries()].filter(([,e])=>e===0).map(([e])=>e).sort((e,n)=>e.localeCompare(n))}d(yo,"sortedZeroInDegreeNodes");function rn(t,e=()=>!0){const n=new Map,o=new Map;for(const s of t.nodes)n.set(s,[]),o.set(s,[]);for(const s of t.edges)e(s)&&(o.get(s.src).push(s.dst),n.get(s.dst).push(s.src));return{preds:n,succs:o}}d(rn,"buildPredecessorSuccessorMaps");function xo(t,e,n,o){let s=0;for(const a of t.nodes)o?.skipGroups&&t.nodeById.get(a)?.isGroup||(s=Math.max(s,n[a]??0));const r=Array.from({length:s+1},()=>[]);for(const a of e)o?.skipGroups&&t.nodeById.get(a)?.isGroup||r[Math.max(0,n[a]??0)].push(a);return r}d(xo,"buildLayersFromRanks");function Pe(t){const e=mo(t),n=yo(e),o=[],s=po(t);for(;n.length;){const r=n.shift();o.push(r);for(const a of s.get(r)??[])if(e.set(a,(e.get(a)??0)-1),(e.get(a)??0)===0){let l=0;for(;l{if(s-o<=1)return 0;const r=o+s>>1;let a=n(o,r)+n(r,s),l=o,f=r,i=o;for(;l=s||lx.dst===C.dst?x.id.localeCompare(C.id):x.dst.localeCompare(C.dst));const o=Object.create(null);for(const g of e.nodes)o[g]=0;const s=[],r=d(g=>{o[g]=1;for(const x of n.get(g)??[]){const C=x.dst;o[C]===0?r(C):o[C]===1&&s.push(x)}o[g]=2},"dfs"),a=[...e.nodes].sort((g,x)=>g.localeCompare(x));for(const g of a)o[g]===0&&r(g);const l=new Set(s.map(g=>`${g.id}:${g.src}->${g.dst}`)),f=e.edges.map(g=>l.has(`${g.id}:${g.src}->${g.dst}`)?{id:g.id,src:g.dst,dst:g.src,weight:g.weight,ref:g.ref}:g);return{acyclic:{nodes:[...e.nodes],edges:f,layout:e.layout,nodeById:new Map(e.nodeById)},reversed:s}}d(As,"removeCycles_DFS");function ws(t){const e=new Map,n=d(o=>{if(e.has(o))return e.get(o);const s=t.nodeById.get(o);if(!s)return e.set(o,null),null;const r=s.parentId;if(!r)return e.set(o,null),null;const l=n(r)??r;return e.set(o,l),l},"resolve");for(const o of t.nodes)n(o);return e}d(ws,"buildTopLaneMap");function fe(t){const e=ws(t);return n=>e.get(n)??null}d(fe,"createTopLaneResolver");function cn(t){const e=[];for(const n of t.layout.nodes??[])n.isGroup&&!n.parentId&&e.push(n.id);return[...new Set(e)].reverse()}d(cn,"buildTopLaneOrder");function Mo(t,e){const n=cn(t);if(!e||e.length===0)return n;const o=new Set(n),s=new Set,r=[];for(const a of e)!o.has(a)||s.has(a)||(s.add(a),r.push(a));for(const a of n)s.has(a)||r.push(a);return r}d(Mo,"resolveTopLaneOrder");var Pr={EPSILON:1e-6},en={GRAVITY_ITERATIONS:8,MAX_CROSSING_OPTIMIZATION_PASSES:4,DEFAULT_COMPACT_SINGLE_INPUT:!0},Po={DEFAULT_LAYER_GAP:100,DEFAULT_NODE_GAP:40};function Rs(t,e){const n=ye(t),o=e?.laneOf??(()=>null),s=e?.rankHint,{preds:r}=rn(n);for(const m of r.values())m.sort((I,w)=>I.localeCompare(w));const a=Pe(n)??[...n.nodes].sort((m,I)=>m.localeCompare(I)),l=new Map;for(const[m,I]of a.entries())l.set(I,m);const f=new Map,i=new Map;for(const m of n.nodes)i.set(m,[]);for(const m of a){const I=(r.get(m)??[]).filter(w=>f.has(w));if(I.length>0){const w=Ns(m,I,{laneOf:o,rankHint:s,topoIndex:l});f.set(m,w),i.get(w).push(m)}else f.has(m)||f.set(m,null)}for(const m of n.nodes)f.has(m)||f.set(m,null);const g=new Set;for(const m of n.nodes)(f.get(m)??null)===null&&g.add(m);const x=[...g].sort((m,I)=>{const w=l.get(m)??0,R=l.get(I)??0;return w===R?m.localeCompare(I):w-R}),C=Os(n),h=new Map;for(const[m,I]of C.entries())h.set(m,[...I].sort((w,R)=>w.localeCompare(R)));const p=Ps(h),c=Bs(h),y=new Map;for(const m of n.nodes)y.set(m,[]);for(const m of c)for(const I of m.nodes){const w=y.get(I);w?w.push(m.id):y.set(I,[m.id])}const v=[],M=[],E=new Set,T=d(m=>{if(!E.has(m)){E.add(m),v.push(m);for(const I of i.get(m)??[])T(I);M.push(m)}},"walk");for(const m of x)T(m);for(const m of a)T(m);return{parent:f,children:i,roots:x,componentOf:p,blocks:c,nodeBlocks:y,adjacency:h,preorder:v,postorder:M,topologicalOrder:a}}d(Rs,"buildDrivingTree");function Ns(t,e,n){const o=n.laneOf(t);return[...e].sort((r,a)=>{const l=n.laneOf(r),f=n.laneOf(a),i=l!=null&&l===o,g=f!=null&&f===o;if(i!==g)return i?-1:1;const x=n.rankHint?.[r],C=n.rankHint?.[a];if(x!=null&&C!=null&&x!==C)return C-x;const h=n.topoIndex.get(r)??0,p=n.topoIndex.get(a)??0;return h!==p?h-p:r.localeCompare(a)})[0]}d(Ns,"chooseParent");function Os(t){const e=new Map;for(const n of t.nodes)e.set(n,new Set);for(const n of t.edges)e.get(n.src).add(n.dst),e.get(n.dst).add(n.src);return e}d(Os,"buildAdjacency");function Ps(t){const e=new Map;let n=0;for(const o of t.keys()){if(e.has(o))continue;const s=[o];for(;s.length>0;){const r=s.pop();if(!e.has(r)){e.set(r,n);for(const a of t.get(r)??[])e.has(a)||s.push(a)}}n++}return e}d(Ps,"assignComponents");function Bs(t){const e=new Map,n=new Map,o=[],s=[];let r=0;const a=d((l,f)=>{e.set(l,++r),n.set(l,r);for(const i of t.get(l)??[])i!==f&&(e.has(i)?(e.get(i)??0)<(e.get(l)??0)&&(o.push([l,i]),n.set(l,Math.min(n.get(l)??r,e.get(i)??r))):(o.push([l,i]),a(i,l),n.set(l,Math.min(n.get(l)??r,n.get(i)??r)),(n.get(i)??0)>=(e.get(l)??0)&&s.push(ks(l,i,o,s.length))))},"visit");for(const l of t.keys())e.has(l)||a(l,null);return s}d(Bs,"computeBlocks");function ks(t,e,n,o){const s=[],r=new Set;for(;n.length>0;){const a=n.pop();if(s.push(a),r.add(a[0]),r.add(a[1]),a[0]===t&&a[1]===e||a[0]===e&&a[1]===t)break}return{id:o,edges:s,nodes:[...r]}}d(ks,"popBlock");function Fs(t,e,n){const o=[...t.nodes],s=new Map;for(const[M,E]of o.entries())s.set(E,M);const r=o.length,a=new Array(r).fill(-1),l=new Array(r).fill(0),f=[],i=new Set;for(const M of o){const E=n.parent.get(M)??null,T=s.get(M);T!=null&&E==null&&(a[T]=-1,l[T]=0,i.has(M)||(i.add(M),f.push(M)))}for(;f.length>0;){const M=f.shift(),E=s.get(M);if(E==null)continue;const T=n.children.get(M)??[];for(const m of T){if(i.has(m))continue;const I=s.get(m);I!=null&&(a[I]=E,l[I]=l[E]+1,i.add(m),f.push(m))}}for(const M of o){if(i.has(M))continue;const E=s.get(M);E!=null&&(a[E]=-1,l[E]=0,i.add(M))}const g=Math.max(1,Math.ceil(Math.log2(Math.max(1,r)))+1),x=Array.from({length:g},()=>new Array(r).fill(-1));for(let M=0;M{if(M===-1||E===-1)return-1;l[M]>m&1&&(M=x[m][M],M===-1))return-1;if(M===E)return M;for(let m=g-1;m>=0;m--){const I=x[m][M],w=x[m][E];I===-1||w===-1||I!==w&&(M=I,E=w)}return x[0][M]},"lcaIndex"),h=Array.from({length:r},()=>new Map);for(const M of t.edges){let E=M.src,T=M.dst,m=e[E],I=e[T];if(m==null||I==null||(m>I&&([E,T]=[T,E],[m,I]=[I,m]),m==null||I==null||m===I))continue;const w=s.get(E),R=s.get(T);if(w==null||R==null)continue;const k=C(w,R);if(k===-1)continue;const O=h[k];for(let F=m;F{if(E.size!==0)for(const[T,m]of E)M.set(T,(M.get(T)??0)+m)},"mergeInto"),y=new Set,v=d(M=>{const E=s.get(M);y.add(M);const T=E==null?void 0:h[E],m=T?new Map(T):new Map,I=n.children.get(M)??[];for(const w of I){const R=v(w),k=e[M];if(k!=null){let O=p.get(M);O||(O=new Map,p.set(M,O));let F=R.get(k)??0;const H=e[w];H!=null&&H>k&&(F+=1),O.set(w,F)}c(m,R)}return m},"dfs");for(const M of n.roots)y.has(M)||v(M);for(const M of o)y.has(M)||v(M);return p}d(Fs,"computeSubtreeCrossCounts");function _s(t,e,n){const o=new Map,s=d(r=>{let a=n[r]??0;const l=[...e.get(r)??[]];l.sort(Io(n));for(const f of l){s(f);const i=o.get(f);i!=null&&(a=Math.min(a,i))}o.set(r,a)},"annotate");for(const r of t)s(r);return o}d(_s,"annotateMinimumLayers");function Io(t){return(e,n)=>{const o=t[e]??0,s=t[n]??0;return o===s?e.localeCompare(n):o-s}}d(Io,"compareByRankThenId");function Ds(t,e,n,o){let s=0;for(const f of e){const i=n[f]??0;i>s&&(s=i)}const r=Array.from({length:s+1},()=>[]),a=new Set,l=d(f=>{if(a.has(f))return;a.add(f);const i=n[f]??0;r[i]||(r[i]=[]),r[i].push(f);for(const g of o(f))l(g)},"emit");for(const f of t)l(f);for(const f of e)if(!a.has(f)){const i=n[f]??0;r[i]||(r[i]=[]),r[i].push(f),a.add(f)}return r}d(Ds,"emitNodesInTreeOrder");function Hs(t){const e=[];for(const n of t){const o=new Set,s=[];for(const r of n)o.has(r)||(o.add(r),s.push(r));e.push(s)}return e}d(Hs,"deduplicateLayers");function Xs(t,e,n,o){return s=>{const r=t.get(s)??[];if(r.length===0)return[];const a=e[s]??0,l=[],f=[],i=n.get(s);for(const g of r){const x=o.get(g)??a;x>a?l.push({child:g,min:x}):f.push(g)}return l.sort((g,x)=>g.min===x.min?g.child.localeCompare(x.child):g.min-x.min),f.sort((g,x)=>{const C=i?.get(g)??0,h=i?.get(x)??0;if(C!==h)return C-h;const p=o.get(g)??a,c=o.get(x)??a;return p!==c?p-c:g.localeCompare(x)}),[...l.map(g=>g.child),...f]}}d(Xs,"createChildOrderer");function nn(t,e,n){const o=Rs(t,{rankHint:e,laneOf:n}),{children:s,roots:r}=o;for(const x of t.nodes)s.has(x)||s.set(x,[]);const a=Fs(t,e,o),l=[...r].sort(Io(e)),f=_s(l,s,e),i=Xs(s,e,a,f);let g=Ds(l,t.nodes,e,i);return g=Hs(g),g}d(nn,"buildMultitreeLayerOrder");function Ys(t,e,n){const o=new Set(t),s=new Set(e),r=Ne(e),a=[];for(const l of n)o.has(l.src)&&s.has(l.dst)&&a.push(r.get(l.dst));return bo(a)}d(Ys,"countCrossingsBetweenAdjacent");function Vn(t,e,n){const o=[];for(const r of e){const a=n[r.src],l=n[r.dst];if(a==null||l==null||a===l)continue;let f=r.src,i=r.dst,g=a,x=l;a>l&&(f=r.dst,i=r.src,g=l,x=a);for(let C=g;C(n[C]??0)-(n[x]??0));for(const x of g){const C=n[x]??0;if(C===0)continue;let h=0;for(const v of o.get(x)??[])h=Math.max(h,(n[v]??0)+1);if(h>=C)continue;const p=C;n[x]=h;const c=nn(t,n,s),y=Vn(c,t.edges,n);y(e[s]??0)-(e[r]??0)||s.localeCompare(r));for(const s of o){const r=n(s);if(!r)continue;const a=t.edges.filter(c=>c.src===s);if(a.length===0)continue;let l=!1,f=0;for(const c of a){const y=n(c.dst);y==null||y===r?l=!0:f++}if(f===0||l)continue;let i=0,g=!1;for(const c of t.edges){if(c.dst!==s)continue;const y=n(c.src);y&&(y===r?g=!0:i++)}if(i>0||!g)continue;const x=e[s]??0,C=x+f;let h=0;for(const c of t.edges)c.dst===s&&(h=Math.max(h,(e[c.src]??0)+1));const p=Math.max(x,h,C);p!==x&&(e[s]=p)}}d($s,"adjustCrossLaneSources");function zs(t,e){const n=ye(t),o=Pe(n)??[...n.nodes].sort(),s=e?.compactSingleInput??!1,r=fe(n);let a=Object.create(null);for(const f of o){const i=go(n,f),g=e?.ignoreCrossLaneEdges?i.filter(x=>{const C=r(x.src),h=r(f);return!C||!h?!0:C===h}):i;if(g.length===0)a[f]=0;else if(s&&g.length===1){const x=g[0].src,C=r(x),h=r(f);C!==h?a[f]=a[x]??0:a[f]=(a[x]??0)+1}else{let x=-1/0;for(const C of g)x=Math.max(x,(a[C.src]??0)+1);a[f]=x===-1/0?0:x}}return(e?.optimizeRanksByCrossings??!1)&&(a=Gs(n,a)),e?.ignoreCrossLaneEdges&&$s(n,a),{layers:nn(n,a,r),rankOf:a,dummy:new Set}}d(zs,"assignLayers_LongestPath");function Vs(t,e){const n=ye(t),s={...zs(n,{compactSingleInput:e?.compactSingleInput,ignoreCrossLaneEdges:e?.ignoreCrossLaneEdges,optimizeRanksByCrossings:e?.optimizeRanksByCrossings}).rankOf},r=fe(n),{preds:a,succs:l}=rn(n,p=>{if(e?.ignoreCrossLaneEdges){const c=r(p.src),y=r(p.dst);if(c&&y&&c!==y)return!1}return!0}),f=Pe(n)??[...n.nodes],i=[...f].reverse(),g=d((p,c)=>{let y=0;for(const E of a.get(p)??[])y=Math.max(y,(s[E]??0)+1);let v=Number.POSITIVE_INFINITY;const M=l.get(p)??[];return M.length>0&&(v=Math.min(...M.map(E=>(s[E]??0)-1))),Number.isFinite(v)||(v=Math.max(y,c)),Math.min(Math.max(c,y),v)},"clampFeasible"),x=en.GRAVITY_ITERATIONS,C=d(p=>{let c=!1;for(const y of p){const v=a.get(y)??[],M=l.get(y)??[];if(v.length===0&&M.length===0)continue;const E=v.length>0?v.reduce((w,R)=>w+(s[R]??0)+1,0)/v.length:s[y]??0,T=M.length>0?M.reduce((w,R)=>w+(s[R]??0)-1,0)/M.length:s[y]??0,m=Math.round((E+T)/2),I=g(y,m);I!==s[y]&&(s[y]=I,c=!0)}return c},"relaxOrder");for(let p=0;p0){const y=Math.min(...c.map(v=>(s[v]??0)-1));(s[p]??0)>y&&(s[p]=y)}}return{layers:xo(n,f,s),rankOf:s,dummy:new Set}}d(Vs,"assignLayers_Gravity");function js(t){const e=mo(t),n=po(t);let o=yo(e);const s=[];for(;o.length>0;){const r=[];for(const a of o){s.push(a);for(const l of n.get(a)??[])e.set(l,(e.get(l)??0)-1),(e.get(l)??0)===0&&r.push(l)}o=r.sort((a,l)=>a.localeCompare(l))}return s.length===t.nodes.length?s:null}d(js,"topoSortByGenerationIfAcyclic");function Us(t,e){const n=ye(t),o=e?.direction==="LR"?js(n)??[...n.nodes].sort():Pe(n)??[...n.nodes].sort(),s=fe(n),r=d(g=>s(g)??g,"laneOf"),a=Object.create(null),l=new Map,f=d((g,x)=>e?.ignoreCrossLaneEdges??!0?r(g)===r(x)?1:0:1,"edgeWeight");for(const g of o){if(n.nodeById.get(g)?.isGroup)continue;const C=go(n,g);let h=0;if(C.length>0)for(const v of C){const M=v.src,E=a[M]??0;h=Math.max(h,E+f(M,g))}const p=r(g),c=l.get(p)??0,y=Math.max(h,c);a[g]=y,l.set(p,y+1)}return{layers:xo(n,o,a,{skipGroups:!0}),rankOf:a,dummy:new Set}}d(Us,"assignLayers_LaneAwareCompact");function Ws(t,e){const n=ye(e),{rankOf:o}=t,s=t.layers.map(h=>[...h]),r=new Set(t.dummy?[...t.dummy]:[]);let a=0;const l=new Map(n.nodeById),f=d(h=>{const p=`placeholder-${a++}`,c={id:p,isGroup:!1,isDummy:!0,width:0,height:0};for(l.set(p,c),r.add(p);s.length<=h;)s.push([]);return s[h].push(p),o[p]=h,p},"addDummyAt"),i=[...n.edges].sort((h,p)=>h.id===p.id?h.src===p.src?h.dst.localeCompare(p.dst):h.src.localeCompare(p.src):h.id.localeCompare(p.id)),g=[];for(const h of i){const p=o[h.src]??0,c=o[h.dst]??0;if(c-p<=1){g.push(h);continue}let y=h.src;for(let M=p+1,E=0;M!n.nodes.includes(h))],edges:g,layout:n.layout,nodeById:l};return{layering:{layers:s,rankOf:o,dummy:r},graphWithDummies:C}}d(Ws,"makeProperLayering");function jn(t){const e=t.length;if(e===0)return Number.POSITIVE_INFINITY;const n=[...t].sort((o,s)=>o-s);return e%2===1?n[(e-1)/2]:.5*(n[e/2-1]+n[e/2])}d(jn,"median");function Un(t){return t.length===0?Number.POSITIVE_INFINITY:t.reduce((n,o)=>n+o,0)/t.length}d(Un,"barycenter");function Ks(t,e,n,o){const s=new Map;for(const r of t)s.set(r,[]);for(const r of n)o==="down"?e.has(r.src)&&s.has(r.dst)&&s.get(r.dst).push(e.get(r.src)):e.has(r.dst)&&s.has(r.src)&&s.get(r.src).push(e.get(r.dst));return s}d(Ks,"neighborPositionsFor");function qs(t,e,n){const o=n.get(t)??0,s=n.get(e)??0;return o!==s?o-s:t.localeCompare(e)}d(qs,"currentOrderTieBreak");function Wn(t,e,n){const o=new Set(t),s=new Set(e),r=Ne(t),a=Ne(e),l=[];for(const i of n)o.has(i.src)&&s.has(i.dst)&&l.push({u:r.get(i.src),v:a.get(i.dst)});l.sort((i,g)=>i.u===g.u?i.v-g.v:i.u-g.u);const f=l.map(i=>i.v);return bo(f)}d(Wn,"countCrossingsBetweenAdjacent");function je(t,e,n){return[...t].sort((o,s)=>{const r=jn(e.get(o)??[]),a=jn(e.get(s)??[]);return r===a?qs(o,s,n):isFinite(r)?isFinite(a)?r-a:-1:1})}d(je,"sortByHeuristic");function Kn(t,e,n,o,s,r){const a=Ne(t),l=Ne(e),f=Ks(e,a,n,o);if(!s||!r||r.length===0)return je(e,f,l);const i=new Map;for(const C of e){const h=s(C),p=i.get(h)??[];p.push(C),i.set(h,p)}const g=[];for(const C of r){const h=i.get(C);if(!h||h.length===0)continue;const p=je(h,f,l);g.push(...p)}const x=i.get(null);if(x&&x.length>0){const C=je(x,f,l);for(const h of C){const p=Un(f.get(h)??[]);let c=g.length;if(isFinite(p))for(const[y,v]of g.entries()){const M=Un(f.get(v)??[]);if(pa.has(c.src)&&l.has(c.dst)),g=f?n.filter(c=>l.has(c.src)&&f.has(c.dst)):void 0,x=d(c=>{let y=Wn(t,c,i);return g&&o&&(y+=Wn(c,o,g)),y},"crossingScore"),C=s?new Map:null;if(s&&C)for(const c of e)C.set(c,s(c));let h=!0,p=x(r);for(;h;){h=!1;for(let c=0;c+1[...l]),s=e.edges,r=fe(e),a=Mo(e,n?.laneOrder);for(let l=0;l<3;l++){for(let f=1;f=0;f--)o[f]=Kn(o[f+1],o[f],s,"up",r,a),o[f]=qn(o[f+1],o[f],s,o[f-1],r)}return{layers:o}}d(Js,"orderLayers");function Zs(t,e,n){const o=n?.layerGap??Po.DEFAULT_LAYER_GAP,s=n?.nodeGap??Po.DEFAULT_NODE_GAP,r=n?.laneGap??s*2,a=n?.direction??"TB",l=a==="LR"||a==="RL",f=t.layers,i=Object.create(null),g=Object.create(null),x=d(O=>e.nodeById.get(O),"getNode"),C=d(O=>x(O)?.width??0,"getWidth"),h=d(O=>x(O)?.height??0,"getHeight"),p=fe(e),c=Mo(e,n?.laneOrder),y=f.map(O=>O.reduce((F,H)=>Math.max(F,h(H)),0)),v=[];if(l)for(let O=0;O+1Math.max(mt,C(kt)),0),H=f[O+1].reduce((mt,kt)=>Math.max(mt,C(kt)),0),P=y[O],G=y[O+1],j=P/2+G/2,J=(F+H)/2,dt=Math.max(0,J-j-o);v.push(dt)}const M=new Set;for(const O of f)for(const F of O)M.add(p(F));const E=M.has(null),T=c.filter(O=>M.has(O)),m=[...E?[null]:[],...T],I=Object.create(null);for(const O of T)I[O]=0;E&&(I.null=0);for(const O of f){const F=Object.create(null),H=[];for(const P of O){const G=p(P);G===null?H.push(P):(F[G]||=[]).push(P)}for(const[P,G]of Object.entries(F)){const j=G.reduce((J,dt)=>J+C(dt),0)+s*Math.max(0,G.length-1);I[P]=Math.max(I[P]??0,j)}if(E&&H.length){const P=H.reduce((G,j)=>G+C(j),0)+s*Math.max(0,H.length-1);I.null=Math.max(I.null??0,P)}}const w=new Map;{const O=m.map(P=>(P===null?I.null:I[P])??0);let H=-(O.reduce((P,G)=>P+G,0)+r*Math.max(0,m.length-1))/2;for(let P=0;PC(Q)),kt=mt.reduce((Q,W)=>Q+W,0)+s*(J.length-1);let Pt=dt-kt/2;for(const[Q,W]of J.entries()){const et=mt[Q];i[W]=Pt+et/2,g[W]=R+H/2,Pt+=et+s}}}const G=v[O]??0;R+=H+o+G}const k=new Map;for(const O of e.edges){const F=O.ref.id;k.has(F)||k.set(F,[]),k.get(F).push(O)}for(const[,O]of k){if(O.length===0)continue;const F=O[0].ref,H=F.start,P=F.end;if(H==null||P==null)continue;const G=Math.round(((i[H]??0)+(i[P]??0))/2),j=new Set;for(const J of O)j.add(J.src),j.add(J.dst);for(const J of j){if(J===H||J===P)continue;e.nodeById.get(J)?.isDummy&&(i[J]=G)}}return{x:i,y:g}}d(Zs,"assignCoordinates");var Qs=8;function tr(t){let e=2166136261;for(let n=0;n>>0}d(tr,"hashString");function er(t){let e=t>>>0;return()=>{e+=1831565813;let n=e;return n=Math.imul(n^n>>>15,n|1),n^=n+Math.imul(n^n>>>7,n|61),((n^n>>>14)>>>0)/4294967296}}d(er,"mulberry32");function nr(t,e){const n=[...t],o=er(e);for(let s=n.length-1;s>0;s--){const r=Math.floor(o()*(s+1));[n[s],n[r]]=[n[r],n[s]]}return n}d(nr,"deterministicShuffle");function or(t,e){let n=0;for(const[o,s]of t.entries())n+=Math.abs(o-(e.get(s)??o));return n}d(or,"sourceDistance");function Jn(t,e){const n=new Map;for(const[s,r]of t.entries())n.set(r,s);let o=0;for(const{a:s,b:r,weight:a}of e){const l=n.get(s),f=n.get(r);l==null||f==null||(o+=a*Math.abs(l-f))}return o}d(Jn,"laneArrangementCost");function sr(t){const e=cn(t);if(e.length<2)return[];const n=new Map(e.map((r,a)=>[r,a])),o=fe(t),s=new Map;for(const r of t.layout.edges??[]){if(r.isLayoutOnly)continue;const a=typeof r.start=="string"?r.start:void 0,l=typeof r.end=="string"?r.end:void 0;if(!a||!l||!t.nodeById.has(a)||!t.nodeById.has(l))continue;const f=o(a),i=o(l);if(!f||!i||f===i)continue;const g=n.get(f),x=n.get(i);if(g==null||x==null)continue;const[C,h]=g<=x?[f,i]:[i,f],p=`${C}\0${h}`,c=s.get(p);c?c.weight++:s.set(p,{a:C,b:h,weight:1})}return[...s.values()]}d(sr,"buildWeightedLaneEdges");function Zn(t,e,n){const o=[...t];let s=Jn(o,e),r=!0,a=0;const l=Math.max(1,o.length);for(;r&&as.a===r.a?s.b.localeCompare(r.b):s.a.localeCompare(r.a)).map(({a:s,b:r,weight:a})=>`${s}:${r}:${a}`).join("|");return tr(`${t.join("|")}#${o}#${n}`)}d(ir,"seedForRestart");function cr(t,e={}){const n=cn(t);if(n.length<2)return n;const o=sr(t);if(o.length===0)return n;const s=new Map(n.map((l,f)=>[l,f]));let r=Zn(n,o,s);const a=Math.max(0,e.restarts??Qs);for(let l=0;lct&&f*3>=l?a>0?"bottom":"top":l>ct?r>0?"right":"left":n}d(Qn,"chooseOrthogonalSide");function to(t,e){return Math.abs(t.to-e.from)u.isGroup&&!u.parentId);for(const u of i){const b={id:u.id},S=d(L=>{a.set(L.id,b),n.filter(A=>A.parentId===L.id).forEach(S)},"assignLane");S(u)}const g=n.filter(u=>!u.isGroup&&!u.isEdgeLabel).map(u=>{const b=u.width??10,S=u.height??10,L=u.x??0,A=u.y??0,B=Br;return{nodeId:u.id,minX:L-b/2-B,maxX:L+b/2+B,minY:A-S/2-B,maxY:A+S/2+B,visualXHalfExtent:f?S/2+B:b/2+B}}),x=d((u,b,S,L)=>{let A=l.find(B=>B.orientation===u&&Math.abs(B.coord-b)<1);return A||(A={id:`pipe-${u}-${b.toFixed(0)}`,orientation:u,coord:b,spanMin:S,spanMax:L,tracks:[]},l.push(A)),A.spanMin=Math.min(A.spanMin,S),A.spanMax=Math.max(A.spanMax,L),A},"getOrAddPipe"),C=d((u,b)=>{const S=u.width??10,L=u.height??10,A=u.x??0,B=u.y??0;switch(b){case"top":return{x:A,y:B-L/2};case"bottom":return{x:A,y:B+L/2};case"left":return{x:A-S/2,y:B};case"right":return{x:A+S/2,y:B}}},"portForSide"),h=d((u,b,S)=>C(u,Qn(u,b,S?"bottom":"top")),"getOrthogonalPort"),p=[],c=[],y=new Set,v=1e3,M=d((u,b,S)=>{if(p.length===0)return 0;const L=Math.abs(b.y-S.y)z||Y.from-ct<=U&&Y.to+ct>=U&&(B+=v)}else if(A){const U=b.x,q=Math.min(b.y,S.y)-ct,z=Math.max(b.y,S.y)+ct;if(z<=q)return 0;for(const Y of p)Y.edgeIndex===u||Y.orientation!=="horizontal"||Y.pipe.coordz||Y.from-ct<=U&&Y.to+ct>=U&&(B+=v)}return B},"crossingPenalty"),E=s.map((u,b)=>{if(!u.start||!u.end)return{idx:b,crossLane:0,dx:0,dy:0};const S=r.get(u.start),L=r.get(u.end),A=a.get(u.start),B=a.get(u.end),U=A&&B&&A.id!==B.id?1:0,q=S&&L?Math.abs((L.x??0)-(S.x??0)):0,z=S&&L?Math.abs((L.y??0)-(S.y??0)):0;return{idx:b,crossLane:U,dx:q,dy:z}}).sort((u,b)=>{if(u.crossLane!==b.crossLane)return b.crossLane-u.crossLane;const S=u.dx+u.dy,L=b.dx+b.dy;return Math.abs(S-L)>1?S-L:u.idx-b.idx}).map(u=>u.idx),T=d((u,b,S,L)=>{const A=Math.min(u.x,b.x),B=Math.max(u.x,b.x),U=Math.min(u.y,b.y),q=Math.max(u.y,b.y);return!!g.find(Y=>S&&Y.nodeId===S||L&&Y.nodeId===L?!1:Math.abs(u.x-b.x)>ct?Y.minYu.y&&Y.maxX>A&&Y.minXu.x&&Y.maxY>U&&Y.minYQn(u,b,"bottom"),"determineSide"),R=new Map;for(const[u,b]of s.entries()){if(!b.start||!b.end||b.start===b.end||b.points&&b.points.length>0)continue;const S=r.get(b.start),L=r.get(b.end);if(!S||!L)continue;const A=(L.x??0)-(S.x??0),B=(L.y??0)-(S.y??0);R.set(u,{edgeIdx:u,srcId:b.start,dstId:b.end,srcSide:w(S,{x:L.x??0,y:L.y??0}),dstSide:w(L,{x:S.x??0,y:S.y??0}),absDx:Math.abs(A),absDy:Math.abs(B),dxSign:Math.sign(A),dySign:Math.sign(B)})}const k=d(u=>u.srcSide==="top"||u.srcSide==="bottom"?u.absDx===0?1/0:u.absDy/u.absDx:u.absDy===0?1/0:u.absDx/u.absDy,"preferenceStrength"),O=d(u=>u.srcSide==="top"||u.srcSide==="bottom"?u.dxSign>=0?"right":"left":u.dySign>=0?"bottom":"top","secondarySide"),F=new Map;for(const u of R.values()){const b=`${u.srcId}:${u.srcSide}`;F.has(b)||F.set(b,[]),F.get(b).push(u)}const H=new Map,P=d((u,b)=>`${u}:${b}`,"loadKey");for(const u of R.values())H.set(P(u.srcId,u.srcSide),(H.get(P(u.srcId,u.srcSide))??0)+1),H.set(P(u.dstId,u.dstSide),(H.get(P(u.dstId,u.dstSide))??0)+1);for(const u of F.values())if(!(u.length<2)){u.sort((b,S)=>{const L=k(b),A=k(S);return Math.abs(L-A)>1e-9?A-L:b.edgeIdx-S.edgeIdx});for(let b=1;b=A||(H.set(P(S.srcId,S.srcSide),A-1),H.set(P(S.srcId,L),B+1),S.srcSide=L)}}const G=d(u=>{const b=u?.shape;return b==="question"||b==="diamond"},"isDiamondNode"),j=new Map;for(const u of R.values())j.has(u.dstId)||j.set(u.dstId,new Set),j.get(u.dstId).add(u.dstSide);for(const u of R.values()){if(!G(r.get(u.srcId)))continue;const b=j.get(u.srcId);if(!b?.has(u.srcSide))continue;const S=O(u);if(b.has(S)||(H.get(P(u.srcId,S))??0)>0)continue;const L=H.get(P(u.srcId,u.srcSide))??0;H.set(P(u.srcId,u.srcSide),Math.max(0,L-1)),H.set(P(u.srcId,S),1),u.srcSide=S}for(const u of R.values()){const{edgeIdx:b,srcId:S,dstId:L,srcSide:A,dstSide:B}=u,U=r.get(S),q=r.get(L),z=`${S}:${A}:src`,Y=A==="top"||A==="bottom"?q.x??0:q.y??0;m.has(z)||m.set(z,[]),m.get(z).push({edgeIdx:b,oppositeCoord:Y});const ot=`${L}:${B}:dst`,rt=B==="top"||B==="bottom"?U.x??0:U.y??0;m.has(ot)||m.set(ot,[]),m.get(ot).push({edgeIdx:b,oppositeCoord:rt})}const J=new Map,dt=8;for(const[u,b]of m){if(b.length<2)continue;b.sort((Lt,Dt)=>Lt.oppositeCoord-Dt.oppositeCoord);const S=u.split(":"),L=S.slice(0,-2).join(":"),A=S[S.length-2],B=S[S.length-1],U=r.get(L);if(!U)continue;const z=A==="left"||A==="right"?U.height??10:U.width??10,Y=U.shape,rt=Y==="question"||Y==="diamond"?z*.3:z,tt=Math.min(20,Math.max(dt,rt/(b.length+1))),Rt=-(tt*(b.length-1))/2;for(const[Lt,Dt]of b.entries()){const Jt=Rt+Lt*tt,dn=`${Dt.edgeIdx}:${B}`;J.set(dn,Jt)}}const mt=d(u=>!!s[u]?.labelNodeId,"edgeHasLabelNode"),kt=d((u,b)=>u?(m.get(`${u}:${b}:src`)??[]).some(({edgeIdx:S})=>mt(S))||(m.get(`${u}:${b}:dst`)??[]).some(({edgeIdx:S})=>mt(S)):!1,"faceHasLabelNode"),Pt=d((u,b,S)=>b==="top"||b==="bottom"?{x:u.x+S,y:u.y}:{x:u.x,y:u.y+S},"applyPortOffset"),Q=d((u,b,S)=>{const L=R.get(u),A={x:S.x??0,y:S.y??0},B={x:b.x??0,y:b.y??0},U=L?.srcSide??w(b,A),q=L?.dstSide??w(S,B);let z=L?C(b,L.srcSide):h(b,A,!0),Y=L?C(S,L.dstSide):h(S,B,!1);const ot=J.get(`${u}:src`),rt=J.get(`${u}:dst`);return ot!==void 0&&(z=Pt(z,U,ot)),rt!==void 0&&(Y=Pt(Y,q,rt)),{pSrcPort:z,pDstPort:Y,srcSide:U,dstSide:q}},"portsForEdge");for(const u of E){const b=s[u];if(c[u]=[],!b.start||!b.end||b.points&&b.points.length>0||b.start===b.end)continue;const S=r.get(b.start),L=r.get(b.end);if(!S||!L)continue;const{pSrcPort:A,pDstPort:B,srcSide:U,dstSide:q}=Q(u,S,L),z={...A},Y={...B},ot=U==="top"||U==="bottom",rt=q==="top"||q==="bottom";if(ot){const X=A.y>(S.y??0);z.y=X?A.y+ne:A.y-ne}else{const X=A.x>(S.x??0);z.x=X?A.x+ne:A.x-ne}if(rt){const X=B.y>(L.y??0);Y.y=X?B.y+ne:B.y-ne}else{const X=B.x>(L.x??0);Y.x=X?B.x+ne:B.x-ne}const st=d((X,$)=>{for(const K of g)if(!$.includes(K.nodeId)&&X.x>K.minX&&X.xK.minY&&X.y{if(Ct){const Nt=X.y>($.y??0);return{x:(K.x??0)>=X.x?lt.maxX+be:lt.minX-be,y:Nt?lt.maxY+Te:lt.minY-Te,leavesPositiveSide:Nt}}const bt=X.x>($.x??0),Et=(K.y??0)>=X.y;return{x:bt?lt.maxX+be:lt.minX-be,y:Et?lt.maxY+Te:lt.minY-Te,leavesPositiveSide:bt}},"obstacleDetour");let yt=[];const Rt=[b.start,b.end],Lt=st(z,Rt);if(Lt.inside&&Lt.obstacle){const X=Lt.obstacle;if(ot){const $=tt(A,S,L,X,!0);z.x=$.x,z.y=$.y;const K=$.leavesPositiveSide?Math.min(X.minY-2,A.y+ne):Math.max(X.maxY+2,A.y-ne);yt=[{x:A.x,y:K},{x:$.x,y:K},{x:$.x,y:$.y}]}else{const $=tt(A,S,L,X,!1),K=$.leavesPositiveSide?Math.min(X.minX-2,A.x+ne):Math.max(X.maxX+2,A.x-ne);z.x=$.x,z.y=$.y,yt=[{x:K,y:A.y},{x:K,y:$.y},{x:$.x,y:$.y}]}}let Dt=[];const Jt=st(Y,Rt);if(Jt.inside&&Jt.obstacle){const X=Jt.obstacle;if(rt){const $=tt(B,L,S,X,!0);Y.x=$.x,Y.y=$.y,Dt=[{x:$.x,y:$.y},{x:B.x,y:$.y}]}else{const $=tt(B,L,S,X,!1);Y.x=$.x,Y.y=$.y,Dt=[{x:$.x,y:$.y},{x:$.x,y:B.y}]}}if(yt.length===0&&Dt.length===0){const X=be,$=Math.abs(z.x-Y.x)1||bt>1,Nt=I.get(b.start??"")??0,ut=I.get(b.end??"")??0,Yt=Ct>1&&kt(b.start,U)||bt>1&&kt(b.end,q),ee=Ct<=1||Nt<=2,Bt=bt<=1||ut<=2;if(($||K)&&!lt&&(!Et||Et&&!Yt&&ee&&Bt)&&!T(A,B,b.start,b.end)){b.points=[{...A},{...z},{...Y},{...B}],y.add(u);const Mt=K?"horizontal":"vertical",$t=K?A.y:A.x,It=K?Math.min(A.x,B.x):Math.min(A.y,B.y),St=K?Math.max(A.x,B.x):Math.max(A.y,B.y),Wt={id:`fast-path-${Mt}-${$t.toFixed(0)}-${u}`,orientation:Mt,coord:$t,spanMin:It,spanMax:St,tracks:[]};p.push({edgeIndex:u,segmentIndex:0,orientation:Mt,pipe:Wt,trackIndex:0,from:It,to:St});continue}}const dn=x("vertical",z.x,z.y,z.y);z.x=dn.coord;const hr=x("vertical",Y.x,Y.y,Y.y);Y.x=hr.coord;let ue=Math.min(z.x,Y.x)-50,he=Math.max(z.x,Y.x)+50,ve=Math.min(z.y,Y.y)-50,Le=Math.max(z.y,Y.y)+50;for(const X of g){const $=Math.min(z.x,Y.x),K=Math.max(z.x,Y.x),lt=Math.min(z.y,Y.y),Ct=Math.max(z.y,Y.y);X.minX$&&X.minYlt&&(ue=Math.min(ue,X.minX-ze),he=Math.max(he,X.maxX+ze),ve=Math.min(ve,X.minY-ze),Le=Math.max(Le,X.maxY+ze))}for(const X of g){if(X.maxXhe||X.maxYLe)continue;const $=be;x("horizontal",X.minY-$,ue,he),x("horizontal",X.maxY+$,ue,he);const K=Te;x("vertical",X.minX-K,ve,Le),x("vertical",X.maxX+K,ve,Le)}x("horizontal",z.y,ue,he),x("horizontal",Y.y,ue,he);const gr=l.filter(X=>X.orientation==="horizontal"&&X.coord>=ve&&X.coord<=Le),pr=l.filter(X=>X.orientation==="vertical"&&X.coord>=ue&&X.coord<=he),Be=d((X,$)=>`${X.toFixed(1)},${$.toFixed(1)}`,"getKey"),ke=Be(z.x,z.y),So=Be(Y.x,Y.y),Fe=new Map,un=new Map,hn=new Map,_e=new Set,xe=[];Fe.set(ke,0),hn.set(ke,"n"),xe.push({key:ke,f:Math.hypot(Y.x-z.x,Y.y-z.y),pt:z}),_e.add(ke);let Ht=[];const ge=d((X,$)=>T(X,$,b.start,b.end),"checkSegmentBlocked"),gn={x:Y.x,y:z.y},mr=ge(z,gn),yr=ge(gn,Y),xr=mr||yr,pn={x:z.x,y:Y.y},br=ge(z,pn),Mr=ge(pn,Y);if(xr?br||Mr||(Math.abs(z.x-Y.x)0;){xe.sort((ut,Yt)=>ut.f-Yt.f);const X=xe.shift();if(_e.delete(X.key),X.key===So){let ut=So,Yt=Y;for(Ht=[Yt];un.has(ut);){const ee=un.get(ut);Ht.unshift(ee),Yt=ee,ut=Be(ee.x,ee.y)}break}const $=X.pt.x,K=X.pt.y,lt=pr.sort((ut,Yt)=>ut.coord-Yt.coord),Ct=lt.findIndex(ut=>Math.abs(ut.coord-$)<1),bt=gr.sort((ut,Yt)=>ut.coord-Yt.coord),Et=bt.findIndex(ut=>Math.abs(ut.coord-K)<1),Nt=[];Ct>0&&Nt.push({x:lt[Ct-1].coord,y:K}),Ct>=0&&Ct0&&Nt.push({x:$,y:bt[Et-1].coord}),Et>=0&&EtZt.nodeId===b.start||Zt.nodeId===b.end?!1:Yt!==ee?Zt.minYK&&Zt.maxX>Yt&&Zt.minX$&&Zt.maxY>Bt&&Zt.minY10&&mn<-5||Ee<-10&&mn>5)&&(St=Math.abs(mn)*100),(Wt>10&&De<-5||Wt<-10&&De>5)&&(St+=Math.abs(De)*50);let Co=0;const vo=hn.get(X.key)??"n",Lo=Math.abs(De)>ct?"h":"v";vo!=="n"&&vo!==Lo&&(Co=50);const Ir=$t+It+St+Co,He=(Fe.get(X.key)??1/0)+Ir,Eo=Math.abs(Y.x-ut.x)+Math.abs(Y.y-ut.y);if(He<(Fe.get(Mt)??1/0))if(un.set(Mt,X.pt),Fe.set(Mt,He),hn.set(Mt,Lo),!_e.has(Mt))xe.push({key:Mt,f:He+Eo,pt:ut}),_e.add(Mt);else{const Zt=xe.findIndex(Sr=>Sr.key===Mt);Zt!==-1&&(xe[Zt].f=He+Eo)}}}if(Ht.length===0&&(Ht=[z,{x:z.x,y:Y.y},Y]),Ht.length>4){const X=Ht[0],$=Ht[Ht.length-1];let K=Math.min(X.x,$.x),lt=Math.max(X.x,$.x),Ct=Math.min(X.y,$.y),bt=Math.max(X.y,$.y);for(const Bt of Ht)K=Math.min(K,Bt.x),lt=Math.max(lt,Bt.x),Ct=Math.min(Ct,Bt.y),bt=Math.max(bt,Bt.y);const Et=lt>Math.max(X.x,$.x),Nt=KIt.minXGt&&It.minYOt);if($t.length>0){let It=Math.max(X.x,$.x);for(const St of $t){const Wt=(St.minX+St.maxX)/2;if(St.visualXHalfExtent===void 0||isNaN(St.visualXHalfExtent))continue;const Ee=Wt+St.visualXHalfExtent+Bt;It=Math.max(It,Ee)}isNaN(It)||(lt=It)}}if(Nt){const Gt=g.filter(Ot=>Ot.minXMath.min(X.y,$.y));if(Gt.length>0){let Ot=Math.min(X.x,$.x);for(const Mt of Gt){const It=(Mt.minX+Mt.maxX)/2-Mt.visualXHalfExtent-Bt;Ot=Math.min(Ot,It)}K=Ot}}}const ut=d(Bt=>{const Gt=$.y>X.y,Ot=g.filter(It=>{const St=Math.min(X.x,$.x)It.minX,Wt=Math.min(X.y,$.y)It.minY;return St&&Wt});let Mt=Ot;if(f&&Ot.length>0){const It=Ot.filter(St=>St.minXBt);It.length>0&&(Mt=It)}if(Mt.length===0)return $.y;const $t=be;if(Gt){const St=Math.max(...Mt.map(Wt=>Wt.maxY))+$t;if(St<$.y-ct)return St}else{const St=Math.min(...Mt.map(Wt=>Wt.minY))-$t;if(St>$.y+ct)return St}return $.y},"findBestReturnY"),Yt=d(Bt=>{const Gt=ut(Bt),Ot={x:Bt,y:X.y},Mt={x:Bt,y:Gt},$t={x:$.x,y:Gt},It=ge(X,Ot),St=ge(Ot,Mt),Wt=ge(Mt,$t),Ee=Gt!==$.y?ge($t,$):!1;return!It&&!St&&!Wt&&!Ee?Math.abs(Gt-$.y)=3){const X=Xt[Xt.length-1],$=Xt[Xt.length-2],K=Xt[Xt.length-3],lt=Math.abs(K.y-$.y)Math.abs(X.x-K.x)&&Xt.splice(-2,1)}else if(Ct){const bt=Math.sign($.y-K.y),Et=Math.sign(X.y-K.y);bt!==0&&bt===Et&&Math.abs($.y-K.y)>Math.abs(X.y-K.y)&&Xt.splice(-2,1)}}const ie=[Xt[0]];for(let X=1;X$.x,bt=lt.x>K.x;if(Ct!==bt){ie.push(K);continue}continue}if(Math.abs($.x-K.x)$.y,bt=lt.y>K.y;if(Ct!==bt){ie.push(K);continue}continue}ie.push(K)}ie.push(Xt[Xt.length-1]);for(let X=0;Xu.from{const A=!L.segments.some(U=>(U.edgeIndex!==b.edgeIndex||U.segmentIndex!==b.segmentIndex)&&W(U,u)),B=!S.segments.some(U=>(U.edgeIndex!==u.edgeIndex||U.segmentIndex!==u.segmentIndex)&&W(U,b));return A&&B?(u.trackIndex=L.index,b.trackIndex=S.index,S.segments=[...S.segments.filter(U=>U.edgeIndex!==u.edgeIndex||U.segmentIndex!==u.segmentIndex),{edgeIndex:b.edgeIndex,segmentIndex:b.segmentIndex,from:b.from,to:b.to}],L.segments=[...L.segments.filter(U=>U.edgeIndex!==b.edgeIndex||U.segmentIndex!==b.segmentIndex),{edgeIndex:u.edgeIndex,segmentIndex:u.segmentIndex,from:u.from,to:u.to}],!0):!1},"trySwapSegmentsAcrossTracks"),at=d(u=>{const b=u.tracks.length;return u.tracks[b]={index:b,coord:u.coord,segments:[]},b},"createNewTrack"),gt=d((u,b)=>{const S=u.pipe.tracks[u.trackIndex];S.segments=S.segments.filter(A=>A.edgeIndex!==u.edgeIndex||A.segmentIndex!==u.segmentIndex),u.trackIndex=b,u.pipe.tracks[b].segments.push({edgeIndex:u.edgeIndex,segmentIndex:u.segmentIndex,from:u.from,to:u.to})},"moveSegmentToTrack"),xt=d((u,b)=>{const S=c[u.edgeIndex];for(const L of S){const A=p[L];A.pipe===u.pipe&>(A,b)}},"moveSegmentChainToTrack"),vt=d(u=>{const b=c[u.edgeIndex],S=b.indexOf(p.indexOf(u)),L=[];return S>0&&L.push(p[b[S-1]]),S{if(u.orientation===b.orientation)return!1;const S=u.orientation==="horizontal"?u:b,L=u.orientation==="horizontal"?b:u;return L.pipe.coord>S.from&&L.pipe.coordL.from&&S.pipe.coord{for(const S of u.tracks)if(!S.segments.some(A=>(A.edgeIndex!==b.edgeIndex||A.segmentIndex!==b.segmentIndex)&&W(A,b)))return S.index;return-1},"findAvailableTrack"),Ut=d((u,b)=>{if(u.trackIndex===b.trackIndex)return W(u,b);const S=vt(u),L=vt(b);return S.some(A=>L.some(B=>Vt(A,B)))},"segmentsConflict"),te=d((u,b,S)=>{if(et(u,b,u.pipe.tracks[u.trackIndex],b.pipe.tracks[b.trackIndex]))return;const L=jt(u.pipe,b);S(b,L!==-1?L:at(u.pipe))},"resolveTrackConflict"),Se=d(u=>{let b=0;for(let S=0;S{if(de.has(u))return de.get(u);const b=c[u];if(b.length===0){const q={dest:0,deviation:0,base:0,delta:0};return de.set(u,q),q}const L=p[b[0]].pipe.coord;let A=L;for(let q=1;qMath.abs(ot-L)?Y:ot;break}}const B=Math.abs(A-L),U={dest:A,deviation:B,base:L,delta:A-L};return de.set(u,U),U},"getDestInfo"),an=d(()=>{let u=0;const b=new Map;for(const[L,A]of s.entries())c[L].length!==0&&A.start&&(b.has(A.start)||b.set(A.start,[]),b.get(A.start).push(L));const S=d(L=>{const A=s[L];if(!A.start||!A.end)return 0;const B=r.get(A.start),U=r.get(A.end);if(!B||!U)return 0;const q=(U.x??0)-(B.x??0),z=(U.y??0)-(B.y??0);return Math.abs(q)+Math.abs(z)},"getEdgeDistance");for(const L of b.values()){L.sort((B,U)=>{const q=Ce(B),z=Ce(U);if(Math.abs(q.deviation-z.deviation)>1)return q.deviation-z.deviation;if(Math.abs(q.dest-z.dest)>1)return q.dest-z.dest;const Y=S(B),ot=S(U);if(Math.abs(Y-ot)>1)return ot-Y;const rt=c[B].length,st=c[U].length;if(rt!==st)return rt-st;if(rt===1){const tt=c[B][0],yt=c[U][0];if(p[tt]&&p[yt]){const Rt=p[tt],Lt=p[yt],Dt=Math.abs(Rt.to-Rt.from),Jt=Math.abs(Lt.to-Lt.from);if(Math.abs(Dt-Jt)>1)return Dt-Jt}}return 0});const A=L.map(B=>p[c[B][0]]);u+=Se(A)}return u},"fixSourceHandleCrossings"),ln=d(()=>{let u=0;const b=new Map;for(const[S,L]of s.entries())c[S].length!==0&&L.end&&(b.has(L.end)||b.set(L.end,[]),b.get(L.end).push(S));for(const S of b.values()){S.sort((A,B)=>{const U=d(Y=>{const ot=c[Y];if(ot.length<2)return 0;const rt=p[ot[ot.length-2]];return Math.abs(rt.to-rt.from)},"getDist"),q=U(A),z=U(B);return Math.abs(q-z)>.1?q-z:A-B});const L=S.map(A=>p[c[A][c[A].length-1]]);u+=Se(L)}return u},"fixTargetHandleCrossings"),fn=d(()=>{let u=0;for(const b of l){const S=[];for(const L of b.tracks)for(const A of L.segments){const B=c[A.edgeIndex].find(U=>p[U].segmentIndex===A.segmentIndex);B!==void 0&&S.push(p[B])}S.sort((L,A)=>L.edgeIndex-A.edgeIndex||L.segmentIndex-A.segmentIndex);for(let L=0;L{L.segments.forEach(A=>{b.push({edgeIndex:A.edgeIndex,segmentIndex:A.segmentIndex,trackIndex:L.index,from:A.from,to:A.to})})}),b.sort((L,A)=>L.from-A.from);const S=[];if(b.length>0){let L=[b[0]],A=b[0].to;for(let B=1;BA.add(tt.trackIndex));const B=new Map;L.forEach(tt=>{const yt=Ce(tt.edgeIndex);B.set(tt.trackIndex,(B.get(tt.trackIndex)??0)+yt.delta)});const U=[...A].filter(tt=>(B.get(tt)??0)<-1),q=[...A].filter(tt=>(B.get(tt)??0)>1),z=[...A].filter(tt=>Math.abs(B.get(tt)??0)<=1);U.sort((tt,yt)=>(B.get(yt)??0)-(B.get(tt)??0)),q.sort((tt,yt)=>(B.get(tt)??0)-(B.get(yt)??0));const Y=d((tt,yt)=>{L.filter(Rt=>Rt.trackIndex===tt).forEach(Rt=>{const Lt=y.has(Rt.edgeIndex)?u.coord:yt;D.set(`${Rt.edgeIndex}-${Rt.segmentIndex}`,Lt)})},"assignCoord");let ot=0;for(const tt of U)ot++,Y(tt,u.coord-ot*Mn);if(z.length===0&&A.size>0){const tt=[...A].sort((Lt,Dt)=>Math.abs(B.get(Lt)??0)-Math.abs(B.get(Dt)??0))[0],yt=U.indexOf(tt);yt!==-1&&U.splice(yt,1);const Rt=q.indexOf(tt);Rt!==-1&&q.splice(Rt,1),z.push(tt)}let rt=0;for(const tt of z){if(rt===0)Y(tt,u.coord);else{const yt=rt%2===1?1:-1,Rt=Math.ceil(rt/2);Y(tt,u.coord+yt*Rt*Mn*.5)}rt++}let st=0;for(const tt of q)st++,Y(tt,u.coord+st*Mn)}}for(const[u,b]of s.entries()){const S=c[u]??[];if(S.length===0)continue;const L=[],A=r.get(b.start),B=r.get(b.end),{pSrcPort:U,pDstPort:q}=Q(u,A,B),z=S.map(rt=>{const st=p[rt],tt=D.get(`${st.edgeIndex}-${st.segmentIndex}`)??st.pipe.coord;return{orient:st.orientation,coord:tt,from:st.from,to:st.to}});L.push(U);for(let rt=0;rtct&&L.push(Me(st,yt)),Dt&&Lt.orient===st.orient)if(Math.abs(st.coord-Lt.coord)>ct){const Jt=st.orient==="vertical"?(yt+Lt.from)/2:to(st,Lt);L.push(Me(st,Jt),Me(Lt,Jt))}else(rt===0||rt===z.length-2)&&L.push(Me(st,to(st,Lt)));else if(Dt)L.push(Me(st,Lt.coord));else{const Jt=Math.abs(st.from-yt)ct||Math.abs(Y.y-q.y)>ct)&&L.push(q);const ot=[];L.length>0&&ot.push(L[0]);for(let rt=1;rtct||Math.abs(st.y-tt.y)>ct)&&ot.push(st)}b.points=ot}for(const u of s){const b=u.__originalEdge;b&&u.points&&(b.points=u.points)}t.edges=(t.edges??[]).filter(u=>!u.isLayoutOnly);const V=d((u,b)=>{const S=b.x??0,L=b.y??0,A=b.width??0,B=b.height??0;if(A<=0||B<=0)return u;const U=S-A/2,q=S+A/2,z=L-B/2,Y=L+B/2;if(u.xq||u.yY)return u;const ot=u.x-U,rt=q-u.x,st=u.y-z,tt=Y-u.y,yt=Math.min(ot,rt,st,tt);return yt===ot?{x:U,y:u.y}:yt===rt?{x:q,y:u.y}:yt===st?{x:u.x,y:z}:{x:u.x,y:Y}},"nodeBoundaryClamp");for(const u of t.edges){const b=u.points;if(!b||b.length<2)continue;const S=u.start,L=u.end,A=S?r.get(S):void 0,B=L?r.get(L):void 0;A&&(b[0]=V(b[0],A)),B&&(b[b.length-1]=V(b[b.length-1],B))}return t}d(lr,"routeEdgesOrthogonal");function fr(t){return t.direction??"TB"}d(fr,"getSwimlaneDirection");function dr(t){const e=Uo(t),n=t.config.flowchart?.nodeSpacing??40,o=t.config.flowchart?.rankSpacing??100,s=t.config.swimlane?.ignoreCrossLaneEdges??!0,r=t.config.swimlane?.optimizeRanksByCrossings??!0,a=t.config.swimlane?.automaticLaneOrdering??!1,l=fr(t),{ordered:f,coordinates:i}=ar(e,{nodeGap:n,layerGap:o,ignoreCrossLaneEdges:s,optimizeRanksByCrossings:r,automaticLaneOrdering:a,direction:l});Wo(e,f,i,{nodeGap:n,layerGap:o});for(const g of t.edges??[])delete g.points;lr(t,l);for(const g of t.edges??[])(!g.curve||g.curve==="basis")&&(g.curve="rounded");return Es(t,l),Ls(t),l}d(dr,"runSwimlaneLayoutCore");function ur(t){jo(t);const e=Ko(t);t.nodes=e.nodes,t.edges=e.edges}d(ur,"prepareSwimlaneLayout");var Hr=Cr({prepareLayout:ur,runLayoutCore:dr,afterPaint:zo});export{Hr as render}; diff --git a/packages/tempo/public/v4/assets/chunks/swimlanesDiagram-VR7AAH4N.DfLXry6V.js b/packages/tempo/public/v4/assets/chunks/swimlanesDiagram-VR7AAH4N.DfLXry6V.js new file mode 100644 index 00000000..dba75170 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/swimlanesDiagram-VR7AAH4N.DfLXry6V.js @@ -0,0 +1,8 @@ +import{c as r,s as e}from"./flowDiagram-HODETNUW.ClPsWLK6.js";import{_ as a}from"../app.CbekdYod.js";import"./chunk-5VM5RSS4.-zPOtr2J.js";import"./chunk-XXDRQBXY.C52oJrTB.js";import"./chunk-POPQ4Y6H.DEs7vhGS.js";import"./chunk-F27PBJKO.CcniKEe6.js";import"./channel.DScgq80D.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var o=a(t=>`${e(t)} + .swimlane.cluster rect { + stroke: ${t.clusterBorder} !important; + } + [data-look="neo"].cluster rect { + filter: none; + } +`,"getStyles"),m=o,y=r({defaultLayout:"swimlane",styles:m});export{y as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/tempo.index.Cp7zs7az.js b/packages/tempo/public/v4/assets/chunks/tempo.index.Cp7zs7az.js new file mode 100644 index 00000000..66ef7bb0 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/tempo.index.Cp7zs7az.js @@ -0,0 +1,5 @@ +function dt(e,t,n,r,s,o){function i(c){if(c!==void 0&&typeof c!="function")throw new TypeError("Function expected");return c}for(var f=r.kind,a=f==="getter"?"get":f==="setter"?"set":"value",h=!t&&e?r.static?e:e.prototype:null,m=t||(h?Object.getOwnPropertyDescriptor(h,r.name):{}),g,p=!1,T=n.length-1;T>=0;T--){var N={};for(var O in r)N[O]=O==="access"?{}:r[O];for(var O in r.access)N.access[O]=r.access[O];N.addInitializer=function(c){if(p)throw new TypeError("Cannot add initializers after decoration has completed");o.push(i(c||null))};var d=(0,n[T])(f==="accessor"?{get:m.get,set:m.set}:m[a],N);if(f==="accessor"){if(d===void 0)continue;if(d===null||typeof d!="object")throw new TypeError("Object expected");(g=i(d.get))&&(m.get=g),(g=i(d.set))&&(m.set=g),(g=i(d.init))&&s.unshift(g)}else(g=i(d))&&(f==="field"?s.unshift(g):m[a]=g)}h&&Object.defineProperty(h,r.name,m),p=!0}function mt(e,t,n){for(var r=arguments.length>2,s=0;spo(e,le.$LogConfig),Qe=e=>po(e,le.$Extensible);function Ze(e){let t=e,n=0;const r=50;for(;t;){const s=t[le.$Target];if(!s||n>=r)break;t=s,n++}return t}function ie(e,t=!1){if(!e||typeof e!="object")return[];const n=Ze(e);if(!t){const h=Reflect.ownKeys(n),m=[];for(const g of h){const p=Object.getOwnPropertyDescriptor(n,g);p&&p.enumerable&&m.push([g,n[g]])}return m}const r=[],s=50;let o=0,i=n;for(;i&&i!==Object.prototype&&o++n)}function go(e,t=!1){return ie(e,t).map(([n,r])=>r)}function ce(e,t,...n){if(e===null||typeof e!="object"&&typeof e!="function")return!1;const r=Ze(e);if(!Object.hasOwn(r,t))return!1;if(n.length===0)return!0;const s=r[t];return yo(s,n)}function tn(e,...t){if(e===null||typeof e!="object"&&typeof e!="function"||t.length===0)return!1;const n=Ze(e);return t.some(r=>r in n)}function zt(e,...t){if(e===null||typeof e!="object"&&typeof e!="function")return!0;const n=Ze(e);return!t.some(r=>r in n)}function Se(e,t,...n){if(e===null||typeof e!="object"&&typeof e!="function")return!1;const r=Ze(e);if(!(t in r))return!1;if(n.length===0)return!0;const s=r[t];return yo(s,n)}function yo(e,t){for(let n=0;nr.length>0).reduce((r,s)=>r?.[s]??null,e)??n}function Wr(e,t,n){return t?Wr(e.map(t,n)):Array.from(new Set(e))}const Tr=[],jr=e=>{if(e===null)return"Null";if(e===void 0)return"Undefined";const t=typeof e;if(t==="string")return"String";if(t==="number")return"Number";if(t==="boolean")return"Boolean";if(t==="bigint")return"BigInt";if(t==="symbol")return"Symbol";try{const n=t==="object"?Ze(e):e;return Object.prototype.toString.call(n).slice(8,-1)}catch{return t==="function"?"Function":"Object"}},Zr=e=>{try{const t=e?.[Symbol.toStringTag]??e?.prototype?.[Symbol.toStringTag];if(typeof t=="string")return t}catch{}},$t=(e,...t)=>{let n=e;try{n=e?.[le.$Target]??e}catch{n=e}const r=jr(n);switch(r){case"Function":try{return Ri(n)?"Class":"Function"}catch{return"Function"}case"Object":{try{if("length"in n&&Object.keys(n).every(o=>o==="length"||Number.isFinite(Number(o))))return"ArrayLike";for(const o of t){const i=o.class?.[le.$Target]??o.class;if(n===i||i&&n instanceof i)return o.type}const s=globalThis[le.$Registry]??[];for(const o of[...Tr,...s]){const i=o.class?.[le.$Target]??o.class;if(n===i||i&&n instanceof i)return o.type}}catch{return"Object"}return"Object"}default:return r}},Mt=(e,...t)=>({type:$t(e,...t),value:e}),Ci=/^\s*(class\s|\[native code\])/,Ri=e=>{if(typeof e!="function")return!1;const t=e?.[le.$Target]??e;if(!("prototype"in t))return!1;const n=t?.name,r=Zr(t);if(t?.[le.$Identity]||t?.prototype?.[le.$Identity]||typeof r=="string"&&r.startsWith("Temporal."))return!0;if(typeof r=="string"&&r.endsWith("Function"))return!1;if((globalThis[le.$Registry]??[]).some(o=>(o.class?.[le.$Target]??o.class)===t||n&&o.type===n||r&&o.type===r))return!0;try{const o=Function.prototype.toString.call(t);if(Ci.test(o))return!0;const i=Object.getOwnPropertyDescriptor(t,"prototype");if(i&&i.writable===!1&&!Object.isFrozen(t))return!0;const f=t.prototype;if(f&&Object.getOwnPropertyNames(f).length>2)return!0}catch{return!1}return!1},Bn=(e,t)=>{if(typeof e!="function")return;const n=Zr(e),r=t??n??e.name;r&&!["Object","Function",""].includes(r)&&(Tr.some(s=>s.class===e)||Tr.push({class:e,type:r}))},Fe=e=>e,Ce=(e,...t)=>t.includes($t(e)),nr=e=>e===null||typeof e!="object"&&typeof e!="function",Vt=e=>!nr(e),_i=e=>Symbol.iterator in Object(e)&&!L(e),L=e=>typeof e=="string",Ye=e=>typeof e=="string"&&e.trim().length>0,V=e=>Number.isFinite(e),Li=/^\d+$/,Or=/^[+-]?[0-9]+$/,wo=/^[+-]?[0-9]+n$/,Pi=/^https?:\/\//i,bo=/^file:\/\//i,Er=/[\u0300-\u036f]/g,Tn=e=>typeof e=="string"&&Pi.test(e),Yn=e=>typeof e=="string"&&bo.test(e);function Le(e){switch(typeof e){case"number":return Number.isFinite(e);case"bigint":return!0;case"string":{const n=e.trim();return n.length===0?!1:wo.test(n)||V(Number(n))}default:return!1}}const Qt=e=>typeof e=="bigint",So=e=>typeof e=="string"&&wo.test(e.trim()),xi=e=>typeof e=="number"?Number.isFinite(e):typeof e=="bigint",Dr=e=>typeof e=="boolean",Ct=e=>Array.isArray(e),zi=e=>jr(e)==="Object"&&"length"in e&&Object.keys(e).every(t=>t==="length"||V(Number(t))),x=e=>Ce(e,"Object"),Re=e=>{if(e===null||typeof e!="object")return!1;const t=Object.getPrototypeOf(e);return t===Object.prototype||t===null},Kn=e=>Ce(e,"Date"),Gn=e=>Ce(e,"RegExp"),De=e=>typeof e=="symbol",To=e=>typeof e=="symbol"&&Symbol.keyFor(e)!==void 0,Fi=["__proto__","constructor","prototype"],gt=e=>!Fi.includes(e),Wi=e=>e===null,Me=e=>e==null||Ce(e,"Void","Empty"),U=e=>e===void 0||Ce(e,"Void","Empty"),k=e=>e!=null&&!Me(e),ms=e=>Ce(e,"Class"),P=e=>Ce(e,"Function","AsyncFunction","GeneratorFunction","AsyncGeneratorFunction"),Te=e=>typeof e=="function",pn=e=>Ce(e,"Map"),gn=e=>Ce(e,"Set"),Ur=(e,t)=>Ce(e,"Error")&&!0,Br=e=>jr(e).startsWith("Temporal.")||k(globalThis.Temporal)&&(e instanceof globalThis.Temporal.Instant||e instanceof globalThis.Temporal.ZonedDateTime||e instanceof globalThis.Temporal.PlainDate||e instanceof globalThis.Temporal.PlainTime||e instanceof globalThis.Temporal.PlainDateTime||e instanceof globalThis.Temporal.Duration||e instanceof globalThis.Temporal.PlainYearMonth||e instanceof globalThis.Temporal.PlainMonthDay),qt=e=>Ce(e,"Temporal.Instant")||k(globalThis.Temporal?.Instant)&&e instanceof globalThis.Temporal.Instant||k(e)&&e[Symbol.toStringTag]==="Temporal.Instant"||k(e)&&P(e.toZonedDateTimeISO)&&U(e.timeZoneId)&&U(e.timeZone),te=e=>Ce(e,"Temporal.ZonedDateTime")||k(globalThis.Temporal?.ZonedDateTime)&&e instanceof globalThis.Temporal.ZonedDateTime||k(e)&&e[Symbol.toStringTag]==="Temporal.ZonedDateTime"||k(e)&&P(e.toInstant)&&(k(e.timeZoneId)||k(e.timeZone)),Oo=e=>Ce(e,"Temporal.PlainDate")||k(globalThis.Temporal?.PlainDate)&&e instanceof globalThis.Temporal.PlainDate||k(e)&&e[Symbol.toStringTag]==="Temporal.PlainDate"||k(e)&&P(e.toZonedDateTime)&&U(e.timeZoneId)&&U(e.timeZone)&&k(e.daysInMonth)&&U(e.hour)&&U(e.minute)&&U(e.second)&&U(e.nanosecond),Eo=e=>Ce(e,"Temporal.PlainDateTime")||k(globalThis.Temporal?.PlainDateTime)&&e instanceof globalThis.Temporal.PlainDateTime||k(e)&&e[Symbol.toStringTag]==="Temporal.PlainDateTime"||k(e)&&P(e.toZonedDateTime)&&U(e.timeZoneId)&&U(e.timeZone)&&(k(e.hour)||k(e.minute)||k(e.second)||k(e.nanosecond)),ji=e=>Ce(e,"Temporal.Duration")||k(globalThis.Temporal?.Duration)&&e instanceof globalThis.Temporal.Duration||k(e)&&e[Symbol.toStringTag]==="Temporal.Duration",hs=e=>L(e)||ji(e)||x(e)&&("years"in e||"months"in e||"weeks"in e||"days"in e||"hours"in e||"minutes"in e||"seconds"in e||"milliseconds"in e||"microseconds"in e||"nanoseconds"in e||"yy"in e||"mm"in e||"ww"in e||"dd"in e||"hh"in e||"mi"in e||"ss"in e||"ms"in e||"us"in e||"ns"in e),Yr=e=>typeof Intl<"u"&&typeof Intl.Locale=="function"&&e instanceof Intl.Locale,Q=e=>Me(e)||x(e)&&Reflect.ownKeys(e).length===0||L(e)&&e.trim().length===0||typeof e=="number"&&Number.isNaN(e)||Ct(e)&&e.length===0||gn(e)&&e.size===0||pn(e)&&e.size===0||ArrayBuffer.isView(e)&&e.byteLength===0||Kn(e)&&Number.isNaN(e.getTime());function vn(e,...t){const{type:n,value:r}=Mt(e);switch(n){case"Array":if(Q(t)){r.length=0;break}Wr(t.filter(s=>!De(s)).map(s=>Number(s)).filter(s=>Number.isInteger(s)&&s>=0&&so-s).forEach(s=>r.splice(s,1));break;case"Object":(Q(t)?he(r):t).forEach(s=>Reflect.deleteProperty(r,s))}return r}function Zi(e){return Object.fromEntries(ie(e,!0))}const at=e=>Object.defineProperties({},Object.getOwnPropertyDescriptors(e)),Do=(e={})=>Ui(e,"get"),Ui=(e={},t)=>{const n=[];let s=0,o=e.prototype||Object.getPrototypeOf(e);for(;o&&o!==Object.prototype&&++s<50;){const f=Object.getOwnPropertyDescriptors(o);Reflect.ownKeys(f).forEach(a=>{P(f[a][t])&&n.push(a)}),o=Object.getPrototypeOf(o)}let i=P(e)?e:e.constructor;for(s=0;i&&i!==Function.prototype&&i!==Object.prototype&&++s<50;){const f=Object.getOwnPropertyDescriptors(i);Reflect.ownKeys(f).forEach(a=>{P(f[a][t])&&n.push(a)}),i=Object.getPrototypeOf(i)}return Wr(n)},pe={Unknown:"unknown",Browser:"browser",WebWorker:"web-worker",NodeJS:"nodejs",Deno:"deno",GoogleAppsScript:"google-apps-script"},rr=()=>{const e=globalThis;try{if(k(e.SpreadsheetApp))return{global:e,type:pe.GoogleAppsScript};if(k(e.window?.document))return{global:e,type:pe.Browser};if(P(e.importScripts)||k(e.WorkerGlobalScope)&&e instanceof e.WorkerGlobalScope)return{global:e,type:pe.WebWorker};if(k(e.Deno))return{global:e,type:pe.Deno};if(k(e.process?.versions?.node)&&e.process?.release?.name==="node")return{global:e,type:pe.NodeJS}}catch{}return{global:e,type:pe.Unknown}},Bi=new WeakSet;function Hn(e,t,n=new WeakSet){const r=t instanceof WeakSet?t:t?.skip??Bi;return nr(e)||n.has(e)||r.has(e)||e instanceof Date||e instanceof RegExp||e instanceof Error||e instanceof Map||e instanceof Set||e instanceof Promise||e?.[Symbol.toStringTag]==="Enumify"||e[le.$Extensible]?e:(n.add(e),ie(e).forEach(([s,o])=>{gt(s)&&Hn(o,{skip:r},n)}),Object.freeze(e))}const ps=new WeakMap;function On(e,t={},n=!1){const{frozen:r,lock:s,appendOnly:o,onGet:i,keys:f,bind:a,skip:h}=t,m=new Set;let g,p;const T=Ze(e);s&&Hn(T,h?{skip:h}:void 0),Bn(T);const N={isExtensible:O=>Reflect.isExtensible(O),getPrototypeOf:O=>Reflect.getPrototypeOf(O),setPrototypeOf:(O,d)=>{if(r)throw new TypeError("Security: Prototype mutation attempt on protected object");return Reflect.setPrototypeOf(O,d)},getOwnPropertyDescriptor:(O,d)=>{if(!(f&&!f.includes(d))){if(f){if(i&&!De(d)&&!m.has(d)){m.add(d);try{const c=i(d,O);if(k(c))return{enumerable:!0,configurable:!0,value:c}}finally{m.delete(d)}}return{enumerable:!0,configurable:!0}}return Reflect.getOwnPropertyDescriptor(O,d)}},ownKeys:O=>{if(f)return f;if(i&&!m.has(le.$Discover)){m.add(le.$Discover);try{i(le.$Discover,O)}finally{m.delete(le.$Discover)}}return Reflect.ownKeys(O)},has:(O,d)=>f?f.includes(d):Reflect.has(O,d),deleteProperty:(O,d)=>{if(r)throw new TypeError(`Cannot delete property '${String(d)}' from a protected object.`);if(o&&Reflect.has(O,d))throw new Error(`Security: Deletion attempt on protected key '${String(d)}'`);return Reflect.deleteProperty(O,d)},defineProperty:(O,d,c)=>{if(r&&!Object.isFrozen(O))throw new TypeError(`Cannot define property '${String(d)}' on a frozen object.`);if(o&&Reflect.has(O,d))throw new Error(`Security: Mutation attempt on protected key '${String(d)}'`);return Reflect.defineProperty(O,d,c)},set:(O,d,c,l)=>{if(r&&l===p)throw new TypeError(`Cannot set property '${String(d)}' on a frozen object.`);if(o){if(Array.isArray(O)&&d==="length"&&c{if(d===le.$Target)return c===p?O:void 0;if(r&&(d===le.$Inspect||d==="toJSON")){const u=Object.getOwnPropertyDescriptor(O,d);return u&&P(u.value)?u.value:(g||(g=()=>Zi(O)),g)}if(f&&!f.includes(d))return;if(i&&!De(d)&&!Reflect.has(O,d)&&!m.has(d)){m.add(d);try{const u=i(d,O);if(k(u))return u}finally{m.delete(d)}}const l=Reflect.get(O,d,c);if(a&&d!=="constructor"&&P(l)){const u=Object.getOwnPropertyDescriptor(O,d);if(u&&!u.configurable&&!u.writable)return l;let y=ps.get(l);y||(y=new WeakMap,ps.set(l,y));const b=y.get(O);if(b)return b;const S=l.bind(O);return y.set(O,S),S}return l}};if(n){const O=Proxy.revocable(T,N);return p=O.proxy,{proxy:O.proxy,revoke:O.revoke}}return p=new Proxy(T,N),p}function qe(e,t=!0,n=t,r=new WeakSet){return On(e,{frozen:t,lock:n,skip:r,bind:t})}function _n(e,t,n=!0){return On(e,{onGet:t,frozen:n})}function Yi(e){return On(e,{appendOnly:!0})}function _e(e,t=new WeakSet){return On(e,{frozen:!0,lock:!0,skip:t,bind:!0})}function Ki(e,t){const n=Array.isArray(e)?e:Reflect.ownKeys(e);return On({},{keys:n,onGet:t,frozen:!0})}function Gi(e,t,n=!0){return _n(e,r=>L(r)&&r!=="length"&&!(r in Array.prototype)&&!V(Number(r))?t(r):void 0,n)}function gs(e){return x(e)?new Proxy(e,{get(t,n,r){if(n===le.$Target)return t;const s=Reflect.get(t,n,r);if(!P(s)||De(n)||n==="constructor")return s;const o=Reflect.getOwnPropertyDescriptor(t,n);return o&&!o.configurable&&!o.writable?s:s.call(t)},has(t,n){return Reflect.has(t,n)},ownKeys(t){return Reflect.ownKeys(t)},getOwnPropertyDescriptor(t,n){return Reflect.getOwnPropertyDescriptor(t,n)}}):e}function yn(e,t=new WeakSet){return JSON.stringify(e,function(n,r){if(r===void 0)return"\0__undefined__\0";if(Qt(r))return`\0__bigint:${r}__\0`;if(P(r))return`function:${r.name||"anonymous"}`;if(Vt(r)){if(t.has(r))return"";if(t.add(r),Yr(r))return r.toString();if(pn(r))return`map:[${Array.from(r.entries()).map(s=>yn(s,t)).sort().join(",")}]`;if(gn(r))return`set:[${Array.from(r).map(s=>yn(s,t)).sort().join(",")}]`}return r})}function Hi(e){return function t(...n){return n.length>=e.length?e(...n):(...r)=>t(...n,...r)}}function xe(e){const t=new Map;return function(...n){const r=yn(this!==void 0&&this!==globalThis?[this,...n]:n);if(!t.has(r)){const s=e.apply(this,n);t.set(r,s)}return t.get(r)}}const kr=new WeakMap;function Gt(e){kr.delete(e)}function Nn(e,t){return{enumerable:!1,configurable:!1,writable:!1,value:function(...n){const r=`${String(e)},${yn(n)}`;let s=kr.get(this);if(s||(s=new Map,kr.set(this,s)),!s.has(r)){const o=t.apply(this,n);_e(o),s.set(r,o)}return s.get(r)}}}function Ji(e){if(!L(e))throw new TypeError("Expected string input to stripJSONC");let t=!1,n="",r=!1,s="";const o=e.length;for(let g=0;g{const t=new Set;let n=e,r=0;for(;n&&n!==Object.prototype&&r++<10;){const s=Object.getOwnPropertyDescriptors(n);for(const[o,i]of Object.entries(s))gt(o)&&(i.enumerable||P(i.get))&&t.add(o);n=Object.getPrototypeOf(n)}return Array.from(t)},Ln=e=>{if(nr(e)||P(e))return e;if(Ct(e))return Fe(e.map(n=>Ln(n)));if(Kn(e)||Gn(e)||pn(e)||gn(e))return e;try{if(P(e.toJSON))return Ln(e.toJSON())}catch{}const t={};for(const n of qi(e))try{t[n]=Ln(e[n])}catch{}return t},Bt=(e,t)=>{if(e===t)return!0;if(Me(e)||Me(t))return e===t;if($t(e)!==$t(t))return!1;if(Ct(e)&&Ct(t)){const n=e,r=t;return n.length===r.length&&n.every((s,o)=>Bt(s,r[o]))}if(pn(e)&&pn(t)){const n=e,r=t;return n.size===r.size&&Array.from(n.keys()).every(s=>r.has(s)&&Bt(n.get(s),r.get(s)))}if(gn(e)&&gn(t)){const n=e,r=t;if(n.size!==r.size)return!1;const s=Array.from(r),o=new Set;for(const i of n){const f=s.findIndex((a,h)=>!o.has(h)&&Bt(i,a));if(f===-1)return!1;o.add(f)}return!0}if(x(e)&&x(t)){const n=e,r=t,s=new Set,o=P(n.keys)&&Object.getPrototypeOf(n)!==Object.prototype?Array.from(n.keys()):he(n),i=P(r.keys)&&Object.getPrototypeOf(r)!==Object.prototype?Array.from(r.keys()):he(r);return o.forEach(f=>s.add(f)),i.forEach(f=>s.add(f)),s.size!==o.length||s.size!==i.length?!1:[...s].every(f=>Bt(n[f],r[f]))}return!1};function ko(e){return ie(e).reduce((t,[n,r])=>(gt(n)&&k(r)&&(t[n]=r),t),{})}const Jn=(...e)=>e.reduce((t,n)=>(x(n)&&Object.entries(n).forEach(([r,s])=>{if(!gt(r))return;const o=t[r];x(o)&&x(s)?t[r]=Jn(o,s):x(s)?t[r]=Jn({},s):t[r]=s}),t),{});function Ne(e){return k(e)?P(e)?e():e:t=>P(t)?t():t}Ne.stringSymbol=Ne();Ne.symbolRegExp=Ne();Ne.symbolString=Ne();Ne.stringString=Ne();const Pn=globalThis[le.$SerializerRegistry]??=new Map,ys=e=>{try{const t=e?.prototype?.[Symbol.toStringTag]??e?.[Symbol.toStringTag];return L(t)?t:void 0}catch{return}},Xi=(e,t)=>{const n=e.startsWith("$")?e:`$${e}`;if(Pn.has(n)){const r=Pn.get(n),s=ys(r),o=ys(t),i=r.name||s,f=t.name||o||(e.startsWith("$")?e.slice(1):e);if(r===t||r.toString()===t.toString()||!!t[le.$Identity]&&r[le.$Identity]===t[le.$Identity]||!!t[le.$Target]&&r[le.$Target]===t[le.$Target]||!!i&&!!f&&i===f)return;throw new Error(`[registerSerializable] Collision: '${n}' is already registered with ${r.name||"anonymous constructor"}`)}Pn.set(n,t)};function vo(e,t){try{return globalThis.structuredClone(e,t)}catch{return Vi(e)}}function Qi(e,t){return ta(t)}const No={"%20":" ","%22":'"',"%3B":";","%3C":"<","%3E":">","%5B":"[","%5D":"]","%5E":"^","%7B":"{","%7C":"|","%7D":"}"},ea=new RegExp(Object.keys(No).join("|"),"gi");function ws(e){let t=encodeURI(e);return t.includes("%")&&(t=t.replace(ea,n=>No[n.toUpperCase()]??decodeURI(n))),t}function ta(e){if(L(e))try{return decodeURI(e)}catch{}return e}function nn(e){return!Ce(e,"Function","AsyncFunction","WeakMap","WeakSet","WeakRef")}function na(e,t){return`{"$${e}":${t}}`}function ra(e){return Ge(De(e)?`${To(e)?"@":""}@(${e.description??""})`:e)}const sa=/^@(@)?\(([^\)]*)\)$/;function vr(e){const[t,n,r]=e.toString().match(sa)||[null,void 0,void 0];switch(!0){case De(e):case Me(t):case(k(n)&&U(r)):return e;case k(n):return Symbol.for(r);case U(n):default:return Symbol(r)}}const oa=globalThis.crypto?.randomUUID?globalThis.crypto.randomUUID().split("-")[0]:Math.random().toString(36).slice(2,10),ia=(e,t=oa)=>{let n=2166136261,r=2654435769;const s=`${t}:${e}`;for(let o=0;o>>0).toString(16).padStart(8,"0")+(r>>>0).toString(16).padStart(8,"0")},aa=(e,t)=>{if(!L(e)||!L(t)||e.length!==t.length)return!1;let n=0;for(let r=0;rnn(o)).map(([o,i])=>`${ra(o)}: ${Ge(i)}`).join(",")}}`;case"Array":return`[${n.value.filter(o=>nn(o)).map(o=>Ge(o)).join(",")}]`;case"Map":{const s=Array.from(n.value.entries()).filter(([,o])=>nn(o)).map(([o,i])=>`[${Ge(o)}, ${Ge(i)}]`).join(",");return r(`[${s}]`)}case"Set":{const s=Array.from(n.value.values()).filter(o=>nn(o)).map(o=>Ge(o)).join(",");return r(`[${s}]`)}case"Symbol":{const s=`${To(n.value)?"@":""}@(${n.value.description??""})`;return vt?JSON.stringify(`~y${s}`):r(JSON.stringify(s))}case"RegExp":return r(Ge({source:n.value.source,flags:n.value.flags}));default:{const s=n.value;switch(!0){case!nn(s):return;case P(s.toJSON):return r(Ge(s.toJSON()));case(P(s.toString)&&s.toString!==Object.prototype.toString):{const o=s.toString();return r(o.includes('"')?o:JSON.stringify(o))}case(P(s.valueOf)&&s.valueOf!==Object.prototype.valueOf):return r(JSON.stringify(s.valueOf()));default:{const o=Ln(s);return Vt(o)&&Object.keys(o).length>0?Ge(o):r(JSON.stringify(s,(i,f)=>Q(i)?f:Ge(f)))}}}}}const ca=64,la=512;function Io(e,t){if(!L(e))return e;const n=P(t)?{sentinel:t}:t??{};if(e.startsWith("$sig:")){const s=e.indexOf(":",5);if(s!==-1){const o=e.substring(5,s),i=e.substring(s+1);if(!L(n.secret)||!n.secret){if(console.warn("objectify: signature verification requires an explicit secret string"),n.throwOnError)throw new TypeError("objectify: signature verification requires an explicit secret string");return e}const f=ia(i,n.secret);if(!aa(o,f)){if(console.warn("objectify: signature verification failed"),n.throwOnError)throw new Error("objectify: signature verification failed");return e}e=i}else if(n.requireSigned){if(console.warn("objectify: malformed signed payload"),n.throwOnError)throw new Error("objectify: malformed signed payload");return e}}else if(n.requireSigned){if(console.warn("objectify: unsigned string rejected by requireSigned policy"),n.throwOnError)throw new Error("objectify: unsigned string rejected by requireSigned policy");return e}let r;try{r=JSON.parse(e,Qi)}catch(s){return e.startsWith('"')&&e.endsWith('"')?(console.warn(`objectify.parse: -> ${e}, ${s.message}`),e):Io(`"${e}"`,n.requireSigned?{...n,requireSigned:!1}:n)}switch(!0){case(e.startsWith("{")&&e.endsWith("}")):case(e.startsWith("[")&&e.endsWith("]")):return Nr(r,n,0);default:return fn(r,n)}}function Nr(e,t,n=0){const r=t.maxDepth??ca;return n>=r?e:x(e)?fn(ie(e).filter(([s])=>gt(s)).reduce((s,[o,i])=>Object.assign(s,{[vr(o)]:fn(Nr(i,t,n+1),t)}),{}),t):Ct(e)?go(e).map(s=>fn(Nr(s,t,n+1),t)):fn(e,t)}function fn(e,t){if(L(e)&&e.startsWith("~"))try{if(e.startsWith("~~"))return e.substring(1);if(e.startsWith("~n"))return BigInt(e.substring(2));if(e.startsWith("~t")){const o=e.substring(2),i=new Date(Le(o)?Number(o):o);return isNaN(i.getTime())?e:i}if(e==="~u")return t.sentinel?.();if(e.startsWith("~y"))return vr(e.substring(2))}catch{return e}if(!x(e)||he(e).length!==1)return e;const[n,r]=ie(e)[0];if(!String(n).startsWith("$"))return e;const s=n.substring(1);try{switch(s){case"String":case"Boolean":case"Object":case"Array":return r;case"Number":return Number(r);case"BigInt":return BigInt(r);case"Null":return null;case"Undefined":case"Empty":case"Void":return t.sentinel?.();case"Date":return new Date(r);case"RegExp":return t.allowRegExp===!1||!x(r)||!L(r.source)||r.source.length>la?e:new RegExp(r.source,r.flags);case"Symbol":return vr(r);case"Map":return Ct(r)?new Map(r):e;case"Set":return Ct(r)?new Set(r):e;default:{if(t.allowClasses===!1||t.allowedClasses&&!(t.allowedClasses instanceof Set?t.allowedClasses.has(n)||t.allowedClasses.has(s):t.allowedClasses.includes(n)||t.allowedClasses.includes(s)))return e;const o=Pn.get(n);return o?Reflect.construct(o,[r]):(console.warn(`objectify: dont know how to deserialize '${s}'`),e)}}}catch{return e}}const ua=/\t/g,fa=/(\r\n|\n|\r)/g,da=/\s{2,}/g;function ma(e,t){return(t?e.toString().replace(t,""):e.toString()).replace(ua," ").replace(fa," ").replace(da," ").trim()}function ha(e,t){try{return e.charAt(0).toLocaleUpperCase(t)+e.slice(1).toLocaleLowerCase(t)}catch{return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()}}const Xe=e=>e.endsWith("s")&&e.length>3?e.slice(0,-1):e,K=(e=0,t=2,n)=>e.toString().padStart(t,(Le(e)?"0":" ").toString());function H(e=[],t){const n=r=>U(t)||k(r)?r:vo(t);return zi(e)||_i(e)&&!L(e)?Array.from(e,n):[e]}function bs(e){return Me(e)?"":Qt(e)?e.toString()+"n":sr(e)}function pa(e,t){if(V(e))return e;if(Qt(e)){const n=Number(e);return V(n)?n:t}if(L(e)){const n=e.trim();if(n.length>0){const r=Number(n);if(V(r))return r}}return t}const ga=/^[+-]/,ya=BigInt(Number.MAX_SAFE_INTEGER),wa=BigInt(Number.MIN_SAFE_INTEGER);function Ao(e){return String(e).trim().replace(ga,"")}function ba(e){if(Qt(e))return e;if(V(e))return BigInt(Math.trunc(e));const t=String(e).trim(),n=Ao(e);if(n.length===0)return BigInt(t);const r=t.startsWith("-")?-1n:1n,s=So(n)?-1:void 0;return r*BigInt(n.slice(0,s))}function fr(e){return e>ya||e{if(Qt(e))return fr(e);if(V(e))return Number.isInteger(e)?fr(BigInt(e)):e;const n=Ao(e);return Le(e)&&(!n.startsWith("0")||t)?So(n)||Or.test(n)?fr(ba(e)):pa(e,0):e},Ss=(e,t)=>e??t;function wn(e){if(Ur(e))return e;const t=new Error(Se(e,"message",L)?e.message:String(e));return x(e)&&(t.name=Se(e,"name","string")?e.name:"Error",Se(e,"code","string","number")&&(t.code=e.code),Se(e,"stack","string")&&(t.stack=e.stack)),t}if(typeof globalThis.Temporal>"u")throw new Error("Temporal API is not available. Node 20+ with a polyfill (e.g. @js-temporal/polyfill) is highly recommended. Native Temporal is fully reliable only on Node 26+ (while Node 22 may have instabilities).");try{if(typeof Temporal.Now.zonedDateTimeISO=="function"&&typeof Temporal.Now.zonedDateTimeISO().add!="function")throw new Error("Incomplete Temporal implementation")}catch(e){const t=wn(e);if(console.warn("Tempo: Native Temporal implementation appears incomplete. Consider loading a polyfill.",t),t.message!=="Incomplete Temporal implementation")throw t}function Gr(e,t){return Zr(e)??(U(t)?e.name||void 0:String(t))}function Sa(e,t,n,r,s){const o=t||"Anonymous";n(()=>{const m=Symbol.metadata,g=s??(m?e[m]:void 0),p=[...e[lt]??e.$Mutable??[],...e?.prototype?.[lt]??e?.prototype?.$Mutable??[],...g?.[lt]??g?.$Mutable??[]];Ta(e,e,p)});const i=Te(e)?Function.prototype.toString.call(e):"",f=i.includes("#")||i.includes("WeakMap")||i.includes("__private")||i.includes("privateMap");if(e[ho]===!0||e.raw===!0||e[lt]==="unwrapped"||f)return t&&Bn(e,t),e;const h={[o]:class extends e{constructor(...m){return super(...m),r(this)}}}[o];return t&&Bn(h,t),h}function Ts(e,t){return Array.isArray(t)?t.some(n=>{if(L(n)||De(n))return n===e;if(Se(n,"name")){if(n.name!==e)return!1;const r=n.condition;return Te(r)?!!r():!!(r??!0)}return!1}):!1}function Ta(e,t,n){const r=o=>{Reflect.ownKeys(o).forEach(i=>{if(i==="prototype"||i==="length"||i==="name"||i==="constructor"||Ts(i,n))return;const f=Object.getOwnPropertyDescriptor(o,i);if(!f)return;const a={};f.configurable&&(a.configurable=!1),"writable"in f&&f.writable&&(a.writable=!1),Object.keys(a).length&&Object.defineProperty(o,i,{...f,...a})})};r(e),r(t);const s=o=>{Vt(o)&&Reflect.ownKeys(o).forEach(i=>{if(i==="constructor"||Ts(i,n))return;const f=Object.getOwnPropertyDescriptor(o,i);if(!f)return;const a={};f.configurable&&(a.configurable=!1),"writable"in f&&f.writable&&(a.writable=!1),Object.keys(a).length&&Object.defineProperty(o,i,{...f,...a})})};s(e.prototype),s(t.prototype)}function $o(e,{kind:t,name:n,addInitializer:r,metadata:s}){const o=Gr(e,n);if(t==="class")return Sa(e,o,r,i=>(Object.freeze(i),i),s);throw new Error(`@Immutable decorating unknown 'kind': ${t} (${n})`)}function Mo(e,{kind:t,name:n,addInitializer:r}){const s=Gr(e,n);if(s&&Bn(e,s),t==="class")return s&&r(()=>Xi(s,e)),e;throw new Error(`@Serializable decorating unknown 'kind': ${t} (${n})`)}function Tt(e,t){const n=(r,s,o)=>{const i=r.prototype,f=s??Gr(r,o);if(f&&(i&&!ce(i,Symbol.toStringTag)&&Object.defineProperty(i,Symbol.toStringTag,{value:f,configurable:!0,writable:!1,enumerable:!1}),!r.name||r.name!==f))try{Object.defineProperty(r,"name",{value:f,configurable:!0,writable:!1,enumerable:!1})}catch{}return r};return Te(e)&&t?.kind==="class"?n(e,void 0,t.name):(r,s)=>n(r,L(e)?e:void 0,s?.name)}function Oa(e,t){const n=(r,s)=>{const o={name:r.name,condition:Te(s)?s:()=>s??!0};if(r.metadata){let i=r.metadata[lt];Array.isArray(i)||(i=[],Object.defineProperty(r.metadata,lt,{value:i,writable:!0,configurable:!0})),i.push(o)}r.addInitializer(function(){const i=[this];this&&Te(this.constructor)&&this.constructor!==this&&i.push(this.constructor);for(const f of i){let a=f[lt];Array.isArray(a)||(a=[],Object.defineProperty(f,lt,{value:a,writable:!0,configurable:!0})),a.push(o)}})};return Se(t,"kind")?n(t,!0):(r,s)=>{n(s,e)}}let Nt=(()=>{let e=[Tt("BoundedCache")],t,n=[],r,s=Map;var o=class extends s{static{r=this}static{const i=typeof Symbol=="function"&&Symbol.metadata?Object.create(s[Symbol.metadata]??null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:i},null,n),o=r=t.value,i&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:i}),mt(r,n)}#e=new Map;#n=new Set;#s=new Map;maxSize;ttl;constructor(i=1e3,f=1440*60*1e3){super(),this.maxSize=i,this.ttl=f}get isBoundedCache(){return!0}#r(i){const f=this.#e.get(i);return f===void 0?!1:Date.now()>f}evictExpired(){if(this.#e.size===0)return;const i=Date.now();for(const[f,a]of this.#e.entries())i>a&&this.delete(f)}setStatic(i,f){return super.has(i)&&super.delete(i),super.set(i,f),this.#n.add(i),this.#e.delete(i),this.#s.delete(i),this}isStatic(i){return this.#n.has(i)}get(i){if(this.#r(i)){this.delete(i);return}if(!super.has(i))return;const f=super.get(i);return super.delete(i),super.set(i,f),f}has(i){return this.#r(i)?(this.delete(i),!1):super.has(i)}get size(){return this.evictExpired(),super.size}forEach(i,f){this.evictExpired(),super.forEach(i,f)}set(i,f,a){this.evictExpired();const h=this.#e.get(i);for(super.has(i)&&super.delete(i),super.set(i,f),this.#n.delete(i),k(a)?a!==1/0?(this.#e.set(i,Date.now()+a),this.#s.set(i,a)):(this.#e.delete(i),this.#s.delete(i)):h!==void 0?this.#e.set(i,h):this.ttl!==1/0?(this.#e.set(i,Date.now()+this.ttl),this.#s.delete(i)):(this.#e.delete(i),this.#s.delete(i));this.size-this.#n.size>this.maxSize;){let m=!1;const g=super.keys();let p=g.next();for(;!p.done;){const T=p.value;if(!this.#n.has(T)){this.delete(T),m=!0;break}p=g.next()}if(!m)break}return this}delete(i){return this.#n.delete(i),this.#e.delete(i),this.#s.delete(i),super.delete(i)}deletePrefix(i){const f=String(i).trim().toLowerCase();if(Q(f))return 0;const a=[];for(const h of super.keys())L(h)&&h.toLowerCase().startsWith(f)&&a.push(h);for(const h of a)this.delete(h);return a.length}clear(i){if(i===void 0){this.#n.clear(),this.#e.clear(),this.#s.clear(),super.clear();return}let f=0;for(const a of super.keys()){if(f>=i)break;this.#n.has(a)||(this.delete(a),f++)}}keys(){return this.evictExpired(),super.keys()}values(){return this.evictExpired(),super.values()}entries(){return this.evictExpired(),super.entries()}[Symbol.iterator](){return this.evictExpired(),super[Symbol.iterator]()}toJSON(){this.evictExpired();const i=[];for(const[f,a]of super.entries())L(f)&&i.push([f,a]);return Object.fromEntries(i)}static fromEntries(i,f=1e3,a=1440*60*1e3){const h=new o(f,a);for(const[m,g]of i)h.set(m,g);return h}};return o=r})();const We=rr(),Co=(e=1e3,t=1/0)=>{const n=new Nt(e,t);return{get length(){return n.size},clear:()=>n.clear(),getItem:r=>n.get(r)??null,key:r=>Array.from(n.keys())[r]??null,removeItem:r=>{n.delete(r)},setItem:(r,s)=>{n.set(r,String(s))}}},Os=new Map,Ea=e=>{let t=Os.get(e);return t||(t=Co(),Os.set(e,t)),t},Da=(e="localStorage")=>{try{const t=globalThis?.[e];if(t&&Te(t.getItem)&&Te(t.setItem)&&Te(t.removeItem)&&Te(t.clear)&&Te(t.key)&&V(t.length))return t}catch{}return Ea(e)};let Ir=We.type===pe.Browser?Da():Co();const Vn=new Nt(1e3,1/0),ka=e=>{try{const t=Reflect.get(We.global,"process");if(!t||typeof t!="object")return;const n=Reflect.get(t,"env");return!n||typeof n!="object"?void 0:Reflect.get(n,e)}catch{return}};function mn(e,t){let n;if(U(e))return t??{};switch(We.type){case pe.Browser:n=Ir.getItem(e);break;case pe.NodeJS:n=Vn.has(e)?Vn.get(e):ka(e);break;case pe.Deno:n=We.global.Deno.env.get(e);break;case pe.GoogleAppsScript:n=We.global.PropertiesService?.getUserProperties().getProperty(e);break;case pe.WebWorker:case pe.Unknown:n=void 0;break;default:throw new Error(`Cannot determine Javascript context: ${We.type}`)}return L(n)?Io(n):t}function Ro(e,t,n){const r=k(t)?sr(t):void 0,s=k(r);switch(We.type){case pe.Browser:try{s?Ir.setItem(e,r):Ir.removeItem(e)}catch(o){console.warn(`[Storage] Failed to ${s?"setItem":"removeItem"} for key '${e}':`,o)}break;case pe.NodeJS:s?Vn.set(e,r,n?.ttl):Vn.set(e,void 0,n?.ttl);break;case pe.Deno:s?We.global.Deno.env.set(e,r):We.global.Deno.env.delete(e);break;case pe.GoogleAppsScript:s?We.global.PropertiesService?.getUserProperties().setProperty(e,r):We.global.PropertiesService?.getUserProperties().deleteProperty(e);break;case pe.WebWorker:case pe.Unknown:break;default:throw new Error(`Cannot determine Javascript context: ${We.type}`)}}const va=()=>!!(We.global.VITEST||We.global.__VITEST_ENVIRONMENT__||mn("TEMPO_TESTING",!1)||mn("NODE_ENV","")==="test"||mn("CI",!1)),An=new FinalizationRegistry(e=>{try{P(e)&&e()}catch(t){console.error("Finalizer callback error:",t)}});let Na=(()=>{let e=[Tt("Finalizer")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),mt(r,n)}#e;constructor(s){this.#e=s}get isFinalizer(){return!0}register(s,o,i){const f=i??Object.create(null),a=this.#e;An.register(s,()=>{a(o)},f)}unregister(s){return An.unregister(s)}static register(s,o,i){const f=i??Object.create(null);return An.register(s,o,f),()=>An.unregister(f)}},r})(),Rt=(()=>{let e=[Tt("WeakCache")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),mt(r,n)}#e=new Map;#n;constructor(){this.#n=new Na(s=>{const o=this.#e.get(s.key);o&&o.token===s.token&&this.#e.delete(s.key)})}get isWeakCache(){return!0}set(s,o){this.delete(s);const i=Object.create(null);return this.#e.set(s,{ref:new WeakRef(o),token:i}),this.#n.register(o,{key:s,token:i},i),this}get(s){const o=this.#e.get(s);if(U(o))return;const i=o.ref.deref();if(U(i)){this.#n.unregister(o.token),this.#e.delete(s);return}return i}has(s){return k(this.get(s))}getOrSet(s,o){const i=this.get(s);if(k(i))return i;const f=o(s);return this.set(s,f),f}delete(s){const o=this.#e.get(s);return k(o)?(this.#e.delete(s),this.#n.unregister(o.token),!0):!1}clear(){for(const s of this.#e.values())this.#n.unregister(s.token);this.#e.clear()}},r})();const Es=new Map;function bt(){return Temporal.Now.instant()}function Ia(e=Intl.DateTimeFormat().resolvedOptions().timeZone){return Temporal.Now.plainDateISO(e)}function Aa(e,t=2024){const n=`${e}::${t}`;let r=Es.get(n);if(U(r)){const s=Temporal.ZonedDateTime.from({year:t,month:1,day:1,hour:0,minute:0,second:0,timeZone:e}).offsetNanoseconds,o=Temporal.ZonedDateTime.from({year:t,month:7,day:1,hour:0,minute:0,second:0,timeZone:e}).offsetNanoseconds;r=Object.freeze({jan:s,jul:o}),Es.set(n,r)}return r}function $a(e){const t=[["hours","minutes",60],["minutes","seconds",60],["seconds","milliseconds",1e3],["milliseconds","microseconds",1e3],["microseconds","nanoseconds",1e3]];for(const[n,r,s]of t){const o=e[n];if(V(o)&&o!==Math.trunc(o)){const i=Math.trunc(o),f=o-i;i?e[n]=i:delete e[n],e[r]=(e[r]??0)+Math.round(f*s)}}return e}const Ma=/^(\d{4}-\d{2}-\d{2})\s+(?=\d{2}:\d{2})/,Ca=/\s+(?=[Zz]|[+-]\d{2}|\[)/,Ds=/\[!?u-ca=[^\]]+\]/i,Ra=/\[(?!!?u-ca=)[^\]]+\]/i,_a=/Z$|[+-]\d{2}(:?\d{2})?$/i,La=/^UTC([+-])(\d{1,2})(?::(\d{2}))?$/i,Pa=new Rt;new Rt;function Hr(e,t="UTC"){if(!L(e))return Temporal.ZonedDateTime.from(e);const n=`${e}::${t}`;return Pa.getOrSet(n,()=>{const r=e.trim().replace(Ma,"$1T").replace(Ca,"");return Ra.test(r)?Temporal.ZonedDateTime.from(r):Ds.test(r)?Temporal.ZonedDateTime.from(r.replace(Ds,`[${t}]$&`)):r.includes("T")&&_a.test(r)?Temporal.Instant.from(r).toZonedDateTimeISO(t):Temporal.ZonedDateTime.from(`${r}[${t}]`)})}function ks(e){return Temporal.Instant.fromEpochNanoseconds(e)}function Pe(e,t){const n=Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC";let r,s;if(te(e)){const m=e;r=m.timeZoneId??m.timeZone?.id??m.timeZone,s=k(t)?t:m.calendarId??m.calendar?.id??m.calendar}else r=e,s=t;const o=m=>L(m)?m:te(m)?o(m.timeZoneId??m.timeZone?.id??m.timeZone):x(m)?String(m.id??m.timeZoneId??m.calendarId??""):String(m??""),i=o(r),f=o(s),a=Ye(i)&&i!=="[object Object]"&&i!=="undefined"?i:n,h=Ye(f)&&f!=="[object Object]"&&f!=="undefined"?f:"iso8601";return[a,h]}function _o(e){const t=La.exec(e);if(!t)return e;const[,n,r,s]=t,o=Number(r),i=Number(s??"0");return o>14||i>59||n==="+"&&o===14&&i!==0||n==="-"&&o>12?e:`${n}${r.padStart(2,"0")}:${s??"00"}`}function Ar(e,t=75,n){if(e>=100||e<0||!Number.isFinite(e))return e;const s=(V(n)?n:n?n.year:Ia().year)-t;let o=Math.floor(s/100)*100+e;return otypeof Intl<"u"&&(!e||ce(Intl,e,Te)),Ot=e=>{if(Yr(e)&&(e=e.toString()),!L(e))return;const t=e.trim();if(Q(t))return;const n=t.split(Fa)[0];if(!Q(n))return n.replace(za,"-")},$r=xe((e,t)=>new Intl.RelativeTimeFormat(Ot(e),t)),Mr=xe((e,t)=>new Intl.ListFormat(Ot(e),t)),be=xe((e,t)=>new Intl.DateTimeFormat(Ot(e),t)),Lo=xe((e,t)=>{try{return new Intl.PluralRules(Ot(e),t)}catch{return Fe({select:()=>"other"})}}),qn=xe((e,t)=>new Intl.NumberFormat(Ot(e),t)),ja=xe((e,t)=>{try{const n=new Intl.DurationFormat(Ot(e),t);if(P(n.format))return n;throw new Error("No format method")}catch{return{format:r=>String(r)}}});function rn(e,t,n){if(e){if(Te(e[t]))return e[t]();if(n&&n in e)return e[n]}}const Za=new Set(["US","CA","MX","BR","IL","JP","TW","HK","MO","PH","SG","TH","IN","KR","CO","PE","VE","ZA"]),Ua=new Set(["SA","AF","BH","DJ","DZ","EG","IQ","IR","JO","KW","LY","OM","QA","SD","SY","YE"]),Ba=new Set(["MV"]),Ya=new Set(["SA","BH","DJ","DZ","EG","IQ","JO","KW","LY","OM","QA","SD","SY","YE"]),Ka=new Set(["AD","AN","AT","AX","BE","BG","CH","CZ","DE","DK","EE","ES","FI","FJ","FO","FR","GB","GF","GG","GI","GP","GR","HU","IE","IM","IS","IT","JE","LI","LT","LU","LV","MC","MQ","NL","NO","PL","PT","RE","RO","RU","SE","SI","SJ","SK","SM","VA","YT"]),Ga=new Set(["ar","he","fa","ur","yi","ps","sd","ug","ckb"]),Ha=new Set(["Arab","Hebr","Thaa","Syrc","Mand","Samr","Nkoo"]),vs=Object.freeze([6,7]),Ja=Object.freeze([5,6]),Va=Object.freeze([5]),qa=Object.freeze([4,5]);function Po(e){return e?Ba.has(e)?5:Ua.has(e)?6:Za.has(e)?7:1:1}function Xa(e){return e?e==="IR"?Va:e==="AF"?qa:Ya.has(e)?Ja:vs:vs}function xo(e){return e&&Ka.has(e)?4:1}function Qa(e,t){const n=e?.script??(Te(e?.maximize)?e.maximize().script:void 0);return n&&Ha.has(n)||t&&Ga.has(t)?"rtl":"ltr"}const ht=xe(e=>{if(Yr(e))return e;if(Xt("Locale"))try{const t=Ot(e);return new Intl.Locale(t||"en-US")}catch{return}}),Jr=xe(e=>{const t=ht(e)??ht("en-US"),n=t?.baseName??zo(e)??"en-US",r=t?.language??n.split("-")[0]?.toLowerCase(),s=[];for(const S of n.split("-").slice(1)){if(S.length===1)break;s.push(S)}const o=t?.region??(Te(t?.maximize)?t.maximize().region:void 0)??s.find(S=>Wa.test(S))?.toUpperCase(),i=t?.script??(Te(t?.maximize)?t.maximize().script:void 0),f=rn(t,"getWeekInfo","weekInfo"),a=f?.firstDay??Po(o),h=f?.minimalDays??xo(o),m=Array.isArray(f?.weekend)?Object.freeze([...f.weekend]):Xa(o),p=rn(t,"getHourCycles","hourCycles")??t?.hourCycle??(Xt("DateTimeFormat")?be(n,{hour:"numeric"}).resolvedOptions().hourCycle:void 0),T=Array.isArray(p)&&p.length>0?Object.freeze([...p]):L(p)?Object.freeze([p]):Object.freeze(["h23"]),N=rn(t,"getTextInfo","textInfo"),O=N?.direction==="rtl"||N?.direction==="ltr"?N.direction:Qa(t,r),c=rn(t,"getNumberingSystems","numberingSystems")??t?.numberingSystem??(Xt("NumberFormat")?qn(n).resolvedOptions().numberingSystem:void 0),l=Array.isArray(c)&&c.length>0?Object.freeze([...c]):L(c)?Object.freeze([c]):Object.freeze(["latn"]),u=rn(t,"getTimeZones","timeZones"),y=Array.isArray(u)&&u.length>0?Object.freeze([...u]):Object.freeze([]),b=Object.freeze({firstDay:a,minimalDays:h,weekend:m});return Object.freeze({locale:t,baseName:n,language:r,region:o,script:i,weekInfo:b,firstDay:a,minimalDays:h,weekend:m,hourCycle:T[0],hourCycles:T,direction:O,numberingSystem:l[0],numberingSystems:l,timeZones:y})}),Ns=xe((e,t)=>{const n=Jr(e),r=ht(e)??ht("en-US"),s=r?.toString()??n.baseName,o=t?Pe(t)[0]:void 0;return Object.freeze({info:n,locale:r,relativeTime(i,f,a){return $r(s,a).format(i,f)},list(i,f){return Mr(s,f).format(Array.from(i))},number(i,f){return qn(s,f).format(i)},plural(i,f){return Lo(s,f).select(i)},dtf(i){const f=o&&!i?.timeZone?{...i,timeZone:o}:i;return be(s,f)},rtf(i){return $r(s,i)},lf(i){return Mr(s,i)},nf(i){return qn(s,i)},firstDay:n.firstDay,minimalDays:n.minimalDays,weekend:n.weekend,direction:n.direction,hourCycle:n.hourCycle,hourCycles:n.hourCycles,numberingSystem:n.numberingSystem,numberingSystems:n.numberingSystems,region:n.region,script:n.script,language:n.language,timeZones:n.timeZones,baseName:n.baseName,weekInfo:n.weekInfo})}),ec=xe((e="latn")=>{if(!(!e||e==="latn"||!Xt("NumberFormat")))try{const t=new Intl.NumberFormat(`en-u-nu-${e}`,{useGrouping:!1}),n=Array.from({length:10},(r,s)=>t.format(s));return n[0]==="0"&&n[9]==="9"?void 0:Object.freeze(n)}catch{return}});function tc(e,t="latn"){const n=String(e);if(!t||t==="latn")return n;const r=ec(t);return r?n.replace(/[0-9]/g,s=>r[+s]??s):n}function nc(e,t){return!e||t!=="rtl"?e:`⁧${e}⁩`}const rc=Object.freeze({locale:"en-US",calendar:"iso8601",numberingSystem:"latn",timeZone:"UTC"}),St=xe(()=>Xt("DateTimeFormat")?Object.freeze(be().resolvedOptions()):rc),zo=xe(e=>{const t=Ot(e);if(t){if(Xt("getCanonicalLocales"))try{return Intl.getCanonicalLocales(t)[0]}catch{return}return ht(t)?.baseName??t}}),en=xe(e=>Object.freeze(H(e).map(t=>zo(t)).filter(Boolean)));function Fo(e){const t=en(e);if(t.length!==0)return t.length===1?t[0]:t}function Is(e){const t=en(e);return t.length>0&&t.every(n=>n.split("-")[0]?.toLowerCase()==="en")}function As(e,t="en"){const n=en(e)[0];return n?n.split("-")[0]?.toLowerCase()??t:t}function sc(e,t,n,r="narrow",s="always"){try{return $r(n,{style:r,numeric:s}).format(e,t)}catch{return`${e} ${t}`}}function oc(e,t,n="conjunction",r="long"){try{return Mr(t,{style:r,type:n}).format(e)}catch{return e.join(", ")}}function ic(e,t,n){return ja(t,n).format(e)}function ac(e,t,n){try{return qn(t,n).format(e)}catch{return e.toString()}}function $s(e,t,n){try{return be(t,n).formatToParts(e).find(s=>s.type==="dayPeriod")?.value}catch{return}}const Ht=xe((e=St().timeZone)=>{try{const{jan:t,jul:n}=Aa(e),s=["Australia","Antarctica","Africa/Johannesburg","America/Argentina/Buenos_Aires","America/Sao_Paulo"].some(o=>e.startsWith(o));switch(!0){case n>t:return"north";case n=0?n.add({days:r}):n.subtract({days:-r}),o=s.year;return{weekOfYear:Math.ceil(s.dayOfYear/7),yearOfWeek:o}}function dr(e,t){const n=t?.region,r=t?.firstDay??Po(n),s=t?.minimalDays??xo(n),o=Math.max(1,Math.min(7,Math.floor(r)||1)),i=Math.max(1,Math.min(7,Math.floor(s)||1));if(o===1&&i===4)return Ae(e);const f=(Se(e,"toPlainDate",P)?e.toPlainDate():Temporal.PlainDate.from(e)).withCalendar("iso8601"),a=(f.dayOfWeek-o+7)%7+1,h=8-i-a,m=h===0?f:h>0?f.add({days:h}):f.subtract({days:-h}),g=m.year,p=m.dayOfWeek,T=Temporal.PlainDate.from({year:g,month:1,day:1}),N=1+(p-T.dayOfWeek+7)%7;return{weekOfYear:Math.round((m.dayOfYear-N)/7)+1,yearOfWeek:g}}function oe(...e){for(const t of e){const n=P(t)?t():t;if(n!==void 0)return n}}function xn(e,...t){const n=P(e)?e(...t):e;return Me(n)?"":String(n)}const mr="_magma_geo_",cc=1440*60*1e3,lc=1e3,uc=["latitude","lat","longitude","lng","lon","long","elevation","sphere","country","city","timezone","tz"],Wo=e=>{if(!k(e)||Dr(e))return NaN;if(L(e)){const t=e.trim();return t.length>0?Number(t):NaN}return V(e)?e:NaN},Vr=(e,t=!0)=>{const n=Wo(e);if(!(!V(n)||n<-90||n>90))return t?Math.round(n*1e3)/1e3:n},qr=(e,t=!0)=>{const n=Wo(e);if(!(!V(n)||n<-180||n>180))return t?Math.round(n*1e3)/1e3:n},Cr=(e,t,n=!0)=>{const r=Vr(e,n),s=qr(t,n);return k(r)&&k(s)?{lat:r,lng:s}:void 0},jo=e=>V(e)?Math.round(e*1e3)/1e3:void 0,Zo=(e,t)=>{if(e==="north"||e==="south"||e==="equator")return e;if(V(t))return t>.001?"north":t<-.001?"south":"equator"},Uo=(e,t=!0)=>{if(L(e)&&e.includes(",")){const n=e.split(",").map(r=>r.trim());return n.length>=2?Cr(n[0],n[1],t):void 0}return Array.isArray(e)&&e.length>=2?Cr(e[0],e[1],t):void 0},Rr=(e,t)=>{const n="lat"in e?e.lat:e.latitude,r="lng"in e?e.lng:e.longitude,s=Vr(n),o=qr(r),i=Zo(t?.sphere,s??n),f=jo(t?.elevation);return{latitude:s??n,longitude:o??r,...i?{sphere:i}:{},...Ye(t?.city)?{city:t.city.trim()}:{},...Ye(t?.country)?{country:t.country.trim()}:{},...f!==void 0?{elevation:f}:{},...Ye(t?.timezone)?{timezone:t.timezone.trim()}:{}}},fc=(e,t=uc)=>{const n={};if(Vt(e))for(const r of Object.keys(e))gt(r)&&!t.includes(r)&&(n[r]=e[r]);return n},_r=e=>{const t=Uo(e);if(t)return Rr(t);if(nr(e))return;const n=e.geo??e,r=e.config?.geo??e.config,s=oe(n?.latitude,n?.lat,e.latitude,e.lat,r?.latitude,r?.lat),o=oe(n?.longitude,n?.lng,n?.lon,n?.long,e.longitude,e.lng,e.lon,e.long,r?.longitude,r?.lng,r?.lon,r?.long),i=oe(n?.elevation,e.elevation,r?.elevation),f=oe(n?.sphere,e.sphere,r?.sphere),a=oe(n?.country,e.country,r?.country),h=oe(n?.city,e.city,r?.city),m=oe(n?.timezone,n?.tz,e.timezone,e.tz,r?.timezone,r?.tz),g={},p=Vr(s),T=qr(o);p!==void 0&&(g.latitude=p),T!==void 0&&(g.longitude=T);const N=jo(i);N!==void 0&&(g.elevation=N);const O=Zo(f,g.latitude);O&&(g.sphere=O),L(a)&&(g.country=a),L(h)&&(g.city=h),L(m)&&(g.timezone=m);const d=Vt(e.geo)?e.geo:Vt(e.config?.geo)?e.config.geo:void 0,c=fc(d);return Object.assign(g,c),Object.keys(g).length>0?g:void 0},Bo=e=>{if(Ye(e)){const t=e.trim();return t.startsWith(mr)?t:`${mr}:${t}`}return mr},Ms=e=>{const t=Bo(e);try{const n=mn(t)??(Se(globalThis?.localStorage,"getItem",Te)?globalThis.localStorage.getItem(t):void 0);if(!n)return;const r=L(n)&&(n.startsWith("{")||n.startsWith("["))?JSON.parse(n):n;if(x(r)&&V(r._expires)&&Date.now()>r._expires){dc(e);return}const s=Uo(r);if(s)return Rr(s);if(x(r)){const o=r.geolocation?.coords??r.coords??r,i=o?.latitude??o?.lat,f=o?.longitude??o?.lng??o?.lon??o?.long,a=Cr(i,f);if(a){const h=r.elevation??o.elevation;return Rr(a,{elevation:h,sphere:r.sphere,country:r.country,city:r.city,timezone:r.timezone})}}}catch{}},dc=e=>{const t=Bo(e);Ro(t,void 0)};new Nt(lc,cc);function hr(e){const t=e?.epoch?.ns??e?.epochNanoseconds;if(Qt(t))return t;throw new TypeError("Invalid TemporalPoint: missing epoch.ns or epochNanoseconds")}let mc=(()=>{let e=[$o,Tt("Interval")],t,n=[],r;var s=class{static{r=this}static{const o=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:o},null,n),s=r=t.value,o&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:o}),mt(r,n)}#e;#n;#s;#r;constructor(o,i){const f=o===null?-1/0:hr(o),a=i===null?1/0:hr(i);return a=this.#s&&io.#s}abuts(o){return this.#r===o.#s||this.#s===o.#r}intersection(o){if(!this.overlaps(o))return null;const i=this.#s>o.#s?this.#e:o.#e,f=this.#ro.#r?this.#n:o.#n;return new s(i,f)}};return s=r})();const hc="Enumify",Ee=_e(Object.create(null,{keys:Nn("keys",function(){return ie(this,!0).map(([e])=>e)}),values:Nn("values",function(){return ie(this,!0).map(([e,t])=>t)}),entries:Nn("entries",function(){return ie(this,!0).map(([e,t])=>Object.freeze([e,t]))}),invert:Nn("invert",function(){return Object.fromEntries(Ee.entries.call(this).map(([e,t])=>[t,e]))}),has:Je(function(e){return Ee.keys.call(this).includes(e)}),hasOwn:Je(function(e){return Object.prototype.hasOwnProperty.call(this,e)}),get:Je(function(e){return Ee.has.call(this,e)?this[e]:void 0}),count:Je(function(){return Ee.keys.call(this).length}),includes:Je(function(e){return Ee.values.call(this).includes(e)}),keyOf:Je(function(e){return Ee.invert.call(this)[e]}),extend:Je(function(e,t){return de.call(this,e,t)}),forEach:Je(function(e,t){Ee.entries.call(this).forEach((n,r)=>e.call(t,n,r,this))}),filter:Je(function(e,t){return de(Ee.entries.call(this).reduce((n,r,s)=>e.call(t,r,s,this)?Object.assign(n,{[r[0]]:r[1]}):n,{}))}),map:Je(function(e,t){return de(Ee.entries.call(this).reduce((n,r,s)=>Object.assign(n,{[r[0]]:e.call(t,r,s,this)}),{}))}),[Symbol.iterator]:Je(function*(){for(const e of Ee.entries.call(this))yield e}),[Symbol.toStringTag]:{enumerable:!1,configurable:!1,writable:!1,value:hc}}));function Je(e){return{enumerable:!1,configurable:!1,writable:!1,value:e}}const pc={has(e,t){return Ee.has.call(e,t)},hasOwn(e,t){return Object.prototype.hasOwnProperty.call(e,t)},get(e,t){return Ee.get.call(e,t)},keys(e){return Ee.keys.call(e)},values(e){return Ee.values.call(e)},entries(e){return Ee.entries.call(e)},keyOf(e,t){return Ee.keyOf.call(e,t)},includes(e,t){return Ee.includes.call(e,t)},count(e){return Ee.count.call(e)},invert(e){return Ee.invert.call(e)},extend(e,t,n){return de.call(e,t,n)},[Symbol.hasInstance](e){return e!=null&&(e[Symbol.toStringTag]==="Enumify"||P(e?.has))}},re=Object.freeze(Object.assign(Object.create(null),pc));function de(e,t=!0){const r=$t(this)!=="Module"&&Se(this,"has",P)?this:Ee,s=Mt(e),o=Object.create(r);switch(s.type){case"Enumify":case"Object":Object.defineProperties(o,Object.getOwnPropertyDescriptors(s.value));break;case"Array":s.value.forEach((i,f)=>{if(Le(i))throw new TypeError(`Enumify: numeric keys are not supported ("${i}").`);if(Object.prototype.hasOwnProperty.call(o,i))throw new TypeError(`Enumify: duplicate member key "${i}" found in array definition.`);Object.defineProperty(o,i,{value:f,enumerable:!0,writable:!1,configurable:!1})});break;default:throw new TypeError(`Enumify: invalid argument type: ${s.type}`)}return qe(o,!0,t)}(()=>{let e=[Mo,Tt("Enumify")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),mt(r,n)}constructor(s){return de(s)}},r})();const ke=de(["Off","Error","Warn","Info","Debug","Trace"]),Be={Off:"off",Log:"log",Info:"info",Warn:"warn",Debug:"debug",Trace:"trace",Error:"error"},Yo={[Be.Off]:ke.Off,[Be.Error]:ke.Error,[Be.Warn]:ke.Warn,[Be.Info]:ke.Info,[Be.Log]:ke.Info,[Be.Debug]:ke.Debug,[Be.Trace]:ke.Trace};function Xn(e,t=ke.Info){return V(e)?e>=ke.Off&&e<=ke.Trace?e:t:L(e)?Yo[e.toLowerCase()]??t:t}let Xr=(()=>{let e=[Tt("Logger")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),mt(r,n)}#e;level;constructor(s,o=ke.Info){this.#e=s.startsWith("[")?s:`[${s}]`,this.level=o}#n(s,...o){let i;if(o.length>0&&x(o[0]))try{o[0][le.$LogConfig]&&(i=o.shift())}catch{}let f=this.level;if(i){if(i.silent===!0)return;i.debug!==void 0&&(f=Xn(i.debug,f))}if(f===ke.Off||(Yo[s]??0)>f)return;const h=o.map(m=>{if(Ur(m))return m.message;if(x(m))try{const g=m.constructor?.name??"Object";if(g==="Object"){const p=Object.keys(m);return`{ ${p.slice(0,3).join(", ")}${p.length>3?`, ... (+${p.length-3} more)`:""} }`}return`[${g}]`}catch{return"[Object]"}return String(m)}).filter(m=>!Q(m)).join(" ");Q(h)||console[s](`${this.#e} ${h}`)}log=(...s)=>this.#n(Be.Log,...s);info=(...s)=>this.#n(Be.Info,...s);warn=(...s)=>this.#n(Be.Warn,...s);debug=(...s)=>this.#n(Be.Debug,...s);trace=(...s)=>this.#n(Be.Trace,...s);error=(...s)=>this.#n(Be.Error,...s)},r})();const ae=e=>e?.[G.$Identity]===!0,Oe=Symbol.for("magmacomputing/tempo/termError"),ge={parse:Symbol.for("magmacomputing/tempo/term/parse"),ordinal:Symbol.for("magmacomputing/tempo/term/ordinal"),step:Symbol.for("magmacomputing/tempo/term/step"),diff:Symbol.for("magmacomputing/tempo/term/diff"),bound:Symbol.for("magmacomputing/tempo/term/bound"),format:Symbol.for("magmacomputing/tempo/term/format")},Ft=Symbol.for("$Tempo"),Ko=Symbol.for("magmacomputing/tempo/register"),gc=Symbol.for("magmacomputing/tempo/interpreter"),Wt=Symbol.for("magmacomputing/tempo/guard"),zn=Symbol.for("magmacomputing/tempo/errored"),X=Symbol.for("magmacomputing/tempo/internal"),yc=Symbol.for("magmacomputing/tempo/runtime"),wc=Symbol.for("magmacomputing/tempo/runtime/brand"),bc=Symbol.for("magmacomputing/tempo/descriptor"),Sc=Symbol.for("magmacomputing/tempo/pluginType"),yt=Symbol.for("magmacomputing/tempo/setConfig"),jt=Symbol.for("magmacomputing/tempo/setDiscovery"),Yt=Symbol.for("magmacomputing/tempo/setEvents"),Kt=Symbol.for("magmacomputing/tempo/setPeriods"),Fn=Symbol.for("magmacomputing/tempo/setAliases"),Dt=Symbol.for("magmacomputing/tempo/buildGuard"),Wn=Symbol.for("magmacomputing/tempo/isBase"),Tc={$Tempo:Ft,$Register:Ko,$Interpreter:gc,$guard:Wt,$errored:zn,$Internal:X,$Bridge:yc,$RuntimeBrand:wc,$Descriptor:bc,$setConfig:yt,$setDiscovery:jt,$setEvents:Yt,$setPeriods:Kt,$setAliases:Fn,$buildGuard:Dt,$IsBase:Wn,$PluginType:Sc},G=Object.assign(Object.create(le),Tc),_=Ne()({yy:Symbol("yy"),yw:Symbol("yw"),mm:Symbol("mm"),ww:Symbol("ww"),dd:Symbol("dd"),hh:Symbol("hh"),mi:Symbol("mi"),ss:Symbol("ss"),ff:Symbol("ff"),ord:Symbol("ord"),mer:Symbol("mer"),www:Symbol("www"),afx:Symbol("afx"),sfx:Symbol("sfx"),unt:Symbol("unt"),sep:Symbol("sep"),mod:Symbol("mod"),nbr:Symbol("nbr"),slk:Symbol("slk"),evt:Symbol("evt"),per:Symbol("per"),tz:Symbol("tz"),tzd:Symbol("tzd"),era:Symbol("era"),nth:Symbol("nth"),Rm:Symbol("romanMonth"),Ry:Symbol("romanYear"),dt:Symbol("date"),tm:Symbol("time"),hms:Symbol("hourMinuteSecond"),dmy6:Symbol("dayMonthYearShort"),mdy6:Symbol("monthDayYearShort"),ymd6:Symbol("yearMonthDayShort"),dtm:Symbol("dateTime"),tmd:Symbol("timeDate"),dmy:Symbol("dayMonthYear"),mdy:Symbol("monthDayYear"),ymd:Symbol("yearMonthDay"),off:Symbol("offset"),wkd:Symbol("weekDay"),rel:Symbol("relativeOffset"),brk:Symbol("brackets"),ye:Symbol("yearEra"),ey:Symbol("eraYearLeading"),ordWkd:Symbol("ordinalWeekday"),ordUnt:Symbol("ordinalUnit"),dRy:Symbol("dayRomanMonthYear"),Ryy:Symbol("romanYearOnly")});class pt extends Error{constructor(t){super(`[Tempo] ${t}`),this.name="TempoError",Object.setPrototypeOf(this,pt.prototype)}}class Qr{constructor(){this[G.$RuntimeBrand]=!0,Qe(this),Qe(this.extensions)}extensions=[];modules={};installed=new Set;resetHooks=new Set;state;logger;usrCount=0;#e=new Map;setHook(t,n){const r=this.#e.get(t);return this.#e.set(t,n),r}getHook(t){return this.#e.get(t)}emit(t,n){this.#e.get(t)?.(n)}addTerm(t,n){if(!n||!Ye(n.key))return;const s=(t.pluginsDb?.terms??[]).findIndex(o=>o?.key===n.key);pr(t,"terms",s,n)}addPlugin(t,n){if(!n)return;const r=t.pluginsDb?.plugins??[],s=Ye(n.name)?r.findIndex(o=>o?.name===n.name):-1;s>=0?pr(t,"plugins",s,n):r.includes(n)||pr(t,"plugins",-1,n)}addExtension(t){t&&(Qe(this.extensions),this.extensions.includes(t)||(Object.isExtensible(this.extensions)?this.extensions.push(t):this.extensions=Qe([...this.extensions,t])))}static createScoped(){return new Qr}}function pr(e,t,n,r){e.pluginsDb||(e.pluginsDb={terms:[],plugins:[]}),e.pluginsDb[t]||(e.pluginsDb[t]=[]),Qe(e.pluginsDb),Qe(e.pluginsDb[t]);const s=e.pluginsDb[t];if(Object.isExtensible(s))n>=0?s[n]=r:s.push(r);else{const o=Qe([...s]);n>=0?o[n]=r:o.push(r),Object.isExtensible(e.pluginsDb)?e.pluginsDb[t]=o:e.pluginsDb=Qe({...e.pluginsDb,[t]:o})}}let gr;function se(){const e=globalThis[G.$Bridge];if(e&&e[G.$RuntimeBrand]===!0)return e;if(gr)return gr;const t=new Qr;if(!e)Object.defineProperty(globalThis,G.$Bridge,{value:t,enumerable:!1,configurable:!1,writable:!1});else{const n=Object.getOwnPropertyDescriptor(globalThis,G.$Bridge);n&&n.configurable!==!1?Object.defineProperty(globalThis,G.$Bridge,{value:t,enumerable:!1,configurable:!1,writable:!1}):gr=t}return t}function Oc(e,t={}){const n=L(e)?new Error(e):e;if(t.silent||(t.logger?t.logger.error(n):console.error("[Boundary]",n)),!t.catch)throw n}function Cs(e){return H(e).map(t=>String(t).trim()).filter(Boolean)}const Y=(e,t,n)=>{Object.isExtensible(e)?Object.defineProperty(e,t,{value:n,writable:!0,configurable:!0,enumerable:!0}):je(`[tempo] setProperty: Cannot define property '${String(t)}' on non-extensible object`,{},e)},yr=(e,t)=>{ie(t).forEach(([n,r])=>Y(e,n,r))},bn=new Xr("Tempo"),Ec=new Xr("Tempo:Parse"),Dc=new Xr("Tempo:Engine"),kc=[bn,Ec,Dc];function Rs(e){const t=Xn(e,ke.Info);kc.forEach(n=>n.level=t)}const vc=e=>e.map(t=>Ur(t)?t.message:String(t)).join(" ");function Nc(e,t={},...n){const r=wn(e);if(n.length>0){const s=vc(n);s&&(r.message=`${r.message} ${s}`)}Oc(r,{catch:t?.catch??!1,silent:t?.silent??!1,logger:bn})}const J=Nc,Go=e=>(t,n={},...r)=>{n?.silent||(n[G.$LogConfig]?bn[e](n,t,...r):bn[e](t,...r))},je=Go("warn"),ve=Go("debug"),Ho=e=>Object.getPrototypeOf(Ze(e));function Ic(e,t){const n=Ho(e);if(!x(n))return J(`[Tempo#create] Failed to create shadowed object for '${t}'. Proto(obj) is null or not an object.`,null),{};const r=n[t];return x(r)?{...r}:(J(`[Tempo#create] Failed to create shadowed object for '${t}'. The prototype entry from proto(obj) is missing or not an object (received: ${$t(r)}).`,null),{})}function hn(e){if(De(e))return e;if(U(e)){const t=se(),n=`usr.${++t.usrCount}`;return _[n]=Symbol(n)}if(L(e)&&e.includes(".")){const t=e.split(".").at(-1);return _[e]??=Symbol(t)}return _[e]??G[e]??Symbol.for(`$Tempo.${e}`)}function Jo(e,t,n){const r=Mt(t);switch(r.type){case"Object":ie(r.value).forEach(([s,o])=>e[hn(s)]=n(o));break;case"String":case"RegExp":e[hn()]=n(r.value);break;case"Array":r.value.forEach(s=>Jo(e,s,n));break}}const It=[["year","yy"],["month","mm"],["day","dd"],["hour","hh"],["minute","mi"],["second","ss"],["millisecond","ms"],["microsecond","us"],["nanosecond","ns"]];function es(e){for(const[t]of It)if(e.some(n=>n[t]!==void 0))return t;return"nanosecond"}function ts(e={},t){const n=Dr(e)||k(e.active);Dr(e)&&(e={active:e});const r=new Set,s=[...new Set([...H(t.locales),...H(e.locales)])],o=[...new Set([...H(t.layouts),...H(e.layouts)])],i={...t.timezones};e.timezones&&Object.entries(e.timezones).forEach(([a,h])=>{const m=ht(a)?.baseName??a;i[m]=[...new Set([...H(i[m]||[]),...H(h)])]});const f=s.map(a=>{const h=ht(a),m=h?.baseName??a,g=h?.getTimeZones?.()??[],p=i[m]??[];return g.length===0&&p.length===0&&!r.has(m)&&r.add(m),{locale:m,timeZones:g.length>0?g:p}});return{...e,isExplicit:n||t.isExplicit,locales:s,layouts:o,timezones:i,resolvedLocales:f}}const Ac=/[.*+?^${}()|[\]\\]/g,$c=/\\?\.$/,Mc=/\.$/,$n=e=>e.replace(Ac,"\\$&"),Mn=e=>e.replace($c,"\\.?"),Cc=e=>e.replace(Mc,"").toLowerCase(),_s=e=>e.normalize("NFD").replace(Er,""),Rc=xe(e=>{const t=e.split(","),n={},r={},s=[],o=[],i=[],f=[],a={},h={timeZone:"UTC"},m=(T,N,O,d,c,l)=>{const u=Cc(O),y=_s(u);T[u]={value:d,locale:N},y!==u&&(T[y]={value:d,locale:N}),c.push(Mn($n(O))),y!==u&&c.push(Mn($n(y))),l&&(l.push(Mn($n(O))),y!==u&&l.push(Mn($n(y))))};for(const T of t){const N=be(T,{...h,month:"long"}),O=be(T,{...h,month:"short"});for(let l=0;l<12;l++){const u=new Date(Date.UTC(2024,l,15)),y=N.format(u).toLowerCase(),b=O.format(u).toLowerCase();m(n,T,y,l+1,s,o),b!==y&&m(n,T,b,l+1,o)}const d=be(T,{...h,weekday:"long"}),c=be(T,{...h,weekday:"short"});for(let l=1;l<=7;l++){const u=new Date(Date.UTC(2024,0,l)),y=d.format(u).toLowerCase(),b=c.format(u).toLowerCase();m(r,T,y,l,i,f),b!==y&&m(r,T,b,l,f)}try{const l=new Intl.RelativeTimeFormat(T,{numeric:"auto"}),u=l.format(-1,"day").toLowerCase(),y=l.format(0,"day").toLowerCase(),b=l.format(1,"day").toLowerCase(),S=(E,v)=>{if(!E)return;a[E]=v;const w=_s(E);w!==E&&(a[w]=v)};S(u,"yesterday"),S(y,"today"),S(b,"tomorrow")}catch{}}const g=(T,N)=>N.length-T.length,p=T=>[...new Set(T)];return{snippets:{mon:p(s).sort(g).join("|"),mmm:p([...s,...o]).sort(g).join("|"),wkd:p(i).sort(g).join("|"),www:p([...i,...f]).sort(g).join("|")},events:a,monthMap:n,weekdayMap:r}}),_c=e=>Rc(H(e).join(",")),Lc=/\[[^\]]*\]/g,Pc=/'([^']|'')*'/g,xc=["moment","dayjs"],zc=["ldml","luxon","datefns","cldr"],Fc=/\{[^}]+\}/;function Vo(e,t){if(!L(e)||!e.includes("{"))return!1;const n=L(t)?t.trim().toLowerCase():"";let r=e;return xc.includes(n)?r=r.replace(Lc,""):zc.includes(n)&&(r=r.replace(Pc,"")),Fc.test(r)}const ns="4.7.0";function ut(e){const t=se().modules.Tempo;return Te(e)?e:ae(e)?e.constructor??t:t??e?.constructor}function Zt(e,t,n=!1){const r=ut(e),s=se(),o=t==="term"?"TermsModule":t,i=s.modules[o],f=r[G.$Internal]?.()||s.state,a=o==="TermsModule"&&f&&(k(i)||s.installed.has("TermsModule")||f.pluginsDb.plugins.some(h=>h.name==="TermsModule"))&&f.pluginsDb.terms.length>0;if(!k(i)&&!a){const h=o.endsWith("Module")?o.slice(0,-6):o,m=h==="Terms"?"term":h.toLowerCase(),g=`${o} not loaded. (Did you forget to Tempo.use(${o}) or import '#tempo/${m}' / '@magmacomputing/tempo/${m}'?)`;if(n||J(g,e?.config),n||e?.config?.catch===!0)return!1;throw new pt(g)}return!0}function wt(e,t,n,r=!1,...s){if(ut(e),!Zt(e,t,r))return P(n)?n.apply(e,s):(L(n)||U(n))&&(e?.config?.catch===!0||r)?e:void 0;const i=se().modules[t],f=L(n)?i[n]:i;if(!P(f)){if(P(n))return n.apply(e,s);if(L(s[0])&&Se(i,s[0],P)){const h=s.shift();return i[h].apply(e,s)}const a=`${t} method '${String(n)}' not found`;throw J(a,e?.config),new pt(a)}return f.apply(e,s)}function qo(e){const t={...e,[G.$PluginType]:"module"};return jn(t),Fe(t)}function Wc(e,t){for(const[n,r]of Object.entries(t)){const s=x(r)&&(r[G.$Descriptor]===!0||(k(r.get)||k(r.set)||k(r.value)||k(r.writable)||k(r.configurable)||k(r.enumerable))&&(!k(r.get)||P(r.get))&&(!k(r.set)||P(r.set)));if(ce(e,n)){const o=Object.getOwnPropertyDescriptor(e,n);if(o){if(!s&&o.value===r)continue;if(s){if(Se(r,"get",P)||Se(r,"set",P)){const a=r;if(o.get===a.get&&o.set===a.set)continue}else if(Se(r,"value")){const a=r;if(o.value===a.value&&o.writable===(a.writable??!0)&&o.enumerable===(a.enumerable??!1)&&o.configurable===(a.configurable??!0))continue}}}const i=`Static name collision on "${n}". Property is already defined on the host class.`;J(i,{...e?.config,catch:!0});continue}Object.defineProperty(e,n,{...s?r:{value:r,writable:!0},enumerable:!1,configurable:!0})}}function or(e,t,n){return qo({name:e,version:ns,install(r){const o=se().modules;if(U(o[e]))o[e]=t;else if(o[e]!==t)throw new pt(`Tempo Security: Core Module clash for '${e}'. Logic is already defined.`);if(U(r[G.$Interpreter])&&Object.defineProperty(r,G.$Interpreter,{value:Yi({}),enumerable:!1,configurable:!0,writable:!0}),k(r[G.$Interpreter][e])){if(r[G.$Interpreter][e]!==t)throw new pt(`Tempo Interpreter Module clash: '${e}' logic is already defined.`)}else r[G.$Interpreter][e]=t;k(n)&&Wc(r,n)}})}function jn(e,t){const n=se();t?n.addPlugin(t,e):n.state&&n.addPlugin(n.state,e);const r=t??n.state;return(!r||r===n.state)&&n.addExtension(e),n.emit(G.$Register,e),e}function jc(...e){const t=e.flat().map(n=>x(n)?n:{field:sr(n)});return(n,r)=>{let s=0;return t.forEach(o=>{if(s===0){const i=o.dir==="desc"?-1:1,f=o.field+(k(o.index)?`[${o.index}]`:""),a=ds(n,f,Ss(o.default,0)),h=ds(r,f,Ss(o.default,0));switch(!0){case(V(a)&&V(h)):case(Kn(a)&&Kn(h)):case(x(a)&&x(h)&&V(a.valueOf())&&V(h.valueOf())):s=i*(a-h);break;default:s=i*bs(a)?.localeCompare(bs(h));break}}}),s}}function Xo(e,...t){return e.sort(jc(...t))}const Ls=(e,t)=>{if(Te(Object.groupBy))return Object.groupBy(e,t);const n=Object.create(null);for(let r=0;rr.map(o=>U(s[o])?"":sr(s[o])).join("."))}const En=e=>{const t=new Set;for(const f of H(e.aliases))f!==e.key&&t.add(f);e.scope&&e.scope!==e.key&&t.add(e.scope);const n={...e,...t.size>0?{aliases:Array.from(t)}:{},[G.$PluginType]:"term",version:e.version??ns},r=function(f){return Hn({...n,options:x(f)?{...f}:f,[G.$PluginType]:"term"})},{name:s,...o}=n,i=Object.assign(r,o,{[G.$PluginType]:"term"});return s&&Object.defineProperty(i,"name",{value:s,configurable:!0}),Zn(i),Hn(i)};function ot(e,t){if(!L(e))return;const n=(e.startsWith("#")?e.slice(1):e).toLowerCase(),[r]=n.split("."),s=t?.pluginsDb?t:se().state;if(s?.pluginsDb?.terms)return s.pluginsDb.terms.find(o=>o.key?.toLowerCase()===r||o.scope?.toLowerCase()===r||H(o.aliases).some(i=>i.toLowerCase()===r)?!0:o.groups?(Array.isArray(o.groups)?o.groups:Object.values(o.groups).flat(1/0)).some(f=>f.key?.toLowerCase()===n||f.key?.toLowerCase()===r):!1)}function ir(e,...t){return _e(Zc(e,...t))}function $e(e,t,n=!0,r){const s=Xo([...t],"year","month","day","hour","minute","second","millisecond","microsecond","nanosecond");if(s.length===0)return;let o=ae(r)?r.toDateTime():te(r)?r:ae(e)?e.toDateTime():void 0;te(o)||(o=bt().toZonedDateTimeISO(e.config.timeZone??"UTC"));const i=es(t),f=It.findIndex(([c])=>c===i),a=Math.max(0,f-1),h=It[a][0],m=(c,l)=>{const u={};for(let E=0;Ea)u[v]=E<=2?1:0;else{const D=l[v];u[v]=V(D)?D:E<=2?1:0}}const[y,b]=Pe(l.timeZoneId,l.calendarId),S=Hr({...u,timeZone:y,calendar:b});return new(ut(e))(S,e.config)},g=s.findLastIndex(c=>m(c,o).toDateTime().epochNanoseconds<=o.epochNanoseconds);if(V(n)){const c=Math.floor(s.length/3);if(c===0||!Number.isInteger(n)||n<1||n>c)return;const l=g===-1?c:Math.floor(g/c)*c,u=s[l+(n-1)];if(!u)return;const y=m(u,o);let b;const S=l+(n-1),E=s[S+1];if(E)b=m(E,o);else{const v={...u};V(v.year)&&v.year++,b=m(v,o.add({[`${h}s`]:1}))}return{start:y,end:b,...u}}if(Ye(n)){const c=Math.floor(s.length/3),l=g===-1?c:Math.floor(g/c)*c,u=c>0?s.slice(l,l+c):s,y=n.toLowerCase(),b=s.find(D=>D.year===o.year&&(D.key?.toLowerCase()===y||D.label?.toLowerCase()===y))??u.find(D=>D.key?.toLowerCase()===y||D.label?.toLowerCase()===y)??s.find(D=>D.key?.toLowerCase()===y||D.label?.toLowerCase()===y);if(!b)return;const S=m(b,o),E=s.indexOf(b),v=s[E+1];let w;if(v)w=m(v,o);else{const D={...b};V(D.year)&&D.year++,w=m(D,o.add({[`${h}s`]:1}))}return{start:S,end:w,...b}}const p=s[g===-1?0:g];if(n===!0)return p.key;const T=s.indexOf(p),N=s[T+1],O=m(p,o);let d;if(N)d=m(N,o);else{const c={...p};V(c.year)&&c.year++,d=m(c,o.add({[`${h}s`]:1}))}return{start:O,end:d,...p}}function ct(e,t,n,r){const s=e.plugin??e;let o;try{if(k(n)){const a=new(ut(t))(n,t.config);o=P(s.resolve)?s.resolve.call(a,n):s.define.call(a,!1,n)}else o=P(s.resolve)?s.resolve.call(t):s.define.call(t,!1)}catch(a){const h=wn(a);if(h.message.includes("Class constructor"))return[];throw h}let i=o==null?[]:H(o);const f=s.groupBy??[];return f.length>0&&(i=i.filter(a=>f.every(h=>{if(h==="sphere"){const m=String(a[h]??"").toLowerCase(),g=String(t.sphere??t.config[h]??"").toLowerCase();return m===""||g===""?!1:g.includes(m)}return a[h]===(t[h]??t.config[h])}))),_e(i)}function Uc(e,t,n,r){const s=e.toDateTime();let o=[];if(t.length>0&&"define"in t[0]){const g=n.startsWith("#")?n.slice(1):n,p=t.find(T=>T.key===g||T.scope===g||H(T.aliases).includes(g));if(!p)return;o=ct(p,e,s)}else o=t;const i=$e(e,o,!1,s);if(!i)return;const f=o.findIndex(g=>g.key===i.key&&(U(g.year)||U(i.year)||g.year===i.year)&&(U(g.month)||U(i.month)||g.month===i.month)&&(U(g.day)||U(i.day)||g.day===i.day));if(f===-1)return;const a=f+r,h=o[a];if(!h)return;const m=$e(e,[h],!1);if(m)return m.start}function ar(e,t,{anchor:n,groupBy:r=[],...s}={}){const o=ae(e)?e:k(e)?new(ut(e))(e):e;if(!ae(o))return[];let i=[];if(!k(t))return o.constructor[Oe]?.(o.config,"template"),[];if(!Array.isArray(t)&&r.length>0){const d=r.map(c=>s[c]??n?.[c]??o[c]??o.config[c]??"").join(".");if(i=t[d]??[],i.length===0&&r.includes("sphere")){const c=r.indexOf("sphere"),l=d.split("."),u=(l.length>c?l[c]:"").toLowerCase();let y,b=-1;for(const S of Object.keys(t)){const E=S.split(".");if(E.length!==l.length)continue;const v=(E[c]??"").trim();if(!v||!E.every((A,M)=>M===c||A===l[M]))continue;const D=v.toLowerCase();u.includes(D)&&(v.length>b||v.length===b&&(!y||S.localeCompare(y)<0))&&(y=S,b=v.length)}y&&(i=t[y])}if(i.length===0){const c=r.filter(u=>U(s[u])&&U(n?.[u])&&U(o[u])&&U(o.config[u])),l=c.length>0?`Missing grouping criteria: ${c.join(", ")}`:`No ranges found for group: ${d}`;return o.constructor[Oe]?.(o.config,l),[]}}else i=Array.isArray(t)?t:Object.values(t).flat();if(i.length===0)return[];i=[...i],Xo(i,"year","month","day","hour","minute","second","millisecond","microsecond","nanosecond");const f=es(i);if(!["year","month","day"].includes(f)){const d=[];for(const c of[-1,0,1]){const l=o.add({days:c});i.forEach(u=>{d.push({...u,year:l.yy,month:l.mm,day:l.dd})})}return d}const a=o.yy,h=o.mm,m=o.dd,g=i[0],p=g.month??1,T=g.day??1;let N=a;(h{const u={...l};V(l.year)?u.year=l.year>=-10&&l.year<=10?l.year+c:l.year:u.year=c,O.push(u)})}return O}function Zn(e,t){const n=se();t?n.addTerm(t,e):n.state&&n.addTerm(n.state,e),n.emit(G.$Register,e)}function rs(e,t,n){const r=t.value??(L(t.ord)?parseInt(t.ord,10):void 0);if(!Number.isFinite(r)||r===0)return;const o=(t.term||"").slice(1).split(".")[1];let i;if(k(o)&&o!==""){const g=parseInt(o,10);Number.isInteger(g)&&g>0?i=P(e.define)?e.define.call(n,g,n):void 0:i=P(e.define)?e.define.call(n,o,n):void 0}else i=P(e.define)?e.define.call(n,!1,n):void 0;if(!i||!i.start||!i.end)return;const f=r>0?i.start.add({days:r-1}):i.end.subtract({days:Math.abs(r)}),a=f.toDateTime().epochNanoseconds,h=i.start.toDateTime().epochNanoseconds,m=i.end.toDateTime().epochNanoseconds;return a=m?void 0:f}function cr(e,t,n,r){if(!P(e?.define))return;const s=e.define.call(r,!1,r),o=e.define.call(t,!1,t);if(!s?.start||!s?.end||!o?.start||!o?.end)return;const i=s.start.toDateTime().epochNanoseconds,f=o.start.toDateTime().epochNanoseconds;if(i===f)return 0;if(ff);){a++;const p=e.define.call(h.end,!1,h.end);if(!p?.start||!p?.end||p.start.toDateTime().epochNanoseconds<=h.start.toDateTime().epochNanoseconds)return;h=p}return a>=m?void 0:a}function Dn(e,t,n){if(!P(e?.define))return;const r=e.define.call(n,!1,n);if(!r)return;const s=t.slice(1).split("."),o=s.slice(1);if(o.length===0){const a=s[0]?.toLowerCase()===e.scope?.toLowerCase(),h=x(r)?a?r.label??r.key:r.key??r.label:r;return k(h)?String(h):void 0}let i=r;for(const f of o){if(Me(i)||!gt(f))return;i=i[f]}if(!(Me(i)||P(i)))return ae(i)?Fe(i).format("{yyyy}-{mm}-{dd}"):x(i)?String(i.label??i.key??i.name??i.value??i):String(i)}const Bc=de({Spring:"spring",Summer:"summer",Autumn:"autumn",Winter:"winter"},!1),Ie=Ne()(de({North:"north",South:"south",East:"east",West:"west",Equator:"equator"},!1)),et={NUMBER:{zero:0,one:1,two:2,three:3,four:4,five:5,six:6,seven:7,eight:8,nine:9,ten:10},ORDINAL:{current:0,first:1,second:2,third:3,fourth:4,fifth:5,sixth:6,seventh:7,eighth:8,ninth:9,tenth:10,last:-1},DURATION:{year:31536e3,month:2628e3,week:604800,day:86400,hour:3600,minute:60,second:1,millisecond:.001,microsecond:1e-6,nanosecond:1e-9},TIMEZONE:{utc:"UTC",gmt:"UTC",est:"America/New_York",edt:"America/New_York",cst:"America/Chicago",cdt:"America/Chicago",mst:"America/Denver",mdt:"America/Denver",pst:"America/Los_Angeles",pdt:"America/Los_Angeles",aest:"Australia/Sydney",aedt:"Australia/Sydney",acst:"Australia/Adelaide",acdt:"Australia/Adelaide",awst:"Australia/Perth",nzt:"Pacific/Auckland",nzst:"Pacific/Auckland",nzdt:"Pacific/Auckland",cet:"Europe/Paris",cest:"Europe/Paris",eet:"Europe/Helsinki",eest:"Europe/Helsinki",ist:"Asia/Kolkata",npt:"Asia/Kathmandu",jst:"Asia/Tokyo"},DURATIONS:{years:31536e6,months:2628e6,weeks:6048e5,days:864e5,hours:36e5,minutes:6e4,seconds:1e3,milliseconds:1,microseconds:.001,nanoseconds:1e-6},FORMAT:{display:"{www}, {dd} {mmm} {yyyy}",weekDate:"{www}, {yyyy}-{mmm}-{dd}",weekTime:"{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}",weekStamp:"{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}",dayMonth:"{dd}-{mmm}",dayDate:"{dd}-{mmm}-{yyyy}",dayTime:"{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}",logStamp:"{ymd}T{hms}.{ff}",sortTime:"{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}",yearWeek:"{yw}{wy}",yearMonth:"{yyyy}{mm}",yearMonthDay:"{ymd}",date:"{yyyy}-{mm}-{dd}",time:"{hh}:{mi}:{ss}"},LIMIT:{get maxTempo(){return Temporal.Instant.from("9999-12-31T23:59:59.999999999+00:00").epochNanoseconds},get minTempo(){return Temporal.Instant.from("1000-01-01T00:00+00:00").epochNanoseconds}},MONTH_DAY:{locales:["en-US","en-AS"],layouts:[["dayMonthYearShort","monthDayYearShort"],["dayMonthYear","monthDayYear"]],timezones:{"en-US":["America/Adak","America/Anchorage","America/Boise","America/Chicago","America/Denver","America/Detroit","America/Indiana/Indianapolis","America/Indiana/Knox","America/Indiana/Marengo","America/Indiana/Petersburg","America/Indiana/Tell_City","America/Indiana/Vevay","America/Indiana/Vincennes","America/Indiana/Winamac","America/Indianapolis","America/Juneau","America/Kentucky/Louisville","America/Kentucky/Monticello","America/Los_Angeles","America/Louisville","America/Menominee","America/Metlakatla","America/New_York","America/Nome","America/North_Dakota/Beulah","America/North_Dakota/Center","America/North_Dakota/New_Salem","America/Phoenix","America/Sitka","America/Yakutat","Pacific/Honolulu","US/Aleutian","US/Alaska","US/Arizona","US/Central","US/Eastern","US/Mountain","US/Pacific"],"en-AS":["Pacific/Pago_Pago"]}},LOCALE:{}},ye={NUMBER:at(et.NUMBER),ORDINAL:at(et.ORDINAL),DURATION:at(et.DURATION),TIMEZONE:at(et.TIMEZONE),DURATIONS:at(et.DURATIONS),FORMAT:at(et.FORMAT),LIMIT:at(et.LIMIT),MONTH_DAY:at(et.MONTH_DAY),LOCALE:at(et.LOCALE)},Et=e=>Object.defineProperty(e,G.$Extensible,{value:!0,enumerable:!1,configurable:!1,writable:!1});Et(ye.NUMBER);Et(ye.ORDINAL);Et(ye.FORMAT);Et(ye.TIMEZONE);Et(ye.DURATION);Et(ye.DURATIONS);Et(ye.MONTH_DAY);Et(ye.LOCALE);const Yc=de(["All","Mon","Tue","Wed","Thu","Fri","Sat","Sun"]),Kc=de(["Everyday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"]),Gc=de(["All","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]),Hc=de(["Every","January","February","March","April","May","June","July","August","September","October","November","December"]),ss=Ne()(de(ye.NUMBER,!1)),os=Ne()(de(ye.ORDINAL,!1)),Qn=Ne()(qe(ye.TIMEZONE,!0,!1)),Qo=de(ye.DURATION,!1),ei=de(ye.DURATIONS,!1),is=Ne()(de(ye.FORMAT,!1)),ti=qe(ye.LIMIT,!0,!1),as=qe(ye.MONTH_DAY,!0,!1),cs=qe(ye.LOCALE,!0,!0),ni=["yy","mm","wy","ww","woy","dd","hh","mi","ss","ms","us","ns"],Jc=de({yy:"year",mm:"month",wy:"week",ww:"week",woy:"week",dd:"day",hh:"hour",mi:"minute",ss:"second",ms:"millisecond",us:"microsecond",ns:"nanosecond"},!1),Vc=[...ni,"yw","yow","isoYear","isoyear","isoWeek","isoweek","event","period","clock","time","date","start","mid","end"],qc=de(Vc,!1),Xc=["value","timeZoneId","calendarId","monthCode","offset","timeZone","calendar","year","month","day","hour","minute","second",...ni],Qc=de(Xc,!1),el=["config","parse","value","intl","localeInfo","store","discovery","debug","catch","silent","timeZone","calendar","locale","sphere","geo","latitude","lat","longitude","lng","timeStamp","registry","plugins","extends","cache"],tl=de(el,!1),ri=de({Auto:"auto",Strict:"strict",Defer:"defer"},!1),nl=de({Off:!1,On:!0,Refresh:"refresh"},!1),rl=["monthDay","planner","layoutOrder","preFilter","mode","pivot","snippet","layout","event","period","anchor"],sl=de(rl,!1),ol=["options","extends","plugins","terms","timeZones","monthDay","intl","planner","numbers","ordinals","formats","ignore"],sn=de(ol,!1),Un={NUMBER:ss,ORDINAL:os,DURATION:Qo,TIMEZONE:Qn,DURATIONS:ei,FORMAT:is,LIMIT:ti,MONTH_DAY:as,LOCALE:cs};var R={SEASON:Bc,COMPASS:Ie,WEEKDAY:Yc,WEEKDAYS:Kc,MONTH:Gc,MONTHS:Hc,NUMBER:ss,ORDINAL:os,TIMEZONE:Qn,DURATION:Qo,DURATIONS:ei,FORMAT:is,LIMIT:ti,ELEMENT:Jc,MUTATION:qc,ZONED_DATE_TIME:Qc,CONFIG:tl,MODE:ri,CACHE:nl,PARSE:sl,MONTH_DAY:as,LOCALE:cs,Enum:re};const Ps=/[^\]]+/,q=qe({braces:/{([#]?[\w]+(?:\.[\w]+)*)}/g,formatBraces:/{([#]?[\w]+(?:\.[\w]+)*(?:\:[\w-]+)*)}/g,captures:/\(\?<([a-zA-Z][\w]*)>(.*?)(?][\=]?/,strips:/\(|\)/g,spaces:/\s+/g,zed:/^Z$/,guard:/[\d\s\-\.\:T\/Z\+\-\(\)\,\=\#\<\>]/i,bracket:/\[[^\]]+\]/i,shorthand:/(?:(?:#[\w]+|[\w]+)\.(?:[\+\-\<\>]=?)?(?:[0-9]+)?(?:[\w]*))/,slick:/^(?#[\w]+|[\w]+)\.(?[\+\-\<\>\=]=?)?(?-?[0-9]+)?(?[\w]*)$/,slickValue:/^(?[\+\-\<\>\=]=?)?(?-?[0-9]+)?(?[\w]*)$/,offset:/(?:[+-]\d{2}:\d{2}|[+-]\d{4}|(?<=\s|T|GMT|UTC)\s*[+-]\d{1,2}(?::?\d{2})?)/,escape:e=>String(e).replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),safeAlias:e=>String(e).replace(/[*+{}!^$\\]/g,"\\$&"),numeric:/^\s*[-+]?\d+(\.\d+)?\s*$/,backtrack:/(\(.*\)\+|\(.*\)\*|\(.*\)\{.*\})/},!0,!1),ft=Ne()({[_.yy]:/(?[0-9]{1,4})/,[_.mm]:/(?Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?|1[0-2]|[0 ]?[1-9])/,[_.ww]:/(?0?[1-9]|[1-4][0-9]|5[0-3])/,[_.dd]:/(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3[01]|[12][0-9]|[0 ]?[1-9]){ord}?/,[_.hh]:/(?2[0-4]|[01]?[0-9])/,[_.mi]:/(\:(?[0-5][0-9]))/,[_.ss]:/(\:(?[0-5][0-9]))/,[_.ff]:/(\.(?[0-9]{1,9}))/,[_.ord]:/(?:\s?(?:st|nd|rd|th|e|er|re|ème|eme))?/i,[_.mer]:/(\s*(?am|pm))/,[_.sfx]:/((?:{sep}+|T)({tm}){tz}?)/,[_.wkd]:/(?Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)/,[_.tz]:new RegExp(`\\s*(?:(?:GMT|UTC)(?=\\s*[+-]))?\\s*(?Z|(?:${Object.keys(Qn).map(e=>q.escape(e.toUpperCase())).join("|")})|${q.offset.source})`,"i"),[_.tzd]:new RegExp(`\\s*(?:(?:GMT|UTC)(?=\\s*[+-]))?\\s*(?Z|(?:${Object.keys(Qn).map(e=>q.escape(e.toUpperCase())).join("|")})|${q.offset.source})`,"i"),[_.nbr]:new RegExp(`(?[0-9]+|${Object.keys(ss).map(e=>q.escape(e)).join("|")})`),[_.afx]:new RegExp(`((s)? (?${q.modifier.source}))?{sep}?`),[_.mod]:new RegExp(`((?${q.modifier.source})? *)`),[_.sep]:new RegExp(`(?:${q.separator.source})`),[_.unt]:/(?year|month|week|day|hour|minute|second|millisecond|microsecond|nanosecond)(?:s)?/,[_.brk]:new RegExp(`(\\[(?${Ps.source})\\](?:\\[(?${Ps.source})\\])?)?`),[_.slk]:new RegExp(q.shorthand.source),[_.era]:/(?:\s*(?b\.?c\.?e\.?|c\.?e\.?|b\.?c\.?|a\.?d\.?))/i,[_.nth]:/(?(?:[0-9]{0,2}11th|[0-9]{0,2}12th|[0-9]{0,2}13th|[0-9]{0,2}[04-9]th|[0-9]{0,2}[02-9]1st|1st|[0-9]{0,2}[02-9]2nd|2nd|[0-9]{0,2}[02-9]3rd|3rd|[1-9][0-9]{0,2})|current|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|last)/i,[_.Rm]:/(?XII|XI|X|IX|VIII|VII|VI|V|IV|III|II|I)/i,[_.Ry]:/(?(?=[MDCLXVI])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3}))/i}),Lr={dmy:"{mod}?(?:{dd}(?:{sep}?{mm}|{sep}{Rm})({sep}?{yy})?|{evt}|(?{slk})|{wkd}){afx}?",mdy:"{mod}?(?:{mm}{sep}?{dd}({sep}?{yy})?|{evt}|(?{slk})|{wkd}){afx}?"},Pr=Ne()({[_.hms]:"(?(?:[01][0-9]|2[0-4]))(?[0-5][0-9])(?[0-5][0-9])",[_.dmy6]:"(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])(?0[1-9]|1[0-2])(?[0-9]{2})",[_.mdy6]:"(?0[1-9]|1[0-2])(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])(?[0-9]{2})",[_.ymd6]:"(?[0-9]{2})(?0[1-9]|1[0-2])(?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0[1-9]|[12][0-9]|3[01])",[_.ordWkd]:"{mod}?{nth}?{sep}+{wkd}(?:{sep}+(?:in|of))?{sep}+(?:{mm}(?:{sep}?{yy})?){afx}?{sfx}?",[_.ordUnt]:"{mod}?{nth}?{sep}+{unt}(?:{sep}+(?:in|of))?{sep}+(?:(?[0-9]{4})|{mm}(?:{sep}?(?[0-9]{2,4}))?){afx}?{sfx}?",[_.wkd]:"{mod}?{nbr}?{sep}?{wkd}{afx}?{sfx}?",[_.dt]:Lr.dmy,[_.tm]:"({hh}{mi}?{ss}?{ff}?{mer}?|{per})",[_.dtm]:"({dt})(?:(?:{sep}+|T)({tm}))?{tz}?{brk}?",[_.tmd]:"({tm})(?:(?:{sep}+|T)({dt}))?{tz}?{brk}?",[_.dmy]:"{mod}?({wkd}{sep}+)?{dd}{sep}?{mm}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[_.mdy]:"{mod}?({wkd}{sep}+)?{mm}{sep}?{dd}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[_.ymd]:"{mod}?({wkd}{sep}+)?{yy}{sep}?{mm}({sep}?{dd})?{era}?{afx}?{sfx}?{brk}?",[_.off]:"{mod}?{dd}{afx}?",[_.rel]:"{nbr}{sep}?{unt}{sep}?{afx}",[_.ye]:"{mod}?{yy}{era}",[_.ey]:"{mod}?{era}{sep}?{yy}",[_.dRy]:"{mod}?({wkd}{sep}+)?{dd}{sep}{Rm}({sep}?{yy})?{era}?{afx}?{sfx}?{brk}?",[_.Ryy]:"{mod}?(?:anno\\s+domini\\s+|(?:copyright\\s*)?(?:©\\s*)?)?{Ry}{era}?{afx}?{sfx}?{brk}?"}),il=Ne()({"new.?years? ?eve":"31 Dec",nye:"31 Dec","new.?years?(?: ?day)?":"01 Jan",ny:"01 Jan","christmas ?eve":"24 Dec",christmas:"25 Dec","xmas ?eve":"24 Dec",xmas:"25 Dec",now:function(){return this.toNow()},today:function(){const{yy:e,mm:t,dd:n}=this.toNow();return this.toDateTime().with({year:e,month:t,day:n})},tomorrow:function(){return this.add({days:1})},yesterday:function(){return this.add({days:-1})},fortnight:function(){return this.add({weeks:2})}}),al=Ne()({"mid[ -]?night":"24:00",morning:"8:00","mid[ -]?morning":"10:00","mid[ -]?day":"12:00",noon:"12:00","after[ -]?noon":"3:00pm",evening:"18:00",night:"20:00","half[ -]?hour":function(){return`${this.hh}:30`}}),cl=["at","the","o-clock","o'clock","oclock","on","in","of","by","for","to"],ll=["yy","mm","ww","dd","hh","mi","ss","wkd"],ul=["am","pm","gmt","utc","ago","hence","this","next","prev","last","from","now","today","yesterday","tomorrow","start","mid","end","year","month","week","day","hour","minute","second","millisecond","microsecond","nanosecond","years","months","weeks","days","hours","minutes","seconds","milliseconds","microseconds","nanoseconds","st","nd","rd","th","monday","tuesday","wednesday","thursday","friday","saturday","sunday","mondays","tuesdays","wednesdays","thursdays","fridays","saturdays","sundays","bc","bce","ad","ce","b.c.","b.c.e.","a.d.","c.e.","anno","domini","copyright","©"],fl={relativeTimeFormat:{style:"narrow"},durationFormat:{style:"long"}},fe=_e({debug:ke.Info,catch:!1,silent:!1,mode:ri.Auto,pivot:75,timeStamp:"ms",calendar:"iso8601",timeZone:St().timeZone,locale:St().locale,sphere:void 0,monthDay:as,localeInfo:!1,intl:fl,pluginOptions:{},registry:{formats:is,locales:cs,modifiers:{"+":["next","hence","from now"],"-":["ago","last","prev"],"=":["this"],"<":[],">":[],"<=":[],">=":[]},ordinals:os},planner:{layoutOrder:[_.hms,_.dmy6,_.mdy6,_.ymd6,_.wkd,_.ye,_.ey,_.dt,_.tm,_.dtm,_.tmd,_.dmy,_.mdy,_.ymd,_.off,_.rel],preFilter:!0}});class kt{static aliasPattern=/^(evt|per)(\d+)_(\d+)$/;static _idCounter=0;static _getBaseWord(t){return t.normalize("NFC").toLowerCase().replace(/\[[^\]]*\]\?/g,"").replace(/.\?/g,"").replace(/[^\p{L}\p{M}\p{N}]/gu,"")}#e;#n;#s;#r;#o;#i;#c;#u=0;get depth(){return this.#s}get id(){return this.#c}get parent(){return this.#e}getWords(){return this.#i}constructor(t={}){const n=t.parent;this.#n=t.config,this.#c=kt._idCounter++,n instanceof kt?(this.#e=n,this.#s=n.depth+1,this.#o=Object.create(n.#o),this.#i=Object.create(n.#i)):(n&&J("Parent engine must be an instance of AliasEngine",this.#n),this.#e=null,this.#s=0,this.#o=Object.create(null),this.#i=Object.create(null)),this.#r={evt:0,per:0}}fork(t){return new kt({parent:this,config:t??this.#n??null})}registerAliases(t,n){let r=!1;for(const[s,o]of n){const i=kt._getBaseWord(s),f=this.#i[i],a=f?this.getAlias(f):void 0;if(this.getAliases(t,!0).some(p=>p.target===o&&p.name.normalize("NFC")===s.normalize("NFC")))continue;r=!0;const h=this.#r[t]++,m=`${t}${this.#s}_${h}`,g=!(a?.type==="evt"&&t==="per");i in this.#i&&je(`[AliasEngine] Collision detected for ${t} alias "${s}". ${g?"Overwriting":"Preserving"} existing alias.`,this.#n),g&&(this.#i[i]=m),this.#o[m]={name:s,target:o,type:t,baseWord:i,collision:k(f),depth:this.#s}}return r&&this.#u++,this.getPatterns(t)}getPatterns(t,n=new Set,r){const s=[],o=r??this.#i;for(const[i,f]of ie(this.#o))if(f.type===t&&!n.has(f.baseWord)){if(t==="per"){const g=o[f.baseWord],p=this.getAlias(g);if(p&&p.type==="evt")continue}n.add(f.baseWord);const a=f.name.normalize("NFC"),h=f.name.normalize("NFD"),m=a===h?q.safeAlias(f.name):`${q.safeAlias(a)}|${q.safeAlias(h)}`;s.push(`(?<${i}>${m})`)}if(this.#e){const i=this.#e.getPatterns(t,n,o);i&&s.push(i)}return s.join("|")}getVersion(){return this.#u+(this.#e?.getVersion()??0)}hasAlias(t,n){const r=kt._getBaseWord(t),s=this.#i[r];return s?n?this.#o[s].type===n:!0:!1}resolveAlias(t,n){const r=this.getAlias(t);if(!r)return;let s="";const o=P(r.target);if(P(r.target)){const i=r.target.call(n);s=k(i)?i.toString():""}else s=r.target.toString();return{value:s,key:r.baseWord,type:r.type,source:r.depth===0?"global":"local",isClock:q.clock.test(s),isFunction:o}}getAlias(t){return this.#o[t]??this.#e?.getAlias(t)}getAliases(t,n=!1){const r=[];return ie(this.#o).filter(([s,o])=>!t||o.type===t).forEach(([s,o])=>{r.push(Object.assign({},{key:s},o))}),n&&this.#e&&r.push(...this.#e.getAliases(t,!0)),r}clear(t){this.#r[t]=0;for(const n in this.#o)this.#o[n].type===t&&delete this.#o[n];this.#i=Object.create(this.#e?this.#e.#i:null),this.#r={evt:0,per:0};for(const[n,r]of ie(this.#o))this.#i[r.baseWord]=n,this.#r[r.type]++;this.#u++}}const dl=new RegExp(q.braces,"g"),xs=/\(\?<([a-zA-Z][\w]*)>/g,ml=/[^A-Za-z0-9_$]/g,hl=/^[A-Za-z_$]/;class si{#e;#n=new Rt;#s=new WeakMap;constructor(t){this.#e=t.state}get state(){return this.#e}compileRegExp(t,n){const r=this.#e,s=Gn(t)?t.source:t;let o;if(n?(this.#s.has(n)||this.#s.set(n,new Rt),o=this.#s.get(n)):o=this.#n,o.has(s))return o.get(s);const i=(f,a=0)=>a>10?(je("[PatternCompiler] Recursion limit exceeded in matcher (d > 10) for src:",this.#e.config,f,"depth:",a),f):(f.length>=2&&f.startsWith("/")&&f.endsWith("/")&&(f=f.slice(1,-1)),f.startsWith("^")&&f.endsWith("$")&&(f=f.slice(1,-1)),f.replace(dl,(h,m)=>{const g=hn(m),p=n?.[g]?.source??n?.[m]?.source,T=r.parse.snippet[g]?.source??r.parse.snippet[m]?.source,N=r.parse.layout[g]??r.parse.layout[m],O=Pr[g];let d=p??T??N??O;if(Me(d)&&(m==="tzd"||g===_.tzd)?d=n?.[_.tz]?.source??n?.tz?.source??r.parse.snippet[_.tz]?.source??r.parse.snippet.tz?.source:Me(d)&&(m==="tz"||g===_.tz)&&(d=n?.[_.tzd]?.source??n?.tzd?.source??r.parse.snippet[_.tzd]?.source??r.parse.snippet.tzd?.source),Me(d)&&m.includes(".")){const c=m.split(".")[0],l=hn(c);d=n?.[l]?.source??n?.[c]?.source??r.parse.snippet[l]?.source??r.parse.snippet[c]?.source??r.parse.layout[l]??r.parse.layout[c]??Pr[l]}if(d&&m.includes(".")){let c=m.trim().replace(ml,"_");hl.test(c)||(c=`_${c}`),d.startsWith(`(?<${c}>`)||(d=`(?<${c}>${d})`)}return Me(d)||d===h?h:i(d,a+1)}));try{const f=pl(i(s)),a=new RegExp(`^(${f})$`,"i");return o.set(s,a),a}catch(f){return J(f,this.#e.config,{context:"pattern compile failed",pattern:s}),new RegExp(`^${q.escape(s)}$`,"i")}}setPatterns(){this.clearCache();const t=this.#e;t.parse.snippet={...t.parse.snippet},t.parse.pattern=new Map;const n=t.parse.snippet;if(R?.NUMBER){const s=t.config.registry?.numbers??{},o=Array.from(new Set([...re.keys(R.NUMBER),...Object.keys(s)])).map(h=>q.escape(h)),i=new RegExp(`(?[0-9]+|${o.sort((h,m)=>m.length-h.length).join("|")})`);n[_.nbr]=i;let f=q.modifier.source,a=q.modifier.source;if(t.config.registry?.modifiers){const h=["+","-","<","<=",">",">=","="],m=new Set;if(h.forEach(g=>{H(t.config.registry.modifiers[g]).forEach(p=>m.add(p))}),m.size>0){const g=Array.from(m).map(d=>q.escape(d));g.sort((d,c)=>c.length-d.length);const p=g.join("|");f=`[\\+\\-\\<\\>][\\=]?|${p}`,a=`[\\+\\-\\<\\>][\\=]?|${p}`;const T="[\\+\\-\\<\\>]=?",N="(?:#[\\w]+|[\\w]+)",O="(?:[\\w]*)";n[_.slk]=new RegExp(`(?:${N}\\.(?:${T}|${p})?(?:[0-9]+)?${O})`,"i")}}n[_.mod]=new RegExp(`((?${f})? *)`,"i"),n[_.afx]=new RegExp(`((s)? (?${a}))?${n[_.sep]?.source||""}?`,"i")}if(R?.ORDINAL){const s=t.config.registry?.ordinals??{},i=Array.from(new Set([...re.keys(R.ORDINAL),...Object.keys(s)])).map(f=>q.escape(f)).sort((f,a)=>a.length-f.length).join("|");n[_.nth]=new RegExp(`(?(?:[0-9]{0,2}11th|[0-9]{0,2}12th|[0-9]{0,2}13th|[0-9]{0,2}[04-9]th|[0-9]{0,2}[02-9]1st|1st|[0-9]{0,2}[02-9]2nd|2nd|[0-9]{0,2}[02-9]3rd|3rd|[1-9][0-9]{0,2})|${i})`,"i")}const r=he(t.parse.ignore,!0);if(Q(r))delete t.parse.ignorePattern;else{const s=r.filter(L).map(o=>q.escape(o.toLowerCase())).join("|");t.parse.ignorePattern=new RegExp(`\\b(${s})\\b`,"gi")}ie(t.parse.layout,!0).forEach(([s,o])=>{const i=hn(s),f=this.compileRegExp(o,n);t.parse.pattern.set(i,f)})}clearCache(){this.#n.clear(),this.#s=new WeakMap}}function tt(e){(!ce(e,"patternCompiler")||!e.patternCompiler)&&(e.patternCompiler=new si({state:e})),e.patternCompiler.setPatterns()}function pl(e){if(!e.includes("|")||!e.includes("(?<"))return e;const t=new Set,n=e.matchAll(xs);for(const s of n)t.add(s[1]);const r=new Map;return e.replace(xs,(s,o)=>{const i=r.get(o)??0;if(r.set(o,i+1),i===0)return s;let f=i,a=`${o}_alt${f}`;for(;t.has(a);)f++,a=`${o}_alt${f}`;return t.add(a),`(?<${a}>`})}const zs=(e=0)=>{const t=Math.abs(e),n=t%100;if(n>=11&&n<=13)return`${e}th`;switch(t%10){case 1:return`${e}st`;case 2:return`${e}nd`;case 3:return`${e}rd`;default:return`${e}th`}},gl=[[1e3,"M"],[900,"CM"],[500,"D"],[400,"CD"],[100,"C"],[90,"XC"],[50,"L"],[40,"XL"],[10,"X"],[9,"IX"],[5,"V"],[4,"IV"],[1,"I"]],Fs={I:1,V:5,X:10,L:50,C:100,D:500,M:1e3},yl=/^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/;function wl(e){if(!Number.isInteger(e)||e<1||e>3999)return"";let t=e,n="";for(const[r,s]of gl)for(;t>=r;)n+=s,t-=r;return n}function er(e){const t=e?.trim?.().toUpperCase();if(!t||!yl.test(t))return NaN;let n=0;for(let r=0;rL(o)||De(o)&&k(o.description)).map(o=>(De(o)?o.description:o).toLowerCase()).filter(Boolean),n=new Set(t);let r=0;for(const o of t)o.length>r&&(r=o.length);const s=r;return{test(o){if(!o||!L(o))return!1;let i=0;const f=o.length;let a=!1;for(;i0;T--){const N=p.substring(0,T);if(n.has(N)){i+=T,m=!0,a=!0;break}}if(!m){if(h>="a"&&h<="z"||h>="A"&&h<="Z"){const T=o.substring(i).match(/^[a-zA-Z]+/);if(T){const N=T[0],O=N===N.toUpperCase(),d=i>0?o[i-1]:void 0,c=i+N.length{const i=r.findIndex(([m])=>m.description===s),f=r.findIndex(([m])=>m.description===o);if(i===-1||f===-1)return;const a=if&&!n;(a||h)&&([r[i],r[f]]=[r[f],r[i]])}),r}const Ws=new Map(ie(_,!0).map(([e,t])=>[t,e])),Tl=new Map(ie(_,!0).map(([e,t])=>[e,t.description??""]).filter(([,e])=>e.length>0)),lr=Symbol("default");function Ol(e){return{[lr]:oi(e)}}function El(e,t,n=lr){const r=t[n]??[];if(r.length===0)return e;const s=ie(e),o=new Map;s.forEach(([h,m])=>{o.set(h,[h,m]);const g=h.description??"";g&&o.set(g,[h,m]);const p=Ws.get(h);p&&o.set(p,[h,m])});const i=[],f=new Set;return r.forEach(h=>{const m=De(h),g=m?h.description??"":"",p=m?Ws.get(h):void 0,T=m?void 0:Tl.get(h)??h,N=m?o.get(h)??o.get(g)??(p?o.get(p):void 0):o.get(T)??o.get(h);N&&(f.has(N[0])||(f.add(N[0]),i.push(N)))}),s.forEach(h=>{f.has(h[0])||i.push(h)}),i.length===s.length&&i.some((h,m)=>h[0]!==s[m][0])?Object.fromEntries(i):e}function Dl({layout:e,monthDayLayouts:t,isMonthDay:n,layoutController:r,classification:s}){const o=El(e,r??Ol(e),s??lr),i=ie(o),f=Sl(o,t,n);return f.length!==i.length?o:f.some((h,m)=>h[0]!==i[m][0])?Object.fromEntries(f):o}function oi(e){return ie(e).map(([t])=>t.description??String(t))}const nt=rr();let _t,Lt;function kl(e,t,n){if(Tn(e)||Yn(e))return e;if(t&&n){const r=t.endsWith("/")||!n.extname(t)?t:n.dirname(t);return n.resolve(r,e)}return e}const js=10,ls=25;function xr(e){return e.remaining<=0?(e.warned||(e.warned=!0,console.warn(`[Tempo] Maximum config extends target budget reached (${ls}). Skipping further extends resolution.`)),!0):!1}function Zs(e,t){const n={...e,...t};if((e.registry||t.registry)&&(n.registry={...e.registry,...t.registry,formats:{...e.registry?.formats,...t.registry?.formats},locales:{...e.registry?.locales,...t.registry?.locales},numbers:{...e.registry?.numbers,...t.registry?.numbers},ordinals:{...e.registry?.ordinals,...t.registry?.ordinals}}),(e.planner||t.planner)&&(n.planner={...e.planner,...t.planner}),e.pluginOptions||t.pluginOptions){const r=x(e.pluginOptions)?e.pluginOptions:{},s=x(t.pluginOptions)?t.pluginOptions:{},o=new Set([...Object.keys(r),...Object.keys(s)]),i={};for(const f of o){if(!gt(f))continue;const a=r[f],h=s[f];x(a)||x(h)?i[f]={...x(a)?a:{},...x(h)?h:{}}:i[f]=h!==void 0?h:a}n.pluginOptions=i}return(e.plugins||t.plugins)&&(n.plugins=[...H(e.plugins),...H(t.plugins)]),n}async function ii(e,t,n,r,s,o=new Set,i=0,f={remaining:ls}){if(!e||!e.extends)return e;if(i>=js)return console.warn(`[Tempo] Maximum config extends depth limit reached (${js}). Skipping further extends resolution.`),e;if(xr(f))return e;const h=H(e.extends).filter(L);if(h.length===0)return e;let m={};for(const T of h){if(xr(f))break;if(Tn(T)){console.warn(`[Tempo] Remote HTTP(S) config extends is not supported, skipping: ${T}`);continue}const N=kl(T,t,r);if(o.has(N)){console.warn(`[Tempo] Circular extends detected for config target: ${N}`);continue}const O=r?r.dirname(t):typeof process<"u"?process.cwd():"",d=new Set(o),c=await Nl(N,O,n,r,s,d,i+1,f);c&&(m=Zs(m,c))}const{extends:g,...p}=e;return Zs(m,p)}const vl=new Set([".json",".jsonc",".js",".mjs",".cjs",".ts",".mts"]);function ai(e,t,n,r){if(Yn(e)){try{const s=new URL(e);if(s.hostname&&s.hostname!=="localhost"){console.warn(`[Tempo] Remote file URL with host is not supported: ${e}`);return}}catch{console.warn(`[Tempo] Invalid file URL config target: ${e}`);return}return r?.fileURLToPath?r.fileURLToPath(e):e.replace(bo,"")}return n&&!n.isAbsolute(e)?n.resolve(t,e):e}async function Nl(e,t,n,r,s,o=new Set,i=1,f={remaining:ls}){if(o.has(e))return;if(Tn(e)){console.warn(`[Tempo] Remote HTTP(S) config target is not supported: ${e}`);return}if(xr(f))return;f.remaining--,o.add(e);const a=ai(e,t,r,s);if(a&&n&&n.existsSync(a))try{const h=r?r.extname(a):".json";if(h!==".json"&&h!==".jsonc"){console.warn(`[Tempo] Config extends only supports static .json and .jsonc data files, skipping: ${a}`);return}const m=await n.promises.readFile(a,"utf8"),g=Kr(m);if(g)return ii(g,a,n,r,s,o,i,f)}catch(h){console.warn(`[Tempo] Failed to load config file at ${a}:`,h)}}async function Us(e,t,n,r,s){if(Tn(e)){console.warn(`[Tempo] Remote HTTP(S) config target is not supported: ${e}`);return}const o=ai(e,t,r,s);if(o&&n&&n.existsSync(o))try{const i=r?r.extname(o):".json";if(!vl.has(i)){console.warn(`[Tempo] Unsupported configuration file format, skipping: ${o}`);return}let f;if(i===".json"||i===".jsonc"){const a=await n.promises.readFile(o,"utf8");f=Kr(a)}else if(s){const a=await import(s.pathToFileURL(o).href);f=a.default||a}if(f)return ii(f,o,n,r,s,new Set([e]),0)}catch(i){console.warn(`[Tempo] Failed to load config file at ${o}:`,i)}}function Il(){if(_t!==void 0)return _t;if(nt.type!==pe.NodeJS||!P(nt.global.process?.cwd))return _t=null;try{const e=P(nt.global.require)?nt.global.require:P(nt.global.process?.mainModule?.require)?nt.global.process.mainModule.require:null;if(e){const n=import.meta?.url,r=e("node:module")?.createRequire;return _t=r&&n?r(n):e}let t=null;try{typeof require<"u"&&P(require)?t=require:P(nt.global.process?.mainModule?.require)&&(t=nt.global.process.mainModule.require)}catch{}if(t){const n=import.meta?.url,r=t("node:module")?.createRequire;return _t=r&&n?r(n):t}}catch{}return _t=null}function Al(e){if(Lt!==void 0&&!e)return Lt||void 0;if(nt.type!==pe.NodeJS||!P(nt.global.process?.cwd)){Lt=null;return}try{const t=Il();if(!t){e||(Lt=null);return}const n="node:fs",r="node:path",s=t(n),o=t(r);let i=e?.cwd||process.cwd();e?.configFile;const f=o.parse(i).root,a=["jsonc","json"];for(;i&&i!==f;){for(const g of a){const p=o.join(i,`tempo.config.${g}`);if(s.existsSync(p))try{const T=s.readFileSync(p,"utf8"),N=Kr(T);return e||(Lt=N),N}catch(T){console.warn(`[Tempo] Found config file at ${p} but failed to parse JSONC:`,T)}}const h=o.join(i,"package.json");if(s.existsSync(h))break;const m=o.dirname(i);if(m===i)break;i=m}}catch{}Lt=null}async function $l(e){if(e?.configFile){if(Tn(e.configFile)){console.warn(`[Tempo] Remote HTTP(S) configFile is not supported: ${e.configFile}`);return}if(Yn(e.configFile))try{const n=new URL(e.configFile);if(n.hostname&&n.hostname!=="localhost"){console.warn(`[Tempo] Remote file URL with host is not supported: ${e.configFile}`);return}}catch{console.warn(`[Tempo] Invalid file URL configFile: ${e.configFile}`);return}}const t=rr();if(!(t.type!==pe.NodeJS||!P(t.global.process?.cwd)))try{const n="node:fs",r="node:url",s="node:path",[o,i,f]=await Promise.all([import(n),import(s),import(r)]);let a=e?.cwd||process.cwd();if(e?.configFile){const m=Yn(e.configFile)?e.configFile:i.resolve(a,e.configFile);return await Us(m,a,o,i,f)}const h=i.parse(a).root;for(;a&&a!==h;){const m=i.join(a,"package.json"),g=[".mts",".ts",".mjs",".js",".jsonc",".json"];for(const T of g){const N=i.join(a,`tempo.config${T}`);if(o.existsSync(N))try{const O=await Us(N,a,o,i,f);if(O)return O}catch(O){console.warn(`[Tempo] Found config file at ${N} but failed to load it:`,O);continue}}if(o.existsSync(m))break;const p=i.dirname(a);if(p===a)break;a=p}}catch{}}function Ml(e){const t=_e({get(n){const r=String(n).trim().toLowerCase();return e().weakCache.get(r)},has(n){const r=String(n).trim().toLowerCase();return e().weakCache.has(r)},set(n,r){const s=String(n).trim().toLowerCase();return e().weakCache.set(s,r),this},getOrSet(n,r){const s=String(n).trim().toLowerCase();return e().weakCache.getOrSet(s,r)},delete(n){const r=String(n).trim().toLowerCase();return e().weakCache.delete(r)},clear(){e().weakCache.clear()},get isWeakCache(){return!0}});return _e({get(n){const r=String(n).trim().toLowerCase();return e().cache.get(r)},has(n){const r=String(n).trim().toLowerCase();return e().cache.has(r)},set(n,r){const s=String(n).trim().toLowerCase();return e().cache.set(s,String(r)),this},setStatic(n,r){const s=String(n).trim().toLowerCase();return e().cache.setStatic(s,String(r)),this},delete(n){const r=String(n).trim().toLowerCase();return e().cache.delete(r)},deletePrefix(n){const r=String(n).trim().toLowerCase();return e().cache.deletePrefix(r)},clear(n){e().cache.clear(n)},entries(){return e().cache.entries()},fromEntries(n){for(const[r,s]of n){const o=String(r).trim().toLowerCase();e().cache.set(o,String(s))}return this},toJSON(){return e().cache.toJSON()},weak:t})}let Cl=(()=>{let e=[Tt("ScopedSet")],t,n=[],r;return class{static{r=this}static{const s=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(null,t={value:r},e,{kind:"class",name:r.name,metadata:s},null,n),r=t.value,s&&Object.defineProperty(r,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:s}),mt(r,n)}#e=new Set;#n;constructor(s){this.#n=s}has(s){return this.#e.has(s)||(this.#n?.has(s)??!1)}add(s){return this.#e.add(s),this}delete(s){return this.#e.delete(s)}clear(){this.#e.clear()}get size(){return this.#e.size}forEach(s,o){this.#e.forEach((i,f)=>s.call(o,i,f,this))}values(){return this.#e.values()}keys(){return this.#e.keys()}entries(){return this.#e.entries()}[Symbol.iterator](){return this.#e[Symbol.iterator]()}},r})();const Ut=se(),ci=()=>Ut.resetHooks;function us(e){ci().add(e)}function Rl(){he(ye).forEach(t=>{const n=ye[t],r=et[t],s=Ze(Un[t]);[n,s].filter(o=>o!=null).forEach(o=>{const i=Object.values(G);Reflect.ownKeys(o).filter(f=>!De(f)||!i.includes(f)).forEach(f=>{Object.getOwnPropertyDescriptor(o,f)?.configurable&&delete o[f]})}),Reflect.ownKeys(r).forEach(o=>{const i=Object.getOwnPropertyDescriptor(r,o);i&&[n,s].filter(f=>f!=null).forEach(f=>{Object.isExtensible(f)||ce(f,o)?Object.defineProperty(f,o,i):je(`[tempo] registryReset: Cannot define property '${String(o)}' on non-extensible object (property does not exist)`,{},f)})}),s&&Gt(s),Un[t]&&Gt(Un[t]),Gt(n)}),Ut.state&&(Ut.state.pluginsDb.terms.length=0,Ut.state.pluginsDb.plugins.length=0),Ut.extensions.length=0,Ut.installed.clear(),ci().forEach(t=>t())}function rt(e,t){const n=Un[e],r=ye[e],s=Ze(n)??n;if(!k(s))return;const o=(i,f,a)=>{Object.entries(f).forEach(([h,m])=>{const g=i[h];if(U(g)){Y(i,h,m),k(a)&&(a[h]=m);return}if(Array.isArray(g)&&Array.isArray(m)){const p=g;m.forEach(T=>{p.some(N=>Bt(N,T))||(p.push(T),k(a)&&(Array.isArray(a[h])||Y(a,h,[]),a[h].some(N=>Bt(N,T))||a[h].push(T)))});return}if(Re(g)&&Re(m)){k(a)&&!Re(a[h])&&Y(a,h,{}),o(g,m,k(a)?a[h]:void 0);return}})};o(s,t,r),Gt(s),n&&Gt(n),r&&Gt(r)}function Bs(e,t){if(!!(e?.isBoundedCache||e instanceof Nt))return e;if(e instanceof Map||e&&P(e.entries)){const r=t??new Nt;for(const[s,o]of e.entries())r.setStatic(String(s).trim().toLowerCase(),String(o));return r}else{if(t&&(t.isBoundedCache||t instanceof Nt))return k(e?.maxSize)&&(t.maxSize=e.maxSize),k(e?.ttl)&&(t.ttl=e.ttl),t;{const r=e?.maxSize??1e3,s=e?.ttl??1440*60*1e3;return new Nt(r,s)}}}function zr(e={},t=!0,n,r){const s=se();if(t&&s.state&&!n)return s.state.cache=Bs(e.cache,s.state.cache),s.state;const{timeZone:o,calendar:i}=St(),f=n?{terms:[...n.pluginsDb.terms],plugins:[...n.pluginsDb.plugins]}:{terms:[],plugins:[]};Qe(f),Qe(f.terms),Qe(f.plugins);const a=n?Object.create(n):{config:{},parse:{},pluginsDb:f,userProvidedKeys:new Set};n&&(a.config=Object.create(n.config),n.config.registry&&(a.config.registry=Object.create(n.config.registry)),a.parse=Object.create(n.parse),a.userProvidedKeys=new Set(n.userProvidedKeys),a.installed=new Cl(s.installed),a.pluginsDb=f),a.options=e;const h=n?.cache??s.state?.cache??r;a.cache=Bs(e.cache,h),a.weakCache=n?new Rt:s.state?.weakCache??new Rt;const m={token:_,result:[],snippet:Object.assign({},n?.parse.snippet??ft),layout:Object.assign({},n?.parse.layout??Pr),event:Object.assign({},n?.parse.event??il),period:Object.assign({},n?.parse.period??al),ignore:n?{...n.parse.ignore}:Object.fromEntries(H(cl).map(p=>[p,p])),monthDay:n?{...n.parse.monthDay,locales:[...H(n.parse.monthDay.locales)],layouts:[...H(n.parse.monthDay.layouts)],timezones:{...n.parse.monthDay.timezones},...n.parse.monthDay.resolvedLocales?{resolvedLocales:n.parse.monthDay.resolvedLocales.map(p=>({...p,timeZones:[...p.timeZones]}))}:{}}:ts({},fe.monthDay),planner:n?{...n.parse.planner.layoutOrder?{layoutOrder:[...H(n.parse.planner.layoutOrder)]}:{},...k(n.parse.planner.preFilter)?{preFilter:!!n.parse.planner.preFilter}:{}}:{layoutOrder:[...H(fe.planner?.layoutOrder??fe.layoutOrder)],preFilter:!!(fe.planner?.preFilter??fe.preFilter)},pivot:n?.parse.pivot??fe.pivot,mode:n?.parse.mode??fe.mode,lazy:!1,pattern:new Map(n?.parse.pattern),...n?{...k(n.parse.isAnchored)?{isAnchored:n.parse.isAnchored}:{},...k(n.parse.anchor)?{anchor:n.parse.anchor}:{},...k(n.parse.format)?{format:n.parse.format}:{},...k(n.parse.term)?{term:n.parse.term}:{},...k(n.parse.guard)?{guard:n.parse.guard}:{}}:{}};a.parse=st(m);const g=Object.fromEntries(Object.entries(fe).filter(([p])=>R.CONFIG.has(p)));if(t){st(Object.assign(a.config,g)),a.config.registry&&(a.config.registry={...a.config.registry,modifiers:{...a.config.registry.modifiers??{}}});const{timeZone:p,calendar:T}=St();yr(a.config,{calendar:T,timeZone:p,locale:St().locale??"en-US",discovery:Symbol.keyFor(G.$Tempo),formats:de(ye.FORMAT,!1),sphere:Ht(p),scope:"global",catch:e.catch??!1,silent:e.silent??!1,intl:{}}),Object.defineProperty(a.config,"get",{value:function(N){return this[N]},enumerable:!1,writable:!0,configurable:!0})}else n?(a.config=st(Object.create(n.config)),n.config.registry&&(a.config.registry=Object.create(n.config.registry)),a.parse=Object.create(n.parse),yr(a.config,{scope:"local",catch:e.catch??n.config.catch??!1,silent:e.silent??n.config.silent??!1,intl:Object.create(n.config.intl||{})}),Object.defineProperty(a.config,"get",{value:function(p){return this[p]},enumerable:!1,writable:!0,configurable:!0})):(st(Object.assign(a.config,g)),a.config.registry&&(a.config.registry={...a.config.registry,modifiers:{...a.config.registry.modifiers??{}}}),yr(a.config,{calendar:i,timeZone:o,locale:St().locale??"en-US",discovery:Symbol.keyFor(G.$Tempo),formats:de(ye.FORMAT,!1),sphere:Ht(o),scope:"local",silent:e.silent??!1,intl:{}}),Object.defineProperty(a.config,"get",{value:function(p){return this[p]},enumerable:!1,writable:!0,configurable:!0}),k(e.catch)&&Y(a.config,"catch",e.catch),k(e.silent)&&Y(a.config,"silent",e.silent));return a.OPTION=new Set(Object.keys(g)),a.ZONED_DATE_TIME=new Set(["year","month","day","hour","minute","second","millisecond","microsecond","nanosecond","offset","timeZone","calendar"]),t&&(s.state=a),a}const _l=Object.assign(Object.create(null),{timezone:"timeZone",timestamp:"timeStamp",monthday:"monthDay",errorhandling:"error"});function li(e,t){let n=!1;const r=()=>{(e.parse.monthMap||e.parse.weekdayMap)&&(delete e.parse.monthMap,delete e.parse.weekdayMap,e.parse.snippet[_.mm]=ft[_.mm],e.parse.snippet[_.wkd]=ft[_.wkd],e.parse.localizedEvents&&(e.parse.localizedEvents.forEach(o=>{delete e.parse.event[o]}),delete e.parse.localizedEvents),n=!0)};ie(t).forEach(([o,i])=>{if(U(i))return;const f=L(o)?_l[o.toLowerCase()]??o:o;e.userProvidedKeys.add(f),e.userProvidedKeys.add(o);const a=P(i)&&e.config?.scope!=="local",h=["timeZone","calendar","locale","sphere","pivot"].includes(f)&&!a?oe(i):i,m=Mt(h);switch(f){case"error":{switch(String(m.value).toLowerCase()){case"throw":U(t.catch)&&Y(e.config,"catch",!1),U(t.silent)&&Y(e.config,"silent",!1);break;case"catch":U(t.catch)&&Y(e.config,"catch",!0),U(t.silent)&&Y(e.config,"silent",!1);break;case"silent":U(t.catch)&&Y(e.config,"catch",!0),U(t.silent)&&Y(e.config,"silent",!0);break;case"log":U(t.catch)&&Y(e.config,"catch",!0),U(t.silent)&&Y(e.config,"silent",!1),U(t.debug)&&Y(e.config,"debug",Xn("warn"));break;default:J(`[Tempo#extend] Invalid error option policy: ${String(m.value)}. Expected 'throw', 'catch', 'silent', or 'log'.`,e.config);break}break}case"monthDay":e.parse.monthDay=ts(m.value,e.parse.monthDay);break;case"timeZone":{const g=String(m.value).toLowerCase(),p=t.timeZones?.[g]??e.config.timeZones?.[g]??R.TIMEZONE[g]??_o(String(m.value));Y(e.config,"timeZone",a?i:p),k(t.sphere)||e.userProvidedKeys?.has("sphere")&&k(e.config.sphere)||Y(e.config,"sphere",Ht(p));break}case"calendar":Y(e.config,"calendar",a?i:String(m.value));break;case"locale":{if(a){Y(e.config,"locale",i);break}const g=Fo(m.value);g&&(Y(e.config,"locale",g),Is(g)&&r());break}case"localeInfo":Y(e.config,"localeInfo",!!m.value);break;case"discovery":Y(e.config,"discovery",m.value);break;case"registry":if(x(m.value)){if(e.config.registry={...e.config.registry,modifiers:{...e.config.registry?.modifiers??{}}},m.value.formats){const p=e.config.registry.formats?re.extend(e.config.registry.formats,m.value.formats):m.value.formats;Y(e.config.registry,"formats",p)}if(m.value.locales){const p=e.config.registry.locales?re.extend(e.config.registry.locales,m.value.locales):m.value.locales;Y(e.config.registry,"locales",p)}if(m.value.modifiers){const p=e.config.registry.modifiers??{},T={};for(const[N,O]of Object.entries(p))T[N]=[...H(O)];for(const[N,O]of Object.entries(m.value.modifiers)){const d=T[N]??[];T[N]=[...new Set([...d,...H(O)])]}Y(e.config.registry,"modifiers",T),n=!0}if(m.value.tokens){const p=e.config.registry.tokens??{};Y(e.config.registry,"tokens",{...p,...m.value.tokens})}if(m.value.dialects){const p=e.config.registry.dialects??{};Y(e.config.registry,"dialects",{...p,...m.value.dialects})}if(m.value.numbers){const p=e.config.registry.numbers??{};Y(e.config.registry,"numbers",{...p,...m.value.numbers}),e.config?.scope==="global"&&rt("NUMBER",m.value.numbers),n=!0}if(m.value.ordinals){const p=e.config.registry.ordinals??{};Y(e.config.registry,"ordinals",{...p,...m.value.ordinals}),e.config?.scope==="global"&&rt("ORDINAL",m.value.ordinals),n=!0}const g={snippets:"snippet",layouts:"layout",events:"event",periods:"period",ignores:"ignore"};ie(m.value).forEach(([p,T])=>{if(L(p)&&p in g){const N=g[p];e.userProvidedKeys.add(N),n=!0,ce(e.parse,N)||(e.parse[N]=Ic(e.parse,N));const O=e.parse[N];["snippet","layout"].includes(N)?Jo(O,T,d=>{if(N==="snippet"){const c=Gn(d)?d.source:String(d);return c.length>500?(J("[Tempo#extend] Snippet pattern too long (max 500 chars).",e.config),new RegExp(q.escape(c))):q.backtrack.test(c)?(J("[Tempo#extend] Snippet contains suspicious nested quantifiers.",e.config),new RegExp(q.escape(c))):new RegExp(c)}return Gn(d)?d.source:d}):H(T).forEach(d=>{x(d)?Object.assign(O,d):L(d)&&Object.assign(O,{[d]:d})})}})}break;case"sphere":a?Y(e.config,"sphere",i):k(m.value)&&Y(e.config,"sphere",m.value);break;case"geo":case"latitude":case"lat":case"longitude":case"lng":case"lon":case"long":{const g=_r(t);g&&Y(e.config,"geo",g);break}case"catch":Y(e.config,"catch",!!m.value);break;case"silent":Y(e.config,"silent",!!m.value);break;case"pivot":{const g=parseInt(String(m.value));e.parse.pivot=Number.isFinite(g)&&g>=0&&g<=99?g:fe.pivot;break}case"mode":e.parse.mode=m.value;break;case"intl":e.config.intl=Jn(e.config.intl??{},m.value);break;case"planner":k(m.value.layoutOrder)&&(e.parse.planner.layoutOrder=Cs(m.value.layoutOrder)),k(m.value.preFilter)&&(e.parse.planner.preFilter=!!m.value.preFilter);break;case"layoutOrder":e.parse.planner.layoutOrder=Cs(m.value);break;case"preFilter":e.parse.planner.preFilter=!!m.value;break;case"timeStamp":{const g=(L(m.value)?m.value:m.value?.unit)?.trim()?.toLowerCase();if(U(g)||!["ss","ms","us","ns"].includes(g)){J(`[Tempo#extend] Invalid timeStamp unit: ${String(g??m.value)}. Expected 'ss', 'ms', 'us', or 'ns'.`,e.config);break}Y(e.config,f,g);break}case"debug":Y(e.config,"debug",Xn(m.value));break;case"cache":x(m.value)?(m.value.maxSize!==void 0&&(e.cache.maxSize=m.value.maxSize),m.value.ttl!==void 0&&(e.cache.ttl=m.value.ttl)):Y(e.config,"cache",m.value);break;case"extends":break;case"format":Y(e.config,"format",m.value);break;case"dialect":L(m.value)||P(m.value)?Y(e.config,"dialect",m.value):J(`[Tempo#extend] Invalid dialect option: ${String(m.value)}. Expected a string or function.`,e.config);break;case"pluginOptions":if(x(m.value)){const g=e.config.pluginOptions??{};Y(e.config,"pluginOptions",{...g,...m.value});const p=e.config.plugins??{};Y(e.config,"plugins",{...p,...m.value})}break;case"plugins":if(Re(m.value)&&zt(m.value,"install","key")){const g=e.config.plugins??{};Y(e.config,"plugins",{...g,...m.value});const p=e.config.pluginOptions??{};Y(e.config,"pluginOptions",{...p,...m.value})}break;default:Y(e.config,f,m.value);break}});const s=P(e.config.locale)&&e.config?.scope!=="local"?void 0:oe(e.config.locale);if(s){const o=en(s);if(o.length>0&&!Is(o)){const{snippets:i,monthMap:f,weekdayMap:a,events:h}=_c(o);e.parse.monthMap=f,e.parse.weekdayMap=a,Object.assign(e.parse.snippet,i);const m=ft[_.mm].source.replace(/^\(\?|\)$/g,""),g=ft[_.wkd].source.replace(/^\(\?|\)$/g,"");e.parse.snippet[_.mm]=new RegExp(`(?${m}|${i.mmm})`,"i"),e.parse.snippet[_.wkd]=new RegExp(`(?${g}|${i.www})`,"i"),Q(h)||(Object.assign(e.parse.event,h),e.parse.localizedEvents=Object.keys(h),e.aliasEngine&&(e.config.scope==="local"&&e.aliasEngine.depth===0&&P(e.aliasEngine.fork)&&(e.aliasEngine=e.aliasEngine.fork(e.config)),e.aliasEngine.registerAliases("evt",ie(h)))),n=!0}else o.length>0&&r()}return n}const Ys=rr(),Cn=new WeakMap,Ju=((e,t)=>new it(e,t).ts),Vu=((e,t)=>new it(e,t)),qu=((e,t,n)=>new it(t,n).format(e));let on={},wr=0;const Ke={bootstrap:!0,initialising:!1,extendDepth:0,ready:!1},Ll={construct(e,t){const n=r=>r===null?null:r instanceof it?r:new it(r);return new e(n(t[0]),n(t[1]))}};let it=(()=>{var e,t,n,r,s,o,i,f,a,h;let m=[Mo,$o,Tt("Tempo")],g,p=[],T,N=[],O;var d=T=class{static{T=this}static{Ei(this,"Tempo")}static{const c=typeof Symbol=="function"&&Symbol.metadata?Object.create(null):void 0;dt(this,null,O,{kind:"method",name:"init",static:!0,private:!1,access:{has:l=>"init"in l,get:l=>l.init},metadata:c},null,N),dt(null,g={value:T},m,{kind:"class",name:T.name,metadata:c},null,p),d=T=g.value,c&&Object.defineProperty(T,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:c})}static Interval=(mt(T,N),Fe(new Proxy(mc,Ll)));static get enums(){return R}static get WEEKDAY(){return R.WEEKDAY}static get WEEKDAYS(){return R.WEEKDAYS}static get MONTH(){return R.MONTH}static get MONTHS(){return R.MONTHS}static get DURATION(){return R.DURATION}static get DURATIONS(){return R.DURATIONS}static get SEASON(){return R.SEASON}static get COMPASS(){return R.COMPASS}static get ELEMENT(){return R.ELEMENT}static get FORMAT(){return R.FORMAT}static get NUMBER(){return R.NUMBER}static get ORDINAL(){return R.ORDINAL}static get TIMEZONE(){return R.TIMEZONE}static get MONTH_DAY(){return R.MONTH_DAY}static get MODE(){return R.MODE}static get CACHE(){return R.CACHE}static get LIMIT(){return R.LIMIT}static get isInitializing(){return!Ke.ready}static get isExtending(){return Ke.extendDepth>0}static{e={value:{Tempo:ns}}}static get versions(){return Object.freeze({...ne(d,T,"f",e)})}static get version(){return ne(d,T,"f",e).Tempo}static get cache(){return Ml(()=>this[X]())}static get weakCache(){return this.cache.weak}static{n={value:new Map}}static{r={value:new Set}}static get[(t=function(){return d[X]().pluginsDb.terms},Wt)](){return this[X]()[Wt]??{test:()=>!0}}static[Wn]=!0;static[X](){return Cn.get(this)??on}get[un](){return!0}static[Fn](c,l,u,y){const b=l==="evt"?"event":"period",S=Ho(c),E=S.parse?.[b]??{},v=y??ie(c.parse[b],!0).filter(([I,A])=>!(I in E)||c.parse[b][I]!==E[I]);if(y&&(ce(c.parse,b)||(c.parse[b]={...c.parse[b]}),y.forEach(([I,A])=>{ce(c.parse[b],I)||(c.parse[b][I]=A)})),v.length===0&&!ce(c,"aliasEngine"))return;let w=c.aliasEngine;ce(c,"aliasEngine")||(w=c.aliasEngine=new kt({parent:S.aliasEngine,config:c.config}));const D=w.registerAliases(l,v);if(D){const I=S.parse?.snippet?.[u]?.source;D!==I&&(ce(c.parse,"snippet")||(c.parse.snippet={...c.parse.snippet}),Y(c.parse.snippet,u,new RegExp(D)))}else ce(c.parse.snippet,u)&&(ce(c.parse,"snippet")||(c.parse.snippet={...c.parse.snippet}),delete c.parse.snippet[u])}static[Yt](c,l,u=!0){this[Fn](c,"evt",_.evt,l),u&&tt(c)}static[Kt](c,l,u=!0){this[Fn](c,"per",_.per,l),u&&tt(c)}static{s={value:(c,l)=>{const u=l.sphere??l.geo?.sphere;if(k(u)){const S=oe(u);if(k(S))return S}const y=_r(l)??c.config.geo??Ms();if(k(y?.sphere))return y.sphere;if(V(y?.latitude))return y.latitude>.001?"north":y.latitude<-.001?"south":"equator";const b=l.timeZone??c.config.timeZone;if(k(b)&&String(b).toLowerCase()!=="utc"){const S=Ht(String(b));if(k(S))return S}}}}static{f={value:c=>{const l=Ys.global;return en(c)[0]??l?.navigator?.languages?.[0]??l?.navigator?.language??fe.locale??H(c)[0]}}}static[(o=function(l){const{timeZone:u,locale:y}=l.config,b=l.parse.monthDay,S=R.MONTH_DAY,E=ne(d,T,"f",f).call(d,y);!ht(E)&&!ne(d,T,"f",r).has(E)&&(ne(d,T,"f",r).add(E),je(`Invalid locale encountered in #isMonthDay: ${y}. Falling back to en-US.`,l.config));const v=Jr(E),w=v.baseName,D=v.language??v.locale?.language,I=String(u);return!!(b.resolvedLocales?.find(M=>M.locale===w||D&&M.locale===D)?.timeZones?.includes(I)||S.timezones?.[w]?.includes(I)||D&&S.timezones?.[D]?.includes(I)||(H(S.locales).includes(w)||D&&H(S.locales).includes(D))&&v.timeZones.includes(I))},i=function(l){const{layouts:u}=l.parse.monthDay;if(Q(u))return;const y=l.parse.monthDay.isExplicit?l.parse.monthDay.active:ne(d,T,"m",o).call(d,l);l.parse.monthDay.active=y;const b=y?Lr.mdy:Lr.dmy;l.parse.layout[_.dt]!==b&&(l.parse.layout={...l.parse.layout,[_.dt]:b});const S=(l.parse.planner.layoutOrder?.length??0)>0?{[lr]:[...l.parse.planner.layoutOrder]}:void 0,E=Dl({layout:l.parse.layout,monthDayLayouts:u,isMonthDay:y,...ko({layoutController:S})});E!==l.parse.layout&&(l.parse.layout=E),ve(`Resolved layout order: ${oi(E).join(" -> ")}`,l.config)},yt)](c,...l){const u=Object.assign({},...l),y=u.store,b=y?Object.assign(d.readStore(y),u):u;if(Q(b))return;const S=li(c,b);let E=S;if(S&&c.config.scope==="local"&&this[Dt](c),(k(b.sphere)||k(b.latitude)||k(b.lat)||k(b.geo))&&!P(b.sphere)){const w=ne(d,T,"f",s).call(d,c,b);k(w)&&(c.config.sphere=w)}const v=c.parse.layout;ne(d,T,"m",i).call(d,c),v!==c.parse.layout&&(E=!0),k(c.parse.event)&&(this[Yt](c,void 0,!1),E=!0),k(c.parse.period)&&(this[Kt](c,void 0,!1),E=!0),E&&(tt(c),this[Dt](c))}static[jt](c,l){if(!x(l))return{};st(l);const u=c!==on;let y=oe(l.options,{})??{};if(l.timeZones){const E=Object.fromEntries(ie(l.timeZones,!0).map(([v,w])=>[String(v).toLowerCase(),w]));u?y={...y,timeZones:E}:rt("TIMEZONE",E)}if(l.monthDay){let E=l.monthDay;if(E.timezones){const v=Object.fromEntries(ie(E.timezones,!0).map(([w,D])=>[ht(String(w))?.baseName??String(w),D]));u?E={...E,timezones:v}:rt("MONTH_DAY",{timezones:v})}u||(E.locales&&rt("MONTH_DAY",{locales:H(E.locales)}),E.layouts&&rt("MONTH_DAY",{layouts:H(E.layouts)})),y={...y,monthDay:E}}l.intl&&(y={...y,intl:l.intl}),x(l.planner)&&(y={...y,planner:l.planner}),l.terms&&this.use(H(l.terms));let b=l.registry??{};if(Object.keys(b).length>0&&(y={...y,registry:b},u||(b.formats&&rt("FORMAT",b.formats),b.locales&&rt("LOCALE",b.locales),b.numbers&&rt("NUMBER",b.numbers),b.ordinals&&rt("ORDINAL",b.ordinals))),l.pluginOptions&&Re(l.pluginOptions)&&(y={...y,pluginOptions:Re(y.pluginOptions)?{...y.pluginOptions,...l.pluginOptions}:l.pluginOptions}),l.plugins&&Re(l.plugins)&&zt(l.plugins,"install","key")&&(y={...y,plugins:Re(y.plugins)?{...y.plugins,...l.plugins}:l.plugins,pluginOptions:Re(y.pluginOptions)?{...l.plugins,...y.pluginOptions}:l.plugins}),l.ignore){const E=oe(l.ignore);y={...y,ignore:E}}const S=oe(y,{})??{};return c===on&&(this[Dt](),tt(c)),S}static[Dt](c){const l=c??this[X](),u=[...re.keys(R.NUMBER),...Object.keys(l.config.registry?.numbers??{}),...re.keys(R.ORDINAL),...Object.keys(l.config.registry?.ordinals??{}),...re.keys(R.WEEKDAY),...re.keys(R.WEEKDAYS),...re.keys(R.MONTH),...re.keys(R.MONTHS),...re.keys(R.DURATION),...re.keys(R.DURATIONS),...re.keys(R.TIMEZONE),...l.aliasEngine?.getAliases(void 0,!0).map(b=>b.name)??[],...he(l.parse.ignore),...he(l.parse.snippet),...he(l.parse.layout),_.slk,...ne(d,T,"a",t).map(b=>b.key),...ne(d,T,"a",t).map(b=>b.scope),...ul,...l.config.registry?.modifiers?Object.values(l.config.registry.modifiers).flat():[],...go(l.parse.layout,!0).flatMap(b=>{const S=b instanceof RegExp?b.source:L(b)?b:"";return S?S.replace(/\{[#]?[\w]+(?:\.[\w]+)*(?:\:[a-zA-Z]+)*\}/g," ").replace(/\(\?<[\w]+>/g," ").replace(/\\\\/g,"").replace(/\\\|/g,"\0").replace(/[\(\)\?\:\^\$\d\{\}\[\]]/g," ").replace(/\\(.)/g,"$1").replace(/\u0001/g,"\\").split(/[\s\|]+/).map(E=>E.replace(/\u0000/g,"|")).filter(Boolean).filter(E=>E!=="["&&E!=="]"):[]})],y=bl(u);c?(c.parse.guard=y,c[Wt]=y):(this[X]()[Wt]=y,this[X]().parse.guard=y),!c&&this[X]()===on&&tt(this[X]())}static use(...c){const l=D=>Array.isArray(D)||P(D)||tn(D,"install","define",G.$PluginType),u=D=>Re(D)&&!he(D).some(I=>sn.has(I))&&zt(D,"name","key","install","define",G.$PluginType)&&he(D).length>0&&he(D).every(I=>x(D[I])),y=D=>Array.isArray(D)&&D.length===2&&!Array.isArray(D[0])&&l(D[0])&&x(D[1])&&!u(D[1])&&!l(D[1]),b=D=>x(D)&&!l(D)&&!u(D),S=c.at(-1);let E=c.length>1&&(b(S)||De(S))?c.pop():void 0;const v=D=>{const I=[];for(const A of D)y(A)?I.push(A):Array.isArray(A)?I.push(...v(A)):A!=null&&I.push(A);return I},w=v(c);if(Q(w))return this;Ke.extendDepth++;try{w.forEach(D=>{let I=D,A;if(y(D)&&(I=D[0],A=D[1]),P(I)){if(I[G.$PluginType]||P(I.install)||P(I.define))A={...I.options??{},...A??{}};else if(I.length===0&&A!==void 0){const Z=I(A);tn(Z,"install","define",G.$PluginType)&&(I=Z,A={...Z.options??{},...A??{}})}}else Se(I,"options")&&I.options&&(A={...I.options??{},...A??{}});let M=I?.[G.$PluginType]||I?.type;if(!M&&Se(I,"define",P)&&Se(I,"key")&&(M="term"),!M&&Se(I,"install",P)&&(M="plugin"),!M&&P(I)){const Z=this[X](),$=se(),C=Z.installed??$.installed;if(C.has(I))return;C.add(I),jn(I,Z);const j=I.name,F=Ye(j)?Z.config.pluginOptions?.[j]??Z.config.plugins?.[j]:void 0,z={...x(F)?F:{},...x(E)?E:{},...x(A)?A:{}};Ye(j)&&j!=="anonymous"&&!Q(z)&&(Z.config.pluginOptions={...Z.config.pluginOptions??{},[j]:z});try{I(this,Q(z)?E:z,B=>new this(B))}catch(B){const W=(B?.message??"").toLowerCase();if(W.includes("constructor")||W.includes("class")||W.includes("extensible")||W.includes("read only")||ms(I))je(`Misidentified class or frozen sandbox in plugin registration: ${I.name}`,Z.config,B.stack??B);else throw B}return}if(x(I)||P(I)){const Z=($,C)=>{if(!$){const j=this[X]().config;if(j.catch)return J(C,j),!1;throw new TypeError(C)}return!0};switch(M){case"plugin":case"namespace":case"module":{if(!Z(P(I.install),`[Tempo] Invalid ${M} object: missing 'install()' method.`))return;const $=I.name,C=this[X](),j=se(),F=C.installed??j.installed,z=$?C.config.pluginOptions?.[$]??C.config.plugins?.[$]:void 0,B={...x(z)?z:{},...x(E)?E:{},...x(A)?A:{}};$&&!Q(B)&&(C.config.pluginOptions={...C.config.pluginOptions??{},[$]:B});const W=x(A)&&!Q(A)||x(E)&&!Q(E);if($&&F.has($)){if(W){jn(I,C);const me=B;I.install.call(this,this,me)}else ve(`Plugin already installed by name: ${$}`,C.config);return}if(!$&&F.has(I))return;if($?F.add($):F.add(I),jn(I,C),I.version&&L($)){let me="";M==="plugin"?me="Plugin":M==="namespace"?me="Namespace":M==="module"?me="Module":me="Plugin",ne(d,T,"f",e)[`${$}${$.endsWith(me)?"":me}`]=I.version}const ee=Q(B)?E:B;I.install.call(this,this,ee);break}case"term":{if(!Z(P(I.define),"[Tempo] Invalid term object: missing 'define()' method."))return;const $=I,C=this[X](),j=$.scope||$.key,F=j?C.config.pluginOptions?.[j]??C.config.plugins?.[j]:void 0,z={...x(F)?F:{},...x(E)?E:{},...x(A)?A:{}};j&&!Q(z)&&(C.config.pluginOptions={...C.config.pluginOptions??{},[j]:z});const B=Q(z)?$:{...$,options:z};if(ne(d,T,"f",n).get($.key)===$){Q(z)||(ne(d,T,"f",n).set($.key,B),$.scope&&ne(d,T,"f",n).set($.scope,B),Zn(B,this[X]()));return}if(ne(d,T,"f",n).has($.key)){const W=ne(d,T,"f",n).get($.key),ee=JSON.stringify(W?.ranges)===JSON.stringify($.ranges);if(W?.scope===$.scope&&W?.description===$.description&&ee){ve(`[Tempo#extend] Duplicate term registration ignored for key: "${$.key}"`,C.config),Q(z)||(ne(d,T,"f",n).set($.key,B),$.scope&&ne(d,T,"f",n).set($.scope,B),Zn(B,this[X]()));return}J(`[Tempo#extend] Term collision on key: "${$.key}". Registration aborted.`,C.config);return}if(!($.scope&&ne(d,T,"f",n).get($.scope)===$)){if($.scope&&ne(d,T,"f",n).has($.scope)){const W=ne(d,T,"f",n).get($.scope),ee=JSON.stringify(W?.ranges)===JSON.stringify($.ranges);if(!(W?.key===$.key&&W?.description===$.description&&ee)){J(`[Tempo#extend] Term collision on scope: "${$.scope}". Registration aborted.`,C.config);return}}}ne(d,T,"f",n).set($.key,B),$.scope&&ne(d,T,"f",n).set($.scope,B);for(const W of H($.aliases))ne(d,T,"f",n).has(W)||ne(d,T,"f",n).set(W,B);if($.version){const W=$.scope||$.key;ne(d,T,"f",e)[`${W}Term`]=$.version}if(Zn(B,this[X]()),$.scope&&$.ranges){const W=$.scope==="period"?"per":$.scope==="event"?"evt":void 0;if(W){const ee=[],me=re.keys(d.MONTH);if($.ranges.forEach(we=>{if(we.key){let kn;k(we.hour)?Number.isInteger(we.hour)&&we.hour>=0&&we.hour<=23&&(kn=`${we.hour}:${K(we.minute??0)}`):we.month&&Number.isInteger(we.month)&&we.month>=1&&we.month<=12&&(kn=`${K(we.day??1)} ${me[we.month-1]}`),kn&&ee.push([we.key,kn])}}),ee.length>0){const we=this[X]();W==="per"?this[Kt](we,ee):W==="evt"&&this[Yt](we,ee)}}}break}default:{const $=D,C=this[jt](this[X](),$);if(Q(C)||this[yt](this[X](),C),Re($)&&!he($).some(F=>sn.has(F))&&zt($,"name","key","install")){const F=this[X]();F.config.plugins={...F.config.plugins??{},...$},F.config.pluginOptions={...F.config.pluginOptions??{},...$}}if($.plugins&&(Array.isArray($.plugins)||P($.plugins)||tn($.plugins,"name","key","install"))&&this.use($.plugins),he(D).some(F=>sn.has(F))){const F=(De(E)?E:E?.discovery)??G.$Tempo,z=L(F)?Symbol.for(F):F;globalThis[z]!==D&&(globalThis[z]=D),this[yt](this[X](),{discovery:z})}break}}}})}finally{Ke.extendDepth--}return Ke.extendDepth===0&&(this[Dt](),tt(this[X]())),this}static extend(...c){return this.use(...c)}static create(c,l){let u={},y;P(c)?y=c:x(c)&&(u=c,P(l)&&(y=l));const b=u.discovery,S=x(b)&&!De(b)||U(b)||De(b)&&!Symbol.keyFor(b)?Symbol("TempoSandbox"):L(b)?Symbol.for(b):b;let E=!1;const v=class extends this{static[Symbol.toStringTag]="TempoSandbox";static[Wn]=!1;static get isDisposed(){return E}static[Symbol.dispose](){E||(E=!0,globalThis[S]===w&&delete globalThis[S],Cn.delete(v))}};let w={options:{...u,discovery:S},scope:"sandbox"};x(u.discovery)&&!De(u.discovery)&&(w={...w,...u.discovery}),globalThis[S]=w;const D=zr(u,!1,this[X]());D.config.discovery=S,Cn.set(v,D),tt(D),v[yt](D,{scope:"sandbox",discovery:S,catch:u.catch??!1},v[jt](D,w),{...u,discovery:S});const I=u.plugins??w?.plugins;if(I&&(Array.isArray(I)||P(I)||tn(I,"name","key","install",G.$PluginType,"type"))){let M=I;if(Array.isArray(I)){const Z=C=>Re(C)&&!he(C).some(j=>sn.has(j))&&zt(C,"name","key","install","define",G.$PluginType),$=[];for(const C of I)Z(C)?(D.config.plugins={...D.config.plugins??{},...C},D.config.pluginOptions={...D.config.pluginOptions??{},...C}):$.push(C);M=$}Q(M)||v.use(M)}Object.freeze(v);const A=Fe(v);if(y)try{const M=y(A);return M&&Te(M.then)?Promise.resolve(M).finally(()=>{A[Symbol.dispose]?.()}):(A[Symbol.dispose]?.(),M)}catch(M){throw A[Symbol.dispose]?.(),M}return A}static async ready(){return"none"}static async bootstrap(c){const l=await $l(c);return this.init(l||{}),await this.ready(),this}static init(c={}){if(Ke.initialising)return this;Ke.initialising=!0;try{Rs(c.debug??fe?.debug??ke.Info);const l=se(),u=l.state?.cache,y=!!this[Wn];y&&(l.state=void 0);const b=y?void 0:Object.getPrototypeOf(this)[X](),S=zr(c,y,b,u);S._count=0,y?on=S:Cn.set(this,S);const E=S.parse;E.pattern??=new Map,E.monthDay=ts(fe.monthDay,R.MONTH_DAY),E.planner.layoutOrder=H(fe.planner?.layoutOrder??fe.layoutOrder),E.planner.preFilter=!!(fe.planner?.preFilter??fe.preFilter),E.pivot??=fe.pivot,E.mode??=fe.mode,E.lazy=!1;const v=St(),w=S.config,D=oe(w.timeZone,v.timeZone),I=oe(w.calendar,v.calendar);let A=c.discovery??Symbol.keyFor(Ft);const M=c.store||w.store||Symbol.keyFor(Ft);if(x(A)&&!De(A)){const W=A;A=Symbol.for(`tempo.discovery.${wr++}`),globalThis[A]=W}const Z=L(A)?Symbol.for(A):A,$=globalThis[Z],j=c.locale??w.locale??ne(d,T,"f",f).call(d);ce(w,"get")||Object.defineProperty(w,"get",{value:function(W){return this[W]},enumerable:!1,writable:!0,configurable:!0}),wr=0;for(const W of Object.keys(_))W.startsWith("usr.")&&delete _[W];ne(d,T,"f",n).clear(),Rl(),this[yt](S,{calendar:I,timeZone:D,locale:j,discovery:Z,registry:{formats:w.registry?.formats??w.formats??R.FORMAT,locales:w.registry?.locales??w.locales??qe(ye.LOCALE,!0,!0)},scope:"global",catch:c.catch??w.catch??!1},{store:M,discovery:Z,scope:"global"},this.readStore(M),this[jt](S,S.pluginsDb),this[jt](S,$),c),Rs(S.config.debug??c.debug??fe?.debug??ke.Info);const F=W=>Array.isArray(W)||P(W)||tn(W,"name","key","install",G.$PluginType,"type"),z=W=>Re(W)&&!he(W).some(ee=>sn.has(ee))&&zt(W,"name","key","install","define",G.$PluginType),B=W=>{if(!Array.isArray(W))return W;const ee=[];for(const me of W)z(me)?(S.config.plugins={...S.config.plugins??{},...me},S.config.pluginOptions={...S.config.pluginOptions??{},...me}):ee.push(me);return ee};return $?.plugins&&F($.plugins)&&this.use(B($.plugins)),c.plugins&&F(c.plugins)&&this.use(B(c.plugins)),(Ys.type===pe.Browser||S.config.debug===ke.Debug)&&ve("Tempo:",this.config,S.config),tt(S),Ke.ready=!0,this}catch(l){throw Ke.ready=!1,l}finally{Ke.initialising=!1,Ke.bootstrap=!1}}static setCatchMode(c){return this[yt](this[X](),{catch:c}),this}static unloadModule(c){const l=se();delete l.modules[c],l.installed.delete(c);const u=c.endsWith("Module")?c.slice(0,-6):c;return l.installed.delete(u),this}static hasModule(c){const l=se(),u=c==="term"?"TermsModule":c;return k(l.modules[u])||l.installed.has(u)||this[X]().pluginsDb.plugins.some(y=>y.name===u)}static readStore(c=this[X]().config.store||Symbol.keyFor(Ft)){return mn(c,{})}static writeStore(c,l=this[X]().config.store||Symbol.keyFor(Ft)){return Ro(l,c)}static getSymbol(c){if(U(c)){const l=`usr.${++wr}`;return _[l]=Symbol(l)}if(De(c))return c;if(L(c)&&c.includes(".")){const l=c.split(".").at(-1);return _[c]??=Symbol(l)}return _[c]??Symbol.for(`$Tempo.${c}`)}static regexp(c,l){const u=this[X]();return(!u.patternCompiler||u.patternCompiler.state!==u)&&(u.patternCompiler=new si({state:u})),u.patternCompiler.compileRegExp(c,l)}static compare(c,l){const u=Se(this,un)?this:d,y=u.isTempo(c)?c:new u(c),b=u.isTempo(l)?l:new u(l);return Number(y.nano>b.nano||-(y.nanore.has(R.CONFIG,b))),u=Object.create(l),y=vn(Object.getOwnPropertyDescriptors(c.config),"value","anchor","result");return Object.defineProperties(u,y),Object.defineProperty(u,"toJSON",{value:()=>Object.fromEntries(Object.entries(u)),enumerable:!1,configurable:!0}),Object.defineProperty(u,G.$Inspect,{value:()=>Object.fromEntries(Object.entries(u)),enumerable:!1,configurable:!0}),gs(qe(u))}static get discovery(){const c=this.config.discovery,l=L(c)?Symbol.for(c):c;return ne(d,T,"m",a).call(d,l)}static get options(){const c=this.config.store??Symbol.keyFor(Ft),l=qe(Object.assign({key:c,scope:"storage"},vn(d.readStore(c),"value")));return Object.assign({},this.default,l,this.discovery,this.config)}static from(c,l){return new this(c,l)}static now(c){const l=bt();switch(c){case"ss":return Math.trunc(l.epochMilliseconds/1e3);case"ms":return l.epochMilliseconds;case"us":return Number(l.epochNanoseconds/1000n);default:return l.epochNanoseconds}}static get epoch(){return ne(d,T,"m",h).call(d,bt())}static get instant(){return Temporal.Instant.fromEpochNanoseconds(d.now())}static get terms(){const c=ne(d,T,"a",t).map(({define:l,resolve:u,...y})=>{const b={...y},S=new Set;for(const E of H(b.aliases))E!==b.key&&S.add(E);return b.scope&&b.scope!==b.key&&S.add(b.scope),S.size>0&&(b.aliases=Array.from(S)),b});return Fe(Gi(c,l=>c.find(u=>u.key===l||u.scope===l||H(u.aliases).includes(l))))}static get registry(){return this.config.registry}static get intl(){return Ns(ne(d,T,"f",f).call(d,this.config.locale),this.config.timeZone)}static get properties(){return _e(Do(d).filter(c=>$t(c)!=="Symbol"))}static get default(){return Fe(Object.freeze({...fe,scope:"default",timeZone:fe.timeZone||R.TIMEZONE.utc}))}static get parse(){const c=this[X]().parse,l={layoutOrder:[...c.planner?.layoutOrder??[]],preFilter:c.planner?.preFilter??!1};return _e({...vn({...c},"token","planner"),snippet:{...c.snippet},layout:{...c.layout},event:{...c.event},period:{...c.period},ignore:{...c.ignore},monthDay:vo(c.monthDay),planner:l})}static[(a=function(l){const u=globalThis[l];return qe(vn({...u,scope:"discovery"},"value"))},h=function(l){return _e({ss:Math.trunc(l.epochMilliseconds/1e3),ms:l.epochMilliseconds,us:Number(l.epochNanoseconds/1000n),ns:l.epochNanoseconds})},O=[Oa(va)],Symbol.iterator)](){return d.properties[Symbol.iterator]()}static[Symbol.dispose](){d.init()}static get ignores(){return _e(he(this[X]().parse.ignore,!0))}static[un]=!0;static[Symbol.hasInstance](c){return Se(c,un)}static isTempo(c){return c instanceof d}static{se().setHook(Ko,l=>{d.isExtending||d.use(l)}),us(()=>{const l=d[G.$Internal]();l.aliasEngine&&l.aliasEngine.depth===0&&(l.aliasEngine.clear("evt"),l.aliasEngine.clear("per")),d[Dt](),d[Yt](l,void 0,!1),d[Kt](l,void 0,!1),tt(l)});const c=Al();d.init(c||{}),se().logger=bn}#e;#n={};#s;#r;#o={};#i=!1;#c;#u;#d;#m=0;#h=0;#t={config:Fe({[mo]:!0}),parse:{result:[]}};static[zn]=zn;static[Oe](c,l){const u=ne(d,T,"a",t).length===0?". (No term plugins are registered—did you forget to call Tempo.use(TermsModule)?)":"",y=`Unknown Term identifier: ${l}${u}`;J(y,c)}[X](){const c=Ze(this),l={get zdt(){return c.#r},set zdt(u){c.#r=u},get errored(){return c.#i},set errored(u){c.#i=u},get parseDepth(){return c.#m},set parseDepth(u){c.#m=u},get mutateDepth(){return c.#h},set mutateDepth(u){c.#h=u},get matches(){return c.#d},set matches(u){c.#d=u},get anchor(){return c.#c},set anchor(u){c.#c=u},get options(){return c.#n},get tempo(){return c.#e},get now(){return c.#f},config:c.#t.config,parse:c.#t.parse,userProvidedKeys:c.#t.userProvidedKeys,pluginsDb:c.#t.pluginsDb,aliasEngine:c.#t.aliasEngine,_id:c.#t._id,tempoInstance:c,CONFIG:R.CONFIG,PARSE:R.PARSE,ZONED_DATE_TIME:R.ZONED_DATE_TIME};return Object.setPrototypeOf(l,c.#t)}[Symbol.toPrimitive](c){switch(c){case"string":return this.toString();case"number":return this.epoch.ms;default:return this.nano}}[Symbol.iterator](){return ie(this.fmt,!0)[Symbol.iterator]()}constructor(c,l={}){[this.#e,this.#n]=this.#E(c,l),te(this.#e)&&(this.#r=this.#e),this.#b(this.#n),this.#n=this.#t.options??{},this.#c=oe(this.#n.anchor),!this.#r&&x(this.#e)&&hs(this.#e)&&(this.#r=this.#O(this.#c).add(this.#e));const u=String(this.#e??""),y=this.#t.parse.guard||this.constructor[Wt],{mode:b}=this.#t.parse;b===R.MODE.Defer?this.#t.parse.lazy=!0:b===R.MODE.Strict?this.#t.parse.lazy=!1:L(this.#e)&&Ye(u)&&y.test(ma(u))&&(this.#t.parse.lazy=!0);const S=this.#n[X];return x(S)?(this.#i=S.errored??!1,this.#h=S.mutateDepth??0,this.#m=0,this.#d=S.matches):this.#n[zn]&&(this.#i=!0),this.#t.parse.lazy||this.#a(),Object.freeze(this)}setCatchMode(c){return Y(this.#t.config,"catch",c),this}unloadModule(c){return this.constructor.unloadModule(c),this}hasModule(c){return this.constructor.hasModule(c)}#p(){return(!this.#o.tz||!this.#o.cal)&&([this.#o.tz,this.#o.cal]=Pe(this.toDateTime())),[this.#o.tz,this.#o.cal]}#a(c){if(!this.#r)try{const u=[this.#t.parse.format,this.#t.parse.term,this.#t.parse.result].filter(k);if(this.#r=this.#S(this.#e,this.#c),U(this.#r)){this.#i=!0;const y=`Tempo parse returned undefined for: ${String(this.#e)}`;J(y,this.#t.config),this.#r=this.#f.toZonedDateTimeISO("UTC")}_e(this.#t.config),_e(this.#t.parse,new WeakSet(u))}catch(u){this.#i=!0;const y=`Cannot create Tempo: ${u.message} +${u.stack}`;if(this.#t.config.catch===!0)J(y,this.#t.config),this.#r=this.#f.toZonedDateTimeISO("UTC");else throw J(u,this.#t.config,y),u}const l=te(this.#r)?this.#r:this.#f.toZonedDateTimeISO("UTC");return c?.(l)??l}#l(c,l,u,y=!1){if(k(l)&&k(u)){const b=Object.getOwnPropertyDescriptor(c,l);if(b)return"value"in b?()=>b.value:b.get;let S=!1,E,v=!1;const w=()=>{if(!S){S=!0;try{if(!v){try{E=u.call(this,y)}catch(D){const I=(D?.message??"").toLowerCase();if(I.includes("constructor")||I.includes("class")||D instanceof TypeError||ms(u))je(`Misidentified class in delegator evaluate: ${String(u)}`,this.#t.config,D.stack??D),E=u;else throw D}v=!0,Reflect.isExtensible(c)&&Object.defineProperty(c,l,{value:E,enumerable:!0,configurable:!0,writable:!1})}return E}finally{S=!1}}};return Reflect.isExtensible(c)&&Object.defineProperty(c,l,{get:w,enumerable:!0,configurable:!0}),w}}#g(c){const l=Object.create(null),u=_n(l,y=>{if(y===fo)return this.#y(c,l);if(L(y))switch(c){case"fmt":{if(!Zt(this,"FormatModule"))return;const b=Object.assign({},R.FORMAT,this.#t.config.registry?.formats);return k(b[y])?this.#l(l,y,()=>this.format(y))?.():void 0}case"term":{if(!Zt(this,"TermsModule"))return;const b=ne(d,T,"f",n).get(y);if(b){const S=y===b.key?!!b.scope:y!==b.scope,E=v=>{try{const w=b.define.call(this,v),D=Array.isArray(w)?$e(this,w,v):w;return x(D)?_e(D):D}catch(w){const D=wn(w);if(D.message.includes("Class constructor"))je(`Misidentified class in term definition: ${y}`,this.#t.config,D.stack??D);else throw D}};return this.#l(l,y,E,S)?.()}return}default:return}},!0);return this.#t.parse.lazy||this.#y(c,l),u}#y(c,l){if(Ke.ready)switch(c){case"fmt":{if(!Zt(this,"FormatModule"))return;const u=Object.assign({},R.FORMAT,this.#t.config.registry?.formats);he(u).forEach(y=>{L(y)&&this.#l(l,y,()=>this.format(y))});break}case"term":{if(!Zt(this,"TermsModule"))return;ne(d,T,"a",t).forEach(u=>{const y=(b,S,E)=>{try{const v=u.define?u.define.call(this,b,S,E):void 0,w=Array.isArray(v)?$e(this,v,b,S):v;return x(w)?_e(w):w}catch(v){const w=wn(v);if(w.message.includes("Class constructor"))je(`Misidentified class in term discovery: ${u.key}`,this.#t.config,w.stack??w);else throw w}};this.#l(l,u.key,b=>y(b,this.toDateTime(),u.key),!!u.scope),u.scope&&this.#l(l,u.scope,b=>y(b,this.toDateTime(),u.scope),!1);for(const b of H(u.aliases))b!==u.scope&&this.#l(l,b,S=>y(S,this.toDateTime(),b),!0)});break}}}get yy(){return this.toDateTime().year}get era(){return this.toDateTime().era}get eon(){return this.toDateTime().eraYear}get eraYear(){return this.toDateTime().eraYear}get yw(){return Ae(this.toDateTime()).yearOfWeek}get yow(){return Ae(this.toDateTime()).yearOfWeek}get wy(){return Ae(this.toDateTime()).weekOfYear}get woy(){return Ae(this.toDateTime()).weekOfYear}get ww(){return Ae(this.toDateTime()).weekOfYear}get mm(){return this.toDateTime().month}get dd(){return this.toDateTime().day}get day(){return this.toDateTime().day}get intl(){return Ns(this.locale,this.tz)}get hh(){return this.toDateTime().hour}get mi(){return this.toDateTime().minute}get ss(){return this.toDateTime().second}get ms(){return this.toDateTime().millisecond}get us(){return this.toDateTime().microsecond}get ns(){return this.toDateTime().nanosecond}get ff(){return+`0.${K(this.ms,3)}${K(this.us,3)}${K(this.ns,3)}`}get tz(){return this.#p()[0]}get cal(){return this.#p()[1]}get locale(){return ne(d,T,"f",f).call(d,this.#t.config.locale??this[X]().config.locale)}get geo(){if(ce(this.#o,"geo"))return this.#o.geo;const c=this.#t.config.geo??this[X]().config.geo??Ms();return this.#o.geo=c?Object.freeze({...c}):void 0}get sphere(){if(ce(this.#o,"sphere"))return this.#o.sphere;const c=this[X]().config.timeZone,l=k(this.tz)&&String(this.tz).toLowerCase()!=="utc"&&(U(c)||String(this.tz).toLowerCase()!==String(c).toLowerCase()),u=this.geo?.latitude,y=this.geo?.sphere,b=oe(ce(this.#t.options,"sphere")?this.#t.options?.sphere:void 0,y,V(u)?u>.001?"north":u<-.001?"south":"equator":void 0,l?()=>Ht(String(this.tz)):void 0,ce(this.#t.config,"sphere")?this.#t.config.sphere:void 0,()=>k(this.tz)&&String(this.tz).toLowerCase()!=="utc"?Ht(String(this.tz)):void 0,this[X]().config.sphere,fe.sphere);return this.#o.sphere=b}get ts(){return this.epoch[this.#t.config.timeStamp??"ms"]}get mmm(){return d.MONTH.keyOf(this.toDateTime().month)}get mon(){return d.MONTHS.keyOf(this.toDateTime().month)}get www(){return d.WEEKDAY.keyOf(this.toDateTime().dayOfWeek)}get wkd(){return d.WEEKDAYS.keyOf(this.toDateTime().dayOfWeek)}get dow(){return this.toDateTime().dayOfWeek}get doy(){return this.toDateTime().dayOfYear}get dim(){return this.toDateTime().daysInMonth}get jj(){const c=this.toDateTime().toPlainDate().withCalendar("iso8601");return 2440588+Math.floor(c.since(Temporal.PlainDate.from("1970-01-01"),{largestUnit:"day"}).days)}get nano(){return this.toDateTime().epochNanoseconds}get iso(){return this.toDateTime().toInstant().toString()}get isValid(){return this.#a(c=>!this.#i&&te(c))}get terms(){const c={};return d.terms.forEach(l=>{const u=l.ranges||l.groups||[],y=Array.isArray(u)?u:Object.values(u).flat(1/0),b=[...new Set(y.map(S=>S.key).filter(L))];c[l.key]=b}),_n(c,l=>{if(!L(l))return;const u=d.terms.find(y=>y.key===l||y.scope===l||H(y.aliases).includes(l));return u?c[u.key]:void 0})}get ranges(){const c={};return d.terms.forEach(l=>{const u=this.term[l.key];L(u)&&(c[l.key]=u)}),_n(c,l=>{if(!L(l))return;const u=d.terms.find(y=>y.key===l||y.scope===l||H(y.aliases).includes(l));return u?c[u.key]:void 0})}get config(){const c=this[X]().config,l=st(Object.create(c));return Object.entries(this.#t.config).forEach(([u,y])=>Y(l,u,y)),Object.defineProperty(l,"sphere",{get:()=>this.sphere,enumerable:!0,configurable:!0}),Object.defineProperty(l,"toJSON",{value:()=>Object.fromEntries(Object.entries(l)),enumerable:!1,configurable:!0}),gs(qe(l))}get parse(){const c=Ze(this);c.#a();const l=Object.create(c.#t.parse),u=["anchor","isAnchored","mode","lazy","pivot"];for(const y of u)c.#t.parse[y]!==void 0&&Object.defineProperty(l,y,{value:c.#t.parse[y],enumerable:!0,configurable:!0});return Object.defineProperty(l,"result",{value:c.#d??c.#t.parse.result??[],enumerable:!0,configurable:!0}),l}get zdt(){return this.toDateTime()}get term(){return this.#u??=this.#g("term")}get fmt(){return this.#o.fmt??=this.#g("fmt")}get epoch(){return ne(d,T,"m",h).call(d,this.toDateTime())}get#w(){return this.constructor}get#f(){return this.#s??=bt()}format(c,l){return this.#a(()=>wt(this,"FormatModule",()=>`{${String(c)}}`,!1,c,l))}until(c,l){return this.#a(()=>wt(this,"DurationModule",void 0,!1,"until",c,l)??this)}since(c,l){return this.#a(()=>wt(this,"DurationModule",void 0,!1,"since",c,l)??this)}add(c,l){return this.#a(()=>wt(this,"MutateModule","add",!1,c,l)??this)}plus(c,l){return this.add(c,l)}subtract(c,l){return this.#a(()=>wt(this,"MutateModule","subtract",!1,c,l)??this)}sub(c,l){return this.subtract(c,l)}minus(c,l){return this.subtract(c,l)}set(c,l){return this.#a(()=>wt(this,"MutateModule","set",!1,c,l)??this)}clone(){return this.#w.from(this,this.config)}toDateTime(){return this.#a()}toPlainDate(){return this.toDateTime().toPlainDate()}toPlainTime(){return this.toDateTime().toPlainTime()}toPlainDateTime(){return this.toDateTime().toPlainDateTime()}toInstant(){return this.toDateTime().toInstant()}toNow(){const[c,l]=Pe(this.#t.config.timeZone,this.#t.config.calendar);return bt().toZonedDateTimeISO(c).withCalendar(l)}toDate(){return new Date(this.toDateTime().round({smallestUnit:R.ELEMENT.ms}).epochMilliseconds)}toJSON(){return{...this.#t.config,value:this.toString()}}toString(){return this.isValid&&!this.#i?this.toPlainDateTime().toString({calendarName:"never"}):String(this.#e??"")}#b(c={}){const l=this.constructor[X](),u=c.store,b={...u?this.constructor.readStore(u):{},...c};this.#t=Object.create(l);const S=Ze(this);this.#t.config=st(Object.create(l.config)),l.config.registry&&(this.#t.config.registry=Object.create(l.config.registry)),Object.assign(this.#t.config,{scope:"local"});const E=b.timeZone??b.timezone??b.TimeZone,v=oe(E),w=v??oe(l.config.timeZone);let D;if(k(w)){const me=x(w)?Pe(w)[0]:String(w),we=me.toLowerCase();D=this.constructor.timeZones?.[we]??l.config.timeZones?.[we]??R.TIMEZONE[we]??_o(me),Y(this.#t.config,"timeZone",D)}const I=b.calendar??b.Calendar,A=oe(I),M=A??oe(l.config.calendar);k(M)&&Y(this.#t.config,"calendar",String(M));let Z;const $=b.locale??b.Locale,C=oe($),j=C??oe(l.config.locale);k(j)&&(Z=Fo(j),Z&&Y(this.#t.config,"locale",Z)),this.#t.userProvidedKeys=new Set;let F,z;const B=b.sphere??b.Sphere??b.geo?.sphere;k(B)?(F=oe(B),z=F,Y(this.#t.config,"sphere",z),this.#t.userProvidedKeys.add("sphere")):l.userProvidedKeys?.has("sphere")&&(z=oe(l.config.sphere),Y(this.#t.config,"sphere",z));const W=_r(b);k(W)?(Y(this.#t.config,"geo",W),this.#t.userProvidedKeys.add("geo"),U(z)&&k(W.sphere)&&(z=W.sphere,Y(this.#t.config,"sphere",z))):l.userProvidedKeys?.has("geo")&&Y(this.#t.config,"geo",l.config.geo);const ee={...b,...k(v)?{timeZone:D}:{},...k(A)?{calendar:String(M)}:{},...k(C)?{locale:Z}:{},...k(F)?{sphere:F}:{},...k(W)?{geo:W}:{}};this.#t.options=ee,this.#t.parse=st(Object.create(l.parse)),this.#t.parse.event={...l.parse.event},this.#t.parse.period={...l.parse.period},this.#t.parse.snippet={...l.parse.snippet},this.#t.userProvidedKeys=new Set(l.userProvidedKeys),this.#t.parse.planner={...l.parse.planner.layoutOrder?{layoutOrder:[...H(l.parse.planner.layoutOrder)]}:{},...k(l.parse.planner.preFilter)?{preFilter:!!l.parse.planner.preFilter}:{}},this.#t.parse.monthDay={...l.parse.monthDay,locales:[...H(l.parse.monthDay.locales)],layouts:[...H(l.parse.monthDay.layouts)],timezones:{...l.parse.monthDay.timezones},...l.parse.monthDay.resolvedLocales?{resolvedLocales:l.parse.monthDay.resolvedLocales.map(me=>({...me,timeZones:[...me.timeZones]}))}:{}},Y(this.#t.parse,"result",[...b.result??[]]),Object.defineProperty(this.#t,"tempoInstance",{value:S,writable:!1,configurable:!0,enumerable:!1}),this.constructor[yt](this.#t,ee)}#S(c,l,u){if(!Zt(this,"ParseModule",!0))return this.#T(c,l,u);const y=wt(this,"ParseModule","parse",!1,c,l,u);if(U(y)){const b=`ParseModule error. Could not parse ${String(c)}`;J(b,this.#t.config);return}return ce(y,"value")?y.value??void 0:y}#T(c,l,u){if(te(c))return c;if(ae(c))return c.toDateTime();if(L(c))try{const b=this.#t.config.timeZone??"UTC";return c.includes("[")?Temporal.ZonedDateTime.from(c):Temporal.PlainDateTime.from(c).toZonedDateTime(b)}catch{}if(U(c)||Q(c))return l??bt().toZonedDateTimeISO(this.#t.config.timeZone);J("Tempo ParseModule not loaded. Did you forget to Tempo.use(ParseModule)?",this.#t.config)}#O(c){return ae(c)?c.toDateTime():te(c)?c:k(c)?new this.constructor(c,this.#n).toDateTime():this.#f.toZonedDateTimeISO(this.#t.config.timeZone)}#E(c,l={}){if(ae(c))return[c,Object.assign({result:[...c.parse.result]},l)];let u=c;if(x(c)&&hs(c)){const y={...Fe(c)};let b=!1;for(const[S,E]of Object.entries(y)){const v=re.has(R.ELEMENT,S)?`${R.ELEMENT[S]}s`:void 0;v&&(y[v]=E,delete y[S],b=!0)}b&&(u=y)}return this.#D(u)?[u.value,Object.assign({},u)]:[u,l]}#D(c){if(!Re(c))return!1;const l=he(c);return l.some(u=>re.has(R.MUTATION,u))||l.some(u=>re.has(R.ZONED_DATE_TIME,u)&&!re.has(R.CONFIG,u)||re.has(R.DURATIONS,u))?!1:(l.some(u=>re.has(R.CONFIG,u)||re.has(R.PARSE,u)),!0)}static{mt(T,p)}};return d=T})();const Pl=/^(\d+)/,xl=/b\.?c\.?(?:e\.?)?|bc/i,zl=/^([+-])(\d{1,2})(?::?(\d{2}))?$/;function Jt(e,t){return ie(e).reduce((n,[r,s])=>{if(V(s))return n[r]=s,n;const o=L(s)?s.trim():s;if(o==="")return n;if(Le(o))return n[r]=Number(o),n;if(t?.registry?.numbers){const a=L(s)?s.trim().toLowerCase():"";for(const[h,m]of Object.entries(t.registry.numbers))if(h.toLowerCase()===a&&V(m))return n[r]=m,n}const i=Fl(s,t);if(V(i))return n[r]=i,n;if(re.has(R.NUMBER,i))return n[r]=R.NUMBER[i],n;const f=ur(s);return re.has(R.WEEKDAY,f)?n[r]=R.WEEKDAY[f]:re.has(R.MONTH,f)&&(n[r]=R.MONTH[f]),n},{})}function Fl(e,t){if(!L(e))return e;const n=e.trim().toLowerCase();if(t?.registry?.numbers){for(const[r,s]of Object.entries(t.registry.numbers))if(r.toLowerCase()===n&&V(s))return s}return re.keys(R.NUMBER).find(r=>r.startsWith(n))??e}function ui(e,t){if(Me(e))return 1;if(!L(e)){const o=Number(e);return Number.isFinite(o)?o:1}const n=e.trim().toLowerCase();if(t?.registry?.ordinals){for(const[o,i]of Object.entries(t.registry.ordinals))if(o.toLowerCase()===n&&V(i))return i}const r=R.ORDINAL[n];if(V(r))return r;const s=n.match(Pl);if(s){const o=parseInt(s[1],10);if(Number.isFinite(o))return o}return 1}function fi(e,...t){for(const n of he(e))for(const r of t)(n===r||n.startsWith(`${r}_alt`))&&delete e[n]}function ur(e){if(!L(e))return e;const t=e.trim().toLowerCase().substring(0,3);if(t.length<2)return e;if(t==="all"||t==="eve")return"All";for(const n of[R.WEEKDAY,R.MONTH]){const r=re.keys(n).find(s=>s.toLowerCase().startsWith(t));if(r)return r}return e}function di(e,t={}){if(e&&t?.registry?.modifiers){const n=e.toLowerCase().trim().normalize("NFD").replace(Er,"");for(const[r,s]of Object.entries(t.registry.modifiers))if(H(s).map(o=>o.toLowerCase().trim().normalize("NFD").replace(Er,"")).includes(n))return r}return e}function Sn({mod:e,adjust:t,offset:n,period:r},s={}){switch(t=Math.abs(t),e=di(e,s),e){case void 0:case"=":return 0;case"+":return t;case"-":return-t;case"<":return r<=n?-t:-(t-1);case"<=":case"-=":return r":return r>=n?t:t-1;case">=":case"+=":return r>n?t:t-1;default:return 0}}function Wl(e,t,n,r,s){const o=ui(n,s),i=ur(t),f=re.get(R.WEEKDAY,i)??re.get(R.WEEKDAYS,i);if(!V(f))return;let a=s?.anchor;ae(a)&&(a=a.toDateTime()),qt(a)&&(a=a.toZonedDateTimeISO(s?.timeZone||"UTC")),Br(a)||(a=void 0);let h=e.yy?Number(e.yy):a?.year??r.year,m=e.mm?Jt({month:e.mm},s).month:a?.month??r.month;if(Number.isFinite(h)&&h<100&&(h=Ar(h,s?.pivot,r)),!Number.isFinite(h)||!Number.isFinite(m))return;if(o===0||Math.abs(o)>5){J(`Ordinal weekday out of bounds for month ${m}`,s);return}const g=Temporal.PlainDate.from({year:h,month:m,day:1});let p;if(o<0){const T=g.add({months:1}).subtract({days:1}),N=(T.dayOfWeek-f+7)%7;p=T.subtract({days:N}).subtract({weeks:Math.abs(o)-1})}else{const T=(f-g.dayOfWeek+7)%7;p=g.add({days:T}).add({weeks:o-1})}if(fi(e,"ord","nth","wkd","mm","yy","mod","nbr","sfx","afx","unt","dd"),p.year===h&&p.month===m){const T=r.timeZoneId??r.timeZone??"UTC",N=p.toZonedDateTime(T).withPlainTime(r.toPlainTime());return ve(`[Lexer] Resolved ordinal weekday to ${p.toString()}`,s),N}else return J(`Ordinal weekday out of bounds for month ${m}`,s),r}function jl(e,t,n){const{wkd:r,mod:s,nbr:o="1",sfx:i,afx:f,...a}=e;if(U(r))return t;const h=e.ord??e.nth??(e.mod?.toLowerCase()==="last"&&(e.mm||e.yy)?"last":void 0);if(k(h)){const d=Wl(e,r,h,t,n);if(k(d))return d}const m=["hh","mi","ss","ms","us","ns","ff","mer"];if(!he(a).every(d=>m.includes(d)||d.startsWith("per")))return t;if(!Q(s)&&!Q(i))return je(`Cannot provide both a modifier '${s}' and suffix '${i}'`,n),t;const g=ur(r),{nbr:p=1}=Jt({nbr:o},n),T=re.get(R.WEEKDAY,g)??re.get(R.WEEKDAYS,g);if(!V(T))return J(`Invalid weekday token: "${r}"`,n),t;const N=T-t.dayOfWeek+Sn({mod:s??i??f,adjust:p,offset:T,period:t.dayOfWeek},n)*t.daysInWeek;delete e.wkd,delete e.mod,delete e.nbr,delete e.sfx;const O=t.add({days:N});return ve(`[Lexer] Applied weekday offset of ${N} days`,n),O}function Zl(e,t,n,r,s,o,i){const f=ui(n,s),a=t?Xe(t).toLowerCase():"day";let h=o,m=k(e.mm)?i:void 0,g;if(a==="day"){const p=k(m)?31:366;if(f===0||Math.abs(f)>p){J(`Ordinal date day ${f} out of bounds for ${k(m)?`month ${m}`:`year ${h}`}`,s);return}if(f<0){const T=Math.abs(f)-1;k(m)?g=Temporal.PlainDate.from({year:h,month:m,day:1}).add({months:1}).subtract({days:1}).subtract({days:T}):g=Temporal.PlainDate.from({year:h,month:12,day:31}).subtract({days:T})}else f>0&&(k(m)?g=Temporal.PlainDate.from({year:h,month:m,day:1}).add({days:f-1}):g=Temporal.PlainDate.from({year:h,month:1,day:1}).add({days:f-1}))}if(g){if(k(m)&&g.month!==m){J(`Ordinal date day ${f} out of bounds for month ${m}`,s);return}if(g.year!==h){J(`Ordinal date day ${f} out of bounds for year ${h}`,s);return}fi(e,"ord","nth","unt","mm","yy","yy2","dd","mod","nbr","afx");const p=r.timeZoneId??r.timeZone??"UTC",T=g.toZonedDateTime(p).withPlainTime(r.toPlainTime());return ve(`[Lexer] Resolved ordinal date to ${g.toString()}`,s),T}}function Ul(e,t,n,r){const{mod:s,nbr:o="1",afx:i,unt:f,era:a}=e;if(e.Rm){const I=er(e.Rm);Number.isFinite(I)&&(e.mm=String(I)),delete e.Rm}if(e.Ry){const I=er(e.Ry);Number.isFinite(I)&&(e.yy=String(I),U(e.mm)&&U(e.dd)&&(e.mm="1",e.dd="1")),delete e.Ry}let h=e.yy||void 0;if(U(h)&&k(e.yy2)){let I=parseInt(e.yy2,10);Number.isFinite(I)&&(I<100&&(I=Ar(I,n?.pivot??r,t)),h=String(I))}let{mm:m,dd:g}=e;if(a){if(U(h))return J(`[Tempo#lexer] Cannot resolve era '${a}' without an explicit year`,n),t;xl.test(a)&&(h=String(-(Number(h)-1))),U(m)&&U(g)&&(m="1",g="1"),delete e.era}if(Q(h)&&Q(m)&&Q(g)&&U(f)&&U(e.ord??e.nth))return t;if(!Q(s)&&!Q(i))return je(`A date unit cannot have both a leading modifier ('${s}') and a trailing affix ('${i}') — use one or the other`,n),t;let p=n?.anchor;ae(p)&&(p=p.toDateTime()),qt(p)&&(p=p.toZonedDateTimeISO(n?.timeZone||"UTC")),Br(p)||(p=void 0);const T=k(p?.year)?p.year:t.year,N=k(p?.month)?p.month:t.month,O=k(p?.day)?p.day:t.day;let{year:d,month:c,day:l}=Jt({year:h??T,month:m??N,day:g??O},n);const u=k(e.ord??e.nth),y=e.ord??e.nth??(e.mod?.toLowerCase()==="last"&&(e.mm||e.yy||f)?"last":void 0);if(k(y)){const I=Zl(e,f,y,t,n,d,c);if(k(I))return I;if(u)return t}if(f){const{nbr:I=1}=Jt({nbr:o},n),M=Sn({mod:s??i,adjust:1,offset:0,period:0},n)<0?-1:1,Z=`${Xe(f)}s`;return t=t.add({[Z]:I*M}),delete e.unt,delete e.nbr,delete e.afx,delete e.mod,t}d.toString().match(q.twoDigit)&&(d=Ar(d,n?.pivot??r,t));const{nbr:b=1}=Jt({nbr:o},n),S=+(K(c)+"."+K(l)),E=+(K(t.month)+"."+K(t.day+1)),v=t.timeZoneId??t.timeZone,w=Sn({mod:s??i,adjust:b,offset:S,period:E},n);if(d+=w,Object.assign(e,{yy:d,mm:c,dd:l}),delete e.mod,delete e.nbr,delete e.afx,!Number.isFinite(d)||!Number.isFinite(c)||!Number.isFinite(l))return J(`Invalid Date components: year=${d}, month=${c}, day=${l}`,n),t;const D=Temporal.PlainDate.from({year:d,month:c,day:l},{overflow:"constrain"}).toZonedDateTime(v).withPlainTime(t.toPlainTime());return ve(`[Lexer] Resolved Date components to ${d}-${c}-${l}`,n),D}function Bl(e={},t,n){if(U(e.hh))return t;let{hh:r=0,mi:s=0,ss:o=0,ms:i=0,us:f=0,ns:a=0}=Jt(e,n);if(r>=24&&(t=t.add({days:Math.trunc(r/24)}),r%=24),k(e.ff)){const m=xa(e.ff);i=m.millisecond,f=m.microsecond,a=m.nanosecond}e.mer?.toLowerCase()==="pm"&&r<12&&r+s+o+i+f+a>0&&(r+=12),e.mer?.toLowerCase()==="am"&&r>=12&&(r-=12);const h=t.withPlainTime({hour:r,minute:s,second:o,millisecond:i,microsecond:f,nanosecond:a});return ve(`[Lexer] Resolved Time components to ${K(r)}:${K(s)}:${K(o)}`,void 0),h}function Yl(e,t,n){if(!Br(t))return t;const r=(e.tz??e.tzd)?.replace(q.zed,"UTC");let o=e.brk?.replace(q.zed,"UTC")||r;if(o){const a=o.match(zl);a&&(o=`${a[1]}${a[2].padStart(2,"0")}:${a[3]??"00"}`)}let i=e.cal;o?.startsWith("u-ca=")&&(i=o,o=r);const f=t;if(o&&o!==f.timeZoneId){const a=R.TIMEZONE[o.toLowerCase()]??o;try{t=f.toPlainDateTime().toZonedDateTime(a),n&&(n.timeZone=a)}catch{je(`Unrecognized or invalid timezone identifier: '${o}'`,n)}}if(i&&i!==t.calendarId){const a=i.startsWith("u-ca=")?i.substring(5):i;n&&(n.calendar=a),t=t.withCalendar(a)}return delete e.brk,delete e.cal,delete e.tzd,delete e.tz,(o||i)&&ve(`[Lexer] Applied Zone/Calendar adjustments: Zone=${o??"unchanged"}, Calendar=${i??"unchanged"}`,n),t}const mi=new Set([">","<",">=","<=","+","-"]),Kl=[...mi,"="],Ks=new Set(["start","mid","end"]),an=new Set(["mid","end"]),Gl=new Set([">","next","+"]),hi=new Set(["<","last","prev","-"]),Hl=new Set(["add","plus"]),Fr=new Set(["subtract","minus","sub"]),br=new Set([...Hl,...Fr]),Sr=e=>k(e)&&(e.includes("<")||e.includes("-")||hi.has(e)),Ue=7;function Jl(e,t,n,r){let s=0;if(Gl.has(n))s=(t-e+Ue)%Ue||Ue;else if(hi.has(n))s=-((e-t+Ue)%Ue||Ue);else if(n===">="||n==="=")s=(t-e+Ue)%Ue;else if(n==="<=")s=-((e-t+Ue)%Ue);else return null;if(r>1||r<-1){const o=r>0?r-1:r;s>0?s+=o*Ue:s<0?s-=o*Ue:s===0&&(n===">="||n==="<=")&&(s=(n===">="?r>0?r-1:r+1:-(r>0?r-1:r+1))*Ue)}return s}const ze=e=>ae(e)?e.toDateTime():e,Gs=(e,t,n,r)=>Hr({year:e.year??t,month:e.month??1,day:e.day??1,hour:e.hour??0,minute:e.minute??0,second:e.second??0,millisecond:e.millisecond??0,microsecond:e.microsecond??0,nanosecond:e.nanosecond??0,timeZone:n,calendar:r});function At(e,t,n,r,s,o){if(!te(o))return o;let i=r,f;if(r.startsWith("#")){const u=r.slice(1).split(".");i=u[0],u.length>1&&(f=u.slice(1).join("."))}else if(r.includes(".")){const u=r.split(".");i=u[0],u.length>1&&(f=u.slice(1).join("."))}const a=ae(t)?t[G.$Internal]?.():t,h=ot(i,a),[m,g]=Pe(o);let p,T=1,N=!1,O=f,d=!1;const c=f?r:L(s)?s:void 0;if(c){let u=q.slick,y=q.slickValue;if(a.config.registry?.modifiers){const E=new Set;if(Kl.forEach(v=>{const w=a.config.registry.modifiers[v];w&&H(w).forEach(D=>E.add(D))}),E.size>0){const v=Array.from(E).map(q.escape);v.sort((D,I)=>I.length-D.length);const w=v.join("|");u=new RegExp(`^(?#[\\w]+|[\\w]+)\\.(?[\\+\\-\\<\\>\\=]=?|${w})?(?-?[0-9]+)?(?[\\w]*)$`),y=new RegExp(`^(?[\\+\\-\\<\\>\\=]=?|${w})?(?-?[0-9]+)?(?[\\w]*)$`)}}const b=c.match(u)||(L(s)?s.match(y):null),{groups:S}=b||{};if(S){const E=k(S.sh_mod);N=Le(S.sh_nbr),p=E?S.sh_mod:void 0,p&&a.config.registry?.modifiers&&(p=di(p,a.config)),T=N?Number(S.sh_nbr):1,O=S.sh_unit&&S.sh_unit.length>0?S.sh_unit:E?void 0:O,d=N&&!E}}if(!h){const u=i.toLowerCase();let b=a.parse?.weekdayMap?.[u]?.value;if(b===void 0){const E=["xxx","mon","tue","wed","thu","fri","sat","sun"].findIndex(v=>u.startsWith(v));E!==-1&&(b=E)}if(b!==void 0&&p){const S=Jl(o.dayOfWeek,b,p,T);return S===null?(e?.[Oe]?.(t.config,r),null):o.add({days:S}).withTimeZone(m).withCalendar(g)}return e?.[Oe]?.(t.config,r),null}if(br.has(n)&&P(h[ge.step])){const u=p&&!["this","=",">=","<="].includes(p)?Sr(p)?-T:T:Le(s)?Number(s):1,y=(Fr.has(n)?-1:1)*u,b=h[ge.step](r,y,t);if(k(b)){const S=ae(b)?b.toDateTime():te(b)?b:void 0;if(S)return S.withTimeZone(m).withCalendar(g)}}if(!br.has(n)){const u=f==="start"||f==="mid"||f==="end"?f:Ks.has(n)?n:void 0;if(u&&P(h[ge.bound])){const y=h[ge.bound](u,r,t);if(k(y)){const b=ae(y)?y.toDateTime():te(y)?y:void 0;if(b)return b.withTimeZone(m).withCalendar(g)}}}if(br.has(n)){const u=k(c),y=p&&!["this",">=","<="].includes(p),b=!y&&Le(s);if(y||b||u&&!p){let S=y?Sr(p)?-1:1:b?Math.sign(Number(s)||1):1;Fr.has(n)&&(S*=-1);const E=y?T:b?Math.abs(Number(s)||1):T,v=ct(h,t,o),w=$e(t,v,!1,o);if(!w)return e?.[Oe]?.(t.config,r),null;const D=ze(w.start).epochNanoseconds,A=o.epochNanoseconds-D;let M=o,Z=E,$=null,C=0;for(;Z>0&&C<200;){C++;const B=ct(h,t,M),W=$e(t,B,!1,M);if(!W)break;const ee=!O||W.key?.toLowerCase()===O.toLowerCase(),me=S>0?ze(W.start).epochNanoseconds>o.epochNanoseconds:ze(W.end).epochNanoseconds1||me)&&($=W,Z--),M=S>0?ze(W.end):ze(W.start).subtract({nanoseconds:1})}if(!$||Z>0)return e?.[Oe]?.(t.config,r),null;const j=ze($.start).epochNanoseconds,F=ze($.end).epochNanoseconds;let z=j+A;return z>=F&&(z=F-1n),zM.key?.toLowerCase()===O.toLowerCase()))return e?.[Oe]?.(t.config,r),null;v=E.filter(M=>M.key?.toLowerCase()===O.toLowerCase())}const w=v.map(A=>({range:A,start:Gs(A,u.year,m,g)})),D=w.filter(A=>A.start.epochNanoseconds<=u.epochNanoseconds).sort((A,M)=>{const Z=A.start.epochNanoseconds,$=M.start.epochNanoseconds;return Z===$?0:Z>$?-1:1})[0];if(D)return D.start.withTimeZone(m).withCalendar(g);const I=w.sort((A,M)=>{const Z=A.start.epochNanoseconds,$=M.start.epochNanoseconds;return Z===$?0:Z<$?-1:1})[0];return I?I.start.withTimeZone(m).withCalendar(g):(e?.[Oe]?.(t.config,r),null)}const y=Sr(p)?-1:1;let b=T,S=0;for(;b>0&&S<200;){S++;const E=ct(h,t,u);let v=E;if(O){if(!E.some(j=>j.key?.toLowerCase()===O.toLowerCase()))return e?.[Oe]?.(t.config,r),null;v=v.filter(j=>j.key?.toLowerCase()===O.toLowerCase())}const w=C=>Gs(C,u.year,m,g),D=C=>w(C).epochNanoseconds,I=[...E].sort((C,j)=>{const F=D(C),z=D(j);return F===z?0:F{if(C.start&&C.end)return C;const F=w(C),z=I[j+1],B=z?w(z):F.add({years:1});return{...C,start:F,end:B}});if(d&&S===1&&T>1){const C=A.filter(z=>O?z.key?.toLowerCase()===O.toLowerCase():!0),j=C.filter(z=>w(z.start).epochNanoseconds<=o.epochNanoseconds).sort((z,B)=>{const W=w(z.start).epochNanoseconds,ee=w(B.start).epochNanoseconds;return W===ee?0:W>ee?-1:1})[0];if(j){const z=j,B=w(z.start).withTimeZone(m).withCalendar(g);if(b--,b===0){if(an.has(n)){u=B;break}return B}u=w(z.end);continue}const F=C.filter(z=>w(z.start).epochNanoseconds>o.epochNanoseconds).sort((z,B)=>{const W=w(z.start).epochNanoseconds,ee=w(B.start).epochNanoseconds;return W===ee?0:W1){const C=A.filter(j=>O?j.key?.toLowerCase()===O.toLowerCase():!0).filter(j=>w(j.start).epochNanoseconds>u.epochNanoseconds).sort((j,F)=>{const z=w(j.start).epochNanoseconds,B=w(F.start).epochNanoseconds;return z===B?0:z0){const j=C[0],F=w(j.start).withTimeZone(m).withCalendar(g);if(b--,b===0){if(an.has(n)){u=F;break}return F}u=w(j.end);continue}}const M=k(p)&&mi.has(p),Z=C=>{const j=te(C.start)?C.start:w(C.start),F=te(C.end)?C.end:w(C.end),z=j.epochNanoseconds,B=F.epochNanoseconds,W=M&&S>1?u.epochNanoseconds:o.epochNanoseconds;let ee=!1;if(p===">"||p==="next")ee=S>1?z>=W:z>W;else if(p==="<"||p==="prev"||p==="last")ee=S>1?B<=W:B=")ee=S>1?z>=W:B>W;else if(p==="<=")ee=S>1?B<=W:z<=W;else if(p==="+"||p==="-")ee=Sn({mod:p,adjust:1,offset:Number(W/1000000n),period:Number(p==="-"?B/1000000n:z/1000000n)},a.config)!==0;else{const me=Number(W/1000000n);p===void 0?ee=!0:ee=Sn({mod:p,adjust:1,offset:me,period:Number(z/1000000n)},a.config)===0}return ee},$=A.filter(C=>O?C.key?.toLowerCase()===O.toLowerCase():!0).filter(Z).sort((C,j)=>{const F=w(C.start).epochNanoseconds,z=w(j.start).epochNanoseconds,B=u.epochNanoseconds;if(M)return y>0?Fz?-1:1;const W=F>B?F-B:B-F,ee=z>B?z-B:B-z;return Wee?1:0}).filter(C=>{if(!M)return!0;const j=w(C.start).epochNanoseconds,F=w(C.end).epochNanoseconds,z=u.epochNanoseconds;return p===">="||p==="<="?!0:y>0?j>=z:F<=z});if($.length>0){const C=$[0],j=w(C.start).withTimeZone(m).withCalendar(g);if(b--,b===0){if(an.has(n)){u=j;break}return j}u=y>0?w(C.end):w(C.start).subtract({nanoseconds:1})}else{const C=$e(t,E,!1,u);if(!C){u=y>0?u.add({days:30}):u.subtract({days:30});continue}u=y>0?w(C.end):w(C.start).subtract({nanoseconds:1})}}if(b>0)return e?.[Oe]?.(t.config,r),null;if(an.has(n)){const E=$e(t,ct(h,t,u),!1,u);if(!E)return e?.[Oe]?.(t.config,r),null;if(n==="mid"){const v=ze(E.start).epochNanoseconds,w=ze(E.end).epochNanoseconds,D=v+(w-v)/2n;return ks(D).toZonedDateTimeISO(m).withCalendar(g)}return ze(E.end).subtract({nanoseconds:1}).withTimeZone(m).withCalendar(g)}return u}const l=L(s)&&q.numeric.test(String(s));if(L(s)&&!s.startsWith("#")&&!l){let u=o;const y=w=>{if(w){const A=H(w),M=es(A),Z=It.findIndex(([$])=>$===M);if(Z!==-1){const $=Math.max(0,Z-1);return{[`${It[$][0]}s`]:1}}}const D=h.scope??"year";return{[`${D==="period"?"day":D}s`]:1}},b=h.define.call(new(ut(t))(u,{...t.config,mode:"strict"}),!1);let S=u.add(y(b)),E=0;for(;S.epochNanoseconds<=o.epochNanoseconds;){if(++E>50)return e?.[Oe]?.(t.config,r),null;{const w=h.define.call(new(ut(t))(u,{...t.config,mode:"strict"}),!1);u=u.add(y(w)),S=u}}const v=new(ut(t))(s,{...t.config,anchor:S,mode:"strict"}).toDateTime();return te(v)?v:S}if(n==="set"&&!p&&Le(s)){const u=ct(h,t,o),y=$e(t,u,Number(s),o);return y?ze(y.start).withTimeZone(m).withCalendar(g):(e?.[Oe]?.(t.config,r),null)}if(Le(s)||L(s)&&s.startsWith("#")){const u=Le(s)?Number(s):1;let y=o,b=Math.abs(u);const S=u>0?1:-1;let E=0;for(;b>0;){if(++E>100)return e?.[Oe]?.(t.config,r),null;let v=ct(h,t,y);if(f&&(v=v.filter(D=>D.key?.toLowerCase()===f.toLowerCase())),v.length===0)return e?.[Oe]?.(t.config,r),null;const w=Uc(new(ut(t))(y,t.config),v,r,S);if(k(w))y=ze(w),b--;else{const D=$e(t,v,!1,y);if(!D)return e?.[Oe]?.(t.config,r),null;const I=S>0?ze(D.end):ze(D.start).subtract({nanoseconds:1});I.epochNanoseconds===y.epochNanoseconds?y=S>0?y.add({days:1}):y.subtract({days:1}):y=I}}return y.withTimeZone(m).withCalendar(g)}return o}function Vl(e,t,n,r){return At(e,t,"start",n,n,r)}const ql=/\b(ago|hence|from\s+now|prior)\b/i,Xl=/(?:^|\s)(b\.?c\.?(?:e\.?)?|a\.?d\.?|c\.?e\.?)(?:\s|$)/i,Ql=256,cn=new Map;function Hs(e){const t=String(e??"").trim(),n=cn.get(t);if(n)return n;const r=iu(t);if(cn.set(t,r),cn.size>Ql){const s=cn.keys().next().value;s!==void 0&&cn.delete(s)}return r}const ue={hms:"hourMinuteSecond",dmy6:"dayMonthYearShort",mdy6:"monthDayYearShort",ymd6:"yearMonthDayShort",wkd:"weekDay",dt:"date",tm:"time",dtm:"dateTime",tmd:"timeDate",dmy:"dayMonthYear",mdy:"monthDayYear",ymd:"yearMonthDay",off:"offset",rel:"relativeOffset",ye:"yearEra",ey:"eraYearLeading",dRy:"dayRomanMonthYear",Ryy:"romanYearOnly"},eu=new Set([ue.hms,ue.dmy6,ue.mdy6,ue.ymd6]),tu=new Set([ue.dt,ue.dmy,ue.mdy,ue.ymd]),nu=new Set([ue.hms,ue.dmy6,ue.mdy6,ue.ymd6,ue.off]),ru=new Set([ue.wkd,ue.rel,ue.dRy,ue.Ryy]),su=new Set([ue.tm,ue.tmd,ue.dtm]),ou=new Set([ue.ye,ue.ey,ue.dmy,ue.mdy,ue.ymd,ue.Ryy]);function iu(e){const t=String(e??"").trim(),n=t.length;let r=!1,s=!1,o=!1,i=!1;for(let N=0;N=48&&O<=57){r=!0;continue}if(O>=65&&O<=90||O>=97&&O<=122){s=!0;continue}if(O===58){o=!0;continue}i=!0}const f=n>0&&(t[0]==="+"||t[0]==="-"),a=r&&!s&&!i&&!o,h=s&&!r&&!i&&!o,m=a&&n===6,g=a&&n===8,p=s&&ql.test(t),T=s&&Xl.test(t);return{trim:t,length:n,hasDigits:r,hasLetters:s,hasColon:o,hasSign:f,hasAgoHence:p,isPureNumeric:a,isAlphaOnly:h,isSixDigits:m,isEightDigits:g,hasEra:T}}function au(e,t,n={}){const r=n.onPlan,s=Te(r),o=ie(e.parse.layout).map(([u])=>{const y=De(u)?u:e.parse.token?.[String(u)];return[y,y?e.parse.pattern.get(y):void 0]}).filter(u=>k(u[0])&&k(u[1]));if(n.enablePrefilter!==!0)return s&&r({inputClass:Hs(t),totalCandidates:o.length,selectedCandidates:o.length,fallbackToFull:!1,rulesApplied:[]}),o;const i=Hs(t),f=i.hasAgoHence,a=i.isAlphaOnly,h=i.isSixDigits,m=i.isEightDigits,g=i.isPureNumeric,p=i.hasColon,T=i.hasEra;let N;s&&(N=[],f&&N.push("hasAgoHence"),a&&N.push("isAlphaOnly"),h&&N.push("isSixDigits"),m&&N.push("isEightDigits"),g&&N.push("isPureNumeric"),p&&N.push("hasColon"),T&&N.push("hasEra"));const O=[],d=[],c=[];for(const u of o){const y=u[0].description??"";let b=!0;f?b=y===ue.rel||y===ue.wkd:(b&&a&&nu.has(y)&&(b=!1),b&&h&&!eu.has(y)&&(b=!1),b&&m&&!tu.has(y)&&(b=!1),b&&g&&ru.has(y)&&(b=!1)),b&&(T&&ou.has(y)?c.push(u):p&&su.has(y)?d.push(u):O.push(u))}let l=O;if(T&&c.length>0){if(l=c,p&&d.length>0)for(const u of d)l.push(u);for(const u of O)l.push(u)}else if(p&&d.length>0){l=d;for(const u of O)l.push(u)}return l.length===0?(s&&r({inputClass:i,totalCandidates:o.length,selectedCandidates:o.length,fallbackToFull:!0,rulesApplied:N}),o):(s&&r({inputClass:i,totalCandidates:o.length,selectedCandidates:l.length,fallbackToFull:!1,rulesApplied:N}),l)}const Js={ss:{scale:1000000000n,matchName:"Seconds"},ms:{scale:1000000n,matchName:"Milliseconds"},us:{scale:1000n,matchName:"Microseconds"},ns:{scale:1n,matchName:"Nanoseconds"}};function cu(e,t,n,r,s,o,i="ms",f,a){const{type:h,value:m,zone:g,calendar:p}=e,T=a?.has("timeZone")?r:g??r,N=a?.has("calendar")?s:p??s;let O=t,d,c;switch(h){case"Temporal.ZonedDateTime":case"Temporal.Instant":case"Temporal.PlainDateTime":case"Temporal.PlainDate":O=m,g?d=g:te(m)&&(d=m.timeZoneId);break;case"Void":case"Empty":case"Undefined":o?.({type:h,value:m}),O=t;break;case"String":try{const l=Hr(m,n);d=Pe(l)[0],O=l,o?.({type:h,value:m,match:"iso8601"})}catch{try{O=Temporal.PlainDateTime.from(m,{overflow:"constrain"})}catch{return J(`[Tempo#composer] Unrecognized or invalid ISO 8601 string: "${m}"`,f),{dateTime:t}}}break;case"Temporal.ZonedDateTime":case"Temporal.PlainDate":case"Temporal.PlainDateTime":case"Temporal.Instant":case"Tempo":O=m;break;case"Temporal.PlainTime":O=t.withPlainTime(m);break;case"Temporal.PlainYearMonth":O=m.toPlainDate({day:Math.min(t.day,m.daysInMonth)});break;case"Temporal.PlainMonthDay":O=m.toPlainDate({year:t.year});break;case"Date":o?.({type:h,value:m}),O=Temporal.Instant.fromEpochMilliseconds(m.getTime());break;case"Number":case"BigInt":{if(h==="Number"&&!Number.isFinite(m)){J(`Invalid Tempo number: ${m}`,f),O=t;break}const{scale:l,matchName:u}=Js[i]??Js.ms;let y;if(h==="Number"&&!Number.isInteger(m)){const b=Math.abs(m);let S=BigInt(Math.trunc(b)),E=BigInt(Math.round((b-Math.trunc(b))*1e9));E===1000000000n&&(S+=1n,E=0n),y=(S*1000000000n+E)*l/1000000000n,m<0&&(y=-y)}else y=BigInt(m)*l;o?.({type:h,value:m,match:u}),O=Temporal.Instant.fromEpochNanoseconds(y);break}}switch(!0){case te(O):c=O.withTimeZone(T).withCalendar(N);break;case qt(O):c=O.toZonedDateTimeISO(T).withCalendar(N);break;case(Oo(O)||Eo(O)):c=O.toZonedDateTime(T).withCalendar(N);break;case ae(O):c=O.toDateTime().withTimeZone(T).withCalendar(N);break;default:return J(`Cannot convert ${h} (value: ${String(O)}) to ZonedDateTime`,f),{dateTime:t}}return ve(`[Composer] Composed final DateTime: ${c?.toString()}`,f),{dateTime:c??t,timeZone:d}}const lu=50,uu=/_alt\d+$/;function dn(e,t){const{state:n,resolvingKeys:r,conform:s}=e,[o,i]=Pe(n.config.timeZone,n.config.calendar);return{add:(a,h)=>{let m=t;const g=h?{...e,state:{...n,config:{...n.config,...h}}}:e;if(L(a)&&a.startsWith("#")){const p=se().modules.Tempo,T=At(p,g.state,"add",a,1,m);te(T)&&(m=T)}else m=m.add(a);return dn(g,m)},plus(a,h){return this.add(a,h)},subtract:(a,h)=>{let m=t;const g=h?{...e,state:{...n,config:{...n.config,...h}}}:e;if(L(a)&&a.startsWith("#")){const p=se().modules.Tempo,T=At(p,g.state,"subtract",a,1,m);te(T)&&(m=T)}else m=m.subtract(a);return dn(g,m)},sub(a,h){return this.subtract(a,h)},minus(a,h){return this.subtract(a,h)},set:(a,h)=>{const m=s(a,t,r),g=te(m.value)?m.value:t,p=h?{...e,state:{...n,config:{...n.config,...h}}}:e;return dn(p,g)},toNow:()=>dn(e,bt().toZonedDateTimeISO(o).withCalendar(i)),toDateTime:()=>t,toString:()=>t.toString(),get zdt(){return t},get yy(){return t.year},get mm(){return t.month},get dd(){return t.day},get hh(){return t.hour},get mi(){return t.minute},get ss(){return t.second},get tz(){return o},get cal(){return i},get locale(){const a=n.config.locale,h=Array.isArray(a)?a[0]:a,m=Array.isArray(fe.locale)?fe.locale[0]:fe.locale;return h??m},get sphere(){return n.config.geo?.sphere??n.config.sphere??fe.sphere},config:n.config,[G.$Identity]:!0}}function fu(e,t,n){if(e)for(const o of he(e)){const i=o.replace(uu,"");i!==o&&k(e[o])&&((!k(e[i])||e[i]==="")&&(e[i]=e[o]),delete e[o])}const{state:r,isAnchored:s}=n;if(t=Yl(e,t,r.config),t=Vs(e,t,n,["evt","slk"]),r.errored)return t;if(k(e.wkd)&&!Le(e.wkd)){const o=String(e.wkd).replace(/\.$/,"").toLowerCase(),i=r.parse.weekdayMap?.[o];if(k(i)){const f=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"][i.value-1];e.wkd=f,ve(`[Normalizer] Normalized localized weekday string '${o}' to '${f}'`,r.config),He(r,{type:"Weekday",value:i.value,match:o,locale:i.locale})}}return t=jl(e,t,r.config),t=Ul(e,t,r.config,r.parse.pivot),t=Vs(e,t,n,["per"]),r.errored||(t=Bl(e,t,r.config)),t}function Vs(e,t,n,r){const{state:s,resolvingKeys:o,subParse:i}=n,f=s.anchor,a=s.zdt;s.anchor=t,s.zdt=t,s.parseDepth=(s.parseDepth??0)+1,s.parseDepth===1&&(s.matches=[]);const m=se().modules.Tempo,g=s.aliasEngine??m?.[G.$Internal]?.().aliasEngine;try{for(const p of he(e)){if(r&&!r.some(d=>{const c=g?.getAlias(p);return p===d||c&&(c.type===d||c.groupName===d)?!0:p.startsWith(d)}))continue;if(p==="slk"){const O=e[p],d=At(m,s,"set",O,void 0,t);if(d===null){s.errored=!0,delete e[p];break}t=d,delete e[p];continue}if(q.named.test(p)){delete e[p];continue}const T=g?.getAlias(p);if(!T)continue;const N=T.name;if(o.size>lu||o.has(N)){const O=`Infinite recursion detected in Tempo resolution for: ${N}`;s.errored=!0,J(new RangeError(O),s.config),delete e[p];continue}o.add(N);try{const O=dn(n,t),d=g?.resolveAlias(p,O);if(!d)continue;ve(`[Normalizer] Resolved alias '${N}'`,s.config);try{const c={evt:{type:"Event",pat:"dt"},per:{type:"Period",pat:"tm"}}[d.type];if(!c)throw new pt(`[ParseEngine] Unexpected AliasType: ${d.type}`);const{type:l,pat:u}=c;if(He(s,{type:l,value:d.key,match:u,source:d.source,groups:{[p]:d.value}}),!Q(d.value)&&d.value!==String(e[p])){const y=new Set(o);y.add(d.key);const b=s.anchor;s.anchor=t;const S=i(d.value,t,y);s.anchor=b,S.type==="Temporal.ZonedDateTime"&&(t=S.value)}}finally{s.zdt=t,delete e[p]}}finally{o.delete(N)}}}finally{k(f)?s.anchor=f:delete s.anchor,k(a)?s.zdt=a:delete s.zdt,s.parseDepth--,s.parseDepth===0&&delete s.matches}if(k(e.mm)&&!Le(e.mm)){const p=String(e.mm).replace(/\.$/,"").toLowerCase(),T=s.parse.monthMap?.[p];if(k(T))e.mm=T.value.toString().padStart(2,"0"),ve(`[Normalizer] Normalized localized month string '${e.mm}'`,s.config),He(s,{type:"Month",value:T.value,match:p,locale:T.locale});else{const N=ur(e.mm),O=R.MONTH[N];k(O)&&(e.mm=O.toString().padStart(2,"0"),ve(`[Normalizer] Normalized month string '${N}' to ${e.mm}`,s.config))}}return t}function He(e,...t){const n=Object.assign({},...t);k(e.parse.anchor)&&(n.anchor=e.parse.anchor),!k(n.isAnchored)&&k(e.parse.isAnchored)&&(n.isAnchored=e.parse.isAnchored);const r=e.parse.result;k(r)&&!Object.isFrozen(r)&&(r.some(o=>o.match===n.match&&o.source===n.source&&String(o.anchor??"")===String(n.anchor??""))||r.push(n))}function qs(e,t,n,r,s){const o=e.trim().toLowerCase(),i=t.toPlainDate().toString(),f=String(n.config.timeZone||"UTC"),a=String(n.config.calendar||"iso8601"),h=Array.isArray(n.config.locale)?n.config.locale.join(","):String(n.config.locale||"en-US"),m=String(n.config.sphere||"north"),g=r?H(r).map(String).join("|"):"",p=String(s??"");return`${o}::${i}::${f}::${a}::${h}::${m}::${g}::${p}`}const Xs=new Rt,Qs=/\s/,du=/[\\^$*+?.()|[\]{}]/,mu=/^-?\d+/,eo=/(?:st|nd|rd|th)/,hu=/#[\w.]+/,pu="[IVXLCDMivxlcdm]+",gu=/^[IVXLCDMivxlcdm]+$/;function ln(e){const t=e.trim();if(gu.test(t)){const n=er(t);if(Number.isFinite(n))return n}return parseInt(t,10)}function yu(e){const t=Ye(e)?`-?\\d+${eo.source}?|${e.trim()}`:`-?\\d+${eo.source}?`;return new RegExp(`^\\s*(?${t})\\s+(?:day\\s+of\\s+)?(?${hu.source})\\s*$`,"i")}function wu(e){let t=Xs.get(e);if(t)return t;const n={},r=(f,a)=>{const h=n[f]=(n[f]??0)+1;return`(?<${h===1?f:`${f}_${h}`}>${a})`};let s="",o=0;for(;oN.toLowerCase()==="roman"),T=N=>p?pu:N;switch(g){case"yyyy":case"year":s+=r("yyyy",T("[+-]?\\d{4,6}|\\d{4}"));break;case"yy":s+=r("yy",T("\\d{2}"));break;case"mm":case"month":s+=r("mm",T("\\d{1,2}"));break;case"mmm":s+=r("mmm","[A-Za-z]{3,}");break;case"mon":s+=r("mon","[A-Za-z]+");break;case"dd":case"day":s+=r("dd",T("\\d{1,2}(?:st|nd|rd|th)?"));break;case"hh":case"h24":case"hour":s+=r("hh",T("\\d{1,2}"));break;case"h12":s+=r("h12","1[0-2]|0?[1-9]");break;case"mi":case"min":case"minute":s+=r("mi","\\d{1,2}");break;case"ss":case"sec":case"second":s+=r("ss","\\d{1,2}");break;case"ms":case"millisecond":s+=r("ms","\\d{1,3}");break;case"mer":case"ampm":s+=r("mer","[AaPp][Mm]?");break;case"*":case"_":case"skip":s+="(?:.*?)";break;default:throw new Error(`[Tempo] Unknown braced format token '{${a}}' in format mask '${e}'.`)}o=f+1}else{const f=e[o];if(Qs.test(f))for(s+="\\s+";o+1f[A]??Object.entries(f).find(([M])=>M===A||M.startsWith(`${A}_`))?.[1];let h=n.year;const m=a("yyyy"),g=a("yy");if(m)h=ln(m);else if(g){const A=ln(g);h=A<100?A>=70?1900+A:2e3+A:A}let p=1;const T=a("mm"),N=a("mmm"),O=a("mon");if(T)p=ln(T);else if(N||O){const A=bu(N||O);if(A)p=A;else return}else!m&&!g&&(p=n.month);let d=1;const c=a("dd");c?d=ln(c):!m&&!g&&!T&&!N&&!O&&(d=n.day);let l=0,u=0,y=0,b=0;const S=a("hh"),E=a("h12");S?l=ln(S):E&&(l=parseInt(E,10));const v=a("mer");if(v){const A=v.toLowerCase().startsWith("p");A&&l<12?l+=12:!A&&l===12&&(l=0)}const w=a("mi");w&&(u=parseInt(w,10));const D=a("ss");D&&(y=parseInt(D,10));const I=a("ms");I&&(b=parseInt(I.padEnd(3,"0").slice(0,3),10));try{return Temporal.PlainDateTime.from({year:h,month:p,day:d,hour:l,minute:u,second:y,millisecond:b},{overflow:"reject"}).toZonedDateTime(r).withCalendar(s)}catch{return}}function Tu(e,t,n,r,s,o,i){const f=i??oe(n.options?.dialect??n.config?.dialect),a=se().modules.Tempo,h=n.config?.registry?.dialects??se().dialects??se().modules?.DialectsModule??globalThis[Symbol.for("Tempo.dialects")]??a?.dialectsRegistry,m=h?.parse??(f?h?.[f]?.parse:void 0);if(P(m))return m(e,t,{...n.config,...n.options,pivot:n.options?.pivot??n.parse?.pivot??n.config?.pivot,timeZone:s,calendar:o,dialect:f,today:r});throw new Error(`[Tempo] Parsing unbraced format mask '${t}' requires '@magmacomputing/tempo-plugin-dialects'.`)}const Ve={parse(e,t,n,r){if(Wi(t)){e.errored=!0;return}if(!r&&(te(t)||qt(t))){const{config:i}=e,[f,a]=Pe(i.timeZone,i.calendar);return{type:"Temporal.ZonedDateTime",value:(te(t)?t:t.toZonedDateTimeISO(f)).withTimeZone(f).withCalendar(a),zone:f,calendar:a}}e.parseDepth=(e.parseDepth??0)+1;const s=e.parseDepth===1;s&&(Array.isArray(e.parse.result)||Y(e.parse,"result",[]),e.parse.result.length=0);let o;try{const{config:i}=e,f=se().modules.Tempo,a=e.pluginsDb.terms,h=n??e.anchor??e.config.anchor??(ae(t)?t.toDateTime():te(t)?t:qt(t)?t.toZonedDateTimeISO(i.timeZone):void 0),[m,g]=Pe(i.timeZone,i.calendar);let p;if(ae(h))p=h.toDateTime();else if(te(h))p=h;else if(k(h)){const v={...e.config};if(delete v.anchor,f)p=f.from(h,v).toDateTime();else{const w=h instanceof Date?h.getTime():xi(h)?Number(h):new Date(String(h)).getTime();p=Temporal.Instant.fromEpochMilliseconds(w||Date.now()).toZonedDateTimeISO(m).withCalendar(g)}}else p=bt().toZonedDateTimeISO(m).withCalendar(g);const T=k(h);if(s&&(e.parse.anchor=p,e.parse.isAnchored=T),o=p,r){const v=r.startsWith("#")?r.slice(1):r,w=a.find(D=>D.key===v||D.scope===v);if(!w){f&&f[Oe](e.config,r);return}if(Le(t)){const D=ct(w,e,o),I=$e(e,D,!1,o);if(!I)throw new RangeError(`Term index out of range: ${t} for ${r}`);const A=k(w.resolve)&&D.some(F=>F.year!==void 0),M=A?D.length/3:D.length,Z=D.findIndex(F=>F.key===I.key&&(A?F.year===I.year:!0));if(Z===-1||M<=0)throw new RangeError(`Term index out of range: ${t} for ${r}`);const C=Math.floor(Z/M)*M+(Number(t)-1),j=D[C];if(j){const F=$e(e,[j],!1,o);if(F?.start)return{type:"Temporal.ZonedDateTime",value:F.start.toDateTime().withTimeZone(m).withCalendar(g),zone:m,calendar:g}}throw new RangeError(`Term index out of range: ${t} for ${r}`)}if(t===r){const D=w.define.call(e,!1,o),I=U(D)?[]:H(D),A=$e(e,I,!1,o);if(A?.start)return{type:"Temporal.ZonedDateTime",value:A.start.toDateTime().withTimeZone(m).withCalendar(g),zone:m,calendar:g}}}if(x(t)){const v=Object.keys(t).find(w=>w.startsWith("#"));if(v){if(U(r)){const w=`Unsupported Syntax: Term-based mutations (#) cannot be passed to the constructor. Use new Tempo().set(${JSON.stringify(t)}) instead.`;throw J(w,e.config),new pt(w)}if(a.length===0){f&&f[Oe](e.config,v);return}}}const N=new Set,O=Ve.conform(e,t,o,T,N),{timeZone:d,calendar:c}=e.config,[l,u]=Pe(d,c),{dateTime:y,timeZone:b}=cu(O,o,m,l,u,v=>He(e,v),e.config.timeStamp,e.config,e.userProvidedKeys);n=y;const S=ce(e.options,"timeZone"),E=S?l:b??l;if(te(n)&&!e.errored&&(n=n.withTimeZone(E).withCalendar(u),!S&&b&&e.config&&(e.config.timeZone=E)),(e.config.cache===!0||e.config.cache===R.CACHE.On||e.config.cache===R.CACHE.Refresh||e.config.cache==="refresh")&&L(t)&&te(n)&&!e.errored){const v=oe(e.options?.format??e.config?.format),w=oe(e.options?.dialect??e.config?.dialect),D=qs(t,o,e,v,w);e.cache.set(D,n.toString())}return Object.assign(O,{type:"Temporal.ZonedDateTime",value:te(n)&&!e.errored?n:void 0})}finally{e.parseDepth--}},conform(e,t,n,r=!1,s=new Set){const o=Mt(t);let{type:i,value:f}=o;const a=se().modules.Tempo,h=e.pluginsDb.terms;if(ae(n)&&(n=n.toDateTime()),!te(n))return J(new TypeError(`Sacred Anchor corrupted: ${String(f)}`),e.config),{type:"Void",value:void 0};let m=n;if(Ve.isZonedDateTimeLike(e,t)){const{timeZone:p,calendar:T,value:N,...O}=t,d=Object.keys(O).find(c=>c.startsWith("#"));return d&&h.length===0?(a&&a[Oe](e.config,d),{type:"Void",value:void 0}):(p&&(m=m.withTimeZone(p)),T&&(m=m.withCalendar(T)),Q(O)||(m=m.with(O)),He(e,{type:"Temporal.ZonedDateTimeLike",value:m,match:"Temporal.ZonedDateTimeLike"}),{type:"Temporal.ZonedDateTime",value:m})}if(ae(f)){const p=f.toDateTime(),[T,N]=Pe(p);return{type:"Temporal.ZonedDateTime",value:p,zone:T,calendar:N}}if(te(f))return{type:"Temporal.ZonedDateTime",value:f};if(L(f)&&f.includes("#")){const p=f.indexOf("#"),T=f.slice(p+1).split(/[\s./]/)[0],N=ot(T,e);if(N){let O;const d=()=>{if(O!==void 0)return O;try{const l=e.options?.anchor;O=ae(l)?l:l&&a?new a(l,e.config):ae(n)?n:a&&te(n)?new a(n,e.config):void 0}catch{O=void 0}return O},c={get anchor(){return d()},timeZone:e.config?.timeZone,calendar:e.config?.calendar,locale:e.config?.locale,geo:e.options?.geo??e.config?.geo,config:e.config};if(f.startsWith("#")&&P(N[ge.parse])){const l=N[ge.parse](f,c);if(l){const u=ae(l)?l.toDateTime():te(l)?l:void 0;if(u)return{type:"Temporal.ZonedDateTime",value:u,zone:u.timeZoneId}}}if(P(N[ge.ordinal])){const l={...e.config?.registry?.ordinals,...e.options?.registry?.ordinals},u={};for(const[E,v]of Object.entries(l))u[E.toLowerCase()]=v;const b=Array.from(new Set([...re.keys(R.ORDINAL),...Object.keys(u)])).filter(Boolean).map(q.escape).join("|"),S=f.match(yu(b));if(S?.groups?.term){const[E]=S.groups.term.slice(1).split(".");if(ot(E,e)===N){const w=c.anchor??d(),D=S.groups.ord?.toLowerCase(),I=mu.test(D)?parseInt(D,10):void 0,A=u[D]??(D?R.ORDINAL?.[D]:void 0)??I,M={...S.groups,...k(A)?{value:A}:{}},Z=N[ge.ordinal](M,w,c);if(Z){const $=ae(Z)?Z.toDateTime():te(Z)?Z:void 0;if($)return{type:"Temporal.ZonedDateTime",value:$,zone:$.timeZoneId}}}}}}if(f.startsWith("#")){const O=Vl(a,e,f,n);return te(O)?{type:"Temporal.ZonedDateTime",value:O,zone:O.timeZoneId}:{type:"Void",value:void 0}}}if(L(f)){let p=f.trim();const T=p.toLowerCase(),N=oe(e.options?.format??e.config?.format),O=oe(e.options?.dialect??e.config?.dialect);if(e.cache.isStatic(T)){const l=e.cache.get(T);if(l)return He(e,{match:"CacheHit",value:p,source:"glossary"}),{type:"String",value:l}}const d=e.config.cache;if(d===!0||d===R.CACHE.On){const l=qs(p,n,e,N,O),u=e.cache.get(l);if(u)return He(e,{match:"CacheHit",value:p,source:"parseCache"}),{type:"String",value:u}}if(k(N)){const l=H(N),[u,y]=Pe(e.config.timeZone,e.config.calendar),b=O??oe(e.options?.dialect??e.config?.dialect);for(const S of l)if(L(S))try{const E=Vo(S,b)?Su(p,S,n,u,y):Tu(p,S,e,n,u,y,O);if(te(E))return He(e,{match:"FormatMask",value:p,pattern:S}),{type:"Temporal.ZonedDateTime",value:E,zone:E.timeZoneId,calendar:y}}catch(E){if(l.length===1)throw E}return e.errored=!0,{type:"Void",value:void 0}}if(e.parse.ignorePattern){const l=Object.isFrozen(e.parse.ignorePattern)?new RegExp(e.parse.ignorePattern.source,e.parse.ignorePattern.flags):e.parse.ignorePattern;p=p.replace(l," ").replace(q.spaces," ").trim()}let c=e?.parse?.guard?.test(p)??a?.[G.$guard]?.test(p)??!0;if(!c){const l=Object.assign({},ft,e.parse?.snippet),u=l[_.sep]?.source??q.separator.source,y=l[_.mm]?.source??ft[_.mm].source,b=(l[_.dd]?.source??ft[_.dd].source).replace("{ord}",l[_.ord]?.source??ft[_.ord].source);new RegExp(`^\\d{4}${u}(?:${y})${u}(?:${b})(?:\\b|[T\\s]|$)`,"i").test(p)&&(!p.includes("[")&&!p.includes("]")||q.bracket.test(p))&&(c=!0)}if(!c&&(!Q(e.parse.monthMap)||!Q(e.parse.weekdayMap))&&(c=!0),!c&&e.config.registry?.modifiers&&Object.values(e.config.registry.modifiers).flat().some(u=>p.toLowerCase().includes(u.toLowerCase()))&&(c=!0),!c){const l=S=>{const E=new Set;let v=S;for(;v&&v!==Object.prototype;)he(v).forEach(w=>E.add(String(w))),v=Object.getPrototypeOf(v);return E},u=[...l(e.parse.event),...l(e.parse.period)],y=p.toLowerCase();if(!u.some(S=>y.includes(String(S).toLowerCase())))return o}f=p}return Ve.parseLayout(e,f,n,r,s)},parseLayout(e,t,n,r=!1,s=new Set){const o=Mt(t),{type:i}=o,f=t?.toString().trim()??"",a=new Set(s);if(se().modules.Tempo,a.size>=100)return J(new RangeError(`Infinite recursion detected in layout resolution for: ${String(t)}`),e.config),o;if(i==="String"&&Q(f))return He(e,{type:"Empty",value:f,match:"Empty"}),Object.assign(o,{type:"Empty"});let h=!1,m=t,g=i;const p=e.userProvidedKeys?.has("timeStamp"),T=f.length>=12||e.config.timeStamp==="ss"&&f.length>=9||p&&f.length>=9;if(i==="String"&&Le(f)){const c=Number(f),l=Number.isInteger(c)&&T;(!Number.isInteger(c)||l)&&(h=!0,m=l?BigInt(f):c,g=l?"BigInt":"Number")}else if(i==="BigInt")h=!0;else if(i==="Number"){if(!V(t))return o;if(!Number.isInteger(t)||T)h=!0,m=Number.isInteger(t)?BigInt(t):t,g=Number.isInteger(t)?"BigInt":"Number";else if(f.length<=7){const c="Cannot safely interpret number with less than 8-digits: use string instead";return J(new TypeError(c),e.config),o}}if(h){const c={type:g,value:m,match:"Epoch"};return He(e,c),Object.assign(o,c)}if(!te(n))return o;const O=n.toPlainTime(),d=au(e,f,{enablePrefilter:e.parse.preFilter===!0,onPlan:c=>{e.parse.preFilter!==!0||!e.config?.debug||c.totalCandidates-c.selectedCandidates<=0&&!c.fallbackToFull||ve(`Planner summary: selected ${c.selectedCandidates}/${c.totalCandidates}`,e.config,`rules=${c.rulesApplied.join(",")||"none"}`,`fallback=${c.fallbackToFull}`,`input="${c.inputClass.trim}"`)}});e.config?.debug===ke.Debug&&ve(`[ParseEngine] Selected layouts: ${d.map(c=>c[0].description).join(", ")}`,e.config);for(const[c,l]of d){const u=Ve.parseMatch(e,l,f);if(Q(u))continue;e.config?.debug===ke.Debug&&ve(`[ParseEngine] Matched layout '${c.description}' with groups: ${JSON.stringify(u)}`,e.config);const y=Object.keys(u).some(S=>["hh","mi","ss","ms","us","ns","ff","mer"].includes(S)||q.period.test(S)||q.named.test(S)&&S.endsWith("tm"))||Object.values(u).includes("now");He(e,{match:c.description,value:f,groups:{...u}}),n=fu(u,n,{state:e,isAnchored:r,resolvingKeys:s,subParse:(S,E,v)=>Ve.parseLayout(e,S,E,!0,v),conform:(S,E,v)=>Ve.conform(e,S,E,!0,v)});const b=!n.toPlainTime().equals(O);!r&&!y&&!b&&(n=n.withPlainTime("00:00:00")),te(n)&&Object.assign(o,{type:"Temporal.ZonedDateTime",value:n,match:c.description,groups:u});break}return o},parseMatch(e,t,n){const r=n.toString().match(t)?.groups||{};return ie(r).forEach(([s,o])=>Q(o)&&delete r[s]),r},isZonedDateTimeLike(e,t){if(!Re(t)||Q(t))return!1;const n=he(t);return n.some(r=>e.CONFIG.has(r)&&!e.ZONED_DATE_TIME.has(r)&&r!=="value")?!1:n.filter(L).some(r=>e.ZONED_DATE_TIME.has(r)&&!e.CONFIG.has(r))}},Pt=e=>function(...t){const n=t[0];let r,s;x(n)&&x(n.config)&&x(n.parse)?(r=n,s=t.slice(1)):x(n)&&n.constructor&&typeof n.constructor[G.$Internal]=="function"?(r=n.constructor[G.$Internal](),s=t.slice(1)):(r=this?.[G.$Internal]?.()??se().state,s=t);const o=e(r,...s);return ce(o,"type")&&ce(o,"value")?o.value:o},pi={parse:Pt(Ve.parse),conform:Pt(Ve.conform),parseLayout:Pt(Ve.parseLayout),parseMatch:Pt(Ve.parseMatch),isZonedDateTimeLike:Pt(Ve.isZonedDateTimeLike),result:Pt(He)},Ou=or("ParseModule",pi);function Xu(e,t={}){const n=se(),r=n.state??zr(),s={...r,config:st({...r.config}),parse:st({...r.parse})};s.parse.snippet={...r.parse.snippet},s.parse.layout={...r.parse.layout},s.parse.event={...r.parse.event},s.parse.period={...r.parse.period},s.parse.ignore={...r.parse.ignore},s.parse.pattern=new Map(r.parse.pattern);const o={...t};o.mode??="strict",s.options=o,li(s,o);const i=n.modules.Tempo;return i&&(i[Yt](s,void 0,!1),i[Kt](s,void 0,!1)),tt(s),pi.parse(s,e)}const to=/^-?\d+$/,Eu=/\{h12[^}]*\}/,Du=/\{h12[^}]*\}/g,ku=/\{mi[^}]*\}/g,vu=/\{ss[^}]*\}/g,Nu=/\{ms[^}]*\}/g,Iu=/\{us[^}]*\}/g,Au=/\{ns[^}]*\}/g,$u=/\{ff[^}]*\}/g,Mu=/:space/g,Cu=new RegExp(q.formatBraces.source,"g"),Ru=/\./g,_u=/^#/,Lu=/:/g;function no(e,t){const n=t.split(".");if(!n.every(gt))return`{${t}}`;const[r,...s]=n;let o=e[r];if(Me(o))return r==="geo"?"":`{${t}}`;for(const i of s){if(Me(o))return"";o=o[i]}return Me(o)||P(o)?"":x(o)?String(o.label??o.key??o.name??o.value??o):String(o)}function ro(e,t,n,r){if(!x(e))return;let s=e;for(const i of t){if(!ce(s,i)){s=void 0;break}s=s[i]}if(ce(s,n))return xn(s[n],r);const o=t.at(-1);if(o&&ce(e,o)&&ce(e[o],n))return xn(e[o][n],r);if(ce(e,n))return xn(e[n],r)}function gi(e,t,n){const r=se().state,s=ae(e)?e.config:r?.config;let o=s;x(t)&&U(n)&&(n=t,t=void 0),n&&(o={...s,...n},n.intl&&(o.intl=Jn(s?.intl||{},n.intl)),n.registry&&(o.registry={...s?.registry,...n.registry},n.registry.formats&&(o.registry.formats={...s?.registry?.formats,...n.registry.formats}),n.registry.locales&&(o.registry.locales={...s?.registry?.locales,...n.registry.locales}),n.registry.tokens&&(o.registry.tokens={...s?.registry?.tokens,...n.registry.tokens})));const i=Object.assign({},R.FORMAT,o?.registry?.formats),f=o?.timeZone??"UTC";let a;switch(!0){case ae(e):a=e.toDateTime();break;case te(e):a=e;break;case qt(e):a=e.toZonedDateTimeISO(f);break;case L(e):a=e.includes("[")?Temporal.ZonedDateTime.from(e):e.includes("T")?Temporal.PlainDateTime.from(e).toZonedDateTime(f):Temporal.PlainDate.from(e).toZonedDateTime(f);break;case Eo(e):case Oo(e):a=e.toZonedDateTime(f);break;case e===void 0:a=Temporal.Now.zonedDateTimeISO(f);break;default:a=e}if(o?.timeZone&&a?.timeZoneId&&a.timeZoneId!==o.timeZone)try{a=a.withTimeZone(o.timeZone)}catch{}if(o?.calendar&&a?.calendarId&&a.calendarId!==o.calendar)try{a=a.withCalendar(o.calendar)}catch{}if(U(t)){if(n)try{return be(o?.locale,n).format(a)}catch{const O={timeZone:a.timeZoneId,...n};return a.calendarId!=="iso8601"&&!O.calendar&&(O.calendar=a.calendarId),be(o?.locale,O).format(a.epochMilliseconds)}return Ki(i,N=>gi(a,N))}if(!te(a))return"";const h=L(t)&&ce(i,t),m=oe(n?.dialect??o?.dialect);if(m&&L(t)&&!h&&!Vo(t,m)){const N=se().modules.Tempo??e?.constructor,O=o?.registry?.dialects??se().dialects??se().modules?.DialectsModule??globalThis[Symbol.for("Tempo.dialects")]??N?.dialectsRegistry,d=O?.format??O?.[m]?.format;if(P(d))return d(a,String(t),{...o,dialect:m});throw new Error(`[Tempo] Formatting with dialect '${m}' requires '@magmacomputing/tempo-plugin-dialects'.`)}let g=L(t)&&i&&t in i?i[t]:String(t);if(g.includes("{h12")&&!g.includes("{mer")){const N=g.match(Eu);let O="",d=!1;if(N){const c=N[0].toLowerCase();c.includes("raw")&&(d=!0),c.includes("upper")&&(O+=":upper"),c.includes("lower")&&(O+=":lower"),c.includes("dots")&&(O+=":dots"),c.includes("locale")&&(O+=":locale"),c.includes("space")&&(O+=":space")}if(!d){const c=E=>[...g.matchAll(E)].at(-1)?.index??-1,l=c(Du),u=c(ku),y=c(vu),b=Math.max(c(Nu),c(Iu),c(Au),c($u)),S=Math.max(l,u,y,b);if(S!==-1){const E=g.indexOf("}",S)+1,v=O.includes(":space")?" ":"",w=O.replace(Mu,"");g=g.slice(0,E)+`${v}{mer${w}}`+g.slice(E)}}}const p=Jr(en(o?.locale)[0]);return g.replace(Cu,(N,O)=>{let[d,...c]=O.split(":");const l=c.map(S=>S.toLowerCase());d==="tzd"&&(d="tz");let u;switch(d){case"yyyy":u=K(a.year,4);break;case"yy":u=K(a.year%100);break;case"yw":case"yow":{const S=l.includes("locale")?dr(a,p).yearOfWeek:Ae(a).yearOfWeek;u=l.includes("short")?K(Math.abs(S)%100):K(S,4);break}case"ww":case"wy":case"woy":{if(l.includes("cal")){const S=Math.ceil(a.dayOfYear/7);u=K(l.includes("zero")||l.includes("0")?S-1:S)}else if(l.includes("month")){const S=Math.ceil(a.day/7);u=(l.includes("zero")||l.includes("0")?S-1:S).toString()}else if(l.includes("locale")){const S=dr(a,p).weekOfYear;u=K(l.includes("zero")||l.includes("0")?S-1:S)}else{const S=Ae(a).weekOfYear;u=K(l.includes("zero")||l.includes("0")?S-1:S)}break}case"wom":{const S=Math.ceil(a.day/7);u=(l.includes("zero")||l.includes("0")?S-1:S).toString();break}case"yyww":case"yywy":case"yywoy":{const{weekOfYear:S,yearOfWeek:E}=l.includes("locale")?dr(a,p):Ae(a);u=K(E,4)+K(S);break}case"era":{const S=o?.intl?.dateTimeFormat||{};u=be(o?.locale,{timeZone:a.timeZoneId,calendar:a.calendarId,era:S.era??"short"}).formatToParts(a.epochMilliseconds).find(E=>E.type==="era")?.value??"";break}case"eon":u=(a.eraYear??Math.abs(a.year<=0?a.year-1:a.year)).toString();break;case"cen":case"century":u=K(Math.abs(Math.floor(a.year/100)),2);break;case"dim":u=a.daysInMonth.toString();break;case"jj":case"julian":{const S=a.toPlainDate().withCalendar("iso8601");u=(2440588+Math.floor(S.since(Temporal.PlainDate.from("1970-01-01"),{largestUnit:"day"}).days)).toString();break}case"mm":{const S=l.includes("zero")||l.includes("0")?a.month-1:a.month;u=K(S);break}case"mon":u=R.MONTHS.keyOf(a.month);break;case"mmm":u=R.MONTH.keyOf(a.month);break;case"dd":case"day":{if(l.includes("year")){const S=l.includes("zero")||l.includes("0")?a.dayOfYear-1:a.dayOfYear;u=K(S,3)}else if(l.includes("week"))u=l.includes("zero")||l.includes("0")?(a.dayOfWeek%7).toString():a.dayOfWeek.toString();else{const S=l.includes("zero")||l.includes("0")?a.day-1:a.day;u=d==="day"?S.toString():K(S)}break}case"dow":{const S=l.includes("zero")||l.includes("0");if(l.includes("locale")){const v=p.firstDay,w=(a.dayOfWeek-v+7)%7+1;u=(S?w-1:w).toString()}else S?u=(a.dayOfWeek%7).toString():u=a.dayOfWeek.toString();break}case"doy":{const S=l.includes("zero")||l.includes("0")?a.dayOfYear-1:a.dayOfYear;u=K(S,3);break}case"wkd":u=R.WEEKDAYS.keyOf(a.dayOfWeek);break;case"www":u=R.WEEKDAY.keyOf(a.dayOfWeek);break;case"h24":case"hh":{if(l.includes("week"))u=((a.dayOfWeek-1)*24+a.hour).toString();else if(l.includes("locale")&&d==="hh"){const S=p.hourCycle;S==="h12"?u=K(a.hour>12?a.hour%12:a.hour||12):S==="h11"?u=K(a.hour%12):S==="h24"?u=K(a.hour===0?24:a.hour):u=K(a.hour)}else u=K(a.hour);break}case"h12":u=K(a.hour>12?a.hour%12:a.hour||12);break;case"mer":u=a.hour>=12?"pm":"am";break;case"mi":{l.includes("day")?u=(a.hour*60+a.minute).toString():l.includes("week")?u=((a.dayOfWeek-1)*1440+(a.hour*60+a.minute)).toString():u=K(a.minute);break}case"ss":{l.includes("day")?u=(a.hour*3600+a.minute*60+a.second).toString():l.includes("week")?u=((a.dayOfWeek-1)*86400+(a.hour*3600+a.minute*60+a.second)).toString():u=K(a.second);break}case"ms":{l.includes("day")?u=((a.hour*3600+a.minute*60+a.second)*1e3+a.millisecond).toString():u=K(a.millisecond,3);break}case"us":u=K(a.microsecond,3);break;case"ns":{l.includes("day")?u=(BigInt((a.hour*3600+a.minute*60+a.second)*1e3+a.millisecond)*1000000n+BigInt(a.microsecond*1e3+a.nanosecond)).toString():u=K(a.nanosecond,3);break}case"ff":u=`${K(a.millisecond,3)}${K(a.microsecond,3)}${K(a.nanosecond,3)}`;break;case"dmy":case"mdy":case"ymd":{const S=l.includes("short")||l.includes("yy")||l.includes("year"),E=K(S?a.year%100:a.year,S?2:4),v=K(a.month),w=K(a.day);d==="dmy"?u=`${w}${v}${E}`:d==="mdy"?u=`${v}${w}${E}`:u=`${E}${v}${w}`;break}case"hms":u=`${K(a.hour)}${K(a.minute)}${K(a.second)}`;break;case"time":{if(l.includes("locale")){const S=p.hourCycle==="h12"||p.hourCycle==="h11",E=a.hour%12,v=p.hourCycle==="h11"?K(E):p.hourCycle==="h12"?K(E||12):p.hourCycle==="h24"?K(a.hour||24):K(a.hour),w=K(a.minute),D=K(a.second);if(S){const I=o?.intl?.dateTimeFormat??{},A=$s(a.epochMilliseconds,o?.locale,{...I,hour:"numeric",hour12:!0,timeZone:f})||(a.hour>=12?"pm":"am");u=`${v}:${w}:${D} ${A}`}else u=`${v}:${w}:${D}`}else u=`${K(a.hour)}:${K(a.minute)}:${K(a.second)}`;break}case"ts":u=(o?.timeStamp??"ms")==="ss"?Math.trunc(a.epochMilliseconds/1e3).toString():a.epochMilliseconds.toString();break;case"nano":u=a.epochNanoseconds.toString();break;case"tz":u=a.timeZoneId;break;case"cal":u=a.calendarId;break;default:{const S=o?.registry?.tokens??{},E=S[d];if(ce(S,d)&&P(E))u=E(a,{modifiers:c,config:o});else if(d.startsWith("#")&&ae(e)){const v=d.slice(1).split(".")[0],w=ot(v,e.constructor[X]?.()),D=w?.[ge.format];let I;if(P(D)&&(I=D.call(w,d,Fe(e))),!k(I)){const M=e?.term?.[v]?.[ge.format];P(M)&&(I=M.call(e?.term?.[v],d,Fe(e)))}if(k(I)){u=I;break}const A=Fe(e).term[d.slice(1)];u=x(A)?A.label??A.key??`{${d}}`:A??`{${d}}`}else d.includes(".")?d.startsWith("intl.")?u=no({intl:{...p,info:p,locale:p.locale}},d):ae(e)?u=no(e,d):u=`{${d}}`:u=`{${d}}`;break}}if(u===`{${d}}`||c.length===0)return u;let y;if(d.startsWith("#")&&ae(e)){const S=Fe(e).term[d.slice(1)];x(S)?y=String(S.key??S.id??u):k(S)&&(y=String(S))}const b=o?.intl?.dateTimeFormat??{};for(const S of c)switch(S.toLowerCase()){case"lower":u=String(u).toLocaleLowerCase(o?.locale);break;case"upper":u=String(u).toLocaleUpperCase(o?.locale);break;case"title":u=ha(String(u),o?.locale);break;case"ord":case"nth":{const E=parseInt(String(u),10),v=As(o?.locale),w=o?.registry?.locales?.[v]?.ordinal;if(x(w)){const I=Lo(o?.locale,{type:"ordinal"}).select(E);u=`${E}${w[I]??w.other??zs(E)}`}else P(w)?u=w(E):u=zs(E);break}case"raw":Li.test(String(u))&&(u=BigInt(String(u)).toString());break;case"roman":{const E=wl(Number(u));E&&(u=E);break}case"dots":{(d==="mer"||d==="era")&&(u=String(u).replace(Ru,"").split("").join(".")+".");break}case"locale":{try{const E=As(o?.locale),v=o?.registry?.locales?.[E],w=d.replace(_u,"").split("."),D=y??String(u);let I=ro(v,w,D,o?.locale);if(!k(I)&&y&&y!==String(u)&&(I=ro(v,w,String(u),o?.locale)),k(I))u=I;else if(d.startsWith("#")&&ae(e)){const M=d.slice(1).split(".")[0],Z=ot(M,e.constructor[X]());if(Z){let $;const j=(Array.isArray(Z.groups)?Z.groups:x(Z.groups)?Object.values(Z.groups).flat():[]).find(F=>F.key===D);j&&x(j.locale)&&($=j.locale[E]??j.locale.en),k($)&&(u=xn($,o?.locale))}}else{const A={...b,timeZone:a.timeZoneId,calendar:a.calendarId};if(d==="mon")u=be(o?.locale,{...A,month:"long"}).format(a.epochMilliseconds);else if(d==="mmm")u=be(o?.locale,{...A,month:"short"}).format(a.epochMilliseconds);else if(d==="wkd")u=be(o?.locale,{...A,weekday:"long"}).format(a.epochMilliseconds);else if(d==="www")u=be(o?.locale,{...A,weekday:"short"}).format(a.epochMilliseconds);else if(d==="mer"){const M=$s(a.epochMilliseconds,o?.locale,{...b,hour:"numeric",hour12:!0,timeZone:f});M&&(u=M)}}}catch{}break}case"short":case"long":case"shortoffset":case"longoffset":case"shortgeneric":case"longgeneric":{const E=S.toLowerCase();if(d==="tz"){if(!(l.includes("offset")||l.includes("offsetcompact"))){const v={short:"short",long:"long",shortoffset:"shortOffset",longoffset:"longOffset",shortgeneric:"shortGeneric",longgeneric:"longGeneric"};u=be(o?.locale,{...b,timeZone:a.timeZoneId,timeZoneName:v[E]}).formatToParts(a.epochMilliseconds).find(D=>D.type==="timeZoneName")?.value??a.timeZoneId}}else d==="mon"||d==="mmm"?(E==="short"||E==="long")&&(u=be(o?.locale,{...b,timeZone:a.timeZoneId,calendar:a.calendarId,month:E}).format(a.epochMilliseconds)):d==="wkd"||d==="www"?(E==="short"||E==="long")&&(u=be(o?.locale,{...b,timeZone:a.timeZoneId,calendar:a.calendarId,weekday:E}).format(a.epochMilliseconds)):d==="era"&&(E==="short"||E==="long")&&(u=be(o?.locale,{...b,timeZone:a.timeZoneId,calendar:a.calendarId,era:E}).formatToParts(a.epochMilliseconds).find(w=>w.type==="era")?.value??u);break}case"offset":case"offsetcompact":{if(d==="tz"){const E=S.toLowerCase()==="offsetcompact"||l.includes("compact")?"":":",v=a.offset==="+00:00"||a.offset==="-00:00"||a.offset==="Z"||a.offsetNanoseconds===0,w=a.offset.startsWith("-")?"-":"+",D=a.offset.startsWith("+")||a.offset.startsWith("-")?a.offset.slice(1):a.offset==="Z"?"00:00":a.offset,[I="00",A="00",M="00"]=D.split(":");(l.includes("utc")||l.includes("z"))&&v?u="Z":l.includes("hh")||l.includes("hour")?u=`${w}${I}`:l.includes("mi")||l.includes("min")?u=A:l.includes("ss")||l.includes("sec")?u=`${w}${I}${E}${A}${E}${M}`:l.includes("short")?A==="00"&&M==="00"?u=`${w}${I}`:u=`${w}${I}${E}${A}`:u=`${w}${I}${E}${A}`}break}case"compact":(d!=="tz"||!l.includes("offset")&&!l.includes("offsetcompact"))&&(u=String(u).replace(Lu,""));break;case"offsetshort":d==="tz"&&(u=a.offset.endsWith(":00")?a.offset.slice(0,-3):a.offset);break;case"z":d==="tz"&&!l.includes("offset")&&!l.includes("offsetcompact")&&(u=a.offset.endsWith(":00")?a.offset.slice(0,-3):a.offset);break;case"zz":d==="tz"&&(u=a.offset);break;case"zzz":d==="tz"&&(u=a.offset.replace(":",""));break;case"zzzz":d==="tz"&&(u=be(o?.locale,{...b,timeZone:a.timeZoneId,timeZoneName:"short"}).formatToParts(a.epochMilliseconds).find(v=>v.type==="timeZoneName")?.value??a.timeZoneId);break;case"zzzzz":d==="tz"&&(u=be(o?.locale,{...b,timeZone:a.timeZoneId,timeZoneName:"long"}).formatToParts(a.epochMilliseconds).find(v=>v.type==="timeZoneName")?.value??a.timeZoneId);break;case"space":{if(!l.some(E=>Or.test(E)&&E!=="0")){const E=d==="doy"||d==="dd"&&l.includes("year")?3:d==="ss"&&l.includes("day")?5:2,v=String(u);if(to.test(v)){const w=v.startsWith("-")?"-"+BigInt(v.slice(1)).toString():BigInt(v).toString();u=w.startsWith("-")?"-"+w.slice(1).padStart(Math.max(1,E-1)," "):w.padStart(E," ")}}break}case"zero":case"0":case"day":case"week":case"month":case"year":case"cal":break;default:{if(Or.test(S)&&S!=="0"){const E=parseInt(S,10),v=String(u);if(to.test(v))if(d==="ff")u=E>0?v.slice(0,E):v;else if(E>0)if(l.includes("space")){const w=v.startsWith("-")?"-"+BigInt(v.slice(1)).toString():BigInt(v).toString();u=w.startsWith("-")?"-"+w.slice(1).padStart(Math.max(1,E-1)," "):w.padStart(E," ")}else u=v.startsWith("-")?"-"+v.slice(1).padStart(Math.max(1,E-1),"0"):v.padStart(E,"0");else E<0&&(u=v.slice(E))}break}}return l.includes("locale")&&(p.numberingSystem&&p.numberingSystem!=="latn"&&(u=tc(u,p.numberingSystem)),p.direction==="rtl"&&(d==="mon"||d==="mmm"||d==="wkd"||d==="www"||d.startsWith("#")||d==="time")&&(u=nc(u,"rtl"))),u})}const Pu=or("FormatModule",function(e,t){return this.isValid?gi(this,e,t):""});function so(e,t){const{weekOfYear:n}=Ae(e),r=Temporal.PlainDate.from({year:t,month:1,day:4}),s=r.subtract({days:r.dayOfWeek-1}),o=Ae(Temporal.PlainDate.from({year:t,month:12,day:28})).weekOfYear,i=Math.min(n,o),f=s.add({weeks:i-1,days:e.dayOfWeek-1}),a=e.toPlainDate().withCalendar("iso8601"),h=f.since(a).days;return e.add({days:h})}function xt(e,t,n={}){e==="plus"&&(e="add"),(e==="minus"||e==="sub")&&(e="subtract");const r=this[G.$Internal]();if(U(r.mutateDepth)&&(r.mutateDepth=0),!te(r.zdt))return this;const{zdt:s}=r;let o=n.timeZone,i=n.calendar,f=n.sphere;if(e==="set"&&x(t)&&t.constructor===Object){const{timeZone:O,calendar:d,sphere:c}=t;k(O)&&(o=O),k(d)&&(i=d),k(c)&&(f=c)}const a=o??this.tz,h=k(a)&&oe(a)!==this.tz,m={timeZone:a,calendar:i??this.cal,sphere:k(f)?f:h?void 0:r.options?.sphere},g=oe(m.timeZone),p=oe(m.calendar);let T=s.withTimeZone(g).withCalendar(p);r.parseDepth++;const N=Array.isArray(this.parse?.result)?Array.from(this.parse.result):[];try{if(k(t))if(L(t)&&t.startsWith("#")){const O=t.slice(1).split(".")[1],d=e==="add"||e==="subtract"?e:O==="mid"||O==="end"?O:"start",c=At(this.constructor,this,d,t,e==="add"||e==="subtract"?1:t,T);c===null?r.errored=!0:T=c}else if(x(t)&&t.constructor===Object){const O={...t};$a(O),T=Object.entries(O).reduce((d,[c,l])=>{if(c==="timeZone"||c==="calendar"||c==="sphere")return d;try{if(++r.mutateDepth>100)return J(`Infinite recursion detected in mutation engine for key: ${c}, adjust: ${l}, depth: ${r.mutateDepth}`,this.config),r.errored=!0,d;if(e==="set"&&L(l)&&l!=="start"&&l!=="mid"&&l!=="end"){const D={year:"yy",month:"mm",week:"ww",day:"dd",hour:"hh",minute:"mi",second:"ss",millisecond:"ms",microsecond:"us",nanosecond:"ns"}[Xe(c)];if(D)return J(`For relative Slick math, use the '${D}' snippet key instead of '${c}'.`,this.config),r.errored=!0,d}if(e==="set"&&ll.includes(c)&&l!=="start"&&l!=="mid"&&l!=="end"){if(L(l)){let w=q.slickValue;const D=new Set;if(r.config.registry?.modifiers){const j=["+","-","<","<=",">",">=","="],F=new Set;if(j.forEach(z=>{const B=r.config.registry.modifiers[z];B&&H(B).forEach(W=>{F.add(W),(z==="<"||z==="<="||z==="-")&&D.add(W)})}),F.size>0){const z=Array.from(F).map(q.escape);z.sort((W,ee)=>ee.length-W.length);const B=z.join("|");w=new RegExp(`^(?[\\+\\-\\<\\>\\=]=?|${B})?(?-?[0-9]+)?(?[\\w]*)$`)}}const I=l.match(w);if(!I||!I.groups)return J(`Invalid slick syntax '${l}' for key '${c}'.`,this.config),r.errored=!0,d;let{sh_mod:A,sh_nbr:M,sh_unit:Z}=I.groups;if(c==="wkd"){if(!Z)return J("Slick key 'wkd' requires a weekday name (e.g. '>Fri').",this.config),r.errored=!0,d;const j=(A||">")+(M||""),F=At(this.constructor,this,"set",Z,j,d);return F===null&&(r.errored=!0),F??d}if(!A)return J(`Slick math requires a shift operator (e.g. '>', '<') for key '${c}'.`,this.config),r.errored=!0,d;let $=M?Number(M):1;(A==="<"||A==="-"||A==="prev"||A==="last"||D.has(A))&&($=-$);const C={yy:"years",mm:"months",ww:"weeks",dd:"days",hh:"hours",mi:"minutes",ss:"seconds",ms:"milliseconds",us:"microseconds",ns:"nanoseconds"};return d.add({[C[c]]:$})}else if(c==="wkd")return J("Slick key 'wkd' requires a weekday name (e.g. '>Fri').",this.config),r.errored=!0,d}const{mutate:u,offset:y,single:b,term:S}=((w,D,I)=>{const A=w.startsWith("#");if(I==="add"||I==="subtract"){const M=!A&&k(ot(w,r)),Z=["period","event","time","date","dow","wkd"].includes(w),$=A||M&&!Z,C=In(D),j=w==="isoYear"||w==="isoyear"||w==="yw"||w==="yow",F=w==="isoWeek"||w==="isoweek"||w==="wy"||w==="woy";return{mutate:$?I:"add",offset:I==="subtract"&&!$&&V(C)?-C:C,single:$?"term":j?"yw":F?"isoweek":Xe(w),term:A||M?w:void 0}}if(I==="set"&&L(D)&&(D==="start"||D==="mid"||D==="end")){const M=w==="isoYear"||w==="isoyear"||w==="yw"||w==="yow",Z=w==="isoWeek"||w==="isoweek"||w==="wy"||w==="woy",$=M?"yw":Z?"isoweek":R.ELEMENT.has(w)?R.ELEMENT[w]:w,C=$.startsWith("#"),j=!C&&k(ot($,r)),F=["period","event","time","date","dow","wkd"].includes($);return{mutate:D,offset:D,single:C||j&&!F?"term":M?"yw":Z?"isoweek":Xe($),term:C||j?$:void 0}}switch(w){case"start":case"mid":case"end":{const M=D?.toString()??"",Z=M==="isoYear"||M==="isoyear"||M==="yw"||M==="yow",$=M==="isoWeek"||M==="isoweek"||M==="wy"||M==="woy",C=Z?"yw":$?"isoweek":R.ELEMENT.has(M)?R.ELEMENT[M]:M,j=C.startsWith("#"),F=!j&&k(ot(C,r)),z=["period","event","time","date","dow","wkd"].includes(C);return{mutate:w,offset:M,single:j||F&&!z?"term":Z?"yw":$?"isoweek":Xe(C),term:j||F?C:void 0}}default:{const M=!A&&k(ot(w,r)),Z=["period","event","time","date","dow","wkd"].includes(w);return{mutate:"set",offset:D,single:A||M&&!Z?"term":w==="isoYear"||w==="isoyear"||w==="yw"||w==="yow"?"yw":w==="isoWeek"||w==="isoweek"||w==="wy"||w==="woy"?"isoweek":Xe(w),term:A||M?w:void 0}}}})(c,l,e);if(b==="term"){const w=At(this.constructor,this,u,S,l,d);return w===null&&(r.errored=!0),w??d}const E=`${u}:${b}`,v=(w,D)=>{const I=this.constructor.from(w,{...this.config,anchor:D});if(I.isValid)return N.push(...I.parse.result),I.toDateTime()};switch(E){case"add:year":case"add:month":case"add:week":case"add:day":case"add:hour":case"add:minute":case"add:second":case"add:millisecond":case"add:microsecond":case"add:nanosecond":case"add:isoweek":return d.add({[`${b==="isoweek"?"week":b}s`]:y});case"add:yy":case"add:mm":case"add:dd":case"add:hh":case"add:mi":case"add:ss":case"add:ms":case"add:us":case"add:ns":case"add:wy":case"add:woy":case"add:ww":{const w=R.ELEMENT[b];return d.add({[`${w}s`]:y})}case"add:yw":case"add:yow":{const w=In(y);if(!V(w)||!Number.isFinite(w))return J(`Unexpected method(${u}), unit(${c}) and offset(${l})`,this.config),r.errored=!0,d;const{yearOfWeek:D}=Ae(d);return so(d,D+Math.trunc(w))}case"set:period":case"set:time":case"set:date":case"set:event":case"set:dow":case"set:wkd":{const w=v(y,d);return U(w)&&(r.errored=!0),w??d}case"set:year":case"set:month":case"set:day":case"set:hour":case"set:minute":case"set:second":case"set:millisecond":case"set:microsecond":case"set:nanosecond":return d.with({[b]:y});case"set:yy":case"set:mm":case"set:dd":case"set:hh":case"set:mi":case"set:ss":case"set:ms":case"set:us":case"set:ns":{const w=R.ELEMENT[b];return d.with({[w]:y})}case"set:yw":case"set:yow":{const w=In(y);return!V(w)||!Number.isFinite(w)?(J(`Unexpected method(${u}), unit(${c}) and offset(${l})`,this.config),r.errored=!0,d):so(d,Math.trunc(w))}case"set:isoweek":{const w=In(y);if(!V(w)||!Number.isFinite(w)||w<1)return J(`Unexpected method(${u}), unit(${c}) and offset(${l})`,this.config),r.errored=!0,d;const D=Math.trunc(w),{weekOfYear:I,yearOfWeek:A}=Ae(d),M=Ae(Temporal.PlainDate.from({year:A,month:12,day:28})).weekOfYear,Z=Math.min(D,M);return d.add({weeks:Z-I})}case"start:year":return d.with({month:R.MONTH.Jan,day:1}).startOfDay();case"start:yw":case"start:yow":{const{yearOfWeek:w}=Ae(d),D=Temporal.PlainDate.from({year:w,month:1,day:4}),I=D.subtract({days:D.dayOfWeek-1}),A=d.toPlainDate().withCalendar("iso8601");return d.add({days:I.since(A).days}).startOfDay()}case"start:month":return d.with({day:1}).startOfDay();case"start:isoweek":case"start:wy":case"start:woy":return d.add({days:-(d.dayOfWeek-R.WEEKDAY.Mon)}).startOfDay();case"start:week":{if(!r.config.localeInfo)return d.add({days:-(d.dayOfWeek-R.WEEKDAY.Mon)}).startOfDay();const w=(d.dayOfWeek-this.intl.info.firstDay+7)%7;return d.subtract({days:w}).startOfDay()}case"start:day":return d.startOfDay();case"start:hour":case"start:minute":case"start:second":case"start:millisecond":case"start:microsecond":case"start:nanosecond":return d.round({smallestUnit:R.ELEMENT[b]??b,roundingMode:"trunc"});case"mid:year":return d.with({month:R.MONTH.Jul,day:1}).startOfDay();case"mid:yw":case"mid:yow":{const{yearOfWeek:w}=Ae(d),D=Temporal.PlainDate.from({year:w,month:1,day:4}),A=D.subtract({days:D.dayOfWeek-1}).add({weeks:25,days:3}),M=d.toPlainDate().withCalendar("iso8601");return d.add({days:A.since(M).days}).startOfDay()}case"mid:month":return d.with({day:Math.trunc(d.daysInMonth/2)}).startOfDay();case"mid:isoweek":case"mid:wy":case"mid:woy":return d.add({days:-(d.dayOfWeek-R.WEEKDAY.Thu)}).startOfDay();case"mid:week":{if(!r.config.localeInfo)return d.add({days:-(d.dayOfWeek-R.WEEKDAY.Thu)}).startOfDay();const w=(d.dayOfWeek-this.intl.info.firstDay+7)%7;return d.subtract({days:w}).startOfDay().add({days:3})}case"mid:day":return d.round({smallestUnit:"day",roundingMode:"trunc"}).add({hours:12});case"mid:hour":return d.round({smallestUnit:"hour",roundingMode:"trunc"}).add({minutes:30});case"mid:minute":return d.round({smallestUnit:"minute",roundingMode:"trunc"}).add({seconds:30});case"mid:second":return d.round({smallestUnit:"second",roundingMode:"trunc"}).add({milliseconds:500});case"mid:millisecond":return d.round({smallestUnit:"millisecond",roundingMode:"trunc"}).add({microseconds:500});case"mid:microsecond":return d.round({smallestUnit:"microsecond",roundingMode:"trunc"}).add({nanoseconds:500});case"mid:nanosecond":return d;case"end:year":return d.add({years:1}).with({month:R.MONTH.Jan,day:1}).startOfDay().subtract({nanoseconds:1});case"end:yw":case"end:yow":{const{yearOfWeek:w}=Ae(d),D=Temporal.PlainDate.from({year:w+1,month:1,day:4}),I=D.subtract({days:D.dayOfWeek-1}),A=d.toPlainDate().withCalendar("iso8601");return d.add({days:I.since(A).days}).startOfDay().subtract({nanoseconds:1})}case"end:month":return d.add({months:1}).with({day:1}).startOfDay().subtract({nanoseconds:1});case"end:isoweek":case"end:wy":case"end:woy":return d.add({days:R.WEEKDAY.Sun-d.dayOfWeek+1}).startOfDay().subtract({nanoseconds:1});case"end:week":{if(!r.config.localeInfo)return d.add({days:R.WEEKDAY.Sun-d.dayOfWeek+1}).startOfDay().subtract({nanoseconds:1});const w=(d.dayOfWeek-this.intl.info.firstDay+7)%7;return d.subtract({days:w}).startOfDay().add({days:7}).subtract({nanoseconds:1})}case"end:day":case"end:hour":case"end:minute":case"end:second":case"end:millisecond":case"end:microsecond":{const w=R.ELEMENT[b]??b,D=`${w}s`;return d.round({smallestUnit:w,roundingMode:"trunc"}).add({[D]:1}).subtract({nanoseconds:1})}case"end:nanosecond":return d;default:return J(`Unexpected method(${u}), unit(${c}) and offset(${l})`,this.config),r.errored=!0,d}}finally{r.mutateDepth--}},T)}else return new this.constructor(t,{...r.options,...this.config,...n,anchor:T,[G.$Internal]:{...r,matches:N}});return r.errored?new this.constructor(null,{...r.options,...m,...n,[G.$Internal]:{...r,matches:N}}):(N.push({type:"Mutation",value:T,match:"mutation"}),new this.constructor(T,{...r.options,...m,...n,anchor:T,[G.$Internal]:{...r,matches:N}}))}finally{r.parseDepth--}}const xu={add(e,t={}){return xt.call(this,"add",e,t)},plus(e,t={}){return xt.call(this,"add",e,t)},subtract(e,t={}){return xt.call(this,"subtract",e,t)},sub(e,t={}){return xt.call(this,"subtract",e,t)},minus(e,t={}){return xt.call(this,"subtract",e,t)},set(e,t={}){return xt.call(this,"set",e,t)}},zu=or("MutateModule",xu);function fs(e){return R.ELEMENT.has(e)?`${R.ELEMENT[e]}s`:void 0}function tr(e,t={}){const n=Do(e).reduce((r,s)=>Object.assign(r,ko({[s]:e[s]})),{iso:e.toString(),sign:e.sign,blank:e.blank,unit:void 0});return Object.defineProperty(n,"balance",{value:function(r={}){const{nominal:s,largestUnit:o="year",relativeTo:i}=r;if(s){let{years:m,months:g,weeks:p,days:T,hours:N,minutes:O,seconds:d,milliseconds:c,microseconds:l,nanoseconds:u}=e,y=T+p*7+g*30+m*365;m=Math.trunc(y/365),y-=m*365,g=Math.trunc(y/30),y-=g*30,p=Math.trunc(y/7),y-=p*7,T=y;const b=Temporal.Duration.from({years:m,months:g,weeks:p,days:T,hours:N,minutes:O,seconds:d,milliseconds:c,microseconds:l,nanoseconds:u,sign:e.sign});return tr(b,{...t,relativeTo:i||t.relativeTo})}const f=i||t.relativeTo;if(!f)throw new pt("A relativeTo anchor is required for strict balancing. Pass an anchor or use { nominal: true } for mathematical balancing.");const a=fs(o)??o,h=e.round({largestUnit:a,relativeTo:f});return tr(h,{...t,relativeTo:f})},enumerable:!1}),Object.defineProperty(n,"format",{value:function(r={}){const{locales:s,...o}=r,i=s||t.locale;if(P(t.durationFormat))return t.durationFormat(this);if(Se(Intl,"DurationFormat","function"))return ic(this,i,{...t.durationFormat||{},...o});const f=["years","months","weeks","days","hours","minutes","seconds","milliseconds","microseconds","nanoseconds"],a=[];for(const h of f){const m=this[h];if(m){const g=Xe(h);a.push(ac(m,i,{style:"unit",unit:g,unitDisplay:"long",...t.numberFormat||{}}))}}return a.length===0?"0":oc(a,i,"conjunction","long")},enumerable:!1}),n}function yi(e,t,n){const r=e==="since";let s,o={},i;switch(!0){case(L(t)&&(R.ELEMENT.values().includes(Xe(t))||R.ELEMENT.has(t))):i=t,{value:s,...o}=n||{};break;case L(t):s=t,x(n)?{unit:i,...o}=n:i=n;break;case(x(t)&&ae(t)):s=t.toDateTime(),x(n)?{unit:i,...o}=n:i=n;break;case(x(t)&&x(n)):({value:s,unit:i,...o}=Object.assign({value:t},n));break;case L(n):i=n,s=t;break;case x(n):({unit:i,...o}=n),s=t;break;case(x(t)&&k(t.unit)):({unit:i,value:s,...o}=t);break;default:s=t}const f=this.toDateTime(),a=new this.constructor(s,{...o,anchor:this,mode:R.MODE.Strict}),h=a.toDateTime(),[m,g]=Pe(f),[p]=Pe(h);if(L(i)&&i.startsWith("#")){const[d]=i.slice(1).split("."),c=ot(d,this[G.$Internal]?.());if(c&&P(c[ge.diff])){const l=ae(a)?a:new this.constructor(h,this.config),u=c[ge.diff](l,i,this);if(k(u))return r?`${u} ${i}`:u}}let T=i;k(T)&&(T=fs(T)??`${Xe(T)}s`);const N=m!==p,O=f.until(h.withCalendar(g),{largestUnit:N?"hours":T??"years"});if(k(i)&&(i=T),U(i)||r){const d=this?.config?.locale,c=o.intl?.numberFormat||this?.config?.intl?.numberFormat,l=o.intl?.durationFormat||this?.config?.intl?.durationFormat,u=tr(O,{relativeTo:f,locale:d,numberFormat:c,durationFormat:l});if(i&&(u.unit=i),!r)return u;const y=[O.years,O.months,O.days],b=[O.hours,O.minutes,O.seconds],S=[O.milliseconds,O.microseconds,O.nanoseconds].map(Math.abs).map(A=>A.toString().padStart(3,"0")).join(""),E=this.config.intl?.relativeTimeFormat,v=o.intl?.relativeTimeFormat,w=(P(v)?v:v?.format)||(P(E)?E:E?.format)||o.rtfFormat||this.config.rtfFormat,D=(A,M,Z)=>v?.[A]||E?.[A]||o[M]||this.config[M]||Z,I=(A,M)=>{const Z=Xe(M);if(P(w))return w(A,Z);if(w instanceof Intl.RelativeTimeFormat)return w.format(A,Z);const $=D("style","rtfStyle","narrow"),C=D("numeric","rtfNumeric","always");return sc(A,Z,d,$,C)};switch(u.unit){case"years":return I(y[0],u.unit);case"months":return I(y[1],u.unit);case"weeks":return I(u.weeks,u.unit);case"days":return I(y[2],u.unit);case"hours":return I(b[0],u.unit);case"minutes":return I(b[1],u.unit);case"seconds":return I(b[2],u.unit);case"milliseconds":case"microseconds":case"nanoseconds":return`${S}`;default:return O.toString()}}return O.total({relativeTo:f,unit:i})}yi.toDuration=(e,t)=>{let n=e;if(x(e)){n={...e};for(const[s,o]of Object.entries(e)){const i=fs(s);i&&(n[i]=o,delete n[s])}}const r=Temporal.Duration.from(n);return tr(r,t)};const Fu=or("DurationModule",yi,{duration(e){const t={locale:this.config?.locale,numberFormat:this.config?.intl?.numberFormat,durationFormat:this.config?.intl?.durationFormat};return wt(this,"DurationModule","toDuration",!1,e,t)}}),wi=ir([{key:"Q1",day:1,month:1,fiscal:0,sphere:Ie.North,label:"First Quarter"},{key:"Q2",day:1,month:4,fiscal:0,sphere:Ie.North,label:"Second Quarter"},{key:"Q3",day:1,month:7,fiscal:0,sphere:Ie.North,label:"Third Quarter"},{key:"Q4",day:1,month:10,fiscal:0,sphere:Ie.North,label:"Fourth Quarter"},{key:"Q1",day:1,month:7,fiscal:1,sphere:Ie.South,label:"First Quarter"},{key:"Q2",day:1,month:10,fiscal:1,sphere:Ie.South,label:"Second Quarter"},{key:"Q3",day:1,month:1,year:1,fiscal:0,sphere:Ie.South,label:"Third Quarter"},{key:"Q4",day:1,month:4,year:1,fiscal:0,sphere:Ie.South,label:"Fourth Quarter"}],"sphere");function oo(e,t){if(e.sphere===void 0&&t?.sphere===void 0)return je("[tempo] QuarterTerm requires 'sphere' configuration (e.g. Tempo.init({ sphere: 'north' }) or { sphere: 'south' }).",e.config),[];const n=ar(e,wi,{anchor:t,groupBy:["sphere"]});return n.forEach(r=>{V(r.fiscal)&&(r.fiscal+=V(r.year)?r.year:0)}),n}const Wu=En({key:"qtr",scope:"quarter",description:"Fiscal Quarter",groups:wi,resolve(e){return oo(this,e)},define(e,t){const n=oo(this,t);return $e(this,H(n),e,t)},[ge.ordinal](e,t){return rs(this,e,t)},[ge.diff](e,t,n){return cr(this,e,t,n)},[ge.format](e,t){return Dn(this,e,t)}}),bi=ir([{key:"Spring",day:1,month:3,symbol:"Flower",group:"meteorological",sphere:Ie.North},{key:"Summer",day:1,month:6,symbol:"Sun",group:"meteorological",sphere:Ie.North},{key:"Autumn",day:1,month:9,symbol:"Leaf",group:"meteorological",sphere:Ie.North},{key:"Winter",day:1,month:12,symbol:"Snowflake",group:"meteorological",sphere:Ie.North},{key:"Spring",day:1,month:9,symbol:"Flower",group:"meteorological",sphere:Ie.South},{key:"Summer",day:1,month:12,symbol:"Sun",group:"meteorological",sphere:Ie.South},{key:"Autumn",day:1,month:3,symbol:"Leaf",group:"meteorological",sphere:Ie.South},{key:"Winter",day:1,month:6,symbol:"Snowflake",group:"meteorological",sphere:Ie.South}],"group","sphere");function io(e,t){return e.sphere===void 0&&t?.sphere===void 0?(je("[tempo] SeasonTerm requires 'sphere' configuration (e.g. Tempo.init({ sphere: 'north' }) or { sphere: 'south' }).",e.config),[]):ar(e,bi,{anchor:t,groupBy:["group","sphere"],group:"meteorological"})}const ju=En({key:"szn",scope:"season",description:"Meteorological season",groups:bi,resolve(e){return io(this,e)},define(e,t){return $e(this,io(this,t),e,t)},[ge.ordinal](e,t){return rs(this,e,t)},[ge.diff](e,t,n){return cr(this,e,t,n)},[ge.format](e,t){return Dn(this,e,t)}}),Si=ir([{key:"Aries",day:21,month:3,symbol:"Ram",emoji:"♈",trait:"Daring and energetic, a natural leader",group:"western"},{key:"Taurus",day:20,month:4,symbol:"Bull",emoji:"♉",trait:"Reliable and patient, enjoys luxury",group:"western"},{key:"Gemini",day:21,month:5,symbol:"Twins",emoji:"♊",trait:"Adaptable and intellectual, great communicator",group:"western"},{key:"Cancer",day:21,month:6,symbol:"Crab",emoji:"♋",trait:"Protective and intuitive, deeply emotional",group:"western"},{key:"Leo",day:23,month:7,symbol:"Lion",emoji:"♌",trait:"Confident and ambitious, loves being center stage",group:"western"},{key:"Virgo",day:23,month:8,symbol:"Virgin",emoji:"♍",trait:"Analytical and practical, meticulous and kind",group:"western"},{key:"Libra",day:23,month:9,symbol:"Scales",emoji:"♎",trait:"Diplomatic and fair, values harmony",group:"western"},{key:"Scorpio",day:23,month:10,symbol:"Scorpion",emoji:"♏",trait:"Passionate and resourceful, dynamic and brave",group:"western"},{key:"Sagittarius",day:22,month:11,symbol:"Archer",emoji:"♐",trait:"Optimistic and free-spirited, loves travel",group:"western"},{key:"Capricorn",day:22,month:12,symbol:"Goat",emoji:"♑",trait:"Disciplined and persistent, highly practical",group:"western"},{key:"Aquarius",day:20,month:1,symbol:"Water Bearer",emoji:"♒",trait:"Original and humanitarian, values independence",group:"western"},{key:"Pisces",day:19,month:2,symbol:"Fish",emoji:"♓",trait:"Compassionate and artistic, deeply intuitive",group:"western"}],"group");function ao(e,t){return ar(e,Si,{anchor:t,groupBy:["group"],group:"western"})}const Zu=En({key:"zdc",scope:"zodiac",aliases:["sunSign","starSign"],description:"Astrological Western Tropical Zodiac sign",groups:Si,resolve(e){return ao(this,e)},define(e,t){return $e(this,ao(this,t),e,t)},[ge.ordinal](e,t){return rs(this,e,t)},[ge.diff](e,t,n){return cr(this,e,t,n)},[ge.format](e,t){return Dn(this,e,t)}});function Uu(e){const t=["Rat","Ox","Tiger","Rabbit","Dragon","Snake","Horse","Goat","Monkey","Rooster","Dog","Pig"],n=["Wood","Fire","Earth","Metal","Water"],r=((e-4)%12+12)%12,s=Math.floor(((e-4)%10+10)%10/2),o=e%2===0?"Yang":"Yin";return{animal:t[r],element:n[s],yinYang:o}}const Bu={Rat:{cn:{animal:"Rat",emoji:"🐀",character:"鼠",romanized:"Shǔ"},jp:{animal:"Rat",emoji:"🐀",character:"子",romanized:"Ne"},kr:{animal:"Rat",emoji:"🐀",character:"쥐",romanized:"Jwi"},vn:{animal:"Rat",emoji:"🐀",character:"Tý / Chuột"}},Ox:{cn:{animal:"Ox",emoji:"🐂",character:"牛",romanized:"Niú"},jp:{animal:"Ox",emoji:"🐂",character:"丑",romanized:"Ushi"},kr:{animal:"Ox",emoji:"🐂",character:"소",romanized:"So"},vn:{animal:"Water Buffalo",emoji:"🐃",character:"Sửu / Trâu"}},Tiger:{cn:{animal:"Tiger",emoji:"🐅",character:"虎",romanized:"Hǔ"},jp:{animal:"Tiger",emoji:"🐅",character:"寅",romanized:"Tora"},kr:{animal:"Tiger",emoji:"🐅",character:"호랑이",romanized:"Horangi"},vn:{animal:"Tiger",emoji:"🐅",character:"Dần / Hổ"}},Rabbit:{cn:{animal:"Rabbit",emoji:"🐇",character:"兔",romanized:"Tù"},jp:{animal:"Rabbit",emoji:"🐇",character:"卯",romanized:"Usagi"},kr:{animal:"Rabbit",emoji:"🐇",character:"토끼",romanized:"Tokki"},vn:{animal:"Cat",emoji:"🐈",character:"Mão / Mèo"}},Dragon:{cn:{animal:"Dragon",emoji:"🐉",character:"龙",romanized:"Lóng"},jp:{animal:"Dragon",emoji:"🐉",character:"辰",romanized:"Tatsu"},kr:{animal:"Dragon",emoji:"🐉",character:"용",romanized:"Yong"},vn:{animal:"Dragon",emoji:"🐉",character:"Thìn / Rồng"}},Snake:{cn:{animal:"Snake",emoji:"🐍",character:"蛇",romanized:"Shé"},jp:{animal:"Snake",emoji:"🐍",character:"巳",romanized:"Mi"},kr:{animal:"Snake",emoji:"🐍",character:"뱀",romanized:"Baem"},vn:{animal:"Snake",emoji:"🐍",character:"Tỵ / Rắn"}},Horse:{cn:{animal:"Horse",emoji:"🐎",character:"马",romanized:"Mǎ"},jp:{animal:"Horse",emoji:"🐎",character:"午",romanized:"Uma"},kr:{animal:"Horse",emoji:"🐎",character:"말",romanized:"Mal"},vn:{animal:"Horse",emoji:"🐎",character:"Ngọ / Ngựa"}},Goat:{cn:{animal:"Goat",emoji:"🐐",character:"羊",romanized:"Yáng"},jp:{animal:"Sheep",emoji:"🐑",character:"未",romanized:"Hitsuji"},kr:{animal:"Sheep",emoji:"🐑",character:"양",romanized:"Yang"},vn:{animal:"Goat",emoji:"🐐",character:"Mùi / Dê"}},Monkey:{cn:{animal:"Monkey",emoji:"🐒",character:"猴",romanized:"Hóu"},jp:{animal:"Monkey",emoji:"🐒",character:"申",romanized:"Saru"},kr:{animal:"Monkey",emoji:"🐒",character:"원숭이",romanized:"Wonsungi"},vn:{animal:"Monkey",emoji:"🐒",character:"Thân / Khỉ"}},Rooster:{cn:{animal:"Rooster",emoji:"🐓",character:"鸡",romanized:"Jī"},jp:{animal:"Rooster",emoji:"🐓",character:"酉",romanized:"Tori"},kr:{animal:"Rooster",emoji:"🐓",character:"닭",romanized:"Dak"},vn:{animal:"Rooster",emoji:"🐓",character:"Dậu / Gà"}},Dog:{cn:{animal:"Dog",emoji:"🐕",character:"狗",romanized:"Gǒu"},jp:{animal:"Dog",emoji:"🐕",character:"戌",romanized:"Inu"},kr:{animal:"Dog",emoji:"🐕",character:"개",romanized:"Gae"},vn:{animal:"Dog",emoji:"🐕",character:"Tuất / Chó"}},Pig:{cn:{animal:"Pig",emoji:"🐖",character:"猪",romanized:"Zhū"},jp:{animal:"Wild Boar",emoji:"🐗",character:"亥",romanized:"Inoshishi"},kr:{animal:"Pig",emoji:"🐖",character:"돼지",romanized:"Dwaeji"},vn:{animal:"Pig",emoji:"🐖",character:"Hợi / Heo"}}},Yu={Rat:"🐀",Ox:"🐂",Tiger:"🐅",Rabbit:"🐇",Dragon:"🐉",Snake:"🐍",Horse:"🐎",Goat:"🐐",Monkey:"🐒",Rooster:"🐓",Dog:"🐕",Pig:"🐖"};function co(e,t){const n=t??e,r=t?.year??n.yy,s=Uu(r),o=s.animal,i=Yu[o]??"🐉",f=Bu[o]??{cn:{animal:o,emoji:i},jp:{animal:o,emoji:i},kr:{animal:o,emoji:i},vn:{animal:o,emoji:i}},a=n.config?.locale??n.locale;let h=o,m=i;if(a){const d=String(a).toLowerCase();d.startsWith("ja")||d==="jp"?(h=f.jp.animal,m=f.jp.emoji):d.startsWith("vi")||d==="vn"?(h=f.vn.animal,m=f.vn.emoji):d.startsWith("ko")||d==="kr"?(h=f.kr.animal,m=f.kr.emoji):(d.startsWith("zh")||d==="cn")&&(h=f.cn.animal,m=f.cn.emoji)}const g=n.tz??"UTC",p=new e.constructor(`${r}-01-01T00:00:00`,{timeZone:g}),T=r+1,N=new e.constructor(`${T}-01-01T00:00:00`,{timeZone:g}),O=p.toDateTime();return{key:h,animal:o,emoji:m,element:s.element,yinYang:s.yinYang,variants:f,group:"lunar-zodiac",year:r,month:O.month,day:O.day,hour:O.hour,minute:O.minute,second:O.second,millisecond:O.millisecond,microsecond:O.microsecond,nanosecond:O.nanosecond,start:p,end:N}}const Ku=En({key:"sign",scope:"shengxiao",aliases:["lunarSign","eastern"],description:"Eastern Lunar Zodiac cycle and regional variants",resolve(e){return[co(this,e)]},define(e,t){const n=co(this,t);return e===!0||e===void 0?n.key:n},[ge.format](e,t){return Dn(this,e,t)}}),Ti=ir([{key:"Midnight",locale:{fr:"Minuit",es:"Medianoche",de:"Mitternacht"},hour:0,group:"standard"},{key:"Early",locale:{fr:"Tôt",es:"Temprano",de:"Früh"},hour:4,group:"standard"},{key:"Morning",locale:{fr:"Matin",es:"Mañana",de:"Morgen"},hour:8,group:"standard"},{key:"Midmorning",locale:{fr:"Milieu de la matinée",es:"Media mañana",de:"Vormittag"},hour:10,group:"standard"},{key:"Midday",locale:{fr:"Midi",es:"Mediodía",de:"Mittag"},hour:12,group:"standard"},{key:"Afternoon",locale:{fr:"Après-midi",es:"Tarde",de:"Nachmittag"},hour:15,minute:30,group:"standard"},{key:"Evening",locale:{fr:"Soir",es:"Noche",de:"Abend"},hour:18,group:"standard"},{key:"Night",locale:{fr:"Nuit",es:"Noche",de:"Nacht"},hour:20,group:"standard"}],"group");function lo(e,t){return ar(e,Ti,{anchor:t,groupBy:["group"],group:"standard"})}const Gu=En({key:"tod",scope:"timeOfDay",description:"Daily time period",groups:Ti,resolve(e){return lo(this,e)},define(e,t){return $e(this,lo(this,t),e,t)},[ge.format](e,t){return Dn(this,e,t)}}),uo=[Wu,ju,Zu,Ku,Gu];function Qu(e){return e}const Hu=qo({name:"TermsModule",install(e){se().modules.TermsModule=!0,us(()=>{e.use(uo)}),e.use(uo)}}),Oi=[Ou,Pu,zu,Fu,Hu];se().modules.Tempo=it;us(()=>{se().modules.Tempo=it,it.use(Oi)});it.use(Oi);const Rn=se().modules.$pendingAutoInstalls;Array.isArray(Rn)&&Rn.length>0&&(it.use(Rn),Rn.length=0);export{mc as Interval,it as Tempo,ge as TermHook,Hu as TermsModule,it as default,Qu as defineConfig,R as enums,qu as fmtTempo,gi as format,Ju as getStamp,Vu as getTempo,Xu as parse}; diff --git a/packages/tempo/public/v4/assets/chunks/theme.BHijFyhG.js b/packages/tempo/public/v4/assets/chunks/theme.BHijFyhG.js new file mode 100644 index 00000000..b1190edf --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/theme.BHijFyhG.js @@ -0,0 +1,292 @@ +const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/chunks/VPLocalSearchBox.0TnTKVFI.js","assets/chunks/framework.DNL3hc5c.js"])))=>i.map(i=>d[i]); +import{d as x,c as i,r as m,n as L,o as r,a as N,t as k,b as w,w as h,T as ce,e as f,_ as S,u as ke,i as Ne,f as Ae,g as Z,h as b,j as s,k as l,l as Y,m as ne,p as P,q as O,s as K,v as B,x as de,y as me,z as Fe,A as Oe,F as H,B as D,C as W,D as J,E as _,G as be,H as A,I as _e,J as X,K as U,L as ee,M as Ee,N as q,O as se,P as we,Q as Se,R as te,S as ze,U as Ue,V as Be,W as $e,X as Me,Y as Ye,Z as We,$ as Ze,a0 as Re,a1 as qe,a2 as Pe,a3 as Ge,a4 as Qe}from"./framework.DNL3hc5c.js";const je=x({__name:"VPBadge",props:{text:{},type:{default:"tip"}},setup(e){return(t,o)=>(r(),i("span",{class:L(["VPBadge",e.type])},[m(t.$slots,"default",{},()=>[N(k(e.text),1)])],2))}}),Ke={key:0,class:"VPBackdrop"},Je=x({__name:"VPBackdrop",props:{show:{type:Boolean}},setup(e){return(t,o)=>(r(),w(ce,{name:"fade"},{default:h(()=>[e.show?(r(),i("div",Ke)):f("",!0)]),_:1}))}}),Xe=S(Je,[["__scopeId","data-v-32d0349a"]]),M=ke;function et(e,t){let o,a=!1;return()=>{o&&clearTimeout(o),a?o=setTimeout(e,t):(e(),(a=!0)&&setTimeout(()=>a=!1,t))}}function re(e){return e.startsWith("/")?e:`/${e}`}function pe(e){const{pathname:t,search:o,hash:a,protocol:n}=new URL(e,"http://a.com");if(Ne(e)||e.startsWith("#")||!n.startsWith("http")||!Ae(t))return e;const{site:c}=M(),d=t.endsWith("/")||t.endsWith(".html")?e:e.replace(/(?:(^\.+)\/)?.*$/,`$1${t.replace(/(\.md)?$/,c.value.cleanUrls?"":".html")}${o}${a}`);return Z(d)}function G({correspondingLink:e=!1}={}){const{site:t,localeIndex:o,page:a,theme:n,hash:c}=M(),d=b(()=>({label:t.value.locales[o.value]?.label,link:t.value.locales[o.value]?.link||(o.value==="root"?"/":`/${o.value}/`)}));return{localeLinks:b(()=>Object.entries(t.value.locales).flatMap(([u,v])=>d.value.label===v.label?[]:{text:v.label,link:tt(v.link||(u==="root"?"/":`/${u}/`),n.value.i18nRouting!==!1&&e,a.value.relativePath.slice(d.value.link.length-1),!t.value.cleanUrls)+c.value})),currentLang:d}}function tt(e,t,o,a){return t?e.replace(/\/$/,"")+re(o.replace(/(^|\/)index\.md$/,"$1").replace(/\.md$/,a?".html":"")):e}const ot={class:"NotFound"},at={class:"code"},nt={class:"title"},st={class:"quote"},rt={class:"action"},it=["href","aria-label"],lt=x({__name:"NotFound",setup(e){const{theme:t}=M(),{currentLang:o}=G();return(a,n)=>(r(),i("div",ot,[s("p",at,k(l(t).notFound?.code??"404"),1),s("h1",nt,k(l(t).notFound?.title??"PAGE NOT FOUND"),1),n[0]||(n[0]=s("div",{class:"divider"},null,-1)),s("blockquote",st,k(l(t).notFound?.quote??"But if you don't change your direction, and if you keep looking, you may end up where you are heading."),1),s("div",rt,[s("a",{class:"link",href:l(Z)(l(o).link),"aria-label":l(t).notFound?.linkLabel??"go to home"},k(l(t).notFound?.linkText??"Take me home"),9,it)])]))}}),ct=S(lt,[["__scopeId","data-v-9e9fbb1e"]]);function Te(e,t){if(Array.isArray(e))return Q(e);if(e==null)return[];t=re(t);const o=Object.keys(e).sort((n,c)=>c.split("/").length-n.split("/").length).find(n=>t.startsWith(re(n))),a=o?e[o]:[];return Array.isArray(a)?Q(a):Q(a.items,a.base)}function dt(e){const t=[];let o=0;for(const a in e){const n=e[a];if(n.items){o=t.push(n);continue}t[o]||t.push({items:[]}),t[o].items.push(n)}return t}function mt(e){const t=[];function o(a){for(const n of a)n.text&&n.link&&t.push({text:n.text,link:n.link,docFooterText:n.docFooterText}),n.items&&o(n.items)}return o(e),t}function ie(e,t){return Array.isArray(t)?t.some(o=>ie(e,o)):Y(e,t.link)?!0:t.items?ie(e,t.items):!1}function Q(e,t){return[...e].map(o=>{const a={...o},n=a.base||t;return n&&a.link&&(a.link=n+a.link),a.items&&(a.items=Q(a.items,n)),a})}function E(){const{frontmatter:e,page:t,theme:o}=M(),a=ne("(min-width: 960px)"),n=P(!1),c=b(()=>{const C=o.value.sidebar,V=t.value.relativePath;return C?Te(C,V):[]}),d=P(c.value);O(c,(C,V)=>{JSON.stringify(C)!==JSON.stringify(V)&&(d.value=c.value)});const p=b(()=>e.value.sidebar!==!1&&d.value.length>0&&e.value.layout!=="home"),u=b(()=>v?e.value.aside==null?o.value.aside==="left":e.value.aside==="left":!1),v=b(()=>e.value.layout==="home"?!1:e.value.aside!=null?!!e.value.aside:o.value.aside!==!1),g=b(()=>p.value&&a.value),y=b(()=>p.value?dt(d.value):[]);function $(){n.value=!0}function T(){n.value=!1}function I(){n.value?T():$()}return{isOpen:n,sidebar:d,sidebarGroups:y,hasSidebar:p,hasAside:v,leftAside:u,isSidebarEnabled:g,open:$,close:T,toggle:I}}function pt(e,t){let o;K(()=>{o=e.value?document.activeElement:void 0}),B(()=>{window.addEventListener("keyup",a)}),de(()=>{window.removeEventListener("keyup",a)});function a(n){n.key==="Escape"&&e.value&&(t(),o?.focus())}}function ut(e){const{page:t,hash:o}=M(),a=P(!1),n=b(()=>e.value.collapsed!=null),c=b(()=>!!e.value.link),d=P(!1),p=()=>{d.value=Y(t.value.relativePath,e.value.link)};O([t,e,o],p),B(p);const u=b(()=>d.value?!0:e.value.items?ie(t.value.relativePath,e.value.items):!1),v=b(()=>!!(e.value.items&&e.value.items.length));K(()=>{a.value=!!(n.value&&e.value.collapsed)}),me(()=>{(d.value||u.value)&&(a.value=!1)});function g(){n.value&&(a.value=!a.value)}return{collapsed:a,collapsible:n,isLink:c,isActiveLink:d,hasActiveLink:u,hasChildren:v,toggle:g}}function ht(){const{hasSidebar:e}=E(),t=ne("(min-width: 960px)"),o=ne("(min-width: 1280px)");return{isAsideEnabled:b(()=>!o.value&&!t.value?!1:e.value?o.value:t.value)}}const yt=/\b(?:VPBadge|header-anchor|footnote-ref|ignore-header)\b/,le=[];function Le(e){return typeof e.outline=="object"&&!Array.isArray(e.outline)&&e.outline.label||e.outlineTitle||"On this page"}function ue(e){const t=[...document.querySelectorAll(".VPDoc :where(h1,h2,h3,h4,h5,h6)")].filter(o=>o.id&&o.hasChildNodes()).map(o=>{const a=Number(o.tagName[1]);return{element:o,title:gt(o),link:"#"+o.id,level:a}});return ft(t,e)}function gt(e){let t="";for(const o of e.childNodes)if(o.nodeType===1){if(yt.test(o.className))continue;t+=o.textContent}else o.nodeType===3&&(t+=o.textContent);return t.trim()}function ft(e,t){if(t===!1)return[];const o=(typeof t=="object"&&!Array.isArray(t)?t.level:t)||2,[a,n]=typeof o=="number"?[o,o]:o==="deep"?[2,6]:o;return kt(e,a,n)}function vt(e,t){const{isAsideEnabled:o}=ht(),a=et(c,100);let n=null;B(()=>{requestAnimationFrame(c),window.addEventListener("scroll",a)}),Fe(()=>{d(location.hash)}),de(()=>{window.removeEventListener("scroll",a)});function c(){if(!o.value)return;const p=window.scrollY,u=window.innerHeight,v=document.body.offsetHeight,g=Math.abs(p+u-v)<1,y=le.map(({element:T,link:I})=>({link:I,top:xt(T)})).filter(({top:T})=>!Number.isNaN(T)).sort((T,I)=>T.top-I.top);if(!y.length){d(null);return}if(p<1){d(null);return}if(g){d(y[y.length-1].link);return}let $=null;for(const{link:T,top:I}of y){if(I>p+Oe()+4)break;$=T}d($)}function d(p){n&&n.classList.remove("active"),p==null?n=null:n=e.value.querySelector(`a[href="${decodeURIComponent(p)}"]`);const u=n;u?(u.classList.add("active"),t.value.style.top=u.offsetTop+39+"px",t.value.style.opacity="1"):(t.value.style.top="33px",t.value.style.opacity="0")}}function xt(e){let t=0;for(;e!==document.body;){if(e===null)return NaN;t+=e.offsetTop,e=e.offsetParent}return t}function kt(e,t,o){le.length=0;const a=[],n=[];return e.forEach(c=>{const d={...c,children:[]};let p=n[n.length-1];for(;p&&p.level>=d.level;)n.pop(),p=n[n.length-1];if(d.element.classList.contains("ignore-header")||p&&"shouldIgnore"in p){n.push({level:d.level,shouldIgnore:!0});return}d.level>o||d.level{const n=W("VPDocOutlineItem",!0);return r(),i("ul",{class:L(["VPDocOutlineItem",e.root?"root":"nested"])},[(r(!0),i(H,null,D(e.headers,({children:c,link:d,title:p})=>(r(),i("li",null,[s("a",{class:"outline-link",href:d,onClick:t,title:p},k(p),9,bt),c?.length?(r(),w(n,{key:0,headers:c},null,8,["headers"])):f("",!0)]))),256))],2)}}}),He=S(_t,[["__scopeId","data-v-872013a5"]]),wt={class:"content"},St={"aria-level":"2",class:"outline-title",id:"doc-outline-aria-label",role:"heading"},$t=x({__name:"VPDocAsideOutline",setup(e){const{frontmatter:t,theme:o}=M(),a=be([]);J(()=>{a.value=ue(t.value.outline??o.value.outline)});const n=P(),c=P();return vt(n,c),(d,p)=>(r(),i("nav",{"aria-labelledby":"doc-outline-aria-label",class:L(["VPDocAsideOutline",{"has-outline":a.value.length>0}]),ref_key:"container",ref:n},[s("div",wt,[s("div",{class:"outline-marker",ref_key:"marker",ref:c},null,512),s("div",St,k(l(Le)(l(o))),1),_(He,{headers:a.value,root:!0},null,8,["headers"])])],2))}}),Mt=S($t,[["__scopeId","data-v-72c9ae02"]]),Pt={class:"VPDocAsideCarbonAds"},Tt=x({__name:"VPDocAsideCarbonAds",props:{carbonAds:{}},setup(e){const t=()=>null;return(o,a)=>(r(),i("div",Pt,[_(l(t),{"carbon-ads":e.carbonAds},null,8,["carbon-ads"])]))}}),Lt={class:"VPDocAside"},Ht=x({__name:"VPDocAside",setup(e){const{theme:t}=M();return(o,a)=>(r(),i("div",Lt,[m(o.$slots,"aside-top",{},void 0,!0),m(o.$slots,"aside-outline-before",{},void 0,!0),_(Mt),m(o.$slots,"aside-outline-after",{},void 0,!0),a[0]||(a[0]=s("div",{class:"spacer"},null,-1)),m(o.$slots,"aside-ads-before",{},void 0,!0),l(t).carbonAds?(r(),w(Tt,{key:0,"carbon-ads":l(t).carbonAds},null,8,["carbon-ads"])):f("",!0),m(o.$slots,"aside-ads-after",{},void 0,!0),m(o.$slots,"aside-bottom",{},void 0,!0)]))}}),Dt=S(Ht,[["__scopeId","data-v-1ad0daab"]]);function It(){const{theme:e,page:t}=M();return b(()=>{const{text:o="Edit this page",pattern:a=""}=e.value.editLink||{};let n;return typeof a=="function"?n=a(t.value):n=a.replace(/:path/g,t.value.filePath),{url:n,text:o}})}function Ct(){const{page:e,theme:t,frontmatter:o}=M();return b(()=>{const a=Te(t.value.sidebar,e.value.relativePath),n=mt(a),c=Vt(n,v=>v.link.replace(/[?#].*$/,"")),d=c.findIndex(v=>Y(e.value.relativePath,v.link)),p=t.value.docFooter?.prev===!1&&!o.value.prev||o.value.prev===!1,u=t.value.docFooter?.next===!1&&!o.value.next||o.value.next===!1;return{prev:p?void 0:{text:(typeof o.value.prev=="string"?o.value.prev:typeof o.value.prev=="object"?o.value.prev.text:void 0)??c[d-1]?.docFooterText??c[d-1]?.text,link:(typeof o.value.prev=="object"?o.value.prev.link:void 0)??c[d-1]?.link},next:u?void 0:{text:(typeof o.value.next=="string"?o.value.next:typeof o.value.next=="object"?o.value.next.text:void 0)??c[d+1]?.docFooterText??c[d+1]?.text,link:(typeof o.value.next=="object"?o.value.next.link:void 0)??c[d+1]?.link}}})}function Vt(e,t){const o=new Set;return e.filter(a=>{const n=t(a);return o.has(n)?!1:o.add(n)})}const F=x({__name:"VPLink",props:{tag:{},href:{},noIcon:{type:Boolean},target:{},rel:{}},setup(e){const t=e,o=b(()=>t.tag??(t.href?"a":"span")),a=b(()=>t.href&&_e.test(t.href)||t.target==="_blank");return(n,c)=>(r(),w(A(o.value),{class:L(["VPLink",{link:e.href,"vp-external-link-icon":a.value,"no-icon":e.noIcon}]),href:e.href?l(pe)(e.href):void 0,target:e.target??(a.value?"_blank":void 0),rel:e.rel??(a.value?"noreferrer":void 0)},{default:h(()=>[m(n.$slots,"default")]),_:3},8,["class","href","target","rel"]))}}),Nt={class:"VPLastUpdated"},At=["datetime"],Ft=x({__name:"VPDocFooterLastUpdated",setup(e){const{theme:t,page:o,lang:a}=M(),n=b(()=>new Date(o.value.lastUpdated)),c=b(()=>n.value.toISOString()),d=P("");return B(()=>{K(()=>{d.value=new Intl.DateTimeFormat(t.value.lastUpdated?.formatOptions?.forceLocale?a.value:void 0,t.value.lastUpdated?.formatOptions??{dateStyle:"short",timeStyle:"short"}).format(n.value)})}),(p,u)=>(r(),i("p",Nt,[N(k(l(t).lastUpdated?.text||l(t).lastUpdatedText||"Last updated")+": ",1),s("time",{datetime:c.value},k(d.value),9,At)]))}}),Ot=S(Ft,[["__scopeId","data-v-4e5f2de1"]]),Et={key:0,class:"VPDocFooter"},zt={key:0,class:"edit-info"},Ut={key:0,class:"edit-link"},Bt={key:1,class:"last-updated"},Yt={key:1,class:"prev-next","aria-labelledby":"doc-footer-aria-label"},Wt={class:"pager"},Zt=["innerHTML"],Rt=["innerHTML"],qt={class:"pager"},Gt=["innerHTML"],Qt=["innerHTML"],jt=x({__name:"VPDocFooter",setup(e){const{theme:t,page:o,frontmatter:a}=M(),n=It(),c=Ct(),d=b(()=>t.value.editLink&&a.value.editLink!==!1),p=b(()=>o.value.lastUpdated),u=b(()=>d.value||p.value||c.value.prev||c.value.next);return(v,g)=>u.value?(r(),i("footer",Et,[m(v.$slots,"doc-footer-before",{},void 0,!0),d.value||p.value?(r(),i("div",zt,[d.value?(r(),i("div",Ut,[_(F,{class:"edit-link-button",href:l(n).url,"no-icon":!0},{default:h(()=>[g[0]||(g[0]=s("span",{class:"vpi-square-pen edit-link-icon"},null,-1)),N(" "+k(l(n).text),1)]),_:1},8,["href"])])):f("",!0),p.value?(r(),i("div",Bt,[_(Ot)])):f("",!0)])):f("",!0),l(c).prev?.link||l(c).next?.link?(r(),i("nav",Yt,[g[1]||(g[1]=s("span",{class:"visually-hidden",id:"doc-footer-aria-label"},"Pager",-1)),s("div",Wt,[l(c).prev?.link?(r(),w(F,{key:0,class:"pager-link prev",href:l(c).prev.link},{default:h(()=>[s("span",{class:"desc",innerHTML:l(t).docFooter?.prev||"Previous page"},null,8,Zt),s("span",{class:"title",innerHTML:l(c).prev.text},null,8,Rt)]),_:1},8,["href"])):f("",!0)]),s("div",qt,[l(c).next?.link?(r(),w(F,{key:0,class:"pager-link next",href:l(c).next.link},{default:h(()=>[s("span",{class:"desc",innerHTML:l(t).docFooter?.next||"Next page"},null,8,Gt),s("span",{class:"title",innerHTML:l(c).next.text},null,8,Qt)]),_:1},8,["href"])):f("",!0)])])):f("",!0)])):f("",!0)}}),Kt=S(jt,[["__scopeId","data-v-4a375655"]]),Jt={class:"container"},Xt={class:"aside-container"},eo={class:"aside-content"},to={class:"content"},oo={class:"content-container"},ao={class:"main"},no=x({__name:"VPDoc",setup(e){const{theme:t}=M(),o=X(),{hasSidebar:a,hasAside:n,leftAside:c}=E(),d=b(()=>o.path.replace(/[./]+/g,"_").replace(/_html$/,""));return(p,u)=>{const v=W("Content");return r(),i("div",{class:L(["VPDoc",{"has-sidebar":l(a),"has-aside":l(n)}])},[m(p.$slots,"doc-top",{},void 0,!0),s("div",Jt,[l(n)?(r(),i("div",{key:0,class:L(["aside",{"left-aside":l(c)}])},[u[0]||(u[0]=s("div",{class:"aside-curtain"},null,-1)),s("div",Xt,[s("div",eo,[_(Dt,null,{"aside-top":h(()=>[m(p.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":h(()=>[m(p.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":h(()=>[m(p.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":h(()=>[m(p.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":h(()=>[m(p.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":h(()=>[m(p.$slots,"aside-ads-after",{},void 0,!0)]),_:3})])])],2)):f("",!0),s("div",to,[s("div",oo,[m(p.$slots,"doc-before",{},void 0,!0),s("main",ao,[_(v,{class:L(["vp-doc",[d.value,l(t).externalLinkIcon&&"external-link-icon-enabled"]])},null,8,["class"])]),_(Kt,null,{"doc-footer-before":h(()=>[m(p.$slots,"doc-footer-before",{},void 0,!0)]),_:3}),m(p.$slots,"doc-after",{},void 0,!0)])])]),m(p.$slots,"doc-bottom",{},void 0,!0)],2)}}}),so=S(no,[["__scopeId","data-v-47e63f70"]]),ro=x({__name:"VPButton",props:{tag:{},size:{default:"medium"},theme:{default:"brand"},text:{},href:{},target:{},rel:{}},setup(e){const t=e,o=b(()=>t.href&&_e.test(t.href)),a=b(()=>t.tag||(t.href?"a":"button"));return(n,c)=>(r(),w(A(a.value),{class:L(["VPButton",[e.size,e.theme]]),href:e.href?l(pe)(e.href):void 0,target:t.target??(o.value?"_blank":void 0),rel:t.rel??(o.value?"noreferrer":void 0)},{default:h(()=>[N(k(e.text),1)]),_:1},8,["class","href","target","rel"]))}}),io=S(ro,[["__scopeId","data-v-cbd0f1a8"]]),lo=["src","alt"],co=x({inheritAttrs:!1,__name:"VPImage",props:{image:{},alt:{}},setup(e){return(t,o)=>{const a=W("VPImage",!0);return e.image?(r(),i(H,{key:0},[typeof e.image=="string"||"src"in e.image?(r(),i("img",U({key:0,class:"VPImage"},typeof e.image=="string"?t.$attrs:{...e.image,...t.$attrs},{src:l(Z)(typeof e.image=="string"?e.image:e.image.src),alt:e.alt??(typeof e.image=="string"?"":e.image.alt||"")}),null,16,lo)):(r(),i(H,{key:1},[_(a,U({class:"dark",image:e.image.dark,alt:e.image.alt},t.$attrs),null,16,["image","alt"]),_(a,U({class:"light",image:e.image.light,alt:e.image.alt},t.$attrs),null,16,["image","alt"])],64))],64)):f("",!0)}}}),j=S(co,[["__scopeId","data-v-713f3478"]]),mo={class:"container"},po={class:"main"},uo={class:"heading"},ho=["innerHTML"],yo=["innerHTML"],go=["innerHTML"],fo={key:0,class:"actions"},vo={key:0,class:"image"},xo={class:"image-container"},ko=x({__name:"VPHero",props:{name:{},text:{},tagline:{},image:{},actions:{}},setup(e){const t=ee("hero-image-slot-exists");return(o,a)=>(r(),i("div",{class:L(["VPHero",{"has-image":e.image||l(t)}])},[s("div",mo,[s("div",po,[m(o.$slots,"home-hero-info-before",{},void 0,!0),m(o.$slots,"home-hero-info",{},()=>[s("h1",uo,[e.name?(r(),i("span",{key:0,innerHTML:e.name,class:"name clip"},null,8,ho)):f("",!0),e.text?(r(),i("span",{key:1,innerHTML:e.text,class:"text"},null,8,yo)):f("",!0)]),e.tagline?(r(),i("p",{key:0,innerHTML:e.tagline,class:"tagline"},null,8,go)):f("",!0)],!0),m(o.$slots,"home-hero-info-after",{},void 0,!0),e.actions?(r(),i("div",fo,[(r(!0),i(H,null,D(e.actions,n=>(r(),i("div",{key:n.link,class:"action"},[_(io,{tag:"a",size:"medium",theme:n.theme,text:n.text,href:n.link,target:n.target,rel:n.rel},null,8,["theme","text","href","target","rel"])]))),128))])):f("",!0),m(o.$slots,"home-hero-actions-after",{},void 0,!0)]),e.image||l(t)?(r(),i("div",vo,[s("div",xo,[a[0]||(a[0]=s("div",{class:"image-bg"},null,-1)),m(o.$slots,"home-hero-image",{},()=>[e.image?(r(),w(j,{key:0,class:"image-src",image:e.image},null,8,["image"])):f("",!0)],!0)])])):f("",!0)])],2))}}),bo=S(ko,[["__scopeId","data-v-bb92d360"]]),_o=x({__name:"VPHomeHero",setup(e){const{frontmatter:t}=M();return(o,a)=>l(t).hero?(r(),w(bo,{key:0,class:"VPHomeHero",name:l(t).hero.name,text:l(t).hero.text,tagline:l(t).hero.tagline,image:l(t).hero.image,actions:l(t).hero.actions},{"home-hero-info-before":h(()=>[m(o.$slots,"home-hero-info-before")]),"home-hero-info":h(()=>[m(o.$slots,"home-hero-info")]),"home-hero-info-after":h(()=>[m(o.$slots,"home-hero-info-after")]),"home-hero-actions-after":h(()=>[m(o.$slots,"home-hero-actions-after")]),"home-hero-image":h(()=>[m(o.$slots,"home-hero-image")]),_:3},8,["name","text","tagline","image","actions"])):f("",!0)}}),wo={class:"box"},So={key:0,class:"icon"},$o=["innerHTML"],Mo=["innerHTML"],Po=["innerHTML"],To={key:4,class:"link-text"},Lo={class:"link-text-value"},Ho=x({__name:"VPFeature",props:{icon:{},title:{},details:{},link:{},linkText:{},rel:{},target:{}},setup(e){return(t,o)=>(r(),w(F,{class:"VPFeature",href:e.link,rel:e.rel,target:e.target,"no-icon":!0,tag:e.link?"a":"div"},{default:h(()=>[s("article",wo,[typeof e.icon=="object"&&e.icon.wrap?(r(),i("div",So,[_(j,{image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])])):typeof e.icon=="object"?(r(),w(j,{key:1,image:e.icon,alt:e.icon.alt,height:e.icon.height||48,width:e.icon.width||48},null,8,["image","alt","height","width"])):e.icon?(r(),i("div",{key:2,class:"icon",innerHTML:e.icon},null,8,$o)):f("",!0),s("h2",{class:"title",innerHTML:e.title},null,8,Mo),e.details?(r(),i("p",{key:3,class:"details",innerHTML:e.details},null,8,Po)):f("",!0),e.linkText?(r(),i("div",To,[s("p",Lo,[N(k(e.linkText)+" ",1),o[0]||(o[0]=s("span",{class:"vpi-arrow-right link-text-icon"},null,-1))])])):f("",!0)])]),_:1},8,["href","rel","target","tag"]))}}),Do=S(Ho,[["__scopeId","data-v-dc805d92"]]),Io={key:0,class:"VPFeatures"},Co={class:"container"},Vo={class:"items"},No=x({__name:"VPFeatures",props:{features:{}},setup(e){const t=e,o=b(()=>{const a=t.features.length;if(a){if(a===2)return"grid-2";if(a===3)return"grid-3";if(a%3===0)return"grid-6";if(a>3)return"grid-4"}else return});return(a,n)=>e.features?(r(),i("div",Io,[s("div",Co,[s("div",Vo,[(r(!0),i(H,null,D(e.features,c=>(r(),i("div",{key:c.title,class:L(["item",[o.value]])},[_(Do,{icon:c.icon,title:c.title,details:c.details,link:c.link,"link-text":c.linkText,rel:c.rel,target:c.target},null,8,["icon","title","details","link","link-text","rel","target"])],2))),128))])])])):f("",!0)}}),Ao=S(No,[["__scopeId","data-v-4491a3bd"]]),Fo=x({__name:"VPHomeFeatures",setup(e){const{frontmatter:t}=M();return(o,a)=>l(t).features?(r(),w(Ao,{key:0,class:"VPHomeFeatures",features:l(t).features},null,8,["features"])):f("",!0)}}),Oo=x({__name:"VPHomeContent",setup(e){const{width:t}=Ee({initialWidth:0,includeScrollbar:!1});return(o,a)=>(r(),i("div",{class:"vp-doc container",style:q(l(t)?{"--vp-offset":`calc(50% - ${l(t)/2}px)`}:{})},[m(o.$slots,"default",{},void 0,!0)],4))}}),Eo=S(Oo,[["__scopeId","data-v-a6e74fd2"]]),zo=x({__name:"VPHome",setup(e){const{frontmatter:t,theme:o}=M();return(a,n)=>{const c=W("Content");return r(),i("div",{class:L(["VPHome",{"external-link-icon-enabled":l(o).externalLinkIcon}])},[m(a.$slots,"home-hero-before",{},void 0,!0),_(_o,null,{"home-hero-info-before":h(()=>[m(a.$slots,"home-hero-info-before",{},void 0,!0)]),"home-hero-info":h(()=>[m(a.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-info-after":h(()=>[m(a.$slots,"home-hero-info-after",{},void 0,!0)]),"home-hero-actions-after":h(()=>[m(a.$slots,"home-hero-actions-after",{},void 0,!0)]),"home-hero-image":h(()=>[m(a.$slots,"home-hero-image",{},void 0,!0)]),_:3}),m(a.$slots,"home-hero-after",{},void 0,!0),m(a.$slots,"home-features-before",{},void 0,!0),_(Fo),m(a.$slots,"home-features-after",{},void 0,!0),l(t).markdownStyles!==!1?(r(),w(Eo,{key:0},{default:h(()=>[_(c)]),_:1})):(r(),w(c,{key:1}))],2)}}}),Uo=S(zo,[["__scopeId","data-v-28935afa"]]),Bo={},Yo={class:"VPPage"};function Wo(e,t){const o=W("Content");return r(),i("div",Yo,[m(e.$slots,"page-top"),_(o),m(e.$slots,"page-bottom")])}const Zo=S(Bo,[["render",Wo]]),Ro=x({__name:"VPContent",setup(e){const{page:t,frontmatter:o}=M(),{hasSidebar:a}=E();return(n,c)=>(r(),i("div",{class:L(["VPContent",{"has-sidebar":l(a),"is-home":l(o).layout==="home"}]),id:"VPContent"},[l(t).isNotFound?m(n.$slots,"not-found",{},()=>[_(ct)],!0,0):l(o).layout==="page"?(r(),w(Zo,{key:1},{"page-top":h(()=>[m(n.$slots,"page-top",{},void 0,!0)]),"page-bottom":h(()=>[m(n.$slots,"page-bottom",{},void 0,!0)]),_:3})):l(o).layout==="home"?(r(),w(Uo,{key:2},{"home-hero-before":h(()=>[m(n.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info-before":h(()=>[m(n.$slots,"home-hero-info-before",{},void 0,!0)]),"home-hero-info":h(()=>[m(n.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-info-after":h(()=>[m(n.$slots,"home-hero-info-after",{},void 0,!0)]),"home-hero-actions-after":h(()=>[m(n.$slots,"home-hero-actions-after",{},void 0,!0)]),"home-hero-image":h(()=>[m(n.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":h(()=>[m(n.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":h(()=>[m(n.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":h(()=>[m(n.$slots,"home-features-after",{},void 0,!0)]),_:3})):l(o).layout&&l(o).layout!=="doc"?(r(),w(A(l(o).layout),{key:3})):(r(),w(so,{key:4},{"doc-top":h(()=>[m(n.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":h(()=>[m(n.$slots,"doc-bottom",{},void 0,!0)]),"doc-footer-before":h(()=>[m(n.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":h(()=>[m(n.$slots,"doc-before",{},void 0,!0)]),"doc-after":h(()=>[m(n.$slots,"doc-after",{},void 0,!0)]),"aside-top":h(()=>[m(n.$slots,"aside-top",{},void 0,!0)]),"aside-outline-before":h(()=>[m(n.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":h(()=>[m(n.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":h(()=>[m(n.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":h(()=>[m(n.$slots,"aside-ads-after",{},void 0,!0)]),"aside-bottom":h(()=>[m(n.$slots,"aside-bottom",{},void 0,!0)]),_:3}))],2))}}),qo=S(Ro,[["__scopeId","data-v-422da788"]]),Go={class:"container"},Qo=["innerHTML"],jo=["innerHTML"],Ko=x({__name:"VPFooter",setup(e){const{theme:t,frontmatter:o}=M(),{hasSidebar:a}=E();return(n,c)=>l(t).footer&&l(o).footer!==!1?(r(),i("footer",{key:0,class:L(["VPFooter",{"has-sidebar":l(a)}])},[s("div",Go,[l(t).footer.message?(r(),i("p",{key:0,class:"message",innerHTML:l(t).footer.message},null,8,Qo)):f("",!0),l(t).footer.copyright?(r(),i("p",{key:1,class:"copyright",innerHTML:l(t).footer.copyright},null,8,jo)):f("",!0)])],2)):f("",!0)}}),Jo=S(Ko,[["__scopeId","data-v-b3ad5ce0"]]);function Xo(){const{theme:e,frontmatter:t}=M(),o=be([]),a=b(()=>o.value.length>0);return J(()=>{o.value=ue(t.value.outline??e.value.outline)}),{headers:o,hasLocalNav:a}}const ea={class:"menu-text"},ta={class:"header"},oa={class:"outline"},aa=x({__name:"VPLocalNavOutlineDropdown",props:{headers:{},navHeight:{}},setup(e){const t=e,{theme:o}=M(),a=P(!1),n=P(0),c=P(),d=P();function p(y){c.value?.contains(y.target)||(a.value=!1)}O(a,y=>{if(y){document.addEventListener("click",p);return}document.removeEventListener("click",p)}),se("Escape",()=>{a.value=!1}),J(()=>{a.value=!1});function u(){a.value=!a.value,n.value=window.innerHeight+Math.min(window.scrollY-t.navHeight,0)}function v(y){y.target.classList.contains("outline-link")&&(d.value&&(d.value.style.transition="none"),we(()=>{a.value=!1}))}function g(){a.value=!1,window.scrollTo({top:0,left:0,behavior:"smooth"})}return(y,$)=>(r(),i("div",{class:"VPLocalNavOutlineDropdown",style:q({"--vp-vh":n.value+"px"}),ref_key:"main",ref:c},[e.headers.length>0?(r(),i("button",{key:0,onClick:u,class:L({open:a.value})},[s("span",ea,k(l(Le)(l(o))),1),$[0]||($[0]=s("span",{class:"vpi-chevron-right icon"},null,-1))],2)):(r(),i("button",{key:1,onClick:g},k(l(o).returnToTopLabel||"Return to top"),1)),_(ce,{name:"flyout"},{default:h(()=>[a.value?(r(),i("div",{key:0,ref_key:"items",ref:d,class:"items",onClick:v},[s("div",ta,[s("a",{class:"top-link",href:"#",onClick:g},k(l(o).returnToTopLabel||"Return to top"),1)]),s("div",oa,[_(He,{headers:e.headers},null,8,["headers"])])],512)):f("",!0)]),_:1})],4))}}),na=S(aa,[["__scopeId","data-v-0e38a025"]]),sa={class:"container"},ra=["aria-expanded"],ia={class:"menu-text"},la=x({__name:"VPLocalNav",props:{open:{type:Boolean}},emits:["open-menu"],setup(e){const{theme:t,frontmatter:o}=M(),{hasSidebar:a}=E(),{headers:n}=Xo(),{y:c}=Se(),d=P(0);B(()=>{d.value=parseInt(getComputedStyle(document.documentElement).getPropertyValue("--vp-nav-height"))}),J(()=>{n.value=ue(o.value.outline??t.value.outline)});const p=b(()=>n.value.length===0),u=b(()=>p.value&&!a.value),v=b(()=>({VPLocalNav:!0,"has-sidebar":a.value,empty:p.value,fixed:u.value}));return(g,y)=>l(o).layout!=="home"&&(!u.value||l(c)>=d.value)?(r(),i("div",{key:0,class:L(v.value)},[s("div",sa,[l(a)?(r(),i("button",{key:0,class:"menu","aria-expanded":e.open,"aria-controls":"VPSidebarNav",onClick:y[0]||(y[0]=$=>g.$emit("open-menu"))},[y[1]||(y[1]=s("span",{class:"vpi-align-left menu-icon"},null,-1)),s("span",ia,k(l(t).sidebarMenuLabel||"Menu"),1)],8,ra)):f("",!0),_(na,{headers:l(n),navHeight:d.value},null,8,["headers","navHeight"])])],2)):f("",!0)}}),ca=S(la,[["__scopeId","data-v-d06d210a"]]);function da(){const e=P(!1);function t(){e.value=!0,window.addEventListener("resize",n)}function o(){e.value=!1,window.removeEventListener("resize",n)}function a(){e.value?o():t()}function n(){window.outerWidth>=768&&o()}const c=X();return O(()=>c.path,o),{isScreenOpen:e,openScreen:t,closeScreen:o,toggleScreen:a}}const ma={},pa={class:"VPSwitch",type:"button",role:"switch"},ua={class:"check"},ha={key:0,class:"icon"};function ya(e,t){return r(),i("button",pa,[s("span",ua,[e.$slots.default?(r(),i("span",ha,[m(e.$slots,"default",{},void 0,!0)])):f("",!0)])])}const ga=S(ma,[["render",ya],["__scopeId","data-v-2ba9eb1e"]]),fa=x({__name:"VPSwitchAppearance",setup(e){const{isDark:t,theme:o}=M(),a=ee("toggle-appearance",()=>{t.value=!t.value}),n=P("");return me(()=>{n.value=t.value?o.value.lightModeSwitchTitle||"Switch to light theme":o.value.darkModeSwitchTitle||"Switch to dark theme"}),(c,d)=>(r(),w(ga,{title:n.value,class:"VPSwitchAppearance","aria-checked":l(t),onClick:l(a)},{default:h(()=>[...d[0]||(d[0]=[s("span",{class:"vpi-sun sun"},null,-1),s("span",{class:"vpi-moon moon"},null,-1)])]),_:1},8,["title","aria-checked","onClick"]))}}),he=S(fa,[["__scopeId","data-v-0a38c41c"]]),va={key:0,class:"VPNavBarAppearance"},xa=x({__name:"VPNavBarAppearance",setup(e){const{site:t}=M();return(o,a)=>l(t).appearance&&l(t).appearance!=="force-dark"&&l(t).appearance!=="force-auto"?(r(),i("div",va,[_(he)])):f("",!0)}}),ka=S(xa,[["__scopeId","data-v-0715029b"]]),ye=P();let De=!1,ae=0;function ba(e){const t=P(!1);if(te){!De&&_a(),ae++;const o=O(ye,a=>{a===e.el.value||e.el.value?.contains(a)?(t.value=!0,e.onFocus?.()):(t.value=!1,e.onBlur?.())});de(()=>{o(),ae--,ae||wa()})}return ze(t)}function _a(){document.addEventListener("focusin",Ie),De=!0,ye.value=document.activeElement}function wa(){document.removeEventListener("focusin",Ie)}function Ie(){ye.value=document.activeElement}const Sa={class:"VPMenuLink"},$a=["innerHTML"],Ma=x({__name:"VPMenuLink",props:{item:{}},setup(e){const{page:t}=M();return(o,a)=>(r(),i("div",Sa,[_(F,{class:L({active:l(Y)(l(t).relativePath,e.item.activeMatch||e.item.link,!!e.item.activeMatch)}),href:e.item.link,target:e.item.target,rel:e.item.rel,"no-icon":e.item.noIcon},{default:h(()=>[s("span",{innerHTML:e.item.text},null,8,$a)]),_:1},8,["class","href","target","rel","no-icon"])]))}}),oe=S(Ma,[["__scopeId","data-v-fc99a6ef"]]),Pa={class:"VPMenuGroup"},Ta={key:0,class:"title"},La=x({__name:"VPMenuGroup",props:{text:{},items:{}},setup(e){return(t,o)=>(r(),i("div",Pa,[e.text?(r(),i("p",Ta,k(e.text),1)):f("",!0),(r(!0),i(H,null,D(e.items,a=>(r(),i(H,null,["link"in a?(r(),w(oe,{key:0,item:a},null,8,["item"])):f("",!0)],64))),256))]))}}),Ha=S(La,[["__scopeId","data-v-9fd5816a"]]),Da={class:"VPMenu"},Ia={key:0,class:"items"},Ca=x({__name:"VPMenu",props:{items:{}},setup(e){return(t,o)=>(r(),i("div",Da,[e.items?(r(),i("div",Ia,[(r(!0),i(H,null,D(e.items,a=>(r(),i(H,{key:JSON.stringify(a)},["link"in a?(r(),w(oe,{key:0,item:a},null,8,["item"])):"component"in a?(r(),w(A(a.component),U({key:1,ref_for:!0},a.props),null,16)):(r(),w(Ha,{key:2,text:a.text,items:a.items},null,8,["text","items"]))],64))),128))])):f("",!0),m(t.$slots,"default",{},void 0,!0)]))}}),Va=S(Ca,[["__scopeId","data-v-2ecede1c"]]),Na=["aria-expanded","aria-label"],Aa={key:0,class:"text"},Fa=["innerHTML"],Oa={key:1,class:"vpi-more-horizontal icon"},Ea={class:"menu"},za=x({__name:"VPFlyout",props:{icon:{},button:{},label:{},items:{}},setup(e){const t=P(!1),o=P();ba({el:o,onBlur:a});function a(){t.value=!1}return(n,c)=>(r(),i("div",{class:"VPFlyout",ref_key:"el",ref:o,onMouseenter:c[1]||(c[1]=d=>t.value=!0),onMouseleave:c[2]||(c[2]=d=>t.value=!1)},[s("button",{type:"button",class:"button","aria-haspopup":"true","aria-expanded":t.value,"aria-label":e.label,onClick:c[0]||(c[0]=d=>t.value=!t.value)},[e.button||e.icon?(r(),i("span",Aa,[e.icon?(r(),i("span",{key:0,class:L([e.icon,"option-icon"])},null,2)):f("",!0),e.button?(r(),i("span",{key:1,innerHTML:e.button},null,8,Fa)):f("",!0),c[3]||(c[3]=s("span",{class:"vpi-chevron-down text-icon"},null,-1))])):(r(),i("span",Oa))],8,Na),s("div",Ea,[_(Va,{items:e.items},{default:h(()=>[m(n.$slots,"default",{},void 0,!0)]),_:3},8,["items"])])],544))}}),ge=S(za,[["__scopeId","data-v-a4cb0e19"]]),Ua=["href","aria-label","innerHTML"],Ba=x({__name:"VPSocialLink",props:{icon:{},link:{},ariaLabel:{}},setup(e){const t=e,o=P();B(async()=>{await we();const n=o.value?.children[0];n instanceof HTMLElement&&n.className.startsWith("vpi-social-")&&(getComputedStyle(n).maskImage||getComputedStyle(n).webkitMaskImage)==="none"&&n.style.setProperty("--icon",`url('https://api.iconify.design/simple-icons/${t.icon}.svg')`)});const a=b(()=>typeof t.icon=="object"?t.icon.svg:``);return(n,c)=>(r(),i("a",{ref_key:"el",ref:o,class:"VPSocialLink no-icon",href:e.link,"aria-label":e.ariaLabel??(typeof e.icon=="string"?e.icon:""),target:"_blank",rel:"noopener",innerHTML:a.value},null,8,Ua))}}),Ya=S(Ba,[["__scopeId","data-v-c300d4f5"]]),Wa={class:"VPSocialLinks"},Za=x({__name:"VPSocialLinks",props:{links:{}},setup(e){return(t,o)=>(r(),i("div",Wa,[(r(!0),i(H,null,D(e.links,({link:a,icon:n,ariaLabel:c})=>(r(),w(Ya,{key:a,icon:n,link:a,ariaLabel:c},null,8,["icon","link","ariaLabel"]))),128))]))}}),fe=S(Za,[["__scopeId","data-v-5ace9ec0"]]),Ra={key:0,class:"group translations"},qa={class:"trans-title"},Ga={key:1,class:"group"},Qa={class:"item appearance"},ja={class:"label"},Ka={class:"appearance-action"},Ja={key:2,class:"group"},Xa={class:"item social-links"},en=x({__name:"VPNavBarExtra",setup(e){const{site:t,theme:o}=M(),{localeLinks:a,currentLang:n}=G({correspondingLink:!0}),c=b(()=>a.value.length&&n.value.label||t.value.appearance||o.value.socialLinks);return(d,p)=>c.value?(r(),w(ge,{key:0,class:"VPNavBarExtra",label:"extra navigation"},{default:h(()=>[l(a).length&&l(n).label?(r(),i("div",Ra,[s("p",qa,k(l(n).label),1),(r(!0),i(H,null,D(l(a),u=>(r(),w(oe,{key:u.link,item:u},null,8,["item"]))),128))])):f("",!0),l(t).appearance&&l(t).appearance!=="force-dark"&&l(t).appearance!=="force-auto"?(r(),i("div",Ga,[s("div",Qa,[s("p",ja,k(l(o).darkModeSwitchLabel||"Appearance"),1),s("div",Ka,[_(he)])])])):f("",!0),l(o).socialLinks?(r(),i("div",Ja,[s("div",Xa,[_(fe,{class:"social-links-list",links:l(o).socialLinks},null,8,["links"])])])):f("",!0)]),_:1})):f("",!0)}}),tn=S(en,[["__scopeId","data-v-ce206fa3"]]),on=["aria-expanded"],an=x({__name:"VPNavBarHamburger",props:{active:{type:Boolean}},emits:["click"],setup(e){return(t,o)=>(r(),i("button",{type:"button",class:L(["VPNavBarHamburger",{active:e.active}]),"aria-label":"mobile navigation","aria-expanded":e.active,"aria-controls":"VPNavScreen",onClick:o[0]||(o[0]=a=>t.$emit("click"))},[...o[1]||(o[1]=[s("span",{class:"container"},[s("span",{class:"top"}),s("span",{class:"middle"}),s("span",{class:"bottom"})],-1)])],10,on))}}),nn=S(an,[["__scopeId","data-v-87280792"]]),sn=["innerHTML"],rn=x({__name:"VPNavBarMenuLink",props:{item:{}},setup(e){const{page:t}=M();return(o,a)=>(r(),w(F,{class:L({VPNavBarMenuLink:!0,active:l(Y)(l(t).relativePath,e.item.activeMatch||e.item.link,!!e.item.activeMatch)}),href:e.item.link,target:e.item.target,rel:e.item.rel,"no-icon":e.item.noIcon,tabindex:"0"},{default:h(()=>[s("span",{innerHTML:e.item.text},null,8,sn)]),_:1},8,["class","href","target","rel","no-icon"]))}}),ln=S(rn,[["__scopeId","data-v-735ee087"]]),cn=x({__name:"VPNavBarMenuGroup",props:{item:{}},setup(e){const t=e,{page:o}=M(),a=c=>"component"in c?!1:"link"in c?Y(o.value.relativePath,c.link,!!t.item.activeMatch):c.items.some(a),n=b(()=>a(t.item));return(c,d)=>(r(),w(ge,{class:L({VPNavBarMenuGroup:!0,active:l(Y)(l(o).relativePath,e.item.activeMatch,!!e.item.activeMatch)||n.value}),button:e.item.text,items:e.item.items},null,8,["class","button","items"]))}}),dn={key:0,"aria-labelledby":"main-nav-aria-label",class:"VPNavBarMenu"},mn=x({__name:"VPNavBarMenu",setup(e){const{theme:t}=M();return(o,a)=>l(t).nav?(r(),i("nav",dn,[a[0]||(a[0]=s("span",{id:"main-nav-aria-label",class:"visually-hidden"}," Main Navigation ",-1)),(r(!0),i(H,null,D(l(t).nav,n=>(r(),i(H,{key:JSON.stringify(n)},["link"in n?(r(),w(ln,{key:0,item:n},null,8,["item"])):"component"in n?(r(),w(A(n.component),U({key:1,ref_for:!0},n.props),null,16)):(r(),w(cn,{key:2,item:n},null,8,["item"]))],64))),128))])):f("",!0)}}),pn=S(mn,[["__scopeId","data-v-2f030098"]]);function un(e){const{localeIndex:t,theme:o}=M();function a(n){const c=n.split("."),d=o.value.search?.options,p=d&&typeof d=="object",u=p&&d.locales?.[t.value]?.translations||null,v=p&&d.translations||null;let g=u,y=v,$=e;const T=c.pop();for(const I of c){let C=null;const V=$?.[I];V&&(C=$=V);const z=y?.[I];z&&(C=y=z);const R=g?.[I];R&&(C=g=R),V||($=C),z||(y=C),R||(g=C)}return g?.[T]??y?.[T]??$?.[T]??""}return a}const hn=["aria-label"],yn={class:"DocSearch-Button-Container"},gn={class:"DocSearch-Button-Placeholder"},xe=x({__name:"VPNavBarSearchButton",setup(e){const o=un({button:{buttonText:"Search",buttonAriaLabel:"Search"}});return(a,n)=>(r(),i("button",{type:"button",class:"DocSearch DocSearch-Button","aria-label":l(o)("button.buttonAriaLabel")},[s("span",yn,[n[0]||(n[0]=s("span",{class:"vp-icon DocSearch-Search-Icon"},null,-1)),s("span",gn,k(l(o)("button.buttonText")),1)]),n[1]||(n[1]=s("span",{class:"DocSearch-Button-Keys"},[s("kbd",{class:"DocSearch-Button-Key"}),s("kbd",{class:"DocSearch-Button-Key"},"K")],-1))],8,hn))}}),fn={class:"VPNavBarSearch"},vn={id:"local-search"},xn={key:1,id:"docsearch"},kn=x({__name:"VPNavBarSearch",setup(e){const t=Ue(()=>Be(()=>import("./VPLocalSearchBox.0TnTKVFI.js"),__vite__mapDeps([0,1]))),o=()=>null,{theme:a}=M(),n=P(!1),c=P(!1);B(()=>{});function d(){n.value||(n.value=!0,setTimeout(p,16))}function p(){const y=new Event("keydown");y.key="k",y.metaKey=!0,window.dispatchEvent(y),setTimeout(()=>{document.querySelector(".DocSearch-Modal")||p()},16)}function u(y){const $=y.target,T=$.tagName;return $.isContentEditable||T==="INPUT"||T==="SELECT"||T==="TEXTAREA"}const v=P(!1);se("k",y=>{(y.ctrlKey||y.metaKey)&&(y.preventDefault(),v.value=!0)}),se("/",y=>{u(y)||(y.preventDefault(),v.value=!0)});const g="local";return(y,$)=>(r(),i("div",fn,[l(g)==="local"?(r(),i(H,{key:0},[v.value?(r(),w(l(t),{key:0,onClose:$[0]||($[0]=T=>v.value=!1)})):f("",!0),s("div",vn,[_(xe,{onClick:$[1]||($[1]=T=>v.value=!0)})])],64)):l(g)==="algolia"?(r(),i(H,{key:1},[n.value?(r(),w(l(o),{key:0,algolia:l(a).search?.options??l(a).algolia,onVnodeBeforeMount:$[2]||($[2]=T=>c.value=!0)},null,8,["algolia"])):f("",!0),c.value?f("",!0):(r(),i("div",xn,[_(xe,{onClick:d})]))],64)):f("",!0)]))}}),bn=x({__name:"VPNavBarSocialLinks",setup(e){const{theme:t}=M();return(o,a)=>l(t).socialLinks?(r(),w(fe,{key:0,class:"VPNavBarSocialLinks",links:l(t).socialLinks},null,8,["links"])):f("",!0)}}),_n=S(bn,[["__scopeId","data-v-02cad4ce"]]),wn=["href","rel","target"],Sn=["innerHTML"],$n={key:2},Mn=x({__name:"VPNavBarTitle",setup(e){const{site:t,theme:o}=M(),{hasSidebar:a}=E(),{currentLang:n}=G(),c=b(()=>typeof o.value.logoLink=="string"?o.value.logoLink:o.value.logoLink?.link),d=b(()=>typeof o.value.logoLink=="string"?void 0:o.value.logoLink?.rel),p=b(()=>typeof o.value.logoLink=="string"?void 0:o.value.logoLink?.target);return(u,v)=>(r(),i("div",{class:L(["VPNavBarTitle",{"has-sidebar":l(a)}])},[s("a",{class:"title",href:c.value??l(pe)(l(n).link),rel:d.value,target:p.value},[m(u.$slots,"nav-bar-title-before",{},void 0,!0),l(o).logo?(r(),w(j,{key:0,class:"logo",image:l(o).logo},null,8,["image"])):f("",!0),l(o).siteTitle?(r(),i("span",{key:1,innerHTML:l(o).siteTitle},null,8,Sn)):l(o).siteTitle===void 0?(r(),i("span",$n,k(l(t).title),1)):f("",!0),m(u.$slots,"nav-bar-title-after",{},void 0,!0)],8,wn)],2))}}),Pn=S(Mn,[["__scopeId","data-v-a3e9f880"]]),Tn={class:"items"},Ln={class:"title"},Hn=x({__name:"VPNavBarTranslations",setup(e){const{theme:t}=M(),{localeLinks:o,currentLang:a}=G({correspondingLink:!0});return(n,c)=>l(o).length&&l(a).label?(r(),w(ge,{key:0,class:"VPNavBarTranslations",icon:"vpi-languages",label:l(t).langMenuLabel||"Change language"},{default:h(()=>[s("div",Tn,[s("p",Ln,k(l(a).label),1),(r(!0),i(H,null,D(l(o),d=>(r(),w(oe,{key:d.link,item:d},null,8,["item"]))),128))])]),_:1},8,["label"])):f("",!0)}}),Dn=S(Hn,[["__scopeId","data-v-8e20710a"]]),In={class:"wrapper"},Cn={class:"container"},Vn={class:"title"},Nn={class:"content"},An={class:"content-body"},Fn=x({__name:"VPNavBar",props:{isScreenOpen:{type:Boolean}},emits:["toggle-screen"],setup(e){const t=e,{y:o}=Se(),{hasSidebar:a}=E(),{frontmatter:n}=M(),c=P({});return me(()=>{c.value={"has-sidebar":a.value,home:n.value.layout==="home",top:o.value===0,"screen-open":t.isScreenOpen}}),(d,p)=>(r(),i("div",{class:L(["VPNavBar",c.value])},[s("div",In,[s("div",Cn,[s("div",Vn,[_(Pn,null,{"nav-bar-title-before":h(()=>[m(d.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":h(()=>[m(d.$slots,"nav-bar-title-after",{},void 0,!0)]),_:3})]),s("div",Nn,[s("div",An,[m(d.$slots,"nav-bar-content-before",{},void 0,!0),_(kn,{class:"search"}),_(pn,{class:"menu"}),_(Dn,{class:"translations"}),_(ka,{class:"appearance"}),_(_n,{class:"social-links"}),_(tn,{class:"extra"}),m(d.$slots,"nav-bar-content-after",{},void 0,!0),_(nn,{class:"hamburger",active:e.isScreenOpen,onClick:p[0]||(p[0]=u=>d.$emit("toggle-screen"))},null,8,["active"])])])])]),p[1]||(p[1]=s("div",{class:"divider"},[s("div",{class:"divider-line"})],-1))],2))}}),On=S(Fn,[["__scopeId","data-v-93e70900"]]),En={key:0,class:"VPNavScreenAppearance"},zn={class:"text"},Un=x({__name:"VPNavScreenAppearance",setup(e){const{site:t,theme:o}=M();return(a,n)=>l(t).appearance&&l(t).appearance!=="force-dark"&&l(t).appearance!=="force-auto"?(r(),i("div",En,[s("p",zn,k(l(o).darkModeSwitchLabel||"Appearance"),1),_(he)])):f("",!0)}}),Bn=S(Un,[["__scopeId","data-v-d4b75105"]]),Yn=["innerHTML"],Wn=x({__name:"VPNavScreenMenuLink",props:{item:{}},setup(e){const t=ee("close-screen");return(o,a)=>(r(),w(F,{class:"VPNavScreenMenuLink",href:e.item.link,target:e.item.target,rel:e.item.rel,"no-icon":e.item.noIcon,onClick:l(t)},{default:h(()=>[s("span",{innerHTML:e.item.text},null,8,Yn)]),_:1},8,["href","target","rel","no-icon","onClick"]))}}),Zn=S(Wn,[["__scopeId","data-v-7c8408f3"]]),Rn=["innerHTML"],qn=x({__name:"VPNavScreenMenuGroupLink",props:{item:{}},setup(e){const t=ee("close-screen");return(o,a)=>(r(),w(F,{class:"VPNavScreenMenuGroupLink",href:e.item.link,target:e.item.target,rel:e.item.rel,"no-icon":e.item.noIcon,onClick:l(t)},{default:h(()=>[s("span",{innerHTML:e.item.text},null,8,Rn)]),_:1},8,["href","target","rel","no-icon","onClick"]))}}),Ce=S(qn,[["__scopeId","data-v-89ef6f22"]]),Gn={class:"VPNavScreenMenuGroupSection"},Qn={key:0,class:"title"},jn=x({__name:"VPNavScreenMenuGroupSection",props:{text:{},items:{}},setup(e){return(t,o)=>(r(),i("div",Gn,[e.text?(r(),i("p",Qn,k(e.text),1)):f("",!0),(r(!0),i(H,null,D(e.items,a=>(r(),w(Ce,{key:a.text,item:a},null,8,["item"]))),128))]))}}),Kn=S(jn,[["__scopeId","data-v-98b82a0d"]]),Jn=["aria-controls","aria-expanded"],Xn=["innerHTML"],es=["id"],ts={key:0,class:"item"},os={key:1,class:"item"},as={key:2,class:"group"},ns=x({__name:"VPNavScreenMenuGroup",props:{text:{},items:{}},setup(e){const t=e,o=P(!1),a=b(()=>`NavScreenGroup-${t.text.replace(" ","-").toLowerCase()}`);function n(){o.value=!o.value}return(c,d)=>(r(),i("div",{class:L(["VPNavScreenMenuGroup",{open:o.value}])},[s("button",{class:"button","aria-controls":a.value,"aria-expanded":o.value,onClick:n},[s("span",{class:"button-text",innerHTML:e.text},null,8,Xn),d[0]||(d[0]=s("span",{class:"vpi-plus button-icon"},null,-1))],8,Jn),s("div",{id:a.value,class:"items"},[(r(!0),i(H,null,D(e.items,p=>(r(),i(H,{key:JSON.stringify(p)},["link"in p?(r(),i("div",ts,[_(Ce,{item:p},null,8,["item"])])):"component"in p?(r(),i("div",os,[(r(),w(A(p.component),U({ref_for:!0},p.props,{"screen-menu":""}),null,16))])):(r(),i("div",as,[_(Kn,{text:p.text,items:p.items},null,8,["text","items"])]))],64))),128))],8,es)],2))}}),ss=S(ns,[["__scopeId","data-v-a2b53d44"]]),rs={key:0,class:"VPNavScreenMenu"},is=x({__name:"VPNavScreenMenu",setup(e){const{theme:t}=M();return(o,a)=>l(t).nav?(r(),i("nav",rs,[(r(!0),i(H,null,D(l(t).nav,n=>(r(),i(H,{key:JSON.stringify(n)},["link"in n?(r(),w(Zn,{key:0,item:n},null,8,["item"])):"component"in n?(r(),w(A(n.component),U({key:1,ref_for:!0},n.props,{"screen-menu":""}),null,16)):(r(),w(ss,{key:2,text:n.text||"",items:n.items},null,8,["text","items"]))],64))),128))])):f("",!0)}}),ls=x({__name:"VPNavScreenSocialLinks",setup(e){const{theme:t}=M();return(o,a)=>l(t).socialLinks?(r(),w(fe,{key:0,class:"VPNavScreenSocialLinks",links:l(t).socialLinks},null,8,["links"])):f("",!0)}}),cs={class:"list"},ds=x({__name:"VPNavScreenTranslations",setup(e){const{localeLinks:t,currentLang:o}=G({correspondingLink:!0}),a=P(!1);function n(){a.value=!a.value}return(c,d)=>l(t).length&&l(o).label?(r(),i("div",{key:0,class:L(["VPNavScreenTranslations",{open:a.value}])},[s("button",{class:"title",onClick:n},[d[0]||(d[0]=s("span",{class:"vpi-languages icon lang"},null,-1)),N(" "+k(l(o).label)+" ",1),d[1]||(d[1]=s("span",{class:"vpi-chevron-down icon chevron"},null,-1))]),s("ul",cs,[(r(!0),i(H,null,D(l(t),p=>(r(),i("li",{key:p.link,class:"item"},[_(F,{class:"link",href:p.link},{default:h(()=>[N(k(p.text),1)]),_:2},1032,["href"])]))),128))])],2)):f("",!0)}}),ms=S(ds,[["__scopeId","data-v-1cc5a949"]]),ps={class:"container"},us=x({__name:"VPNavScreen",props:{open:{type:Boolean}},setup(e){const t=P(null),o=$e(te?document.body:null);return(a,n)=>(r(),w(ce,{name:"fade",onEnter:n[0]||(n[0]=c=>o.value=!0),onAfterLeave:n[1]||(n[1]=c=>o.value=!1)},{default:h(()=>[e.open?(r(),i("div",{key:0,class:"VPNavScreen",ref_key:"screen",ref:t,id:"VPNavScreen"},[s("div",ps,[m(a.$slots,"nav-screen-content-before",{},void 0,!0),_(is,{class:"menu"}),_(ms,{class:"translations"}),_(Bn,{class:"appearance"}),_(ls,{class:"social-links"}),m(a.$slots,"nav-screen-content-after",{},void 0,!0)])],512)):f("",!0)]),_:3}))}}),hs=S(us,[["__scopeId","data-v-0ad0c2e2"]]),ys={key:0,class:"VPNav"},gs=x({__name:"VPNav",setup(e){const{isScreenOpen:t,closeScreen:o,toggleScreen:a}=da(),{frontmatter:n}=M(),c=b(()=>n.value.navbar!==!1);return Me("close-screen",o),K(()=>{te&&document.documentElement.classList.toggle("hide-nav",!c.value)}),(d,p)=>c.value?(r(),i("header",ys,[_(On,{"is-screen-open":l(t),onToggleScreen:l(a)},{"nav-bar-title-before":h(()=>[m(d.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":h(()=>[m(d.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":h(()=>[m(d.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":h(()=>[m(d.$slots,"nav-bar-content-after",{},void 0,!0)]),_:3},8,["is-screen-open","onToggleScreen"]),_(hs,{open:l(t)},{"nav-screen-content-before":h(()=>[m(d.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":h(()=>[m(d.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3},8,["open"])])):f("",!0)}}),fs=S(gs,[["__scopeId","data-v-13b6eb60"]]),vs=["role","tabindex"],xs={key:1,class:"items"},ks=x({__name:"VPSidebarItem",props:{item:{},depth:{}},setup(e){const t=e,{collapsed:o,collapsible:a,isLink:n,isActiveLink:c,hasActiveLink:d,hasChildren:p,toggle:u}=ut(b(()=>t.item)),v=b(()=>p.value?"section":"div"),g=b(()=>n.value?"a":"div"),y=b(()=>p.value?t.depth+2===7?"p":`h${t.depth+2}`:"p"),$=b(()=>n.value?void 0:"button"),T=b(()=>[[`level-${t.depth}`],{collapsible:a.value},{collapsed:o.value},{"is-link":n.value},{"is-active":c.value},{"has-active":d.value}]);function I(V){"key"in V&&V.key!=="Enter"||!t.item.link&&u()}function C(){t.item.link&&u()}return(V,z)=>{const R=W("VPSidebarItem",!0);return r(),w(A(v.value),{class:L(["VPSidebarItem",T.value])},{default:h(()=>[e.item.text?(r(),i("div",U({key:0,class:"item",role:$.value},Ye(e.item.items?{click:I,keydown:I}:{},!0),{tabindex:e.item.items&&0}),[z[1]||(z[1]=s("div",{class:"indicator"},null,-1)),e.item.link?(r(),w(F,{key:0,tag:g.value,class:"link",href:e.item.link,rel:e.item.rel,target:e.item.target},{default:h(()=>[(r(),w(A(y.value),{class:"text",innerHTML:e.item.text},null,8,["innerHTML"]))]),_:1},8,["tag","href","rel","target"])):(r(),w(A(y.value),{key:1,class:"text",innerHTML:e.item.text},null,8,["innerHTML"])),e.item.collapsed!=null&&e.item.items&&e.item.items.length?(r(),i("div",{key:2,class:"caret",role:"button","aria-label":"toggle section",onClick:C,onKeydown:We(C,["enter"]),tabindex:"0"},[...z[0]||(z[0]=[s("span",{class:"vpi-chevron-right caret-icon"},null,-1)])],32)):f("",!0)],16,vs)):f("",!0),e.item.items&&e.item.items.length?(r(),i("div",xs,[e.depth<5?(r(!0),i(H,{key:0},D(e.item.items,ve=>(r(),w(R,{key:ve.text,item:ve,depth:e.depth+1},null,8,["item","depth"]))),128)):f("",!0)])):f("",!0)]),_:1},8,["class"])}}}),bs=S(ks,[["__scopeId","data-v-7e70fccd"]]),_s=x({__name:"VPSidebarGroup",props:{items:{}},setup(e){const t=P(!0);let o=null;return B(()=>{o=setTimeout(()=>{o=null,t.value=!1},300)}),Ze(()=>{o!=null&&(clearTimeout(o),o=null)}),(a,n)=>(r(!0),i(H,null,D(e.items,c=>(r(),i("div",{key:c.text,class:L(["group",{"no-transition":t.value}])},[_(bs,{item:c,depth:0},null,8,["item"])],2))),128))}}),ws=S(_s,[["__scopeId","data-v-ecb5358a"]]),Ss={class:"nav",id:"VPSidebarNav","aria-labelledby":"sidebar-aria-label",tabindex:"-1"},$s=x({__name:"VPSidebar",props:{open:{type:Boolean}},setup(e){const{sidebarGroups:t,hasSidebar:o}=E(),a=e,n=P(null),c=$e(te?document.body:null);O([a,n],()=>{a.open?(c.value=!0,n.value?.focus()):c.value=!1},{immediate:!0,flush:"post"});const d=P(0);return O(t,()=>{d.value+=1},{deep:!0}),(p,u)=>l(o)?(r(),i("aside",{key:0,class:L(["VPSidebar",{open:e.open}]),ref_key:"navEl",ref:n,onClick:u[0]||(u[0]=Re(()=>{},["stop"]))},[u[2]||(u[2]=s("div",{class:"curtain"},null,-1)),s("nav",Ss,[u[1]||(u[1]=s("span",{class:"visually-hidden",id:"sidebar-aria-label"}," Sidebar Navigation ",-1)),m(p.$slots,"sidebar-nav-before",{},void 0,!0),(r(),w(ws,{items:l(t),key:d.value},null,8,["items"])),m(p.$slots,"sidebar-nav-after",{},void 0,!0)])],2)):f("",!0)}}),Ms=S($s,[["__scopeId","data-v-41586462"]]),Ps=x({__name:"VPSkipLink",setup(e){const{theme:t}=M(),o=X(),a=P();O(()=>o.path,()=>a.value.focus());function n({target:c}){const d=document.getElementById(decodeURIComponent(c.hash).slice(1));if(d){const p=()=>{d.removeAttribute("tabindex"),d.removeEventListener("blur",p)};d.setAttribute("tabindex","-1"),d.addEventListener("blur",p),d.focus(),window.scrollTo(0,0)}}return(c,d)=>(r(),i(H,null,[s("span",{ref_key:"backToTop",ref:a,tabindex:"-1"},null,512),s("a",{href:"#VPContent",class:"VPSkipLink visually-hidden",onClick:n},k(l(t).skipToContentLabel||"Skip to content"),1)],64))}}),Ts=S(Ps,[["__scopeId","data-v-654948f2"]]),Ls=x({__name:"Layout",setup(e){const{isOpen:t,open:o,close:a}=E(),n=X();O(()=>n.path,a),pt(t,a);const{frontmatter:c}=M(),d=qe(),p=b(()=>!!d["home-hero-image"]);return Me("hero-image-slot-exists",p),(u,v)=>{const g=W("Content");return l(c).layout!==!1?(r(),i("div",{key:0,class:L(["Layout",l(c).pageClass])},[m(u.$slots,"layout-top",{},void 0,!0),_(Ts),_(Xe,{class:"backdrop",show:l(t),onClick:l(a)},null,8,["show","onClick"]),_(fs,null,{"nav-bar-title-before":h(()=>[m(u.$slots,"nav-bar-title-before",{},void 0,!0)]),"nav-bar-title-after":h(()=>[m(u.$slots,"nav-bar-title-after",{},void 0,!0)]),"nav-bar-content-before":h(()=>[m(u.$slots,"nav-bar-content-before",{},void 0,!0)]),"nav-bar-content-after":h(()=>[m(u.$slots,"nav-bar-content-after",{},void 0,!0)]),"nav-screen-content-before":h(()=>[m(u.$slots,"nav-screen-content-before",{},void 0,!0)]),"nav-screen-content-after":h(()=>[m(u.$slots,"nav-screen-content-after",{},void 0,!0)]),_:3}),_(ca,{open:l(t),onOpenMenu:l(o)},null,8,["open","onOpenMenu"]),_(Ms,{open:l(t)},{"sidebar-nav-before":h(()=>[m(u.$slots,"sidebar-nav-before",{},void 0,!0)]),"sidebar-nav-after":h(()=>[m(u.$slots,"sidebar-nav-after",{},void 0,!0)]),_:3},8,["open"]),_(qo,null,{"page-top":h(()=>[m(u.$slots,"page-top",{},void 0,!0)]),"page-bottom":h(()=>[m(u.$slots,"page-bottom",{},void 0,!0)]),"not-found":h(()=>[m(u.$slots,"not-found",{},void 0,!0)]),"home-hero-before":h(()=>[m(u.$slots,"home-hero-before",{},void 0,!0)]),"home-hero-info-before":h(()=>[m(u.$slots,"home-hero-info-before",{},void 0,!0)]),"home-hero-info":h(()=>[m(u.$slots,"home-hero-info",{},void 0,!0)]),"home-hero-info-after":h(()=>[m(u.$slots,"home-hero-info-after",{},void 0,!0)]),"home-hero-actions-after":h(()=>[m(u.$slots,"home-hero-actions-after",{},void 0,!0)]),"home-hero-image":h(()=>[m(u.$slots,"home-hero-image",{},void 0,!0)]),"home-hero-after":h(()=>[m(u.$slots,"home-hero-after",{},void 0,!0)]),"home-features-before":h(()=>[m(u.$slots,"home-features-before",{},void 0,!0)]),"home-features-after":h(()=>[m(u.$slots,"home-features-after",{},void 0,!0)]),"doc-footer-before":h(()=>[m(u.$slots,"doc-footer-before",{},void 0,!0)]),"doc-before":h(()=>[m(u.$slots,"doc-before",{},void 0,!0)]),"doc-after":h(()=>[m(u.$slots,"doc-after",{},void 0,!0)]),"doc-top":h(()=>[m(u.$slots,"doc-top",{},void 0,!0)]),"doc-bottom":h(()=>[m(u.$slots,"doc-bottom",{},void 0,!0)]),"aside-top":h(()=>[m(u.$slots,"aside-top",{},void 0,!0)]),"aside-bottom":h(()=>[m(u.$slots,"aside-bottom",{},void 0,!0)]),"aside-outline-before":h(()=>[m(u.$slots,"aside-outline-before",{},void 0,!0)]),"aside-outline-after":h(()=>[m(u.$slots,"aside-outline-after",{},void 0,!0)]),"aside-ads-before":h(()=>[m(u.$slots,"aside-ads-before",{},void 0,!0)]),"aside-ads-after":h(()=>[m(u.$slots,"aside-ads-after",{},void 0,!0)]),_:3}),_(Jo),m(u.$slots,"layout-bottom",{},void 0,!0)],2)):(r(),w(g,{key:1}))}}}),Hs=S(Ls,[["__scopeId","data-v-f81a5f2e"]]),Ve={Layout:Hs,enhanceApp:({app:e})=>{e.component("Badge",je)}},Ds=[{id:"celestial",name:"Celestial Plugin",description:"Tempo plugin to add Terms for location-aware solar twilight events, lunar phase tracking, and astronomical seasons / tidal mechanics",packageName:"@magmacomputing/tempo-plugin-celestial",plan:"community",status:"active",version:"1.3.0"},{id:"batch",name:"Batch Plugin",description:"Tempo community plugin bringing C-level parallelization to massive date arrays via SharedArrayBuffer and Worker Threads.",packageName:"@magmacomputing/tempo-plugin-batch",plan:"community",status:"active",version:"1.2.1"},{id:"finance",name:"Finance Plugin",description:"Tempo Community Plugin: Finance namespace and fiscal year utilities",packageName:"@magmacomputing/tempo-plugin-finance",plan:"community",status:"active",version:"1.1.0"},{id:"snap",name:"Snap Plugin",description:"Tempo plugin for rounding and snapping dates to custom minute, hour, or sub-second intervals — ideal for calendar UIs, time-pickers, and telemetry aggregation",packageName:"@magmacomputing/tempo-plugin-snap",plan:"community",status:"active",version:"1.4.2"},{id:"sync",name:"Sync Plugin",description:"Tempo community plugin providing lock-free, highly precise cross-thread synchronization via SharedArrayBuffer and Atomics.",packageName:"@magmacomputing/tempo-plugin-sync",plan:"community",status:"active",version:"1.1.2"},{id:"ai",name:"AI Plugin",description:"Tempo community plugin for LLM-powered natural language parsing.",packageName:"@magmacomputing/tempo-plugin-ai",plan:"community",status:"active",version:"2.3.2"},{id:"ticker",name:"Ticker Plugin",description:"Tempo plugin that provides a high-performance continuous execution loop (Ticker) based on temporal mathematics.",packageName:"@magmacomputing/tempo-plugin-ticker",plan:"community",status:"active",version:"2.6.1"},{id:"geo",name:"Geo Plugin",description:"Tempo community plugin for IP geolocation lookup, browser hardware location services, and coordinate resolution.",packageName:"@magmacomputing/tempo-plugin-geo",plan:"community",status:"active",version:"1.4.2"},{id:"_std",name:"_std Plugin",description:"Standard built-in Terms for @magmacomputing/tempo (showcase implementation — not published separately)",packageName:"@magmacomputing/tempo-std",plan:"community",status:"active",version:"1.0.0",hidden:!0},{id:"dialects",name:"Dialects Plugin",description:"Tempo Community Plugin: Format dialects for Unicode LDML/Luxon, Moment, POSIX strftime, and Oracle/SQL TO_CHAR",packageName:"@magmacomputing/tempo-plugin-dialects",version:"1.1.0",plan:"community",status:"active"},{id:"holidays",name:"Holidays Plugin",description:"Regional bank holiday, public holiday, and business day SLA scheduling plugin for Tempo",packageName:"@magmacomputing/tempo-plugin-holidays",version:"1.0.2",plan:"community",status:"active"},{id:"spatial",name:"Spatial Plugin",description:"Tempo community plugin for GIS spatial geometry, Great-Circle navigation, transit velocity, and impossible travel anomaly detection.",packageName:"@magmacomputing/tempo-plugin-spatial",version:"1.0.1",plan:"community",status:"active"},{id:"ntp",name:"Ntp Plugin",description:"Tempo plugin providing client-server network time synchronization and monotonic clock drift compensation using Cristian's algorithm and HTTP Server-Timing headers.",packageName:"@magmacomputing/tempo-plugin-ntp",version:"1.0.0",plan:"community",status:"active"}],Is={class:"catalog-container"},Cs={class:"domain-header"},Vs=["id"],Ns={class:"domain-desc"},As={class:"row-list"},Fs={class:"plugin-info"},Os={class:"title-line"},Es={class:"plugin-name"},zs={key:0,class:"version-tag"},Us={key:1,class:"badge experimental-badge"},Bs={class:"plugin-desc"},Ys={class:"plugin-actions"},Ws={class:"copy-wrapper"},Zs=["onClick"],Rs={key:0,width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"#10b981","stroke-width":"2.5"},qs={key:1,width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},Gs={key:0,class:"copy-tooltip"},Qs=["href"],js={key:0,class:"premium-section"},Ks={class:"row-list"},Js={class:"plugin-info"},Xs={class:"title-line"},er={class:"plugin-name"},tr={key:0,class:"version-tag"},or={key:1,class:"badge experimental-badge"},ar={class:"plugin-desc"},nr={class:"plugin-actions"},sr={class:"copy-wrapper"},rr=["onClick"],ir={key:0,width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"#10b981","stroke-width":"2.5"},lr={key:1,width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},cr={key:0,class:"copy-tooltip"},dr=["href"],mr={key:1,class:"coming-soon-section"},pr={class:"row-list"},ur={class:"plugin-info"},hr={class:"title-line"},yr={class:"plugin-name"},gr={key:0,class:"version-tag"},fr={class:"plugin-desc"},vr=x({__name:"CatalogList",setup(e){const t=P(Ds),o=b(()=>t.value.filter(v=>!v.hidden&&v.plan==="community"&&(v.status==="active"||v.status==="experimental"))),a=b(()=>t.value.filter(v=>!v.hidden&&v.plan!=="community"&&(v.status==="active"||v.status==="experimental"))),n=b(()=>t.value.filter(v=>!v.hidden&&v.status==="coming_soon")),c=[{id:"geo",title:"🌍 Geolocation & Regional Calendars",description:"Hardware GPS / IP geolocation resolution, cultural calendars, bank holidays, and SLA business day arithmetic.",pluginIds:["geo","holidays","spatial"]},{id:"celestial",title:"☀️ Celestial & Astronomical Science",description:"Hemisphere-aware solar events, lunar phase tracking, solstices, and twilight boundaries.",pluginIds:["astro","celestial"]},{id:"ai",title:"🤖 AI & Natural Language",description:"LLM-powered natural language date parsing, narrative formatting, and recurrence rules.",pluginIds:["ai"]},{id:"business",title:"💼 Business, Finance & UI Utilities",description:"Fiscal calendars, financial namespaces, and precision block-snapping for UI controls.",pluginIds:["finance","snap"]},{id:"system",title:"⚡ High Performance & System Execution",description:"Lock-free thread synchronization, continuous execution loops, and SAB multi-threading.",pluginIds:["batch","ntp","sync","ticker"]},{id:"dialects",title:"🗣️ Formats & Dialects",description:"Format dialects for Unicode LDML/Luxon, Moment.js, and POSIX strftime compatibility.",pluginIds:["dialects"]}],d=b(()=>{const v=o.value,g=c.map(T=>({...T,plugins:v.filter(I=>T.pluginIds.includes(I.id))})).filter(T=>T.plugins.length>0),y=new Set(c.flatMap(T=>T.pluginIds)),$=v.filter(T=>!y.has(T.id));return $.length>0&&g.push({id:"other",title:"🧩 Other Extensions",description:"General-purpose community plugins for Tempo.",pluginIds:$.map(T=>T.id),plugins:$}),g}),p=P(null),u=v=>{navigator.clipboard.writeText(`npm install ${v}`),p.value=v,setTimeout(()=>{p.value===v&&(p.value=null)},2e3)};return(v,g)=>(r(),i("div",Is,[s("section",null,[g[3]||(g[3]=s("h2",{id:"community",class:"section-title"},"Community Plugins",-1)),g[4]||(g[4]=s("p",{class:"section-subtitle"},"Free, open-source extensions under the MIT license organized by functional domain.",-1)),(r(!0),i(H,null,D(d.value,y=>(r(),i("div",{key:y.id,class:"domain-group"},[s("div",Cs,[s("h3",{id:y.id,class:"domain-title"},k(y.title),9,Vs),s("p",Ns,k(y.description),1)]),s("div",As,[(r(!0),i(H,null,D(y.plugins,$=>(r(),i("div",{key:$.id,class:L(["plugin-row",{"experimental-row":$.status==="experimental"}])},[s("div",Fs,[s("div",Os,[s("span",Es,k($.name),1),$.version?(r(),i("span",zs,"v"+k($.version),1)):f("",!0),$.status==="experimental"?(r(),i("span",Us,"Experimental")):f("",!0)]),s("p",Bs,k($.description),1)]),s("div",Ys,[s("div",Ws,[s("button",{onClick:T=>u($.packageName),class:L(["action-btn copy-icon-btn",{copied:p.value===$.packageName}]),title:"Copy Install Command"},[p.value===$.packageName?(r(),i("svg",Rs,[...g[0]||(g[0]=[s("polyline",{points:"20 6 9 17 4 12"},null,-1)])])):(r(),i("svg",qs,[...g[1]||(g[1]=[s("path",{d:"M8 6V4a2 2 0 0 1 2-2h6l4 4v11a2 2 0 0 1-2 2h-3"},null,-1),s("path",{d:"M16 2v4h4"},null,-1),s("path",{d:"M10 6H5a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V11l-5-5z"},null,-1),s("path",{d:"M10 6v5h5"},null,-1)])]))],10,Zs),p.value===$.packageName?(r(),i("span",Gs,"Copied!")):f("",!0)]),s("a",{href:`../9-plugins/${$.id}.index`,class:"action-btn docs-icon-btn",title:"View Documentation"},[...g[2]||(g[2]=[s("svg",{width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},[s("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),s("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})],-1)])],8,Qs)])],2))),128))])]))),128))]),a.value.length>0?(r(),i("section",js,[g[9]||(g[9]=Pe('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Premium Plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enterprise-grade extensions requiring a license token.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo License Registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Go to the Tempo License Registry 👈
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manage your subscriptions and retrieve your license key.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',3)),s("div",Ks,[(r(!0),i(H,null,D(a.value,y=>(r(),i("div",{key:y.id,class:L(["plugin-row premium-row",{"experimental-row":y.status==="experimental"}])},[s("div",Js,[s("div",Xs,[s("span",er,k(y.name),1),y.version?(r(),i("span",tr,"v"+k(y.version),1)):f("",!0),g[5]||(g[5]=s("span",{class:"badge premium-badge"},"Premium",-1)),y.status==="experimental"?(r(),i("span",or,"Experimental")):f("",!0)]),s("p",ar,k(y.description),1)]),s("div",nr,[s("div",sr,[s("button",{onClick:$=>u(y.packageName),class:L(["action-btn copy-icon-btn",{copied:p.value===y.packageName}]),title:"Copy Install Command"},[p.value===y.packageName?(r(),i("svg",ir,[...g[6]||(g[6]=[s("polyline",{points:"20 6 9 17 4 12"},null,-1)])])):(r(),i("svg",lr,[...g[7]||(g[7]=[s("path",{d:"M8 6V4a2 2 0 0 1 2-2h6l4 4v11a2 2 0 0 1-2 2h-3"},null,-1),s("path",{d:"M16 2v4h4"},null,-1),s("path",{d:"M10 6H5a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V11l-5-5z"},null,-1),s("path",{d:"M10 6v5h5"},null,-1)])]))],10,rr),p.value===y.packageName?(r(),i("span",cr,"Copied!")):f("",!0)]),s("a",{href:`../9-plugins/${y.id}.index`,class:"action-btn docs-icon-btn",title:"View Documentation"},[...g[8]||(g[8]=[s("svg",{width:"15",height:"15",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},[s("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),s("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})],-1)])],8,dr)])],2))),128))])])):f("",!0),n.value.length>0?(r(),i("section",mr,[g[10]||(g[10]=s("h2",{id:"coming-soon",class:"section-title"},"Coming Soon",-1)),s("div",pr,[(r(!0),i(H,null,D(n.value,y=>(r(),i("div",{key:y.id,class:"plugin-row disabled"},[s("div",ur,[s("div",hr,[s("span",yr,k(y.name),1),y.version?(r(),i("span",gr,"v"+k(y.version),1)):f("",!0)]),s("p",fr,k(y.description),1)])]))),128))])])):f("",!0)]))}}),xr=S(vr,[["__scopeId","data-v-1da38fb5"]]),kr={quickstart:{label:"Preset: Quick Start (Core)",code:`// ⚡ Quick Start with Tempo +const t = new Tempo('now'); + +console.log('ISO 8601 String:', t.iso); +console.log('Formatted:', t.format('{wkd}, {mon} {dd:ord}, {yyyy} at {h12}:{mi} [{tz}]')); +console.log('Days until next Friday:', t.until('next Friday').format()); + +// Return value displays in the top Result card: +return t.format('{yyyy}-{mmm}-{dd}');`},weekend:{label:"Preset: Weekend Check (Cookbook)",code:`// 🗓️ Weekend Checking (from Tempo Cookbook) +const today = new Tempo(); +console.log('Today:', today.format('{www}, {dd} {mon}')); +console.log('ISO Day of Week (1..7):', today.dow); + +// 1. Simple ISO check (Sat = 6, Sun = 7) +const isIsoWeekend = today.dow >= 6; +console.log('Is ISO Weekend?', isIsoWeekend); + +// 2. Locale-Aware check using t.intl.weekend +const us = new Tempo({ locale: 'en-US' }); +const sa = new Tempo({ locale: 'ar-SA' }); + +console.log('en-US Weekend Days:', JSON.stringify(us.intl.weekend)); // [6, 7] (Saturday, Sunday) +console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.weekend)); // [5, 6] (Friday, Saturday) + +return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.weekend.includes(today.dow)}\`;`},quarters:{label:"Preset: Fiscal Quarters & Math (Core)",code:`// 💼 Fiscal Quarters and Tempo Math +const t = new Tempo('2026-02-15', { sphere: 'north' }); + +console.log('Quarter Key:', t.term.qtr); // "Q1" +console.log('Quarter Label:', t.term.quarter.label); // "First Quarter" +console.log('Quarter Start:', t.term.quarter.start.format('{yyyy}-{mm}-{dd}')); +console.log('Quarter End:', t.term.quarter.end.format('{yyyy}-{mm}-{dd}')); + +// Chainable Semantic Term Mutation: +const nextQtr = t.add({ '#quarter': 1 }); +console.log('Next Quarter (Key):', nextQtr.term.qtr); // "Q2" +console.log('Next Quarter (Label):', nextQtr.term.quarter.label); // "Second Quarter" + +return nextQtr.format('Next quarter: {#quarter}');`},seasons:{label:"Preset: Seasons & Lunar Phases (Celestial)",plugin:"celestial",code:`// 🌍 Hemispheric Seasons & Lunar Phases +// Tempo terms are hemisphere-aware based on geo coordinates or sphere setting: +const sydney = new Tempo('2026-07-01', { sphere: 'south' }); +const london = new Tempo('2026-07-01', { sphere: 'north' }); + +console.log('Sydney in July:', sydney.term.szn); // "Winter" +console.log('London in July:', london.term.szn); // "Summer" + +// Celestial Plugin (Lunar Phase): +const now = new Tempo(); +console.log('Moon Phase:', now.term.lunar.phase, now.term.lunar.emoji); +console.log('Illumination:', (now.term.lunar.illumination * 100).toFixed(1) + '%'); + +return \`Current Lunar Phase: \${now.term.lunar.phase}\`;`},spatial:{label:"Preset: Spatial & Navigation (GIS, Haversine, Transit)",plugin:"spatial",code:`// 🧭 Great-Circle Navigation & Spatial Geofencing (@magmacomputing/tempo-plugin-spatial) +const { SpatialPlugin } = await import('@magmacomputing/tempo-plugin-spatial'); +Tempo.use(SpatialPlugin); + +const sydney = { lat: -33.8688, lng: 151.2093 }; +const london = { lat: 51.5074, lng: -0.1278 }; + +// 1. Haversine Distance & Initial Bearing +const distKm = Tempo.spatial.distance(sydney, london, 'km'); +const heading = Tempo.spatial.bearing(sydney, london); +console.log('Distance Sydney -> London:', distKm.toFixed(1), 'km'); +console.log('Compass Heading:', heading.toFixed(1) + '°'); + +// 2. Geographic Midpoint +const mid = Tempo.spatial.midpoint(sydney, london); +console.log('Great-Circle Midpoint:', \`\${mid.latitude.toFixed(2)}°, \${mid.longitude.toFixed(2)}° (\${mid.sphere})\`); + +// 3. Impossible Travel Anomaly Detection +const loginSydney = new Tempo('2026-03-31T08:00:00Z', { geo: sydney }); +const loginLondon = new Tempo('2026-03-31T09:30:00Z', { geo: london }); // 1.5h later +const speed = loginSydney.spatialVelocity(loginLondon); +const isAnomaly = Tempo.spatial.isImpossibleTravel(loginSydney, loginLondon); + +console.log('Transit Velocity:', speed.toFixed(1), 'km/h'); +console.log('Impossible Travel Alert?', isAnomaly); + +return \`Sydney -> London: \${distKm.toFixed(0)} km (Midpoint: \${mid.latitude.toFixed(1)}°, \${mid.longitude.toFixed(1)}°)\`;`},geo:{label:"Preset: Live Geolocation & Providers (Geo)",plugin:"geo",code:`// 🌍 Live Geolocation & Pluggable Providers (@magmacomputing/tempo-plugin-geo) +// Note: In browser sandbox, resolves browser GPS or IP-based coordinates + +const lookup = await Tempo.geo.lookup({ reverse: true }); +console.log('Detected City:', lookup.city ?? 'Local City', ',', lookup.country ?? 'Local Country'); +console.log('Coordinates:', lookup.lat, lookup.lng); + +// Attach coordinates to a Tempo instance: +const localTime = new Tempo('now', { geo: lookup }); +console.log('Astronomical Season:', localTime.term.szn); +console.log('Moon Phase:', localTime.term.lunar.phase, localTime.term.lunar.emoji); + +// Reverse Geocoding to place details: +const place = await Tempo.geo.reverse({ lat: -33.8688, lng: 151.2093 }); +console.log('Reverse Geocoded Place:', place.city, place.country); + +return \`Located at \${lookup.city ?? 'Local City'} (\${lookup.lat?.toFixed(2)}°, \${lookup.lng?.toFixed(2)}°)\`;`},holidays:{label:"Preset: Regional Public Holidays & SLA Business Days",plugin:"holidays",code:`// 🏖️ Regional Public Holidays & SLA Business Days (@magmacomputing/tempo-plugin-holidays) +const { HolidaysPlugin } = await import('@magmacomputing/tempo-plugin-holidays'); +Tempo.use(HolidaysPlugin); + +// 1. Evaluate holiday by country or instance geo metadata +const christmas = new Tempo('2026-12-25', { geo: { country: 'US' } }); +console.log('Is Christmas Day holiday in US?', christmas.holidays.isHoliday()); +console.log('Holiday Name:', christmas.holidays.name); +console.log('Is Business Day?', christmas.holidays.isBusinessDay()); + +// 2. Next & previous business day arithmetic +const nextWorkDay = christmas.holidays.nextBusinessDay(); +console.log('Next Business Day after Christmas:', nextWorkDay.format('{www}, {dd} {mon} {yyyy}')); + +// 3. Add N working business days +const deadline = christmas.holidays.addBusinessDays(5); +console.log('5 Business Days later:', deadline.format('{www}, {dd} {mon} {yyyy}')); + +// 4. SLA Working Hours calculation +const ticketOpened = new Tempo('2026-01-23 15:00:00', { geo: { country: 'AU' } }); +const ticketResolved = new Tempo('2026-01-27 11:00:00', { geo: { country: 'AU' } }); +const hours = ticketOpened.holidays.workingHoursUntil(ticketResolved); +console.log('SLA Working Hours (9am-5pm window):', hours, 'hours'); + +return \`Christmas: \${christmas.holidays.name} (Next work day: \${nextWorkDay.format('{www}, {dd} {mon}')})\`;`},dialects:{label:"Preset: Dialects (LDML, strftime, Oracle, .NET, MySQL, Sheet)",plugin:"dialects",code:`// 🌐 External Dialect Formatting, Parsing & Transpilation +// Dynamic import of @magmacomputing/tempo-plugin-dialects +const { DialectsPlugin, DIALECT } = await import('@magmacomputing/tempo-plugin-dialects'); +Tempo.use(DialectsPlugin); + +const t = new Tempo('2026-10-24T15:30:45.123'); + +// 1. Format across external ecosystems +console.log('Luxon / LDML:', t.toFormat('dd LLL yyyy, HH:mm')); +console.log('POSIX strftime:', t.dialects.strftime('%Y-%m-%d %H:%M:%S')); +console.log('Oracle / SQL TO_CHAR:', t.dialects.oracle('YYYY-MM-DD HH24:MI:SS')); +console.log('.NET DateTime:', t.dialects.dotnet('yyyy-MM-dd HH:mm:ss.fff')); +console.log('MySQL DATE_FORMAT:', t.dialects.mysql('%Y-%m-%d %H:%i:%s')); +console.log('Excel / Sheets:', t.dialects.sheet('yyyy-mm-dd hh:mm:ss')); + +// 2. Ingest & Explain legacy masks into native Tempo {token} syntax +const inspection = Tempo.dialects.explain('[Report for] MMMM Do, YYYY [at] hh:mm A', DIALECT.Moment); +console.log('Explained Moment -> Tempo IR:', inspection.pattern); + +// 3. Export canonical Tempo templates to external dialect models +const sqlExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', DIALECT.Oracle); +console.log('Exported Tempo -> SQL TO_CHAR model:', sqlExport.pattern); +const sheetExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', DIALECT.Sheet); +console.log('Exported Tempo -> Spreadsheet mask:', sheetExport.pattern); + +// 4. Universal Cross-Dialect Transpilation (.convert) +const posixToOracle = Tempo.dialects.convert('%Y-%m-%d %H:%M:%S', DIALECT.Strftime, DIALECT.Oracle); +console.log('Converted POSIX -> Oracle:', posixToOracle.pattern); + +// 5. Multi-candidate fallback parser +const parsed = Tempo.fromFormats('24/10/2026 15:30', [ + 'yyyy-MM-dd HH:mm', + 'dd/MM/yyyy HH:mm', +]); +console.log('Parsed multi-candidate ISO:', parsed.iso); + +return \`Transpiled POSIX to Oracle: \${posixToOracle.pattern}\`;`},celestial:{label:"Preset: Celestial Solar & Lunar Ephemeris",plugin:"celestial",code:`// 🌙 Celestial Solar & Lunar Ephemeris Demo (@magmacomputing/tempo-plugin-celestial) +const now = new Tempo(); +console.log('Moon Phase:', now.term.lunar.phase); +console.log('Illumination:', (now.term.lunar.illumination * 100).toFixed(1) + '%'); +console.log('Is King Tide?', now.term.tides.isKingTide); + +return \`Phase: \${now.term.lunar.phase} (\${(now.term.lunar.illumination * 100).toFixed(0)}% illuminated)\`;`},astro:{label:"Preset: Astronomical Seasons & Solstices",plugin:"celestial",code:`// ☀️ Astronomical Seasons & Solstices Demo (@magmacomputing/tempo-plugin-celestial) +const sydney = new Tempo('2026-07-01', { sphere: 'south' }); +const london = new Tempo('2026-07-01', { sphere: 'north' }); + +console.log('Sydney in July:', sydney.term.astro, '-> Season:', sydney.term.szn); +console.log('London in July:', london.term.astro, '-> Season:', london.term.szn); + +const equinox = new Tempo('2026-03-20', { sphere: 'north' }); +console.log('March 20 Equinox:', equinox.term.equinox); + +return \`Sydney: \${sydney.term.szn} | London: \${london.term.szn}\`;`},finance:{label:"Preset: Fiscal & Financial Math",plugin:"finance",code:`// 💼 Fiscal & Financial Math Demo (@magmacomputing/tempo-plugin-finance) +const { FinanceNamespace } = await import('@magmacomputing/tempo-plugin-finance'); +Tempo.use(FinanceNamespace); + +const t = new Tempo('2026-07-15'); +console.log('Fiscal Quarter:', t.finance.fiscalQuarter); +console.log('Tax Year:', t.finance.taxYear); +console.log('Is Fiscal Year Start?', t.finance.isFiscalYearStart()); + +return \`Fiscal Q\${t.finance.fiscalQuarter} (Tax Year \${t.finance.taxYear})\`;`},snap:{label:"Preset: Time Snapping & Quantization",plugin:"snap",code:`// ⏱️ Time Snapping & Quantization Demo (@magmacomputing/tempo-plugin-snap) +const { SnapPlugin } = await import('@magmacomputing/tempo-plugin-snap'); +Tempo.use(SnapPlugin); + +const t = new Tempo('2026-06-01T14:08:23Z'); +console.log('Original time:', t.format('{hh}:{mi}:{ss}')); + +// Snap to nearest 15-minute block +const snapped15m = t.snap(); +console.log('Snapped (15m):', snapped15m.format('{hh}:{mi}:{ss}')); + +// Snap to 1-hour interval upward +const snapHourUp = t.snap({ hh: 1, direction: 'up' }); +console.log('Snapped Up (1h):', snapHourUp.format('{hh}:{mi}:{ss}')); + +return \`Snapped to \${snapped15m.format('{hh}:{mi}')}\`;`},batch:{label:"Preset: Parallel Bulk Mutation",plugin:"batch",code:`// ⚡ Parallel Bulk Mutation Demo (@magmacomputing/tempo-plugin-batch) +// Note: @magmacomputing/tempo-plugin-batch uses Node.js worker_threads for multi-threaded processing. +const timestamps = [1700000000000, 1700086400000, 1700172800000]; +console.log('Original timestamps count:', timestamps.length); + +let mutated; +const isNode = typeof process !== 'undefined' && Boolean(process.versions?.node); + +if (isNode) { + const { BatchPlugin } = await import('@magmacomputing/tempo-plugin-batch'); + Tempo.use(BatchPlugin); + mutated = await Tempo.batch(timestamps, '+1w'); +} else { + console.info('Running browser fallback (BatchPlugin worker_threads requires Node.js).'); + mutated = timestamps.map(ts => new Tempo(ts).add({ weeks: 1 }).epoch.ms); +} + +console.log('Mutated +1 week timestamps:', mutated); +return \`Batch processed \${mutated.length} timestamps successfully!\`;`},sync:{label:"Preset: Cross-Thread Time Sync",plugin:"sync",code:`// 🔄 Cross-Thread Time Sync Demo (@magmacomputing/tempo-plugin-sync) +const { SyncPlugin } = await import('@magmacomputing/tempo-plugin-sync'); +Tempo.use(SyncPlugin); + +// SharedArrayBuffer requires Cross-Origin Isolation (COOP/COEP) in browsers: +// Cross-Origin-Opener-Policy: same-origin +// Cross-Origin-Embedder-Policy: require-corp +if (typeof SharedArrayBuffer === 'undefined') { + console.warn('SharedArrayBuffer is unavailable in this environment.'); + console.info('To enable in browsers, serve with COOP/COEP cross-origin isolation headers.'); + return 'SharedArrayBuffer unavailable (requires cross-origin isolation or Node.js)'; +} + +Tempo.sync.startClock({ interval: 1 }); +try { + const buffer = Tempo.sync.getBuffer(); + console.log('Clock buffer byte length:', buffer.byteLength); + + const nowMs = Tempo.sync.now(buffer); + console.log('High-precision current epoch ms:', nowMs); + + return \`Sync read successful (Epoch: \${nowMs})\`; +} finally { + Tempo.sync.stopClock(); +}`},ntp:{label:"Preset: Network Time Sync & Drift (NTP)",plugin:"ntp",code:`// 🌐 Network Time Sync & Drift Calibration (@magmacomputing/tempo-plugin-ntp) +const { NtpPlugin } = await import('@magmacomputing/tempo-plugin-ntp'); +Tempo.use(NtpPlugin); + +console.log('Calibrating clock with remote time source...'); +const sample = await Tempo.ntp.sync('https://worldtimeapi.org/api/timezone/Etc/UTC'); + +console.log('Sync Result: Offset', sample.offsetMs, 'ms (Uncertainty: ±' + sample.uncertaintyMs + 'ms, Samples: ' + sample.sampleCount + ')'); +console.log('Calibrated Tempo:', Tempo.ntp.now().format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{ms}')); + +return \`Calibrated! Offset: \${Tempo.ntp.offset}ms | Local: \${new Tempo().format('{hh}:{mi}:{ss}.{ms}')} vs NTP: \${Tempo.ntp.now().format('{hh}:{mi}:{ss}.{ms}')}\`;`},ticker:{label:"Preset: Continuous Temporal Ticker",plugin:"ticker",code:`// ⏰ Continuous Temporal Ticker Demo (@magmacomputing/tempo-plugin-ticker) +const { TickerPlugin } = await import('@magmacomputing/tempo-plugin-ticker'); +Tempo.use(TickerPlugin); + +console.log('Starting 1-second cadence ticker...'); +let count = 0; +const ticker = Tempo.ticker({ seconds: 1 }, (t, stop) => { + count++; + console.log(\`Tick #\${count}:\`, t.format('{hh}:{mi}:{ss}')); + if (count >= 3) { + console.log('Ticker stopped after 3 ticks.'); + stop(); + } +}); + +return 'Ticker started (executes in console stream)';`},dynamic:{label:"Preset: Dynamic Plugin (ESM import)",plugin:"ticker",code:`// 📦 Dynamic Plugin Loading via native ESM +console.log('Dynamically importing @magmacomputing/tempo-plugin-ticker...'); +const { TickerPlugin } = await import('@magmacomputing/tempo-plugin-ticker'); + +// Register the dynamically imported plugin +Tempo.use(TickerPlugin); + +console.log('TickerPlugin loaded and active!'); +return 'Dynamic import successful!';`},ai:{label:"Preset: AI Semantic Parsing & Scheduling",plugin:"ai",autoRun:!1,code:`// 🤖 AI Semantic Parsing & Scheduling (@magmacomputing/tempo-plugin-ai) +const { AiPlugin } = await import('@magmacomputing/tempo-plugin-ai'); +Tempo.use(AiPlugin); + +// 1. Configure provider (Trial 'tempo' sandbox or BYOK: 'gemini', 'openai', 'groq') +await Tempo.ai.init({ provider: 'tempo', debug: true }); + +// 2. Parse complex cultural/relative calendar expression +// Note: { force: true } bypasses cached entries for live LLM reasoning +const t = await Tempo.ai.parse("The Friday before Melbourne Cup next year", { force: true }); + +console.log('📅 Parsed: ', t.format('{www}, {yyyy}-{mmm}-{dd}')); +console.log('🧠 Reasoning:', t.ai?.reasoning); +console.log('🎯 Provider: ', t.ai?.provider, \`(confidence: \${t.ai?.confidence})\`); + +if (t.ai?.limits?.remainingRequests !== undefined) { + const resetStr = t.ai.limits.resetAt ? t.ai.limits.resetAt.format('{hh}:{mi}:{ss}') : 'in 1h'; + console.log('⏱️ Quota: ', \`\${t.ai.limits.remainingRequests} req remaining (resets at \${resetStr})\`); +} + +return t.iso;`}},br={key:0,class:"plugin-repl-active"},_r=["src","title"],wr={class:"facade-header"},Sr={class:"facade-title"},$r={class:"plugin-icon",viewBox:"0 0 285 235.319",fill:"#38bdf8",style:{width:"20px",height:"16px",filter:"drop-shadow(0 0 5px rgba(56, 189, 248, 0.45))"}},Mr=["href"],Pr={class:"facade-body"},Tr={class:"facade-code"},Lr=x({__name:"PluginRepl",props:{plugin:{},title:{default:""},snippet:{default:""},height:{default:"460px"}},setup(e){const t=e,o=P(!1),a=b(()=>t.snippet&&t.snippet.trim().length>0?t.snippet.trim():kr[t.plugin]?.code??`// ⚡ Interactive Demo for ${t.plugin} +const t = new Tempo(); +console.log(t.format('{yyyy}-{mm}-{dd}')); +return t.iso;`),n=b(()=>{const p="/magma/repl/index.html",u=a.value?`#code=${btoa(encodeURIComponent(a.value))}`:"";return`${p}?embed=true&plugin=${encodeURIComponent(t.plugin)}${u}`}),c=b(()=>{const p="/magma/repl/index.html",u=a.value?`#code=${btoa(encodeURIComponent(a.value))}`:"";return`${p}?plugin=${encodeURIComponent(t.plugin)}${u}`});function d(){o.value=!0}return(p,u)=>(r(),i("div",{class:"plugin-repl-container",style:q({minHeight:e.height})},[o.value?(r(),i("div",br,[s("iframe",{src:n.value,sandbox:"allow-scripts allow-modals allow-popups",allow:"geolocation",style:q({width:"100%",height:e.height,border:"none",borderRadius:"8px"}),title:e.title||`Interactive ${e.plugin} demo`},null,12,_r)])):(r(),i("div",{key:1,class:"plugin-repl-facade",style:q({height:e.height})},[s("div",wr,[s("div",Sr,[(r(),i("svg",$r,[...u[0]||(u[0]=[Pe('',2)])])),s("span",null,k(e.title||`Interactive Demo (@magmacomputing/tempo-plugin-${e.plugin})`),1)]),s("a",{href:c.value,target:"_blank",rel:"noopener noreferrer",class:"facade-link",title:"Open in Full-Screen REPL"},[...u[1]||(u[1]=[s("span",null,"Open in Full REPL",-1),s("span",null,"↗",-1)])],8,Mr)]),s("div",Pr,[s("pre",Tr,[s("code",null,k(a.value),1)]),s("div",{class:"facade-overlay"},[s("button",{onClick:d,class:"btn-launch",title:"Launch Interactive REPL in this window"},[...u[2]||(u[2]=[s("span",{class:"icon"},"▶",-1),s("span",null,"Run Live Interactive Demo",-1)])]),u[3]||(u[3]=s("span",{class:"facade-hint"},"Executes 100% in browser via native ESM sandbox",-1))])])],4))],4))}}),Hr=S(Lr,[["__scopeId","data-v-f957e754"]]),Dr={class:"dialect-tabs-wrapper"},Ir={class:"dialect-nav",role:"tablist","aria-label":"Dialect Selection"},Cr=["aria-selected","onClick"],Vr={class:"tab-icon"},Nr={class:"tab-name"},Ar={class:"dialect-banner"},Fr={class:"dialect-banner-main"},Or={class:"dialect-title-row"},Er={class:"banner-icon"},zr={class:"banner-title"},Ur={class:"banner-badge"},Br={class:"banner-ecosystem"},Yr={class:"banner-syntax"},Wr={class:"syntax-text"},Zr={class:"dialect-sample-card"},Rr={class:"sample-header"},qr={class:"sample-body"},Gr={class:"dialect-toolbar"},Qr={class:"search-box"},jr={class:"token-count"},Kr={class:"dialect-table-container"},Jr={class:"dialect-token-table"},Xr={class:"col-ext"},ei={class:"col-ext"},ti={class:"token-pill token-ext"},oi={class:"col-tempo"},ai=["title","onClick"],ni={class:"copy-hint"},si={key:1,class:"unsupported-tempo",title:"No direct 1:1 Native Tempo equivalent"},ri={class:"col-cat"},ii=["data-cat"],li={class:"col-desc"},ci={class:"desc-text"},di={class:"example-text"},mi={key:0,class:"notes-text"},pi={key:0},ui={colspan:"4",class:"no-tokens-found"},hi=x({__name:"DialectTabs",setup(e){const t=[{id:"ldml",name:"Unicode LDML",icon:"🌐",ecosystem:"date-fns, Luxon, Angular, CLDR / UTS #35",aliases:["luxon","datefns","cldr"],syntaxNote:"Wrap literal text in single quotes: 'Date: ' yyyy-MM-dd. Escaped quote: ''",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', 'yyyy-MM-dd HH:mm:ss', { dialect: 'ldml' })",sampleFormat:"t.format('yyyy-MM-dd HH:mm:ss.SSS zzzz', { dialect: 'ldml' })",tokens:[{external:"yyyy",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"yy",tempo:"{yy}",category:"Year",description:"2-digit calendar year",example:"26"},{external:"y",tempo:"{yyyy}",category:"Year",description:"Calendar year without zero-padding",example:"2026"},{external:"Y",tempo:"{yow}",category:"Year",description:"Week-numbering year without zero-padding",example:"2026"},{external:"YYYY",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year",example:"2026"},{external:"YY",tempo:"{yow:-2}",category:"Year",description:"2-digit ISO week-numbering year",example:"26"},{external:"MM",tempo:"{mm}",category:"Month",description:"Zero-padded numeric month (01–12)",example:"10"},{external:"M",tempo:"{mm:raw}",category:"Month",description:"Unpadded numeric month (1–12)",example:"10"},{external:"MMM / LLL",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"MMMM / LLLL",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"dd",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"d",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"DDD",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"D",tempo:"{doy:raw}",category:"Day",description:"Unpadded day of year (1–366)",example:"297"},{external:"ww",tempo:"{woy}",category:"Week",description:"Zero-padded ISO week of year (01–53)",example:"43"},{external:"w",tempo:"{woy:raw}",category:"Week",description:"Unpadded ISO week of year (1–53)",example:"43"},{external:"EEEE",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"EEE",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"e / c",tempo:"{dow:locale}",category:"Weekday",description:"Locale-relative day of week (1–7)",example:"6"},{external:"HH",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"H",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"hh",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"h",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"kk",tempo:"{hh}",category:"Hour",description:"24-hour clock (01–24), 24:00 normalized to 00:00",example:"15"},{external:"k",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour clock (1–24)",example:"15"},{external:"mm",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"m",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"ss",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"s",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:"SSS",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:"123"},{external:"SSSSSS",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"SSSSSSSSS",tempo:"{ff:9}",category:"Fractional",description:"Nanoseconds (9 digits)",example:"123456789"},{external:"aa",tempo:"{mer:upper}",category:"Hour",description:"AM / PM marker (uppercase)",example:"PM"},{external:"a",tempo:"{mer}",category:"Hour",description:"am / pm marker (lowercase)",example:"pm"},{external:"z",tempo:"{tz:short}",category:"Timezone",description:"Short localized time zone name",example:"EDT"},{external:"zzzz",tempo:"{tz:long}",category:"Timezone",description:"Full localized time zone name",example:"Eastern Daylight Time"},{external:"ZZZZZ / XXX",tempo:"{tz:offset}",category:"Timezone",description:"ISO 8601 offset with colon",example:"+08:00"},{external:"ZZ / XX",tempo:"{tz:offsetcompact}",category:"Timezone",description:"Compact offset without colon",example:"+0800"},{external:"QQQQ / qqqq",tempo:"{#quarter}",category:"Quarter",description:"Full quarter name (via #quarter Term)",example:"4th quarter"},{external:"Q / q",tempo:"{#quarter}",category:"Quarter",description:"Quarter number 1–4 (via #quarter Term)",example:"4"}]},{id:"moment",name:"Moment.js / Day.js",icon:"⚡",ecosystem:"Moment.js, Day.js",aliases:["dayjs"],syntaxNote:"Wrap literal text in square brackets: [Report Date:] YYYY-MM-DD. Bare characters outside tokens remain literal.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', 'YYYY-MM-DD HH:mm:ss', { dialect: 'moment' })",sampleFormat:"t.format('dddd, MMMM Do YYYY, h:mm:ss a', { dialect: 'moment' })",tokens:[{external:"YYYY",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"YY",tempo:"{yy}",category:"Year",description:"2-digit calendar year",example:"26"},{external:"Y",tempo:"{yyyy}",category:"Year",description:"Calendar year without zero-padding",example:"2026"},{external:"GGGG",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year",example:"2026"},{external:"GG",tempo:"{yow:-2}",category:"Year",description:"2-digit ISO week-numbering year",example:"26"},{external:"MM",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"M",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"MMM",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"MMMM",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"DD",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"D",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"Do",tempo:"{dd:ord}",category:"Day",description:"Ordinal day of month",example:"24th"},{external:"DDDD",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"DDD",tempo:"{doy:raw}",category:"Day",description:"Unpadded day of year (1–366)",example:"297"},{external:"WW",tempo:"{woy}",category:"Week",description:"Zero-padded ISO week of year (01–53)",example:"43"},{external:"W",tempo:"{woy:raw}",category:"Week",description:"Unpadded ISO week of year (1–53)",example:"43"},{external:"dddd",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"ddd",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"dd",tempo:"{www}",category:"Weekday",description:"Two-letter weekday name",example:"Sa"},{external:"d",tempo:"{dow:0}",category:"Weekday",description:"Day of week with Sunday as 0 (0–6)",example:"6"},{external:"E",tempo:"{dow}",category:"Weekday",description:"ISO day of week (1=Monday..7=Sunday)",example:"6"},{external:"HH",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"H",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"hh",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"h",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"kk",tempo:"{hh}",category:"Hour",description:"24-hour clock (01–24), normalized to 00-23",example:"15"},{external:"k",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour clock (1–24)",example:"15"},{external:"mm",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"m",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"ss",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"s",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:"SSS",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:"123"},{external:"SSSSSS",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"SSSSSSSSS",tempo:"{ff:9}",category:"Fractional",description:"Nanoseconds (9 digits)",example:"123456789"},{external:"A",tempo:"{mer:upper}",category:"Hour",description:"Uppercase meridiem (AM / PM)",example:"PM"},{external:"a",tempo:"{mer}",category:"Hour",description:"Lowercase meridiem (am / pm)",example:"pm"},{external:"Z",tempo:"{tz:offset}",category:"Timezone",description:"Standard offset with colon",example:"+08:00"},{external:"ZZ",tempo:"{tz:offsetcompact}",category:"Timezone",description:"Compact offset without colon",example:"+0800"},{external:"z / zz",tempo:"{tz:short}",category:"Timezone",description:"Timezone abbreviation",example:"EDT"},{external:"X",tempo:"{ts}",category:"Epoch",description:"Unix epoch timestamp in seconds",example:"1792848645"},{external:"x",tempo:"",category:"Epoch",description:"Unix epoch timestamp in milliseconds (unsupported in seconds-based {ts})",example:"1792848645000"},{external:"Q",tempo:"{#quarter}",category:"Quarter",description:"Quarter of year (1–4)",example:"4"},{external:"Qo",tempo:"{#quarter:ord}",category:"Quarter",description:"Ordinal quarter of year",example:"4th"}]},{id:"strftime",name:"POSIX strftime",icon:"🐧",ecosystem:"C, Python (datetime.strftime), Ruby, Linux / POSIX systems",aliases:["posix","c","python"],syntaxNote:"All characters not prefixed with % are literal. Use %% for a literal percent sign.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', '%Y-%m-%d %H:%M:%S', { dialect: 'strftime' })",sampleFormat:"t.format('%A, %B %d, %Y %I:%M:%S %p %z', { dialect: 'strftime' })",tokens:[{external:"%Y",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"%y",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"%-y",tempo:"{yy:raw}",category:"Year",description:"Unpadded 2-digit year (0–99)",example:"6"},{external:"%G",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year",example:"2026"},{external:"%g",tempo:"{yow:-2}",category:"Year",description:"2-digit ISO week-numbering year",example:"26"},{external:"%C",tempo:"{cen}",category:"Year",description:"Century number (00–99)",example:"20"},{external:"%m",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"%-m",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"%b / %h",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"%B",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"%d",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"%-d",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"%e",tempo:"{dd:space}",category:"Day",description:"Space-padded day of month ( 1–31)",example:"24"},{external:"%j",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"%V",tempo:"{woy}",category:"Week",description:"Zero-padded ISO week number (01–53)",example:"43"},{external:"%U",tempo:"",category:"Week",description:"Week number with Sunday as first day (00–53)",example:"42"},{external:"%W",tempo:"",category:"Week",description:"Week number with Monday as first day (00–53)",example:"43"},{external:"%A",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"%a",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"%u",tempo:"{dow}",category:"Weekday",description:"ISO weekday (1=Monday..7=Sunday)",example:"6"},{external:"%w",tempo:"{dow:0}",category:"Weekday",description:"Day of week with Sunday as 0 (0–6)",example:"6"},{external:"%H",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"%-H",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"%k",tempo:"{hh:space}",category:"Hour",description:"Space-padded 24-hour ( 0–23)",example:"15"},{external:"%I",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"%-I",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"%l",tempo:"{h12:space}",category:"Hour",description:"Space-padded 12-hour ( 1–12)",example:" 3"},{external:"%M",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"%-M",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"%S",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"%-S",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:"%p",tempo:"{mer:upper}",category:"Hour",description:"Uppercase meridiem (AM / PM)",example:"PM"},{external:"%P",tempo:"{mer}",category:"Hour",description:"Lowercase meridiem (am / pm)",example:"pm"},{external:"%3f",tempo:"{ms}",category:"Fractional",description:"Milliseconds (Tempo extension, 3 digits)",example:"123"},{external:"%f / %6f",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits, Python %f)",example:"123456"},{external:"%9f",tempo:"{ff:9}",category:"Fractional",description:"Nanoseconds (Tempo extension, 9 digits)",example:"123456789"},{external:"%Z",tempo:"{tz:short}",category:"Timezone",description:"Timezone abbreviation or name",example:"EDT"},{external:"%z",tempo:"{tz:offsetcompact}",category:"Timezone",description:"Compact timezone offset",example:"+0800"},{external:"%:z",tempo:"{tz:offset}",category:"Timezone",description:"Timezone offset with colon",example:"+08:00"},{external:"%s",tempo:"{ts}",category:"Epoch",description:"Unix epoch timestamp in seconds",example:"1792848645"},{external:"%%",tempo:"%",category:"Other",description:"Literal percent sign",example:"%"}]},{id:"dotnet",name:".NET / C#",icon:"🔷",ecosystem:"C#, .NET, ASP.NET, PowerShell, F#",aliases:["csharp",".net","c#"],syntaxNote:"Wrap literal text in single or double quotes: 'Date: ' yyyy-MM-dd. Escaped backslash: \\.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45.123', 'yyyy-MM-dd HH:mm:ss.fff', { dialect: 'dotnet' })",sampleFormat:"t.format('dddd, MMMM d, yyyy HH:mm:ss K', { dialect: 'dotnet' })",tokens:[{external:"yyyy",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"yyyyy",tempo:"{yyyy}",category:"Year",description:"5-digit zero-padded year",example:"02026"},{external:"yy",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"y",tempo:"{yy:raw}",category:"Year",description:"Unpadded year (0–99)",example:"26"},{external:"MMMM",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"MMM",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"MM",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"M",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"dddd",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"ddd",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"dd",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"d",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"HH",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"H",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"hh",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"h",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"mm",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"m",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"ss",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"s",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:"fffffff",tempo:"{ff:7}",category:"Fractional",description:"100-nanosecond ticks (7 digits)",example:"1234567"},{external:"ffffff",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"fff",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:"123"},{external:"tt",tempo:"{mer:upper}",category:"Hour",description:"AM / PM designator",example:"PM"},{external:"t",tempo:"{mer:upper}",category:"Hour",description:"A / P marker",example:"P"},{external:"zzz",tempo:"{tz:offset}",category:"Timezone",description:"Hours and minutes offset with colon",example:"+08:00"},{external:"zz / z",tempo:"{tz:offset:hh}",category:"Timezone",description:"Signed hour offset",example:"+08"},{external:"K",tempo:"{tz:offset:utc}",category:"Timezone",description:"ISO 8601 offset representation (Z for UTC)",example:"+08:00"},{external:"O / o",tempo:"Round-trip",category:"Other",description:"Standard Round-trip ISO-8601 specifier",example:"2026-10-24T15:30:45.1234567+08:00",notes:"Standard .NET composite format specifier"},{external:"s",tempo:"Sortable",category:"Other",description:"Standard Sortable ISO specifier",example:"2026-10-24T15:30:45",notes:"Standard .NET composite format specifier"},{external:"u",tempo:"Universal",category:"Other",description:"Universal sortable pattern",example:"2026-10-24 15:30:45Z",notes:"Standard .NET composite format specifier"},{external:"r / R",tempo:"RFC 1123",category:"Other",description:"RFC 1123 format specifier",example:"Sat, 24 Oct 2026 15:30:45 GMT",notes:"Standard .NET composite format specifier"}]},{id:"sheet",name:"Excel / Sheets",icon:"📊",ecosystem:"Microsoft Excel, Google Sheets, LibreOffice Calc, OpenDocument Spreadsheet",aliases:["spreadsheet","excel","sheets"],syntaxNote:'Wrap literal text in double quotes: "Date: " yyyy-mm-dd. Token mm is month by default, or minute when immediately near h or s.',sampleParse:"Tempo.fromFormat('24/10/2026 15:30:45', 'dd/mm/yyyy hh:mm:ss', { dialect: 'sheet' })",sampleFormat:"t.format('mmmm d, yyyy hh:mm:ss AM/PM', { dialect: 'sheet' })",tokens:[{external:"yyyy",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"yy",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"mm (date)",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12) in date context",example:"10"},{external:"m (date)",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12) in date context",example:"10"},{external:"mmm",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"mmmm",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"mmmmm",tempo:"{mon:1}",category:"Month",description:"First letter of month",example:"O"},{external:"dd",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"d",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"ddd",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"dddd",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"hh",tempo:"{h12} / {hh}",category:"Hour",description:"Zero-padded hour (12h if AM/PM present, else 24h)",example:"03"},{external:"h",tempo:"{h12:raw} / {hh:raw}",category:"Hour",description:"Unpadded hour (12h if AM/PM present, else 24h)",example:"3"},{external:"mm (time)",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59) after hour or before second",example:"30"},{external:"m (time)",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59) after hour or before second",example:"30"},{external:"ss",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"s",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:".000",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 decimal places)",example:".123"},{external:".00",tempo:"{ff:2}",category:"Fractional",description:"Hundredths of a second (2 decimal places)",example:".12"},{external:".0",tempo:"{ff:1}",category:"Fractional",description:"Tenths of a second (1 decimal place)",example:".1"},{external:"AM/PM",tempo:"{mer:upper}",category:"Hour",description:"Uppercase AM/PM indicator",example:"PM"},{external:"am/pm",tempo:"{mer}",category:"Hour",description:"Lowercase am/pm indicator",example:"pm"},{external:"A/P",tempo:"{mer:upper}",category:"Hour",description:"Single letter uppercase A or P",example:"P"},{external:"a/p",tempo:"{mer}",category:"Hour",description:"Single letter lowercase a or p",example:"p"},{external:"[h]",tempo:"{hh:raw}",category:"Hour",description:"Cumulative elapsed hours",example:"15"},{external:"[m]",tempo:"",category:"Minute",description:"Cumulative elapsed minutes",example:"930"},{external:"[s]",tempo:"",category:"Second",description:"Cumulative elapsed seconds",example:"55845"}]},{id:"mysql",name:"MySQL / MariaDB",icon:"🐬",ecosystem:"MySQL, MariaDB (DATE_FORMAT & STR_TO_DATE)",aliases:["mariadb"],syntaxNote:"All specifiers are prefixed with %. Literal text does not require escaping. Use %% for a literal percent sign.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', '%Y-%m-%d %H:%i:%s', { dialect: 'mysql' })",sampleFormat:"t.format('%W, %M %e, %Y at %r', { dialect: 'mysql' })",tokens:[{external:"%Y",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"%y",tempo:"{yy}",category:"Year",description:"2-digit calendar year (00–99)",example:"26"},{external:"%x",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year (with %v)",example:"2026"},{external:"%X",tempo:"",category:"Year",description:"4-digit year for week %V (Sunday-based Mode 2, unsupported)",example:"2026"},{external:"%m",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"%c",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"%b",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"%M",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"%d",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"%e",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"%D",tempo:"{dd:ord}",category:"Day",description:"Day of month with English suffix",example:"24th"},{external:"%j",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"%v",tempo:"{woy}",category:"Week",description:"Zero-padded ISO week of year (01–53, Monday start)",example:"43"},{external:"%u",tempo:"",category:"Week",description:"Week number with Monday as first day (00–53, Mode 1)",example:"43"},{external:"%U",tempo:"",category:"Week",description:"Week number with Sunday as first day (00–53, Mode 0)",example:"42"},{external:"%V",tempo:"",category:"Week",description:"Week number with Sunday as first day (01–53, Mode 2)",example:"42"},{external:"%W",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"%a",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"%w",tempo:"{dow:0}",category:"Weekday",description:"Day of week (0=Sunday..6=Saturday)",example:"6"},{external:"%H",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"%k",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"%h / %I",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"%l",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"%i",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"%s / %S",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"%f",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"%p",tempo:"{mer:upper}",category:"Hour",description:"AM or PM meridiem",example:"PM"},{external:"%r",tempo:"{h12}:{mi}:{ss} {mer:upper}",category:"Other",description:"12-hour time format with AM/PM",example:"03:30:45 PM"},{external:"%T",tempo:"{hh}:{mi}:{ss}",category:"Other",description:"24-hour time format",example:"15:30:45"},{external:"%%",tempo:"%",category:"Other",description:"Literal percent sign",example:"%"}]},{id:"oracle",name:"Oracle / PostgreSQL",icon:"🏛️",ecosystem:"Oracle Database, PostgreSQL, Snowflake, Amazon Redshift (TO_CHAR / TO_DATE)",aliases:["sql","postgres","postgresql","snowflake","redshift","to_char","tochar"],syntaxNote:"Tokens are case-insensitive. Prefix with FM to suppress zero-padding or trailing spaces.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', 'YYYY-MM-DD HH24:MI:SS', { dialect: 'oracle' })",sampleFormat:"t.format('Day, Month DD, YYYY at HH12:MI:SS AM', { dialect: 'oracle' })",tokens:[{external:"YYYY / RRRR",tempo:"{yyyy}",category:"Year",description:"4-digit year",example:"2026"},{external:"YY / RR",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"IYYY",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year",example:"2026"},{external:"IY",tempo:"{yow:-2}",category:"Year",description:"2-digit ISO week-numbering year",example:"26"},{external:"MM",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"FMMM",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"MON / Mon / mon",tempo:"{mmm}",category:"Month",description:"Abbreviated month name (case-preserving)",example:"Oct"},{external:"MONTH / Month / month",tempo:"{mon}",category:"Month",description:"Full month name (case-preserving)",example:"October"},{external:"DD",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"FMDD",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"DDD",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"IW",tempo:"{woy}",category:"Week",description:"ISO week number (01–53)",example:"43"},{external:"DAY / Day / day",tempo:"{wkd}",category:"Weekday",description:"Full weekday name (case-preserving)",example:"Saturday"},{external:"DY / Dy / dy",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name (case-preserving)",example:"Sat"},{external:"D",tempo:"{dow}",category:"Weekday",description:"Numeric day of week",example:"6"},{external:"HH24",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"FMHH24",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"HH / HH12",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"FMHH12",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"MI",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"FMMI",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"SS",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"FMSS",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:"FF3",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:"123"},{external:"FF6",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"FF9",tempo:"{ff:9}",category:"Fractional",description:"Nanoseconds (9 digits)",example:"123456789"},{external:"AM / PM",tempo:"{mer:upper}",category:"Hour",description:"Uppercase meridiem indicator",example:"PM"},{external:"am / pm",tempo:"{mer}",category:"Hour",description:"Lowercase meridiem indicator",example:"pm"},{external:"TZD",tempo:"{tz:short}",category:"Timezone",description:"Daylight savings abbreviation",example:"EDT"},{external:"TZH:TZM",tempo:"{tz:offset}",category:"Timezone",description:"Time zone offset with colon",example:"+08:00"},{external:"OF",tempo:"{tz:offset}",category:"Timezone",description:"Compact offset without colon",example:"+0800"}]},{id:"php",name:"PHP date()",icon:"🐘",ecosystem:"PHP, Laravel, WordPress, Symfony",aliases:["laravel","wordpress"],syntaxNote:"Single letters represent tokens; backslash-escape any character to treat as literal: \\d\\a\\t\\e.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', 'Y-m-d H:i:s', { dialect: 'php' })",sampleFormat:"t.format('l, F jS, Y \\\\a\\\\t g:i:s A', { dialect: 'php' })",tokens:[{external:"Y",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"y",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"o",tempo:"{yow}",category:"Year",description:"4-digit ISO week-numbering year",example:"2026"},{external:"m",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"n",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"M",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"F",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"d",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"j",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"jS",tempo:"{dd:ord}",category:"Day",description:"Day of month with English ordinal suffix",example:"24th"},{external:"z",tempo:"{doy:0}",category:"Day",description:"Day of year (0-indexed: 0–365)",example:"296"},{external:"W",tempo:"{woy}",category:"Week",description:"ISO week number (01–53)",example:"43"},{external:"l",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"D",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"N",tempo:"{dow}",category:"Weekday",description:"ISO-8601 day of week (1=Monday..7=Sunday)",example:"6"},{external:"w",tempo:"{dow:0}",category:"Weekday",description:"Day of week (0=Sunday..6=Saturday)",example:"6"},{external:"H",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"G",tempo:"{hh:raw}",category:"Hour",description:"Unpadded 24-hour (0–23)",example:"15"},{external:"h",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"g",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"i",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"s",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"v",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:"123"},{external:"u",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:"123456"},{external:"A",tempo:"{mer:upper}",category:"Hour",description:"Uppercase meridiem (AM / PM)",example:"PM"},{external:"a",tempo:"{mer}",category:"Hour",description:"Lowercase meridiem (am / pm)",example:"pm"},{external:"T",tempo:"{tz:short}",category:"Timezone",description:"Timezone abbreviation",example:"EDT"},{external:"P",tempo:"{tz:offset}",category:"Timezone",description:"Difference to Greenwich time with colon",example:"+08:00"},{external:"O",tempo:"{tz:offsetcompact}",category:"Timezone",description:"Difference to Greenwich time without colon",example:"+0800"},{external:"U",tempo:"{ts}",category:"Epoch",description:"Seconds since Unix Epoch",example:"1792848645"}]},{id:"go",name:"Go (time.Format)",icon:"🐹",ecosystem:"Go standard library (time package)",aliases:["golang"],syntaxNote:"Go defines layouts via reference timestamp: Mon Jan 2 15:04:05 MST 2006. Standard characters outside reference layouts remain literal.",sampleParse:"Tempo.fromFormat('2026-10-24 15:30:45', '2006-01-02 15:04:05', { dialect: 'go' })",sampleFormat:"t.format('Monday, January 2, 2006 at 3:04:05 PM MST', { dialect: 'go' })",tokens:[{external:"2006",tempo:"{yyyy}",category:"Year",description:"4-digit calendar year",example:"2026"},{external:"06",tempo:"{yy}",category:"Year",description:"2-digit year (00–99)",example:"26"},{external:"01",tempo:"{mm}",category:"Month",description:"Zero-padded month (01–12)",example:"10"},{external:"1",tempo:"{mm:raw}",category:"Month",description:"Unpadded month (1–12)",example:"10"},{external:"Jan",tempo:"{mmm}",category:"Month",description:"Abbreviated month name",example:"Oct"},{external:"January",tempo:"{mon}",category:"Month",description:"Full month name",example:"October"},{external:"02",tempo:"{dd}",category:"Day",description:"Zero-padded day of month (01–31)",example:"24"},{external:"2",tempo:"{dd:raw}",category:"Day",description:"Unpadded day of month (1–31)",example:"24"},{external:"_2",tempo:"{dd:space}",category:"Day",description:"Space-padded day of month ( 1–31)",example:"24"},{external:"002",tempo:"{doy}",category:"Day",description:"Zero-padded day of year (001–366)",example:"297"},{external:"Monday",tempo:"{wkd}",category:"Weekday",description:"Full weekday name",example:"Saturday"},{external:"Mon",tempo:"{www}",category:"Weekday",description:"Abbreviated weekday name",example:"Sat"},{external:"15",tempo:"{hh}",category:"Hour",description:"Zero-padded 24-hour (00–23)",example:"15"},{external:"03",tempo:"{h12}",category:"Hour",description:"Zero-padded 12-hour (01–12)",example:"03"},{external:"3",tempo:"{h12:raw}",category:"Hour",description:"Unpadded 12-hour (1–12)",example:"3"},{external:"04",tempo:"{mi}",category:"Minute",description:"Zero-padded minute (00–59)",example:"30"},{external:"4",tempo:"{mi:raw}",category:"Minute",description:"Unpadded minute (0–59)",example:"30"},{external:"05",tempo:"{ss}",category:"Second",description:"Zero-padded second (00–59)",example:"45"},{external:"5",tempo:"{ss:raw}",category:"Second",description:"Unpadded second (0–59)",example:"45"},{external:".000",tempo:"{ms}",category:"Fractional",description:"Milliseconds (3 digits)",example:".123"},{external:".999",tempo:"",category:"Fractional",description:"Milliseconds with trailing zeros omitted (unsupported in tokens)",example:".123"},{external:".000000 / .999999",tempo:"{ff:6}",category:"Fractional",description:"Microseconds (6 digits)",example:".123456"},{external:".000000000 / .999999999",tempo:"{ff:9}",category:"Fractional",description:"Nanoseconds (9 digits)",example:".123456789"},{external:"PM",tempo:"{mer:upper}",category:"Hour",description:"Uppercase meridiem (AM / PM)",example:"PM"},{external:"pm",tempo:"{mer}",category:"Hour",description:"Lowercase meridiem (am / pm)",example:"pm"},{external:"MST",tempo:"{tz:short}",category:"Timezone",description:"Timezone abbreviation",example:"EDT"},{external:"-07:00",tempo:"{tz:offset}",category:"Timezone",description:"ISO 8601 offset with colon",example:"+08:00"},{external:"-0700",tempo:"{tz:offsetcompact}",category:"Timezone",description:"Compact offset without colon",example:"+0800"}]}],o=P("dotnet"),a=P(""),n=P(null),c=b(()=>t.find(v=>v.id===o.value)||t[0]),d=b(()=>{const v=a.value.trim().toLowerCase(),g=c.value.tokens;return v?g.filter(y=>y.external.toLowerCase().includes(v)||y.tempo.toLowerCase().includes(v)||y.category.toLowerCase().includes(v)||y.description.toLowerCase().includes(v)||y.example.toLowerCase().includes(v)):g});function p(v){o.value=v}function u(v){typeof navigator<"u"&&navigator.clipboard&&navigator.clipboard.writeText(v).then(()=>{n.value=v,setTimeout(()=>{n.value===v&&(n.value=null)},1800)}).catch(()=>{})}return(v,g)=>(r(),i("div",Dr,[s("div",Ir,[(r(),i(H,null,D(t,y=>s("button",{key:y.id,class:L(["dialect-tab-btn",{"is-active":o.value===y.id}]),role:"tab","aria-selected":o.value===y.id,onClick:$=>p(y.id)},[s("span",Vr,k(y.icon),1),s("span",Nr,k(y.name),1)],10,Cr)),64))]),s("div",Ar,[s("div",Fr,[s("div",Or,[s("span",Er,k(c.value.icon),1),s("h3",zr,k(c.value.name),1),s("span",Ur,"dialect: '"+k(c.value.id)+"'",1)]),s("p",Br,[g[3]||(g[3]=s("strong",null,"Primary Ecosystems:",-1)),N(" "+k(c.value.ecosystem),1)]),s("div",Yr,[g[4]||(g[4]=s("span",{class:"syntax-icon"},"💡",-1)),s("span",Wr,k(c.value.syntaxNote),1)])]),s("div",Zr,[s("div",Rr,[g[5]||(g[5]=s("span",{class:"sample-label"},"TypeScript Quick Example",-1)),s("button",{class:"sample-copy-btn",onClick:g[0]||(g[0]=y=>u(c.value.sampleFormat))},k(n.value===c.value.sampleFormat?"✓ Copied":"Copy"),1)]),s("div",qr,[g[6]||(g[6]=s("code",null,"// Parse:",-1)),s("code",null,k(c.value.sampleParse),1),g[7]||(g[7]=s("code",null,"// Format:",-1)),s("code",null,k(c.value.sampleFormat),1)])])]),s("div",Gr,[s("div",Qr,[g[8]||(g[8]=s("span",{class:"search-icon"},"🔍",-1)),Ge(s("input",{"onUpdate:modelValue":g[1]||(g[1]=y=>a.value=y),type:"text",class:"search-input",placeholder:"Filter tokens by name, category, or Tempo tag (e.g. year, hour, ord, {ms})...","aria-label":"Filter tokens"},null,512),[[Qe,a.value]]),a.value?(r(),i("button",{key:0,class:"clear-btn",title:"Clear filter",onClick:g[2]||(g[2]=y=>a.value="")},"✕")):f("",!0)]),s("div",jr,[g[9]||(g[9]=N(" Showing ",-1)),s("strong",null,k(d.value.length),1),N(" of "+k(c.value.tokens.length)+" tokens ",1)])]),s("div",Kr,[s("table",Jr,[s("thead",null,[s("tr",null,[s("th",Xr,k(c.value.name)+" Token",1),g[10]||(g[10]=s("th",{class:"col-tempo"},"Native Tempo Equivalent",-1)),g[11]||(g[11]=s("th",{class:"col-cat"},"Category",-1)),g[12]||(g[12]=s("th",{class:"col-desc"},"Description & Output Sample",-1))])]),s("tbody",null,[(r(!0),i(H,null,D(d.value,y=>(r(),i("tr",{key:y.external+y.tempo},[s("td",ei,[s("span",ti,k(y.external),1)]),s("td",oi,[y.tempo?(r(),i("button",{key:0,class:"token-tempo-btn",title:"Click to copy "+y.tempo,onClick:$=>u(y.tempo)},[s("code",null,k(y.tempo),1),s("span",ni,k(n.value===y.tempo?"✓ Copied!":"Copy"),1)],8,ai)):(r(),i("span",si,"—"))]),s("td",ri,[s("span",{class:"cat-pill","data-cat":y.category},k(y.category),9,ii)]),s("td",li,[s("div",ci,k(y.description),1),s("div",di,[g[13]||(g[13]=N("Sample: ",-1)),s("code",null,k(y.example),1)]),y.notes?(r(),i("div",mi,k(y.notes),1)):f("",!0)])]))),128)),d.value.length===0?(r(),i("tr",pi,[s("td",ui,' No matching tokens found for "'+k(a.value)+'". Try searching for "year", "hour", "day", or clear the filter. ',1)])):f("",!0)])])])]))}}),yi=S(hi,[["__scopeId","data-v-b974baac"]]),gi=["src"],fi=x({__name:"Layout",setup(e){const{Layout:t}=Ve,{page:o}=ke(),a=b(()=>(o.value.relativePath||"").includes("_setup")),n=b(()=>{const d=o.value.relativePath||"";return d.includes("9-plugins")||d.includes("plugins/")||d.includes("ecosystem")}),c=b(()=>a.value?Z("/registry-logo.svg"):n.value?Z("/plugin-logo.svg"):Z("/tempo-logo.svg"));return(d,p)=>(r(),w(l(t),null,{"nav-bar-title-before":h(()=>[s("img",{src:c.value,alt:"Tempo Logo",class:"custom-navbar-logo"},null,8,gi)]),_:1}))}}),vi=S(fi,[["__scopeId","data-v-8ddba353"]]),ki={extends:Ve,Layout:vi,enhanceApp({app:e}){e.component("CatalogList",xr),e.component("PluginRepl",Hr),e.component("DialectTabs",yi)}};export{ki as R,un as c,M as u}; diff --git a/packages/tempo/public/v4/assets/chunks/timeline-definition-24CTP7MA.XH_18yc2.js b/packages/tempo/public/v4/assets/chunks/timeline-definition-24CTP7MA.XH_18yc2.js new file mode 100644 index 00000000..2d76f244 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/timeline-definition-24CTP7MA.XH_18yc2.js @@ -0,0 +1,120 @@ +import{_ as o,A as pt,ac as Rt,ad as Ct,ae as Wt,c as gt,l as E,G as Pt,a2 as Bt,af as ft,j as U,v as Vt,ag as Ft,r as zt}from"../app.CbekdYod.js";import{d as ot}from"./arc.BFiNID6s.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var tt=(function(){var e=o(function(k,s,d,l){for(d=d||{},l=k.length;l--;d[k[l]]=s);return d},"o"),t=[6,11,13,14,15,17,19,20,23,24],n=[1,12],i=[1,13],r=[1,14],h=[1,15],c=[1,16],a=[1,19],f=[1,20],g={trace:o(function(){},"trace"),yy:{},symbols_:{error:2,start:3,timeline_header:4,document:5,EOF:6,timeline:7,timeline_lr:8,timeline_td:9,line:10,SPACE:11,statement:12,NEWLINE:13,title:14,acc_title:15,acc_title_value:16,acc_descr:17,acc_descr_value:18,acc_descr_multiline_value:19,section:20,period_statement:21,event_statement:22,period:23,event:24,$accept:0,$end:1},terminals_:{2:"error",6:"EOF",7:"timeline",8:"timeline_lr",9:"timeline_td",11:"SPACE",13:"NEWLINE",14:"title",15:"acc_title",16:"acc_title_value",17:"acc_descr",18:"acc_descr_value",19:"acc_descr_multiline_value",20:"section",23:"period",24:"event"},productions_:[0,[3,3],[4,1],[4,1],[4,1],[5,0],[5,2],[10,2],[10,1],[10,1],[10,1],[12,1],[12,2],[12,2],[12,1],[12,1],[12,1],[12,1],[21,1],[22,1]],performAction:o(function(s,d,l,p,x,u,S){var v=u.length-1;switch(x){case 1:return u[v-1];case 3:p.setDirection("LR");break;case 4:p.setDirection("TD");break;case 5:this.$=[];break;case 6:u[v-1].push(u[v]),this.$=u[v-1];break;case 7:case 8:this.$=u[v];break;case 9:case 10:this.$=[];break;case 11:p.getCommonDb().setDiagramTitle(u[v].substr(6)),this.$=u[v].substr(6);break;case 12:this.$=u[v].trim(),p.getCommonDb().setAccTitle(this.$);break;case 13:case 14:this.$=u[v].trim(),p.getCommonDb().setAccDescription(this.$);break;case 15:p.addSection(u[v].substr(8)),this.$=u[v].substr(8);break;case 18:p.addTask(u[v],0,""),this.$=u[v];break;case 19:p.addEvent(u[v].substr(2)),this.$=u[v];break}},"anonymous"),table:[{3:1,4:2,7:[1,3],8:[1,4],9:[1,5]},{1:[3]},e(t,[2,5],{5:6}),e(t,[2,2]),e(t,[2,3]),e(t,[2,4]),{6:[1,7],10:8,11:[1,9],12:10,13:[1,11],14:n,15:i,17:r,19:h,20:c,21:17,22:18,23:a,24:f},e(t,[2,10],{1:[2,1]}),e(t,[2,6]),{12:21,14:n,15:i,17:r,19:h,20:c,21:17,22:18,23:a,24:f},e(t,[2,8]),e(t,[2,9]),e(t,[2,11]),{16:[1,22]},{18:[1,23]},e(t,[2,14]),e(t,[2,15]),e(t,[2,16]),e(t,[2,17]),e(t,[2,18]),e(t,[2,19]),e(t,[2,7]),e(t,[2,12]),e(t,[2,13])],defaultActions:{},parseError:o(function(s,d){if(d.recoverable)this.trace(s);else{var l=new Error(s);throw l.hash=d,l}},"parseError"),parse:o(function(s){var d=this,l=[0],p=[],x=[null],u=[],S=this.table,v="",I=0,R=0,W=2,O=1,L=u.slice.call(arguments,1),w=Object.create(this.lexer),H={yy:{}};for(var V in this.yy)Object.prototype.hasOwnProperty.call(this.yy,V)&&(H.yy[V]=this.yy[V]);w.setInput(s,H.yy),H.yy.lexer=w,H.yy.parser=this,typeof w.yylloc>"u"&&(w.yylloc={});var F=w.yylloc;u.push(F);var K=w.options&&w.options.ranges;typeof H.yy.parseError=="function"?this.parseError=H.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function N(A){l.length=l.length-2*A,x.length=x.length-A,u.length=u.length-A}o(N,"popStack");function b(){var A;return A=p.pop()||w.lex()||O,typeof A!="number"&&(A instanceof Array&&(p=A,A=p.pop()),A=d.symbols_[A]||A),A}o(b,"lex");for(var _,$,T,P,C={},G,B,X,Z;;){if($=l[l.length-1],this.defaultActions[$]?T=this.defaultActions[$]:((_===null||typeof _>"u")&&(_=b()),T=S[$]&&S[$][_]),typeof T>"u"||!T.length||!T[0]){var Y="";Z=[];for(G in S[$])this.terminals_[G]&&G>W&&Z.push("'"+this.terminals_[G]+"'");w.showPosition?Y="Parse error on line "+(I+1)+`: +`+w.showPosition()+` +Expecting `+Z.join(", ")+", got '"+(this.terminals_[_]||_)+"'":Y="Parse error on line "+(I+1)+": Unexpected "+(_==O?"end of input":"'"+(this.terminals_[_]||_)+"'"),this.parseError(Y,{text:w.match,token:this.terminals_[_]||_,line:w.yylineno,loc:F,expected:Z})}if(T[0]instanceof Array&&T.length>1)throw new Error("Parse Error: multiple actions possible at state: "+$+", token: "+_);switch(T[0]){case 1:l.push(_),x.push(w.yytext),u.push(w.yylloc),l.push(T[1]),_=null,R=w.yyleng,v=w.yytext,I=w.yylineno,F=w.yylloc;break;case 2:if(B=this.productions_[T[1]][1],C.$=x[x.length-B],C._$={first_line:u[u.length-(B||1)].first_line,last_line:u[u.length-1].last_line,first_column:u[u.length-(B||1)].first_column,last_column:u[u.length-1].last_column},K&&(C._$.range=[u[u.length-(B||1)].range[0],u[u.length-1].range[1]]),P=this.performAction.apply(C,[v,R,I,H.yy,T[1],x,u].concat(L)),typeof P<"u")return P;B&&(l=l.slice(0,-1*B*2),x=x.slice(0,-1*B),u=u.slice(0,-1*B)),l.push(this.productions_[T[1]][0]),x.push(C.$),u.push(C._$),X=S[l[l.length-2]][l[l.length-1]],l.push(X);break;case 3:return!0}}return!0},"parse")},m=(function(){var k={EOF:1,parseError:o(function(d,l){if(this.yy.parser)this.yy.parser.parseError(d,l);else throw new Error(d)},"parseError"),setInput:o(function(s,d){return this.yy=d||this.yy||{},this._input=s,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:o(function(){var s=this._input[0];this.yytext+=s,this.yyleng++,this.offset++,this.match+=s,this.matched+=s;var d=s.match(/(?:\r\n?|\n).*/g);return d?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),s},"input"),unput:o(function(s){var d=s.length,l=s.split(/(?:\r\n?|\n)/g);this._input=s+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-d),this.offset-=d;var p=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),l.length-1&&(this.yylineno-=l.length-1);var x=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:l?(l.length===p.length?this.yylloc.first_column:0)+p[p.length-l.length].length-l[0].length:this.yylloc.first_column-d},this.options.ranges&&(this.yylloc.range=[x[0],x[0]+this.yyleng-d]),this.yyleng=this.yytext.length,this},"unput"),more:o(function(){return this._more=!0,this},"more"),reject:o(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:o(function(s){this.unput(this.match.slice(s))},"less"),pastInput:o(function(){var s=this.matched.substr(0,this.matched.length-this.match.length);return(s.length>20?"...":"")+s.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:o(function(){var s=this.match;return s.length<20&&(s+=this._input.substr(0,20-s.length)),(s.substr(0,20)+(s.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:o(function(){var s=this.pastInput(),d=new Array(s.length+1).join("-");return s+this.upcomingInput()+` +`+d+"^"},"showPosition"),test_match:o(function(s,d){var l,p,x;if(this.options.backtrack_lexer&&(x={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(x.yylloc.range=this.yylloc.range.slice(0))),p=s[0].match(/(?:\r\n?|\n).*/g),p&&(this.yylineno+=p.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:p?p[p.length-1].length-p[p.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+s[0].length},this.yytext+=s[0],this.match+=s[0],this.matches=s,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(s[0].length),this.matched+=s[0],l=this.performAction.call(this,this.yy,this,d,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),l)return l;if(this._backtrack){for(var u in x)this[u]=x[u];return!1}return!1},"test_match"),next:o(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var s,d,l,p;this._more||(this.yytext="",this.match="");for(var x=this._currentRules(),u=0;ud[0].length)){if(d=l,p=u,this.options.backtrack_lexer){if(s=this.test_match(l,x[u]),s!==!1)return s;if(this._backtrack){d=!1;continue}else return!1}else if(!this.options.flex)break}return d?(s=this.test_match(d,x[p]),s!==!1?s:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:o(function(){var d=this.next();return d||this.lex()},"lex"),begin:o(function(d){this.conditionStack.push(d)},"begin"),popState:o(function(){var d=this.conditionStack.length-1;return d>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:o(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:o(function(d){return d=this.conditionStack.length-1-Math.abs(d||0),d>=0?this.conditionStack[d]:"INITIAL"},"topState"),pushState:o(function(d){this.begin(d)},"pushState"),stateStackSize:o(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:o(function(d,l,p,x){switch(p){case 0:break;case 1:break;case 2:return 13;case 3:break;case 4:break;case 5:return 8;case 6:return 9;case 7:return 7;case 8:return 14;case 9:return this.begin("acc_title"),15;case 10:return this.popState(),"acc_title_value";case 11:return this.begin("acc_descr"),17;case 12:return this.popState(),"acc_descr_value";case 13:this.begin("acc_descr_multiline");break;case 14:this.popState();break;case 15:return"acc_descr_multiline_value";case 16:return 20;case 17:return 24;case 18:return 23;case 19:return 6;case 20:return"INVALID"}},"anonymous"),rules:[/^(?:%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?:#[^\n]*)/i,/^(?:timeline[ \t]+LR\b)/i,/^(?:timeline[ \t]+TD\b)/i,/^(?:timeline\b)/i,/^(?:title\s[^\n]+)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:section\s[^:\n]+)/i,/^(?::\s(?:[^:\n]|:(?!\s))+)/i,/^(?:[^#:\n]+)/i,/^(?:$)/i,/^(?:.)/i],conditions:{acc_descr_multiline:{rules:[14,15],inclusive:!1},acc_descr:{rules:[12],inclusive:!1},acc_title:{rules:[10],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8,9,11,13,16,17,18,19,20],inclusive:!0}}};return k})();g.lexer=m;function y(){this.yy={}}return o(y,"Parser"),y.prototype=g,g.Parser=y,new y})();tt.parser=tt;var Ot=tt,yt={};Vt(yt,{addEvent:()=>Tt,addSection:()=>_t,addTask:()=>Et,addTaskOrg:()=>$t,clear:()=>kt,default:()=>Gt,getCommonDb:()=>xt,getDirection:()=>bt,getSections:()=>wt,getTasks:()=>St,setDirection:()=>vt});var D="",mt=0,nt="LR",rt=[],q=[],j=[],xt=o(()=>Ft,"getCommonDb"),kt=o(function(){rt.length=0,q.length=0,D="",j.length=0,nt="LR",zt()},"clear"),vt=o(function(e){nt=e},"setDirection"),bt=o(function(){return nt},"getDirection"),_t=o(function(e){D=e,rt.push(e)},"addSection"),wt=o(function(){return rt},"getSections"),St=o(function(){let e=ct();const t=100;let n=0;for(;!e&&nn.id===mt-1).events.push(e)},"addEvent"),$t=o(function(e){const t={section:D,type:D,description:e,task:e,classes:[]};q.push(t)},"addTaskOrg"),ct=o(function(){const e=o(function(n){return j[n].processed},"compileTask");let t=!0;for(const[n,i]of j.entries())e(n),t=t&&i.processed;return t},"compileTasks"),Gt={clear:kt,getCommonDb:xt,getDirection:bt,setDirection:vt,addSection:_t,getSections:wt,getTasks:St,addTask:Et,addTaskOrg:$t,addEvent:Tt},Nt=0,J=o(function(e,t){const n=e.append("rect");return n.attr("x",t.x),n.attr("y",t.y),n.attr("fill",t.fill),n.attr("stroke",t.stroke),n.attr("width",t.width),n.attr("height",t.height),n.attr("rx",t.rx),n.attr("ry",t.ry),t.class!==void 0&&n.attr("class",t.class),n},"drawRect"),Dt=o(function(e,t){const i=e.append("circle").attr("cx",t.cx).attr("cy",t.cy).attr("class","face").attr("r",15).attr("stroke-width",2).attr("overflow","visible"),r=e.append("g");r.append("circle").attr("cx",t.cx-15/3).attr("cy",t.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666"),r.append("circle").attr("cx",t.cx+15/3).attr("cy",t.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666");function h(f){const g=ot().startAngle(Math.PI/2).endAngle(3*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);f.append("path").attr("class","mouth").attr("d",g).attr("transform","translate("+t.cx+","+(t.cy+2)+")")}o(h,"smile");function c(f){const g=ot().startAngle(3*Math.PI/2).endAngle(5*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);f.append("path").attr("class","mouth").attr("d",g).attr("transform","translate("+t.cx+","+(t.cy+7)+")")}o(c,"sad");function a(f){f.append("line").attr("class","mouth").attr("stroke",2).attr("x1",t.cx-5).attr("y1",t.cy+7).attr("x2",t.cx+5).attr("y2",t.cy+7).attr("class","mouth").attr("stroke-width","1px").attr("stroke","#666")}return o(a,"ambivalent"),t.score>3?h(r):t.score<3?c(r):a(r),i},"drawFace"),jt=o(function(e,t){const n=e.append("circle");return n.attr("cx",t.cx),n.attr("cy",t.cy),n.attr("class","actor-"+t.pos),n.attr("fill",t.fill),n.attr("stroke",t.stroke),n.attr("r",t.r),n.class!==void 0&&n.attr("class",n.class),t.title!==void 0&&n.append("title").text(t.title),n},"drawCircle"),It=o(function(e,t){const n=t.text.replace(//gi," "),i=e.append("text");i.attr("x",t.x),i.attr("y",t.y),i.attr("class","legend"),i.style("text-anchor",t.anchor),t.class!==void 0&&i.attr("class",t.class);const r=i.append("tspan");return r.attr("x",t.x+t.textMargin*2),r.text(n),i},"drawText"),Kt=o(function(e,t){function n(r,h,c,a,f){return r+","+h+" "+(r+c)+","+h+" "+(r+c)+","+(h+a-f)+" "+(r+c-f*1.2)+","+(h+a)+" "+r+","+(h+a)}o(n,"genPoints");const i=e.append("polygon");i.attr("points",n(t.x,t.y,50,20,7)),i.attr("class","labelBox"),t.y=t.y+t.labelMargin,t.x=t.x+.5*t.labelMargin,It(e,t)},"drawLabel"),Ut=o(function(e,t,n){const i=e.append("g"),r=st();r.x=t.x,r.y=t.y,r.fill=t.fill,r.width=n.width,r.height=n.height,r.class="journey-section section-type-"+t.num,r.rx=3,r.ry=3,J(i,r),Ht(n)(t.text,i,r.x,r.y,r.width,r.height,{class:"journey-section section-type-"+t.num},n,t.colour)},"drawSection"),et=-1,Xt=o(function(e,t,n,i){const r=t.x+n.width/2,h=e.append("g");et++,h.append("line").attr("id",i+"-task"+et).attr("x1",r).attr("y1",t.y).attr("x2",r).attr("y2",450).attr("class","task-line").attr("stroke-width","1px").attr("stroke-dasharray","4 2").attr("stroke","#666"),Dt(h,{cx:r,cy:300+(5-t.score)*30,score:t.score});const a=st();a.x=t.x,a.y=t.y,a.fill=t.fill,a.width=n.width,a.height=n.height,a.class="task task-type-"+t.num,a.rx=3,a.ry=3,J(h,a),Ht(n)(t.task,h,a.x,a.y,a.width,a.height,{class:"task"},n,t.colour)},"drawTask"),Zt=o(function(e,t){J(e,{x:t.startx,y:t.starty,width:t.stopx-t.startx,height:t.stopy-t.starty,fill:t.fill,class:"rect"}).lower()},"drawBackgroundRect"),qt=o(function(){return{x:0,y:0,fill:void 0,"text-anchor":"start",width:100,height:100,textMargin:0,rx:0,ry:0}},"getTextObj"),st=o(function(){return{x:0,y:0,width:100,anchor:"start",height:100,rx:0,ry:0}},"getNoteRect"),Ht=(function(){function e(r,h,c,a,f,g,m,y){const k=h.append("text").attr("x",c+f/2).attr("y",a+g/2+5).style("font-color",y).style("text-anchor","middle").text(r);i(k,m)}o(e,"byText");function t(r,h,c,a,f,g,m,y,k){const{taskFontSize:s,taskFontFamily:d}=y,l=r.split(//gi);for(let p=0;p)/).reverse(),r,h=[],c=1.1,a=n.attr("y"),f=parseFloat(n.attr("dy")),g=n.text(null).append("tspan").attr("x",0).attr("y",a).attr("dy",f+"em");for(let m=0;mt||r==="
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ")&&(h.pop(),g.text(h.join(" ").trim()),r==="
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "?h=[""]:h=[r],g=n.append("tspan").attr("x",0).attr("y",a).attr("dy",c+"em").text(r))})}o(it,"wrap");var Qt=o(function(e,t,n,i,r,h=!1){const{theme:c,look:a}=i,f=c?.includes("redux"),g=i?.themeVariables?.THEME_COLOR_LIMIT??12,m=n%g-1,y=e.append("g");t.section=m,y.attr("class",(t.class?t.class+" ":"")+"timeline-node "+("section-"+m));const k=y.append("g"),s=y.append("g"),l=s.append("text").text(t.descr).attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle").call(it,t.width).node().getBBox(),p=i.fontSize?.replace?i.fontSize.replace("px",""):i.fontSize;if(t.height=l.height+p*1.1*.5+t.padding,t.height=Math.max(t.height,t.maxHeight),t.width=t.width+2*t.padding,s.attr("transform","translate("+t.width/2+", "+t.padding/2+")"),f&&s.attr("transform",`translate(${t.width/2}, ${h?t.padding/2+3:t.padding})`),te(k,t,m,r,i),a==="neo"&&(y.attr("data-look","neo"),f)){const x=c.includes("dark"),u=e.node()?.ownerSVGElement??e.node(),S=U(u),v=S.attr("id")??"",I=v?`${v}-drop-shadow`:"drop-shadow";if(S.select(`#${I}`).empty()){const R=S.select("defs");(R.empty()?S.append("defs"):R).append("filter").attr("id",I).attr("height","130%").attr("width","130%").append("feDropShadow").attr("dx","4").attr("dy","4").attr("stdDeviation",0).attr("flood-opacity",x?"0.2":"0.06").attr("flood-color",x?"#FFFFFF":"#000000")}}return t},"drawNode"),Yt=o(function(e,t,n){const i=e.append("g"),h=i.append("text").text(t.descr).attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle").call(it,t.width).node().getBBox(),c=n.fontSize?.replace?n.fontSize.replace("px",""):n.fontSize;return i.remove(),h.height+c*1.1*.5+t.padding},"getVirtualNodeHeight"),te=o(function(e,t,n,i,r){const{theme:h}=r,c=h?.includes("redux")?0:5,a=5,f=c>0?`M0 ${t.height-a} v${-t.height+2*a} q0,-${c},${c},-${c} h${t.width-2*a} q${c},0,${c},${c} v${t.height-a} H0 Z`:`M0 ${t.height-a} v${-(t.height-a)} h${t.width} v${t.height} H0 Z`;e.append("path").attr("id",i+"-node-"+Nt++).attr("class","node-bkg node-"+t.type).attr("d",f),h?.includes("redux")||e.append("line").attr("class","node-line-"+n).attr("x1",0).attr("y1",t.height).attr("x2",t.width).attr("y2",t.height)},"defaultBkg"),M={drawRect:J,drawCircle:jt,drawSection:Ut,drawText:It,drawLabel:Kt,drawTask:Xt,drawBackgroundRect:Zt,getTextObj:qt,getNoteRect:st,initGraphics:Jt,drawNode:Qt,getVirtualNodeHeight:Yt},ee=o(function(e,t,n,i){const r=gt(),{look:h,theme:c,themeVariables:a}=r,{useGradient:f,gradientStart:g,gradientStop:m}=a,y=r.timeline?.leftMargin??50;E.debug("timeline",i.db);const k=r.securityLevel;let s;k==="sandbox"&&(s=U("#i"+t));const l=(k==="sandbox"?U(s.nodes()[0].contentDocument.body):U("body")).select("#"+t);l.append("g");const p=i.db.getTasks(),x=i.db.getCommonDb().getDiagramTitle();E.debug("task",p),M.initGraphics(l,t);const u=i.db.getSections();E.debug("sections",u);let S=0,v=0,I=0,R=0,W=50+y,O=50;R=50;let L=0,w=!0;u.forEach(function(N){const b={number:L,descr:N,section:L,width:150,padding:20,maxHeight:S},_=M.getVirtualNodeHeight(l,b,r);E.debug("sectionHeight before draw",_),S=Math.max(S,_+20)});let H=0,V=0;E.debug("tasks.length",p.length);for(const[N,b]of p.entries()){const _={number:N,descr:b,section:b.section,width:150,padding:20,maxHeight:v},$=M.getVirtualNodeHeight(l,_,r);E.debug("taskHeight before draw",$),v=Math.max(v,$+20),H=Math.max(H,b.events.length);let T=0;for(const P of b.events){const C={descr:P,section:b.section,number:b.section,width:150,padding:20,maxHeight:50};T+=M.getVirtualNodeHeight(l,C,r)}b.events.length>0&&(T+=(b.events.length-1)*10),V=Math.max(V,T)}E.debug("maxSectionHeight before draw",S),E.debug("maxTaskHeight before draw",v),u&&u.length>0?u.forEach(N=>{const b=p.filter(P=>P.section===N),_={number:L,descr:N,section:L,width:200*Math.max(b.length,1)-50,padding:20,maxHeight:S};E.debug("sectionNode",_);const $=l.append("g"),T=M.drawNode($,_,L,r,t);E.debug("sectionNode output",T),$.attr("transform",`translate(${W}, ${R})`),O+=S+50,b.length>0&<(l,b,L,W,O,v,r,H,V,S,!1,t),W+=200*Math.max(b.length,1),O=R,L++}):(w=!1,lt(l,p,L,W,O,v,r,H,V,S,!0,t));const F=l.node().getBBox();if(E.debug("bounds",F),x&&l.append("text").text(x).attr("x",h==="neo"?F.x*2+y:F.width/2-y).attr("font-size","4ex").attr("font-weight","bold").attr("y",20),I=w?S+v+150:v+100,l.append("g").attr("class","lineWrapper").append("line").attr("x1",y).attr("y1",I).attr("x2",F.width+3*y).attr("y2",I).attr("stroke-width",4).attr("stroke","black").attr("marker-end",`url(#${t}-arrowhead)`),h==="neo"&&f&&c!=="neutral"){const N=l.select("defs"),_=(N.empty()?l.append("defs"):N).append("linearGradient").attr("id",l.attr("id")+"-gradient").attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");_.append("stop").attr("offset","0%").attr("stop-color",g).attr("stop-opacity",1),_.append("stop").attr("offset","100%").attr("stop-color",m).attr("stop-opacity",1)}ft(void 0,l,r.timeline?.padding??50,r.timeline?.useMaxWidth??!1)},"draw"),lt=o(function(e,t,n,i,r,h,c,a,f,g,m,y){for(const k of t){const s={descr:k.task,section:n,number:n,width:150,padding:20,maxHeight:h};E.debug("taskNode",s);const d=e.append("g").attr("class","taskWrapper"),p=M.drawNode(d,s,n,c,y).height;if(E.debug("taskHeight after draw",p),d.attr("transform",`translate(${i}, ${r})`),h=Math.max(h,p),k.events){const x=e.append("g").attr("class","lineWrapper");let u=h;r+=100,u=u+ne(e,k.events,n,i,r,c,y),r-=100,x.append("line").attr("x1",i+190/2).attr("y1",r+h).attr("x2",i+190/2).attr("y2",r+h+100+f+100).attr("stroke-width",2).attr("stroke","black").attr("marker-end",`url(#${y}-arrowhead)`).attr("stroke-dasharray","5,5")}i=i+200,m&&!c.timeline?.disableMulticolor&&n++}r=r-10},"drawTasks"),ne=o(function(e,t,n,i,r,h,c){let a=0;const f=r;r=r+100;for(const g of t){const m={descr:g,section:n,number:n,width:150,padding:20,maxHeight:50};E.debug("eventNode",m);const y=e.append("g").attr("class","eventWrapper"),s=M.drawNode(y,m,n,h,c,!0).height;a=a+s,y.attr("transform",`translate(${i}, ${r})`),r=r+10+s}return r=f,a},"drawEvents"),re={setConf:o(()=>{},"setConf"),draw:ee},Q=200,z=5,se=Q+z*2,at=Q+100,ie=at+z*2,Lt=10,ae=0,ht=20,Mt=20,dt=30,At=50,oe=o(function(e,t,n,i){const r=gt(),h=r.timeline?.leftMargin??50;E.debug("timeline",i.db);const c=Pt(t);c.append("g");const a=i.db.getTasks(),f=i.db.getCommonDb().getDiagramTitle();E.debug("task",a),M.initGraphics(c);const g=i.db.getSections();E.debug("sections",g);let m=0,y=0;const k=50+h;let s=50;const d=s,l=k,p=se+Mt,x=ie+At,u=l+p;let S=0;const v=g&&g.length>0,I=v?u:k+p,R=Math.max(50,p+x-z*2);g.forEach(function(N){const b={number:S,descr:N,section:S,width:R,padding:z,maxHeight:m},_=M.getVirtualNodeHeight(c,b,r);E.debug("sectionHeight before draw",_),m=Math.max(m,_)});let W=0;E.debug("tasks.length",a.length);for(const[N,b]of a.entries()){const _={number:N,descr:b,section:b.section,width:Q,padding:z,maxHeight:y},$=M.getVirtualNodeHeight(c,_,r);E.debug("taskHeight before draw",$),y=Math.max(y,$);let T=0;for(const P of b.events){const C={descr:P,section:b.section,number:b.section,width:at,padding:z,maxHeight:50};T+=M.getVirtualNodeHeight(c,C,r)}b.events.length>0&&(T+=(b.events.length-1)*Lt),W=Math.max(W,T)+ae}E.debug("maxSectionHeight before draw",m),E.debug("maxTaskHeight before draw",y);const L=Math.max(y,W)+dt;v?g.forEach(N=>{const b=a.filter(X=>X.section===N),_={number:S,descr:N,section:S,width:R,padding:z,maxHeight:m};E.debug("sectionNode",_);const $=c.append("g"),T=M.drawNode($,_,S,r);E.debug("sectionNode output",T);const P=I-p;$.attr("transform",`translate(${P}, ${s})`);const C=s+T.height+ht;b.length>0&&ut(c,b,S,I,C,y,r,L,!1);const G=b.length,B=T.height+ht+L*Math.max(G,1)-(G>0?dt*2:0);s+=B,S++}):ut(c,a,S,I,s,y,r,L,!0);let w=c.node()?.getBBox();if(!w)throw new Error("bbox not found");if(E.debug("bounds",w),f){if(c.append("text").text(f).attr("x",w.width/2-h).attr("font-size","4ex").attr("font-weight","bold").attr("y",20),w=c.node()?.getBBox(),!w)throw new Error("bbox not found");E.debug("bounds after title",w)}const[H]=Bt(r.fontSize),V=(H??16)*2,F=(H??16)*.5+20,K=c.append("g").attr("class","lineWrapper");K.append("line").attr("x1",I).attr("y1",d-V).attr("x2",I).attr("y2",w.y+w.height+F).attr("stroke-width",4).attr("stroke","black").attr("marker-end","url(#arrowhead)"),K.lower(),ft(void 0,c,r.timeline?.padding??50,r.timeline?.useMaxWidth??!1)},"draw"),ut=o(function(e,t,n,i,r,h,c,a,f){for(const g of t){const m={descr:g.task,section:n,number:n,width:Q,padding:z,maxHeight:h};E.debug("taskNode",m);const y=e.append("g").attr("class","taskWrapper"),k=M.drawNode(y,m,n,c),s=k.height;E.debug("taskHeight after draw",s);const d=i-Mt-k.width;if(y.attr("transform",`translate(${d}, ${r})`),h=Math.max(h,s),g.events&&g.events.length>0){const l=r,p=i+At;ce(e,g.events,n,i,p,l,c)}r=r+a,f&&!c.timeline?.disableMulticolor&&n++}},"drawTasks"),ce=o(function(e,t,n,i,r,h,c){let a=h;for(const f of t){const g={descr:f,section:n,number:n,width:at,padding:z,maxHeight:0};E.debug("eventNode",g);const m=e.append("g").attr("class","eventWrapper"),k=M.drawNode(m,g,n,c).height;m.attr("transform",`translate(${r}, ${a})`);const s=e.append("g").attr("class","lineWrapper"),d=a+k/2;s.append("line").attr("x1",i).attr("y1",d).attr("x2",r).attr("y2",d).attr("stroke-width",2).attr("stroke","black").attr("marker-end","url(#arrowhead)").attr("stroke-dasharray","5,5"),a=a+k+Lt}return a-h},"drawEvents"),le={setConf:o(()=>{},"setConf"),draw:oe},he=o(e=>{const{theme:t}=pt(),n=t?.includes("dark"),i=t?.includes("color"),r=e.svgId?.replace(/^#/,"")??"",h=r?`url(#${r}-drop-shadow)`:e.dropShadow??"none";let c="";for(let a=0;a{let t="";for(let n=0;n{const{theme:t}=pt(),n=t?.includes("redux"),i=t==="neutral",r=e.svgId?.replace(/^#/,"")??"";let h="";if(e.useGradient&&r&&e.THEME_COLOR_LIMIT&&!i)for(let c=0;c{},"setConf"),draw:o((e,t,n,i)=>(i?.db?.getDirection?.()??"LR")==="TD"?le.draw(e,t,n,i):re.draw(e,t,n,i),"draw")},ke={db:yt,renderer:ge,parser:Ot,styles:pe};export{ke as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/vennDiagram-4TSXK5OY.REB-xxGl.js b/packages/tempo/public/v4/assets/chunks/vennDiagram-4TSXK5OY.REB-xxGl.js new file mode 100644 index 00000000..3b5db633 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/vennDiagram-4TSXK5OY.REB-xxGl.js @@ -0,0 +1,34 @@ +import{b2 as Wt,s as Kt,g as Ht,q as Yt,p as Xt,a as Zt,b as Jt,_ as w,A as wt,G as Qt,j as ot,an as $t,ac as te,ad as ee,ae as ne,d as se,r as ie,D as oe,E as re}from"../app.CbekdYod.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";const kt=(t,n)=>Wt(t,"a",-n),_t=1e-10;function st(t,n){const s=le(t),e=s.filter(l=>ae(l,t));let i=0,o=0;const r=[];if(e.length>1){const l=Tt(e);for(let u=0;ua.angle-u.angle);let f=e[e.length-1];for(let u=0;up.radius*2&&(g=p.radius*2),(h==null||h.width>g)&&(h={circle:p,width:g,p1:a,p2:f,large:g>p.radius,sweep:!0})}h!=null&&(r.push(h),i+=lt(h.circle.radius,h.width),f=a)}}else{let l=t[0];for(let u=1;uMath.abs(l.radius-t[u].radius)){f=!0;break}f?i=o=0:(i=l.radius*l.radius*Math.PI,r.push({circle:l,p1:{x:l.x,y:l.y+l.radius},p2:{x:l.x-_t,y:l.y+l.radius},width:l.radius*2,large:!0,sweep:!0}))}return o/=2,n&&(n.area=i+o,n.arcArea=i,n.polygonArea=o,n.arcs=r,n.innerPoints=e,n.intersectionPoints=s),i+o}function ae(t,n){return n.every(s=>q(t,s)=t+n)return 0;if(s<=Math.abs(t-n))return Math.PI*Math.min(t,n)*Math.min(t,n);const e=t-(s*s-n*n+t*t)/(2*s),i=n-(s*s-t*t+n*n)/(2*s);return lt(t,e)+lt(n,i)}function Et(t,n){const s=q(t,n),e=t.radius,i=n.radius;if(s>=e+i||s<=Math.abs(e-i))return[];const o=(e*e-i*i+s*s)/(2*s),r=Math.sqrt(e*e-o*o),l=t.x+o*(n.x-t.x)/s,f=t.y+o*(n.y-t.y)/s,u=-(n.y-t.y)*(r/s),a=-(n.x-t.x)*(r/s);return[{x:l+u,y:f-a},{x:l-u,y:f+a}]}function Tt(t){const n={x:0,y:0};for(const s of t)n.x+=s.x,n.y+=s.y;return n.x/=t.length,n.y/=t.length,n}function ce(t,n,s,e){e=e||{};const i=e.maxIterations||100,o=e.tolerance||1e-10,r=t(n),l=t(s);let f=s-n;if(r*l>0)throw"Initial bisect points must have opposite signs";if(r===0)return n;if(l===0)return s;for(let u=0;u=0&&(n=a),Math.abs(f)ct(n))}function $(t,n){let s=0;for(let e=0;ev.fx-c.fx,_=n.slice(),S=n.slice(),g=n.slice(),m=n.slice();for(let v=0;v{const D=d.slice();return D.fx=d.fx,D.id=d.id,D});x.sort((d,D)=>d.id-D.id),s.history.push({x:p[0].slice(),fx:p[0].fx,simplex:x})}h=0;for(let x=0;x=p[b-1].fx){let x=!1;if(S.fx>c.fx?(J(g,1+a,_,-a,c),g.fx=t(g),g.fx=1)break;for(let d=1;dl+o*i*f||u>=T)M=i;else{if(Math.abs(y)<=-r*f)return i;y*(M-p)>=0&&(M=p),p=i,T=u}return 0}for(let p=0;p<10;++p){if(J(e.x,1,s.x,i,n),u=e.fx=t(e.x,e.fxprime),y=$(e.fxprime,n),u>l+o*i*f||p&&u>=a)return b(h,i,a);if(Math.abs(y)<=-r*f)return i;if(y>=0)return b(i,h,u);a=u,h=i,i*=2}return i}function fe(t,n,s){let e={x:n.slice(),fx:0,fxprime:n.slice()},i={x:n.slice(),fx:0,fxprime:n.slice()};const o=n.slice();let r,l,f=1,u;s=s||{},u=s.maxIterations||n.length*20,e.fx=t(e.x,e.fxprime),r=e.fxprime.slice(),ft(r,e.fxprime,-1);for(let a=0;a{const y={};for(let h=0;hxt(t,n,e)-s,0,t+n)}function he(t,n={}){const s=n.distinct,e=t.map(l=>Object.assign({},l));function i(l){return l.join(";")}if(s){const l=new Map;for(const f of e)for(let u=0;ul===f?0:lo.sets.length===2).forEach(o=>{const r=s[o.sets[0]],l=s[o.sets[1]],f=Math.sqrt(n[r].size/Math.PI),u=Math.sqrt(n[l].size/Math.PI),a=ht(f,u,o.size);e[r][l]=e[l][r]=a;let y=0;o.size+1e-10>=Math.min(n[r].size,n[l].size)?y=1:o.size<=1e-10&&(y=-1),i[r][l]=i[l][r]=y}),{distances:e,constraints:i}}function ge(t,n,s,e){for(let o=0;o0&&p<=y||h<0&&p>=y||(i+=2*M*M,n[2*o]+=4*M*(r-u),n[2*o+1]+=4*M*(l-a),n[2*f]+=4*M*(u-r),n[2*f+1]+=4*M*(a-l))}}return i}function xe(t,n={}){let s=pe(t,n);const e=n.lossFunction||tt;if(t.length>=8){const i=ye(t,n),o=e(i,t),r=e(s,t);o+1e-8h.map(b=>b/l));const f=(h,b)=>ge(h,b,o,r);let u=null;for(let h=0;hy.sets.length===2);for(const y of t){let h=y.weight!=null?y.weight:1;const b=y.sets[0],p=y.sets[1];y.size+Rt>=Math.min(e[b].size,e[p].size)&&(h=0),i[b].push({set:p,size:y.size,weight:h}),i[p].push({set:b,size:y.size,weight:h})}const o=[];Object.keys(i).forEach(y=>{let h=0;for(let b=0;bt[r]));const o=e.weight!=null?e.weight:1;s+=o*(i-e.size)*(i-e.size)}return s}function Dt(t,n){let s=0;for(const e of n){if(e.sets.length===1)continue;let i;if(e.sets.length===2){const l=t[e.sets[0]],f=t[e.sets[1]];i=xt(l.radius,f.radius,q(l,f))}else i=st(e.sets.map(l=>t[l]));const o=e.weight!=null?e.weight:1,r=Math.log((i+1)/(e.size+1));s+=o*r*r}return s}function me(t,n,s){if(s==null?t.sort((i,o)=>o.radius-i.radius):t.sort(s),t.length>0){const i=t[0].x,o=t[0].y;for(const r of t)r.x-=i,r.y-=o}if(t.length===2&&q(t[0],t[1])1){const i=Math.atan2(t[1].x,t[1].y)-n,o=Math.cos(i),r=Math.sin(i);for(const l of t){const f=l.x,u=l.y;l.x=o*f-r*u,l.y=r*f+o*u}}if(t.length>2){let i=Math.atan2(t[2].x,t[2].y)-n;for(;i<0;)i+=2*Math.PI;for(;i>2*Math.PI;)i-=2*Math.PI;if(i>Math.PI){const o=t[1].y/(1e-10+t[1].x);for(const r of t){var e=(r.x+o*r.y)/(1+o*o);r.x=2*e-r.x,r.y=2*e*o-r.y}}}}function be(t){t.forEach(i=>{i.parent=i});function n(i){return i.parent!==i&&(i.parent=n(i.parent)),i.parent}function s(i,o){const r=n(i),l=n(o);r.parent=l}for(let i=0;i{delete i.parent}),Array.from(e.values())}function dt(t){const n=s=>{const e=t.reduce((o,r)=>Math.max(o,r[s]+r.radius),Number.NEGATIVE_INFINITY),i=t.reduce((o,r)=>Math.min(o,r[s]-r.radius),Number.POSITIVE_INFINITY);return{max:e,min:i}};return{xRange:n("x"),yRange:n("y")}}function Ct(t,n,s){n==null&&(n=Math.PI/2);let e=jt(t).map(u=>Object.assign({},u));const i=be(e);for(const u of i){me(u,n,s);const a=dt(u);u.size=(a.xRange.max-a.xRange.min)*(a.yRange.max-a.yRange.min),u.bounds=a}i.sort((u,a)=>a.size-u.size),e=i[0];let o=e.bounds;const r=(o.xRange.max-o.xRange.min)/50;function l(u,a,y){if(!u)return;const h=u.bounds;let b,p;if(a)b=o.xRange.max-h.xRange.min+r;else{b=o.xRange.max-h.xRange.max;const M=(h.xRange.max-h.xRange.min)/2-(o.xRange.max-o.xRange.min)/2;M<0&&(b+=M)}if(y)p=o.yRange.max-h.yRange.min+r;else{p=o.yRange.max-h.yRange.max;const M=(h.yRange.max-h.yRange.min)/2-(o.yRange.max-o.yRange.min)/2;M<0&&(p+=M)}for(const M of u)M.x+=b,M.y+=p,e.push(M)}let f=1;for(;f({radius:a*b.radius,x:e+y+(b.x-r.min)*a,y:e+h+(b.y-l.min)*a,setid:b.setid})))}function Ot(t){const n={};for(const s of t)n[s.setid]=s;return n}function jt(t){return Object.keys(t).map(s=>Object.assign(t[s],{setid:s}))}function ve(t={}){let n=!1,s=600,e=350,i=15,o=1e3,r=Math.PI/2,l=!0,f=null,u=!0,a=!0,y=null,h=null,b=!1,p=null,M=t&&t.symmetricalTextCentre?t.symmetricalTextCentre:!1,T={},_=t&&t.colourScheme?t.colourScheme:t&&t.colorScheme?t.colorScheme:["#1f77b4","#ff7f0e","#2ca02c","#d62728","#9467bd","#8c564b","#e377c2","#7f7f7f","#bcbd22","#17becf"],S=0,g=function(x){if(x in T)return T[x];var d=T[x]=_[S];return S+=1,S>=_.length&&(S=0),d},m=At,v=tt;function c(x){let d=x.datum();const D=new Set;d.forEach(k=>{k.size==0&&k.sets.length==1&&D.add(k.sets[0])}),d=d.filter(k=>!k.sets.some(j=>D.has(j)));let I={},C={};if(d.length>0){let k=m(d,{lossFunction:v,distinct:b});l&&(k=Ct(k,r,h)),I=Nt(k,s,e,i,f),C=Lt(I,d,M)}const U={};d.forEach(k=>{k.label&&(U[k.sets]=k.label)});function V(k){if(k.sets in U)return U[k.sets];if(k.sets.length==1)return""+k.sets[0]}x.selectAll("svg").data([I]).enter().append("svg");const O=x.select("svg");n?O.attr("viewBox",`0 0 ${s} ${e}`):O.attr("width",s).attr("height",e);const R={};let E=!1;O.selectAll(".venn-area path").each(function(k){const j=this.getAttribute("d");k.sets.length==1&&j&&!b&&(E=!0,R[k.sets[0]]=Me(j))});function A(k){return j=>{const H=k.sets.map(et=>{let Y=R[et],Z=I[et];return Y||(Y={x:s/2,y:e/2,radius:1}),Z||(Z={x:s/2,y:e/2,radius:1}),{x:Y.x*(1-j)+Z.x*j,y:Y.y*(1-j)+Z.y*j,radius:Y.radius*(1-j)+Z.radius*j}});return St(H,p)}}const G=O.selectAll(".venn-area").data(d,k=>k.sets),P=G.enter().append("g").attr("class",k=>`venn-area venn-${k.sets.length==1?"circle":"intersection"}${k.colour||k.color?" venn-coloured":""}`).attr("data-venn-sets",k=>k.sets.join("_")),B=P.append("path"),L=P.append("text").attr("class","label").text(k=>V(k)).attr("text-anchor","middle").attr("dy",".35em").attr("x",s/2).attr("y",e/2);a&&(B.style("fill-opacity","0").filter(k=>k.sets.length==1).style("fill",k=>k.colour?k.colour:k.color?k.color:g(k.sets)).style("fill-opacity",".25"),L.style("fill",k=>k.colour||k.color?"#FFF":t.textFill?t.textFill:k.sets.length==1?g(k.sets):"#444"));function K(k){return typeof k.transition=="function"?k.transition("venn").duration(o):k}let z=x;E&&typeof z.transition=="function"?(z=K(x),z.selectAll("path").attrTween("d",A)):z.selectAll("path").attr("d",k=>St(k.sets.map(j=>I[j])),p);const N=z.selectAll("text").filter(k=>k.sets in C).text(k=>V(k)).attr("x",k=>Math.floor(C[k.sets].x)).attr("y",k=>Math.floor(C[k.sets].y));u&&(E?"on"in N?N.on("end",rt(I,V)):N.each("end",rt(I,V)):N.each(rt(I,V)));const F=K(G.exit()).remove();typeof G.transition=="function"&&F.selectAll("path").attrTween("d",A);const X=F.selectAll("text").attr("x",s/2).attr("y",e/2);return y!==null&&(L.style("font-size","0px"),N.style("font-size",y),X.style("font-size","0px")),{circles:I,textCentres:C,nodes:G,enter:P,update:z,exit:F}}return c.wrap=function(x){return arguments.length?(u=x,c):u},c.useViewBox=function(){return n=!0,c},c.width=function(x){return arguments.length?(s=x,c):s},c.height=function(x){return arguments.length?(e=x,c):e},c.padding=function(x){return arguments.length?(i=x,c):i},c.distinct=function(x){return arguments.length?(b=x,c):b},c.colours=function(x){return arguments.length?(g=x,c):g},c.colors=function(x){return arguments.length?(g=x,c):g},c.fontSize=function(x){return arguments.length?(y=x,c):y},c.round=function(x){return arguments.length?(p=x,c):p},c.duration=function(x){return arguments.length?(o=x,c):o},c.layoutFunction=function(x){return arguments.length?(m=x,c):m},c.normalize=function(x){return arguments.length?(l=x,c):l},c.scaleToFit=function(x){return arguments.length?(f=x,c):f},c.styled=function(x){return arguments.length?(a=x,c):a},c.orientation=function(x){return arguments.length?(r=x,c):r},c.orientationOrder=function(x){return arguments.length?(h=x,c):h},c.lossFunction=function(x){return arguments.length?(v=x==="default"?tt:x==="logRatio"?Dt:x,c):v},c}function rt(t,n){return function(s){const e=this,i=t[s.sets[0]].radius||50,o=n(s)||"",r=o.split(/\s+/).reverse(),f=(o.length+r.length)/3;let u=r.pop(),a=[u],y=0;const h=1.1;e.textContent=null;const b=[];function p(g){const m=e.ownerDocument.createElementNS(e.namespaceURI,"tspan");return m.textContent=g,b.push(m),e.append(m),m}let M=p(u);for(;u=r.pop(),!!u;){a.push(u);const g=a.join(" ");M.textContent=g,g.length>f&&M.getComputedTextLength()>i&&(a.pop(),M.textContent=a.join(" "),a=[u],M=p(u),y++)}const T=.35-y*h/2,_=e.getAttribute("x"),S=e.getAttribute("y");b.forEach((g,m)=>{g.setAttribute("x",_),g.setAttribute("y",S),g.setAttribute("dy",`${T+m*h}em`)})}}function at(t,n,s){let e=n[0].radius-q(n[0],t);for(let i=1;i=o&&(i=e[a],o=y)}const r=zt(a=>-1*at({x:a[0],y:a[1]},t,n),[i.x,i.y],{maxIterations:500,minErrorDelta:1e-10}).x,l={x:s?0:r[0],y:r[1]};let f=!0;for(const a of t)if(q(l,a)>a.radius){f=!1;break}for(const a of n)if(q(l,a)a.p1))}function Ie(t){const n={},s=Object.keys(t);for(const e of s)n[e]=[];for(let e=0;e0&&console.log("WARNING: area "+r+" not represented on screen")}return e}function ke(t,n,s){const e=[];return e.push(` +M`,t,n),e.push(` +m`,-s,0),e.push(` +a`,s,s,0,1,0,s*2,0),e.push(` +a`,s,s,0,1,0,-s*2,0),e.join(" ")}function Me(t){const n=t.split(" ");return{x:Number.parseFloat(n[1]),y:Number.parseFloat(n[2]),radius:-Number.parseFloat(n[4])}}function Pt(t){if(t.length===0)return[];const n={};return st(t,n),n.arcs}function Bt(t,n){if(t.length===0)return"M 0 0";const s=Math.pow(10,n||0),e=n!=null?o=>Math.round(o*s)/s:o=>o;if(t.length==1){const o=t[0].circle;return ke(e(o.x),e(o.y),e(o.radius))}const i=[` +M`,e(t[0].p2.x),e(t[0].p2.y)];for(const o of t){const r=e(o.circle.radius);i.push(` +A`,r,r,0,o.large?1:0,o.sweep?1:0,e(o.p1.x),e(o.p1.y))}return i.join(" ")}function St(t,n){return Bt(Pt(t),n)}function Se(t,n={}){const{lossFunction:s,layoutFunction:e=At,normalize:i=!0,orientation:o=Math.PI/2,orientationOrder:r,width:l=600,height:f=350,padding:u=15,scaleToFit:a=!1,symmetricalTextCentre:y=!1,distinct:h,round:b=2}=n;let p=e(t,{lossFunction:s==="default"||!s?tt:s==="logRatio"?Dt:s,distinct:h});i&&(p=Ct(p,o,r));const M=Nt(p,l,f,u,a),T=Lt(M,t,y),_=new Map(Object.keys(M).map(m=>[m,{set:m,x:M[m].x,y:M[m].y,radius:M[m].radius}])),S=t.map(m=>{const v=m.sets.map(d=>_.get(d)),c=Pt(v),x=Bt(c,b);return{circles:v,arcs:c,path:x,area:m,has:new Set(m.sets)}});function g(m){let v="";for(const c of S)c.has.size>m.length&&m.every(x=>c.has.has(x))&&(v+=" "+c.path);return v}return S.map(({circles:m,arcs:v,path:c,area:x})=>({data:x,text:T[x.sets],circles:m,arcs:v,path:c,distinctPath:c+g(x.sets)}))}var gt=(function(){var t=w(function(S,g,m,v){for(m=m||{},v=S.length;v--;m[S[v]]=g);return m},"o"),n=[5,8],s=[7,8,11,12,17,19,22,24],e=[1,17],i=[1,18],o=[7,8,11,12,14,15,16,17,19,20,21,22,24,27],r=[1,31],l=[1,39],f=[7,8,11,12,17,19,22,24,27],u=[1,57],a=[1,56],y=[1,58],h=[1,59],b=[1,60],p=[7,8,11,12,16,17,19,20,22,24,27,31,32,33],M={trace:w(function(){},"trace"),yy:{},symbols_:{error:2,start:3,optNewlines:4,VENN:5,document:6,EOF:7,NEWLINE:8,line:9,statement:10,TITLE:11,SET:12,identifier:13,BRACKET_LABEL:14,COLON:15,NUMERIC:16,UNION:17,identifierList:18,TEXT:19,IDENTIFIER:20,STRING:21,INDENT_TEXT:22,indentedTextTail:23,STYLE:24,stylesOpt:25,styleField:26,COMMA:27,styleValue:28,valueTokens:29,valueToken:30,HEXCOLOR:31,RGBCOLOR:32,RGBACOLOR:33,$accept:0,$end:1},terminals_:{2:"error",5:"VENN",7:"EOF",8:"NEWLINE",11:"TITLE",12:"SET",14:"BRACKET_LABEL",15:"COLON",16:"NUMERIC",17:"UNION",19:"TEXT",20:"IDENTIFIER",21:"STRING",22:"INDENT_TEXT",24:"STYLE",27:"COMMA",31:"HEXCOLOR",32:"RGBCOLOR",33:"RGBACOLOR"},productions_:[0,[3,4],[4,0],[4,2],[6,0],[6,2],[9,1],[9,1],[10,1],[10,2],[10,3],[10,4],[10,5],[10,2],[10,3],[10,4],[10,5],[10,3],[10,3],[10,3],[10,4],[10,4],[10,2],[10,3],[23,1],[23,1],[23,1],[23,2],[23,2],[25,1],[25,3],[26,3],[28,1],[28,1],[29,1],[29,2],[30,1],[30,1],[30,1],[30,1],[30,1],[18,1],[18,3],[13,1],[13,1]],performAction:w(function(g,m,v,c,x,d,D){var I=d.length-1;switch(x){case 1:return d[I-1];case 2:case 3:case 4:this.$=[];break;case 5:d[I-1].push(d[I]),this.$=d[I-1];break;case 6:this.$=[];break;case 7:case 22:case 32:case 36:case 37:case 38:case 39:case 40:this.$=d[I];break;case 8:c.setDiagramTitle(d[I].substr(6)),this.$=d[I].substr(6);break;case 9:c.addSubsetData([d[I]],void 0,void 0),c.setIndentMode&&c.setIndentMode(!0);break;case 10:c.addSubsetData([d[I-1]],d[I],void 0),c.setIndentMode&&c.setIndentMode(!0);break;case 11:c.addSubsetData([d[I-2]],void 0,parseFloat(d[I])),c.setIndentMode&&c.setIndentMode(!0);break;case 12:c.addSubsetData([d[I-3]],d[I-2],parseFloat(d[I])),c.setIndentMode&&c.setIndentMode(!0);break;case 13:if(d[I].length<2)throw new Error("union requires multiple identifiers");c.validateUnionIdentifiers&&c.validateUnionIdentifiers(d[I]),c.addSubsetData(d[I],void 0,void 0),c.setIndentMode&&c.setIndentMode(!0);break;case 14:if(d[I-1].length<2)throw new Error("union requires multiple identifiers");c.validateUnionIdentifiers&&c.validateUnionIdentifiers(d[I-1]),c.addSubsetData(d[I-1],d[I],void 0),c.setIndentMode&&c.setIndentMode(!0);break;case 15:if(d[I-2].length<2)throw new Error("union requires multiple identifiers");c.validateUnionIdentifiers&&c.validateUnionIdentifiers(d[I-2]),c.addSubsetData(d[I-2],void 0,parseFloat(d[I])),c.setIndentMode&&c.setIndentMode(!0);break;case 16:if(d[I-3].length<2)throw new Error("union requires multiple identifiers");c.validateUnionIdentifiers&&c.validateUnionIdentifiers(d[I-3]),c.addSubsetData(d[I-3],d[I-2],parseFloat(d[I])),c.setIndentMode&&c.setIndentMode(!0);break;case 17:case 18:case 19:c.addTextData(d[I-1],d[I],void 0);break;case 20:case 21:c.addTextData(d[I-2],d[I-1],d[I]);break;case 23:c.addStyleData(d[I-1],d[I]);break;case 24:case 25:case 26:var C=c.getCurrentSets();if(!C)throw new Error("text requires set");c.addTextData(C,d[I],void 0);break;case 27:case 28:var C=c.getCurrentSets();if(!C)throw new Error("text requires set");c.addTextData(C,d[I-1],d[I]);break;case 29:case 41:this.$=[d[I]];break;case 30:case 42:this.$=[...d[I-2],d[I]];break;case 31:this.$=[d[I-2],d[I]];break;case 33:this.$=d[I].join(" ");break;case 34:this.$=[d[I]];break;case 35:d[I-1].push(d[I]),this.$=d[I-1];break;case 43:case 44:this.$=d[I];break}},"anonymous"),table:[t(n,[2,2],{3:1,4:2}),{1:[3]},{5:[1,3],8:[1,4]},t(s,[2,4],{6:5}),t(n,[2,3]),{7:[1,6],8:[1,8],9:7,10:9,11:[1,10],12:[1,11],17:[1,12],19:[1,13],22:[1,14],24:[1,15]},{1:[2,1]},t(s,[2,5]),t(s,[2,6]),t(s,[2,7]),t(s,[2,8]),{13:16,20:e,21:i},{13:20,18:19,20:e,21:i},{13:20,18:21,20:e,21:i},{16:[1,25],20:[1,23],21:[1,24],23:22},{13:20,18:26,20:e,21:i},t(s,[2,9],{14:[1,27],15:[1,28]}),t(o,[2,43]),t(o,[2,44]),t(s,[2,13],{14:[1,29],15:[1,30],27:r}),t(o,[2,41]),{16:[1,34],20:[1,32],21:[1,33],27:r},t(s,[2,22]),t(s,[2,24],{14:[1,35]}),t(s,[2,25],{14:[1,36]}),t(s,[2,26]),{20:l,25:37,26:38,27:r},t(s,[2,10],{15:[1,40]}),{16:[1,41]},t(s,[2,14],{15:[1,42]}),{16:[1,43]},{13:44,20:e,21:i},t(s,[2,17],{14:[1,45]}),t(s,[2,18],{14:[1,46]}),t(s,[2,19]),t(s,[2,27]),t(s,[2,28]),t(s,[2,23],{27:[1,47]}),t(f,[2,29]),{15:[1,48]},{16:[1,49]},t(s,[2,11]),{16:[1,50]},t(s,[2,15]),t(o,[2,42]),t(s,[2,20]),t(s,[2,21]),{20:l,26:51},{16:u,20:a,21:[1,53],28:52,29:54,30:55,31:y,32:h,33:b},t(s,[2,12]),t(s,[2,16]),t(f,[2,30]),t(f,[2,31]),t(f,[2,32]),t(f,[2,33],{30:61,16:u,20:a,31:y,32:h,33:b}),t(p,[2,34]),t(p,[2,36]),t(p,[2,37]),t(p,[2,38]),t(p,[2,39]),t(p,[2,40]),t(p,[2,35])],defaultActions:{6:[2,1]},parseError:w(function(g,m){if(m.recoverable)this.trace(g);else{var v=new Error(g);throw v.hash=m,v}},"parseError"),parse:w(function(g){var m=this,v=[0],c=[],x=[null],d=[],D=this.table,I="",C=0,U=0,V=2,O=1,R=d.slice.call(arguments,1),E=Object.create(this.lexer),A={yy:{}};for(var G in this.yy)Object.prototype.hasOwnProperty.call(this.yy,G)&&(A.yy[G]=this.yy[G]);E.setInput(g,A.yy),A.yy.lexer=E,A.yy.parser=this,typeof E.yylloc>"u"&&(E.yylloc={});var P=E.yylloc;d.push(P);var B=E.options&&E.options.ranges;typeof A.yy.parseError=="function"?this.parseError=A.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function L(W){v.length=v.length-2*W,x.length=x.length-W,d.length=d.length-W}w(L,"popStack");function K(){var W;return W=c.pop()||E.lex()||O,typeof W!="number"&&(W instanceof Array&&(c=W,W=c.pop()),W=m.symbols_[W]||W),W}w(K,"lex");for(var z,N,F,X,k={},j,H,et,Y;;){if(N=v[v.length-1],this.defaultActions[N]?F=this.defaultActions[N]:((z===null||typeof z>"u")&&(z=K()),F=D[N]&&D[N][z]),typeof F>"u"||!F.length||!F[0]){var Z="";Y=[];for(j in D[N])this.terminals_[j]&&j>V&&Y.push("'"+this.terminals_[j]+"'");E.showPosition?Z="Parse error on line "+(C+1)+`: +`+E.showPosition()+` +Expecting `+Y.join(", ")+", got '"+(this.terminals_[z]||z)+"'":Z="Parse error on line "+(C+1)+": Unexpected "+(z==O?"end of input":"'"+(this.terminals_[z]||z)+"'"),this.parseError(Z,{text:E.match,token:this.terminals_[z]||z,line:E.yylineno,loc:P,expected:Y})}if(F[0]instanceof Array&&F.length>1)throw new Error("Parse Error: multiple actions possible at state: "+N+", token: "+z);switch(F[0]){case 1:v.push(z),x.push(E.yytext),d.push(E.yylloc),v.push(F[1]),z=null,U=E.yyleng,I=E.yytext,C=E.yylineno,P=E.yylloc;break;case 2:if(H=this.productions_[F[1]][1],k.$=x[x.length-H],k._$={first_line:d[d.length-(H||1)].first_line,last_line:d[d.length-1].last_line,first_column:d[d.length-(H||1)].first_column,last_column:d[d.length-1].last_column},B&&(k._$.range=[d[d.length-(H||1)].range[0],d[d.length-1].range[1]]),X=this.performAction.apply(k,[I,U,C,A.yy,F[1],x,d].concat(R)),typeof X<"u")return X;H&&(v=v.slice(0,-1*H*2),x=x.slice(0,-1*H),d=d.slice(0,-1*H)),v.push(this.productions_[F[1]][0]),x.push(k.$),d.push(k._$),et=D[v[v.length-2]][v[v.length-1]],v.push(et);break;case 3:return!0}}return!0},"parse")},T=(function(){var S={EOF:1,parseError:w(function(m,v){if(this.yy.parser)this.yy.parser.parseError(m,v);else throw new Error(m)},"parseError"),setInput:w(function(g,m){return this.yy=m||this.yy||{},this._input=g,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:w(function(){var g=this._input[0];this.yytext+=g,this.yyleng++,this.offset++,this.match+=g,this.matched+=g;var m=g.match(/(?:\r\n?|\n).*/g);return m?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),g},"input"),unput:w(function(g){var m=g.length,v=g.split(/(?:\r\n?|\n)/g);this._input=g+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-m),this.offset-=m;var c=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),v.length-1&&(this.yylineno-=v.length-1);var x=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:v?(v.length===c.length?this.yylloc.first_column:0)+c[c.length-v.length].length-v[0].length:this.yylloc.first_column-m},this.options.ranges&&(this.yylloc.range=[x[0],x[0]+this.yyleng-m]),this.yyleng=this.yytext.length,this},"unput"),more:w(function(){return this._more=!0,this},"more"),reject:w(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:w(function(g){this.unput(this.match.slice(g))},"less"),pastInput:w(function(){var g=this.matched.substr(0,this.matched.length-this.match.length);return(g.length>20?"...":"")+g.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:w(function(){var g=this.match;return g.length<20&&(g+=this._input.substr(0,20-g.length)),(g.substr(0,20)+(g.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:w(function(){var g=this.pastInput(),m=new Array(g.length+1).join("-");return g+this.upcomingInput()+` +`+m+"^"},"showPosition"),test_match:w(function(g,m){var v,c,x;if(this.options.backtrack_lexer&&(x={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(x.yylloc.range=this.yylloc.range.slice(0))),c=g[0].match(/(?:\r\n?|\n).*/g),c&&(this.yylineno+=c.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:c?c[c.length-1].length-c[c.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+g[0].length},this.yytext+=g[0],this.match+=g[0],this.matches=g,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(g[0].length),this.matched+=g[0],v=this.performAction.call(this,this.yy,this,m,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),v)return v;if(this._backtrack){for(var d in x)this[d]=x[d];return!1}return!1},"test_match"),next:w(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var g,m,v,c;this._more||(this.yytext="",this.match="");for(var x=this._currentRules(),d=0;dm[0].length)){if(m=v,c=d,this.options.backtrack_lexer){if(g=this.test_match(v,x[d]),g!==!1)return g;if(this._backtrack){m=!1;continue}else return!1}else if(!this.options.flex)break}return m?(g=this.test_match(m,x[c]),g!==!1?g:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:w(function(){var m=this.next();return m||this.lex()},"lex"),begin:w(function(m){this.conditionStack.push(m)},"begin"),popState:w(function(){var m=this.conditionStack.length-1;return m>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:w(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:w(function(m){return m=this.conditionStack.length-1-Math.abs(m||0),m>=0?this.conditionStack[m]:"INITIAL"},"topState"),pushState:w(function(m){this.begin(m)},"pushState"),stateStackSize:w(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:w(function(m,v,c,x){switch(c){case 0:break;case 1:break;case 2:break;case 3:if(m.getIndentMode&&m.getIndentMode())return m.consumeIndentText=!0,this.begin("INITIAL"),22;break;case 4:break;case 5:m.setIndentMode&&m.setIndentMode(!1),this.begin("INITIAL"),this.unput(v.yytext);break;case 6:return this.begin("bol"),8;case 7:break;case 8:break;case 9:return 7;case 10:return 11;case 11:return 5;case 12:return 12;case 13:return 17;case 14:if(m.consumeIndentText)m.consumeIndentText=!1;else return 19;break;case 15:return 24;case 16:return v.yytext=v.yytext.slice(2,-2),14;case 17:return v.yytext=v.yytext.slice(1,-1).trim(),14;case 18:return 16;case 19:return 31;case 20:return 33;case 21:return 32;case 22:return 20;case 23:return 21;case 24:return 27;case 25:return 15}},"anonymous"),rules:[/^(?:%%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:[ \t]+(?=[\n\r]))/i,/^(?:[ \t]+(?=text\b))/i,/^(?:[ \t]+)/i,/^(?:[^ \t\n\r])/i,/^(?:[\n\r]+)/i,/^(?:%%[^\n]*)/i,/^(?:[ \t]+)/i,/^(?:$)/i,/^(?:title\s[^#\n;]+)/i,/^(?:venn-beta\b)/i,/^(?:set\b)/i,/^(?:union\b)/i,/^(?:text\b)/i,/^(?:style\b)/i,/^(?:\["[^\"]*"\])/i,/^(?:\[[^\]\"]+\])/i,/^(?:[+-]?(\d+(\.\d+)?|\.\d+))/i,/^(?:#[0-9a-fA-F]{3,8})/i,/^(?:rgba\(\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*\))/i,/^(?:rgb\(\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*\))/i,/^(?:[A-Za-z_][A-Za-z0-9\-_]*)/i,/^(?:"[^\"]*")/i,/^(?:,)/i,/^(?::)/i],conditions:{bol:{rules:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25],inclusive:!0},INITIAL:{rules:[0,1,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25],inclusive:!0}}};return S})();M.lexer=T;function _(){this.yy={}}return w(_,"Parser"),_.prototype=M,M.Parser=_,new _})();gt.parser=gt;var we=gt,yt=[],pt=[],mt=[],bt=new Set,vt,It=!1,_e=w((t,n,s)=>{const e=it(t).sort(),i=s??10/Math.pow(t.length,2);vt=e,e.length===1&&bt.add(e[0]),yt.push({sets:e,size:i,label:n?nt(n):void 0})},"addSubsetData"),Ee=w(()=>yt,"getSubsetData"),nt=w(t=>{const n=t.trim();return n.length>=2&&n.startsWith('"')&&n.endsWith('"')?n.slice(1,-1):n},"normalizeText"),Te=w(t=>t&&nt(t),"normalizeStyleValue"),ze=w((t,n,s)=>{const e=nt(n);pt.push({sets:it(t).sort(),id:e,label:s?nt(s):void 0})},"addTextData"),Ae=w((t,n)=>{const s=it(t).sort(),e={};for(const[i,o]of n)e[i]=Te(o)??o;mt.push({targets:s,styles:e})},"addStyleData"),Re=w(()=>mt,"getStyleData"),it=w(t=>t.map(n=>nt(n)),"normalizeIdentifierList"),De=w(t=>{const s=it(t).filter(e=>!bt.has(e));if(s.length>0)throw new Error(`unknown set identifier: ${s.join(", ")}`)},"validateUnionIdentifiers"),Ce=w(()=>pt,"getTextData"),Ne=w(()=>vt,"getCurrentSets"),Oe=w(()=>It,"getIndentMode"),je=w(t=>{It=t},"setIndentMode"),Fe=re.venn;function Vt(){return oe(Fe,wt().venn)}w(Vt,"getConfig");var Le=w(()=>{ie(),yt.length=0,pt.length=0,mt.length=0,bt.clear(),vt=void 0,It=!1},"customClear"),Pe={getConfig:Vt,clear:Le,setAccTitle:Jt,getAccTitle:Zt,setDiagramTitle:Xt,getDiagramTitle:Yt,getAccDescription:Ht,setAccDescription:Kt,addSubsetData:_e,getSubsetData:Ee,addTextData:ze,addStyleData:Ae,validateUnionIdentifiers:De,getTextData:Ce,getStyleData:Re,getCurrentSets:Ne,getIndentMode:Oe,setIndentMode:je},Be=w(t=>` + .venn-title { + font-size: 32px; + fill: ${t.vennTitleTextColor}; + font-family: ${t.fontFamily}; + } + + .venn-circle text { + font-size: 48px; + font-family: ${t.fontFamily}; + } + + .venn-intersection text { + font-size: 48px; + fill: ${t.vennSetTextColor}; + font-family: ${t.fontFamily}; + } + + .venn-text-node { + font-family: ${t.fontFamily}; + color: ${t.vennSetTextColor}; + } +`,"getStyles"),Ve=Be;function qt(t){const n=new Map;for(const s of t){const e=s.targets.join("|"),i=n.get(e);i?Object.assign(i,s.styles):n.set(e,{...s.styles})}return n}w(qt,"buildStyleByKey");var qe=w((t,n,s,e)=>{const i=e.db,o=i.getConfig?.(),{themeVariables:r,look:l,handDrawnSeed:f}=wt(),u=l==="handDrawn",a=[r.venn1,r.venn2,r.venn3,r.venn4,r.venn5,r.venn6,r.venn7,r.venn8].filter(Boolean),y=i.getDiagramTitle?.(),h=i.getSubsetData(),b=i.getTextData(),p=qt(i.getStyleData()),M=Gt(h),T=o?.width??800,_=o?.height??450,g=T/1600,m=y?48*g:0,v=r.primaryTextColor??r.textColor,c=Qt(n);c.attr("viewBox",`0 0 ${T} ${_}`),y&&c.append("text").text(y).attr("class","venn-title").attr("font-size",`${32*g}px`).attr("text-anchor","middle").attr("dominant-baseline","middle").attr("x","50%").attr("y",32*g).style("fill",r.vennTitleTextColor||r.titleColor);const x=ot(document.createElement("div")),d=ve().width(T).height(_-m);x.datum(M).call(d);const D=u?$t.svg(x.select("svg").node()):void 0,I=Se(M,{width:T,height:_-m,padding:o?.padding??15}),C=new Map;for(const R of I){const E=Q([...R.data.sets].sort());C.set(E,R)}b.length>0&&Ut(o,C,x,b,g,p);const U=te(r.background||"#f4f4f4");x.selectAll(".venn-circle").each(function(R,E){const A=ot(this),P=Q([...R.sets].sort()),B=p.get(P),L=B?.fill||a[E%a.length]||r.primaryColor;A.classed(`venn-set-${E%8}`,!0);const K=B?.["fill-opacity"]??.1,z=B?.stroke||L,N=B?.["stroke-width"]||`${5*g}`;if(u&&D){const X=C.get(P);if(X&&X.circles.length>0){const k=X.circles[0],j=D.circle(k.x,k.y,k.radius*2,{roughness:.7,seed:f,fill:kt(L,.7),fillStyle:"hachure",fillWeight:2,hachureGap:8,hachureAngle:-41+E*60,stroke:z,strokeWidth:parseFloat(String(N))});A.select("path").remove(),A.node()?.insertBefore(j,A.select("text").node())}}else A.select("path").style("fill",L).style("fill-opacity",K).style("stroke",z).style("stroke-width",N).style("stroke-opacity",.95);const F=B?.color||(U?ee(L,30):ne(L,30));A.select("text").style("font-size",`${48*g}px`).style("fill",F)}),u&&D?x.selectAll(".venn-intersection").each(function(R){const E=ot(this),G=Q([...R.sets].sort()),P=p.get(G),B=P?.fill;if(B){const L=E.select("path"),K=L.attr("d");if(K){const z=D.path(K,{roughness:.7,seed:f,fill:kt(B,.3),fillStyle:"cross-hatch",fillWeight:2,hachureGap:6,hachureAngle:60,stroke:"none"}),N=L.node();N?.parentNode?.insertBefore(z,N),L.remove()}}else E.select("path").style("fill-opacity",0);E.select("text").style("font-size",`${48*g}px`).style("fill",P?.color??r.vennSetTextColor??v)}):(x.selectAll(".venn-intersection text").style("font-size",`${48*g}px`).style("fill",R=>{const A=Q([...R.sets].sort());return p.get(A)?.color??r.vennSetTextColor??v}),x.selectAll(".venn-intersection path").style("fill-opacity",R=>{const A=Q([...R.sets].sort());return p.get(A)?.fill?1:0}).style("fill",R=>{const A=Q([...R.sets].sort());return p.get(A)?.fill??"transparent"}));const V=c.append("g").attr("transform",`translate(0, ${m})`),O=x.select("svg").node();if(O&&"childNodes"in O)for(const R of[...O.childNodes])V.node()?.appendChild(R);se(c,_,T,o?.useMaxWidth??!0)},"draw");function Q(t){return t.join("|")}w(Q,"stableSetsKey");function Ut(t,n,s,e,i,o){const r=t?.useDebugLayout??!1,f=s.select("svg").append("g").attr("class","venn-text-nodes"),u=new Map;for(const a of e){const y=Q(a.sets),h=u.get(y);h?h.push(a):u.set(y,[a])}for(const[a,y]of u.entries()){const h=n.get(a);if(!h?.text)continue;const b=h.text.x,p=h.text.y,M=Math.min(...h.circles.map(O=>O.radius)),T=Math.min(...h.circles.map(O=>O.radius-Math.hypot(b-O.x,p-O.y)));let _=Number.isFinite(T)?Math.max(0,T):0;_===0&&Number.isFinite(M)&&(_=M*.6);const S=f.append("g").attr("class","venn-text-area").attr("font-size",`${40*i}px`);r&&S.append("circle").attr("class","venn-text-debug-circle").attr("cx",b).attr("cy",p).attr("r",_).attr("fill","none").attr("stroke","purple").attr("stroke-width",1.5*i).attr("stroke-dasharray",`${6*i} ${4*i}`);const g=Math.max(80*i,_*2*.95),m=Math.max(60*i,_*2*.95),x=(h.data.label&&h.data.label.length>0?Math.min(32*i,_*.25):0)+(y.length<=2?30*i:0),d=b-g/2,D=p-m/2+x,I=Math.max(1,Math.ceil(Math.sqrt(y.length))),C=Math.max(1,Math.ceil(y.length/I)),U=g/I,V=m/C;for(const[O,R]of y.entries()){const E=O%I,A=Math.floor(O/I),G=d+U*(E+.5),P=D+V*(A+.5);r&&S.append("rect").attr("class","venn-text-debug-cell").attr("x",d+U*E).attr("y",D+V*A).attr("width",U).attr("height",V).attr("fill","none").attr("stroke","teal").attr("stroke-width",1*i).attr("stroke-dasharray",`${4*i} ${3*i}`);const B=U*.9,L=V*.9,K=S.append("foreignObject").attr("class","venn-text-node-fo").attr("width",B).attr("height",L).attr("x",G-B/2).attr("y",P-L/2).attr("overflow","visible"),z=o.get(R.id)?.color,N=K.append("xhtml:span").attr("class","venn-text-node").style("display","flex").style("width","100%").style("height","100%").style("white-space","normal").style("align-items","center").style("justify-content","center").style("text-align","center").style("overflow-wrap","normal").style("word-break","normal").text(R.label??R.id);z&&N.style("color",z)}}}w(Ut,"renderTextNodes");function Gt(t){const n=new Set(t.map(i=>[...i.sets].sort().join("|"))),s=new Map(t.filter(i=>i.sets.length===1&&i.size!==void 0).map(i=>[i.sets[0],i.size])),e=[];for(const i of t){if(i.sets.length<3)continue;const o=[...i.sets].sort();for(let r=0;r0?[...t,...e]:t}w(Gt,"ensurePairwiseSubsets");var Ue={draw:qe},He={parser:we,db:Pe,renderer:Ue,styles:Ve};export{He as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/virtual_mermaid-config.DDnGl6nM.js b/packages/tempo/public/v4/assets/chunks/virtual_mermaid-config.DDnGl6nM.js new file mode 100644 index 00000000..effcb965 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/virtual_mermaid-config.DDnGl6nM.js @@ -0,0 +1 @@ +const e={securityLevel:"loose",startOnLoad:!1};export{e as default}; diff --git a/packages/tempo/public/v4/assets/chunks/wardleyDiagram-VM6X3IG4.DCCyph2y.js b/packages/tempo/public/v4/assets/chunks/wardleyDiagram-VM6X3IG4.DCCyph2y.js new file mode 100644 index 00000000..89fde6fc --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/wardleyDiagram-VM6X3IG4.DCCyph2y.js @@ -0,0 +1,78 @@ +import{p as St}from"./chunk-JWPE2WC7.5yopTNlD.js";import{s as Mt,g as Nt,q as zt,p as Lt,a as Tt,b as At,_ as u,X as Xt,A as Et,D as U,l as K,G as Yt,d as It,r as Bt,c as j}from"../app.CbekdYod.js";import{p as Ft}from"./cynefin-OW5HDTMX.C9PKCYHo.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";var D=u((e,n)=>{const r=e<=1?e*100:e;if(r<0||r>100)throw new Error(`${n} must be between 0-1 (decimal) or 0-100 (percentage). Received: ${e}`);return r},"toPercent"),A=u((e,n,r)=>({x:D(n,`${r} evolution`),y:D(e,`${r} visibility`)}),"toCoordinates"),J=u(e=>{if(e){if(e==="+<>")return"bidirectional";if(e==="+<")return"backward";if(e==="+>")return"forward"}},"getFlowFromPort"),Rt=u(e=>{if(!e?.startsWith("+"))return{};const r=/^\+'([^']*)'/.exec(e)?.[1];return e.includes("<>")?{flow:"bidirectional",label:r}:e.includes("<")?{flow:"backward",label:r}:e.includes(">")?{flow:"forward",label:r}:{label:r}},"extractFlowFromArrow"),Ot=u((e,n)=>{if(St(e,n),e.size&&n.setSize(e.size.width,e.size.height),e.evolution){const r=e.evolution.stages.map(a=>a.secondName?`${a.name.trim()} / ${a.secondName.trim()}`:a.name.trim()),x=e.evolution.stages.filter(a=>a.boundary!==void 0).map(a=>a.boundary);n.updateAxes({stages:r,stageBoundaries:x})}if(e.anchors.forEach(r=>{const x=A(r.visibility,r.evolution,`Anchor "${r.name}"`);n.addNode(r.name,r.name,x.x,x.y,"anchor")}),e.components.forEach(r=>{const x=A(r.visibility,r.evolution,`Component "${r.name}"`),a=r.label?(r.label.negX?-1:1)*r.label.offsetX:void 0,d=r.label?(r.label.negY?-1:1)*r.label.offsetY:void 0,w=r.decorator?.strategy;n.addNode(r.name,r.name,x.x,x.y,"component",a,d,r.inertia,w)}),e.notes.forEach(r=>{const x=A(r.visibility,r.evolution,`Note "${r.text}"`);n.addNote(r.text,x.x,x.y)}),e.pipelines.forEach(r=>{const x=n.getNode(r.parent);if(!x||typeof x.y!="number")throw new Error(`Pipeline "${r.parent}" must reference an existing component with coordinates.`);const a=x.y;n.startPipeline(r.parent),r.components.forEach(d=>{const w=`${r.parent}_${d.name}`,C=d.label?(d.label.negX?-1:1)*d.label.offsetX:void 0,g=d.label?(d.label.negY?-1:1)*d.label.offsetY:void 0,F=D(d.evolution,`Pipeline component "${d.name}" evolution`);n.addNode(w,d.name,F,a,"pipeline-component",C,g),n.addPipelineComponent(r.parent,w)})}),e.links.forEach(r=>{const x=!!r.arrow&&(r.arrow.includes("-.->")||r.arrow.includes(".-."));let a=J(r.fromPort)??J(r.toPort);const{flow:d,label:w}=Rt(r.arrow);!a&&d&&(a=d);const C=r.linkLabel,g=w??C;n.addLink(n.resolveNodeId(r.from),n.resolveNodeId(r.to),x,g,a)}),e.evolves.forEach(r=>{const x=n.getNode(r.component);if(x?.y!==void 0){const a=D(r.target,`Evolve target for "${r.component}"`);n.addTrend(r.component,a,x.y)}}),e.annotations.length>0){const r=e.annotations[0],x=A(r.x,r.y,"Annotations box");n.setAnnotationsBox(x.x,x.y)}e.annotation.forEach(r=>{const x=A(r.x,r.y,`Annotation ${r.number}`);n.addAnnotation(r.number,[{x:x.x,y:x.y}],r.text)}),e.accelerators.forEach(r=>{const x=A(r.x,r.y,`Accelerator "${r.name}"`);n.addAccelerator(r.name,x.x,x.y)}),e.deaccelerators.forEach(r=>{const x=A(r.x,r.y,`Deaccelerator "${r.name}"`);n.addDeaccelerator(r.name,x.x,x.y)})},"populateDb"),Q={parser:{yy:void 0},parse:u(async e=>{const n=await Ft("wardley",e);K.debug(n);const r=Q.parser?.yy;if(!r||typeof r.addNode!="function")throw new Error("parser.parser?.yy was not a WardleyDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues.");Ot(n,r)},"parse")},Wt=class{constructor(){this.nodes=new Map,this.links=[],this.trends=new Map,this.pipelines=new Map,this.annotations=[],this.notes=[],this.accelerators=[],this.deaccelerators=[],this.axes={}}static{u(this,"WardleyBuilder")}addNode(e){const n=this.nodes.get(e.id)??{id:e.id,label:e.label},r={...n,...e,className:e.className??n.className,labelOffsetX:e.labelOffsetX??n.labelOffsetX,labelOffsetY:e.labelOffsetY??n.labelOffsetY};this.nodes.set(e.id,r)}addLink(e){this.links.push(e)}addTrend(e){this.trends.set(e.nodeId,e)}startPipeline(e){this.pipelines.set(e,{nodeId:e,componentIds:[]});const n=this.nodes.get(e);n&&(n.isPipelineParent=!0)}addPipelineComponent(e,n){const r=this.pipelines.get(e);r&&r.componentIds.push(n);const x=this.nodes.get(n);x&&(x.inPipeline=!0)}addAnnotation(e){this.annotations.push(e)}addNote(e){this.notes.push(e)}addAccelerator(e){this.accelerators.push(e)}addDeaccelerator(e){this.deaccelerators.push(e)}setAnnotationsBox(e,n){this.annotationsBox={x:e,y:n}}setAxes(e){this.axes={...this.axes,...e}}setSize(e,n){this.size={width:e,height:n}}getNode(e){return this.nodes.get(e)}resolveNodeId(e){if(this.nodes.has(e))return e;for(const[n,r]of this.nodes)if(r.label===e)return n;return e}build(){const e=[];for(const n of this.nodes.values()){if(typeof n.x!="number"||typeof n.y!="number")throw new Error(`Node "${n.label}" is missing coordinates`);e.push(n)}return{nodes:e,links:[...this.links],trends:[...this.trends.values()],pipelines:[...this.pipelines.values()],annotations:[...this.annotations],notes:[...this.notes],accelerators:[...this.accelerators],deaccelerators:[...this.deaccelerators],annotationsBox:this.annotationsBox,axes:{...this.axes},size:this.size}}clear(){this.nodes.clear(),this.links=[],this.trends.clear(),this.pipelines.clear(),this.annotations=[],this.notes=[],this.accelerators=[],this.deaccelerators=[],this.annotationsBox=void 0,this.axes={},this.size=void 0}},k=new Wt;function tt(){return j()["wardley-beta"]}u(tt,"getConfig");function et(e,n,r,x,a,d,w,C,g){k.addNode({id:e,label:n,x:r,y:x,className:a,labelOffsetX:d,labelOffsetY:w,inertia:C,sourceStrategy:g})}u(et,"addNode");function at(e,n,r=!1,x,a){k.addLink({source:e,target:n,dashed:r,label:x,flow:a})}u(at,"addLink");function rt(e,n,r){k.addTrend({nodeId:e,targetX:n,targetY:r})}u(rt,"addTrend");function ot(e,n,r){k.addAnnotation({number:e,coordinates:n,text:r})}u(ot,"addAnnotation");function nt(e,n,r){k.addNote({text:e,x:n,y:r})}u(nt,"addNote");function st(e,n,r){k.addAccelerator({name:e,x:n,y:r})}u(st,"addAccelerator");function it(e,n,r){k.addDeaccelerator({name:e,x:n,y:r})}u(it,"addDeaccelerator");function dt(e,n){k.setAnnotationsBox(e,n)}u(dt,"setAnnotationsBox");function lt(e,n){k.setSize(e,n)}u(lt,"setSize");function ct(e){k.startPipeline(e)}u(ct,"startPipeline");function pt(e,n){k.addPipelineComponent(e,n)}u(pt,"addPipelineComponent");function ft(e){k.setAxes(e)}u(ft,"updateAxes");function ht(e){return k.getNode(e)}u(ht,"getNode");function xt(e){return k.resolveNodeId(e)}u(xt,"resolveNodeId");function gt(){return k.build()}u(gt,"getWardleyData");function yt(){k.clear(),Bt()}u(yt,"clear");var Dt={getConfig:tt,addNode:et,addLink:at,addTrend:rt,addAnnotation:ot,addNote:nt,addAccelerator:st,addDeaccelerator:it,setAnnotationsBox:dt,setSize:lt,startPipeline:ct,addPipelineComponent:pt,updateAxes:ft,getNode:ht,resolveNodeId:xt,getWardleyData:gt,clear:yt,setAccTitle:At,getAccTitle:Tt,setDiagramTitle:Lt,getDiagramTitle:zt,getAccDescription:Nt,setAccDescription:Mt},Gt=["Genesis","Custom Built","Product","Commodity"],qt=u(()=>{const{themeVariables:e}=j();return{backgroundColor:e.wardley?.backgroundColor??e.background??"#fff",axisColor:e.wardley?.axisColor??"#000",axisTextColor:e.wardley?.axisTextColor??e.primaryTextColor??"#222",gridColor:e.wardley?.gridColor??"rgba(100, 100, 100, 0.2)",componentFill:e.wardley?.componentFill??"#fff",componentStroke:e.wardley?.componentStroke??"#000",componentLabelColor:e.wardley?.componentLabelColor??e.primaryTextColor??"#222",linkStroke:e.wardley?.linkStroke??"#000",evolutionStroke:e.wardley?.evolutionStroke??"#dc3545",annotationStroke:e.wardley?.annotationStroke??"#000",annotationTextColor:e.wardley?.annotationTextColor??e.primaryTextColor??"#222",annotationFill:e.wardley?.annotationFill??e.background??"#fff"}},"getTheme"),Ht=u(()=>{const e=j()["wardley-beta"];return{width:e?.width??900,height:e?.height??600,padding:e?.padding??48,nodeRadius:e?.nodeRadius??6,nodeLabelOffset:e?.nodeLabelOffset??8,axisFontSize:e?.axisFontSize??12,labelFontSize:e?.labelFontSize??10,showGrid:e?.showGrid??!1,useMaxWidth:e?.useMaxWidth??!0}},"getConfigValues"),jt=u((e,n,r,x)=>{K.debug(`Rendering Wardley map +`+e);const a=Ht(),d=qt(),w=a.nodeRadius*1.6,C=x.db,g=C.getWardleyData(),F=C.getDiagramTitle(),S=g.size?.width??a.width,b=g.size?.height??a.height,E=Yt(n);E.selectAll("*").remove(),It(E,b,S,a.useMaxWidth),E.attr("viewBox",`0 0 ${S} ${b}`);const v=E.append("g").attr("class","wardley-map"),G=E.append("defs");G.append("marker").attr("id",`arrow-${n}`).attr("viewBox","0 0 10 10").attr("refX",9).attr("refY",5).attr("markerWidth",6).attr("markerHeight",6).attr("orient","auto-start-reverse").append("path").attr("d","M 0 0 L 10 5 L 0 10 z").attr("fill",d.evolutionStroke).attr("stroke","none"),G.append("marker").attr("id",`link-arrow-end-${n}`).attr("viewBox","0 0 10 10").attr("refX",9).attr("refY",5).attr("markerWidth",5).attr("markerHeight",5).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z").attr("fill",d.linkStroke).attr("stroke","none"),G.append("marker").attr("id",`link-arrow-start-${n}`).attr("viewBox","0 0 10 10").attr("refX",1).attr("refY",5).attr("markerWidth",5).attr("markerHeight",5).attr("orient","auto").append("path").attr("d","M 10 0 L 0 5 L 10 10 z").attr("fill",d.linkStroke).attr("stroke","none"),v.append("rect").attr("class","wardley-background").attr("width",S).attr("height",b).attr("fill",d.backgroundColor);const Y=S-a.padding*2,I=b-a.padding*2;F&&v.append("text").attr("class","wardley-title").attr("x",S/2).attr("y",a.padding/2).attr("fill",d.axisTextColor).attr("font-size",a.axisFontSize*1.05).attr("font-weight","bold").attr("text-anchor","middle").attr("dominant-baseline","middle").text(F);const z=u(t=>a.padding+t/100*Y,"projectX"),L=u(t=>b-a.padding-t/100*I,"projectY"),R=v.append("g").attr("class","wardley-axes");R.append("line").attr("x1",a.padding).attr("x2",S-a.padding).attr("y1",b-a.padding).attr("y2",b-a.padding).attr("stroke",d.axisColor).attr("stroke-width",1),R.append("line").attr("x1",a.padding).attr("x2",a.padding).attr("y1",a.padding).attr("y2",b-a.padding).attr("stroke",d.axisColor).attr("stroke-width",1);const ut=g.axes.xLabel??"Evolution",wt=g.axes.yLabel??"Visibility";R.append("text").attr("class","wardley-axis-label wardley-axis-label-x").attr("x",a.padding+Y/2).attr("y",b-a.padding/4).attr("fill",d.axisTextColor).attr("font-size",a.axisFontSize).attr("font-weight","bold").attr("text-anchor","middle").text(ut),R.append("text").attr("class","wardley-axis-label wardley-axis-label-y").attr("x",a.padding/3).attr("y",a.padding+I/2).attr("fill",d.axisTextColor).attr("font-size",a.axisFontSize).attr("font-weight","bold").attr("text-anchor","middle").attr("transform",`rotate(-90 ${a.padding/3} ${a.padding+I/2})`).text(wt);const B=g.axes.stages&&g.axes.stages.length>0?g.axes.stages:Gt;if(B.length>0){const t=v.append("g").attr("class","wardley-stages"),s=g.axes.stageBoundaries,o=[];if(s&&s.length===B.length){let i=0;s.forEach(p=>{o.push({start:i,end:p}),i=p})}else{const i=1/B.length;B.forEach((p,l)=>{o.push({start:l*i,end:(l+1)*i})})}B.forEach((i,p)=>{const l=o[p],f=a.padding+l.start*Y,h=a.padding+l.end*Y,y=(f+h)/2;p>0&&t.append("line").attr("x1",f).attr("x2",f).attr("y1",a.padding).attr("y2",b-a.padding).attr("stroke","#000").attr("stroke-width",1).attr("stroke-dasharray","5 5").attr("opacity",.8),t.append("text").attr("class","wardley-stage-label").attr("x",y).attr("y",b-a.padding/1.5).attr("fill",d.axisTextColor).attr("font-size",a.axisFontSize-2).attr("text-anchor","middle").text(i)})}if(a.showGrid){const t=v.append("g").attr("class","wardley-grid");for(let s=1;s<4;s++){const o=s/4,i=a.padding+Y*o;t.append("line").attr("x1",i).attr("x2",i).attr("y1",a.padding).attr("y2",b-a.padding).attr("stroke",d.gridColor).attr("stroke-dasharray","2 6"),t.append("line").attr("x1",a.padding).attr("x2",S-a.padding).attr("y1",b-a.padding-I*o).attr("y2",b-a.padding-I*o).attr("stroke",d.gridColor).attr("stroke-dasharray","2 6")}}const c=new Map;if(g.nodes.forEach(t=>{c.set(t.id,{x:z(t.x),y:L(t.y),node:t})}),g.pipelines.length>0){const t=v.append("g").attr("class","wardley-pipelines"),s=v.append("g").attr("class","wardley-pipeline-links");g.pipelines.forEach(o=>{if(o.componentIds.length===0)return;const i=o.componentIds.map(h=>({id:h,pos:c.get(h),node:g.nodes.find(y=>y.id===h)})).filter(h=>h.pos&&h.node).sort((h,y)=>h.node.x-y.node.x);for(let h=0;h{const y=c.get(h);y&&(p=Math.min(p,y.x),l=Math.max(l,y.x),f=y.y)}),p!==1/0&&l!==-1/0){const y=a.nodeRadius*4,m=f-y/2,P=c.get(o.nodeId);if(P){const N=(p+l)/2;P.x=N,P.y=m-w/6}t.append("rect").attr("class","wardley-pipeline-box").attr("x",p-15).attr("y",m).attr("width",l-p+30).attr("height",y).attr("fill","none").attr("stroke",d.axisColor).attr("stroke-width",1.5).attr("rx",4).attr("ry",4)}})}const V=v.append("g").attr("class","wardley-links"),_=new Map;g.pipelines.forEach(t=>{_.set(t.nodeId,new Set(t.componentIds))});const Z=g.links.filter(t=>!(!c.has(t.source)||!c.has(t.target)||_.get(t.target)?.has(t.source)));V.selectAll("line").data(Z).enter().append("line").attr("class",t=>`wardley-link${t.dashed?" wardley-link--dashed":""}`).attr("x1",t=>{const s=c.get(t.source),o=c.get(t.target),p=g.nodes.find(y=>y.id===t.source).isPipelineParent?w/Math.sqrt(2):a.nodeRadius,l=o.x-s.x,f=o.y-s.y,h=Math.sqrt(l*l+f*f);return s.x+l/h*p}).attr("y1",t=>{const s=c.get(t.source),o=c.get(t.target),p=g.nodes.find(y=>y.id===t.source).isPipelineParent?w/Math.sqrt(2):a.nodeRadius,l=o.x-s.x,f=o.y-s.y,h=Math.sqrt(l*l+f*f);return s.y+f/h*p}).attr("x2",t=>{const s=c.get(t.source),o=c.get(t.target),p=g.nodes.find(y=>y.id===t.target).isPipelineParent?w/Math.sqrt(2):a.nodeRadius,l=s.x-o.x,f=s.y-o.y,h=Math.sqrt(l*l+f*f);return o.x+l/h*p}).attr("y2",t=>{const s=c.get(t.source),o=c.get(t.target),p=g.nodes.find(y=>y.id===t.target).isPipelineParent?w/Math.sqrt(2):a.nodeRadius,l=s.x-o.x,f=s.y-o.y,h=Math.sqrt(l*l+f*f);return o.y+f/h*p}).attr("stroke",d.linkStroke).attr("stroke-width",1).attr("stroke-dasharray",t=>t.dashed?"6 6":null).attr("marker-end",t=>t.flow==="forward"||t.flow==="bidirectional"?`url(#link-arrow-end-${n})`:null).attr("marker-start",t=>t.flow==="backward"||t.flow==="bidirectional"?`url(#link-arrow-start-${n})`:null),V.selectAll("text").data(Z.filter(t=>t.label)).enter().append("text").attr("class","wardley-link-label").attr("x",t=>{const s=c.get(t.source),o=c.get(t.target),i=(s.x+o.x)/2,p=o.y-s.y,l=o.x-s.x,f=Math.sqrt(l*l+p*p),h=8,y=p/f;return i+y*h}).attr("y",t=>{const s=c.get(t.source),o=c.get(t.target),i=(s.y+o.y)/2,p=o.x-s.x,l=o.y-s.y,f=Math.sqrt(p*p+l*l),h=8,y=-p/f;return i+y*h}).attr("fill",d.axisTextColor).attr("font-size",a.labelFontSize).attr("text-anchor","middle").attr("dominant-baseline","middle").attr("transform",t=>{const s=c.get(t.source),o=c.get(t.target),i=(s.x+o.x)/2,p=(s.y+o.y)/2,l=o.x-s.x,f=o.y-s.y,h=Math.sqrt(l*l+f*f),y=8,m=f/h,P=-l/h,N=i+m*y,O=p+P*y;let X=Math.atan2(f,l)*180/Math.PI;return(X>90||X<-90)&&(X+=180),`rotate(${X} ${N} ${O})`}).text(t=>t.label);const mt=v.append("g").attr("class","wardley-trends"),kt=g.trends.map(t=>{const s=c.get(t.nodeId);if(!s)return null;const o=z(t.targetX),i=L(t.targetY),p=o-s.x,l=i-s.y,f=Math.sqrt(p*p+l*l),h=a.nodeRadius+2,y=f>h?o-p/f*h:o,m=f>h?i-l/f*h:i;return{origin:s,targetX:o,targetY:i,adjustedX2:y,adjustedY2:m}}).filter(t=>t!==null);mt.selectAll("line").data(kt).enter().append("line").attr("class","wardley-trend").attr("x1",t=>t.origin.x).attr("y1",t=>t.origin.y).attr("x2",t=>t.adjustedX2).attr("y2",t=>t.adjustedY2).attr("stroke",d.evolutionStroke).attr("stroke-width",1).attr("stroke-dasharray","4 4").attr("marker-end",`url(#arrow-${n})`);const M=v.append("g").attr("class","wardley-nodes").selectAll("g").data(g.nodes).enter().append("g").attr("class",t=>["wardley-node",t.className?`wardley-node--${t.className}`:""].filter(Boolean).join(" "));M.filter(t=>t.sourceStrategy==="outsource").append("circle").attr("class","wardley-outsource-overlay").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y).attr("r",a.nodeRadius*2).attr("fill","#666").attr("stroke",d.componentStroke).attr("stroke-width",1),M.filter(t=>t.sourceStrategy==="buy").append("circle").attr("class","wardley-buy-overlay").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y).attr("r",a.nodeRadius*2).attr("fill","#ccc").attr("stroke",d.componentStroke).attr("stroke-width",1),M.filter(t=>t.sourceStrategy==="build").append("circle").attr("class","wardley-build-overlay").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y).attr("r",a.nodeRadius*2).attr("fill","#eee").attr("stroke","#000").attr("stroke-width",1);const T=M.filter(t=>t.sourceStrategy==="market");T.append("circle").attr("class","wardley-market-overlay").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y).attr("r",a.nodeRadius*2).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",1),M.filter(t=>!t.isPipelineParent&&t.sourceStrategy!=="market"&&t.className!=="anchor").append("circle").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y).attr("r",a.nodeRadius).attr("fill",d.componentFill).attr("stroke",d.componentStroke).attr("stroke-width",1);const q=a.nodeRadius*.7,$=a.nodeRadius*1.2;if(T.append("line").attr("class","wardley-market-line").attr("x1",t=>c.get(t.id).x).attr("y1",t=>c.get(t.id).y-$).attr("x2",t=>c.get(t.id).x-$*Math.cos(Math.PI/6)).attr("y2",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("stroke",d.componentStroke).attr("stroke-width",1),T.append("line").attr("class","wardley-market-line").attr("x1",t=>c.get(t.id).x-$*Math.cos(Math.PI/6)).attr("y1",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("x2",t=>c.get(t.id).x+$*Math.cos(Math.PI/6)).attr("y2",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("stroke",d.componentStroke).attr("stroke-width",1),T.append("line").attr("class","wardley-market-line").attr("x1",t=>c.get(t.id).x+$*Math.cos(Math.PI/6)).attr("y1",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("x2",t=>c.get(t.id).x).attr("y2",t=>c.get(t.id).y-$).attr("stroke",d.componentStroke).attr("stroke-width",1),T.append("circle").attr("class","wardley-market-dot").attr("cx",t=>c.get(t.id).x).attr("cy",t=>c.get(t.id).y-$).attr("r",q).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",2),T.append("circle").attr("class","wardley-market-dot").attr("cx",t=>c.get(t.id).x-$*Math.cos(Math.PI/6)).attr("cy",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("r",q).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",2),T.append("circle").attr("class","wardley-market-dot").attr("cx",t=>c.get(t.id).x+$*Math.cos(Math.PI/6)).attr("cy",t=>c.get(t.id).y+$*Math.sin(Math.PI/6)).attr("r",q).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",2),M.filter(t=>t.isPipelineParent===!0).append("rect").attr("x",t=>c.get(t.id).x-w/2).attr("y",t=>c.get(t.id).y-w/2).attr("width",w).attr("height",w).attr("fill",d.componentFill).attr("stroke",d.componentStroke).attr("stroke-width",1),M.filter(t=>t.inertia===!0).append("line").attr("class","wardley-inertia").attr("x1",t=>{const s=c.get(t.id);let o=t.isPipelineParent?w/2+15:a.nodeRadius+15;return t.sourceStrategy&&(o+=a.nodeRadius+10),s.x+o}).attr("y1",t=>{const s=c.get(t.id),o=t.isPipelineParent?w:a.nodeRadius*2;return s.y-o/2}).attr("x2",t=>{const s=c.get(t.id);let o=t.isPipelineParent?w/2+15:a.nodeRadius+15;return t.sourceStrategy&&(o+=a.nodeRadius+10),s.x+o}).attr("y2",t=>{const s=c.get(t.id),o=t.isPipelineParent?w:a.nodeRadius*2;return s.y+o/2}).attr("stroke",d.componentStroke).attr("stroke-width",6),M.append("text").attr("x",t=>{const s=c.get(t.id);if(t.className==="anchor")return t.labelOffsetX!==void 0?s.x+t.labelOffsetX:s.x;let o=a.nodeLabelOffset;t.sourceStrategy&&t.labelOffsetX===void 0&&(o+=10);const i=t.labelOffsetX??o;return s.x+i}).attr("y",t=>{const s=c.get(t.id);if(t.className==="anchor")return t.labelOffsetY!==void 0?s.y+t.labelOffsetY:s.y-3;let o=-a.nodeLabelOffset;t.sourceStrategy&&t.labelOffsetY===void 0&&(o-=10);const i=t.labelOffsetY??o;return s.y+i}).attr("class","wardley-node-label").attr("fill",t=>t.className==="evolved"?d.evolutionStroke:t.className==="anchor"?"#000":d.componentLabelColor).attr("font-size",a.labelFontSize).attr("font-weight",t=>t.className==="anchor"?"bold":"normal").attr("text-anchor",t=>t.className==="anchor"?"middle":"start").attr("dominant-baseline",t=>t.className==="anchor"?"middle":"auto").text(t=>t.label),g.annotations.length>0){const t=v.append("g").attr("class","wardley-annotations");if(g.annotations.forEach(s=>{const o=s.coordinates.map(i=>({x:z(i.x),y:L(i.y)}));if(o.length>1)for(let i=0;i{const p=t.append("g").attr("class","wardley-annotation");p.append("circle").attr("cx",i.x).attr("cy",i.y).attr("r",10).attr("fill","white").attr("stroke",d.axisColor).attr("stroke-width",1.5),p.append("text").attr("x",i.x).attr("y",i.y).attr("text-anchor","middle").attr("dominant-baseline","central").attr("font-size",10).attr("fill",d.axisTextColor).attr("font-weight","bold").text(s.number)})}),g.annotationsBox){let s=z(g.annotationsBox.x),o=L(g.annotationsBox.y);const i=10,p=16,l=11,f=t.append("g").attr("class","wardley-annotations-box"),h=[...g.annotations].filter(m=>m.text).sort((m,P)=>m.number-P.number),y=[];if(h.forEach((m,P)=>{const N=f.append("text").attr("x",s+i).attr("y",o+i+(P+1)*p).attr("font-size",l).attr("fill",d.axisTextColor).attr("text-anchor","start").attr("dominant-baseline","middle").text(`${m.number}. ${m.text}`);y.push(N)}),y.length>0){let m=0,P=0;y.forEach(H=>{const W=H.node(),Pt=W.getComputedTextLength();m=Math.max(m,Pt);const Ct=W.getBBox();P=Math.max(P,Ct.height)});const N=m+i*2+105,O=h.length*p+i*2+P/2,X=a.padding,bt=S-a.padding-N,$t=a.padding,vt=b-a.padding-O;s=Math.max(X,Math.min(s,bt)),o=Math.max($t,Math.min(o,vt)),y.forEach((H,W)=>{H.attr("x",s+i).attr("y",o+i+(W+1)*p)}),f.insert("rect","text").attr("x",s).attr("y",o).attr("width",N).attr("height",O).attr("fill","white").attr("stroke",d.axisColor).attr("stroke-width",1.5).attr("rx",4).attr("ry",4)}}}if(g.notes.length>0){const t=v.append("g").attr("class","wardley-notes");g.notes.forEach(s=>{const o=z(s.x),i=L(s.y);t.append("text").attr("x",o).attr("y",i).attr("text-anchor","start").attr("font-size",11).attr("fill",d.axisTextColor).attr("font-weight","bold").text(s.text)})}if(g.accelerators.length>0){const t=v.append("g").attr("class","wardley-accelerators");g.accelerators.forEach(s=>{const o=z(s.x),i=L(s.y),p=60,l=30,f=20,h=` + M ${o} ${i-l/2} + L ${o+p-f} ${i-l/2} + L ${o+p-f} ${i-l/2-8} + L ${o+p} ${i} + L ${o+p-f} ${i+l/2+8} + L ${o+p-f} ${i+l/2} + L ${o} ${i+l/2} + Z + `;t.append("path").attr("d",h).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",1),t.append("text").attr("x",o+p/2).attr("y",i+l/2+15).attr("text-anchor","middle").attr("font-size",10).attr("fill",d.axisTextColor).attr("font-weight","bold").text(s.name)})}if(g.deaccelerators.length>0){const t=v.append("g").attr("class","wardley-deaccelerators");g.deaccelerators.forEach(s=>{const o=z(s.x),i=L(s.y),p=60,l=30,f=20,h=` + M ${o+p} ${i-l/2} + L ${o+f} ${i-l/2} + L ${o+f} ${i-l/2-8} + L ${o} ${i} + L ${o+f} ${i+l/2+8} + L ${o+f} ${i+l/2} + L ${o+p} ${i+l/2} + Z + `;t.append("path").attr("d",h).attr("fill","white").attr("stroke",d.componentStroke).attr("stroke-width",1),t.append("text").attr("x",o+p/2).attr("y",i+l/2+15).attr("text-anchor","middle").attr("font-size",10).attr("fill",d.axisTextColor).attr("font-weight","bold").text(s.name)})}},"draw"),Vt={draw:jt},_t=u(({wardley:e}={})=>{const n=Xt(),r=Et(),x=U(n,r.themeVariables),a=U(x.wardley,e);return` + .wardley-background { + fill: ${a.backgroundColor}; + } + .wardley-axes line, .wardley-axes path { + stroke: ${a.axisColor}; + } + .wardley-axis-label { + fill: ${a.axisTextColor}; + } + .wardley-stage-label { + fill: ${a.axisTextColor}; + } + .wardley-grid line { + stroke: ${a.gridColor}; + } + .wardley-node circle { + fill: ${a.componentFill}; + stroke: ${a.componentStroke}; + } + .wardley-node-label { + fill: ${a.componentLabelColor}; + } + .wardley-link { + stroke: ${a.linkStroke}; + } + .wardley-link--dashed { + stroke-dasharray: 4 4; + } + .wardley-link-label { + fill: ${a.axisTextColor}; + } + .wardley-trend line { + stroke: ${a.evolutionStroke}; + } + .wardley-annotation-line { + stroke: ${a.annotationStroke}; + } + .wardley-annotation circle { + fill: ${a.annotationFill}; + stroke: ${a.annotationStroke}; + } + .wardley-annotation text { + fill: ${a.annotationTextColor}; + } + .wardley-annotations-box rect { + fill: ${a.annotationFill}; + stroke: ${a.annotationStroke}; + } + .wardley-annotations-box text { + fill: ${a.annotationTextColor}; + } + .wardley-pipeline-box { + stroke: ${a.componentStroke}; + } + .wardley-notes text { + fill: ${a.axisTextColor}; + } + `},"styles"),ee={parser:Q,db:Dt,renderer:Vt,styles:_t};export{ee as diagram}; diff --git a/packages/tempo/public/v4/assets/chunks/xychartDiagram-S5SC5T6Z.By1ew1_3.js b/packages/tempo/public/v4/assets/chunks/xychartDiagram-S5SC5T6Z.By1ew1_3.js new file mode 100644 index 00000000..0050b5b2 --- /dev/null +++ b/packages/tempo/public/v4/assets/chunks/xychartDiagram-S5SC5T6Z.By1ew1_3.js @@ -0,0 +1,7 @@ +import{s as ai,g as oi,q as It,p as ri,a as hi,b as li,_ as a,l as zt,G as ci,d as gi,r as ui,A as mt,i as di,D as Bt,E as xi,X as fi,aC as pi,a9 as vt}from"../app.CbekdYod.js";import{i as mi}from"./init.Gi6I4Gst.js";import{o as yi}from"./ordinal.BYWQX77i.js";import{l as Lt}from"./linear.D7HjFZ5V.js";import"./framework.DNL3hc5c.js";import"./theme.BHijFyhG.js";import"./defaultLocale.DX6XiGOO.js";function bi(t,i,e){t=+t,i=+i,e=(n=arguments.length)<2?(i=t,t=0,1):n<3?1:+e;for(var s=-1,n=Math.max(0,Math.ceil((i-t)/e))|0,h=new Array(n);++s"u"&&(P.yylloc={});var lt=P.yylloc;o.push(lt);var si=P.options&&P.options.ranges;typeof $.yy.parseError=="function"?this.parseError=$.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function ni(z){u.length=u.length-2*z,S.length=S.length-z,o.length=o.length-z}a(ni,"popStack");function Dt(){var z;return z=f.pop()||P.lex()||Tt,typeof z!="number"&&(z instanceof Array&&(f=z,z=f.pop()),z=g.symbols_[z]||z),z}a(Dt,"lex");for(var I,U,V,ct,j={},st,Y,Pt,nt;;){if(U=u[u.length-1],this.defaultActions[U]?V=this.defaultActions[U]:((I===null||typeof I>"u")&&(I=Dt()),V=Z[U]&&Z[U][I]),typeof V>"u"||!V.length||!V[0]){var gt="";nt=[];for(st in Z[U])this.terminals_[st]&&st>ii&&nt.push("'"+this.terminals_[st]+"'");P.showPosition?gt="Parse error on line "+(et+1)+`: +`+P.showPosition()+` +Expecting `+nt.join(", ")+", got '"+(this.terminals_[I]||I)+"'":gt="Parse error on line "+(et+1)+": Unexpected "+(I==Tt?"end of input":"'"+(this.terminals_[I]||I)+"'"),this.parseError(gt,{text:P.match,token:this.terminals_[I]||I,line:P.yylineno,loc:lt,expected:nt})}if(V[0]instanceof Array&&V.length>1)throw new Error("Parse Error: multiple actions possible at state: "+U+", token: "+I);switch(V[0]){case 1:u.push(I),S.push(P.yytext),o.push(P.yylloc),u.push(V[1]),I=null,kt=P.yyleng,p=P.yytext,et=P.yylineno,lt=P.yylloc;break;case 2:if(Y=this.productions_[V[1]][1],j.$=S[S.length-Y],j._$={first_line:o[o.length-(Y||1)].first_line,last_line:o[o.length-1].last_line,first_column:o[o.length-(Y||1)].first_column,last_column:o[o.length-1].last_column},si&&(j._$.range=[o[o.length-(Y||1)].range[0],o[o.length-1].range[1]]),ct=this.performAction.apply(j,[p,kt,et,$.yy,V[1],S,o].concat(ei)),typeof ct<"u")return ct;Y&&(u=u.slice(0,-1*Y*2),S=S.slice(0,-1*Y),o=o.slice(0,-1*Y)),u.push(this.productions_[V[1]][0]),S.push(j.$),o.push(j._$),Pt=Z[u[u.length-2]][u[u.length-1]],u.push(Pt);break;case 3:return!0}}return!0},"parse")},K=(function(){var W={EOF:1,parseError:a(function(g,u){if(this.yy.parser)this.yy.parser.parseError(g,u);else throw new Error(g)},"parseError"),setInput:a(function(r,g){return this.yy=g||this.yy||{},this._input=r,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:a(function(){var r=this._input[0];this.yytext+=r,this.yyleng++,this.offset++,this.match+=r,this.matched+=r;var g=r.match(/(?:\r\n?|\n).*/g);return g?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),r},"input"),unput:a(function(r){var g=r.length,u=r.split(/(?:\r\n?|\n)/g);this._input=r+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-g),this.offset-=g;var f=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),u.length-1&&(this.yylineno-=u.length-1);var S=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:u?(u.length===f.length?this.yylloc.first_column:0)+f[f.length-u.length].length-u[0].length:this.yylloc.first_column-g},this.options.ranges&&(this.yylloc.range=[S[0],S[0]+this.yyleng-g]),this.yyleng=this.yytext.length,this},"unput"),more:a(function(){return this._more=!0,this},"more"),reject:a(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true). +`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:a(function(r){this.unput(this.match.slice(r))},"less"),pastInput:a(function(){var r=this.matched.substr(0,this.matched.length-this.match.length);return(r.length>20?"...":"")+r.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:a(function(){var r=this.match;return r.length<20&&(r+=this._input.substr(0,20-r.length)),(r.substr(0,20)+(r.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:a(function(){var r=this.pastInput(),g=new Array(r.length+1).join("-");return r+this.upcomingInput()+` +`+g+"^"},"showPosition"),test_match:a(function(r,g){var u,f,S;if(this.options.backtrack_lexer&&(S={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(S.yylloc.range=this.yylloc.range.slice(0))),f=r[0].match(/(?:\r\n?|\n).*/g),f&&(this.yylineno+=f.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:f?f[f.length-1].length-f[f.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+r[0].length},this.yytext+=r[0],this.match+=r[0],this.matches=r,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(r[0].length),this.matched+=r[0],u=this.performAction.call(this,this.yy,this,g,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),u)return u;if(this._backtrack){for(var o in S)this[o]=S[o];return!1}return!1},"test_match"),next:a(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var r,g,u,f;this._more||(this.yytext="",this.match="");for(var S=this._currentRules(),o=0;og[0].length)){if(g=u,f=o,this.options.backtrack_lexer){if(r=this.test_match(u,S[o]),r!==!1)return r;if(this._backtrack){g=!1;continue}else return!1}else if(!this.options.flex)break}return g?(r=this.test_match(g,S[f]),r!==!1?r:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text. +`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:a(function(){var g=this.next();return g||this.lex()},"lex"),begin:a(function(g){this.conditionStack.push(g)},"begin"),popState:a(function(){var g=this.conditionStack.length-1;return g>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:a(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:a(function(g){return g=this.conditionStack.length-1-Math.abs(g||0),g>=0?this.conditionStack[g]:"INITIAL"},"topState"),pushState:a(function(g){this.begin(g)},"pushState"),stateStackSize:a(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:a(function(g,u,f,S){switch(f){case 0:break;case 1:break;case 2:return this.popState(),36;case 3:return this.popState(),36;case 4:return 36;case 5:break;case 6:return 10;case 7:return this.pushState("acc_title"),19;case 8:return this.popState(),"acc_title_value";case 9:return this.pushState("acc_descr"),21;case 10:return this.popState(),"acc_descr_value";case 11:this.pushState("acc_descr_multiline");break;case 12:this.popState();break;case 13:return"acc_descr_multiline_value";case 14:return 5;case 15:return 5;case 16:return 8;case 17:return this.pushState("axis_data"),"X_AXIS";case 18:return this.pushState("axis_data"),"Y_AXIS";case 19:return this.pushState("axis_band_data"),24;case 20:return 33;case 21:return this.pushState("data"),16;case 22:return this.pushState("data"),18;case 23:return this.pushState("data_inner"),24;case 24:return 29;case 25:return this.popState(),26;case 26:this.popState();break;case 27:this.pushState("string");break;case 28:this.popState();break;case 29:return"STR";case 30:return 24;case 31:return 26;case 32:return 44;case 33:return"COLON";case 34:return 45;case 35:return 28;case 36:return 46;case 37:return 47;case 38:return 49;case 39:return 51;case 40:return 48;case 41:return 42;case 42:return 50;case 43:return 43;case 44:break;case 45:return 37;case 46:return 38}},"anonymous"),rules:[/^(?:%%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:(\r?\n))/i,/^(?:(\r?\n))/i,/^(?:[\n\r]+)/i,/^(?:%%[^\n]*)/i,/^(?:title\b)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:\})/i,/^(?:[^\}]*)/i,/^(?:xychart-beta\b)/i,/^(?:xychart\b)/i,/^(?:(?:vertical|horizontal))/i,/^(?:x-axis\b)/i,/^(?:y-axis\b)/i,/^(?:\[)/i,/^(?:-->)/i,/^(?:line\b)/i,/^(?:bar\b)/i,/^(?:\[)/i,/^(?:[+-]?(?:\d+(?:\.\d+)?|\.\d+))/i,/^(?:\])/i,/^(?:(?:`\) \{ this\.pushState\(md_string\); \}\n\(\?:\(\?!`"\)\.\)\+ \{ return MD_STR; \}\n\(\?:`))/i,/^(?:["])/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:\[)/i,/^(?:\])/i,/^(?:[A-Za-z]+)/i,/^(?::)/i,/^(?:\+)/i,/^(?:,)/i,/^(?:=)/i,/^(?:\*)/i,/^(?:#)/i,/^(?:[\_])/i,/^(?:\.)/i,/^(?:&)/i,/^(?:-)/i,/^(?:[0-9]+)/i,/^(?:\s+)/i,/^(?:;)/i,/^(?:$)/i],conditions:{data_inner:{rules:[0,1,4,5,6,7,9,11,14,15,16,17,18,21,22,24,25,26,27,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],inclusive:!0},data:{rules:[0,1,3,4,5,6,7,9,11,14,15,16,17,18,21,22,23,26,27,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],inclusive:!0},axis_band_data:{rules:[0,1,4,5,6,7,9,11,14,15,16,17,18,21,22,25,26,27,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],inclusive:!0},axis_data:{rules:[0,1,2,4,5,6,7,9,11,14,15,16,17,18,19,20,21,22,24,26,27,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],inclusive:!0},acc_descr_multiline:{rules:[12,13],inclusive:!1},acc_descr:{rules:[10],inclusive:!1},acc_title:{rules:[8],inclusive:!1},title:{rules:[],inclusive:!1},md_string:{rules:[],inclusive:!1},string:{rules:[28,29],inclusive:!1},INITIAL:{rules:[0,1,4,5,6,7,9,11,14,15,16,17,18,21,22,26,27,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],inclusive:!0}}};return W})();T.lexer=K;function q(){this.yy={}}return a(q,"Parser"),q.prototype=T,T.Parser=q,new q})();dt.parser=dt;var wi=dt;function at(t){return t.type==="bar"}a(at,"isBarPlot");function ot(t){return t.type==="band"}a(ot,"isBandAxisData");function Q(t){return t.type==="linear"}a(Q,"isLinearAxisData");var yt=class{constructor(t){this.parentGroup=t}static{a(this,"TextDimensionCalculatorWithFont")}getMaxDimension(t,i){if(!this.parentGroup)return{width:t.reduce((n,h)=>Math.max(h.length,n),0)*i,height:i};const e={width:0,height:0},s=this.parentGroup.append("g").attr("visibility","hidden").attr("font-size",i);for(const n of t){const h=pi(s,1,n),l=h?h.width:n.length*i,d=h?h.height:i;e.width=Math.max(e.width,l),e.height=Math.max(e.height,d)}return s.remove(),e}},Et=.7,Mt=.2,Ot=class{constructor(t,i,e,s){this.axisConfig=t,this.title=i,this.textDimensionCalculator=e,this.axisThemeConfig=s,this.boundingRect={x:0,y:0,width:0,height:0},this.axisPosition="left",this.showTitle=!1,this.showLabel=!1,this.showTick=!1,this.showAxisLine=!1,this.outerPadding=0,this.titleTextHeight=0,this.labelTextHeight=0,this.normalizedLabelRotationInRad=0,this.range=[0,10],this.boundingRect={x:0,y:0,width:0,height:0},this.axisPosition="left",this.normalizedLabelRotationInRad=this.axisConfig.labelRotation>=-90&&this.axisConfig.labelRotation<=90?this.axisConfig.labelRotation*Math.PI/180:0}static{a(this,"BaseAxis")}setRange(t){this.range=t,this.axisPosition==="left"||this.axisPosition==="right"?this.boundingRect.height=t[1]-t[0]:this.boundingRect.width=t[1]-t[0],this.recalculateScale()}getRange(){return[this.range[0]+this.outerPadding,this.range[1]-this.outerPadding]}setAxisPosition(t){this.axisPosition=t,this.setRange(this.range)}getTickDistance(){const t=this.getRange();return Math.abs(t[0]-t[1])/this.getTickValues().length}getAxisOuterPadding(){return this.outerPadding}getLabelDimension(){return this.textDimensionCalculator.getMaxDimension(this.getTickValues().map(t=>t.toString()),this.axisConfig.labelFontSize)}recalculateOuterPaddingToDrawBar(){Et*this.getTickDistance()>this.outerPadding*2&&(this.outerPadding=Math.floor(Et*this.getTickDistance()/2)),this.recalculateScale()}calculateSpaceIfDrawnHorizontally(t){let i=t.height;if(this.axisConfig.showAxisLine&&i>this.axisConfig.axisLineWidth&&(i-=this.axisConfig.axisLineWidth,this.showAxisLine=!0),this.axisConfig.showLabel){const e=this.getLabelDimension(),s=Mt*t.width;this.outerPadding=Math.min(e.width/2,s);let n=e.height;this.axisPosition==="bottom"&&this.normalizedLabelRotationInRad!==0&&(n=Math.max(n,Math.abs(Math.sin(this.normalizedLabelRotationInRad)*e.width)+Math.abs(Math.cos(this.normalizedLabelRotationInRad)*e.height))),n+=this.axisConfig.labelPadding*2,this.labelTextHeight=e.height,n<=i&&(i-=n,this.showLabel=!0)}if(this.axisConfig.showTick&&i>=this.axisConfig.tickLength&&(this.showTick=!0,i-=this.axisConfig.tickLength),this.axisConfig.showTitle&&this.title){const e=this.textDimensionCalculator.getMaxDimension([this.title],this.axisConfig.titleFontSize),s=e.height+this.axisConfig.titlePadding*2;this.titleTextHeight=e.height,s<=i&&(i-=s,this.showTitle=!0)}this.boundingRect.width=t.width,this.boundingRect.height=t.height-i}calculateSpaceIfDrawnVertical(t){let i=t.width;if(this.axisConfig.showAxisLine&&i>this.axisConfig.axisLineWidth&&(i-=this.axisConfig.axisLineWidth,this.showAxisLine=!0),this.axisConfig.showLabel){const e=this.getLabelDimension(),s=Mt*t.height;this.outerPadding=Math.min(e.height/2,s);const n=e.width+this.axisConfig.labelPadding*2;n<=i&&(i-=n,this.showLabel=!0)}if(this.axisConfig.showTick&&i>=this.axisConfig.tickLength&&(this.showTick=!0,i-=this.axisConfig.tickLength),this.axisConfig.showTitle&&this.title){const e=this.textDimensionCalculator.getMaxDimension([this.title],this.axisConfig.titleFontSize),s=e.height+this.axisConfig.titlePadding*2;this.titleTextHeight=e.height,s<=i&&(i-=s,this.showTitle=!0)}this.boundingRect.width=t.width-i,this.boundingRect.height=t.height}calculateSpace(t){return this.axisPosition==="left"||this.axisPosition==="right"?this.calculateSpaceIfDrawnVertical(t):this.calculateSpaceIfDrawnHorizontally(t),this.recalculateScale(),{width:this.boundingRect.width,height:this.boundingRect.height}}setBoundingBoxXY(t){this.boundingRect.x=t.x,this.boundingRect.y=t.y}calculateOffsetByRotation(t){const i=this.normalizedLabelRotationInRad;return i===0?0:Math.sin(i)*this.getLabelDimension()[t]/2}getDrawableElementsForLeftAxis(){const t=[];if(this.showAxisLine){const i=this.boundingRect.x+this.boundingRect.width-this.axisConfig.axisLineWidth/2;t.push({type:"path",groupTexts:["left-axis","axisl-line"],data:[{path:`M ${i},${this.boundingRect.y} L ${i},${this.boundingRect.y+this.boundingRect.height} `,strokeFill:this.axisThemeConfig.axisLineColor,strokeWidth:this.axisConfig.axisLineWidth}]})}if(this.showLabel&&t.push({type:"text",groupTexts:["left-axis","label"],data:this.getTickValues().map(i=>({text:i.toString(),x:this.boundingRect.x+this.boundingRect.width-(this.showLabel?this.axisConfig.labelPadding:0)-(this.showTick?this.axisConfig.tickLength:0)-(this.showAxisLine?this.axisConfig.axisLineWidth:0),y:this.getScaleValue(i),fill:this.axisThemeConfig.labelColor,fontSize:this.axisConfig.labelFontSize,rotation:0,verticalPos:"middle",horizontalPos:"right"}))}),this.showTick){const i=this.boundingRect.x+this.boundingRect.width-(this.showAxisLine?this.axisConfig.axisLineWidth:0);t.push({type:"path",groupTexts:["left-axis","ticks"],data:this.getTickValues().map(e=>({path:`M ${i},${this.getScaleValue(e)} L ${i-this.axisConfig.tickLength},${this.getScaleValue(e)}`,strokeFill:this.axisThemeConfig.tickColor,strokeWidth:this.axisConfig.tickWidth}))})}return this.showTitle&&t.push({type:"text",groupTexts:["left-axis","title"],data:[{text:this.title,x:this.boundingRect.x+this.axisConfig.titlePadding,y:this.boundingRect.y+this.boundingRect.height/2,fill:this.axisThemeConfig.titleColor,fontSize:this.axisConfig.titleFontSize,rotation:270,verticalPos:"top",horizontalPos:"center"}]}),t}getDrawableElementsForBottomAxis(){const t=[];if(this.showAxisLine){const i=this.boundingRect.y+this.axisConfig.axisLineWidth/2;t.push({type:"path",groupTexts:["bottom-axis","axis-line"],data:[{path:`M ${this.boundingRect.x},${i} L ${this.boundingRect.x+this.boundingRect.width},${i}`,strokeFill:this.axisThemeConfig.axisLineColor,strokeWidth:this.axisConfig.axisLineWidth}]})}if(this.showLabel&&t.push({type:"text",groupTexts:["bottom-axis","label"],data:this.getTickValues().map(i=>({text:i.toString(),x:this.getScaleValue(i)+this.calculateOffsetByRotation("height"),y:this.boundingRect.y+this.axisConfig.labelPadding+(this.showTick?this.axisConfig.tickLength:0)+(this.showAxisLine?this.axisConfig.axisLineWidth:0)+Math.abs(this.calculateOffsetByRotation("width")),fill:this.axisThemeConfig.labelColor,fontSize:this.axisConfig.labelFontSize,rotation:this.normalizedLabelRotationInRad*180/Math.PI,verticalPos:"top",horizontalPos:"center"}))}),this.showTick){const i=this.boundingRect.y+(this.showAxisLine?this.axisConfig.axisLineWidth:0);t.push({type:"path",groupTexts:["bottom-axis","ticks"],data:this.getTickValues().map(e=>({path:`M ${this.getScaleValue(e)},${i} L ${this.getScaleValue(e)},${i+this.axisConfig.tickLength}`,strokeFill:this.axisThemeConfig.tickColor,strokeWidth:this.axisConfig.tickWidth}))})}return this.showTitle&&t.push({type:"text",groupTexts:["bottom-axis","title"],data:[{text:this.title,x:this.range[0]+(this.range[1]-this.range[0])/2,y:this.boundingRect.y+this.boundingRect.height-this.axisConfig.titlePadding-this.titleTextHeight,fill:this.axisThemeConfig.titleColor,fontSize:this.axisConfig.titleFontSize,rotation:0,verticalPos:"top",horizontalPos:"center"}]}),t}getDrawableElementsForTopAxis(){const t=[];if(this.showAxisLine){const i=this.boundingRect.y+this.boundingRect.height-this.axisConfig.axisLineWidth/2;t.push({type:"path",groupTexts:["top-axis","axis-line"],data:[{path:`M ${this.boundingRect.x},${i} L ${this.boundingRect.x+this.boundingRect.width},${i}`,strokeFill:this.axisThemeConfig.axisLineColor,strokeWidth:this.axisConfig.axisLineWidth}]})}if(this.showLabel&&t.push({type:"text",groupTexts:["top-axis","label"],data:this.getTickValues().map(i=>({text:i.toString(),x:this.getScaleValue(i),y:this.boundingRect.y+(this.showTitle?this.titleTextHeight+this.axisConfig.titlePadding*2:0)+this.axisConfig.labelPadding,fill:this.axisThemeConfig.labelColor,fontSize:this.axisConfig.labelFontSize,rotation:0,verticalPos:"top",horizontalPos:"center"}))}),this.showTick){const i=this.boundingRect.y;t.push({type:"path",groupTexts:["top-axis","ticks"],data:this.getTickValues().map(e=>({path:`M ${this.getScaleValue(e)},${i+this.boundingRect.height-(this.showAxisLine?this.axisConfig.axisLineWidth:0)} L ${this.getScaleValue(e)},${i+this.boundingRect.height-this.axisConfig.tickLength-(this.showAxisLine?this.axisConfig.axisLineWidth:0)}`,strokeFill:this.axisThemeConfig.tickColor,strokeWidth:this.axisConfig.tickWidth}))})}return this.showTitle&&t.push({type:"text",groupTexts:["top-axis","title"],data:[{text:this.title,x:this.boundingRect.x+this.boundingRect.width/2,y:this.boundingRect.y+this.axisConfig.titlePadding,fill:this.axisThemeConfig.titleColor,fontSize:this.axisConfig.titleFontSize,rotation:0,verticalPos:"top",horizontalPos:"center"}]}),t}getDrawableElements(){if(this.axisPosition==="left")return this.getDrawableElementsForLeftAxis();if(this.axisPosition==="right")throw Error("Drawing of right axis is not implemented");return this.axisPosition==="bottom"?this.getDrawableElementsForBottomAxis():this.axisPosition==="top"?this.getDrawableElementsForTopAxis():[]}},Ai=class extends Ot{static{a(this,"BandAxis")}constructor(t,i,e,s,n){super(t,s,n,i),this.categories=e,this.scale=ut().domain(this.categories).range(this.getRange())}setRange(t){super.setRange(t)}recalculateScale(){this.scale=ut().domain(this.categories).range(this.getRange()).paddingInner(1).paddingOuter(0).align(.5),zt.trace("BandAxis axis final categories, range: ",this.categories,this.getRange())}getTickValues(){return this.categories}getScaleValue(t){return this.scale(t)??this.getRange()[0]}},Ci=class extends Ot{static{a(this,"LinearAxis")}constructor(t,i,e,s,n){super(t,s,n,i),this.domain=e,this.scale=Lt().domain(this.domain).range(this.getRange())}getTickValues(){return this.scale.ticks()}recalculateScale(){const t=[...this.domain];this.axisPosition==="left"&&t.reverse(),this.scale=Lt().domain(t).range(this.getRange())}getScaleValue(t){return this.scale(t)}};function xt(t,i,e,s){const n=new yt(s);return ot(t)?new Ai(i,e,t.categories,t.title,n):new Ci(i,e,[t.min,t.max],t.title,n)}a(xt,"getAxis");var Si=class{constructor(t,i,e,s){this.textDimensionCalculator=t,this.chartConfig=i,this.chartData=e,this.chartThemeConfig=s,this.boundingRect={x:0,y:0,width:0,height:0},this.showChartTitle=!1}static{a(this,"ChartTitle")}setBoundingBoxXY(t){this.boundingRect.x=t.x,this.boundingRect.y=t.y}calculateSpace(t){const i=this.textDimensionCalculator.getMaxDimension([this.chartData.title],this.chartConfig.titleFontSize),e=Math.max(i.width,t.width),s=i.height+2*this.chartConfig.titlePadding;return i.width<=e&&i.height<=s&&this.chartConfig.showTitle&&this.chartData.title&&(this.boundingRect.width=e,this.boundingRect.height=s,this.showChartTitle=!0),{width:this.boundingRect.width,height:this.boundingRect.height}}getDrawableElements(){const t=[];return this.showChartTitle&&t.push({groupTexts:["chart-title"],type:"text",data:[{fontSize:this.chartConfig.titleFontSize,text:this.chartData.title,verticalPos:"middle",horizontalPos:"center",x:this.boundingRect.x+this.boundingRect.width/2,y:this.boundingRect.y+this.boundingRect.height/2,fill:this.chartThemeConfig.titleColor,rotation:0}]}),t}};function Vt(t,i,e,s){const n=new yt(s);return new Si(n,t,i,e)}a(Vt,"getChartTitleComponent");var Ri=.75,_i=.5,ki=.35;function ft(t){return{fontSize:t,markerSize:t*Ri,markerSpacing:t*ki,itemSpacing:t*_i}}a(ft,"getLegendLayout");var Ti=class{constructor(t,i,e,s){this.textDimensionCalculator=t,this.chartConfig=i,this.chartData=e,this.chartThemeConfig=s,this.boundingRect={x:0,y:0,width:0,height:0},this.visiblePlots=[]}static{a(this,"ChartLegend")}setBoundingBoxXY(t){this.boundingRect.x=t.x,this.boundingRect.y=t.y}calculateSpace(t){if(this.visiblePlots=this.chartConfig.showLegend?this.chartData.plots.filter(x=>x.title):[],this.visiblePlots.length===0)return this.boundingRect.width=0,this.boundingRect.height=0,{width:0,height:0};const{fontSize:i,markerSize:e,markerSpacing:s,itemSpacing:n}=ft(this.chartConfig.legendFontSize),h=this.textDimensionCalculator.getMaxDimension(this.visiblePlots.map(x=>x.title),i),l=this.chartConfig.legendPadding*2+e+s+h.width,d=this.chartConfig.legendPadding*2+this.visiblePlots.length*i+(this.visiblePlots.length-1)*n;return l<=t.width&&d<=t.height?(this.boundingRect.width=l,this.boundingRect.height=d):(this.visiblePlots=[],this.boundingRect.width=0,this.boundingRect.height=0),{width:this.boundingRect.width,height:this.boundingRect.height}}getDrawableElements(){if(this.visiblePlots.length===0)return[];const{fontSize:t,markerSize:i,markerSpacing:e,itemSpacing:s}=ft(this.chartConfig.legendFontSize),n=t+s,h=this.boundingRect.x+this.chartConfig.legendPadding,l=this.boundingRect.y+this.chartConfig.legendPadding,d=[],x=[];for(const[C,k]of this.visiblePlots.entries())if(at(k))d.push({x:h,y:l+C*n,width:i,height:i,fill:k.fill,strokeFill:k.fill,strokeWidth:0});else{const R=l+C*n+i/2;x.push({path:`M ${h},${R} L ${h+i},${R}`,strokeFill:k.strokeFill,strokeWidth:k.strokeWidth})}return[{groupTexts:["legend","markers"],type:"rect",data:d},{groupTexts:["legend","markers"],type:"path",data:x},{groupTexts:["legend","label"],type:"text",data:this.visiblePlots.map((C,k)=>({text:C.title,x:h+i+e,y:l+k*n+i/2,fill:this.chartThemeConfig.legendTextColor,fontSize:t,rotation:0,verticalPos:"middle",horizontalPos:"left"}))}]}};function Ft(t,i,e,s){const n=new yt(s);return new Ti(n,t,i,e)}a(Ft,"getChartLegendComponent");var Di=class{constructor(t,i,e,s,n){this.plotData=t,this.xAxis=i,this.yAxis=e,this.orientation=s,this.plotIndex=n}static{a(this,"LinePlot")}getDrawableElement(){const t=this.plotData.data.map(s=>[this.xAxis.getScaleValue(s[0]),this.yAxis.getScaleValue(s[1])]);let i;if(this.orientation==="horizontal"?i=vt().y(s=>s[0]).x(s=>s[1])(t):i=vt().x(s=>s[0]).y(s=>s[1])(t),!i)return[];const e=[{groupTexts:["plot",`line-plot-${this.plotIndex}`],type:"path",data:[{path:i,strokeFill:this.plotData.strokeFill,strokeWidth:this.plotData.strokeWidth}]}];if(this.plotData.pointLabels&&this.plotData.pointLabels.length>0){const h=[];for(const[l,[d,x]]of t.entries()){const C=this.plotData.pointLabels[l];C&&(this.orientation==="horizontal"?h.push({x:x+10,y:d,text:C,fill:this.plotData.strokeFill,verticalPos:"middle",horizontalPos:"left",fontSize:12,rotation:0}):h.push({x:d,y:x-10,text:C,fill:this.plotData.strokeFill,verticalPos:"middle",horizontalPos:"center",fontSize:12,rotation:0}))}h.length>0&&e.push({groupTexts:["plot",`line-plot-${this.plotIndex}`,"labels"],type:"text",data:h})}return e}},Pi=class{constructor(t,i,e,s,n,h){this.barData=t,this.boundingRect=i,this.xAxis=e,this.yAxis=s,this.orientation=n,this.plotIndex=h}static{a(this,"BarPlot")}getDrawableElement(){const t=this.barData.data.map(n=>[this.xAxis.getScaleValue(n[0]),this.yAxis.getScaleValue(n[1])]),e=Math.min(this.xAxis.getAxisOuterPadding()*2,this.xAxis.getTickDistance())*(1-.05),s=e/2;return this.orientation==="horizontal"?[{groupTexts:["plot",`bar-plot-${this.plotIndex}`],type:"rect",data:t.map(n=>({x:this.boundingRect.x,y:n[0]-s,height:e,width:n[1]-this.boundingRect.x,fill:this.barData.fill,strokeWidth:0,strokeFill:this.barData.fill}))}]:[{groupTexts:["plot",`bar-plot-${this.plotIndex}`],type:"rect",data:t.map(n=>({x:n[0]-s,y:n[1],width:e,height:this.boundingRect.y+this.boundingRect.height-n[1],fill:this.barData.fill,strokeWidth:0,strokeFill:this.barData.fill}))}]}},vi=class{constructor(t,i,e){this.chartConfig=t,this.chartData=i,this.chartThemeConfig=e,this.boundingRect={x:0,y:0,width:0,height:0}}static{a(this,"BasePlot")}setAxes(t,i){this.xAxis=t,this.yAxis=i}setBoundingBoxXY(t){this.boundingRect.x=t.x,this.boundingRect.y=t.y}calculateSpace(t){return this.boundingRect.width=t.width,this.boundingRect.height=t.height,{width:this.boundingRect.width,height:this.boundingRect.height}}getDrawableElements(){if(!(this.xAxis&&this.yAxis))throw Error("Axes must be passed to render Plots");const t=[];for(const[i,e]of this.chartData.plots.entries())switch(e.type){case"line":{const s=new Di(e,this.xAxis,this.yAxis,this.chartConfig.chartOrientation,i);t.push(...s.getDrawableElement())}break;case"bar":{const s=new Pi(e,this.boundingRect,this.xAxis,this.yAxis,this.chartConfig.chartOrientation,i);t.push(...s.getDrawableElement())}break}return t}};function Wt(t,i,e){return new vi(t,i,e)}a(Wt,"getPlotComponent");var Li=class{constructor(t,i,e,s){this.chartConfig=t,this.chartData=i,this.componentStore={title:Vt(t,i,e,s),plot:Wt(t,i,e),legend:Ft(t,i,e,s),xAxis:xt(i.xAxis,t.xAxis,{titleColor:e.xAxisTitleColor,labelColor:e.xAxisLabelColor,tickColor:e.xAxisTickColor,axisLineColor:e.xAxisLineColor},s),yAxis:xt(i.yAxis,t.yAxis,{titleColor:e.yAxisTitleColor,labelColor:e.yAxisLabelColor,tickColor:e.yAxisTickColor,axisLineColor:e.yAxisLineColor},s)}}static{a(this,"Orchestrator")}calculateVerticalSpace(){let t=this.chartConfig.width,i=this.chartConfig.height,e=0,s=0,n={width:0,height:0},h=Math.floor(t*this.chartConfig.plotReservedSpacePercent/100),l=Math.floor(i*this.chartConfig.plotReservedSpacePercent/100),d=this.componentStore.plot.calculateSpace({width:h,height:l});t-=d.width,i-=d.height,d=this.componentStore.title.calculateSpace({width:this.chartConfig.width,height:i}),s=d.height,i-=d.height,this.componentStore.xAxis.setAxisPosition("bottom"),d=this.componentStore.xAxis.calculateSpace({width:t,height:i}),i-=d.height,this.componentStore.yAxis.setAxisPosition("left"),d=this.componentStore.yAxis.calculateSpace({width:t,height:i}),e=d.width,t-=d.width,n=this.componentStore.legend.calculateSpace({width:t,height:l}),t-=n.width,t>0&&(h+=t,t=0),i>0&&(l+=i,i=0),this.componentStore.plot.calculateSpace({width:h,height:l}),this.componentStore.plot.setBoundingBoxXY({x:e,y:s}),this.componentStore.legend.setBoundingBoxXY({x:e+h,y:s+Math.max((l-n.height)/2,0)}),this.componentStore.xAxis.setRange([e,e+h]),this.componentStore.xAxis.setBoundingBoxXY({x:e,y:s+l}),this.componentStore.yAxis.setRange([s,s+l]),this.componentStore.yAxis.setBoundingBoxXY({x:0,y:s}),this.chartData.plots.some(x=>at(x))&&this.componentStore.xAxis.recalculateOuterPaddingToDrawBar()}calculateHorizontalSpace(){let t=this.chartConfig.width,i=this.chartConfig.height,e=0,s=0,n=0,h={width:0,height:0},l=Math.floor(t*this.chartConfig.plotReservedSpacePercent/100),d=Math.floor(i*this.chartConfig.plotReservedSpacePercent/100),x=this.componentStore.plot.calculateSpace({width:l,height:d});t-=x.width,i-=x.height,x=this.componentStore.title.calculateSpace({width:this.chartConfig.width,height:i}),e=x.height,i-=x.height,this.componentStore.xAxis.setAxisPosition("left"),x=this.componentStore.xAxis.calculateSpace({width:t,height:i}),t-=x.width,s=x.width,this.componentStore.yAxis.setAxisPosition("top"),x=this.componentStore.yAxis.calculateSpace({width:t,height:i}),i-=x.height,n=e+x.height,h=this.componentStore.legend.calculateSpace({width:t,height:d}),t-=h.width,t>0&&(l+=t,t=0),i>0&&(d+=i,i=0),this.componentStore.plot.calculateSpace({width:l,height:d}),this.componentStore.plot.setBoundingBoxXY({x:s,y:n}),this.componentStore.legend.setBoundingBoxXY({x:s+l,y:n+Math.max((d-h.height)/2,0)}),this.componentStore.yAxis.setRange([s,s+l]),this.componentStore.yAxis.setBoundingBoxXY({x:s,y:e}),this.componentStore.xAxis.setRange([n,n+d]),this.componentStore.xAxis.setBoundingBoxXY({x:0,y:n}),this.chartData.plots.some(C=>at(C))&&this.componentStore.xAxis.recalculateOuterPaddingToDrawBar()}calculateSpace(){this.chartConfig.chartOrientation==="horizontal"?this.calculateHorizontalSpace():this.calculateVerticalSpace()}getDrawableElement(){this.calculateSpace();const t=[];this.componentStore.plot.setAxes(this.componentStore.xAxis,this.componentStore.yAxis);for(const i of Object.values(this.componentStore))t.push(...i.getDrawableElements());return t}},Ei=class{static{a(this,"XYChartBuilder")}static build(t,i,e,s){return new Li(t,i,e,s).getDrawableElement()}},J=0,Xt,tt=At(),it=wt(),y=Ct(),pt=it.plotColorPalette.split(",").map(t=>t.trim()),rt=!1,bt=!1;function wt(){const t=fi(),i=mt();return Bt(t.xyChart,i.themeVariables.xyChart)}a(wt,"getChartDefaultThemeConfig");function At(){const t=mt();return Bt(xi.xyChart,t.xyChart)}a(At,"getChartDefaultConfig");function Ct(){return{yAxis:{type:"linear",title:"",min:1/0,max:-1/0},xAxis:{type:"band",title:"",categories:[]},title:"",plots:[]}}a(Ct,"getChartDefaultData");function G(t){const i=mt();return di(t.trim(),i)}a(G,"textSanitizer");function Nt(t){Xt=t}a(Nt,"setTmpSVGG");function Yt(t){t==="horizontal"?tt.chartOrientation="horizontal":tt.chartOrientation="vertical"}a(Yt,"setOrientation");function Ht(t){y.xAxis.title=G(t.text)}a(Ht,"setXAxisTitle");function St(t,i){y.xAxis={type:"linear",title:y.xAxis.title,min:t,max:i},rt=!0}a(St,"setXAxisRangeData");function $t(t){y.xAxis={type:"band",title:y.xAxis.title,categories:t.map(i=>G(i.text))},rt=!0}a($t,"setXAxisBand");function Ut(t){y.yAxis.title=G(t.text)}a(Ut,"setYAxisTitle");function Gt(t,i){y.yAxis={type:"linear",title:y.yAxis.title,min:t,max:i},bt=!0}a(Gt,"setYAxisRangeData");function qt(t){const i=Math.min(...t),e=Math.max(...t),s=Q(y.yAxis)?y.yAxis.min:1/0,n=Q(y.yAxis)?y.yAxis.max:-1/0;y.yAxis={type:"linear",title:y.yAxis.title,min:Math.min(s,i),max:Math.max(n,e)}}a(qt,"setYAxisRangeFromPlotData");function Rt(t){let i=[];if(t.length===0)return i;if(!rt){const e=Q(y.xAxis)?y.xAxis.min:1/0,s=Q(y.xAxis)?y.xAxis.max:-1/0;St(Math.min(e,1),Math.max(s,t.length))}if(ot(y.xAxis)&&t.length>y.xAxis.categories.length&&(t=t.slice(0,y.xAxis.categories.length)),bt||qt(t),ot(y.xAxis)&&(i=y.xAxis.categories.map((e,s)=>[e,t[s]])),Q(y.xAxis)){const e=y.xAxis.min,s=y.xAxis.max;if(t.length===1)i=[[`${e}`,t[0]]];else{const n=(s-e)/(t.length-1);i=t.map((h,l)=>[`${e+l*n}`,h])}}return i}a(Rt,"transformDataWithoutCategory");function _t(t){return pt[t===0?0:t%pt.length]}a(_t,"getPlotColorFromPalette");function jt(t,i){const e=i.map(l=>l.value),s=i.map(l=>l.label?G(l.label):""),n=Rt(e),h=s.some(l=>l!=="");y.plots.push({type:"line",title:G(t.text),strokeFill:_t(J),strokeWidth:2,data:n,...h?{pointLabels:s}:{}}),J++}a(jt,"setLineData");function Qt(t,i){const e=i.map(n=>n.value),s=Rt(e);y.plots.push({type:"bar",title:G(t.text),fill:_t(J),data:s}),J++}a(Qt,"setBarData");function Kt(){if(y.plots.length===0)throw Error("No Plot to render, please provide a plot with some data");return y.title=It(),Ei.build(tt,y,it,Xt)}a(Kt,"getDrawableElem");function Zt(){return it}a(Zt,"getChartThemeConfig");function Jt(){return tt}a(Jt,"getChartConfig");function ti(){return y}a(ti,"getXYChartData");var Mi=a(function(){ui(),J=0,tt=At(),y=Ct(),it=wt(),pt=it.plotColorPalette.split(",").map(t=>t.trim()),rt=!1,bt=!1},"clear"),Ii={getDrawableElem:Kt,clear:Mi,setAccTitle:li,getAccTitle:hi,setDiagramTitle:ri,getDiagramTitle:It,getAccDescription:oi,setAccDescription:ai,setOrientation:Yt,setXAxisTitle:Ht,setXAxisRangeData:St,setXAxisBand:$t,setYAxisTitle:Ut,setYAxisRangeData:Gt,setLineData:jt,setBarData:Qt,setTmpSVGG:Nt,getChartThemeConfig:Zt,getChartConfig:Jt,getXYChartData:ti},zi=a((t,i,e,s)=>{const n=s.db,h=n.getChartThemeConfig(),l=n.getChartConfig(),d=n.getXYChartData().plots[0].data.map(m=>m[1]);function x(m){return m==="top"?"text-before-edge":"middle"}a(x,"getDominantBaseLine");function C(m){return m==="left"?"start":m==="right"?"end":"middle"}a(C,"getTextAnchor");function k(m){return`translate(${m.x}, ${m.y}) rotate(${m.rotation||0})`}a(k,"getTextTransformation"),zt.debug(`Rendering xychart chart +`+t);const R=ci(i),b=R.append("g").attr("class","main"),E=b.append("rect").attr("width",l.width).attr("height",l.height).attr("class","background");gi(R,l.height,l.width,!0),R.attr("viewBox",`0 0 ${l.width} ${l.height}`),E.attr("fill",h.backgroundColor),n.setTmpSVGG(R.append("g").attr("class","mermaid-tmp-group"));const v=n.getDrawableElem(),L={};function M(m){let D=b,c="";for(const[B]of m.entries()){let F=b;B>0&&L[c]&&(F=L[c]),c+=m[B],D=L[c],D||(D=L[c]=F.append("g").attr("class",m[B]))}return D}a(M,"getGroup");for(const m of v){if(m.data.length===0)continue;const D=M(m.groupTexts);switch(m.type){case"rect":if(D.selectAll("rect").data(m.data).enter().append("rect").attr("x",c=>c.x).attr("y",c=>c.y).attr("width",c=>c.width).attr("height",c=>c.height).attr("fill",c=>c.fill).attr("stroke",c=>c.strokeFill).attr("stroke-width",c=>c.strokeWidth),l.showDataLabel){const c=l.showDataLabelOutsideBar;if(l.chartOrientation==="horizontal"){let B=function(A,O){const{data:T,label:K}=A;return O*K.length*F<=T.width-X};a(B,"fitsHorizontally");const F=.7,X=10,N=m.data.map((A,O)=>({data:A,label:d[O].toString()})).filter(A=>A.data.width>0&&A.data.height>0),_=N.map(A=>{const{data:O}=A;let T=O.height*.7;for(;!B(A,T)&&T>0;)T-=1;return T}),H=Math.floor(Math.min(..._)),w=a(A=>c?A.data.x+A.data.width+X:A.data.x+A.data.width-X,"determineLabelXPosition");D.selectAll("text").data(N).enter().append("text").attr("x",w).attr("y",A=>A.data.y+A.data.height/2).attr("text-anchor",c?"start":"end").attr("dominant-baseline","middle").attr("fill",h.dataLabelColor).attr("font-size",`${H}px`).text(A=>A.label)}else{let B=function(w,A,O){const{data:T,label:K}=w,W=A*K.length*.7,r=T.x+T.width/2,g=r-W/2,u=r+W/2,f=g>=T.x&&u<=T.x+T.width,S=T.y+O+A<=T.y+T.height;return f&&S};a(B,"fitsInBar");const F=10,X=m.data.map((w,A)=>({data:w,label:d[A].toString()})).filter(w=>w.data.width>0&&w.data.height>0),N=X.map(w=>{const{data:A,label:O}=w;let T=A.width/(O.length*.7);for(;!B(w,T,F)&&T>0;)T-=1;return T}),_=Math.floor(Math.min(...N)),H=a(w=>c?w.data.y-F:w.data.y+F,"determineLabelYPosition");D.selectAll("text").data(X).enter().append("text").attr("x",w=>w.data.x+w.data.width/2).attr("y",H).attr("text-anchor","middle").attr("dominant-baseline",c?"auto":"hanging").attr("fill",h.dataLabelColor).attr("font-size",`${_}px`).text(w=>w.label)}}break;case"text":D.selectAll("text").data(m.data).enter().append("text").attr("x",0).attr("y",0).attr("fill",c=>c.fill).attr("font-size",c=>c.fontSize).attr("dominant-baseline",c=>x(c.verticalPos)).attr("text-anchor",c=>C(c.horizontalPos)).attr("transform",c=>k(c)).text(c=>c.text);break;case"path":D.selectAll("path").data(m.data).enter().append("path").attr("d",c=>c.path).attr("fill",c=>c.fill?c.fill:"none").attr("stroke",c=>c.strokeFill).attr("stroke-width",c=>c.strokeWidth);break}}},"draw"),Bi={draw:zi},Hi={parser:wi,db:Ii,renderer:Bi};export{Hi as diagram}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.js b/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.js new file mode 100644 index 00000000..14786720 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.js @@ -0,0 +1 @@ +import{_ as t,o as a,c as i,a2 as e}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"🤖 AI & IDE Integration (llms.txt)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/ai-integration.md","filePath":"doc/1-getting-started/ai-integration.md"}'),n={name:"doc/1-getting-started/ai-integration.md"};function o(l,s,r,p,h,d){return a(),i("div",null,[...s[0]||(s[0]=[e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure modern AI coding assistants—such as Cursor, VS Code (GitHub Copilot), Antigravity, ChatGPT, and Claude—generate accurate, idiomatically aligned Tempo code and minimize hallucinations, Tempo publishes an official, standardized llms.txt rulebook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By providing these rules to your AI assistant, your IDE will respect Tempo's strict immutability, zero-cost getters, native Temporal runtime expectations, and layout token syntax out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Quick Setup by IDE / Tool ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cursor IDE ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add Tempo to Cursor's native documentation index:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Open Cursor Settings (Cmd + , or Ctrl + ,).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Navigate to Features ➔ Docs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Click + Add new doc and enter:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Name: Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • URL: https://tempo.magmacomputing.com.au/llms.txt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once added, type @Tempo in any Cursor chat or prompt window to inject exact API syntax rules into your conversation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. VS Code & GitHub Copilot ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In VS Code, configure GitHub Copilot Chat by adding a .github/copilot-instructions.md file to the root of your workspace:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # Tempo AI Rules\n- Always use `Tempo` from `@magmacomputing/tempo`.\n- Never instantiate legacy JavaScript `Date`. Tempo expects native `Temporal` or polyfill.\n- All mutating methods (`.add()`, `.subtract()`, `.set()`) return a brand-new, frozen `Tempo` instance.\n- Refer to https://tempo.magmacomputing.com.au/llms.txt for full layout token grammar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When prompting Copilot Chat in VS Code:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Using https://tempo.magmacomputing.com.au/llms.txt, write a custom layout parser..."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Antigravity AI Assistant ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Antigravity, you can reference the live endpoint directly in your chat prompt or store it as a localized Knowledge Item (KI):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reference @https://tempo.magmacomputing.com.au/llms.txt in your prompt for instant context ingestion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. ChatGPT & Claude Projects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For web-based LLM interfaces, reference or copy-paste the full, un-truncated documentation context file: 👉 Full RAG Documentation Bundle (llms-full.txt)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Prompting AI for Custom Layout Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When asking AI assistants to generate custom layout patterns for non-standard date-time formats, instruct the model to use Tempo's configuration syntax (Tempo.init({ registry: { layouts: { ... } } })) and layout tokens ({yy}, {mm}, {dd}, {hh}, {mi}, {ss}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sample Prompt: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Using the rules from https://tempo.magmacomputing.com.au/llms.txt, register a custom Tempo layout for star-delimited dates (e.g., '08042026') using Tempo.init({ registry: { layouts: { ... } } }) and parse the date string using new Tempo(...)."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generated Code (Actual Tempo Syntax): ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';\n\n// 1. Register custom layout pattern using layout tokens\nTempo.init({\n  registry: {\n    layouts: {\n      star_date: '{mm}\\\\*{dd}\\\\*{yy}'\n    }\n  }\n});\n\n// 2. Parse date string matching the custom layout\nconst date = new Tempo('08*04*2026');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',29)])])}const g=t(n,[["render",o]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.lean.js b/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.lean.js new file mode 100644 index 00000000..3e3ecc1e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_ai-integration.md.BZMrNeW6.lean.js @@ -0,0 +1 @@ +import{_ as t,o as a,c as i,a2 as e}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"🤖 AI & IDE Integration (llms.txt)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/ai-integration.md","filePath":"doc/1-getting-started/ai-integration.md"}'),n={name:"doc/1-getting-started/ai-integration.md"};function o(l,s,r,p,h,d){return a(),i("div",null,[...s[0]||(s[0]=[e("",29)])])}const g=t(n,[["render",o]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.js b/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.js new file mode 100644 index 00000000..5644c11f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.js @@ -0,0 +1,82 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Installation Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/installation.md","filePath":"doc/1-getting-started/installation.md"}'),e={name:"doc/1-getting-started/installation.md"};function l(p,s,h,o,r,k){return a(),t("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed to be environment-agnostic. Whether you are building a server-side application, a modern browser project with ESM, or a performance-critical "Lite" bundle, Tempo provides a specific path for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal Polyfill Note ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo expects the host environment to provide Temporal, either through native runtime support or a user-supplied polyfill.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal has reached Stage 4 of the TC39 standards process (the committee that evolves JavaScript) and is shipping natively in modern environments (Deno 2.7+, Node.js 26+, Chrome 144+, Firefox 139+). Note that Safari/iOS currently do not support Temporal natively and require a polyfill. You can verify current browser support at caniuse.com/temporal. To avoid needlessly inflating package sizes for modern apps, Tempo does not bundle a Temporal polyfill by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js environments that ship Temporal behind a feature flag (--harmony-temporal) may have incomplete implementations. For stability, we strongly recommend using @js-temporal/polyfill instead of the native flag until you upgrade to an official unflagged release.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can check at runtime with a simple guard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    js
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (typeof globalThis.Temporal === 'undefined') {
+  // Load your Temporal polyfill for this environment
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: The examples below include a polyfill for demonstration purposes only, so the snippets work consistently across environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💻 Server & Bundlers (Node.js, Bun, Vite) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For most modern projects using a package manager, install Tempo via the npm registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo   # npm
+yarn add @magmacomputing/tempo      # yarn
+pnpm add @magmacomputing/tempo      # pnpm
+bun add @magmacomputing/tempo       # bun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+const t = new Tempo('next Friday');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js (with Native Temporal) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native unflagged Temporal support is available in Node.js 26+ and is enabled by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node my-app.js

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js (with Polyfill) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The polyfill import shown here is conditional guidance, not required for all environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @js-temporal/polyfill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@js-temporal/polyfill';
+import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('next Friday');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🦕 Deno ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a native ESM package and works perfectly with Deno. You can add it via the deno add command which will resolve it from the npm registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of Deno 2.7, the Temporal API is fully stabilized and enabled by default. You no longer need to pass the --unstable-temporal flag to use it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deno add npm:@magmacomputing/tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from "@magmacomputing/tempo";
+const t = new Tempo();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Browser & Native Environments ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides multiple native browser distribution formats. Here is the quick breakdown of which approach to use:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standard Usage (No plugins): Use the Native ESM Bundle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugins without a bundler: Use Smart CDNs (Easiest setup) OR Static CDNs (Best production performance).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugins with a bundler (Vite/Webpack): Do nothing. Your bundler handles the resolution automatically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Non-ESM Environments: Use the UMD Global Variable approach.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Global Bundle (Standard Usage) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The easiest way to use Tempo natively in the browser is via the pre-optimized ESM bundle. It includes the entire core engine in a single file, eliminating network waterfall effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.esm.js"
+  }
+}
+</script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="module">
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  
+  const t = new Tempo('tomorrow');
+  console.log(t.format('{mon} {dd:ord}'));
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Smart CDNs (The "Best-of-Both-Worlds") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want the absolute easiest setup for Tempo Plugins natively in the browser, use an on-the-fly bundling CDN like esm.sh. Smart CDNs act like a Node environment—they read the package resolution rules and resolve nested dependencies automatically, meaning you don't have to map any internal subpaths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While you could import directly from the URL everywhere, the best practice is to use a tiny import map for your top-level packages to keep your application code clean:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <!-- 1. A tiny import map for your clean shortcuts -->
+<script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://esm.sh/@js-temporal/polyfill@0.5.1",
+    "@magmacomputing/tempo": "https://esm.sh/@magmacomputing/tempo@4",
+    "@magmacomputing/tempo-plugin-ticker": "https://esm.sh/@magmacomputing/tempo-plugin-ticker@2"
+  }
+}
+</script>
+
+<!-- 2. Your Application Code -->
+<script type="module">
+  // You can use standard bare specifiers thanks to the tiny import map above.
+  // esm.sh handles all the complex internal plugin routing behind the scenes!
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+  Tempo.init({ 
+    plugins: [TickerPlugin] 
+  });
+</script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Trade-offs of using Smart CDNs in Production

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While esm.sh is fantastic for prototyping and reducing import map complexity, there are architectural trade-offs to consider before using it in a mission-critical production environment:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Network Waterfalls: The browser must fetch the module, parse it, and then fetch its nested dependencies sequentially. This can slow down page load times compared to a fully bundled application.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Uptime Dependency: You are introducing a critical third-party dependency into your runtime. If the CDN experiences routing issues, your application could break for end-users.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Sub-dependency Version Floating: esm.sh automatically resolves sub-dependencies based on semver constraints. If a sub-dependency introduces an accidental breaking change, it could affect your app.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Suboptimal Tree Shaking: The browser will download the entire module graph for that package; you cannot easily tree-shake unused exports as you can with a dedicated bundler like Vite or Webpack.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Environment Parity: Handling development versus production environments (like process.env.NODE_ENV) requires query parameters (e.g., ?dev), which complicates deployment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Static CDNs (Production-Ready) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For production environments where uptime and load speeds are critical, you should use a static file CDN (like jsdelivr). Because static CDNs serve raw files without compiling them on the fly, they are significantly faster and more reliable than Smart CDNs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To use Tempo Plugins via a static CDN, you simply need to explicitly map the unified plugin/sdk subpath so the browser knows how to resolve the internal connections:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.index.js",
+    "@magmacomputing/tempo/plugin/sdk": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/plugin/plugin.sdk.js",
+
+    "@magmacomputing/tempo-plugin-celestial": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-celestial@1/dist/index.js",
+    "@magmacomputing/tempo-plugin-ticker": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-ticker@2/dist/index.js"
+  }
+}
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Busting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The jsdelivr CDN aggressively caches major version tags (like @4). When relying on precise module resolution for plugins, it is highly recommended to use explicit patch versions (like @4.0.0) to avoid fetching mismatched or outdated sub-modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Browser (Global Variable / Plugins) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you aren't using ESM or just want a simple <script> tag for rapid prototyping, use our unified Magma global bundles. This clean approach ensures all plugins share a single, collision-free namespace on the window object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <!-- 1. Load the Temporal Polyfill first -->
+<script src="https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.umd.js"></script>
+
+<!-- 2. Load the Tempo Global Bundle (Creates window.Magma) -->
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.min.js"></script>
+
+<!-- 3. Load any Community Plugins (Attaches to window.Magma.plugins) -->
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-celestial@1/dist/index.global.min.js"></script>
+
+<script>
+  // 1. Extract what you need from the Magma namespace
+  const { Tempo, plugins } = Magma;
+  
+  // 2. Extend the core engine
+  Tempo.use(plugins.celestial);
+
+  // 3. Create your instance!
+  const t = new Tempo('next friday');
+  console.log(t.toString());
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Granular "Lite" Builds (Advanced) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are extremely concerned about bundle size, you can bypass the "Batteries Included" entry point and import only the core engine. You then manually opt-in to the modules you need.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { MutateModule } from '@magmacomputing/tempo/mutate';
+
+// Opt-in to specific functionality
+Tempo.use(MutateModule);
+
+const t = new Tempo().add({ days: 1 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Lite build, the Tempo class will have almost no methods (like .add(), .set(), or .format()) until you explicitly call Tempo.use() with the appropriate module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Versioning Policy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We recommend pinning your versions in production environments to ensure stability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • JSDelivr: https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/... (Locks to major version 4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Latest: https://cdn.jsdelivr.net/npm/@magmacomputing/tempo/... (Omit the version string to always receive the latest release. Note that JSDelivr will resolve a missing version tag to the latest published release).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Cursor, VS Code (GitHub Copilot), Antigravity, ChatGPT, or Claude? Tempo publishes an official llms.txt index to give AI assistants documented project context and reduce hallucinations regarding Tempo's syntax, token grammar, and immutability rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the dedicated AI & IDE Integration Guide for step-by-step setup instructions for your IDE or tool.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,63)])])}const c=i(e,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.lean.js b/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.lean.js new file mode 100644 index 00000000..344017dc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_installation.md.CJJI9Qtd.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Installation Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/installation.md","filePath":"doc/1-getting-started/installation.md"}'),e={name:"doc/1-getting-started/installation.md"};function l(p,s,h,o,r,k){return a(),t("div",null,[...s[0]||(s[0]=[n("",63)])])}const c=i(e,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.js b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.js new file mode 100644 index 00000000..8867f1fe --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.js @@ -0,0 +1,99 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Cookbook","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/tempo.cookbook.md","filePath":"doc/1-getting-started/tempo.cookbook.md"}'),e={name:"doc/1-getting-started/tempo.cookbook.md"};function h(l,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Cookbook ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A collection of recipes for solving common date and time challenges using Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Table of Contents ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Basics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Parsing Challenges
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Manipulation and Calculations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Timezones and Locales
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Business Logic and Terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Formatting and Localization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Interoperability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Basics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I get the current date and time? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When invoked without arguments, the constructor initializes to the current date and time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const now = new Tempo();
+console.log(now.toString()); // e.g. "2026-07-31T14:42:11+10:00[Australia/Sydney]"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Get "Now" in UTC ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const utcNow = new Tempo({ timeZone: 'UTC' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I format a date for my UI? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use the placeholder syntax in the .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-12-25');
+t.format('{dd} {mon} {yyyy}');  // "25 December 2024"
+t.format('{h12}:{mi}');         // "12:00am"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I check if a date is valid? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('invalid-date');
+if (t.isValid) {
+  // ...
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can initialize global defaults that apply to all future Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  timeZone: 'UTC',
+  locale: 'en-GB',
+  silent: true
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: Configuration Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing Challenges ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing "Ambiguous" Digits (US vs UK) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo intelligently resolves ambiguous dates like 04012026 based on your timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('04012026', { timeZone: 'America/New_York' }); 
+console.log(us.format('{mon} {dd}')); // "April 01"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: Ambiguity Resolution Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Handling Relative Strings ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively understands human-readable offsets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('yesterday');
+new Tempo('next Friday');
+new Tempo('2 weeks ago');
+new Tempo('tomorrow afternoon');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: You can seamlessly localize relative phrases (e.g. next to prochain) by reading the Internationalized Parsing Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing Unix Timestamps ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo handles both milliseconds (Number) and nanoseconds (BigInt).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo(1716163200000);         // Milliseconds
+new Tempo(1716163200000000000n);  // Nanoseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manipulation and Calculations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add or Subtract Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo instances are immutable; add() returns a new instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const deadline = new Tempo().add({ days: 7, hours: 2 });
+const past = new Tempo().add({ months: -1 });
+
+// You can also step by semantic Terms using the \`#\` prefix!
+const t1 = new Tempo('2024-05-15'); // Middle of Q2
+const t2 = t1.add({ '#quarter': 1 }); // Middle of Q3: "2024-08-14" (approx)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Jumping to Boundaries (start, mid, end) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .set() method allows you to jump to the boundaries of native units (like months or years) or semantic Terms (using the # prefix). You can specify whether to land on the inclusive start, inclusive end, or the exact center.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Native Units
+const monthStart = new Tempo().set({ month: 'start' });
+
+// Semantic Terms (Lands on 30-Sep 23:59:59.999... Inclusive End)
+const qtrEnd = new Tempo('2024-07-15').set({ '#quarter': 'end' });
+
+// Lands on the arithmetic nanosecond midpoint of the period
+const qtrMid = new Tempo().set({ '#quarter': 'mid' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can navigate relative to your current date by using Slick Shorthand operators directly inside .set(). Use the snippet shorthand keys (yy, mm, ww, dd, wkd, etc.) and provide a string payload containing a directional modifier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+t.set({ mm: '>2' });               // July 20th
+t.set({ wkd: '>Fri' });            // May 24th

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: To read about advanced chaining, order-of-operations, and architectural limitations, see the Slick Object Mutations Deep Dive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How long until a deadline? (until) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+const daysLeft = t.until('2025-01-01', 'days');
+console.log(\`\${daysLeft} days remaining\`);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative Time (since) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generate human-readable relative time strings instantly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('yesterday');
+console.log(t.since()); // "1d ago"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezones and Locales ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Convert Time to Another Zone ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const nyc = new Tempo('2024-05-20 10:00', { timeZone: 'America/New_York' });
+const london = nyc.set({ timeZone: 'Europe/London' });
+
+console.log(nyc.format('{hh}:{mi}'));    // "10:00"
+console.log(london.format('{hh}:{mi}')); // "15:00"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic / Multi-Tenant Context (Functional Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Context options (timeZone, locale, calendar, sphere) accept supplier functions (() => string). Tempo resolves suppliers at instantiation time to construct an immutable, frozen instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { AsyncLocalStorage } from 'node:async_hooks';
+
+const requestContext = new AsyncLocalStorage<{ timeZone: string; locale: string }>();
+
+// Configure dynamic suppliers that evaluate against current request context
+const t = new Tempo('now', {
+  timeZone: () => requestContext.getStore()?.timeZone || 'UTC',
+  locale: () => requestContext.getStore()?.locale || 'en-US'
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Configuration Guide for details on functional options and immutability guarantees.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business Logic and Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Is it the weekend? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For simple ISO checks, Saturday is 6 and Sunday is 7:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+const isWeekend = t.dow >= 6; // Saturday = 6, Sunday = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For international applications, use the locale-aware t.intl.weekend array (backed by Intl.Locale.prototype.getWeekInfo() and its fallback resolver), which reflects regional weekend days (e.g. [5, 6] for Friday & Saturday in Middle Eastern locales like ar-SA):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Standard weekend ([6, 7] for Saturday and Sunday in en-US)
+const us = new Tempo({ locale: 'en-US' });
+const isUsWeekend = us.intl.weekend.includes(us.dow);
+
+// Regional weekend ([5, 6] for Friday and Saturday in ar-SA)
+const sa = new Tempo({ locale: 'ar-SA' });
+const isSaWeekend = sa.intl.weekend.includes(sa.dow);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What Fiscal Quarter are we in? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using the qtr Term plugin (term.qtr is a convenient alias for the full term.quarter property).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+console.log(\`Current Quarter: \${t.term.qtr}\`); // "Q1", "Q2", etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemispheric Seasons ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Terms are hemisphere-aware.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sydney = new Tempo('2024-07-01', { sphere: 'south' });
+console.log(sydney.term.szn); // "Winter"
+
+const london = new Tempo('2024-07-01', { sphere: 'north' });
+console.log(london.term.szn); // "Summer"
+
+// or even via the timeZone setting
+console.log(new Tempo({ timeZone: 'America/New_York' }).term.szn); // "Summer"
+console.log(new Tempo({ timeZone: 'Australia/Sydney' }).term.szn); // "Winter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting and Localization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Semantic Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use specific Term tokens like {#quarter} or {#season} to automatically embed a Term's label (or key) into a format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+console.log(t.format('We are currently in the {#quarter}')); // "We are currently in the First Quarter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Modifiers & Localization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format strings support chained colon-modifiers (e.g., :upper, :locale, :ord) to dynamically change the presentation casing or delegate to the native Intl API. You can stack them to get the exact presentation required!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-15 15:30', { locale: 'fr-FR' });
+
+t.format('{mon:upper}');             // "MAY" (English Default -> UpperCase)
+t.format('{mon:long}');              // "mai" (Native French Intl output via styling bridge)
+t.format('{mon:long:upper} {dd}');   // "MAI 15" (Native French Intl output)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Smart Formatting Guide for the complete list of available modifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tired of typing styling modifiers?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you find yourself repeatedly writing :long or :short for the same localized date structure, save it to the global FORMATS registry! This creates a clean, reusable shortcut:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+    locale: 'fr-FR',
+    registry: {
+        formats: {
+            'ui-date': '{wkd:long}, {dd:raw} {mon:long} {yyyy}'
+        }
+    }
+});
+
+t.format('ui-date'); // Resolved with all modifiers intact!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Format keys are resolved case-sensitively from the global registry.formats object. If the requested key is not found, Tempo will simply treat the provided string as a literal layout string rather than throwing an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: To build custom zero-overhead logic evaluators (like Fiscal Years or native Intl bridges), read the Custom Format Tokens Deep Dive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Ticker engine is a community plugin for precisely driving business logic (like recurring billing or reporting cycles) on specific date boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Drive internal reporting precisely when a new quarter begins
+await using quarterly = Tempo.ticker({ '#quarter': 1 });
+
+for await (const t of quarterly) {
+  generateReport(t.term.qtr);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Ticker Plugin Documentation for detailed configuration, term-driven intervals, and await using syntax requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format & Parse Dialects Plugin (Moment, Luxon, SQL, POSIX, PHP) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating existing code or layouts from Moment.js, Luxon, date-fns, POSIX strftime, PHP, or SQL, use the @magmacomputing/tempo-plugin-dialects community plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Zero-config drop-in import automatically mounts dialect shims:
+import '@magmacomputing/tempo-plugin-dialects/install';
+
+const t = new Tempo('2026-10-24T15:30:00');
+
+// Luxon convenience shim (.toFormat)
+t.toFormat('yyyy-MM-dd HH:mm:ss');          // "2026-10-24 15:30:00"
+
+// LDML & Moment parsing
+Tempo.fromFormat('2026-10-24', 'yyyy-MM-dd'); // LDML parsing via Luxon shim
+Tempo.dialects.parse('2026-10-24', 'YYYY-MM-DD', 'moment'); // Moment layout parsing
+
+// Direct dialect formatters
+t.dialects.sql('YYYY-MM-DD HH24:MI:SS');     // Oracle / PostgreSQL TO_CHAR
+t.dialects.php('Y-m-d H:i:s');               // PHP date()
+t.dialects.go('2006-01-02 15:04:05');        // Go reference layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Dialects Plugin Documentation for full token specifications, multi-candidate parsing fallbacks, and cross-ecosystem translation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interoperability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converting to / from Native Date ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = new Tempo().toDate();
+const tempo = new Tempo(new Date());

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converting to Temporal Objects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const zdt = new Tempo().zdt;             // Temporal.ZonedDateTime (or .toDateTime())
+const instant = new Tempo().toInstant(); // Temporal.Instant
+const pdt = new Tempo().toPlainDate();   // Temporal.PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sorting an array of Tempos ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dates = [new Tempo('tomorrow'), new Tempo('yesterday'), new Tempo('today')];
+dates.sort(Tempo.compare); // Sorts chronologically
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,102)])])}const E=i(e,[["render",h]]);export{g as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.lean.js b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.lean.js new file mode 100644 index 00000000..e2b96d4c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.cookbook.md.BTs_Rb_Y.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Cookbook","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/tempo.cookbook.md","filePath":"doc/1-getting-started/tempo.cookbook.md"}'),e={name:"doc/1-getting-started/tempo.cookbook.md"};function h(l,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n("",102)])])}const E=i(e,[["render",h]]);export{g as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.js b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.js new file mode 100644 index 00000000..05024d12 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.js @@ -0,0 +1,6 @@ +import{_ as a,o as i,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Interactive REPL & Feature Showcase","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/tempo.repl.md","filePath":"doc/1-getting-started/tempo.repl.md"}'),r={name:"doc/1-getting-started/tempo.repl.md"};function n(o,e,l,p,d,h){return i(),s("div",null,[...e[0]||(e[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interactive REPL & Feature Showcase ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers two dedicated, zero-install in-browser environments running 100% client-side via native ECMAScript Modules (esm.sh):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 🎨 Feature Showcase & Workbench: A dynamic, visual sandbox to test format tokens, chained mutations, relative durations, world geolocation, and astronomical ephemeris in real time with auto-generated TypeScript code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. ⚡ Freeform Code REPL: A freeform JavaScript/TypeScript code editor with real-time evaluation, console streaming, official plugin preloading, and snippet URL sharing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎨 Interactive Feature Showcase ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore live formatting, chained mutations, hemisphere-aware astronomical seasons, and celestial mechanics without writing boilerplate:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs 100% in your browser. Generates ready-to-use TypeScript code.🚀 Open Full-Screen Showcase↗

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Freeform Code REPL ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An instant scratchpad for testing custom algorithms, experimental plugin imports, and sharing reproducible snippet links:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-configured with Tempo, Temporal, and official plugins.🚀 Open Full-Screen Code REPL↗

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Capabilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Preloaded Official Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both environments pre-register the core Tempo instance along with default official plugins:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo-plugin-geo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can immediately access Terms, seasons, and celestial data without import boilerplate:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('today', { geo: { lat: -33.86, lng: 151.2 } });
+console.log(t.term.szn);            // "Spring"
+console.log(t.term.lunar.phase);    // "First Quarter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dynamic Plugin Loading & Presets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need an additional plugin like @magmacomputing/tempo-plugin-spatial, @magmacomputing/tempo-plugin-ticker, or custom third-party modules? Select their preset from the preset dropdown or use standard dynamic imports in the Code REPL:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const { SpatialPlugin } = await import('@magmacomputing/tempo-plugin-spatial');
+Tempo.use(SpatialPlugin);
+
+console.log('Spatial plugin active!');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. AI Semantic Parsing & Natural Language Scheduling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore generative date parsing, conversational recurrence, and multi-point event scheduling powered by @magmacomputing/tempo-plugin-ai:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Select the Preset: AI Semantic Parsing & Scheduling from the preset dropdown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supported Provider Configuration (BYOK): Provide an API key or local endpoint in Tempo.ai.init({ providers: [...] }) before calling Tempo.ai.parse or Tempo.ai.schedule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • External Resources & Free Keys:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Groq Console: Ultra-fast inference with a generous free tier (recommended for quick testing).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Google AI Studio (Gemini): Free API key for Gemini models.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • OpenAI Platform: Standard GPT-4o / GPT-4o-mini keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ollama: 100% free, private local LLMs. Note: When running locally for browser access, start Ollama with CORS enabled: OLLAMA_ORIGINS="*" ollama serve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    API Key Safety in Share Links: When you click 📋 Share, the editor content is encoded into the URL hash (#code=...). Never paste production or sensitive API keys into shared snippets. For live testing, use ephemeral personal sandbox keys or local Ollama.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Shareable Snippets & Presets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Share: Click the 📋 Share button in the REPL header to encode your code directly into a shareable URL hash (#code=...).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copy Code: Click 📋 Copy Code in the Showcase to grab production-ready TypeScript code for your current visual setup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Keyboard Shortcuts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ctrl + Enter (Windows/Linux) or Cmd + Enter (macOS): Immediately re-evaluate the current editor code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tab: Inserts 2-space indentation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,31)])])}const m=a(r,[["render",n]]);export{g as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.lean.js b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.lean.js new file mode 100644 index 00000000..c66809d3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_1-getting-started_tempo.repl.md.Be6Mnegx.lean.js @@ -0,0 +1 @@ +import{_ as a,o as i,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Interactive REPL & Feature Showcase","description":"","frontmatter":{},"headers":[],"relativePath":"doc/1-getting-started/tempo.repl.md","filePath":"doc/1-getting-started/tempo.repl.md"}'),r={name:"doc/1-getting-started/tempo.repl.md"};function n(o,e,l,p,d,h){return i(),s("div",null,[...e[0]||(e[0]=[t("",31)])])}const m=a(r,[["render",n]]);export{g as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.js new file mode 100644 index 00000000..e2a15e86 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.js @@ -0,0 +1,23 @@ +import{_ as l,o as a,c as n,a2 as t,j as s,a as i}from"./chunks/framework.DNL3hc5c.js";const f=JSON.parse('{"title":"Cache Management Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.cache.md","filePath":"doc/2-core-concepts/tempo.cache.md"}'),o={name:"doc/2-core-concepts/tempo.cache.md"},r={tabindex:"0"},p={style:{"text-align":"left"}},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function k(u,e,m,y,T,E){return a(),n("div",null,[e[20]||(e[20]=t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Management Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a centralized, high-performance BoundedCache singleton accessible via Tempo.cache. It provides dual-layer resolution for dynamic relative dates (with LRU eviction and TTL expiration) and static business glossaries (immortal keys).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏛️ Centralized Cache Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All date resolution caching—whether triggered by core Tempo parsing or the Tempo AI plugin (parseAI, formatAI, contextAI)—is managed centrally by Tempo.cache.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Behavior: Core Tempo vs. Tempo AI Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core Tempo: Caching is opt-in. Core date parsing executes at sub-microsecond speeds using standard regex matching. Tempo.cache is consulted when you seed a static glossary or enable caching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo AI Plugin: Caching is automatic. To eliminate network latency (~500ms+) and avoid redundant LLM API billing, AI functions (like parseAI) automatically check Tempo.cache before sending network requests and cache every successful LLM resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Topology & Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can configure global cache parameters using Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  cache: {
+    maxSize: 1000,             // Maximum number of entries before LRU eviction (default: 1000)
+    ttl: 24 * 60 * 60 * 1000   // Time-to-live in milliseconds (default: 24 hours)
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Capacity Management (LRU): When the cache reaches maxSize, the Least Recently Used dynamic entry is automatically evicted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TTL Expiration: Dynamic entries older than ttl are automatically purged upon lookup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Static Glossary Isolation: Static entries added to the glossary are exempt from both LRU eviction and TTL expiration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Seeding & Appending Glossaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can seed static business terms into Tempo.cache using a native JavaScript Map or via Tempo.init({ cache: map }):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const businessGlossary = new Map([
+  ['fiscal year start 2026', '2026-07-01T00:00:00Z'],
+  ['q3 board review', '2026-09-15T09:00:00Z']
+]);
+
+// Appends entries to Tempo.cache as static, immortal terms
+Tempo.init({ cache: businessGlossary });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Non-Destructive Appending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing a Map or custom key-value pairs to Tempo.init({ cache }) or initAI({ cache }) appends to the existing cache without clearing previously cached terms or resetting cache capacity settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 When to Use What: Glossary vs. Alias vs. Snippet/Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides multiple mechanisms for augmenting parsing intelligence. Choosing the right pattern depends on whether your logic is static, dynamic, structural, or string replacement:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18)),s("table",r,[e[9]||(e[9]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Mechanism"),s("th",{style:{"text-align":"left"}},"Tier / Location"),s("th",{style:{"text-align":"left"}},"Evaluation Model"),s("th",{style:{"text-align":"left"}},"Best Used For...")])],-1)),s("tbody",null,[s("tr",null,[e[4]||(e[4]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Glossary"),i(" ("),s("code",null,"Tempo.cache"),i(")")],-1)),e[5]||(e[5]=s("td",{style:{"text-align":"left"}},"Core Engine",-1)),s("td",p,[e[2]||(e[2]=i("Zero-cost ",-1)),s("mjx-container",h,[(a(),n("svg",d,[...e[0]||(e[0]=[t('',1)])])),e[1]||(e[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),e[3]||(e[3]=i(" Map lookup",-1))]),e[6]||(e[6]=s("td",{style:{"text-align":"left"}},"Pre-calculated static ISO date/time strings or exact business dates.",-1))]),e[7]||(e[7]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Aliases / Events / Periods"),i(" ("),s("code",null,"registry.events"),i(" / "),s("code",null,"periods"),i(")")]),s("td",{style:{"text-align":"left"}},"Registry Engine"),s("td",{style:{"text-align":"left"}},"Dynamic function or target string"),s("td",{style:{"text-align":"left"}},[i("Computing dynamic business dates (e.g. "),s("code",null,"'deadline' => () => this.add({ days: 30 })"),i(").")])],-1)),e[8]||(e[8]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Snippet / Layouts"),i(" ("),s("code",null,"registry.snippets"),i(" / "),s("code",null,"layouts"),i(")")]),s("td",{style:{"text-align":"left"}},"Parser Planner"),s("td",{style:{"text-align":"left"}},"Regex pattern matcher"),s("td",{style:{"text-align":"left"}},[i("Structural natural language formats (e.g. "),s("code",null,"yyyy/mm/dd"),i(" or custom date tokens).")])],-1))])]),e[21]||(e[21]=s("h3",{id:"decision-tree",tabindex:"-1"},[i("Decision Tree "),s("a",{class:"header-anchor",href:"#decision-tree","aria-label":'Permalink to "Decision Tree"'},"​")],-1)),s("ol",null,[s("li",null,[e[12]||(e[12]=s("strong",null,[i("Use a Glossary ("),s("code",null,"Tempo.cache"),i(")")],-1)),e[13]||(e[13]=i(" when you have fixed, pre-resolved ISO dates for specific terms (e.g., ",-1)),e[14]||(e[14]=s("code",null,"'eoy 2026'",-1)),e[15]||(e[15]=i(" -> ",-1)),e[16]||(e[16]=s("code",null,"'2026-12-31T23:59:59Z'",-1)),e[17]||(e[17]=i("). It offers instant ",-1)),s("mjx-container",c,[(a(),n("svg",g,[...e[10]||(e[10]=[t('',1)])])),e[11]||(e[11]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),e[18]||(e[18]=i(" resolution without invoking the regex parser.",-1))]),e[19]||(e[19]=t("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use an Alias (registry.events / periods) when you need dynamic rules calculated relative to the current date/time (e.g., 'market-close' -> '16:00' or 'deadline' -> 30 days from now).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use a Snippet or Layout (registry.snippets / layouts) when parsing custom input structures with variable numbers or tokens (e.g. "2026-W05" or "Quarter 3, 2026").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ",2))]),e[22]||(e[22]=t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI Plugin Cache Integration (@magmacomputing/tempo-plugin-ai) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ai plugin works hand-in-hand with Tempo.cache to reduce LLM API calls and costs across AI functions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { parseAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+initAI({ providers: [...] });
+
+// First lookup: Triggers LLM call -> Stores ISO result in Tempo.cache
+const t1 = await parseAI("The penultimate Tuesday before Thanksgiving in 2026");
+
+// Second lookup: Instantly resolves from Tempo.cache (O(1) local hit, $0 cost)
+const t2 = new Tempo("The penultimate Tuesday before Thanksgiving in 2026");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Two-Tier Resolution Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Date-Salted Relative Cache: Relative queries (e.g. "next Tuesday") are salted with the anchor date so cached entries remain valid for the given day.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Static Glossary Fallback: Business glossary terms seeded via initAI({ cache }) or Tempo.init({ cache }) are checked first, providing zero-latency resolution without ever contacting the LLM.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,6))])}const v=l(o,[["render",k]]);export{f as __pageData,v as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.lean.js new file mode 100644 index 00000000..2cade3d5 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.cache.md.DC5v2nZ0.lean.js @@ -0,0 +1 @@ +import{_ as l,o as a,c as n,a2 as t,j as s,a as i}from"./chunks/framework.DNL3hc5c.js";const f=JSON.parse('{"title":"Cache Management Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.cache.md","filePath":"doc/2-core-concepts/tempo.cache.md"}'),o={name:"doc/2-core-concepts/tempo.cache.md"},r={tabindex:"0"},p={style:{"text-align":"left"}},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function k(u,e,m,y,T,E){return a(),n("div",null,[e[20]||(e[20]=t("",18)),s("table",r,[e[9]||(e[9]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Mechanism"),s("th",{style:{"text-align":"left"}},"Tier / Location"),s("th",{style:{"text-align":"left"}},"Evaluation Model"),s("th",{style:{"text-align":"left"}},"Best Used For...")])],-1)),s("tbody",null,[s("tr",null,[e[4]||(e[4]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Glossary"),i(" ("),s("code",null,"Tempo.cache"),i(")")],-1)),e[5]||(e[5]=s("td",{style:{"text-align":"left"}},"Core Engine",-1)),s("td",p,[e[2]||(e[2]=i("Zero-cost ",-1)),s("mjx-container",h,[(a(),n("svg",d,[...e[0]||(e[0]=[t("",1)])])),e[1]||(e[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),e[3]||(e[3]=i(" Map lookup",-1))]),e[6]||(e[6]=s("td",{style:{"text-align":"left"}},"Pre-calculated static ISO date/time strings or exact business dates.",-1))]),e[7]||(e[7]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Aliases / Events / Periods"),i(" ("),s("code",null,"registry.events"),i(" / "),s("code",null,"periods"),i(")")]),s("td",{style:{"text-align":"left"}},"Registry Engine"),s("td",{style:{"text-align":"left"}},"Dynamic function or target string"),s("td",{style:{"text-align":"left"}},[i("Computing dynamic business dates (e.g. "),s("code",null,"'deadline' => () => this.add({ days: 30 })"),i(").")])],-1)),e[8]||(e[8]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Snippet / Layouts"),i(" ("),s("code",null,"registry.snippets"),i(" / "),s("code",null,"layouts"),i(")")]),s("td",{style:{"text-align":"left"}},"Parser Planner"),s("td",{style:{"text-align":"left"}},"Regex pattern matcher"),s("td",{style:{"text-align":"left"}},[i("Structural natural language formats (e.g. "),s("code",null,"yyyy/mm/dd"),i(" or custom date tokens).")])],-1))])]),e[21]||(e[21]=s("h3",{id:"decision-tree",tabindex:"-1"},[i("Decision Tree "),s("a",{class:"header-anchor",href:"#decision-tree","aria-label":'Permalink to "Decision Tree"'},"​")],-1)),s("ol",null,[s("li",null,[e[12]||(e[12]=s("strong",null,[i("Use a Glossary ("),s("code",null,"Tempo.cache"),i(")")],-1)),e[13]||(e[13]=i(" when you have fixed, pre-resolved ISO dates for specific terms (e.g., ",-1)),e[14]||(e[14]=s("code",null,"'eoy 2026'",-1)),e[15]||(e[15]=i(" -> ",-1)),e[16]||(e[16]=s("code",null,"'2026-12-31T23:59:59Z'",-1)),e[17]||(e[17]=i("). It offers instant ",-1)),s("mjx-container",c,[(a(),n("svg",g,[...e[10]||(e[10]=[t("",1)])])),e[11]||(e[11]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),e[18]||(e[18]=i(" resolution without invoking the regex parser.",-1))]),e[19]||(e[19]=t("",2))]),e[22]||(e[22]=t("",6))])}const v=l(o,[["render",k]]);export{f as __pageData,v as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.js new file mode 100644 index 00000000..281896bd --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.js @@ -0,0 +1,153 @@ +import{_ as l,o as a,c as n,a2 as t,j as i,a as e}from"./chunks/framework.DNL3hc5c.js";const T=JSON.parse('{"title":"Configuration Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.config.md","filePath":"doc/2-core-concepts/tempo.config.md"}'),o={name:"doc/2-core-concepts/tempo.config.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"8.549ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3778.7 1000","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"10.811ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 4778.7 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(y,s,E,u,m,f){return a(),n("div",null,[s[13]||(s[13]=t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a flexible, multi-tiered configuration system. Settings are applied in a specific order of precedence, allowing you to set broad defaults that can be refined at the application or instance level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Precedence Hierarchy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings are loaded in the following order (where later stages override earlier ones):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Library Defaults: Sensible out-of-the-box baseline.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Persistent Storage: Sticky user preferences (which merge into Defaults).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Global Discovery: Enterprise-level setup discovered via Symbol.for('$Tempo').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Library Extension: Dynamic feature registration via Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Explicit Initialization: Baseline configuration via Tempo.init().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Instance Constructor: Specific overrides for a single new Tempo() call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏆 Best Practice: The tempo.config.ts Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than scattering Tempo.init() or Tempo.use() calls throughout your application, the recommended best practice is to centralize your environment setup into a single tempo.config.ts (or .js) file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This mirrors modern ecosystem standards (like vite.config.ts or tailwind.config.js) and ensures that plugins, timezones, and custom aliases are consistently applied before any domain logic executes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Target Environment & Discovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automatic zero-config discovery relies on Node.js file system capabilities and is exclusive to Server and Node.js environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In bundled frontend environments (like Vite or Webpack), you can still maintain a central tempo.config.ts, but you must explicitly import and pass it to Tempo.init(config) at your application entry point (e.g. main.ts). If you are using Tempo via a <script> tag in a pure Browser environment, skip to Explicit Initialization to configure Tempo directly!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo.config.ts
+import { defineConfig } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+export default defineConfig({
+  timeZone: 'Australia/Sydney',        // Set your baseline timezone
+  extends: './tempo-base.config.jsonc',// Inherit local base config
+  plugins: [
+    CelestialPlugin,                   // 1. Executable plugin or term
+    TickerPlugin,                      // 2. Plugin singleton (or factory closure)
+  ],
+  pluginOptions: {
+    ai: { mode: 'fallback', timeout: 10000 }, // 3. Plugin configuration defaults
+    ticker: { interval: 1000 }
+  },
+  registry: {
+    periods: { 
+      'market-open': '09:30',
+      'market-close': '16:00' 
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Clean Separation: Feature Registration vs Plugin Configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo separates code registration from data configuration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • plugins: Strictly registers executable plugins, namespaces, terms, or factory closures ((Plugin | Term)[]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pluginOptions: Dedicated dictionary holding runtime options and configuration defaults for plugins (Record<string, any>), serializable in tempo.config.json and cascading across local extends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The 'plugins' key as a JSON of plugin-configuration settings has been migrated to 'pluginOptions' so as not to overload the 'plugins' key (which registers Plugin instances / Terms / Modules / Namespaces).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can then bootstrap this environment at the very top of your application's entry point (e.g., main.ts or index.js) to guarantee the configuration is locked in before any other files run:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Server / Node.js Entry Point (Zero-Config Discovery) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // main.ts (Server / Node.js)
+import { Tempo } from '@magmacomputing/tempo';
+
+// Automatically discovers and loads local 'tempo.config.ts' (or .js / .json / .jsonc)
+await Tempo.bootstrap(); 
+
+// OR: Bootstrap from an explicit local configuration file or path
+await Tempo.bootstrap({ configFile: './configs/tempo.production.jsonc' });
+
+// Dynamic import ensures domain logic loads ONLY AFTER configuration is complete
+const { App } = await import('./app.js');
+// ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bundled Frontend Entry Point (Vite / Webpack) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // main.ts (Bundled Frontend / Browser)
+import { Tempo } from '@magmacomputing/tempo';
+import tempoConfig from './tempo.config';
+
+// Explicitly pass central configuration into Tempo.init()
+Tempo.init(tempoConfig);
+
+// Application bootstrap proceeds with configured Tempo
+import './app';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cascading Configurations ("extends") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo configuration files can inherit settings from parent baseline configurations via local file paths or file:// URLs using the "extends" key. Local options automatically override parent baseline options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jsonc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo.config.jsonc
+{
+  "extends": "./tempo-base.config.jsonc",
+  "timeZone": "Australia/Sydney", // Local override
+  "registry": {
+    "periods": {
+      "standup": "09:15"
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits vs. Drawbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using tempo.config.ts or Tempo.bootstrap() is the modern standard, but it introduces specific architectural tradeoffs due to Node.js ES Module and asynchronous I/O boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TypeScript Autocomplete: Using defineConfig provides instant IDE intellisense and type-safety for all configuration options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Execution: You can import and instantiate plugins directly inside JS/TS configuration files, keeping your application logic clean.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Configuration Inheritance: Enables inheriting shared base configs via relative paths, absolute paths, or file:// URLs with recursive inheritance and cycle detection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dynamic Configuration: Enables runtime logic (e.g., debug: process.env.NODE_ENV !== 'production') in JS/TS configs that strict JSON cannot provide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Drawbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Asynchronous Requirement: Because dynamic config loading and file reading are asynchronous, you must use await Tempo.bootstrap() instead of synchronous calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛑 Security & Reliability Bounds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Data-Only Inheritance: The "extends" mechanism strictly supports static .json and .jsonc data files. Dynamic JavaScript execution (eval or dynamic import) from extended configurations is prohibited to prevent unintended code execution in inherited configs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Boundary Safety: Remote HTTP(S) URLs are rejected when specified as configFile (returning undefined), whereas remote "extends" targets are skipped with a warning while local configuration processing continues, protecting against external network dependencies and remote code injection. file:// URLs are validated to disallow remote hosts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Floating Promises: You must ensure you actually await the bootstrap call. If you forget the await keyword, your application will continue booting before Tempo finishes reading your config file, leading to race conditions where early instances use default settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Looking to configure Internationalization?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers deep integration with native Intl APIs for both parsing and formatting foreign languages out-of-the-box. See Internationalization & Locale for a general guide, and the Internationalized Parsing and Format Modifiers & Localization guides for configuration details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Persistent Configuration ($Tempo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first layer Tempo checks after its own internal defaults is persistent storage. This is ideal for "sticky" settings like a user's preferred timezone or locale that should persist across sessions without a database.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Write a preference to localStorage under the default key ('$Tempo')
+Tempo.writeStore({ timeZone:'Australia/Sydney' });
+// Write a preference to localStorage under the key 'mySettings'
+Tempo.writeStore({ timeZone: 'America/New_York' }, 'mySettings');
+
+// Later, or in another file, initialize Tempo pointing to that key
+// It will automatically read 'America/New_York' and apply it
+Tempo.init({ store: 'mySettings' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Global Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To facilitate configuration in micro-frontend architectures or script-first bootstraps, Tempo can discover a Discovery object from globalThis during Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The intended flow is:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Write a Discovery object into globalThis under the configured discovery symbol key.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Import a module containing Tempo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Tempo class static initialization runs Tempo.init().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Tempo.init() reads the global discovery slot and merges it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, the key is Symbol.for('$Tempo').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-Bootstrap Discovery (globalThis) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Must run before the first Tempo module is evaluated
+globalThis[Symbol.for('$Tempo')] = Object.freeze({
+  options: { timeZone: 'Europe/Paris' },
+  timeZones: { MYTZ: 'Asia/Dubai' },
+  registry: { formats: { myFormat: '{dd}!!{mm}!!{yyyy}' } },
+  terms: [myCustomTermPlugin]
+});
+
+// Load Tempo after the discovery object is in place
+const { Tempo } = await import('@magmacomputing/tempo');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With static ESM imports, import evaluation happens before module body execution. If you need discovery to apply on first load, assign globalThis in an earlier script/module, or use dynamic import() as shown above.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explicit Runtime Registration (Not Global Discovery) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Tempo.use(...) is explicit registration after Tempo is loaded. It is ergonomic and strongly recommended for normal application code, but it is a different mechanism from pre-bootstrap global discovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.use({
+  options: { timeZone: 'Europe/Paris' },
+  timeZones: { MYTZ: 'Asia/Dubai' },
+  registry: { formats: { myFormat: '{dd}!!{mm}!!{yyyy}' } },
+  terms: [myCustomTermPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Security and Ergonomics Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tamper Prevention: When utilizing Global Discovery in a shared environment (like micro-frontends), it is highly recommended to Object.freeze() your configuration. Tempo only reads from this object, so freezing it prevents third-party scripts from injecting unauthorized plugins before Tempo boots up.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Discovery is convenient for host-controlled bootstraps and cross-bundle handoff.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use(...) is usually safer in app code because configuration is explicit, local, and easier to trace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use Global Discovery when you must configure Tempo before the first Tempo import executes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovery Contract ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo looks for the following structure:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optionsOptions | (() => Options)Configuration options merged into global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intlIntlOptionsInternationalization configuration grouping relativeTimeFormat, numberFormat, durationFormat, and dateTimeFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extendsstring | string[]Local file path(s) or file:// URL(s) to inherit base configuration from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins(Plugin | TermPlugin)[]Modular plugins/terms to register during configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptionsRecord<string, any>Plugin configuration defaults and dictionaries keyed by plugin name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonesRecord<string, string>Custom timezone aliases to be merged.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registry{ formats?, locales?, numbers?, ordinals?, events?, periods?, snippets?, layouts?, ignores?, modifiers?, tokens? }Custom configuration for internal dictionary registries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Explicit Initialization (Tempo.init) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is the Standard Developer Tier. Most applications should call Tempo.init() during startup to establish a predictable baseline for all instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  timeZone: 'Australia/Sydney',
+  locale: 'en-AU',
+  pivot: 80,
+  debug: 0
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Single-App vs. Sandboxed Environments (Tempo.init() vs. Tempo.create())

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init(): Designed for single-app entry points (such as client-side SPAs or CLI tools) to establish baseline defaults globally across the runtime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.create(): Designed for multi-tenant SSR servers (e.g. Next.js, Fastify), reusable npm libraries, or isolated unit test suites. Tempo.create() branches off an isolated, sandboxed class constructor with its own independent state and registry, guaranteeing zero cross-tenant preference leakage or global state pollution when using the default discovery setting or a unique options.discovery key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZoneEvaluable<string>System ZoneDefault IANA time zone, alias, or dynamic supplier (() => string).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localeEvaluable<string | string[]>System LocaleDefault BCP 47 language tag(s) or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendarEvaluable<string>'iso8601'Default calendar system or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pivotnumber75Cutoff for parsing two-digit years.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    monthDayMonthDay | booleanundefinedRegional date-parsing configuration (grouped). Includes active, locales, layouts, and timezones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeStamp'ss' | 'ms' | 'us' | 'ns''ms'Precision for numeric inputs and the .ts property.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sphereEvaluable<'north' | 'south' | 'equator'>Auto-inferredHemisphere for seasonal plugins or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    geoGeoOptionsundefinedGeographic coordinates, city, country, elevation, and timezone metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intlIntlOptionsundefinedInternationalization configuration grouping relativeTimeFormat, numberFormat, and durationFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localeInfobooleanfalseEnables locale-aware week-boundary mutation behavior (week: 'start' | 'mid' | 'end'). Formatting tokens ({dow:locale}, {hh:locale}) resolve locale info independently.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registry{ formats?, locales?, numbers?, ordinals?, events?, periods?, snippets?, layouts?, ignores?, modifiers? }Built-in registriesCustom data augmentation registries (e.g., format aliases, number-to-word mappings, parsing logic, localization).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extendsstring | string[]undefinedLocal file path(s) or file:// URL(s) to inherit base configuration from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins(Plugin | TermPlugin)[][]Plugins/terms to register during initialization (applied via Tempo.use(p)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptionsRecord<string, any>{}Plugin configuration defaults and dictionaries keyed by plugin name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    storestring'$Tempo'Persistent storage key used by readStore/writeStore.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    discoverystring | symbol'$Tempo' symbol keyDiscovery slot used to resolve global discovery config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debugnumber | string'info'Controls log verbosity via direct LOG levels (0=Off ... 5=Trace) or string labels ('trace', 'info', etc).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catchbooleanfalseIf true, invalid inputs return a Void instance instead of throwing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode'auto' | 'strict' | 'defer''auto'Controls the hydration strategy (e.g., defer for Zero-Cost creation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    silentbooleanfalseSuppresses console output. Combined with catch: true for silent failover.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plannerPlannerOptionsundefinedGrouped configuration for layoutOrder and preFilter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debug accepts numeric level values (0 through 5) or lowercase string labels ('off', 'error', 'warn', 'info', 'debug', 'trace').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Instance-Level Overrides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The final layer of precedence is the constructor itself. You can override any global setting for a specific calculation without affecting the rest of your application.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // This instance uses UTC regardless of any global configuration
+const t = new Tempo('now', { timeZone: 'UTC' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4.1 Dynamic & Functional Context Evaluation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In modern multi-tenant, serverless, or micro-service architectures (such as Next.js, Express, or Fastify), user timezone and locale preferences frequently change on a per-request basis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To eliminate repetitive instance options and prevent global configuration mutation churn (Tempo.init()), Tempo supports Evaluable<T> (T | (() => T)) suppliers across all core context properties (timeZone, locale, calendar, sphere):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+interface UserSession {
+  tenantId: string;
+  timeZone: string;
+  locale: string;
+}
+
+export const sessionContext = new AsyncLocalStorage<UserSession>();
+
+// Initialize global baseline with dynamic supplier functions once:
+Tempo.init({
+  timeZone: () => sessionContext.getStore()?.timeZone || 'UTC',
+  locale: () => sessionContext.getStore()?.locale || 'en-US'
+});
+
+// In request handlers, instantiate Tempo without manual option boilerplate:
+app.get('/api/report', (req, res) => {
+  sessionContext.run({ tenantId: 'tenant-123', timeZone: 'America/Chicago', locale: 'en-US' }, () => {
+    const t = new Tempo(); // Automatically resolves to 'America/Chicago'
+    res.json({ formatted: t.format('{mon} {dd}, {yyyy}') });
+  });
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determinism and Immutability Guarantees ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a Tempo instance is constructed:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. All functional suppliers (timeZone, locale, calendar, sphere) are evaluated synchronously at the moment of instantiation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The resolved scalar values are locked into the instance's immutable Temporal.ZonedDateTime engine and #state record.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. The instance is strictly frozen (Object.freeze).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero Configuration Drift: Because suppliers are resolved at creation time into an immutable snapshot, an existing Tempo instance will never drift or become out-of-sync if external session state changes later in the request lifecycle. Subsequent new Tempo() or plugin calls will cleanly evaluate contemporary session state anew.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4.2 Geographic Coordinates & Location Configuration (geo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can configure geographic coordinates and location metadata globally or override them on individual instances:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Global baseline in tempo.config.ts or Tempo.init():
+Tempo.init({
+  geo: {
+    lat: -33.8688,
+    lng: 151.2093,
+    city: 'Sydney',
+    country: 'Australia'
+  }
+});
+
+// Or per-instance override:
+const t = new Tempo('now', {
+  geo: {
+    lat: 51.5074,
+    lng: -0.1278,
+    city: 'London',
+    country: 'United Kingdom'
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,75)),i("ul",null,[i("li",null,[s[4]||(s[4]=i("strong",null,"Deterministic Validation",-1)),s[5]||(s[5]=e(": Latitudes outside ",-1)),i("mjx-container",r,[(a(),n("svg",p,[...s[0]||(s[0]=[t('',1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"["),i("mo",null,"−"),i("mn",null,"90"),i("mo",null,","),i("mn",null,"90"),i("mo",{stretchy:"false"},"]")])],-1))]),s[6]||(s[6]=e(" and longitudes outside ",-1)),i("mjx-container",d,[(a(),n("svg",h,[...s[2]||(s[2]=[t('',1)])])),s[3]||(s[3]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"["),i("mo",null,"−"),i("mn",null,"180"),i("mo",null,","),i("mn",null,"180"),i("mo",{stretchy:"false"},"]")])],-1))]),s[7]||(s[7]=e(" are rejected.",-1))]),s[8]||(s[8]=t("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 3-Decimal Precision: Automatically rounded (Math.round(val * 1000) / 1000) to guarantee cache hit consistency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Hemisphere Inference: Automatically sets t.sphere ('north', 'south', or 'equator').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Canonical Access: Read through t.geo (recursively frozen GeoConfig) and t.sphere.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ",3))]),s[14]||(s[14]=t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Advanced Parsing Rules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Beyond basic settings, Tempo's parsing engine can be extended with custom rules and behaviors to handle specialized natural language or high-volume processing requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 5.1 Custom Events and Periods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can extend Tempo's intelligence by supplying custom Events (date aliases) and Periods (time aliases) at any global configuration tier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    events: {
+      'launch date': '2026-05-20',
+      'deadline': function () { return this.add({ days: 30 }) }
+    },
+    periods: {
+      'tea time': '15:00',
+      'mid[ -]?after[ -]?noon': '16:00',  // regex-like key for 'mid after noon' or 'mid-after-noon' etc
+    }
+  }
+})
+
+const delivery = new Tempo('deadline'); // Parsed using your custom logic, adds 30-days to current-date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ 5.2 Deferring Initialization (mode: 'defer') ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default (mode: 'auto'), Tempo uses the Master Guard to determine if a string can be lazily evaluated. For exceptionally high-volume scenarios where you may be creating thousands of Tempo instances but only using them for calculations (not formats or Terms), you can force a standard lazy behavior using mode: 'defer'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When mode: 'defer' is set, the registry-discovery logic is deferred until the first time you access a property on t.fmt or t.term.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Optimized for mass-creation
+const t = new Tempo('now', { mode: 'defer' });
+
+console.log(t.format('{yyyy}')); // Discovery triggers NOW, only once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,10)),i("p",null,[s[11]||(s[11]=e("When initialized this way, no registries are built upfront. The constructor returns in ",-1)),i("mjx-container",c,[(a(),n("svg",k,[...s[9]||(s[9]=[t('',1)])])),s[10]||(s[10]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[12]||(s[12]=e(" time.",-1))]),s[15]||(s[15]=t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Cost Constructor: Combining the Master Guard (automatic) and the defer mode allows Tempo to satisfy the "Zero-Cost Constructor" requirement for mass-processing applications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧹 5.3 Noise Word Filtering (ignore) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo allows you to specify "noise words" that should be ignored during natural language parsing. This is particularly useful for handling human-readable strings that contain connectors or filler words.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo ignores the word "at" (e.g., "Friday at 3pm" becomes "Friday 3pm" internally).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Extend globally via Tempo.init()
+// This adds 'the' and 'o-clock' to the existing default list (['at'])
+Tempo.init({ registry: { ignores: ['the', 'o-clock'] } });
+
+// Use in a specific instance via the Tempo constructor (new Tempo(...))
+// This instance will ignore 'at', 'the', and 'o-clock'
+const t = new Tempo('next Friday at 3 o-clock', { 
+  registry: { ignores: 'o-clock' }
+}); 
+
+console.log(t.toString()); // Resolved correctly (noise words stripped)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registry Structure: The ignore registry accepts a String or an Array of strings. These are converted to a high-performance internal format to support efficient prototype-based shadowing. Note that values provided via Tempo.init() or the new Tempo() constructor merge with the default ignore list rather than replacing it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 5.4 Parse Planner & Pre-filtering ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For high-performance applications, you can enable the Parse Planner to optimize the pattern-matching loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    planner.preFilter (Boolean) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled, Tempo performs a fast upfront classification of the input string (detecting digits, letters, colons, etc.) and skips layouts that cannot possibly match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Purely numeric inputs: Skips event, period, wkd, and rel layouts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Alpha-only inputs: Skips time-heavy layouts like hms or off.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Colon detected: Prioritizes time-based layouts (tm, dtm) to find a match faster.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ 
+  planner: { preFilter: true } 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    planner.layoutOrder (Array) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can manually define the order in which layouts are attempted. This is useful if you know your data primarily uses a specific format (e.g., ISO dates) and want to avoid checking other layouts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ 
+  planner: { layoutOrder: ['ymd', 'dt', 'tm', 'rel'] } 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Observability: Set debug: 'debug' along with planner.preFilter to see a detailed "Planner summary" in the console, showing how many layouts were skipped for a given input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Summary of Tiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TierPrecedenceBest For...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defaults🐚 BaselineOut-of-the-box reasonable settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Persistence🏅 Low (Default)Sticky user preferences (merges into baseline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovery🥉 MediumMicro-frontends and third-party integrations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Init🥈 HighStandard baseline for the whole application.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance🥇 HighestAd-hoc overrides for specific calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Observability: When debug: 'debug' is set, Tempo logs its discovery path to the console (e.g., "Global Discovery found via Symbol"), making it easy to trace exactly where a setting originated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hidden Keys: The tempo.config getter excludes internal properties like anchor and input-only properties like value to keep the public API clean. These properties are still used internally for relative date resolution and instance hydration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,22))])}const b=l(o,[["render",g]]);export{T as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.lean.js new file mode 100644 index 00000000..7ad60bcf --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.config.md.CCVR1kyn.lean.js @@ -0,0 +1 @@ +import{_ as l,o as a,c as n,a2 as t,j as i,a as e}from"./chunks/framework.DNL3hc5c.js";const T=JSON.parse('{"title":"Configuration Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.config.md","filePath":"doc/2-core-concepts/tempo.config.md"}'),o={name:"doc/2-core-concepts/tempo.config.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"8.549ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3778.7 1000","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"10.811ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 4778.7 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(y,s,E,u,m,f){return a(),n("div",null,[s[13]||(s[13]=t("",75)),i("ul",null,[i("li",null,[s[4]||(s[4]=i("strong",null,"Deterministic Validation",-1)),s[5]||(s[5]=e(": Latitudes outside ",-1)),i("mjx-container",r,[(a(),n("svg",p,[...s[0]||(s[0]=[t("",1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"["),i("mo",null,"−"),i("mn",null,"90"),i("mo",null,","),i("mn",null,"90"),i("mo",{stretchy:"false"},"]")])],-1))]),s[6]||(s[6]=e(" and longitudes outside ",-1)),i("mjx-container",d,[(a(),n("svg",h,[...s[2]||(s[2]=[t("",1)])])),s[3]||(s[3]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"["),i("mo",null,"−"),i("mn",null,"180"),i("mo",null,","),i("mn",null,"180"),i("mo",{stretchy:"false"},"]")])],-1))]),s[7]||(s[7]=e(" are rejected.",-1))]),s[8]||(s[8]=t("",3))]),s[14]||(s[14]=t("",10)),i("p",null,[s[11]||(s[11]=e("When initialized this way, no registries are built upfront. The constructor returns in ",-1)),i("mjx-container",c,[(a(),n("svg",k,[...s[9]||(s[9]=[t("",1)])])),s[10]||(s[10]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[12]||(s[12]=e(" time.",-1))]),s[15]||(s[15]=t("",22))])}const b=l(o,[["render",g]]);export{T as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.js new file mode 100644 index 00000000..0558ce29 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.js @@ -0,0 +1,63 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Duration Logic","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"doc/2-core-concepts/tempo.duration.md","filePath":"doc/2-core-concepts/tempo.duration.md"}'),e={name:"doc/2-core-concepts/tempo.duration.md"};function l(h,s,p,o,r,k){return a(),n("div",null,[...s[0]||(s[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Duration Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a powerful DurationModule for calculating, balancing, and formatting the elapsed time between two dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo wraps the modern Temporal API, durations are highly accurate, seamlessly handling leap years, daylight saving time boundaries, and variable month lengths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculating Durations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers two primary methods for calculating time differences: .until() and .since(). While they may appear to be directional inverses of each other, they serve distinct architectural purposes and produce different output types:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .until() is built for numeric and mathematical calculations, returning primitive Number metrics (e.g. 420 minutes) or a Duration object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .since() is built for human-readable relative time formatting, returning localized String outputs (e.g. "36y ago" or "yesterday" via Intl.RelativeTimeFormat).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Coming from Moment.js or Day.js?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are looking for .diff(), you won't find it in Tempo—and for good reason!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In legacy libraries, a.diff(b) performed a - b, frequently causing off-by-sign confusion (e.g., today.diff(christmas) returning a negative number).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When architecting the modern ECMAScript Temporal API, the TC39 committee deliberately rejected .diff() in favor of directional, self-explanatory methods. Tempo follows this modern standard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use .until() for forward-looking math and durations ("How long until Christmas?" → today.until(christmas, 'days') is intuitively positive).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use .since() for elapsed time and human-readable relative strings ("How long since my birthday?" → today.since(birthday, 'years') → "36y ago").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .until() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the time remaining from the Tempo instance until a future date. The target can be a Tempo instance, a Temporal object, a JS Date, an ISO string, or a natural-language string expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const now = new Tempo('2026-05-10T08:00:00');
+const targetDate = new Tempo('2026-12-25'); // Tempo instance
+
+// 1. Target as a Tempo / Temporal instance (returns a Duration EDO)
+const duration = now.until(targetDate);
+
+// 2. Target as a Tempo instance with a specific unit (returns a primitive Number)
+now.until(targetDate, 'days');               // → 229    (using Tempo instance)
+now.until(targetDate, 'weeks');              // → ~32.71 (using Tempo instance)
+
+// 3. Target as a natural-language string expression or ISO string
+now.until('2026-12-25', 'days');             // → 229    (ISO date string)
+now.until('christmas', 'days');              // → 229    (natural-language string expression)
+now.until('afternoon', 'minutes');           // → 420    (natural-language string expression)
+
+// 4. Target as a chained Tempo mutation
+now.until(now.add({ days: 2 }), 'hours');    // → 48     (or 47/49 if crossing a DST transition)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Date-only targets inherit the current time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a target resolves to a date without a time component (e.g. 'christmas', 'tomorrow', 'next friday'), Tempo copies the current time-of-day from the anchor into the target. This means:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'days') → whole number — the time components cancel out exactly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'hours') → whole number — same reason.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'weeks') → fractional — 229 days does not divide evenly into weeks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This matches natural-language intuition: "How many days until Christmas?" expects 229, not 229.43. Targets with an explicit time (e.g. 'afternoon', '9am') produce fractional values if the target time differs from the anchor's current time-of-day.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .since() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the time elapsed since a past date. By default, it returns a human-readable localized string (powered by Intl.RelativeTimeFormat).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const anchor = new Tempo('2026-05-10', { locale: 'en-US' });
+const birthday = new Tempo('1990-05-10');
+
+// 1. Returns localized relative string based on the given unit
+// Note: Tempo uses a compact ('narrow') Intl style by default
+anchor.since(birthday, 'years');  // → "36y ago" (deterministic)
+anchor.since(birthday, 'days');   // → "13,149d ago" (deterministic)
+
+// 2. Pass a custom formatter for natural language output (e.g. "yesterday")
+const yesterday = anchor.add({ days: -1 });
+const autoFormat = new Intl.RelativeTimeFormat('en-US', { numeric: 'auto' });
+anchor.since(yesterday, { unit: 'days', intl: { relativeTimeFormat: autoFormat.format.bind(autoFormat) } }); // → "yesterday"
+
+// 3. Returns an ISO 8601 Duration String if no unit is provided
+anchor.since(birthday);     // → "-P36Y..."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Duration Object (EDO) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you call until() (or Tempo.duration()), Tempo returns an Extended Data Object (EDO) representing the exact duration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dur = Tempo.duration('P1Y2M15D');
+console.log(dur.years);   // 1
+console.log(dur.months);  // 2
+console.log(dur.days);    // 15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Intelligent Balancing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Return Types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you call .until() without a unit, it returns a Tempo.Duration object, onto which you can chain .balance() and .format() (see below). If you provide a unit (like 'days'), it returns a primitive JavaScript Number. Calling .balance() on a Number will throw an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes you have a raw number of days (e.g. 365 days) and you want to mathematically "balance" it into larger units (like 1 year). Tempo provides the .balance() method directly on the Duration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When to use .balance()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo injects { largestUnit: 'years' } by default, .until() is usually perfectly balanced out of the box. However, you will still need to chain .balance() in three specific scenarios:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Raw Durations: When you manually construct an unbalanced duration (e.g., Tempo.duration({ days: 365 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Cross-Timezone Math: If you run .until() between two different timezones, Tempo restricts the result to hours to prevent calendar ambiguity. Chaining .balance() forces the rollup into Years/Months.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Nominal Math: When you want to force commercial math ({ nominal: true }) instead of strict calendar math.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strict Calendar Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, .balance() uses a relativeTo anchor to perform perfect calendar math.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // A manually created duration is unbalanced by default: { days: 365 }
+const rawDuration = Tempo.duration({ days: 365 });
+
+// Balance it using an anchor: safely converts it to { years: 1 } (or 11mo 30d if a leap year!)
+const balanced = rawDuration.balance({ relativeTo: '2026-01-01' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nominal (Commercial) Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building SaaS pricing tables or catalog displays, strict calendar math can be frustrating (you don't want a 365-day license to display as "11 months and 30 days" during a leap year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can pass { nominal: true } to mathematically force 365 days = 1 year, 30 days = 1 month, and 7 days = 1 week regardless of the calendar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const commercialDur = Tempo.duration({ days: 365 }).balance({ nominal: true });
+console.log(commercialDur.years); // 1
+console.log(commercialDur.days);  // 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Balancing Downwards (Un-balancing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also force a duration to roll downwards into smaller units by specifying a largestUnit. This is incredibly useful for UI countdown timers (e.g., displaying "48 Hours" instead of "2 Days") or per-diem billing calculations where you need to know exactly how many days are in a specific year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const yearlyLicense = Tempo.duration({ years: 1 });
+
+// Un-balance the year down into exact days (365 or 366 depending on the anchor)
+const exactDays = yearlyLicense.balance({ 
+  largestUnit: 'days', 
+  relativeTo: '2024-01-01' 
+});
+
+console.log(exactDays.days); // 366 (2024 is a leap year!)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting Absolute Durations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once you have a balanced duration, you can instantly render it as a highly localized, plural-aware string using the .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .format() natively uses Intl.DurationFormat (or a robust multi-unit polyfill) to render all non-zero units perfectly into the user's language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Perfect for detailed countdowns or SaaS dashboards!
+const formatted = Tempo.duration({ days: 395, hours: 4 })
+  // 'nominal: true' uses 365d/yr and 30d/mo math, so no relativeTo anchor is needed
+  .balance({ nominal: true })
+  .format();
+
+console.log(formatted); // "1 year, 1 month, and 4 hours" (or localized equivalent)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also define default formatting options globally by adding durationFormat into your Tempo.init configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  intl: {
+    durationFormat: { style: 'short' } // e.g. "1 yr, 1 mth, 4 hr" instead of long-form
+  }
+});
+
+// Now, all format calls will automatically use 'short' display
+const shortDur = Tempo.duration('P1Y1M').format(); // "1 yr, 1 mth"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,38)])])}const g=i(e,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.lean.js new file mode 100644 index 00000000..cc2b67da --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.duration.md.C8tFRYva.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Duration Logic","description":"","frontmatter":{"outline":"deep"},"headers":[],"relativePath":"doc/2-core-concepts/tempo.duration.md","filePath":"doc/2-core-concepts/tempo.duration.md"}'),e={name:"doc/2-core-concepts/tempo.duration.md"};function l(h,s,p,o,r,k){return a(),n("div",null,[...s[0]||(s[0]=[t("",38)])])}const g=i(e,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.js new file mode 100644 index 00000000..2d84258b --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.js @@ -0,0 +1,141 @@ +import{_ as l,o as a,c as n,a2 as i,j as s,a as t}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Smart Formatting Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.format.md","filePath":"doc/2-core-concepts/tempo.format.md"}'),d={name:"doc/2-core-concepts/tempo.format.md"},o={class:"tip custom-block github-alert"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"2.009ex",height:"1.545ex",role:"img",focusable:"false",viewBox:"0 -683 888 683","aria-hidden":"true"};function p(r,e,k,g,y,E){return a(),n("div",null,[e[9]||(e[9]=i(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Formatting Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a powerful token-based formatting engine that goes beyond the standard ISO strings of native Temporal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Standalone Formatting (Zero-Overhead) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you have a native Temporal.ZonedDateTime and want to format it using Tempo's readable tokens, you can use the standalone format function. This allows you to use Tempo's formatting logic without importing the full Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { format } from '@magmacomputing/tempo/format';
+
+const zdt = Temporal.Now.zonedDateTimeISO();
+const str = format(zdt, '{mon} {dd:ord}, {yyyy}'); 
+
+console.log(str); // e.g., "October 24th, 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms and Standalone Formatting: When using format() with native Temporal objects, Terms (tokens starting with #) are not resolved. To use Terms resolution in your format strings, you must either pass a Tempo instance to the format() utility or use the class-based .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Input Types ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine can interpret:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Objects: ZonedDateTime, Instant (auto-projected to ZDT), PlainDate, PlainDateTime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo Instances: Any instance of the Tempo class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Strings: Valid Temporal ISO-8601 strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Defaults: If no object is provided, it defaults to Now in the configured timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Class-Based Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Tempo class, the .format() method is available on every instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('2026-10-24T15:30:00');
+console.log(t.format('display')); // Sat, 24 Oct 2026 (using a named format alias)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Named Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo comes with several pre-configured format aliases. You can also define your own globally during initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    formats: {
+      'fancy': '{mon} the {dd:ord} day of {yyyy}'
+    }
+  }
+});
+
+const t = new Tempo('2026-10-24');
+console.log(t.format('fancy')); // October the 24th day of 2026

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modularity: Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Like the parsing engine, the formatting engine is modular:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VersionFormatting Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo FullBuilt-in. Works out of the box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo CoreOpt-in. You must call Tempo.use(FormatModule) to enable .format().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabling Formatting in Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using @magmacomputing/tempo/core, you must explicitly register the formatting engine:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { FormatModule } from '@magmacomputing/tempo/format';
+
+Tempo.use(FormatModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔠 Supported Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is heavily opinionated. To provide maximum predictability and eliminate common timezone or regional bugs, Tempo strictly defaults to ISO-8601 standards. This means weeks always start on Monday (1), and mathematical bounds (like week-of-year and year-of-week calculations) adhere to the rigorous ISO specification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Dialects & Migration Tempo's formatting engine uses explicit curly braces and consistent lower-case tokens ({yyyy}, {mm}, {dd}) to prevent common cross-ecosystem pitfalls—such as token confusion between calendar year and ISO week-year (in Unicode LDML yyyy is calendar year while YYYY is ISO week-year, whereas in Moment and Day.js YYYY is calendar year while GGGG is ISO week-year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating an existing codebase from Moment, Day.js, or Luxon, the @magmacomputing/tempo-plugin-dialects community plugin provides drop-in support for familiar external masks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+Tempo.init({ dialect: 'moment' });
+
+const t = new Tempo('2026-10-24');
+t.format('YYYY-MM-DD');        // "2026-10-24" (Moment mask)
+t.format('{yyyy}-{mm}-{dd}');  // "2026-10-24" (Native Tempo tokens always work)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For Unicode LDML, POSIX strftime, and dual-mode configuration details, see the Dialects Plugin Documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TokenDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yyyy}4-digit Year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yy}2-digit Year26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {eon}Absolute Year within Era200
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {era}Era Designator (e.g., AD/BC, CE/BCE)AD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yow}ISO Year of Week2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {woy}Zero-padded ISO Week of Year43
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mon}Full Month NameOctober
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mmm}Short Month NameOct
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mm}Zero-padded Month10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dd}Zero-padded Day24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wkd}Full Weekday NameSaturday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {www}Short Weekday NameSat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dow}ISO Day of Week (1=Mon, 7=Sun)6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {doy}Day of Year (1-366)297
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {intl.<prop>}Regional metadata via Intl.LocaleInfo ({intl.region}, {intl.script}, {intl.firstDay}, {intl.direction}, {intl.hourCycle})US, Latn, 7, ltr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hh}Zero-padded Hour (24h)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {h24}Zero-padded Hour synonym (24h)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {h12}Zero-padded Hour (12h) plus meridiem03pm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mer}am/pm meridiem markerpm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mi}Zero-padded Minutes30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ss}Zero-padded Seconds45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ms}Zero-padded Milliseconds (3-digit)123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {us}Zero-padded Microseconds (3-digit)456
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ns}Zero-padded Nanoseconds (3-digit)789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ff}Fractional Seconds (9-digit)123456789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ts}Unix Timestamp1792843200000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dmy}Compact Date (ddmmyyyy)24102026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mdy}Compact Date (mmddyyyy)10242026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ymd}Compact Date (yyyymmdd)20261024
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hms}Compact Time (24h)153045
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {time}Time (24h, or localized format via :locale)15:30:45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {nano}Nanosecond Timestamp1792843200000000000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dim}Total Days in Month (28-31)31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {cen}2-digit Century ({century})20
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {jj}Astronomical Julian Day Number ({julian})2461338
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wom}Week of Month (1-5, aliases {ww:month}, {woy:month})4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz}Time Zone IDAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {cal}Calendar Systemiso8601

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎛️ Token Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can append modifiers to any token using a colon (:) to transform its output. Multiple modifiers can be chained together (e.g., {mon:locale:title}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierTargetDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :<number>NumberPositive integer zero-fill pads numeric tokens (e.g. {ns:6} → 000005); negative integer tail-slices digits from the right (e.g. {yyyy:-3} → 026, {yow:-2} → 26); or slices fractional-second {ff} to precision length (e.g. {ff:1} → tenths, {ff:2} → hundredths){doy:3} → 045, {yyyy:-3} → 026, {ff:1} → 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :rawNumberUnpadded number with no meridiem{h12:raw} → 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :ordNumberUnpadded number with ordinal suffix{dd:ord} → 24th
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :romanNumberConverts integer into Roman numeral representation (supports chaining with :lower){yyyy:roman} → MMXXVI, {mm:roman:lower} → x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :upperStringConverts to uppercase{mer:upper} → PM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :lowerStringConverts to lowercase{mon:lower} → october
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :titleStringConverts to titlecase{mon:locale:title} → Octobre
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :dotsStringInjects periods (useful for abbreviations){mer:lower:dots} → a.m.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :spaceUniversalInjects leading space padding for numeric tokens (e.g. {dd:space} → 5, {doy:3:space} → 5), or a leading space before string/meridiem elements{dd:space} → 5, {h12}:{mi}{mer:space:dots} → 03:30 a.m.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :localeUniversalResolves localized term/month/weekday, adapts {dow:locale} to week start, adapts {woy:locale} / {yow:locale} to locale week rules, adapts {hh:locale} to hourCycle, or transliterates numeric tokens into locale numberingSystem{mon:locale} → octobre, {dow:locale} → 1, {dow:locale:0} → 0, {woy:locale} → 01, {hh:locale} → 03 (in en-US), {yyyy:locale} → ٢٠٢٦ (in ar-EG)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :shortUniversal / StringYields a short or abbreviated style (e.g. {mon:short} → Oct, {yow:short} → 26, {dmy:short} → 241026){mon:short} → Oct, {yow:short} → 26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :longStringYields a full-length style{mon:long} → October
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :compactStringYields a delimiter-free, compact representation{tz:offset:compact} → +1000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :offset{tz}Converts timezone identifier to numeric UTC offset. Supports granular sub-modifiers (:hh, :mi, :ss, :z){tz:offset} → +10:00, {tz:offset:hh} → +10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :zero / :0NumberShifts 1-based counters to zero-indexed ({doy:zero} → 000–365, {dow:zero} → 0–6 Sunday=0, {dow:locale:0} → 0–6 locale week start=0, {mm:zero} → 00–11, {woy:zero} → 00–52, {wom:zero} → 0–4){dow:0} → 6, {dow:locale:0} → 0, {mm:raw:0} → 9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :dayUnit ScopeExpresses time units cumulatively over the day ({ss:day} → 0–86399, {mi:day} → 0–1439, {ms:day}, {ns:day}){ss:day} → 55845
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :weekUnit ScopeExpresses time units cumulatively over the week ({hh:week} → 0–167, {mi:week}, {ss:week}) or day within the week ({dd:week} → 1–7){hh:week} → 135, {dd:week} → 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :monthUnit ScopeScopes counters to the month ({wom} / {woy:month} → 1–5, {dd:month} → 1–31){wom} → 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :yearUnit ScopeScopes counters to the year ({dd:year} → 001–366, {mm:year} → 01–12){dd:year} → 297

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezone Formatting & Extended Offset Variations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz} defaults to the IANA timezone identifier (e.g. Australia/Sydney). Modifiers can be composed seamlessly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Named Styles: {tz:short} → AEST, {tz:long} → Australian Eastern Standard Time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chained Offsets: {tz:offset} → +10:00, {tz:offset:short} → +10, {tz:offset:compact} → +1000.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Granular Offset Components:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:hh} / {tz:offset:hour} → Hour with sign (e.g. +10, -05, +00).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:mi} (and alias :min) → Minutes without sign (e.g. 00, 30).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:ss} (and alias :sec) → Offset including seconds (e.g. +10:00:00, compact {tz:offset:compact:ss} → +100000).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:utc} / {tz:offset:compact:utc} → UTC Z indicator: emits Z for UTC (+00:00), else ISO offset +10:00 (or compact +1000).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Canonical Naming: Sub-modifiers :hh, :mi, :ss, and :utc match Tempo's core time tokens. Modifiers :hour, :min, :sec, and :z are supported synonyms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shorthands & Aliases: LDML aliases ({tz:z}, {tz:zz}, {tz:zzz}) are supported as drop-in shorthands.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,32)),s("div",o,[e[7]||(e[7]=s("p",{class:"custom-block-title"},"TIP",-1)),e[8]||(e[8]=s("p",null,[s("strong",null,"Numeric Zero-Fill Padding, Tail-Slicing & Fractional Precision"),s("br"),t(" You can pass any integer width directly as a modifier (e.g. "),s("code",null,"{doy:3}"),t(", "),s("code",null,"{yyyy:-3}"),t(", "),s("code",null,"{yow:-2}"),t(", "),s("code",null,"{ns:6}"),t(").")],-1)),s("ul",null,[e[5]||(e[5]=s("li",null,[s("strong",null,[t("Positive width ("),s("code",null,"+N"),t(")")]),t(": Zero-pads integers to the specified width. Negative values maintain proper sign formatting (e.g. "),s("code",null,"-5"),t(" with "),s("code",null,":3"),t(" yields "),s("code",null,'"-05"'),t(").")],-1)),s("li",null,[e[2]||(e[2]=s("strong",null,[t("Negative width ("),s("code",null,"-N"),t(")")],-1)),e[3]||(e[3]=t(": Slices the last ",-1)),s("mjx-container",h,[(a(),n("svg",c,[...e[0]||(e[0]=[s("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[s("g",{"data-mml-node":"math"},[s("g",{"data-mml-node":"mi"},[s("path",{"data-c":"1D441",d:"M234 637Q231 637 226 637Q201 637 196 638T191 649Q191 676 202 682Q204 683 299 683Q376 683 387 683T401 677Q612 181 616 168L670 381Q723 592 723 606Q723 633 659 637Q635 637 635 648Q635 650 637 660Q641 676 643 679T653 683Q656 683 684 682T767 680Q817 680 843 681T873 682Q888 682 888 672Q888 650 880 642Q878 637 858 637Q787 633 769 597L620 7Q618 0 599 0Q585 0 582 2Q579 5 453 305L326 604L261 344Q196 88 196 79Q201 46 268 46H278Q284 41 284 38T282 19Q278 6 272 0H259Q228 2 151 2Q123 2 100 2T63 2T46 1Q31 1 31 10Q31 14 34 26T39 40Q41 46 62 46Q130 49 150 85Q154 91 221 362L289 634Q287 635 234 637Z",style:{"stroke-width":"3"}})])])],-1)])])),e[1]||(e[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"N")])],-1))]),e[4]||(e[4]=i(" characters from the right (slice(-N)). Ideal for year variations such as 3-digit year ({yyyy:-3} → '026'), 1-digit year ({yyyy:-1} → '6'), or 2-digit ISO week-year ({yow:-2} / {yow:short} → '26').",17))]),e[6]||(e[6]=s("li",null,[s("strong",null,[t("Fractional seconds ("),s("code",null,"{ff}"),t(")")]),t(": Slices the 9-digit fractional second string to the specified precision length (e.g. "),s("code",null,"{ff:1}"),t(" for tenths, "),s("code",null,"{ff:2}"),t(" for hundredths, "),s("code",null,"{ff:3}"),t(" for milliseconds, "),s("code",null,"{ff:6}"),t(" for microseconds).")],-1))])]),e[10]||(e[10]=i(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specialized Tokens, Calendrical Counters & Designed Composability
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than proliferating one-off tokens for every niche format requirement, Tempo promotes an orthogonal matrix of composable unit scopes (:day, :week, :month, :year) alongside specialized tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Astronomical Julian Day ({jj}, {julian}): Emits continuous 7-digit day count since 4713 BC (2461331 for 2026-10-17, matching Oracle J).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Julian Day vs. Day of Year: {jj} is the astronomical Julian Day number, whereas {dd:year} (or {doy}) is the day of the year (1–366, matching mainframe "Julian dates" like YYYYDDD).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Days in Month ({dim}): Total count of days in the current month (28–31, matching PHP t). (Convenience alias for .zdt.daysInMonth).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Century ({cen}, {century}): 2-digit century number (20 for 2026, matching POSIX %C).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Week of Month ({wom}): 1-based week counter within the month (1–5, matching Oracle W and Unicode LDML W). Semantic aliases: {ww:month}, {woy:month}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calendar Week ({woy:cal}) & v5 Roadmap: Week of year starting on January 1st (01–53, matching Oracle WW). Marked @deprecated Will be superseded by {ww} in v5.0.0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dimensional Time-Scope Modifiers: Compose time units over a specified duration scope:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {ss:day}: Seconds past midnight (0–86399, matching Oracle SSSSS).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mi:day}: Minute of the day (0–1439).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {ms:day}, {ns:day}: Milliseconds and nanoseconds of the day.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {dd:week}: Day of week (1–7, or 0–6 with :zero).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {hh:week}: Hour of the week (0–167).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mi:week}, {ss:week}: Minute and second of the week.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Generalized Zero-Indexing (:zero / :0): Shifts any 1-based numeric counter to 0-based without width collisions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • :zero is the canonical semantic modifier; :0 is its compact shorthand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {doy:zero} / {doy:0}: 000–365 (or {doy:raw:0} → 0–365, matching PHP z).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {dow:zero} / {dow:0}: 0–6 with Sunday = 0 (matching POSIX %w, JavaScript Date.prototype.getDay() parity).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mm:zero} / {mm:0}: 00–11 (or {mm:raw:0} → 0–11, matching JavaScript Date.prototype.getMonth() parity).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {woy:zero} / {woy:0}: 00–52.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {wom:zero} / {wom:0}: 0–4.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implicit Localization Bridge The :short and :long styling modifiers act as an automatic bridge to the browser's native Intl API! By default, core tokens like {mon} or {wkd} run at zero-cost using Tempo's lightning-fast internal enums (yielding English results). If you want a localized string, you don't need to explicitly chain the :locale modifier. Simply using a styling modifier like {mon:long} will automatically translate the string using the instance's configured locale!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Automatic Meridiem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your format string contains {h12} (12-hour clock) but lacks a {mer} token, Tempo will automatically append a {mer} token with the same modifiers as the {h12} token after the last time component to ensure the time remains unambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (If you explicitly want a 12-hour digit without an auto-appended meridiem, use the :raw modifier: {h12:raw})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why {h12} and {h24}? In other date libraries, {hh} could mean 12-hour and {HH} could mean 24-hour time. This is confusing and error-prone. Tempo standardizes {hh} on the default 24-hour expectation, but provides explicit {h12} and {h24} tokens to completely eliminate ambiguity. This keeps all token definitions fully lowercase and semantic, without relying on uppercase variations like {HH}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.format('{h12}:{mi}');           // "03:30pm" (auto-append standard meridiem)
+t.format('{h12:upper}:{mi}');     // "03:30PM" (auto-append modified meridiem)
+t.format('{h12:dots}:{mi}');      // "03:30a.m." (auto-append meridiem with dots)
+t.format('{h12:space:dots}:{mi}');// "03:30 a.m." (auto-append meridiem with leading space)
+t.format('{h12:raw}:{mi}');       // "3:30"    (no meridiem added)
+t.format('{h12:raw}:{mi} {mer}'); // "3:30 am" (manual space + meridiem)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📝 Common Formatting Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Here are a few real-world examples demonstrating how tokens and modifiers can be composed together to build readable sentences and structured strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-05T15:30:00');
+
+// Injecting tokens directly into sentences
+t.format('Today is the {dd:ord} of {mon:title}'); 
+// "Today is the 5th of October"
+
+// Building standard UI formats
+t.format('{wkd}, {mmm} {dd:raw}, {yyyy} @ {h12}:{mi}'); 
+// "Monday, Oct 5, 2026 @ 03:30pm"
+
+// Forcing fully lowercase strings
+t.format('{wkd:lower} afternoon'); 
+// "monday afternoon"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📍 Dynamic Namespace & Spatial Tokens ({namespace.key}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's format engine dynamically resolves bracketed dot-notated tokens ({namespace.key}) against any active plugin namespace or property container on the Tempo instance (such as t.geo, t.finance, t.astro, t.term, or custom attached metadata).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geographic Tokens ({geo.*}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When geographic coordinates or metadata are attached to a Tempo instance (via options.geo, new Tempo('...', { geo: { city: 'Sydney', country: 'AU', lat: -33.8688, lng: 151.2093 } }), or resolved via t.geoLocate()), you can format location fields directly using {geo.<property>} tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TokenDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.city}Locality or City nameSydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.country}ISO Country code or Country nameAU / Australia
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.sphere}Hemisphere (north, south, or equator)south
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.elevation}Altitude / Elevation in meters above sea level42
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.timezone}IANA Timezone resolved from coordinatesAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.<custom>}Any custom metadata key attached to t.geoOpera House

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom & Plugin Namespace Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any namespace plugin mounted via defineNamespace or property object on the instance can be formatted directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Plugin namespace (e.g. tempo-plugin-finance):
+t.format('Fiscal Quarter: Q{finance.fiscalQuarter} ({finance.taxYear})');
+
+// Term plugin (e.g. season or solar terms):
+t.format('Current Season: {term.season} · {geo.city:title}');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modifiers & Graceful Fallback ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All standard formatting modifiers apply seamlessly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.country:upper} → AU
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.city:title} → Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.sphere:upper} → SOUTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For known property namespaces (like geo), if the context is unpopulated or the requested property is missing, the token cleanly resolves to an empty string ('') rather than throwing an exception or printing undefined:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24T15:30:00', {
+  geo: { city: 'Sydney', country: 'AU', lat: -33.869, lng: 151.209 }
+});
+
+t.format('{geo.city}, {geo.country} · {h12}:{mi} {mer}');
+// "Sydney, AU · 03:30 pm"
+
+// Graceful fallback for instances without geo:
+const tNoGeo = new Tempo('2026-10-24T15:30:00');
+tNoGeo.format('Time: {hh}:{mi} [{geo.city}]');
+// "Time: 15:30 []"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Hierarchical Localization ({namespace.key:locale}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using :locale on namespace tokens (e.g. {geo.sphere:locale} or {custom.tag:locale}), Tempo resolves translations from the global registry.locales dictionary using an intuitive, cascading fallback:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Deep Hierarchical Path: locales[lang]?.geo?.sphere?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Leaf Property Scoped: locales[lang]?.sphere?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Flat Word Match: locales[lang]?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Canonical Fallback: If no dictionary match exists, gracefully returns the raw canonical value ("south").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',
+  registry: {
+    locales: {
+      fr: {
+        geo: {
+          sphere: {
+            north: 'nord',
+            south: 'sud',
+            equator: 'équateur',
+          },
+          city: {
+            sydney: 'Sydney (Australie)',
+          },
+        },
+      },
+    },
+  },
+});
+
+const t = new Tempo('2026-10-24', { geo: { city: 'sydney', sphere: 'south' } });
+
+t.format('{geo.sphere:locale}');        // "sud"
+t.format('{geo.sphere:locale:title}');  // "Sud" (modifiers chain seamlessly)
+t.format('{geo.sphere:locale:upper}');  // "SUD"
+t.format('{geo.city:locale}');          // "Sydney (Australie)"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Complex Native Intl Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Tempo's template tokens ({dd}, {mon}, etc.) combined with the :locale modifier are incredibly powerful for structured formats, there are times when you want the full power of the native Intl.DateTimeFormat API for complete, culturally-specific sentence formatting (like Arabic numerals or full-length descriptive dates).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo's philosophy is to "humanize" the rigid Temporal API, you can pass an Intl.DateTimeFormatOptions object directly into the .format() method. While Intl.DateTimeFormat still strictly validates your locales and option values, Tempo catches Temporal mismatch failures for you. It automatically retries formatting using zdt.epochMilliseconds for Temporal/Intl mismatch cases, safely injects the necessary timeZone and calendar metadata, but will explicitly rethrow any withTimeZone or withCalendar failures (e.g. from invalid timezones).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo vs Temporal (Side-by-Side):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const arabicConfig = {
+  locale: 'ar-EG',
+  timeZone: 'Africa/Cairo',
+  weekday: 'long',
+  year: 'numeric',
+  month: 'long',
+  day: 'numeric',
+  numberingSystem: 'arab'
+}
+
+// 🔴 Native Temporal (Strict & Verbose)
+// 1. You must carefully parse the date using the correct Temporal factory.
+// 2. You must manually shift the timezone before formatting, or it throws an exception!
+const nativeStr = Temporal.PlainDateTime
+  .from('2024-12-25T14:30:00')
+  .toZonedDateTime('UTC')
+  .withTimeZone('Africa/Cairo')
+  .toLocaleString('ar-EG', arabicConfig);
+
+// 🟢 Tempo (Humanized)
+// Automatically handles the parsing, shifts constraints, and safely delegates to Intl!
+const tempoStr = new Tempo('2024-12-25 14:30')
+  .format(arabicConfig);
+
+console.log(tempoStr); // "الأربعاء، ٢٥ ديسمبر ٢٠٢٤"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example: Japanese Reiwa Era formatting
+const t = new Tempo('2024-12-25 14:30');
+
+const japaneseConfig = {
+  locale: 'ja-JP-u-ca-japanese',
+  timeZone: 'Asia/Tokyo',
+  calendar: 'japanese',
+  era: 'long',
+  year: 'numeric',
+  month: 'long',
+  day: 'numeric'
+}
+
+console.log(t.format(japaneseConfig));
+// Output: "令和6年12月25日"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Custom Format Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need a completely custom format behavior? You can define dynamic token evaluators in the global registry that receive the zdt (Temporal.ZonedDateTime) instance and a context object, giving you full native access to Intl formatting or custom logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why native ZonedDateTime instead of a Tempo instance? The formatting engine is highly modular and designed to be tree-shakable via the standalone format() utility. By injecting native Temporal objects, custom tokens remain extremely fast, portable, and zero-overhead. If you absolutely need access to Tempo's syntactic sugar inside your token evaluator, you can simply re-wrap the object on the fly: const t = new Tempo(zdt);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+    locale: 'fr-FR',
+    registry: {
+        tokens: {
+            // A simple math-based token
+            'myDay': (zdt) => String(zdt.day - 1),
+            
+            // A deeply localized custom token using native Intl
+            'wkd-fr': (zdt, { config }) => {
+                const dtOptions = config?.intl?.dateTimeFormat ?? {};
+                return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
+            }
+        }
+    }
+});
+
+const t = new Tempo('2024-05-20');
+t.format('{myDay}');  // "19"
+t.format('{wkd-fr}'); // "lundi"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,40))])}const f=l(d,[["render",p]]);export{u as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.lean.js new file mode 100644 index 00000000..3058c96d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.format.md.CnjB55c2.lean.js @@ -0,0 +1 @@ +import{_ as l,o as a,c as n,a2 as i,j as s,a as t}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Smart Formatting Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.format.md","filePath":"doc/2-core-concepts/tempo.format.md"}'),d={name:"doc/2-core-concepts/tempo.format.md"},o={class:"tip custom-block github-alert"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"2.009ex",height:"1.545ex",role:"img",focusable:"false",viewBox:"0 -683 888 683","aria-hidden":"true"};function p(r,e,k,g,y,E){return a(),n("div",null,[e[9]||(e[9]=i("",32)),s("div",o,[e[7]||(e[7]=s("p",{class:"custom-block-title"},"TIP",-1)),e[8]||(e[8]=s("p",null,[s("strong",null,"Numeric Zero-Fill Padding, Tail-Slicing & Fractional Precision"),s("br"),t(" You can pass any integer width directly as a modifier (e.g. "),s("code",null,"{doy:3}"),t(", "),s("code",null,"{yyyy:-3}"),t(", "),s("code",null,"{yow:-2}"),t(", "),s("code",null,"{ns:6}"),t(").")],-1)),s("ul",null,[e[5]||(e[5]=s("li",null,[s("strong",null,[t("Positive width ("),s("code",null,"+N"),t(")")]),t(": Zero-pads integers to the specified width. Negative values maintain proper sign formatting (e.g. "),s("code",null,"-5"),t(" with "),s("code",null,":3"),t(" yields "),s("code",null,'"-05"'),t(").")],-1)),s("li",null,[e[2]||(e[2]=s("strong",null,[t("Negative width ("),s("code",null,"-N"),t(")")],-1)),e[3]||(e[3]=t(": Slices the last ",-1)),s("mjx-container",h,[(a(),n("svg",c,[...e[0]||(e[0]=[s("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[s("g",{"data-mml-node":"math"},[s("g",{"data-mml-node":"mi"},[s("path",{"data-c":"1D441",d:"M234 637Q231 637 226 637Q201 637 196 638T191 649Q191 676 202 682Q204 683 299 683Q376 683 387 683T401 677Q612 181 616 168L670 381Q723 592 723 606Q723 633 659 637Q635 637 635 648Q635 650 637 660Q641 676 643 679T653 683Q656 683 684 682T767 680Q817 680 843 681T873 682Q888 682 888 672Q888 650 880 642Q878 637 858 637Q787 633 769 597L620 7Q618 0 599 0Q585 0 582 2Q579 5 453 305L326 604L261 344Q196 88 196 79Q201 46 268 46H278Q284 41 284 38T282 19Q278 6 272 0H259Q228 2 151 2Q123 2 100 2T63 2T46 1Q31 1 31 10Q31 14 34 26T39 40Q41 46 62 46Q130 49 150 85Q154 91 221 362L289 634Q287 635 234 637Z",style:{"stroke-width":"3"}})])])],-1)])])),e[1]||(e[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"N")])],-1))]),e[4]||(e[4]=i("",17))]),e[6]||(e[6]=s("li",null,[s("strong",null,[t("Fractional seconds ("),s("code",null,"{ff}"),t(")")]),t(": Slices the 9-digit fractional second string to the specified precision length (e.g. "),s("code",null,"{ff:1}"),t(" for tenths, "),s("code",null,"{ff:2}"),t(" for hundredths, "),s("code",null,"{ff:3}"),t(" for milliseconds, "),s("code",null,"{ff:6}"),t(" for microseconds).")],-1))])]),e[10]||(e[10]=i("",40))])}const f=l(d,[["render",p]]);export{u as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.js new file mode 100644 index 00000000..98de2222 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.js @@ -0,0 +1,7 @@ +import{_ as s,o as l,c as o,j as e,a as d,a2 as a}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"🧲 Core Getters","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.getters.md","filePath":"doc/2-core-concepts/tempo.getters.md"}'),i={name:"doc/2-core-concepts/tempo.getters.md"},n={class:"tip custom-block github-alert"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function y(p,t,f,x,m,u){return l(),o("div",null,[t[12]||(t[12]=e("h1",{id:"🧲-core-getters",tabindex:"-1"},[d("🧲 Core Getters "),e("a",{class:"header-anchor",href:"#🧲-core-getters","aria-label":'Permalink to "🧲 Core Getters"'},"​")],-1)),t[13]||(t[13]=e("p",null,[d("The "),e("code",null,"Tempo"),d(" class provides an extensive array of zero-cost getters that allow you to seamlessly read properties from the underlying "),e("code",null,"Temporal"),d(" instance.")],-1)),e("div",n,[t[11]||(t[11]=e("p",{class:"custom-block-title"},"TIP",-1)),e("p",null,[t[4]||(t[4]=e("strong",null,"Zero-Cost Lazy Evaluation",-1)),t[5]||(t[5]=e("br",null,null,-1)),t[6]||(t[6]=d(" Tempo uses a sophisticated proxy-based lazy-evaluation pattern. Accessing a getter (like ",-1)),t[7]||(t[7]=e("code",null,"t.yy",-1)),t[8]||(t[8]=d(") resolves the property on demand, and then overwrites the getter with a static literal. This means the first access is ",-1)),e("mjx-container",r,[(l(),o("svg",c,[...t[0]||(t[0]=[a('',1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[9]||(t[9]=d(" and every subsequent access is raw property access (",-1)),e("mjx-container",g,[(l(),o("svg",h,[...t[2]||(t[2]=[a('',1)])])),t[3]||(t[3]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"0"),e("mo",{stretchy:"false"},")")])],-1))]),t[10]||(t[10]=d(" cost).",-1))])]),t[14]||(t[14]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Native Temporal Gateway ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .zdtTemporal.ZonedDateTimeDirect zero-overhead access to the underlying native Temporal instancet.zdt.daysInMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .zdt getter provides direct, zero-overhead access to the underlying Temporal.ZonedDateTime instance, enabling native Temporal inspections and properties without method call ceremony:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24T15:30:00[Australia/Sydney]');
+
+console.log(t.zdt.daysInMonth);  // 31
+console.log(t.zdt.inLeapYear);   // false
+console.log(t.zdt.offset);       // '+11:00'
+console.log(t.zdt.hoursInDay);   // 24
+console.log(t.zdt.monthCode);    // 'M10'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 Date Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .yynumber4-digit Year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .mmnumberMonth number (1 = Jan, 12 = Dec)10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ddnumberDay of the month (1-31)24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .dimnumberTotal days in the month (28-31; convenience alias for .zdt.daysInMonth)31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .jjnumberAstronomical Julian Day number since 4713 BC2461331
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .erastringLocalized era string'ce', 'bce', 'ad', 'bc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .eonnumberPositive integer year within the current .era2026, 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Days in Month (.dim) vs. Native .zdt.daysInMonth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While .dim is provided as a zero-cost convenience property returning the number of days in the current month (28–31, matching format token {dim} and PHP t), t.zdt.daysInMonth is the native standard property directly available on the underlying Temporal.ZonedDateTime instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Astronomical Julian Day (.jj) vs. Day of Year (.doy)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .jj provides the true astronomical Julian Day Number (an integer day count elapsed since noon UT on January 1, 4713 BC in the proleptic Julian calendar, e.g. 2461331 for 2026-10-17), matching Oracle J and token {jj}. If you need the calendar day within the current year (1–366), use .doy (or format token {doy} / {dd:year}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Time Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .hhnumberHour of the day (0-23)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .minumberMinutes of the hour (0-59)30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ssnumberSeconds of the minute (0-59)45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .msnumberMilliseconds of the second (0-999)123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .usnumberMicroseconds of the millisecond (0-999)456
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .nsnumberNanoseconds of the microsecond (0-999)789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ffnumberFractional seconds representation0.123456789

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ ISO Week & Day Alignments ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .yownumber4-digit ISO week-numbering year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .woynumberISO week number of the year (1-53; canonical, supersedes legacy .ww)43
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .downumberISO weekday number (1 = Mon, 7 = Sun)6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .doynumberDay of the year (1-366)297

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Canonical Getters & v5 Deprecation Path
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To establish a clean, predictable, and collision-free API surface across getters and format tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .woy is canonical for ISO week of the year. The legacy .ww getter is marked @deprecated and will be removed in v5.0.0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .eon is canonical for the positive integer year within the era (supersedes @deprecated .eraYear).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .dd is canonical for the day of the month (supersedes @deprecated .day).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔤 Named String Representations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .monstringFull English month name'October'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .mmmstringShort English month name'Oct'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .wkdstringFull English weekday name'Saturday'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .wwwstringShort English weekday name'Sat'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Regional, Timezone & System Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .tzstringIANA Time Zone ID'Australia/Sydney'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .calstringTemporal Calendar ID'iso8601'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .localestring | string[]Resolved BCP 47 locale'en-AU', ['en-US', 'fr-FR']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .intlTempoIntlNamespaceStructured internationalization namespace (.info for cultural metadata, .locale for native Intl.Locale)t.intl.info.firstDay, t.intl.locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .geoobject | undefinedResolved geographic coordinates (latitude, longitude, elevation, sphere){ latitude: -33.8688, longitude: 151.2093 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .sphere'north' | 'south' | undefinedResolved hemisphere configuration'south'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .tsnumber | bigintUnix timestamp (number for ss/ms/us, bigint for ns)1792843200000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .nanobigintNanoseconds since Unix epoch1792843200000000000n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .isostringStandard ISO 8601 string (RFC 3339) in UTC'2026-10-24T04:30:00Z'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .isValidbooleantrue if the underlying date-time is validtrue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎛️ Metadata Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Beyond date-time properties, the Tempo class also provides read-only getters into its active state and configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .configobjectReturns a proxy to the active configuration, including all resolved inheritance and local overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .termsobjectReturns a dictionary of all registered TermPlugins and their available ranges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .rangesobjectReturns a dictionary of the currently active range key for every registered term (e.g., { 'season': 'summer' }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .parseobjectReturns a shadowed view of the internal parsing state (including anchor, mode, and the AST-like match output).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,21))])}const b=s(i,[["render",y]]);export{k as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.lean.js new file mode 100644 index 00000000..11d75edd --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.getters.md.DNLIMJ-B.lean.js @@ -0,0 +1 @@ +import{_ as s,o as l,c as o,j as e,a as d,a2 as a}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"🧲 Core Getters","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.getters.md","filePath":"doc/2-core-concepts/tempo.getters.md"}'),i={name:"doc/2-core-concepts/tempo.getters.md"},n={class:"tip custom-block github-alert"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function y(p,t,f,x,m,u){return l(),o("div",null,[t[12]||(t[12]=e("h1",{id:"🧲-core-getters",tabindex:"-1"},[d("🧲 Core Getters "),e("a",{class:"header-anchor",href:"#🧲-core-getters","aria-label":'Permalink to "🧲 Core Getters"'},"​")],-1)),t[13]||(t[13]=e("p",null,[d("The "),e("code",null,"Tempo"),d(" class provides an extensive array of zero-cost getters that allow you to seamlessly read properties from the underlying "),e("code",null,"Temporal"),d(" instance.")],-1)),e("div",n,[t[11]||(t[11]=e("p",{class:"custom-block-title"},"TIP",-1)),e("p",null,[t[4]||(t[4]=e("strong",null,"Zero-Cost Lazy Evaluation",-1)),t[5]||(t[5]=e("br",null,null,-1)),t[6]||(t[6]=d(" Tempo uses a sophisticated proxy-based lazy-evaluation pattern. Accessing a getter (like ",-1)),t[7]||(t[7]=e("code",null,"t.yy",-1)),t[8]||(t[8]=d(") resolves the property on demand, and then overwrites the getter with a static literal. This means the first access is ",-1)),e("mjx-container",r,[(l(),o("svg",c,[...t[0]||(t[0]=[a("",1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[9]||(t[9]=d(" and every subsequent access is raw property access (",-1)),e("mjx-container",g,[(l(),o("svg",h,[...t[2]||(t[2]=[a("",1)])])),t[3]||(t[3]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"0"),e("mo",{stretchy:"false"},")")])],-1))]),t[10]||(t[10]=d(" cost).",-1))])]),t[14]||(t[14]=a("",21))])}const b=s(i,[["render",y]]);export{k as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.js new file mode 100644 index 00000000..1137bc62 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.js @@ -0,0 +1,38 @@ +import{_ as i,o as a,c as e,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Interval","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.interval.md","filePath":"doc/2-core-concepts/tempo.interval.md"}'),n={name:"doc/2-core-concepts/tempo.interval.md"};function h(p,s,l,k,r,o){return a(),e("div",null,[...s[0]||(s[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interval ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In the realm of time mathematics, an Interval is a continuous segment of time bounded by two fixed points (a start and an end). While a Duration represents an amount of time (e.g., "5 hours"), an Interval is firmly anchored to the timeline (e.g., "9:00 AM to 2:00 PM").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The official ECMAScript Temporal proposal currently lacks a native Interval type. Tempo bridges this gap by providing a mathematically pure, highly optimized Interval primitive directly in the core package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instantiating an Interval ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access the Interval class either statically through the Tempo namespace (for developer convenience) or as a decoupled named export (for strict tree-shaking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Ergonomic Approach (Attached to Tempo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The easiest way to use Interval is directly from the Tempo class. When instantiated this way, Tempo.Interval automatically intercepts its arguments and parses them through the Tempo constructor. This means you can pass standard strings, Temporal objects, or Date objects directly without wrapping them yourself!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const meeting = new Tempo.Interval(
+  '2026-07-15T14:00:00Z',
+  '2026-07-15T15:00:00Z'
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Purist Approach (Tree-Shakeable Export) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are strictly using native Temporal polyfill objects and want to avoid bundling the entire Tempo class, you can import Interval directly. The pure Interval class has stricter requirements: it relies on simple duck-typing and requires the arguments to be pre-instantiated objects that expose an epochNanoseconds or epoch.ns property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Interval } from '@magmacomputing/tempo';
+import { Temporal } from '@js-temporal/polyfill';
+
+const meeting = new Interval(
+  Temporal.Instant.from('2026-07-15T14:00:00Z'),
+  Temporal.Instant.from('2026-07-15T15:00:00Z')
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Because Interval uses duck-typing to read epochNanoseconds, it natively supports all Temporal point-in-time types (Instant, ZonedDateTime, etc.) and Tempo instances right out of the box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Open-Ended Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both Tempo.Interval and the pure Interval class fully support open-ended time spans! Just pass null for the start or end parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const fromNowOn = new Tempo.Interval(Tempo.now(), null);
+const untilThen = new Interval(null, Temporal.Instant.from('2026-07-15T14:00:00Z'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Interval provides four read-only properties to access its boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    start & end ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These properties return the exact original objects that were used to create the interval (e.g., the Tempo instances or Temporal.ZonedDateTime objects). If the boundary is open-ended, they return null. Use these when you need to format the date, extract calendar components (like month or year), or apply timezone logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startNs & endNs ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These properties return the raw BigInt epoch nanoseconds of the boundaries. If a boundary is open-ended (null), these properties will automatically return the absolute limits of the timeline (Year 1000 or Year 9999).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Performance: When writing custom logic, sorting algorithms, or mathematical overlap checks, always use startNs and endNs! Comparing raw BigInt nanoseconds is thousands of times faster than comparing or mutating Temporal objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set Operations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Interval class provides powerful, lightning-fast methods for evaluating time ranges.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    overlaps() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if two intervals share any common timeline segment. Perfect for finding meeting scheduling conflicts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const bookedSlot = new Tempo.Interval(
+  new Tempo('2026-07-15T14:30:00Z'), 
+  new Tempo('2026-07-15T16:00:00Z')
+);
+
+if (meeting.overlaps(bookedSlot)) {
+  throw new Error('This time slot is already taken!');
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contains() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if a specific point in time falls within the boundaries of the interval (inclusive of start, exclusive of end). Useful for business-hours or promotional-period evaluations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const businessHours = new Tempo.Interval(
+  new Tempo('09:00'), 
+  new Tempo('17:00')
+);
+
+if (businessHours.contains(Tempo.now())) {
+  console.log("We are open!");
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abuts() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if one interval ends exactly when another begins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const shift1 = new Tempo.Interval(new Tempo('09:00'), new Tempo('13:00'));
+const shift2 = new Tempo.Interval(new Tempo('13:00'), new Tempo('17:00'));
+
+shift1.abuts(shift2); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intersection() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a new Interval representing the shared, overlapping time between two intervals. Returns null if they do not overlap. Useful for finding mutual availability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const aliceFreeTime = new Tempo.Interval(new Tempo('09:00'), new Tempo('12:00'));
+const bobFreeTime = new Tempo.Interval(new Tempo('11:00'), new Tempo('14:00'));
+
+const mutualFreeTime = aliceFreeTime.intersection(bobFreeTime);
+// Interval: 11:00 to 12:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    union() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a new Interval that spans the entire duration of two overlapping or abutting intervals. Returns null if there is a gap between them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const shift1 = new Tempo.Interval(new Tempo('09:00'), new Tempo('13:00'));
+const shift2 = new Tempo.Interval(new Tempo('13:00'), new Tempo('17:00'));
+
+const fullDay = shift1.union(shift2);
+// Interval: 09:00 to 17:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,39)])])}const E=i(n,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.lean.js new file mode 100644 index 00000000..ac31621f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.interval.md.ekIBwDM2.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as e,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Interval","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.interval.md","filePath":"doc/2-core-concepts/tempo.interval.md"}'),n={name:"doc/2-core-concepts/tempo.interval.md"};function h(p,s,l,k,r,o){return a(),e("div",null,[...s[0]||(s[0]=[t("",39)])])}const E=i(n,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.js new file mode 100644 index 00000000..8defa45b --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.js @@ -0,0 +1,37 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Mutation & Math","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.mutate.md","filePath":"doc/2-core-concepts/tempo.mutate.md"}'),n={name:"doc/2-core-concepts/tempo.mutate.md"};function h(p,s,l,k,d,r){return a(),t("div",null,[...s[0]||(s[0]=[e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mutation & Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's API for modifying instances is intentionally microscopic. Rather than bloating the prototype with dozens of distinct methods (.addDays(), .subMonths(), .startOf(), etc.), Tempo provides unified utilities that natively support intuitive shorthand strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability & Chainability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All mutation methods in Tempo (.add(), .subtract(), .set()) are strictly immutable. They never modify the original instance. Instead, they evaluate the change and return a new Tempo instance, ensuring absolute safety and allowing for predictable method chaining.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .add() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .add() method returns a new Tempo instance shifted by a specific amount.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = tempo();
+t.add({ days: 5 });           // Adds 5 days

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .subtract() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .subtract() method returns a new Tempo instance shifted backwards by a specific amount.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.subtract({ days: 5 });      // Subtracts 5 days

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also use negative values if you prefer:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.add({ days: -5 });          // Subtracts 5 days
+t.subtract({ days: -5 });     // Adds 5 days (double negative)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .set() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While .add() shifts a date, the .set() method replaces components.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ year: 2026, month: 1 }); // Sets to January 2026

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can snap to boundaries using intuitive property-based { Term: Value } assignment, or use Slick Structural Keys to navigate custom terminology cycles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ month: 'start' });    // Native: Start of the current month
+t.set({ '#qtr': 'end' });     // Slick: End of the current quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Week Boundaries & Dedicated ISO Invariance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, week boundaries follow ISO 8601 (Monday start, Thursday middle, Sunday end):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ week: 'start' });     // Snaps to Monday 00:00:00
+t.set({ week: 'mid' });       // Snaps to Thursday 00:00:00
+t.set({ week: 'end' });       // Snaps to Sunday 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When localeInfo: true is enabled, week boundary calculations adapt to the active locale's regional first day of the week (e.g., Sunday in en-US, Saturday in ar-EG):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('2026-09-16', { locale: 'en-US', localeInfo: true });
+us.set({ week: 'start' });    // Snaps to Sunday 2026-09-13 00:00:00
+us.set({ week: 'mid' });      // Snaps to Wednesday 2026-09-16 00:00:00
+us.set({ week: 'end' });      // Snaps to Saturday 2026-09-19 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To guarantee strict ISO 8601 Monday-to-Sunday boundaries regardless of active locale or localeInfo settings, use dedicated ISO tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    us.set({ isoWeek: 'start' }); // Always snaps to Monday 00:00:00
+us.set({ woy: 'start' });     // Equivalent dedicated ISO week boundary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO Week & ISO Year Mutation (woy, yow) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides full mathematical support for ISO 8601 week calendar coordinates (yow, woy, dow):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Numeric ISO Week Assignment (woy, isoWeek, isoweek) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Assign an ISO week number (1..53) while preserving day of week (dow), time, and ISO year of week (yow):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ isoWeek: 25 });       // Jump to week 25 in the same ISO year
+t.set({ woy: 10 });           // Token equivalent
+t.set({ isoweek: 5 });        // Case-insensitive alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If an ISO year has 52 weeks and 53 is assigned, Tempo gracefully clamps to week 52 without leaking into the next year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Numeric ISO Year Assignment & Shifting (yow, isoYear, isoyear) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Assign or shift the ISO week-numbering year while preserving week-of-year (woy), day-of-week (dow), and wall-clock time:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ yow: 2028 });         // Move to ISO year 2028 (preserves woy, dow, and time)
+t.set({ isoYear: 2029 });     // Descriptive alias
+t.set({ isoyear: 2030 });     // Case-insensitive alias
+
+t.add({ yow: 1 });            // Shift forward 1 ISO year
+t.subtract({ yow: 1 });       // Shift backward 1 ISO year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When shifting from a 53-week ISO year (e.g., 2020) to a 52-week ISO year (e.g., 2021), Week 53 safely clamps to Week 52 while preserving weekday and time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. ISO Year Boundaries (start, mid, end) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snap directly to key ISO year checkpoints:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ yow: 'start' });      // Monday of Week 1 at 00:00:00
+t.set({ yow: 'mid' });        // Thursday of Week 26 at 00:00:00
+t.set({ yow: 'end' });        // Sunday of Week 52/53 at 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snippet shorthand keys (mm, yy, dd) are also supported for boundary snapping:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ mm: 'start' });       // Snaps to start of current month
+t.set({ yy: 'end' });         // Snaps to end of current year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also navigate relative to your current date by using Slick Shorthand operators directly inside the .set() object payload. Use the snippet shorthand keys (yy, mm, ww, dd, wkd, etc.) and provide a string payload containing a directional modifier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+
+// Jump forward two months
+t.set({ mm: '>2' }); // July 20th
+
+// Jump to the next Friday
+t.set({ wkd: '>Fri' }); // May 24th

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because .set() processes keys in insertion order, you can now effortlessly combine absolute assignments and Slick shifts in a single pass to build complex boundaries:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Jump 2 months forward, find the next Friday, and set the time to 10:30 AM
+const t2 = t.set({ 
+  mm: '>2', 
+  wkd: '>Fri', 
+  hour: 10, 
+  minute: 30 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ ESLint sort-keys Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because mixed object payloads execute strictly in the order they are defined, you must be careful if you use aggressive automated linters (like ESLint's sort-keys auto-fixer). If your linter alphabetically re-orders your properties, your math will execute in the wrong order! If your codebase forces alphabetical object keys, stick to chaining: t.set({ mm: '>2' }).set({ wkd: '>Fri' }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 Why can't I use Slick modifiers on timezones (tz)?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changing a timezone (tz or timeZone) does not traverse the timeline—it merely changes the local representation of the exact same absolute moment in time. Because no temporal displacement occurs, applying directional Slick modifiers (like >) to a timezone is logically invalid and unsupported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chainability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because all mutations return a new instance, you can safely chain .add() and .set() methods together to perform complex temporal logic in a single, readable line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const endOfQ1 = t
+  .set({ year: 'start' })     // Snap to January 1st
+  .add({ months: 3 })         // Shift forward 3 months (to April 1st)
+  .subtract({ days: 1 })      // Step back exactly one day (March 31st)
+  .set({ month: 'end' });     // Snap to March 31st at 23:59:59.999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relational vs. Navigation Shifting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using custom terminology plugins (like Fiscal Quarters or Seasons), Tempo provides two distinct shorthand styles for mutation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Navigation Mode (String) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use a string to jump to a specific boundary. This relies on chronological momentum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set('#qtr.>q1');              // Snaps to the start of the next Q1
+t.add('#timeOfDay.>afternoon'); // Jumps to the start of the next Afternoon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Relational Mode (Object) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use an object to shift by a specific semantic step while preserving your relative position in the cycle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.add({ '#qtr': 1 });           // Shift forward 1 quarter, preserving progress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are 20 days into Q1, relational shifting will put you exactly 20 days into Q2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: For deeper details on cycle preservation and directional operators, see the Shorthand Engine Reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,59)])])}const E=i(n,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.lean.js new file mode 100644 index 00000000..e9eca1c2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.mutate.md.pL4xn7XU.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Mutation & Math","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.mutate.md","filePath":"doc/2-core-concepts/tempo.mutate.md"}'),n={name:"doc/2-core-concepts/tempo.mutate.md"};function h(p,s,l,k,d,r){return a(),t("div",null,[...s[0]||(s[0]=[e("",59)])])}const E=i(n,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.js new file mode 100644 index 00000000..e1c49135 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.js @@ -0,0 +1,126 @@ +import{_ as l,o as t,c as n,a2 as e,j as s,a}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Smart Parsing Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.parse.md","filePath":"doc/2-core-concepts/tempo.parse.md"}'),h={name:"doc/2-core-concepts/tempo.parse.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},r={tabindex:"0"},d={style:{"text-align":"left"}},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(E,i,y,u,m,F){return t(),n("div",null,[i[14]||(i[14]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Parsing Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's strongest feature is its flexible, natural-language parsing engine. While native Temporal is strictly ISO-only, Tempo can interpret a vast range of human-friendly date and time expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Standalone Parsing (Zero-Overhead) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you only need Tempo's "Smart" parsing but want to keep your project lightweight, you can use the standalone parse function. This returns a native Temporal.ZonedDateTime without importing the full Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parse } from '@magmacomputing/tempo/parse';
+
+// Returns a native Temporal.ZonedDateTime
+const zdt = parse('May 20, 2026 at 3pm', { timeZone: 'Australia/Sydney' });
+
+console.log(zdt.toString()); // 2026-05-20T15:00:00+10:00[Australia/Sydney]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why use Standalone Parse? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tree-Shaking: Your bundler can skip the entire Tempo class and its associated methods, significantly reducing your bundle size.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Native: Perfect for projects that already use native Temporal objects but need a friendlier input layer for users.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict by Default: The standalone function defaults to mode: 'strict', ensuring that it won't "guess" if the input is ambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms and Standalone Parsing: Standalone parse() supports all standard natural language patterns but does not resolve Global Terms or aliases unless they are part of the core pattern registry. For full Term-dispatch and instance-aware resolution, use the Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Standalone vs. Class-Based ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is important to understand the trade-offs when using the lightweight parse() function:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureStandalone parse()new Tempo() Class
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Return TypeNative Temporal.ZonedDateTimeTempo Instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fluent API❌ Native Temporal methods only✅ .add(), .set(), .format(), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Validation❌ No .isValid property✅ Track success via .isValid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    State❌ One-off (Stateless)✅ Persistent instance configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins❌ Bypasses class-level plugins✅ Full support for .ticker(), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Config❌ Configuration per call only✅ Configure once via Tempo.init()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Standalone Parse for server-side processing or background tasks where bundle size is the priority. Use the Tempo Class for UI-heavy applications that need advanced formatting and mutation chains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Class-Based Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Tempo class, parsing is handled automatically by the constructor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('May 20, 2026');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine can interpret:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Strings: 2024-05-20T10:00:00Z
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Short Dates: 20-May, May 20 (locale-aware)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relative Strings: next Monday, last Friday, 2 days ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Numbers/BigInt: Unix timestamps in milliseconds or nanoseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Objects: ZonedDateTime, PlainDate, PlainDateTime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical Era Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively supports parsing historical and future dates with era designations such as BC, BCE, AD, and CE. It correctly resolves both trailing (200 BC) and leading (BC 200) formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Era Parsing Assumptions When parsing dates with eras, be aware of the following architectural rules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Implicit Defaults: If no era is explicitly provided in the string, Tempo safely assumes CE (Common Era).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Missing Months/Days: If a historical era string like "200 BC" is parsed without a month or day, Tempo anchors the missing components to January 1st of that astronomical year (i.e., -199-01-01).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calendar Systems: Era parsing and conversion to astronomical years is strictly restricted to the ISO/Gregorian calendar system. This mathematically means 1 BC becomes astronomical year 0, and 200 BC becomes year -199.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📆 Ordinals & Nth Parsing ("3rd Wednesday of October") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,23)),s("p",null,[i[2]||(i[2]=e("Tempo natively supports parsing structured ordinal weekday and ordinal date expressions—using both numeric (1st, 2nd, 3rd) and written word ordinals (first, second, tenth, last, current)—in deterministic ",17)),s("mjx-container",p,[(t(),n("svg",o,[...i[0]||(i[0]=[e('',1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[3]||(i[3]=a(" time with zero network overhead.",-1))]),i[15]||(i[15]=e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Numeric Ordinal Weekdays
+new Tempo('3rd Wednesday of October');        // 3rd Wed in Oct of anchor/current year
+new Tempo('1st Thursday of November 2026');   // 1st Thursday of November 2026
+
+// Written Ordinal Weekdays (backed by Tempo.enums.ORDINAL)
+new Tempo('first Wednesday of October');      // 1st Wed in Oct
+new Tempo('second Friday of November');       // 2nd Fri in Nov
+new Tempo('last Monday of May');              // Last Mon in May
+
+// Ordinal Dates
+new Tempo('15th day of May');                 // 15th day of May
+new Tempo('1st day of 2026');                 // 1st day of 2026
+new Tempo('last day of the month');           // Last day of anchor/current month

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Written ordinals are powered by the extensible Tempo.enums.ORDINAL enum (@magmacomputing/tempo/enums), providing built-in mappings for current (0), first (1) through tenth (10), and last (-1). Custom ordinals can be registered globally via Tempo.init({ registry: { ordinals: { eleventh: 11 } } }) (or Enum.extend(Tempo.enums.ORDINAL, ...)) or per-instance via new Tempo(date, { registry: { ordinals: { eleventh: 11 } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 When to use Native Ordinal Parsing vs. @magmacomputing/tempo-plugin-ai (parseAI) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,3)),s("table",r,[i[13]||(i[13]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Input Type & Scenario"),s("th",{style:{"text-align":"left"}},"Recommended Approach"),s("th",{style:{"text-align":"left"}},"Key Advantage")])],-1)),s("tbody",null,[s("tr",null,[i[10]||(i[10]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Structured Expressions"),s("br"),a("(e.g. "),s("code",null,'"3rd Wednesday of Oct"'),a(", "),s("code",null,'"1st day of next month"'),a(")")],-1)),i[11]||(i[11]=s("td",{style:{"text-align":"left"}},[s("strong",null,[a("Native "),s("code",null,"Tempo"),a(" Parsing")])],-1)),s("td",d,[s("strong",null,[i[6]||(i[6]=a("Deterministic ",-1)),s("mjx-container",k,[(t(),n("svg",c,[...i[4]||(i[4]=[e('',1)])])),i[5]||(i[5]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[7]||(i[7]=a(" Speed",-1))]),i[8]||(i[8]=s("br",null,null,-1)),i[9]||(i[9]=a("Zero API latency, zero token costs, 100% offline processing.",-1))])]),i[12]||(i[12]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Free-Form / Conversational Text"),s("br"),a("(e.g. "),s("code",null,'"Schedule a call on the third Wednesday after my trip ends"'),a(")")]),s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"tempo-plugin-ai"),a(" ("),s("code",null,"parseAI"),a(")")])]),s("td",{style:{"text-align":"left"}},[s("strong",null,"LLM Natural Language Reasoning"),s("br"),a("Extracts context and conversational intent before passing dates to Tempo.")])],-1))])]),i[16]||(i[16]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Always prefer native Tempo parsing for form inputs, search inputs, and predictable UI date controls. Reserve @magmacomputing/tempo-plugin-ai for conversational chat interfaces or unstructured email/document text processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎭 Structured Mask & Wildcard Parsing ({format: '...'}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can parse strictly structured templates with braced tokens and {*} wildcards without crafting custom regexes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Braced structured format masks
+new Tempo('24-10-2026', { format: '{dd}-{mm}-{yyyy}' });
+
+// With non-capturing wildcard {*}
+new Tempo('Recorded on 15 Sep 2026 at server-01', { 
+  format: '{*} on {dd} {mmm} {yyyy} at {*}' 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Dialects & Migration Tempo's formatting and parsing engine uses consistent lower-case tokens ({yyyy}, {mm}, {dd}) to prevent common pitfalls—such as the subtle year-end shift between calendar year (yyyy) and ISO week-year (YYYY).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating an existing codebase or prefer familiar external formatting standards (such as Luxon, Moment, or POSIX strftime), the @magmacomputing/tempo-plugin-dialects community plugin provides drop-in support:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-dialects/install';
+
+// Parse using external masks
+const t = new Tempo('2026-10-24', { format: 'YYYY-MM-DD', dialect: 'moment' });
+
+// Or via the Luxon convenience shim
+const t2 = Tempo.fromFormat('2026-10-24', 'yyyy-MM-dd');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For full token specifications and multi-candidate parsing fallbacks, see the Dialects Plugin Documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔢 Numeric & Epoch Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides robust support for parsing Unix timestamps (Epochs). Unlike standard Date.parse, Tempo can interpret epochs in multiple units and handles both Number and BigInt types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unit Selection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo treats numbers as milliseconds. You can configure this via the timeStamp option:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Default (milliseconds)
+new Tempo(1715900000000).format('{yyyy}-{mm}-{dd}'); // 2024-05-16
+
+// Seconds
+new Tempo(946684800, { timeStamp: 'ss' }).yy; // 2000
+
+// Microseconds / Nanoseconds
+new Tempo(1715900000000000n, { timeStamp: 'us' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Epoch Detection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parsing engine automatically detects shorter numeric strings (9-10 digits) as valid Epoch candidates when a non-default unit (like 'ss') is configured. This ensures that second-based timestamps like 946684800 are correctly interpreted as timestamps rather than being passed to the layout engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fractional Precision ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo supports fractional numeric inputs across all units with nanosecond precision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 1.5 (seconds mode) resolves to 1.5 seconds (1500ms).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 100.25 (milliseconds mode) resolves to 100 milliseconds and 250 microseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modularity: Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parsing engine is modular. Depending on which version of Tempo you are using, you may need to explicitly enable it:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VersionSmart Parsing Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo FullBuilt-in. Works out of the box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo CoreOpt-in. You must call Tempo.use(ParseModule) to enable natural language support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabling Smart Parsing in Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using @magmacomputing/tempo/core, the constructor only supports basic ISO strings by default. To enable "next Tuesday" style parsing, you must extend it:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { ParseModule } from '@magmacomputing/tempo/parse';
+
+Tempo.use(ParseModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Internationalization, TimeZone & Locale ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses your configuration to intelligently parse ambiguous dates and foreign languages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TimeZone & Offset Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively supports human-readable timezone abbreviations (e.g. AEST, PST, EST, CET, JST) as well as explicit GMT / UTC offset designators (e.g. 'Aug 6, 16:16 GMT+10', 'August 6, 16:16 AEST', 'UTC-5').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Default Layout Positioning & Collisions By default, Tempo's built-in layouts expect timezone offsets and abbreviations to follow the date/time payload. This design prevents leading abbreviations from colliding with 3-letter month names (such as MAR for March vs. Marshall Islands Time).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registering a Custom Leading Timezone Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your application processes custom log files or legacy data streams that position timezone designators at the start (e.g. "PST 8 Aug 10:30"), you can register a custom layout using {tz} alongside {dt} and {tm}. The {tz} token accepts both timezone offset designators (+10:00, Z, GMT+10) and registered timezone abbreviations (such as AEST, PST, EST):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    layouts: {
+      leadingTz: '{tz}{sep}+{dt}{sep}+{tm}'
+    }
+  }
+});
+
+const t = new Tempo('PST 8 Aug 10:30');
+console.log(t.tz); // 'America/Los_Angeles'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    US-Style Dates (MM/DD/YYYY) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you parse a numeric string like 04012026, Tempo uses your timeZone to decide if it means April 1st (US) or 4th of January (UK/AU).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo achieves this by dynamically checking if your current timeZone is associated with a locale that prefers Month-Day ordering (like en-US). It uses the Intl.Locale.prototype.getTimeZones() API where available, and maintains a robust hardcoded fallback list for environments (like Node.js CI or non-ICU environments) where the full Intl API is not present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('04012026', { timeZone: 'America/New_York' }); // Apr 1
+const au = new Tempo('04012026', { timeZone: 'Australia/Sydney' }); // Jan 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing "Ambiguous" Digits (6 vs 8) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When processing numeric-only strings, the length determines the ambiguity rules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A 6-digit string is always validated as compact time first (hhmiss) regardless of timeZone. Only if time validation fails does Tempo try compact date layouts (ddmmyy or mmddyy).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An 8-digit string is checked as a compact date first, with month-day-year vs day-month-year decided by the active Region/timeZone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To avoid ambiguity completely, prefer separators whenever you control the input format (e.g., 2026-04-01, 04/01/2026, or 01/04/2026).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manual Resolution Override ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want to bypass the timezone detection, you can explicitly force the parser to use Month-Day logic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Force MDY parsing
+const t = new Tempo('04/01/2023', { monthDay: true }); 
+
+// Force DMY parsing
+const t3 = new Tempo('04/01/2023', { monthDay: { active: false } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Customizing the MONTH_DAY Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The global MONTH_DAY registry defines the default rules for detection. You can augment this to support additional custom regions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  monthDay: {
+    locales: ['en-CA'], // Add Canada to the MDY preference list
+    timezones: {
+      'en-CA': ['America/Toronto', 'America/Vancouver']
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalized Parsing (Locales) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo can be instructed to automatically generate language-specific parsing rules based on your locale. This enables parsing of translated months, weekdays, and relative events out-of-the-box!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can provide either a single locale string or an array of locales to parse multiple languages simultaneously:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ locale: ['fr-FR', 'es-ES'] });
+
+// Natively understand French, Spanish, AND English dates!
+new Tempo('15 fevrier 2026');   // parses as "15 February 2026" (French)
+new Tempo('15 febrero 2026');   // parses as "15 February 2026" (Spanish)
+new Tempo('vendredi');          // parses as the closest "Friday"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cross-Locale Collisions: In a multi-lingual lexer, if two languages share the exact same abbreviation/word for different dates (e.g. if "mai" meant May in French but March in another language), the parser will resolve a collision using "Last-One-Wins" logic based on your array order. The language that appears last in the locale array takes priority. Be deliberate in your array ordering to safely prioritize your primary language fallback!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works & Accent Normalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When non-English locales are provided, Tempo automatically uses the native Intl API to pre-generate lists of Months, Weekdays, and Relative terms ("yesterday", "today", "tomorrow").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It also automatically normalizes and strips accents from these generated rules. This means that if a user types fevrier (without the accent), it will still successfully fuzzy-match against the strictly translated février.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Current Limitations (What is NOT Available) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Intl provides a robust foundation for month and weekday translations, there are limits to auto-localization:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Units: Words representing duration units ("days", "weeks", "months", "hours") inside natural language strings are currently English-only.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Grammar Structure: The parser expects sequences matching standard English formats (e.g., [value] [unit] [affix]). Highly inflected languages or completely different phrase structures might fail to parse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To bridge these gaps, you can register Custom Aliases (see below) or define custom localized keywords in registry.modifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Localized Parsing Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo allows you to localize term modifiers (like next, last, this) by defining them in the registry.modifiers configuration. This lets you seamlessly mix localized terms into your relative string parsing and even use them in the # shorthand navigation engine!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',                // Natively translates months & weekdays
+  registry: {
+    modifiers: {
+      '>': ['prochain', 'suivant'],
+      '<': ['dernier', 'passé'],
+      '=': ['ce', 'cette']
+    }
+  }
+});
+
+new Tempo('next Friday');         // English always works natively
+new Tempo('vendredi prochain');   // Pure French localized string!
+new Tempo('#qtr.dernier');        // Localized shorthand navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Aliases (Events & Periods) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can teach the parser new words or entire foreign phrases to bridge translation gaps:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',
+  registry: {
+    events: {
+      // Map a full foreign phrase directly to an English-equivalent relative string
+      'le lendemain': 'tomorrow',
+      // Or standard static events
+      'launch': '2026-12-01',
+      'party': () => 'next Friday 8pm'
+    }
+  }
+});
+
+const t1 = new Tempo('le lendemain'); // Parses accurately to tomorrow
+const t2 = new Tempo('party');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧠 Functional Alias Context ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Functional Alias Context is a powerful API for creating dynamic, self-referential date definitions. Within an alias function, this provides access to the AliasContext instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.set(input): Reset the context to a specific date/time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.add(duration): Add a Temporal-style duration (e.g. 'P1D').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.toNow(): Align context with current system time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.zdt (or this.toDateTime()): Resolve the context to a Temporal.ZonedDateTime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.yy / this.mm / this.dd: Access current date components.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.hh / this.mi / this.ss: Access current time components.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.tz / this.cal / this.locale / this.sphere / this.config: Access instance metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example: Dynamic 'meeting' alias
+'meeting': function() {
+    return this.set('2026-05-20').add({ hours: 1 }); // Resolves to 2026-05-20T01:00:00
+},
+'bedtime': function() {
+    return this.set('22:00').zdt; // or .toDateTime()
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: Complex Functional Alias ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    events: {
+      // Resolve "bedtime" to 10pm on the same day
+      'bedtime': function() {
+        return this.set({ hour: 22, minute: 0, second: 0 });
+      },
+      // Resolve "meeting" to 2 hours after whatever was just parsed
+      'meeting': function() {
+        return this.add({ hours: 2 });
+      }
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📍 Geographic Context & Coordinates (geo Option) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When constructing a Tempo instance or calling parse(), you can supply a geo object directly in the options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24 15:30', {
+  geo: {
+    lat: -33.8688,
+    lng: 151.2093,
+    city: 'Sydney',
+    country: 'Australia'
+  }
+});
+
+console.log(t.geo?.latitude);  // -33.869 (rounded to 3 decimals)
+console.log(t.geo?.longitude); // 151.209
+console.log(t.sphere);         // 'south'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Normalization & Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo applies strict validation and standardization to all incoming coordinate payloads with zero external network dependencies:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Boundary Validation: Coordinates outside physical Earth limits (-90° ≤ lat ≤ 90°, -180° ≤ lng ≤ 180°) are strictly rejected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3-Decimal Precision: Coordinates are rounded deterministically to 3 decimal places (≈ 111 m resolution at the equator), eliminating sensor noise and storage cache fragmentation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic Hemisphere Inference: The hemisphere ('north', 'south', or 'equator') is automatically deduced from latitude, recognizing the ±0.001° equatorial band.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Access: Normalized geographic metadata is accessible on the instance via t.geo (recursively frozen GeoConfig) and t.sphere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Performance: The Master Guard ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a "Scan-and-Consume" engine called the Master Guard. This allows it to check your input string against dozens of patterns (weekdays, months, custom events) in a single pass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In version 2.9.0, the Master Guard has been optimized with a Versioned Registry. The engine now tracks a #version counter on the alias registry, ensuring that the guard's pattern list is only rebuilt when a mutation actually occurs. This provides near-instant validation for high-volume parsing tasks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,82))])}const T=l(h,[["render",g]]);export{b as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.lean.js b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.lean.js new file mode 100644 index 00000000..f69b88b5 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_2-core-concepts_tempo.parse.md.DjDPsHhD.lean.js @@ -0,0 +1 @@ +import{_ as l,o as t,c as n,a2 as e,j as s,a}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Smart Parsing Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/2-core-concepts/tempo.parse.md","filePath":"doc/2-core-concepts/tempo.parse.md"}'),h={name:"doc/2-core-concepts/tempo.parse.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},r={tabindex:"0"},d={style:{"text-align":"left"}},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(E,i,y,u,m,F){return t(),n("div",null,[i[14]||(i[14]=e("",23)),s("p",null,[i[2]||(i[2]=e("",17)),s("mjx-container",p,[(t(),n("svg",o,[...i[0]||(i[0]=[e("",1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[3]||(i[3]=a(" time with zero network overhead.",-1))]),i[15]||(i[15]=e("",3)),s("table",r,[i[13]||(i[13]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Input Type & Scenario"),s("th",{style:{"text-align":"left"}},"Recommended Approach"),s("th",{style:{"text-align":"left"}},"Key Advantage")])],-1)),s("tbody",null,[s("tr",null,[i[10]||(i[10]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Structured Expressions"),s("br"),a("(e.g. "),s("code",null,'"3rd Wednesday of Oct"'),a(", "),s("code",null,'"1st day of next month"'),a(")")],-1)),i[11]||(i[11]=s("td",{style:{"text-align":"left"}},[s("strong",null,[a("Native "),s("code",null,"Tempo"),a(" Parsing")])],-1)),s("td",d,[s("strong",null,[i[6]||(i[6]=a("Deterministic ",-1)),s("mjx-container",k,[(t(),n("svg",c,[...i[4]||(i[4]=[e("",1)])])),i[5]||(i[5]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[7]||(i[7]=a(" Speed",-1))]),i[8]||(i[8]=s("br",null,null,-1)),i[9]||(i[9]=a("Zero API latency, zero token costs, 100% offline processing.",-1))])]),i[12]||(i[12]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Free-Form / Conversational Text"),s("br"),a("(e.g. "),s("code",null,'"Schedule a call on the third Wednesday after my trip ends"'),a(")")]),s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"tempo-plugin-ai"),a(" ("),s("code",null,"parseAI"),a(")")])]),s("td",{style:{"text-align":"left"}},[s("strong",null,"LLM Natural Language Reasoning"),s("br"),a("Extracts context and conversational intent before passing dates to Tempo.")])],-1))])]),i[16]||(i[16]=e("",82))])}const T=l(h,[["render",g]]);export{b as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.js new file mode 100644 index 00000000..bbc1d723 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.js @@ -0,0 +1 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as l,C as i,o as a,c as r,j as e,a as t,E as u}from"./chunks/framework.DNL3hc5c.js";const v=JSON.parse('{"title":"Plugin Ecosystem","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/ecosystem.md","filePath":"doc/3-extending-tempo/ecosystem.md"}'),m={name:"doc/3-extending-tempo/ecosystem.md"};function d(p,o,c,g,y,f){const n=i("CatalogList");return a(),r("div",null,[o[0]||(o[0]=e("p",null,[e("img",{src:s,alt:"Tempo Plugin"})],-1)),o[1]||(o[1]=e("h1",{id:"plugin-ecosystem",tabindex:"-1"},[t("Plugin Ecosystem "),e("a",{class:"header-anchor",href:"#plugin-ecosystem","aria-label":'Permalink to "Plugin Ecosystem"'},"​")],-1)),o[2]||(o[2]=e("p",null,"Tempo's functionality can be easily extended through community plugins. Because of Tempo's unique core architecture, plugins add exactly 0 bytes to the bundle size of developers who do not use them.",-1)),o[3]||(o[3]=e("p",null,"Browse the live catalog below to discover extensions for scheduling, calendar math, astronomical events, and more.",-1)),u(n),o[4]||(o[4]=e("hr",null,null,-1)),o[5]||(o[5]=e("div",{class:"tip custom-block"},[e("p",{class:"custom-block-title"},"Submit Your Own Plugin!"),e("p",null,"Have you built something amazing for Tempo? We want to see it!"),e("p",null,[t("You can have your own packages listed in this live catalog. Simply build your extension using "),e("code",null,"definePlugin()"),t(" or "),e("code",null,"defineTerm()"),t(" and publish it to NPM with the "),e("code",null,'"tempo-plugin"'),t(" keyword. Open an Issue on our GitHub repository with a link to your package, and we'll review it for inclusion in the global registry!")])],-1))])}const x=l(m,[["render",d]]);export{v as __pageData,x as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.lean.js new file mode 100644 index 00000000..bbc1d723 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_ecosystem.md.CVsJ_cls.lean.js @@ -0,0 +1 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as l,C as i,o as a,c as r,j as e,a as t,E as u}from"./chunks/framework.DNL3hc5c.js";const v=JSON.parse('{"title":"Plugin Ecosystem","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/ecosystem.md","filePath":"doc/3-extending-tempo/ecosystem.md"}'),m={name:"doc/3-extending-tempo/ecosystem.md"};function d(p,o,c,g,y,f){const n=i("CatalogList");return a(),r("div",null,[o[0]||(o[0]=e("p",null,[e("img",{src:s,alt:"Tempo Plugin"})],-1)),o[1]||(o[1]=e("h1",{id:"plugin-ecosystem",tabindex:"-1"},[t("Plugin Ecosystem "),e("a",{class:"header-anchor",href:"#plugin-ecosystem","aria-label":'Permalink to "Plugin Ecosystem"'},"​")],-1)),o[2]||(o[2]=e("p",null,"Tempo's functionality can be easily extended through community plugins. Because of Tempo's unique core architecture, plugins add exactly 0 bytes to the bundle size of developers who do not use them.",-1)),o[3]||(o[3]=e("p",null,"Browse the live catalog below to discover extensions for scheduling, calendar math, astronomical events, and more.",-1)),u(n),o[4]||(o[4]=e("hr",null,null,-1)),o[5]||(o[5]=e("div",{class:"tip custom-block"},[e("p",{class:"custom-block-title"},"Submit Your Own Plugin!"),e("p",null,"Have you built something amazing for Tempo? We want to see it!"),e("p",null,[t("You can have your own packages listed in this live catalog. Simply build your extension using "),e("code",null,"definePlugin()"),t(" or "),e("code",null,"defineTerm()"),t(" and publish it to NPM with the "),e("code",null,'"tempo-plugin"'),t(" keyword. Open an Issue on our GitHub repository with a link to your package, and we'll review it for inclusion in the global registry!")])],-1))])}const x=l(m,[["render",d]]);export{v as __pageData,x as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.js new file mode 100644 index 00000000..614383a5 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.js @@ -0,0 +1,76 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Creating a Custom Plugin","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.extension.md","filePath":"doc/3-extending-tempo/tempo.extension.md"}'),h={name:"doc/3-extending-tempo/tempo.extension.md"};function l(e,s,p,k,d,r){return a(),n("div",null,[...s[0]||(s[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creating a Custom Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Term Plugins are excellent for providing static, memoized data (like astrological signs or fiscal quarters), a general Plugin allows you to fundamentally enhance the Tempo class with entirely new methods and behaviors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide will teach you the "Tempo-way" of authoring a custom plugin by building a classic, real-world example: The Business Days Plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adding a group of properties?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building a plugin that adds multiple related properties or methods (like .finance.taxYear and .finance.fiscalQuarter), you should use the defineNamespace factory instead! It automatically lazy-loads your methods and prevents prototype pollution. 👉 Read the Namespace Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Goal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We want to add an .addBusinessDays() method to the Tempo instance that adds or subtracts a specific number of working days (defaulting to 1), skipping weekends automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-05-22'); // Friday
+console.log(t.addBusinessDays(2).format('{www}')); // Output: 'Tue'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The definePlugin Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The safest and most efficient way to author a plugin is using the definePlugin factory. This handles the internal registration automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // src/index.ts
+import { definePlugin, type TempoPlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+export const BusinessDaysPlugin: TempoPlugin = definePlugin({
+  name: 'BusinessDaysPlugin',
+  install(TempoClass) {
+    // Plugin implementation goes here!
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Extending the Prototype ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add an instance method, you extend the TempoClass.prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability is King

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is strictly immutable. When authoring an instance method that modifies the date, never mutate this. Instead, use the core methods (like this.add or this.set) which automatically generate and return a fresh, isolated clone for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's implement our .addBusinessDays() logic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const BusinessDaysPlugin: TempoPlugin = definePlugin({
+  name: 'BusinessDaysPlugin',
+  install(TempoClass) {
+    TempoClass.prototype.addBusinessDays = function(days: number = 1) {
+      let next = this;
+      const direction = days >= 0 ? 1 : -1;
+      let remaining = Math.abs(days);
+      
+      // Loop using the underlying Temporal API data
+      // dayOfWeek: 1 = Monday ... 7 = Sunday
+      while (remaining > 0) {
+        next = next.add({ days: direction });
+        
+        // Only count Monday-Friday as a valid jump
+        if (next.dow <= TempoClass.WEEKDAY.Fri) {
+          remaining--;
+        }
+      }
+      
+      // Return the new clone! (Tempo's native .add() already guarantees a fresh instance)
+      return next;
+    };
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Notice how we used the next.dow getter to easily read the Day Of Week? Tempo instances have many lightweight getters (like .yy, .mm, .dd, .hh) built-in.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    However, if you ever need to calculate advanced calendar math (like dayOfYear, daysInMonth, or weeksInYear), you can drop into this.zdt (or this.toDateTime()) to access the raw, underlying Temporal.ZonedDateTime object with zero method call ceremony.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. TypeScript Module Augmentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using TypeScript (highly recommended), your IDE will not know about .addBusinessDays() until you augment the Tempo interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You must declare this augmentation in the same file that exports your plugin:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // src/index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+// ... (plugin implementation) ...
+
+// Inform TypeScript that the core Tempo class now has this method
+declare module '@magmacomputing/tempo/core' {
+  interface Tempo {
+    addBusinessDays(days?: number): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Packing it as a Configurable Module ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes, you want your plugin to accept options (e.g., passing in a custom array of public holidays to skip). To do this, wrap your definePlugin call in a standard factory function:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export type BusinessDayOptions = {
+  skipHolidays?: boolean;
+};
+
+export const BusinessDaysPlugin = (pluginOptions: BusinessDayOptions = {}): TempoPlugin => {
+  return definePlugin({
+    name: 'BusinessDaysPlugin',
+    install(TempoClass) {
+      TempoClass.prototype.addBusinessDays = function(days: number = 1) {
+        let next = this;
+        const direction = days >= 0 ? 1 : -1;
+        let remaining = Math.abs(days);
+        
+        while (remaining > 0) {
+          next = next.add({ days: direction });
+          if (next.dow <= TempoClass.WEEKDAY.Fri) {
+            // We can now use 'pluginOptions' in our logic!
+            if (!pluginOptions.skipHolidays /* || !isHoliday(next) */) {
+               remaining--;
+            }
+          }
+        }
+        
+        return next;
+      };
+    }
+  });
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consuming the Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Your users can now import and register your plugin elegantly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { BusinessDaysPlugin } from 'my-business-days-plugin';
+
+Tempo.use(BusinessDaysPlugin({ skipHolidays: true }));
+
+const t = new Tempo();
+const nextBiz = t.addBusinessDays(2);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need something more complex?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you need to build advanced scheduling engines, AsyncGenerators, or precision arithmetic tools that you plan to distribute commercially, check out our Plugin Ecosystem ↗ for inspiration, or contact Magma Computing Solutions for professional plugin development.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,30)])])}const o=i(h,[["render",l]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.lean.js new file mode 100644 index 00000000..1f4a5414 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.extension.md.DTm8-Lvc.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Creating a Custom Plugin","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.extension.md","filePath":"doc/3-extending-tempo/tempo.extension.md"}'),h={name:"doc/3-extending-tempo/tempo.extension.md"};function l(e,s,p,k,d,r){return a(),n("div",null,[...s[0]||(s[0]=[t("",30)])])}const o=i(h,[["render",l]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.js new file mode 100644 index 00000000..1b28e7bb --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.js @@ -0,0 +1,20 @@ +import{_ as e,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Layout Patterns Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.layout.md","filePath":"doc/3-extending-tempo/tempo.layout.md"}'),l={name:"doc/3-extending-tempo/tempo.layout.md"};function d(n,t,o,r,p,c){return s(),i("div",null,[...t[0]||(t[0]=[a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layout Patterns Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's parsing engine is driven by regular expression patterns and named capture-groups. By understanding and extending these layouts, you can teach Tempo to understand entirely new terminology, formats, and relative units.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What is a Snippet? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Snippet is a pre-defined regex pattern that can be combined with other snippets to create a Layout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What is a Layout? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Layout is a string that combines pre-defined Snippets and strings. When you provide a layout to Tempo, it is translated into an anchored, case-insensitive Regular Expression used to match and extract date-time values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Snippets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snippets represent specific date or time units. When arranged in a layout, they form the blueprint for the parser:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SnippetDescriptionRegex Match (approx)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yy}Year (2 or 4 digits)([0-9]{2})?[0-9]{2}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mm}Month (01-12, Jan-Dec, etc.)01-12 or names
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dd}Day (01-31)01-31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hh}Hour (00-24)00-24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mi}Minute (prefixed by :):[0-5][0-9]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ss}Second (prefixed by :):[0-5][0-9]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ff}Fraction (prefixed by .)\\.[0-9]{1,9}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wkd}Weekday (Mon-Sun)Name strings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {era}Historical era markerBC, a.d., c.e., etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz}Time zone designatorZ, ±hh:mm, GMT+10, or abbreviation (AEST, PST)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {sep}Separator character/, -, ., ,, or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mod}Modifier and count+, -, next, prev
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {unt}Time unitsyear(s), day(s), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {evt}Event aliasxmas, nye, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {per}Period aliasmidnight, noon, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {sfx}Time-pattern suffixT {tm} Z
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {brk}Zone/Calendar brackets[UTC][u-ca=iso8601]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {www}Short weekday nameMon, Tue, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {nbr}Numeric value or word1, two, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {afx}Relative affixago, hence, from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Composite Snippets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dt}: Matches a date (e.g., {dd}{sep}{mm}) OR an event alias {evt}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {tm}: Matches a time (e.g., {hh}{mi}) OR a period alias {per}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Built-in Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeyLayoutDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dtm({dt}){sfx}?{brk}?Calendar/event and clock/period
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dmy{www}?{dd}{sep}?{mm}({sep}{yy})?{sfx}?{brk}?Day-month(-year)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mdy{www}?{mm}{sep}?{dd}({sep}{yy})?{sfx}?{brk}?Month-day(-year)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ymd{www}?{yy}{sep}?{mm}({sep}{dd})?{sfx}?{brk}?Year-month(-day)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ye{mod}?{yy}{era}Explicit year and era (e.g., 200 BC)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ey{mod}?{era}{sep}?{yy}Explicit leading era and year (e.g., BC 200)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unt{nbr}{sep}?{unt}{sep}?{afx}Relative duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Customizing Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can supply your own parsing tokens to Tempo globally via Tempo.init() or locally per-instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    layouts: {
+      'myCustomFormat': '{dd}{sep}?{mm}{sep}?{yy}'
+    }
+  }
+});
+
+const t = new Tempo('20-05-2024'); // Parsed using 'myCustomFormat'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Escaping Regex Meta-Characters in Custom Delimiters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layout strings are compiled directly into regular expressions by the Tempo engine. If your custom layout uses non-standard separators that are regex meta-characters (such as *, |, +, ?, ., ^, $), you must escape them in layout strings (e.g., \\\\*, \\\\|) or pass a pre-compiled RegExp object with escaped delimiters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ Incorrect: '*' is interpreted as a regex quantifier
+Tempo.init({ registry: { layouts: { starDate: '{mm}*{dd}*{yy}' } } });
+
+// ✅ Correct: escape meta-characters in layout strings
+Tempo.init({ registry: { layouts: { starDate: '{mm}\\\\*{dd}\\\\*{yy}' } } });
+
+// ✅ Correct: using RegExp with escaped delimiters
+Tempo.init({ registry: { layouts: { starDate: /(?<mm>\\d{2})\\*(?<dd>\\d{2})\\*(?<yy>\\d{4})/ } } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance-Specific Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('20240520', { registry: { layouts: '{yy}{mm}{dd}' } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced Capture Groups ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When crafting raw regex, the following capture groups are used by the engine:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • yy, mm, dd: Year, Month, Day digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hh, mi, ss, ff: Hour, Minute, Second, Fractional digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mer: Meridiem (am, pm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evt: Event string offset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • per: Period string offset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • unt: Relative unit (e.g., days, weeks)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prototyping with Tempo.regexp() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can use the static Tempo.regexp() method to "preview" how a layout string will be compiled by the engine. This is useful for testing custom regex logic before applying it to your configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Expands {dd}, {sep}, {mm}, etc. into a final anchored RegExp
+const regex = Tempo.regexp('{dd}{sep}{mm}{sep}{yy}');
+
+console.log(regex.source); 
+// Output (illustrative): ^((?<dd>...)(?<sep>...)(?<mm>...)(?<sep_1>...)(?<yy>...))$

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & LLM Layout Prompting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When prompting AI assistants (Cursor, GitHub Copilot, ChatGPT, Claude) to write custom Tempo regular expression snippets and layout extensions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ingest AI Rules: Provide the assistant with our official llms.txt rules by referencing @https://tempo.magmacomputing.com.au/llms.txt in Cursor or pasting llms.txt context into ChatGPT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit Token Request: Ask the LLM to use Tempo's standard snippet tokens ({yy}, {mm}, {dd}, {hh}, {mi}, {ss}, {tz}) rather than raw, un-anchored regular expressions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Example AI Prompt:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "Using https://tempo.magmacomputing.com.au/llms.txt, register a custom layout for strings like '20-05-2024' using Tempo.init({ registry: { layouts: { ... } } }) and snippet tokens."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Professional Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your project involves specialized terminology, complex financial calendars, or legacy application log formats, the Magma Computing Solutions team offers professional services to design and test custom Tempo Layouts optimized for your business needs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Contact us at Magma Computing Solutions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,33)])])}const y=e(l,[["render",d]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.lean.js new file mode 100644 index 00000000..ce3f94ad --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.layout.md.BkxWkK6_.lean.js @@ -0,0 +1 @@ +import{_ as e,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Layout Patterns Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.layout.md","filePath":"doc/3-extending-tempo/tempo.layout.md"}'),l={name:"doc/3-extending-tempo/tempo.layout.md"};function d(n,t,o,r,p,c){return s(),i("div",null,[...t[0]||(t[0]=[a("",33)])])}const y=e(l,[["render",d]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.js new file mode 100644 index 00000000..fe20f781 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.js @@ -0,0 +1,37 @@ +import{_ as s,o as a,c as e,a2 as t}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"Tempo Modularity","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.modularity.md","filePath":"doc/3-extending-tempo/tempo.modularity.md"}'),n={name:"doc/3-extending-tempo/tempo.modularity.md"};function l(p,i,o,h,r,d){return a(),e("div",null,[...i[0]||(i[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Modularity ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed as a modular library, allowing you to include only the features you need. This reduces the core bundle size and prevents your application from being polluted with unused functionality.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Module Activation Quick Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using module entry points, use this rule of thumb:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. import '@magmacomputing/tempo/<module>' (side-effect import): auto-registers that module. You usually do not need Tempo.use(...) for the same module.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. import { SomeModule } from '@magmacomputing/tempo/<module>' (named import): requires explicit activation via Tempo.use(SomeModule).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Tempo.init() is primarily for baseline configuration and initial discovery. Call it at startup for config; if you load modules later at runtime, use Tempo.use(...) for deterministic activation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Import order is usually only relevant when modules are loaded dynamically/lazily. For deterministic activation in those cases, prefer explicit Tempo.use(...) immediately after import.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo/core: The bare-bones Tempo engine. Includes parsing (standard ISO string or a native Temporal object), basic getters, and internal state management.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo: The "batteries included" version. Includes all standard modules (Duration, Format, Term Registry, Mutate, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { DurationModule } from '@magmacomputing/tempo/duration';
+import { FormatModule } from '@magmacomputing/tempo/format';
+import { MutateModule } from '@magmacomputing/tempo/mutate';
+import { ParseModule } from '@magmacomputing/tempo/parse';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+
+// Individual extension...
+Tempo.use(DurationModule);
+
+// ...or bulk extension!
+Tempo.use(DurationModule, FormatModule, TermsModule, MutateModule, ...);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Modules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Duration Module (@magmacomputing/tempo/duration) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for .until() and .since() instance methods, as well as the static Tempo.duration() factory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Module (@magmacomputing/tempo/format) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for the .format() method and custom layout resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mutate Module (@magmacomputing/tempo/mutate) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for the .add(), .subtract(), and .set() instance methods, enabling time manipulation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parse Module (@magmacomputing/tempo/parse) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Handles string parsing and token extraction. This is included automatically in the full package, but must be explicitly opted-in when using core.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms Module (@magmacomputing/tempo/term) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for semantic Terms like quarter, season, zodiac, and period. There are three ways to enable Terms:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Side-Effect (Standard Activation) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fastest way to enable all standard Terms in a Core environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/term'; // One-line activation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Explicit Module (Uniform Sync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Recommended for consistency with other modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+Tempo.use(TermsModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. The Surgical Strike (Data-Only) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for maximum bundle-size optimization by picking only what you need. Note that specific standard terms have their own dedicated sub-paths natively bundled within the main package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { QuarterTerm } from '@magmacomputing/tempo/term/quarter';
+
+Tempo.use(QuarterTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Modules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can create your own modules to extend Tempo's internal engine or its public API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineModule } from '@magmacomputing/tempo/plugin';
+
+export const MyModule = defineModule((TempoClass, options) => {
+    // Add instance methods
+    TempoClass.prototype.sayHello = function() { return 'Hello!'; };
+    
+    // Add static methods
+    (TempoClass as any).greet = () => 'Greetings!';
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure TypeScript recognizes your new methods without throwing augmentation errors (such as TS2669), you must properly declare the module augmentation in a .d.ts file alongside an explicit import:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // my-module.d.ts
+import '@magmacomputing/tempo';
+
+declare module '@magmacomputing/tempo' {
+    interface Tempo {
+        sayHello(): string;
+    }
+    namespace Tempo {
+        export function greet(): string;
+    }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dual Module Hazard: If you are using @magmacomputing/tempo/core and @magmacomputing/tempo in the same project, ensure you use the development condition or consistent import paths to avoid registering the same classes twice.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ The Registration "Gotcha" ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    There is a subtle but important distinction between how features are activated in Core mode:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use(Module): This is Immediate and Explicit. It applies the module or plugin to the class exactly when the line is executed. This is the recommended pattern for modular applications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init(): Establishes global baseline configuration at application startup and registers plugins specified in the plugins array during initial startup discovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ::: note Startup Initialization Lifecycle: Tempo.init() establishes baseline configuration during application startup. Built-in plugins are registered automatically via static imports in full Tempo (@magmacomputing/tempo), while explicit plugin lists are registered during Tempo.init({ plugins: [...] }). Note that subsequent calls to Tempo.init() re-evaluate and merge configuration options rather than executing as an idempotent no-op. To register additional plugins dynamically after startup, use Tempo.use(...). :::

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,38)])])}const c=s(n,[["render",l]]);export{m as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.lean.js new file mode 100644 index 00000000..2762ffd7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.modularity.md.BgMZMuGP.lean.js @@ -0,0 +1 @@ +import{_ as s,o as a,c as e,a2 as t}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"Tempo Modularity","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.modularity.md","filePath":"doc/3-extending-tempo/tempo.modularity.md"}'),n={name:"doc/3-extending-tempo/tempo.modularity.md"};function l(p,i,o,h,r,d){return a(),e("div",null,[...i[0]||(i[0]=[t("",38)])])}const c=s(n,[["render",l]]);export{m as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.js new file mode 100644 index 00000000..a10a919d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.js @@ -0,0 +1,99 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Creating a Namespace Plugin","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.namespace.md","filePath":"doc/3-extending-tempo/tempo.namespace.md"}'),t={name:"doc/3-extending-tempo/tempo.namespace.md"};function h(p,s,l,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creating a Namespace Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building plugins that provide multiple related features, adding them directly to the Tempo prototype can clutter the root interface and increase the risk of naming collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To solve this, Tempo provides the defineNamespace factory. This allows you to mount an entire suite of related tools under a single property (e.g., Tempo().finance.taxYear).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Lazy-Evaluation Advantage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespaces in Tempo are Lazy-Evaluated Proxies. When a user extends Tempo with your namespace plugin, it adds exactly 0 CPU cycles of overhead to instantiation. Your methods and resolvers are only initialized and executed if the user actually accesses the namespace property on that specific date instance!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The defineNamespace Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's build a finance plugin. We want to add a .finance namespace that provides tools like fiscalQuarter and isFiscalYearStart().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // finance.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+import type { Tempo } from '@magmacomputing/tempo/core';
+
+export const FinanceNamespace = defineNamespace({
+  // 1. Define the property name where this namespace will live on the Tempo instance
+  name: 'finance',
+  
+  // 2. Define the lazy-resolvers
+  resolvers: {
+    // Static properties return values directly
+    fiscalQuarter: (tempo: Tempo): number => {
+      const month = tempo.mm;
+      return Math.floor((month - 1) / 3) + 1;
+    },
+    
+    taxYear: (tempo: Tempo): number => {
+      return tempo.yy;
+    },
+    
+    // Methods return callable functions
+    isFiscalYearStart: (tempo: Tempo): ((startMonth?: number) => boolean) => {
+      const currentMonth = tempo.mm;
+      const currentDay = tempo.dd;
+      return (startMonth: number = 1) => currentMonth === startMonth && currentDay === 1;
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Notice how every resolver receives the current Tempo instance as its first argument? This gives you full access to the date's underlying data (tempo.mm, tempo.add(), etc.) without ever needing to worry about this binding!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Memoized Closure Pattern (Methods with Parameters) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the most powerful features of the defineNamespace architecture is that your resolvers are memoized closures. Because a resolver is only evaluated the very first time the property is accessed on that specific Tempo instance, you can use the outer block to execute expensive setup logic or stash variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's zoom in on the isFiscalYearStart method we defined above:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFiscalYearStart: (tempo: Tempo) => {
+  // 1. SETUP BLOCK (Runs exactly once per Tempo instance)
+  // You can stash variables, run complex mathematical lookups, or build state here!
+  const currentMonth = tempo.mm;
+  const currentDay = tempo.dd;
+
+  // 2. INNER CLOSURE (Runs every time the consumer calls the method)
+  // The consumer can pass their company's fiscal start month (e.g., 7 for July). Defaults to 1.
+  return (startMonth: number = 1): boolean => {
+    return currentMonth === startMonth && currentDay === 1;
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a consumer types t.finance.isFiscalYearStart(7), they are executing that returned inner function to check if the date is July 1st. This pattern allows you to write incredibly performant plugins with zero repeated overhead!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. TypeScript Module Augmentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Just like standard plugins, you must inform TypeScript about your new namespace so developers get full IDE autocomplete:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // finance.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+
+// ... (FinanceNamespace implementation) ...
+
+declare module '@magmacomputing/tempo/core' {
+  interface Tempo {
+    finance: {
+      fiscalQuarter: number;
+      taxYear: number;
+      isFiscalYearStart: (startMonth?: number) => boolean;
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Consuming the Namespace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Developers can now import your plugin, register it once, and enjoy your clean, isolated API!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { FinanceNamespace } from './finance.js';
+
+// Extend the core Tempo engine
+Tempo.use(FinanceNamespace);
+
+const t = new Tempo('2024-07-01');
+
+// Access the static property (Evaluated instantly and memoized!)
+console.log(t.finance.fiscalQuarter); // 3
+
+// Access the callable method (Checking if it's the start of the Australian fiscal year)
+console.log(t.finance.isFiscalYearStart(7)); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Dual Architecture (OOP vs FP) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building a Namespace plugin, you'll naturally face a choice between Object-Oriented Programming (OOP) and Functional Programming (FP).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Namespace (OOP): t.finance.isFiscalYearStart()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pros: Incredible Developer Experience (DX). You get instant IDE autocomplete, and the Tempo object automatically carries your timezone and locale context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Cons: Extending Tempo means the entire namespace is attached to the prototype. It is not fully tree-shakeable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Functional Approach (FP): isFiscalYearStart(t)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pros: 100% tree-shakeable. Developers only import exactly the functions they need. Zero prototype pollution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Cons: Less discoverable. Developers must pass the Tempo object as the first argument manually.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Best of Both Worlds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A world-class plugin doesn't force developers to choose—it provides both! You can write all your logic as pure functions first, and then use defineNamespace to wrap those functions for OOP users.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. The Pure Functions (The FP layer)
+export function isFiscalYearStart(t: Tempo, startMonth: number = 1): boolean {
+    return t.mm === startMonth && t.dd === 1; 
+}
+export function nextTaxYear(t: Tempo): Tempo { ... }
+
+// 2. The Namespace Wrapper (The OOP layer)
+export const FinanceNamespace = defineNamespace({
+    name: 'finance',
+    resolvers: {
+        // We simply wrap our pure functions and inject the 'tempo' context!
+        isFiscalYearStart: (tempo: Tempo) => (startMonth?: number) => isFiscalYearStart(tempo, startMonth),
+        nextTaxYear: (tempo: Tempo) => () => nextTaxYear(tempo)
+    }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because of this interleaving, developers can choose their preferred architecture based on their project needs (e.g. rapid prototyping with t.finance.x vs. strict bundle optimization with isFiscalYearStart(t)).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced: Symbol Namespaces ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building a highly-specialized internal plugin and want to mathematically guarantee zero naming collisions, you can use a Symbol as your namespace key!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // secret.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+import type { Tempo } from '@magmacomputing/tempo/core';
+
+export const InternalTools = Symbol('internal');
+
+export const SecretPlugin = defineNamespace({
+  name: InternalTools,
+  resolvers: {
+    audit: (tempo: Tempo) => () => console.log(\`Audited: \${tempo.format('{yyyy}-{mm}-{dd}')}\`)
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Consumer's code
+import { Tempo } from '@magmacomputing/tempo/core';
+import { FormatModule } from '@magmacomputing/tempo/format';
+// The consumer must import BOTH the Plugin (to extend Tempo) and the Symbol (to access the namespace)
+import { SecretPlugin, InternalTools } from './secret.js';
+
+// Register both modules so tempo.format() is available for the audit method
+Tempo.use(FormatModule, SecretPlugin);
+
+const t = new Tempo();
+t[InternalTools].audit();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbol Tagging Requirement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo enforces a strict tagging policy for security and discovery. If you pass an undescribed Symbol (e.g., Symbol()) as a namespace, the factory will throw a TempoError. You must provide a description (e.g., Symbol('myPlugin')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbol Discovery in the Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a developer calls Tempo.versions to view the loaded plugins, Tempo intelligently translates your Symbol namespaces into standard representations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Symbols (e.g., Symbol('internal')) are reported as @internalNamespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Symbols (e.g., Symbol.for('system')) are reported as @@systemNamespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,37)])])}const g=i(t,[["render",h]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.lean.js new file mode 100644 index 00000000..3b54c711 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.namespace.md.N8lEDe0_.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Creating a Namespace Plugin","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.namespace.md","filePath":"doc/3-extending-tempo/tempo.namespace.md"}'),t={name:"doc/3-extending-tempo/tempo.namespace.md"};function h(p,s,l,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e("",37)])])}const g=i(t,[["render",h]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.js new file mode 100644 index 00000000..3ce7b5d6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.js @@ -0,0 +1,118 @@ +import{_ as s,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Extending Tempo with Plugins","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.plugin.md","filePath":"doc/3-extending-tempo/tempo.plugin.md"}'),t={name:"doc/3-extending-tempo/tempo.plugin.md"};function l(p,i,h,o,r,k){return a(),n("div",null,[...i[0]||(i[0]=[e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extending Tempo with Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed with a "lean core" philosophy. While it provides robust date-time manipulation and parsing out of the box, advanced functionality (like reactive Tickers or domain-specific business logic) is added through a flexible Plugin System.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In the Tempo ecosystem, a Plugin is the universal overarching term for any feature added to the core library. To make authoring plugins easy and consistent, Tempo provides two specialized factory functions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. definePlugin: The standard factory for general-purpose features (e.g., adding prototype instance methods, static tools, or altering configuration).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. defineTerm: A specialized factory exclusively for defining temporal vocabulary constraints (a "Term" is technically just a highly-opinionated "Plugin" focused on date ranges and schedules).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. defineNamespace: A factory for creating lazily-evaluated property landing pads (e.g., Tempo().finance.taxYear).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Naming Convention Standard ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To provide a consistent and intuitive developer experience, the exported symbol of your plugin should use a suffix that directly matches the factory used to construct it. This makes it instantly obvious to consumers how the extension will attach to the Tempo core:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with definePlugin ➡️ [Name]Plugin (e.g., TickerPlugin)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with defineTerm ➡️ [Name]Term (e.g., FiscalTerm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with defineNamespace ➡️ [Name]Namespace (e.g., FinanceNamespace)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (Note: The Module suffix and defineModule factory are strictly reserved for Tempo's core internal injection APIs like ParseModule and should not be used by external plugins.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To register a plugin, choose between explicit registration (Tempo.use) or zero-boilerplate side-effect imports (/install):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Explicit registration (Recommended for production apps & tree-shaking)
+import { Tempo } from '@magmacomputing/tempo/core';
+import { MyPlugin } from './my-plugin.js';
+import { HolidayPlugin } from './my-holiday-plugin.js';
+
+Tempo.use(MyPlugin);
+Tempo.use(HolidayPlugin({ region: 'US-NY' }));
+
+// 2. Zero-boilerplate side-effect registration (Recommended for scripts & REPLs)
+import '@magmacomputing/tempo-plugin-geo/install';
+import '@magmacomputing/tempo-plugin-ai/install';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Creating a Custom Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a dedicated step-by-step guide for developers wishing to author their own general-purpose plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the Custom Plugin Guide (tempo.extension.md) to learn how to:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use the definePlugin factory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Safely extend the TempoClass.prototype
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build a full BusinessDaysPlugin from scratch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Safety (TypeScript) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure your plugin is discoverable by the IDE, use Module Augmentation to extend the Tempo namespace and the Tempo class interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    declare module '@magmacomputing/tempo/core' {
+  namespace Tempo {
+    // 1. Define new types/interfaces here
+    interface HolidayOptions { ... }
+
+    // 2. Add static methods to the Tempo namespace
+    function myStaticMethod(): void;
+  }
+
+  interface Tempo {
+    // 3. Add instance methods to the Tempo class
+    toHoliday(): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Understanding Tempo Versions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo/core (Lite): A bare-bones engine with zero side-effects. This is the recommended choice for production builds and plugin authoring.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo (Full): The "Batteries Included" version which automatically imports and registers all standard modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Avoid Circular Dependencies: When authoring a plugin, never import the Tempo class directly from the Full version (@magmacomputing/tempo). Doing so triggers the library's automatic registration sequence in a recursive loop, which will break your application's initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Use types: import type { Tempo } from '@magmacomputing/tempo/core'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Use the argument: Rely on the TempoClass argument passed into your plugin function for static method access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Use the engine: If you need a class reference (e.g., for instanceof checks), import only from the Lite engine (@magmacomputing/tempo/core).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modern Tempo plugins are designed to be "plug-and-play." By using the definePlugin factory, a plugin registers itself with the global Tempo registry as soon as it's imported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';   // 1. Load the \`lite\` engine
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker'; // 2. Import the plugin
+
+Tempo.init({ 
+  plugins: [TickerPlugin]                             // 3. Register and activate plugin during init
+});
+
+// Ticker is now available on the core Tempo class!
+const pulse = Tempo.ticker(1);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Extension vs Startup Registration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ plugins: [...] }) establishes baseline configuration at startup and performs initial registration of plugins. In full Tempo (@magmacomputing/tempo), standard plugins are registered automatically upon import. To dynamically register custom plugins loaded later at runtime, use Tempo.use(Plugin) directly rather than re-running Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Selective Immobility ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core methods of Tempo (like add, set, format) are protected. The use() system will prevent you from accidentally overwriting these essential behaviors. By standardizing plugins through the Tempo module system, the entire library remains small and fast, while offering unbounded domain-specific customization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Immutability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When adding instance methods that "modify" the date, always follow the Tempo pattern of returning a new instance. Do not mutate this. Rely on the core methods (like this.add()) inside your plugin, as they automatically guarantee a fresh, cloned instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Namespace Respect ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin provides many related methods, consider grouping them under a single namespace property on the instance (e.g., tempo.holiday.isPublic() rather than tempo.isPublicHoliday()). This keeps the root Tempo interface clean and minimizes the risk of naming collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of manually building these namespaces on the prototype, Tempo provides the defineNamespace factory to automate lazy-evaluation. 👉 Read the Namespace Guide to learn more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Error Handling & The Diagnostic Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building plugins that perform complex parsing or logic, follow Tempo's "Fail-fast by Default" principle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Mode (Default): If your plugin encounters a terminal error (e.g., invalid input that cannot be recovered), you should throw a descriptive error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Catch Mode: Respect the user's catch configuration. If this.config.catch is true, instead of throwing, you should log a warning using this.warn() and return a sensible fallback (or the original input).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Dependencies: You are responsible for managing missing configuration keys that your plugin depends on. The core engine will not validate your plugin's specific requirements. If a required config key is missing (e.g., sphere for a Season plugin), either provide a reasonable default fallback value or warn the user explicitly using this.warn(). Do not make assumptions that lead to silent failures.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example within a plugin instance method
+if (errorCondition) {
+  const msg = \`Custom Error: \${details}\`;
+  if (this.config.catch === true) {
+    this.warn(msg);
+    return this; // or a fallback value
+  }
+  throw new Error(msg);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This pattern ensures that Tempo remains robust in production environments while providing strict validation during development.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Unified Logging Hooks (logWarn, logError, logDebug) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins should avoid invoking raw console.warn, console.error, or console.log directly. Instead, import and use the standard logging hooks exported by @magmacomputing/tempo/plugin/sdk:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { logWarn, logError, logDebug } from '@magmacomputing/tempo/plugin/sdk';
+
+// Log operational warnings or errors while passing instance config
+logWarn("MyPlugin: Missing optional coordinate parameters.", this?.config);
+logError(err, this?.config);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing the instance configuration allows Tempo's logging subsystem to automatically respect { silent: true }, custom logger delegates, and debug verbosity levels. Additionally, logError(err, this?.config) automatically throws the error when config.catch is false (the default) and swallows it gracefully when catch: true, eliminating the need for manual if (!config.catch) throw checks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alternative: Standalone Functions (tempo-fns) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The JavaScript ecosystem is divided between two architectural preferences: Chained Fluent APIs (like Tempo Plugins) and Pure Standalone Functions (for aggressive tree-shaking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To support teams that mandate strict 0kb bundle-impacts and functional programming paradigms, Magma Computing provides the @magmacomputing/tempo-fns library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // The Pure, Tree-shakeable approach:
+import { isFirstDayOfMonth } from '@magmacomputing/tempo-fns';
+import { Tempo } from '@magmacomputing/tempo/core';
+
+if (isFirstDayOfMonth(new Tempo('2024-01-01'))) { ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building complex logic, consider whether it belongs as a core Plugin extension, or as a standalone utility in tempo-fns (or a hybrid wrapper of both!).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distributing Your Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To make your plugin available to the community, package it as a standard NPM module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Factories (with Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin requires its own configuration, use definePlugin directly and export the result as a callable PluginFactory. Consumers can then invoke it at registration time with their options, following the Vite / Rollup colocated plugin model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo-plugin-holiday/index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+import type { TempoPlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+export interface HolidayPluginOptions {
+  region?: string;
+  observeWeekendShifts?: boolean;
+}
+
+// Export the options type so consumers get IDE intellisense inside HolidayPlugin({ ... })
+export const HolidayPlugin = definePlugin({
+  name: 'holiday',
+  install(TempoClass, options?: any) {
+    const opts = options as HolidayPluginOptions | undefined;
+    const region = opts?.region ?? 'US-NY';
+    // ... register methods or terms using the resolved options ...
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consumers can then register it using any of the three patterns:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins: [
+  HolidayPlugin,                            // Pattern 0: bare (uses pluginOptions fallback)
+  HolidayPlugin({ region: 'AU-NSW' }),      // Pattern 1: factory closure
+  [HolidayPlugin, { region: 'AU-NSW' }],   // Pattern 2: tuple
+]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Module Aggregator Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin provides multiple related components, wrap them in an aggregator module to provide a uniform activation experience for the user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+import { PluginA } from './plugin.a.js';
+import { PluginB } from './plugin.b.js';
+
+export const MyFeaturePlugin = definePlugin((TempoClass, options) => {
+  TempoClass.use([PluginA, PluginB]);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Commercial & Enterprise Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you require custom commercial plugins, domain-specific extensions, or enterprise-grade features with dedicated support, see our Commercial & Professional Services guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consuming a Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For developers using your plugin, registration can be handled imperatively via use() or declaratively via configuration. As of v4.3.0, Tempo supports three registration patterns:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PatternSyntaxDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0 — BareTickerPluginDefault options; reads from pluginOptions fallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1 — Factory ClosureTickerPlugin({ interval: 1000 })Colocated options injected at call site
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2 — Tuple[TickerPlugin, { interval: 1000 }]Works with any plugin, including third-party

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Imperative Registration (Tempo.use) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For standalone usage, pass the plugin directly to Tempo.use() using any pattern:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+import { HolidayPlugin } from '@magmacomputing/tempo-plugin-holidays';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+// Pattern 0: bare
+Tempo.use(TickerPlugin);
+
+// Pattern 1: factory closure — options colocated at the call site
+Tempo.use(TickerPlugin({ interval: 1000 }));
+
+// Pattern 2: tuple — pairs any plugin with its options
+Tempo.use([HolidayPlugin, { region: 'US-NY' }]);
+
+// Mix and match in a single call:
+Tempo.use(
+  CelestialPlugin,
+  TickerPlugin({ interval: 500 }),
+  [GeoPlugin, { timeout: 5000 }],
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Declarative Configuration (defineConfig / Tempo.init) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All three patterns are supported directly in the plugins array of tempo.config.ts or Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.init({
+  plugins: [
+    CelestialPlugin,                       // Pattern 0: bare
+    TickerPlugin({ interval: 1000 }),      // Pattern 1: factory closure
+    [GeoPlugin, { timeout: 5000 }],        // Pattern 2: tuple
+  ],
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options Precedence (lowest → highest):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. pluginOptions[name] from config (base/shared fallback)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Trailing shared options passed to Tempo.use(PluginA, PluginB, sharedOpts)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Call-site colocated options (Pattern 1 or Pattern 2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. pluginOptions — Legacy / Shared Fallback ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptions remains fully supported as a passive configuration registry. It is the right tool for:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bare-registered plugins that read their config from TempoClass.config.pluginOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lazy / dynamically imported plugins that aren't in the main bundle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enterprise base configs shared via extends across microservices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  plugins: [HolidayPlugin, TickerPlugin],  // bare (Pattern 0)
+  pluginOptions: {
+    holiday: { region: 'US-NY', observeWeekendShifts: true },
+    ticker: { interval: 500 },
+    ai: { mode: 'fallback', timeout: 10000 },  // safe even if 'ai' plugin not imported
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecation Notice: Configuration Dictionaries in \`plugins\`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supplying plain configuration dictionaries directly inside the plugins array (e.g. plugins: [{ holiday: { ... } }]) remains supported for backwards compatibility, but is marked @deprecated in favor of pluginOptions or the new colocated option patterns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bulk Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.use() supports rest parameters and arrays, allowing you to register multiple plugins in a single call. If the last argument is a plain object (and not a plugin/term), it is treated as a shared configuration for all plugins in that batch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Mix and match arrays and individual arguments
+Tempo.use(
+  [PluginA, PluginB], 
+  PluginC, 
+  { debug: 5 } // applied to A, B, and C
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Need Help Writing a Plugin? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you have a complex business requirement or need a high-performance plugin built to professional standards, we can help. Our team can design, implement, and verify custom Tempo plugins tailored to your specific domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Contact Magma Computing Solutions to discuss your requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,84)])])}const c=s(t,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.lean.js new file mode 100644 index 00000000..bcef4fed --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.plugin.md.BzPg5rhy.lean.js @@ -0,0 +1 @@ +import{_ as s,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Extending Tempo with Plugins","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.plugin.md","filePath":"doc/3-extending-tempo/tempo.plugin.md"}'),t={name:"doc/3-extending-tempo/tempo.plugin.md"};function l(p,i,h,o,r,k){return a(),n("div",null,[...i[0]||(i[0]=[e("",84)])])}const c=s(t,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.js new file mode 100644 index 00000000..ffb99ab2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.js @@ -0,0 +1,10 @@ +import{_ as t,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const h=JSON.parse('{"title":"Registries and Dictionaries","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.registry.md","filePath":"doc/3-extending-tempo/tempo.registry.md"}'),o={name:"doc/3-extending-tempo/tempo.registry.md"};function d(r,e,n,l,c,p){return s(),i("div",null,[...e[0]||(e[0]=[a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registries and Dictionaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses internal dictionaries—called Registries—to map string keys to values, functions, or formats. This is how Tempo resolves timezone abbreviations like EST, parses custom month layouts, and translates numbers to words.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By standardizing these data stores under the registry namespace, you can deeply customize how Tempo parses, formats, and understands regional values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Accessing Registries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access active registries using the static Tempo.registry getter. These objects are Read-Only Proxies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+console.log(Tempo.registry.formats);
+// { '{iso}': '{yyyy}-{mm}-{dd}T{hh}:{mi}:{ss}', ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because these registries are frozen proxies, attempting to mutate them directly (e.g., Tempo.registry.formats.custom = '...') will throw an error. This guarantees that internal caches and parser guards remain synchronized.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add or override values, you must use Tempo.use() or Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.use({
+  registry: {
+    formats: {
+      custom: '{yyyy}!!{mm}!!{dd}'
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 TIMEZONE Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a built-in registry of common timezone abbreviations. Most regional aliases map to DST-aware regional IANA zones, not fixed UTC offsets. For example, both est and edt map to America/New_York, which means dates parsed during summer months will automatically adjust to Eastern Daylight Time (-04:00), whereas gmt and utc map to fixed UTC (+00:00). If your application requires a constant, non-shifting offset year-round (e.g. strict UTC-5 without Daylight Saving adjustments), use an explicit fixed offset like "-05:00" or 'Etc/GMT+5' instead of a regional abbreviation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AliasIANA Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    utc/ gmtUTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    est / edtAmerica/New_York
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cst / cdtAmerica/Chicago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mst / mdtAmerica/Denver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pst / pdtAmerica/Los_Angeles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aest / aedtAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    acst / acdtAustralia/Adelaide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    awstAustralia/Perth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nzt / nzst / nzdtPacific/Auckland
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cet / cestEurope/Paris
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eet / eestEurope/Helsinki
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    istAsia/Kolkata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nptAsia/Kathmandu
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jstAsia/Tokyo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can extend this list or override existing aliases using Tempo.use({ registry: { timeZones: { ... } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other Internal Registries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo leverages several other internal data dictionaries to parse and format dates. The formats and locales dictionaries are organized under the registry configuration namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formats: Named format aliases used by the format() engine.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Locales: Translation dictionaries used by the :locale format modifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Events: Custom aliases mapped to specific dates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Periods: Custom aliases mapped to specific times.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Snippets: Reusable Regex patterns mapped to variables for parsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layouts: Composed string patterns mapped to Regex logic for parsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Numbers: Word-to-number dictionaries (e.g., "one" -> 1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinals: Word-to-ordinal offset dictionaries (e.g., "first" -> 1, "last" -> -1, "current" -> 0).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (Note: All dictionaries are consolidated into the registry namespace to separate data from behavior.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registry Merge Contracts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core internal registryUpdate() utility applies an additive-only merge strategy. It deeply merges new keys into the registries but safely preserves existing root keys (preventing accidental overrides of built-in definitions).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you pass an options object to Tempo.use(), it acts differently depending on the data type:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enum/Proxy-Backed Registries: For explicitly wrapped structures (like formats and locales), Tempo.use() can be used to forcefully shadow existing entries, making it the proper tool to change standard behaviors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • General Registries: It does not provide a blanket, universal overwrite mechanism for the entire registry system.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,23)])])}const m=t(o,[["render",d]]);export{h as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.lean.js new file mode 100644 index 00000000..437b81d3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.registry.md.DETutRWD.lean.js @@ -0,0 +1 @@ +import{_ as t,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const h=JSON.parse('{"title":"Registries and Dictionaries","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.registry.md","filePath":"doc/3-extending-tempo/tempo.registry.md"}'),o={name:"doc/3-extending-tempo/tempo.registry.md"};function d(r,e,n,l,c,p){return s(),i("div",null,[...e[0]||(e[0]=[a("",23)])])}const m=t(o,[["render",d]]);export{h as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.js new file mode 100644 index 00000000..b003fb53 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.js @@ -0,0 +1,194 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Tempo Terms","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.term.md","filePath":"doc/3-extending-tempo/tempo.term.md"}'),t={name:"doc/3-extending-tempo/tempo.term.md"};function h(l,s,p,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Overview ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Terms system is Tempo's extensible plugin mechanism for attaching business-logic to a date-time instance, without adding to the profile (memory footprint) of a Tempo object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because a Tempo instance is designed to be as lean as possible, term properties are lazy-loaded: their lookup function is not executed until the property is first accessed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once evaluated, the result is memoised — subsequent reads of the same property return the cached value directly, with no further computation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('25-Dec-2024').term.season     // ← computed on first access, cached thereafter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transparent Discovery: As of v2.0.1, all Term properties are enumerable. While modern console.log environments (like Node.js) will typically display these as [Getter] to preserve laziness, they are visible to property-scanning tools. This means a serializer (like JSON.stringify) or a deep-clone utility will trigger the eager evaluation of every registered Term at once. To prevent terminal noise during these events (e.g., for invalid dates), initialize Tempo with silent: true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What a Term Does ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Term plugin answers a single question:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Where does this Tempo instance sit within a pre-defined date-time range?"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each plugin holds a static list of range boundaries (e.g. the start of each meteorological season) and a define function that is called — with the Tempo instance as its this context — to determine into which boundary the instance falls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin expose two views of that result via the Tempo.term object:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyReturns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.term.<key>A short identifier string (e.g. 'qtr', 'szn', 'zdc')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.term.<scope>The full matching range object, with all metadata fields (e.g. key, day, month, year, sphere, etc.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The <key> and <scope> are defined by the plugin author, where the intent of the <key> is to provide a short identifier value, and the intent of the <scope> is to provide the full matching range object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provided Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The examples given below for Fiscal Quarters and Meteorological Seasons assume a Northern Hemisphere configuration (sphere: 'north'), unless they explicitly state otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    qtr / quarter — Fiscal Quarters ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Divides the calendar year into four fiscal quarters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemisphere-aware: southern-hemisphere configs shift the quarter boundaries by six months.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('15-Feb-2025');
+
+t.term.qtr      // → 'Q1'
+t.term.quarter  // → { key: 'Q1', day: 1, month: 1, fiscal: 2025, sphere: 'north' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('15-Feb-2025', { sphere: 'south' });
+
+t.term.qtr      // → 'Q3'  (southern hemisphere)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    szn / season — Meteorological Seasons ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Maps the current date to the appropriate meteorological season.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemisphere-aware (northern / southern boundaries differ).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('01-Jul-2025');
+
+t.term.szn      // → 'Summer'  (northern hemisphere)
+t.term.season
+// → { key: 'Summer', day: 1, month: 6, symbol: 'Sun', sphere: 'north' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('01-Jul-2025', { sphere: 'south' });
+
+t.term.szn      // → 'Winter'  (southern hemisphere, different boundary dates)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zdc / zodiac — Astrological Zodiac ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines the Western astrological sign for the date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full zodiac scope also includes the Chinese zodiac (animal, element, Yin/Yang) derived from the year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('14-Mar-2025');
+
+t.term.zdc      // → 'Pisces'
+t.term.zodiac
+// → { key: 'Pisces', day: 19, month: 2, symbol: 'Fish', longitude: 330, planet: 'Neptune' }
+
+t.term.zodiac.CN
+// → { animal: 'Snake', traits: 'Wise, intuitive', element: 'Wood', yinYang: 'Yin' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tod / timeOfDay — Daily Time Periods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Classifies the time of day into a named period based on a pre-defined range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeyStarts at
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midnight00:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Early04:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Morning08:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midmorning10:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midday12:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Afternoon15:30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Evening18:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Night20:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('1pm');
+
+t.term.tod      // → 'Midday'
+t.term.timeOfDay   // → { key: 'Midday', hour: 12, group: 'standard' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspecting Registered Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The static Tempo.terms getter returns a read-only list of all registered plugins:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.terms
+// → [
+//     { key: 'qtr', scope: 'quarter',  description: 'Fiscal Quarter' },
+//     { key: 'szn', scope: 'season',   description: 'Meteorological season' },
+//     { key: 'zdc', scope: 'zodiac',   description: 'Astrological Zodiac sign' },
+//     { key: 'tod', scope: 'timeOfDay',   description: 'Daily time period' },
+//   ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Activating Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Tempo Full, all standard Terms are enabled by default. In Tempo Core, you have three ways to opt-in:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Standard Activation (Recommended) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The fastest way to enable all built-in Terms (qtr, szn, zdc, tod).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/term'; // One-line side-effect activation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit Module (Uniform Sync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for projects that prefer explicit dependencies and a uniform API across all features.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+Tempo.use(TermsModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Surgical Opt-in (Maximum Lite) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for maximum bundle-size optimization—you only load the specific Terms you use. Note that specific standard terms have their own dedicated sub-paths natively bundled within the main package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { QuarterTerm } from '@magmacomputing/tempo/term/quarter';
+
+Tempo.use(QuarterTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How to Define a Term Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Term plugin is created using the defineTerm factory function provided by the library (@magmacomputing/tempo/plugin/sdk). This ensures correct type-inference and automatically handles registration during the discovery phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Definition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineTerm, defineRange, getTermRange, resolveCycleWindow } from '@magmacomputing/tempo/plugin/sdk';
+import { enums, type Tempo } from '@magmacomputing/tempo/core';
+
+/** 1. The range boundaries (grouped by sphere) */
+const ranges = defineRange([
+  { key: 'Spring', month: 3,  sphere: enums.COMPASS.North },
+  { key: 'Summer', month: 6,  sphere: enums.COMPASS.North },
+  { key: 'Autumn', month: 9,  sphere: enums.COMPASS.North },
+  { key: 'Winter', month: 12, sphere: enums.COMPASS.North },
+  { key: 'Spring', month: 9,  sphere: enums.COMPASS.South },
+  { key: 'Summer', month: 12, sphere: enums.COMPASS.South },
+  { key: 'Autumn', month: 3,  sphere: enums.COMPASS.South },
+  { key: 'Winter', month: 6,  sphere: enums.COMPASS.South },
+], 'sphere');
+
+/** 2. Resolve the candidate list for the current anchor/context */
+function resolve(t: Tempo, anchor?: any): any[] {
+  const source = anchor ?? t;
+  const sphere = source.sphere ?? t.sphere;
+  const template = ranges[sphere] ?? [];
+  
+  // resolveCycleWindow handle the ±1 year shifting for boundaries
+  return resolveCycleWindow(t, template, anchor);
+}
+
+/** 3. The Plugin Object */
+export const MyRetailSeasonTerm = defineTerm({
+    key: 'rsn',
+    scope: 'retailSeason',
+    description: 'Custom retail seasonal range',
+    ranges,
+
+    /** Optional: Used for multi-cycle discovery & traversals */
+    resolve(this: Tempo, anchor?: any) {
+      return resolve(this, anchor);
+    },
+
+    /**
+     * Determine the current range.
+     * @param keyOnly - if true, return only the identifier string
+     * @param anchor - the specific date-time we are calculating for 
+     */
+    define(this: Tempo, keyOnly?: boolean, anchor?: any) {
+      const list = resolve(this, anchor);
+      return getTermRange(this, list, keyOnly, anchor);
+    }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Range fields ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Range object must include a key and any subset of the date-time fields below.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getTermRange sorts ranges in descending chronological order and returns the first range whose boundary the instance has reached or passed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Sync to Alias Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a Term plugin defines ranges with string-based key values, Tempo automatically synchronizes these keys with the internal Alias Engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Period Scopes: Ranges defined in a period scope (like midnight or morning) are registered as Period Aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Event Scopes: Ranges defined in an event scope are registered as Event Aliases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This synchronization happens during Tempo.use() and Tempo.init(), ensuring that any named range boundaries are immediately available for use in the natural-language parsing engine. For example, if you define a custom Term with a range key "bedtime", you can immediately create a new instance using new Tempo('bedtime').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Range = {
+  key: PropertyKey;                // identifier returned when keyOnly = true
+  year?:   number;
+  month?:  number;
+  day?:    number;
+  hour?:   number;
+  minute?: number;
+  second?: number;
+  group?:  string;                 // categorization marker (e.g. 'fiscal', 'western')
+  [extra: PropertyKey]: any;       // any additional term-dependent metadata (e.g. 'sphere')
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registering the plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use the static Tempo.use() method. This allows you to add Terms dynamically without modifying the library source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { MyRetailSeasonTerm } from './term.myretailseason.js';
+
+// Register the term plugin
+Tempo.use(MyRetailSeasonTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Tempo instance created after that point will have the custom Term available.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Custom Configuration in Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Since Tempo preserves non-standard configuration options in its internal config object, you can use Tempo.init() to provide values that your custom Term plugin can later reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Initialize with a custom 'business' config option
+Tempo.init({ 
+  fiscalYearStart: 7 // e.g., July
+});
+
+// 2. Define a term that uses this custom property
+Tempo.use({
+  key: 'cfy',
+  scope: 'fiscal',
+  description: 'Custom Fiscal Year',
+  define: function(this: Tempo, keyOnly?: boolean) {
+    const startMonth = this.config.fiscalYearStart ?? 1;
+    const isPastStart = this.mm >= startMonth;
+    const year = \`FY\${this.yy - Number(!isPastStart)}\`;
+    
+    return keyOnly
+      ? year
+      : { key: year, year, startMonth };
+  }
+});
+
+const t = new Tempo('2025-02-15');
+console.log(t.term.cfy); // → "FY2024" (because it's before July 2025)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Writing Math-Aware Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To unlock Tempo's advanced Term Traversal (e.g., t.add({ '#quarter': 1 })) and Ticker Syncing, a plugin must provide semantic boundaries (start and end).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The getTermRange Helper ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library provides a specialized helper that calculates these boundaries automatically based on your ranges array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { getTermRange } from '@magmacomputing/tempo/plugin/sdk';
+
+export function define(this: Tempo, keyOnly?: boolean) {
+  // Finds the current range, then injects 'start' and 'end' (as Tempo instances)
+  // into the result object before returning it to the user.
+  return getTermRange(this, ranges, keyOnly);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manual Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you choose not to use getTermRange, you must manually include start and end (as Tempo instances) in your scope object:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return keyOnly ? 'MyTerm' : {
+  key: 'MyTerm',
+  start: this.set({ hour: 0 }),
+  end: this.set({ hour: 23, mi: 59 })
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Cycle Discovery & Traversals (The resolve method) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The define method only returns a single boundary (the one the instance currently falls into). But what happens if a user wants to traverse forward by three boundaries (t.add({ '#rsn': 3 }))? Or what if the Ticker engine needs to discover virtual deadlines across multiple years?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To enable this, your plugin can optionally provide a resolve(anchor) method. This method should return the complete array of boundaries for a given cycle (e.g., all the retail seasons in a given year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When the core engine needs to mathematically "step" through boundaries across multiple years, it repeatedly calls your resolve method with different anchor dates (e.g., shifting the year forward) to discover future/past boundaries seamlessly!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪝 Term Lifecycle Hooks Protocol ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Starting in v4.6.0, Term plugins can participate directly in Tempo's core parsing, arithmetic, boundary snapping, difference calculation, and formatting pipelines via well-known symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of overriding core methods or monkey-patching regex tables, term plugins implement protocol hooks using well-known symbols (Symbol.for), exported under TermHook:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineTerm, TermHook, type TermParseContext, type Tempo } from '@magmacomputing/tempo';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The 6 Lifecycle Hooks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hook SymbolMethod SignatureEngine Trigger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.parse](input: string, context?: TermParseContext) => Tempo | Temporal.ZonedDateTime | undefinedExplicit #term natural string input (e.g. new Tempo('#fiscal.q1'))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.ordinal](groups: Record<string, any>, anchor: Tempo, context?: TermParseContext) => Tempo | Temporal.ZonedDateTime | undefinedAnchored ordinal expressions (e.g. Tempo.from('3rd day of #sprint.2', { anchor }))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.step](unit: string, count: number, tempo: Tempo) => Tempo | undefinedStepping arithmetic via dictionary syntax: t.add({ '#term': n }), t.sub({ '#term': n })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.diff](other: Tempo, unit: string, tempo: Tempo) => number | undefinedDifference calculation: t1.until(t2, '#term'), t1.since(t2, '#term')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.bound](boundary: 'start' | 'mid' | 'end', unit: string, tempo: Tempo) => Tempo | undefinedRange boundary snapping: t.set({ '#term': 'start' }), t.set('#term.mid')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.format](token: string, tempo: Tempo) => string | undefinedCustom token formatting: t.format('{#academic}'), t.format('{#academic:upper}')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Complete Hook Example ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo, defineTerm, TermHook } from '@magmacomputing/tempo';
+
+export const SprintTerm = defineTerm({
+  key: 'sprint',
+  scope: 'sprint',
+  description: 'Two-week development sprint cycle',
+  define() {
+    return {
+      key: 'sprint.1',
+      start: this.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }),
+      end: this.add({ days: 14 })
+    };
+  },
+
+  // 1. Parse: Resolve custom #sprint expressions
+  [TermHook.parse](input, ctx) {
+    if (input === '#sprint.current') {
+      return (ctx?.anchor ?? this).set({ day: 1 });
+    }
+    return undefined;
+  },
+
+  // 2. Ordinal: Handle ordinal offsets
+  [TermHook.ordinal](groups, anchor) {
+    // e.g. "3rd day of #sprint.current" or "penultimate day of #sprint.current"
+    const ord = groups.ord?.toLowerCase();
+    const val = groups.value ?? (ord === 'last' ? 14 : (parseInt(ord, 10) || Tempo.enums.ORDINAL[ord]));
+    if (!val) return undefined;
+    const dayOffset = val < 0 ? 14 + val + 1 : val;
+    if (dayOffset < 1 || dayOffset > 14) return undefined;
+    return anchor.add({ days: dayOffset - 1 });
+  },
+
+  // 3. Step: add/sub sprint blocks
+  [TermHook.step](unit, count, tempo) {
+    return tempo.add({ days: count * 14 });
+  },
+
+  // 4. Bound: Snap to sprint start/end
+  [TermHook.bound](boundary, unit, tempo) {
+    if (boundary === 'start') return tempo.set({ hour: 9, minute: 0, second: 0, millisecond: 0 });
+    if (boundary === 'end') return tempo.add({ days: 14 }).set({ hour: 17, minute: 0, second: 0, millisecond: 0 });
+    return undefined;
+  },
+
+  // 5. Diff: Sprints between two dates
+  [TermHook.diff](other, unit, tempo) {
+    const diffDays = tempo.until(other, 'days');
+    return Math.trunc(diffDays / 14);
+  },
+
+  // 6. Format: Custom sprint format token
+  [TermHook.format](token, tempo) {
+    if (token === '#sprint') {
+      return \`Sprint-\${Math.ceil(tempo.doy / 14)}\`;
+    }
+    return undefined;
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Overhead Guarantee ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All lifecycle hooks are strictly isolated behind the # domain term sigil:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calls to standard ISO date parsing (e.g. new Tempo('2026-10-09')), core unit arithmetic (e.g. t.add({ months: 1 })), and standard formatting (t.format('{yyyy}-{mm}-{dd}')) bypass hook lookups entirely with 0ns overhead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Existing terms that do not implement lifecycle hooks continue to use default range-based dispatching without interruption.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Developer Guide: Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure a custom Term plugin integrates fully with Tempo, follow these guidelines:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Static ranges Export: Always include the ranges property in your defineTerm configuration. This enables programmatic discovery via Tempo.terms and allows the Ticker to automatically calculate next-pulse intervals.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Metadata-First Boundaries: If your plugin handles multiple sets (e.g. hemispheres or cultural calendars), avoid using array indices like ranges[0]. Instead, add marker fields like sphere or group to each range object and use .filter() inside your define function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Memoization Safety: Keep the define function pure. It will only be called once per instance access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Math Readiness: Always use getTermRange or provide boundaries. Without them, users cannot use your Term in add(), set(), or ticker().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Key consistency: It is valid to remap the returned scope key (for example, cfy -> FY2024) when that is the semantic value your Term represents. Be intentional and keep it consistent with your ranges lookup and consumer expectations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Unique Names & Collisions: Keep key and scope globally unique across all registered Terms. Avoid reusing an existing Term key (e.g., another plugin already uses qtr) or scope alias. Current behavior is not ideal for collisions: duplicate Term keys are ignored, while scope alias resolution is order-dependent and can shadow another Term. Treat collisions as unsupported and choose unique names to ensure deterministic behavior.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Semantic Casing: To provide a predictable developer experience, adhere to the following casing standards for your Term and Range fields:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Lower-case: Internal identifiers (Term key and scope) and marker fields (e.g., group, sphere, id).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • CapInit / TitleCase: Presentational identifiers (e.g., Range key or symbol, like 'Q1' or 'Spring'). This ensures t.term.season.key returns a properly capitalized string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Free-form text: Longer descriptive fields (e.g., label, description, trait).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8. IDE Autocomplete (Interface Augmentation): To provide a world-class developer experience, always augment the global TempoTermRegistry interface with your custom keys and payload types. This ensures IDEs can provide strict type-checking and autocomplete when users access t.term.myKey.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // IDE Autocomplete (Interface Augmentation)
+declare module '@magmacomputing/tempo' {
+  interface TempoTermRegistry {
+    rsn: 'Spring' | 'Summer' | 'Autumn' | 'Winter';
+    retailSeason: {
+      key: 'Spring' | 'Summer' | 'Autumn' | 'Winter';
+      symbol: string;
+      // ...
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Best Practices: Idempotency & Side-Effects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Term lookups are memoized (cached) on the instance, the define function must be pure and idempotent. It should only depend on the current Tempo instance state and its configuration (this.config).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Never apply side-effects or modify external state within a Term definition. The function is only guaranteed to run once per instance access; subsequent reads will return the cached value directly without re-executing your logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,90)])])}const g=i(t,[["render",h]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.lean.js b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.lean.js new file mode 100644 index 00000000..dcd47f8e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_3-extending-tempo_tempo.term.md.CEKveWAD.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Tempo Terms","description":"","frontmatter":{},"headers":[],"relativePath":"doc/3-extending-tempo/tempo.term.md","filePath":"doc/3-extending-tempo/tempo.term.md"}'),t={name:"doc/3-extending-tempo/tempo.term.md"};function h(l,s,p,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e("",90)])])}const g=i(t,[["render",h]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.js new file mode 100644 index 00000000..c3edc8f4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.js @@ -0,0 +1,66 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Sandbox Factory Pattern","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/sandbox-factory.md","filePath":"doc/4-advanced-reference/sandbox-factory.md"}'),t={name:"doc/4-advanced-reference/sandbox-factory.md"};function l(p,s,h,o,k,r){return a(),e("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandbox Factory Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.5.0 introduces the Sandbox Factory pattern, allowing for deep isolation of configurations and parsing rules. This is particularly useful in complex applications where different modules may require different date-time aliases or behaviors without polluting the global Tempo namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historically, Tempo.init() modified the global library state. This meant that:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Only one set of custom Event or Period aliases could exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Large applications or libraries using Tempo internally would step on each other's configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Testing multiple configurations required careful cleanup between tests.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.create() returns a derived sandboxed class with its own isolated configuration, registry, and plugin state. Each sandbox inherits from the caller, but runs with independent internal state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lifecycle Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To understand when to use Tempo.create(), it helps to contrast it with the other initialization methods:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init({ options })Concept: Hard-reset to "out-of-the-box" factory defaults, then apply the provided configuration globally. All previous plugins, terms, and custom formats are purged.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use({ options })Concept: Additive mutation. Keep all existing global settings, plugins, and formats intact, but merge in new configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.create({ options }) / Tempo.create(fn) / Tempo.create(options, fn)Concept: Sandbox Factory. Clone the current global state (inheriting all currently loaded plugins and settings), but branch it off into a brand new, isolated class. Any future changes made to this Sandbox will not affect the global Tempo, and vice-versa. Supports both long-lived derived class creation and ephemeral scoped callback execution with deterministic resource disposal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Overloaded Signatures & Usage Modes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.create supports three distinct execution patterns tailored for different application lifecycles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Derived Class Factory (Long-lived sandbox)
+static create(options?: Options): typeof Tempo;
+
+// 2. Scoped Callback Mode (Ephemeral auto-disposed sandbox)
+static create<R>(fn: (sandbox: typeof Tempo) => R): R;
+
+// 3. Configured Scoped Callback Mode (Custom options + auto-disposed sandbox)
+static create<R>(options: Options, fn: (sandbox: typeof Tempo) => R): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 1: Derived Class Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use this mode when building long-lived domain services, multi-tenant app routers, or dedicated modules requiring custom configurations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
+
+// Create a specialized Sandbox for a Financial app
+const FinTempo = Tempo.create({
+  plugins: [FinancePlugin],
+  pluginOptions: {
+    finance: { fiscalYearStart: 7 } // July fiscal year
+  },
+  registry: {
+    periods: {
+      'market-open': '09:30',
+      'market-close': '16:00'
+    }
+  }
+});
+
+// Standard Tempo remains untouched
+const t1 = new Tempo('market-open'); // Error: Unknown alias
+const t2 = new FinTempo('market-open'); // Success: 09:30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 2: Scoped Callback Execution (Tempo.create(fn)) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For unit tests, request-scoped operations, or short-lived calculations, pass an execution callback. Tempo.create invokes your callback with a freshly isolated sandbox and automatically disposes of it when the function completes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+// Synchronous callback: automatically disposed on return
+const season = Tempo.create((sb) => {
+  sb.use(CelestialPlugin);
+  return sb('2026-06-21').term.astronomy.season;
+});
+
+// Asynchronous callback: automatically disposed when the Promise settles
+const result = await Tempo.create({ timeZone: 'Pacific/Auckland' }, async (sb) => {
+  const data = await fetchFlightDeparture();
+  return sb(data.departureTime).format('{full}');
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 3: Explicit Resource Management (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandboxed classes created via Tempo.create() implement the TC39 Disposable protocol (Symbol.dispose). In TypeScript 5.2+ and modern JavaScript runtimes supporting the using keyword, sandboxes can be scoped deterministically to code blocks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CustomPlugin } from './custom-plugin.js';
+
+{
+  using sb = Tempo.create({ discovery: 'ephemeral-batch' });
+  sb.use(CustomPlugin);
+
+  const formatted = sb('2026-05-10').format();
+  console.log(formatted);
+} // sb is automatically disposed here as execution leaves block scope!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Disposal & Memory Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every sandbox class exposes lifecycle disposal mechanisms to prevent memory leaks in high-turnover server environments:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sb[Symbol.dispose](): Purges the sandbox from internal state registries (ClassStates) and deletes the registered discovery symbol slot from globalThis.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sb.isDisposed: Readonly boolean getter indicating whether the sandbox has been cleaned up.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sb = Tempo.create();
+console.log(sb.isDisposed); // false
+
+// Explicitly clean up when finished
+sb[Symbol.dispose]();
+console.log(sb.isDisposed); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Traceability & Collision Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using sandboxes, it's important to know which configuration resolved an input. Tempo now records the source of every match in the parse.result array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hierarchy of Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a conflict occurs (e.g., you redefine "noon"), Tempo resolves it by checking layers from highest priority to lowest priority:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Local (Instance): Options passed to new Tempo(val, options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Sandbox (Factory): Options passed to Tempo.create(options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Plugins: Aliases registered via Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Global Defaults: Built-in aliases like "xmas", "midnight", etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checking the Trace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can inspect the parse.result to see exactly which layer provided the definition:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new FinTempo('market-open');
+console.log(t.parse.result);
+/*
+[
+  {
+    type: "Period",
+    value: "market-open",
+    source: "sandbox", // Resolved from FinTempo (factory/sandbox layer)
+    match: "tm",
+    ...
+  }
+]
+*/

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability & Security ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandboxed classes created via Tempo.create() are protected by the same @Immutable and @Serializable decorators as the base class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Sandbox class itself is hardened against static member modification.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instances of the Sandbox are frozen upon construction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The internal state is stored in a WeakMap, inaccessible to external code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Create Once: Create your application-specific Sandbox once and export it as your primary entry point.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Prefer Sandboxes for Custom Aliases: Avoid modifying the base Tempo class if your app is intended to be used as a library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Use Debug Mode: When developing new aliases, set debug: 'debug' to receive console warnings about naming collisions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,39)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.lean.js new file mode 100644 index 00000000..9b1d1669 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_sandbox-factory.md.CkHhycey.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Sandbox Factory Pattern","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/sandbox-factory.md","filePath":"doc/4-advanced-reference/sandbox-factory.md"}'),t={name:"doc/4-advanced-reference/sandbox-factory.md"};function l(p,s,h,o,k,r){return a(),e("div",null,[...s[0]||(s[0]=[n("",39)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.js new file mode 100644 index 00000000..3f793510 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.js @@ -0,0 +1 @@ +import{_ as i,o as t,c as a,a2 as s}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Debugging & Introspection","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.debugging.md","filePath":"doc/4-advanced-reference/tempo.debugging.md"}'),o={name:"doc/4-advanced-reference/tempo.debugging.md"};function n(r,e,c,l,d,p){return t(),a("div",null,[...e[0]||(e[0]=[s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Debugging & Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo encapsulates complex parsing logic and date-time permutations within an immutable class, understanding why a Tempo instance has arrived at its absolute Temporal.ZonedDateTime value can be critical.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document outlines the various debugging and introspection mechanisms available to help trace and understand Tempo's behavior.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before an instance is even created, you can inspect the static state of the Tempo class to understand the global configuration and available plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.config ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of current global configuration settings that act as the default for all new Tempo instances. This includes properties like the default locale, timeZone, and formatting layouts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.default ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of initial, out-of-the-box defaults that Tempo ships with, unaffected by any modifications made via Global Discovery or Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an array of all currently registered Term plugins. This is useful to verify which plugins have been loaded via Tempo.use().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an array of the available static getters on the Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.parse ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of current global parsing rules. This includes the registries of regex patterns (pattern), snippets, and mapped {event} and {period} definitions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once a Tempo instance is instantiated, you can inspect its internal state to understand how it was constructed and what logic was applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.config ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of configuration settings applied to this instance. This is a composite of the global Tempo.config and any specific Tempo.Options passed during instantiation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.parse.result ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is arguably the most powerful debugging tool within Tempo. The parse.result property contains an array (a history lineage) of all the rule-matches that occurred to produce the current value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo is chainable (e.g., new Tempo('xmas').set({ period: 'afternoon' })), the parse.result array will contain an entry for every step in that chain, detailing:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • type: The interpreted type of the input (e.g., String, Temporal.ZonedDateTimeLike).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: The original argument passed to that step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • match: The specific regex pattern or symbol that successfully matched the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • groups: The resolved components (yy, mm, dd, hh, etc.) extracted from the match.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • anchor: The active reference point used for this specific match. This provides a "breadcrumb" trail during complex parses where the anchor might shift as components are resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.parse.anchor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the initial reference point used for the current parsing operation. This is the baseline "Now" against which relative Terms (like next Monday or ago) are calculated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.term ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a collection containing the evaluated results of all registered Term plugins for this specific instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.fmt ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a collection containing the pre-calculated string outputs for all currently registered formatting codes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primitive Auditing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you simply need to see the value represented in different primitive formats, Tempo implements [Symbol.toPrimitive]:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ${tempo} (String coercion) outputs the ISO8601 string via this.toString().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +tempo (Number coercion) outputs the Unix epoch in milliseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tempo.nano outputs the Unix epoch in nanoseconds formatted as a BigInt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Debugging and Console Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo utilizes a central Diagnostic Engine (replacing the legacy Logify strategy) that respects configuration flags to provide structured output without polluting the console.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The debug Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When instantiating a Tempo, or globally via Tempo.init(), you can pass { debug: 'debug' } in the options object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('next Friday', { debug: 'debug' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When this flag is enabled, Tempo's Diagnostic Engine will output detailed console.debug logs during parsing. These logs provide a deep-dive look into the Parse Engine's resolution logic, including:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The prioritized layout regex patterns evaluated against the string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The raw regex groups extracted (e.g., specific day offsets, localized term mappings).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The intermediate steps in temporal normalization (e.g., resolving aliases, computing time and date).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The absolute temporal coordinates composed before final instantiation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: The Diagnostic Engine evaluates the debug setting before serializing any string interpolations, guaranteeing zero-cost execution overhead for standard users who do not request debug-level diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The catch Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo is designed to be resilient. If it encounters parsing errors or invalid inputs, it will gracefully fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    However, if you want Tempo to throw Error objects instead of swallowing them (useful during development or in strict environments), you can pass { catch: false } in the options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Throws an Error instead of returning a fallback date\nconst t = new Tempo('invalid string', { catch: false });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Fast-Fail (Master Guard) Debugging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a Master Guard to avoid the expensive regex parsing phase for strings that are obviously not date-time inputs. If you find that a string is not being parsed as expected, it's possible that the guard is Rejecting it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Check characters: The guard only allows digits, common symbols (-, :, ., T, Z, /, +, #), space, and standard Latin characters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Use debug: 5: If a string passes the guard but fails the parser, you will see "conformed groups" logs. If you see nothing and the input is returned as-is (falling back to a timestamp interpretation), then the guard likely rejected the string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Invalid String fallback: If the guard rejects a string and it cannot be parsed as a numeric timestamp, it will result in an Invalid instance (see below).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Invalid Instances ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If a Tempo instance completely fails to instantiate (and { catch: false } is not set), it returns an empty object. You can check for this using the isValid property:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();\nif (!t.isValid) {\n    console.error("Tempo failed to initialize properly");\n}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',54)])])}const u=i(o,[["render",n]]);export{g as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.lean.js new file mode 100644 index 00000000..a4cc0359 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.debugging.md.IJqQ10ZR.lean.js @@ -0,0 +1 @@ +import{_ as i,o as t,c as a,a2 as s}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Debugging & Introspection","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.debugging.md","filePath":"doc/4-advanced-reference/tempo.debugging.md"}'),o={name:"doc/4-advanced-reference/tempo.debugging.md"};function n(r,e,c,l,d,p){return t(),a("div",null,[...e[0]||(e[0]=[s("",54)])])}const u=i(o,[["render",n]]);export{g as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.js new file mode 100644 index 00000000..a2b33367 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.js @@ -0,0 +1,51 @@ +import{_ as l,o as t,c as n,a2 as a,j as s,a as e}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Internationalization (Intl) & Locale in Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.intl.md","filePath":"doc/4-advanced-reference/tempo.intl.md"}'),o={name:"doc/4-advanced-reference/tempo.intl.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={tabindex:"0"},p={style:{"text-align":"left"}},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(y,i,E,u,m,F){return t(),n("div",null,[i[27]||(i[27]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalization (Intl) & Locale in Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The locale configuration setting (config.locale) and internationalization subsystem are foundational pillars of the Tempo engine. Because Tempo delegates heavily to native ECMAScript APIs (Intl and Temporal), the locale parameter is responsible for driving three distinct behavioral systems:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ambiguity Resolution (How ambiguous dates are ordered)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-lingual Parsing (How foreign text is lexed)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Auto-localization Formatting (How output strings are generated)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scope & Design Philosophy Tempo focuses strictly on high-performance date-time mathematics, localized calendar heuristics, and temporal token formatting. General-purpose string manipulation (such as Intl.DisplayNames, Intl.Segmenter, or Intl.Collator) is intentionally delegated directly to standard native ECMAScript engines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you initialize Tempo (or let it infer its environment), the locale dictates how it interprets and communicates dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ambiguity Resolution (Date Layout) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When parsing an ambiguous string like 04/05/2024, the engine must decide if it's April 5th (MDY order) or May 4th (DMY order).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses the active locale as a critical piece of metadata to resolve this:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It resolves your locale (e.g. 'en-US' or 'en-GB') to determine the active region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It cross-references the locale's region or language against the internal MONTH_DAY registry to check its preferred layout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If the locale inherently prefers MDY (as in the United States), Tempo dynamically swaps its parsing order to attempt Month-Day-Year patterns before it attempts Day-Month-Year patterns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper details on layout configurations and ambiguous digits, see the Ambiguity Resolution Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-Lingual Parsing (Input) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo parses structural English abbreviations (e.g., Jan, Feb, Mon, Tue). However, Tempo is capable of natively parsing foreign languages by dynamically learning from the runtime environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you nominate a non-English locale (or an array of locales like ['fr-FR', 'es-ES']):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo asks the native ECMAScript Intl API how to spell months, weekdays, and relative events (like "tomorrow" or "yesterday") in the specified languages.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It dynamically compiles new, high-performance Regular Expressions containing these localized abbreviations (and automatically handles accent variations, matching both próximo and proximo).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It injects these patterns into its lexer, allowing Tempo to instantly understand strings like '15 Janvier 2024' or '15 febrero 2024'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// Tempo learns French and Spanish months & weekdays at runtime!
+// Custom relative modifier keywords ('próximo') and noise articles ('el') can be registered in the registry.
+Tempo.init({ 
+  locale: ['fr-FR', 'es-ES'],
+  registry: {
+    modifiers: { '+': ['próximo', 'proximo', 'siguiente'] },
+    ignores: ['el', 'la', 'los', 'las']
+  }
+});
+
+const a = new Tempo('15 janvier 2024');  // Matches French
+const b = new Tempo('el próximo lunes');  // Matches Spanish ("next Monday")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more details on setting up and optimizing international parsing, see Internationalized Parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Formatting (Output) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When generating human-readable output, Tempo uses the locale to ensure the resulting text is culturally accurate. It delegates this heavily to native Intl APIs for extreme performance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • When calling .toLocaleString(), Tempo automatically passes your configured locale to Temporal so that dates and times are correctly formatted for that region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom format masks can leverage :locale modifiers (e.g. {hh:locale}, {time:locale}, {mon:locale}, {geo.sphere:locale}) to apply local hour-cycles, localized month names, spatial hemisphere translations, and numbering system transliteration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regional Calendar & Environment Fallbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo delegates regional calendar metadata (such as firstDay of the week, regional weekend days, and text direction) directly to the ECMAScript Intl.Locale Info API powered by the host runtime's Unicode CLDR/ICU database.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Host Environment & Default Baseline Fallbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modern Runtimes (Node 18.19+, Node 20+, Modern Browsers): Tempo pulls dynamic, fully authoritative CLDR data directly from the host engine for all 250+ world territories (e.g. Sunday start for en-US, Monday start for en-GB, Saturday/Sunday weekend for France, Friday/Saturday for Saudi Arabia).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy or Stripped Environments (Minimal Docker / Older Engines): If running in an environment lacking the native Intl.Locale Info API, Tempo applies a best-effort regional heuristic for major cohorts (like US, Canada, and Middle Eastern locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Default Baseline Settings: If a locale or territory is not covered by these heuristics, Tempo deliberately falls back to standard baseline settings:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • First day of week: Monday (1, matching ISO 8601)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Weekend days: Saturday & Sunday ([6, 7])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Text direction: Left-to-Right ('ltr')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tip for Docker Deployments: When packaging server applications in minimal Linux or Alpine containers, ensure your Node.js runtime has full ICU support (standard official node container images include full ICU by default) so your applications enjoy full native CLDR accuracy across all locales.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Intl.Locale Info & Regional Calendar Integration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo delegates regional calendar and cultural metadata directly to the ECMAScript Intl.Locale Info API (such as Intl.Locale.prototype.getWeekInfo() and getTextInfo()), bridging the mathematical rigor of the ISO 8601 engine with the practical cultural expectations of calendars around the world (e.g., Sunday-first weeks in North America and Japan, Friday–Saturday weekends in the Middle East).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspecting Cultural Metadata (t.intl.info) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Tempo instance provides a structured t.intl namespace:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.intl.info: Returns a frozen, memoized ResolvedLocaleInfo object. Guaranteed to be fully populated across all runtimes (providing standard ISO/CLDR fallbacks if running in minimal or stripped environments).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.intl.locale: Returns the memoized native ECMAScript Intl.Locale instance (typed as Intl.Locale | undefined to safely handle legacy or headless environments that lack Intl.Locale).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-09-16', { locale: 'en-US' });
+
+// Cultural calendar metadata via t.intl.info (always defined):
+console.log(t.intl.info.firstDay);        // 7 (Sunday)
+console.log(t.intl.info.weekend);         // [6, 7] (Saturday, Sunday)
+console.log(t.intl.info.region);          // 'US'
+console.log(t.intl.info.script);          // 'Latn'
+console.log(t.intl.info.direction);       // 'ltr'
+console.log(t.intl.info.hourCycle);       // 'h12'
+console.log(t.intl.info.numberingSystem); // 'latn'
+console.log(t.intl.info.baseName);        // 'en-US'
+
+// Native Intl.Locale instance via t.intl.locale (use optional chaining):
+console.log(t.intl.locale?.language);             // 'en'
+console.log(t.intl.locale?.maximize().baseName);  // 'en-Latn-US'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Safety & Environment Portability: While t.intl.info.* properties are guaranteed non-nullish across all platforms, t.intl.locale directly exposes the host engine's native Intl.Locale. TypeScript strict checking encourages optional chaining (t.intl.locale?....) when directly interacting with the native instance prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Backward Compatibility: Direct access via t.intl.firstDay, t.intl.weekend, etc., remains supported as a deprecated fallback during v4.x, but new code should target t.intl.info.*.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Opt-in Regional Calendar Math (localeInfo: true) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo protects your backend and machine logic with strict ISO 8601 invariants (t.set({ week: 'start' }) always snaps to Monday).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To adapt week mutations to human cultural conventions, enable localeInfo: true:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Enable globally or per-instance:
+Tempo.init({ locale: 'en-US', localeInfo: true });
+
+const t = new Tempo('2026-09-16'); // Wednesday
+t.set({ week: 'start' });          // Snaps to previous Sunday (2026-09-13 00:00:00)
+t.set({ week: 'mid' });            // Snaps to Wednesday (2026-09-16 00:00:00, 3 days after start)
+t.set({ week: 'end' });            // Snaps to Saturday (2026-09-19 23:59:59.999999999)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dedicated ISO Escape Hatches (isoWeek, wy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When localeInfo: true is active, you can always guarantee strict ISO 8601 Monday-start boundaries using dedicated ISO tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ isoWeek: 'start' });       // Always snaps to Monday 00:00:00
+t.set({ wy: 'start' });            // Equivalent dedicated ISO week boundary
+t.set({ isoWeek: 'mid' });         // Always snaps to Thursday 00:00:00
+t.set({ isoWeek: 'end' });         // Always snaps to Sunday 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cultural Formatting Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dow:locale}: Formats a 1-based day-of-week index relative to the active locale's firstDay (e.g. Sunday = 1 in en-US, Saturday = 1 in ar-EG, Monday = 1 in en-GB). Because the developer explicitly requested :locale, this evaluates directly using t.intl.info.firstDay. Standard {dow} continues to evaluate to ISO Monday = 1 strictly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dow:locale:0} / {dow:0:locale}: Formats a 0-based day-of-week index (0..6) relative to the active locale's firstDay (e.g. Sunday = 0 in en-US, Saturday = 0 in ar-EG, Monday = 0 in en-GB).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {woy:locale}: Formats the week-of-year according to the active locale's week rules (firstDay and minimalDays, e.g. US week numbering where Week 1 is the week containing January 1st). Compose with :raw ({woy:locale:raw}) for unpadded week numbers, or :0 ({woy:locale:0}) for zero-indexed weeks (00..52).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {yow:locale} / {yw:locale}: Formats the week-numbering year according to the active locale's week rules. Compose with :short ({yow:locale:short}) for a 2-digit week-year.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {hh:locale}: Adapts hour formatting to the region's hourCycle (12-hour format 00..11 in h11 regions, 01..12 in h12 regions like en-US, and 24-hour format 00..23 in h23/h24 regions like fr-FR). Compose with :raw ({hh:locale:raw}) for unpadded hours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {time:locale}: Formats a complete localized time string, automatically including localized meridiem markers in h12 locales ("03:30:45 pm") and 24-hour time in h23 locales ("15:30:45").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Localized Numerals (:locale): When applied to numeric tokens ({yyyy:locale}, {mm:locale}, {dd:locale}), transliterates digits into the region's native numbering system (e.g. ٢٠٢٦-١٠-٢٤ in ar-EG). Base tokens without :locale ({yyyy}-{mm}-{dd}) always maintain strict ASCII digits for machine safety.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • BiDi Isolation: When formatting localized text tokens ({mon:locale}, {wkd:locale}) in RTL regions (Arabic, Hebrew), Tempo wraps text in Unicode BiDi isolates to prevent bidirectional text disruption.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {intl.<property>}: Directly embeds resolved regional metadata into format templates (e.g. {intl.region}, {intl.script}, {intl.direction}, {intl.firstDay}, {intl.minimalDays}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. High-Performance Intl Utility Hub ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In addition to inspecting regional calendar metadata, the t.intl namespace is designed as a zero-overhead, pre-bound internationalization utility hub.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,47)),s("p",null,[i[2]||(i[2]=e("Native ECMAScript ",-1)),i[3]||(i[3]=s("code",null,"Intl",-1)),i[4]||(i[4]=e(" formatters (",-1)),i[5]||(i[5]=s("code",null,"Intl.RelativeTimeFormat",-1)),i[6]||(i[6]=e(", ",-1)),i[7]||(i[7]=s("code",null,"Intl.ListFormat",-1)),i[8]||(i[8]=e(", ",-1)),i[9]||(i[9]=s("code",null,"Intl.DateTimeFormat",-1)),i[10]||(i[10]=e(") are powerful but can be slow to initialize in tight loops because they re-parse Unicode CLDR databases on each constructor call. ",-1)),i[11]||(i[11]=s("code",null,"Tempo.intl",-1)),i[12]||(i[12]=e(" eliminates this overhead through an internal ",-1)),s("mjx-container",r,[(t(),n("svg",d,[...i[0]||(i[0]=[a('',1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[13]||(i[13]=e(" memoization cache pre-bound to the active instance's ",-1)),i[14]||(i[14]=s("code",null,"locale",-1)),i[15]||(i[15]=e(" and ",-1)),i[16]||(i[16]=s("code",null,"timeZone",-1)),i[17]||(i[17]=e(":",-1))]),i[28]||(i[28]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-Bound Formatting Operations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-02', { locale: 'fr-FR' });
+
+// 1. Relative Time Formatting (Pre-bound to t.locale)
+t.intl.relativeTime(-2, 'day');              // "il y a 2 jours"
+t.intl.relativeTime(3, 'month');             // "dans 3 mois"
+
+// 2. Localized List Formatting (Pre-bound to t.locale)
+t.intl.list(['lundi', 'mardi', 'mercredi']);  // "lundi, mardi et mercredi"
+
+// 3. Pre-Memoized Native DateTimeFormat Instance
+const dtf = t.intl.dtf({ dateStyle: 'full' }); // Instant O(1) cached Intl.DateTimeFormat
+
+// 4. Plural Category Rules
+t.intl.plural(1);                            // 'one'
+t.intl.plural(5);                            // 'other'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,3)),s("table",h,[i[26]||(i[26]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Feature"),s("th",{style:{"text-align":"left"}},[e("Raw Native "),s("code",null,"Intl")]),s("th",{style:{"text-align":"left"}},[s("code",null,"Tempo.intl"),e(" Utility Hub")])])],-1)),s("tbody",null,[s("tr",null,[i[21]||(i[21]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Instantiation Cost")],-1)),i[22]||(i[22]=s("td",{style:{"text-align":"left"}},"Repeated CLDR/ICU initialization",-1)),s("td",p,[s("mjx-container",k,[(t(),n("svg",c,[...i[18]||(i[18]=[a('',1)])])),i[19]||(i[19]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[20]||(i[20]=e(" Globally memoized cache",-1))])]),i[23]||(i[23]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Context Wiring")]),s("td",{style:{"text-align":"left"}},[e("Manual "),s("code",null,"locale"),e(" & "),s("code",null,"timeZone"),e(" passing")]),s("td",{style:{"text-align":"left"}},"Automatically bound to instance context")],-1)),i[24]||(i[24]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Memory Footprint")]),s("td",{style:{"text-align":"left"}},"Manual GC management required"),s("td",{style:{"text-align":"left"}},[e("0 bytes added to "),s("code",null,"Tempo"),e(" instances")])],-1)),i[25]||(i[25]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Relative & List Formatting")]),s("td",{style:{"text-align":"left"}},"Multi-line constructor boilerplate"),s("td",{style:{"text-align":"left"}},"Clean, humanized one-liners")],-1))])])])}const T=l(o,[["render",g]]);export{b as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.lean.js new file mode 100644 index 00000000..dc77ee14 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.intl.md.CWGPkHoo.lean.js @@ -0,0 +1 @@ +import{_ as l,o as t,c as n,a2 as a,j as s,a as e}from"./chunks/framework.DNL3hc5c.js";const b=JSON.parse('{"title":"Internationalization (Intl) & Locale in Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.intl.md","filePath":"doc/4-advanced-reference/tempo.intl.md"}'),o={name:"doc/4-advanced-reference/tempo.intl.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={tabindex:"0"},p={style:{"text-align":"left"}},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function g(y,i,E,u,m,F){return t(),n("div",null,[i[27]||(i[27]=a("",47)),s("p",null,[i[2]||(i[2]=e("Native ECMAScript ",-1)),i[3]||(i[3]=s("code",null,"Intl",-1)),i[4]||(i[4]=e(" formatters (",-1)),i[5]||(i[5]=s("code",null,"Intl.RelativeTimeFormat",-1)),i[6]||(i[6]=e(", ",-1)),i[7]||(i[7]=s("code",null,"Intl.ListFormat",-1)),i[8]||(i[8]=e(", ",-1)),i[9]||(i[9]=s("code",null,"Intl.DateTimeFormat",-1)),i[10]||(i[10]=e(") are powerful but can be slow to initialize in tight loops because they re-parse Unicode CLDR databases on each constructor call. ",-1)),i[11]||(i[11]=s("code",null,"Tempo.intl",-1)),i[12]||(i[12]=e(" eliminates this overhead through an internal ",-1)),s("mjx-container",r,[(t(),n("svg",d,[...i[0]||(i[0]=[a("",1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[13]||(i[13]=e(" memoization cache pre-bound to the active instance's ",-1)),i[14]||(i[14]=s("code",null,"locale",-1)),i[15]||(i[15]=e(" and ",-1)),i[16]||(i[16]=s("code",null,"timeZone",-1)),i[17]||(i[17]=e(":",-1))]),i[28]||(i[28]=a("",3)),s("table",h,[i[26]||(i[26]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Feature"),s("th",{style:{"text-align":"left"}},[e("Raw Native "),s("code",null,"Intl")]),s("th",{style:{"text-align":"left"}},[s("code",null,"Tempo.intl"),e(" Utility Hub")])])],-1)),s("tbody",null,[s("tr",null,[i[21]||(i[21]=s("td",{style:{"text-align":"left"}},[s("strong",null,"Instantiation Cost")],-1)),i[22]||(i[22]=s("td",{style:{"text-align":"left"}},"Repeated CLDR/ICU initialization",-1)),s("td",p,[s("mjx-container",k,[(t(),n("svg",c,[...i[18]||(i[18]=[a("",1)])])),i[19]||(i[19]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),i[20]||(i[20]=e(" Globally memoized cache",-1))])]),i[23]||(i[23]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Context Wiring")]),s("td",{style:{"text-align":"left"}},[e("Manual "),s("code",null,"locale"),e(" & "),s("code",null,"timeZone"),e(" passing")]),s("td",{style:{"text-align":"left"}},"Automatically bound to instance context")],-1)),i[24]||(i[24]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Memory Footprint")]),s("td",{style:{"text-align":"left"}},"Manual GC management required"),s("td",{style:{"text-align":"left"}},[e("0 bytes added to "),s("code",null,"Tempo"),e(" instances")])],-1)),i[25]||(i[25]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,"Relative & List Formatting")]),s("td",{style:{"text-align":"left"}},"Multi-line constructor boilerplate"),s("td",{style:{"text-align":"left"}},"Clean, humanized one-liners")],-1))])])])}const T=l(o,[["render",g]]);export{b as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.js new file mode 100644 index 00000000..896b0721 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.js @@ -0,0 +1,13 @@ +import{_ as s,o as i,c as a,a2 as n}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Parse Planner Configuration","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.planner.md","filePath":"doc/4-advanced-reference/tempo.planner.md"}'),t={name:"doc/4-advanced-reference/tempo.planner.md"};function l(p,e,o,r,h,d){return i(),a("div",null,[...e[0]||(e[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parse Planner Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Parse Planner allows you to configure exactly how Tempo's text-to-date parsing engine operates, prioritizing certain date layouts and optimizing the parsing phase using pre-filters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These options are nested under the planner property when configuring Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layoutOrder ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo searches through a variety of date layouts (like ISO 8601, European, American, etc.) to understand user input. The layoutOrder configuration allows you to explicitly list which layout patterns should be evaluated first, prioritizing formats that you expect most often.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This leads to performance gains and gives you deterministic control when overriding Ambiguity Resolution heuristics (e.g. forcing mdy over dmy).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  planner: {
+    layoutOrder: ['iso', 'dmy', 'mdy'] // Array of string layout names
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Common layouts include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iso (e.g., 2024-05-20)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mdy (e.g., 05/20/2024)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dmy (e.g., 20/05/2024)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ymd (e.g., 2024/05/20)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a layoutOrder is provided, those specific layouts are pushed to the top of the parsing queue.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preFilter ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The preFilter option is a performance-optimization flag for the engine. When set to true, the parsing engine will pre-scan incoming text and immediately skip complex regex evaluation if the input contains no discernible date or time characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is highly recommended for applications where non-date text is frequently evaluated by Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('some random text', {
+  planner: {
+    preFilter: true
+  }
+});
+
+// \`t\` will quickly resolve to an errored state, saving CPU cycles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,15)])])}const g=s(t,[["render",l]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.lean.js new file mode 100644 index 00000000..2a823f84 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.planner.md.bxTXGqP7.lean.js @@ -0,0 +1 @@ +import{_ as s,o as i,c as a,a2 as n}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Parse Planner Configuration","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.planner.md","filePath":"doc/4-advanced-reference/tempo.planner.md"}'),t={name:"doc/4-advanced-reference/tempo.planner.md"};function l(p,e,o,r,h,d){return i(),a("div",null,[...e[0]||(e[0]=[n("",15)])])}const g=s(t,[["render",l]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.js new file mode 100644 index 00000000..66ceaa35 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.js @@ -0,0 +1,9 @@ +import{_ as e,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Shorthand Engine","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.shorthand.md","filePath":"doc/4-advanced-reference/tempo.shorthand.md"}'),n={name:"doc/4-advanced-reference/tempo.shorthand.md"};function o(r,t,h,l,d,p){return s(),i("div",null,[...t[0]||(t[0]=[a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Shorthand Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo Shorthand Engine (the "Slick" engine) provides a powerful, namespace-based syntax for navigating and manipulating complex date/time cycles (Terms). It allows you to treat high-level concepts like Quarters, Seasons, and Daily Periods as first-class units of measure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Three Modes of Shorthand ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Shorthand behavior changes depending on whether you provide a String, an Object, or a Structural Key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Navigation Mode (String Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .set(), .add(), .subtract(), .until(), and .since().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: #[namespace].[modifier][repeat][range]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Jumping to specific boundaries (e.g., "the start of the next Q1").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set('#qtr.>q1'); // Snaps to the start of the next available Q1
+t.add('#timeOfDay.>afternoon'); // Jumps to the start of the next Afternoon period

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Relational Mode (Object Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .add(), .subtract(), and .set().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: { '#namespace': value }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Shifting by semantic "steps" while preserving your relative position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Relational Add & Subtract: Preserves your offset within the cycle
+t.add({ '#qtr': 1 });      // If you are 20 days into Q1, you resolve to 20 days into Q2.
+t.subtract({ '#qtr': 1 }); // Resolves backwards to 20 days into the previous Quarter.
+
+// Relational Set: Absolute index alignment
+t.set({ '#qtr': 2 }); // Aligns to the start of the 2nd quarter of the current year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C. Structural Mode (Boundary Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .set().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: { '#namespace': 'start' | 'mid' | 'end' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Snapping a date to the precise boundaries or midpoint of its current Term.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ '#qtr': 'start' }); // Snaps to the exact start of the current quarter
+t.set({ '#qtr': 'end' });   // Snaps to the final nanosecond of the current quarter
+t.set({ '#qtr': 'mid' });   // Snaps to the midpoint of the current quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Navigation Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modifiers control the direction and inclusivity of the search.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierMeaningBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >Forward (Exclusive)Finds the next boundary strictly after the current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <Backward (Exclusive)Finds the previous boundary strictly before the current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >=Forward (Inclusive)Returns the current Term if it contains the cursor; otherwise, the next.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <=Backward (Inclusive)Returns the current Term if it contains the cursor; otherwise, the previous.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +Relative FutureAlias for >.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -Relative PastAlias for <.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thisIdentityResolves the Term currently containing the cursor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Proximity vs. Momentum ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The "Slick" engine uses two different sorting strategies to ensure results feel "natural."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Proximity Resolution (Identifiers) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a simple identifier like #zodiac.aries, Tempo uses Past-Leaning Resolution. It finds the most recent instance of Aries that has already started. If you are currently in Aries, it returns the start of the current one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Momentum Resolution (Shifters) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a shifter like >q1, Tempo uses Chronological Momentum. It ignores where you are now and looks exclusively into the future for the next occurrence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. The "Cycle Preservation" Guarantee ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of Tempo's premium features is its ability to maintain your relative offset when shifting across Terms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are 45% of the way through a Morning period and you call t.add({ '#timeOfDay': 1 }), Tempo doesn't just add a fixed number of hours. It:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Determines your relative percentage/offset within the current Morning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Finds the boundaries of the next registered period (e.g., Afternoon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calculates the same 45% point within that new period.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This ensures that "shifting by a quarter" or "shifting by a period" feels mathematically correct even when those Terms have different durations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Development Constraints ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building custom Terminology Plugins, you must follow the Golden Rules of Range-Keys to ensure the lexer can resolve them:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No Reserved Characters: Range-Keys (e.g., q1, aries) must not contain:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > < + = , . ! @ # $ % ^ & * ( ) [ ] { }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This rule does not reserve - even though the Relative Past shorthand uses - as an alias for <; that modifier is parsed in operator position, not as part of the range-key token itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No Leading Numbers: Range-Keys must not start with a digit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1q is Invalid (Lexer thinks it's a repeat count). Use q1 instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Explicit Spheres: Always set sphere: 'north' or 'south' in your config if using seasonal Terms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Method Intent: Use String shorthand for "Jumping" to boundaries and Object shorthand for "Shifting" relative to your current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fail-Safe: Use catch: true in your global config to allow shorthand resolution to fail silently (returning a void instance) instead of throwing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,38)])])}const k=e(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.lean.js new file mode 100644 index 00000000..3c21e57e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.shorthand.md.Y4AXHmBr.lean.js @@ -0,0 +1 @@ +import{_ as e,o as s,c as i,a2 as a}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Tempo Shorthand Engine","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.shorthand.md","filePath":"doc/4-advanced-reference/tempo.shorthand.md"}'),n={name:"doc/4-advanced-reference/tempo.shorthand.md"};function o(r,t,h,l,d,p){return s(),i("div",null,[...t[0]||(t[0]=[a("",38)])])}const k=e(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.js new file mode 100644 index 00000000..643b188d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.js @@ -0,0 +1,2 @@ +import{_ as t,o as a,c as i,a2 as d}from"./chunks/framework.DNL3hc5c.js";const f=JSON.parse('{"title":"Weekday Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.weekday.md","filePath":"doc/4-advanced-reference/tempo.weekday.md"}'),o={name:"doc/4-advanced-reference/tempo.weekday.md"};function s(l,e,n,r,c,h){return a(),i("div",null,[...e[0]||(e[0]=[d(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a flexible way to parse Weekday inputs, allowing you to specify dates relative to the current day or a specific base date. This is particularly useful for phrases like "next Monday" or "3 Wednesdays ago".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday inputs typically consist of a modifier (optional), a count (optional), and the Weekday name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Simple Weekday Names ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can provide the short or full name of a Weekday.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mon, Monday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Wed, Wednesday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sun, Sunday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Symbolic Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbols can be used to indicate relative weeks or specific directions in time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When no modifier is provided, Tempo defaults to the Weekday in the current week.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierMeaningExampleResults in...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +Next week+MonMonday of next week
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -Previous week-TueTuesday of last week
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <=Prior to<=WedThe Wednesday immediately preceding (or equal to) today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <Prior to (strict)<ThuThe Thursday strictly before today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >=Subsequent to>=FriThe Friday immediately following (or equal to) today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >Subsequent to (strict)>SatThe Saturday strictly after today

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strict vs Inclusive Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The difference between < (strict) and <= (inclusive) is only relevant when you evaluate a string on the exact same weekday you are targeting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For example, if today is Wednesday:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('<Wed')  // → returns LAST Wednesday (strictly before today)
+new Tempo('<=Wed') // → returns TODAY (inclusive match)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Keyword Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Keywords can be used for more natural language-like inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeywordMeaningExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thisCurrent weekthis Wed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextNext weeknext Monday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prevPrevious weekprev Fri
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lastLast weeklast Sunday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Count Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can specify a number of weeks to jump by adding a count after the modifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • -3 Wed: Three Wednesdays ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +2 Mon: Two Mondays from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Relative Suffixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also specify the direction of time using a suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3 Wed ago: Three Wednesdays ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 2 Mon hence: Two Mondays hence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 2 Mon from now: Two Mondays from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time Suffixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can append time information to a Weekday string. Tempo will parse the Weekday first and then apply the time to that specific date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mon 10:00am
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • >Friday noon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <3 Wed 15:30:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Normalization: Weekday names are normalized to their 3-letter proper-case prefix (e.g., monday -> Mon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Anchor: If no time-zone or base date is provided, Tempo uses "now" as the anchor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calculation: The modifier and count determine the number of weeks to add or subtract from the anchor date to find the target Weekday.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Constraint: If time components are provided, they are set on the calculated date. Otherwise, the time defaults to 00:00:00 if it's the first parsing pass.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,28)])])}const p=t(o,[["render",s]]);export{f as __pageData,p as default}; diff --git a/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.lean.js b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.lean.js new file mode 100644 index 00000000..0c64761d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_4-advanced-reference_tempo.weekday.md.Ddy-N3v_.lean.js @@ -0,0 +1 @@ +import{_ as t,o as a,c as i,a2 as d}from"./chunks/framework.DNL3hc5c.js";const f=JSON.parse('{"title":"Weekday Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/4-advanced-reference/tempo.weekday.md","filePath":"doc/4-advanced-reference/tempo.weekday.md"}'),o={name:"doc/4-advanced-reference/tempo.weekday.md"};function s(l,e,n,r,c,h){return a(),i("div",null,[...e[0]||(e[0]=[d("",28)])])}const p=t(o,[["render",s]]);export{f as __pageData,p as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.js new file mode 100644 index 00000000..f5ea576c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.js @@ -0,0 +1 @@ +import{_ as n,o as r,c as i,a2 as a,j as t,a as o}from"./chunks/framework.DNL3hc5c.js";const S=JSON.parse('{"title":"🏗️ Core Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/architecture.md","filePath":"doc/5-architecture-and-internals/architecture.md"}'),s={name:"doc/5-architecture-and-internals/architecture.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},m={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},u={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},y={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function f(b,e,x,w,Q,v){return r(),i("div",null,[e[31]||(e[31]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Core Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo introduces several industry-leading architectural patterns designed for maximum resilience in complex Monorepo and Proxy-wrapped environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Shared Global Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoRuntime — single hardened bridge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historically, Tempo spread its inter-module state across many global symbol slots on globalThis ($terms, $extends, $modules, etc.). Each slot was a potential tamper target, making the global namespace difficult to audit securely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of modern builds, all bookkeeping is consolidated inside a single TempoRuntime object (internal core runtime). The runtime is stored on globalThis under a hardened private symbol property with descriptor enumerable: false, configurable: false, writable: false, ensuring external code can neither replace nor delete it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reduced Global Footprint — Consolidation from multiple scatter-slots down to a single root.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Centralized Hardening — Strict input validation (Tempo.use) and hook management operate securely from one nexus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Runtimes (Experimental) — TempoRuntime.createScoped() returns a fresh, isolated runtime for internal test harnesses without globalThis manipulation. Note: This is an internal testing utility. For user-facing configuration and plugin isolation, use the official Sandbox Factory API (Tempo.create()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-Bundle / HMR Safety — Guarantees that two bundle copies of Tempo always share the identical runtime object, resolving complex split-brain states in monorepos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    User-facing "Global Discovery" slots remain on globalThis. The Symbol.for('$Tempo') slot (and custom discovery symbols passed to Tempo.init) are intentionally exposed for user-readability, remaining ordinary writable properties. Only sensitive internal bookkeeping was moved into the hardened runtime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To solve the "Split-Brain" issue inherent in monorepo development, Tempo utilizes a Shared Global Registry. By leveraging a unified global type-identification symbol on globalThis, all versions of Tempo share a synchronized constructor registry. This ensures classes are accurately identified as constructors even when loaded across disparate module boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🕵️ Decoupled Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo utilizes a centralized, functional diagnostic engine (via logError / logWarn utilities) relying on private context to avoid polluting the public console or altering object state. This ensures parsing telemetry never clashes with standard application logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context-Aware: Logs rigorously track their discovery path (e.g., "Applied via Global Discovery").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero-Footprint: When debug: 0, the logging overhead is mathematically eliminated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol-Gated: Diagnostic metadata is attached via private symbol variable directly (e.g., config[sym.$LogConfig]), making it invisible to standard iteration (Object.keys) and serialization (JSON.stringify).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Hardened Functional Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine implements a "Fail-Safe" execution pattern for functional inputs, automatically recovering from misidentified types—such as ES6 classes wrapped in defensive Proxies or circular dependency deadlocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Defensive Execution: All plugin invocations are wrapped in recursive try/catch execution blocks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Silent Failover: When combined with catch: true, resolution failures safely return a Void Instance, preventing application crashes while surfacing clear diagnostic symbols for debugging.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Tempo Architecture: Internal Protection & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo employs two distinct methodologies for protecting its internal state. These strategies are highly complementary, each meticulously tailored to a specific scope (Instance vs. Global) and performance requirement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Methodology Comparison ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureLazy Evaluation (Shadowing)Soft Freeze (Proxy)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primary TargetTempo.#term, Tempo.#fmt (Instance State)NUMBER, FORMAT (Global Registries)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ScopeInstance-Specific: Unique to every separate new Tempo() call.Global-Shared: One single source of truth used by all instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primary GoalPerformance: Avoid computing expensive Terms (e.g., qtr or szn) until explicitly requested.Extensibility: Allow plugins to safely append new data to registries at runtime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MechanismObject.create(proto) + Prototype Shadowing.new Proxy(target) + Symbol-bypass.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why this one?Memory Efficiency: Thousands of instances share the same base prototype.Reference Stability: Shared registries must persist at the same object reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ The "Zero-Cost Constructor" Objective ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is built with a militant "Performance First" mindset, specifically targeting the computational overhead of the class constructor. In high-frequency applications (like Tickers or real-time Dashboards), creating thousands of objects must be nearly as computationally cheap as primitive assignments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Status: Achieved. We successfully meet the Zero-Cost objective under stable conditions. Benchmarks demonstrate an instantiation overhead of ~523µs, and a fast-fail rejection speed of ~359µs (steady-state results after warm-up on the documented hardware setup).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This objective is achieved through two primary architectural pillars:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy Evaluation (Section 1): Deferring the computationally expensive work of string parsing and Term calculation until the first strict property access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Master Guard (Section 3): Implementing a high-speed "fast-fail" gatekeeper to instantly reject invalid inputs before parsing logic is engaged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Together, these pillars help ensure that new Tempo() maintains an extremely fast constructor execution time by completely deferring standard parsing workloads. However, note that these costs can depend on input scanning length and registry-mutation-driven wordlist rebuilds, meaning performance is not universally input- or registry-independent.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Iteration & Enumerability (Delegator Proxies) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A delegator Proxy is a wrapper whose traps forward operations to an internal target/handler pair. Unlike a standard Proxy, delegation is explicit and tightly routed through an intermediate forwarding layer. In Tempo, the "Generic Lazy Delegator Proxy" handles the public delegation mechanism, while lazy shadowing initializes the private state. These mechanisms coexist: the instance.term / instance.fmt public API employs the delegator Proxy path, and Tempo.#term / Tempo.#fmt private fields are initialized exactly once via lazy shadowing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✅ Object.keys() Behavior ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object.keys(instance.fmt) and Object.keys(instance.term) return the enumerable own keys strictly registered on each delegator target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Proxy Discovery (Definition): This is the proxy-handler phase that enumerates available target keys and installs enumerable lazy getter properties on the proxy target without computing their values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Triggered by Enumeration APIs: Discovery executes when enumeration APIs execute, including Object.keys(instance.fmt), for...in, and Reflect.ownKeys(...).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Timing: Discovery happens at enumeration time (before any property get), establishing key visibility prior to value resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relation to Section 1: Discovery only registers getters; actual value computation and memoization trigger purely on-demand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • After Access: Getter access memoizes values directly onto the target object; keys remain highly stable and do not "move" across prototype links.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Iteration Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Object.keys / for...in / Object Spread: Operate reliably on enumerable keys exposed by the delegator target after discovery.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • [Symbol.iterator]: Maintains explicit iterator semantics where fully implemented.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.registry.formats & Tempo.registry.terms: These static getters provide a registry-wide macroscopic view of available keys, entirely independent of per-instance memoization state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy Evaluation (Shadowing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: Tempo.#term, Tempo.#fmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Instance Shadowing pattern is engineered for massive scale. When a library handles dense operations, creating thousands of new Proxy() objects injects unacceptable memory overhead. Instead, Tempo exploits the native JavaScript prototype chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 0: All instances initially point to the identical base #term object containing un-evaluated getters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 1: When a Term (e.g., .qtr) is accessed, the value is computationally evaluated exactly once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 2: Tempo utilizes a Generic Lazy Delegator Proxy (via getLazyDelegator) which catches property access and evaluates it strictly on-demand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Result: The V8 engine executes lookups via an aggressively optimized Proxy handler, making lookups mathematically comparable to raw property access while keeping the state strictly immutable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper implementation schematics, see the Lazy Evaluation Pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Soft Freeze Strategy (Proxy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: Tempo.NUMBER, Tempo.FORMAT, Tempo.TIMEZONE, Tempo.config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global registries must remain live yet highly secure. These are protected by a "Soft Freeze" layer to prevent state corruption or prototype poisoning by third-party code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The User: Interacts with a read-only Proxy that strictly behaves like a frozen object. Direct assignments are hard-blocked to prevent poisoning the global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Library: Utilizes a private symbol bypass to execute "Transactional Updates" natively via registryUpdate().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Result: The object reference remains constant while facilitating deeply controlled extensibility. This ensures that internal high-speed caches (like the Master Guard) can be synchronously rebuilt whenever a registry mutates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper implementation schematics, see the Soft Freeze Strategy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ 3. Master Guard (Guarded-Lazy Strategy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: new Tempo(string | number)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Guarded-Lazy strategy ensures that even under the weight of hundreds of custom plugins, the constructor entry point remains near-instantaneous. This logic is decoupled into a high-performance engine.guard.ts module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',56)),t("ol",null,[e[22]||(e[22]=t("li",null,[t("strong",null,"Longest-Token Matching"),o(": To prevent fractional matching (e.g., matching "),t("code",null,"qtr"),o(" inside "),t("code",null,"quarter"),o('), the guard executes a greedy "Scan-and-Consume" loop that strongly prioritizes the longest available token match.')],-1)),t("li",null,[e[2]||(e[2]=t("strong",null,"Unified Wordlist",-1)),e[3]||(e[3]=o(": The guard systematically ingests all registered Terms, Timezones, Month names, and Custom Events into a single ",-1)),t("mjx-container",l,[(r(),i("svg",d,[...e[0]||(e[0]=[a('',1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=o(" Set lookup (average token-lookup performance ",-1)),e[5]||(e[5]=t("em",null,"after",-1)),e[6]||(e[6]=o(" cache construction).",-1))]),t("li",null,[e[11]||(e[11]=t("strong",null,"High-Speed Gatekeeper",-1)),e[12]||(e[12]=o(": By eliminating complex backtracking regular expressions, the gatekeeper provides deterministic ",-1)),t("mjx-container",c,[(r(),i("svg",g,[...e[7]||(e[7]=[a('',1)])])),e[8]||(e[8]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[13]||(e[13]=o(" average lookup performance regardless of the depth of registered plugins. Note that overall validation time is bounded by the string length during the scan-and-consume phase, plus occasional ",-1)),t("mjx-container",h,[(r(),i("svg",m,[...e[9]||(e[9]=[a('',1)])])),e[10]||(e[10]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[14]||(e[14]=o(" cache rebuild costs when the underlying registry mutates.",-1))]),e[23]||(e[23]=t("li",null,[t("strong",null,"Versioned Registry"),o(": To avoid catastrophic redundant wordlist rebuilding, the Guard strictly monitors a version counter on the alias registry. The wordlist is dynamically rebuilt "),t("em",null,"only"),o(" when a valid mutation occurs.")],-1)),t("li",null,[e[17]||(e[17]=t("strong",null,"Auto-Lazy",-1)),e[18]||(e[18]=o(": Valid inputs that successfully clear the guard automatically shift the instance to ",-1)),e[19]||(e[19]=t("code",null,"mode: 'defer'",-1)),e[20]||(e[20]=o(", completely deferring the heavy ",-1)),t("mjx-container",p,[(r(),i("svg",u,[...e[15]||(e[15]=[a('',1)])])),e[16]||(e[16]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[21]||(e[21]=o(" parsing work until a property is strictly read.",-1))])]),e[32]||(e[32]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Centralized Alias Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo consolidates all Event and Period alias logic into a deeply optimized AliasEngine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Registry: Aliases operate in a strict prototype-aware chain. A local Tempo instance can deploy its own private aliases that safely shadow global implementations, all while sharing the underlying resolution engines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich Metadata: Every resolution returns a strict AliasResult, providing the Parser with immediate categorical knowledge of the alias's origin (global vs local), structural type, and clock-snapping requirements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clock Snapping: Time-based aliases (e.g. 8:00) are mathematically "snapped" to absolute precision, clearing sub-second drift (ms, us, ns) directly during the resolution phase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decoupled Registration: By deprecating legacy raw objects, the modern registry is highly protected against accidental mutation and supports high-efficiency, version-aware monitoring.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈 Validation & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The algorithmic efficiency of the Master Guard and the success of the Zero-Cost objective remain strictly validated via core benchmarking:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',7)),t("ul",null,[t("li",null,[e[28]||(e[28]=t("strong",null,"Instantiation Overhead",-1)),e[29]||(e[29]=o(": ~523µs on average (passing the Master Guard). ",-1)),t("em",null,[e[26]||(e[26]=o("(Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Validates the Zero-Cost ",-1)),t("mjx-container",y,[(r(),i("svg",T,[...e[24]||(e[24]=[a('',1)])])),e[25]||(e[25]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[27]||(e[27]=o(" objective on this hardware.)",-1))])]),e[30]||(e[30]=t("li",null,[t("strong",null,"Fast-Fail Rejection"),o(": ~359µs on average (failing the Master Guard). "),t("em",null,"(Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Demonstrates the Master Guard's low-latency rejection performance.)")],-1))]),e[33]||(e[33]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For detailed execution timings and methodology, see the Performance Benchmarks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Internal Lifecycle & Reactive Sync ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo commands system-wide synchronization through a deeply integrated, Symbol-based hook ecosystem.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a plugin is imported via a side-effect (import '@magmacomputing/tempo/duration'), it triggers a strict sym.$Register hook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Sync: The Tempo core listens for these hooks and synchronously updates its internal registries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Guard Rebuild: Upon any new Term or layout registration, the Master Guard is automatically rebuilt to dynamically ingest the new tokens, ensuring the "Zero-Cost Constructor" remains entirely synchronized with the ecosystem.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disposable Engine (Symbol.dispose) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo class rigorously implements the explicit resource management pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Slate: Calling Tempo[Symbol.dispose]() (or utilizing the using keyword in a test suite) comprehensively resets all global registries and configuration parameters back to factory defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolation: This is mathematically critical for automated testing environments to prevent memory or state-leaks between discrete test cases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚖️ Summary ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo architecture strictly follows the structural principle of "Right Tool for the Job":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shadowing provides the extreme performance and mathematical memory efficiency required for per-instance computed state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Proxies enforce the strict reference stability and highly controlled extensibility required for global system registries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Master Guard algorithmically ensures that even under massive extensibility, the entry point maintains a true "Zero-Cost Constructor".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',14))])}const q=n(s,[["render",f]]);export{S as __pageData,q as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.lean.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.lean.js new file mode 100644 index 00000000..a05b7caa --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_architecture.md.0jD-ZGOD.lean.js @@ -0,0 +1 @@ +import{_ as n,o as r,c as i,a2 as a,j as t,a as o}from"./chunks/framework.DNL3hc5c.js";const S=JSON.parse('{"title":"🏗️ Core Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/architecture.md","filePath":"doc/5-architecture-and-internals/architecture.md"}'),s={name:"doc/5-architecture-and-internals/architecture.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},m={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},u={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},y={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function f(b,e,x,w,Q,v){return r(),i("div",null,[e[31]||(e[31]=a("",56)),t("ol",null,[e[22]||(e[22]=t("li",null,[t("strong",null,"Longest-Token Matching"),o(": To prevent fractional matching (e.g., matching "),t("code",null,"qtr"),o(" inside "),t("code",null,"quarter"),o('), the guard executes a greedy "Scan-and-Consume" loop that strongly prioritizes the longest available token match.')],-1)),t("li",null,[e[2]||(e[2]=t("strong",null,"Unified Wordlist",-1)),e[3]||(e[3]=o(": The guard systematically ingests all registered Terms, Timezones, Month names, and Custom Events into a single ",-1)),t("mjx-container",l,[(r(),i("svg",d,[...e[0]||(e[0]=[a("",1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=o(" Set lookup (average token-lookup performance ",-1)),e[5]||(e[5]=t("em",null,"after",-1)),e[6]||(e[6]=o(" cache construction).",-1))]),t("li",null,[e[11]||(e[11]=t("strong",null,"High-Speed Gatekeeper",-1)),e[12]||(e[12]=o(": By eliminating complex backtracking regular expressions, the gatekeeper provides deterministic ",-1)),t("mjx-container",c,[(r(),i("svg",g,[...e[7]||(e[7]=[a("",1)])])),e[8]||(e[8]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[13]||(e[13]=o(" average lookup performance regardless of the depth of registered plugins. Note that overall validation time is bounded by the string length during the scan-and-consume phase, plus occasional ",-1)),t("mjx-container",h,[(r(),i("svg",m,[...e[9]||(e[9]=[a("",1)])])),e[10]||(e[10]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[14]||(e[14]=o(" cache rebuild costs when the underlying registry mutates.",-1))]),e[23]||(e[23]=t("li",null,[t("strong",null,"Versioned Registry"),o(": To avoid catastrophic redundant wordlist rebuilding, the Guard strictly monitors a version counter on the alias registry. The wordlist is dynamically rebuilt "),t("em",null,"only"),o(" when a valid mutation occurs.")],-1)),t("li",null,[e[17]||(e[17]=t("strong",null,"Auto-Lazy",-1)),e[18]||(e[18]=o(": Valid inputs that successfully clear the guard automatically shift the instance to ",-1)),e[19]||(e[19]=t("code",null,"mode: 'defer'",-1)),e[20]||(e[20]=o(", completely deferring the heavy ",-1)),t("mjx-container",p,[(r(),i("svg",u,[...e[15]||(e[15]=[a("",1)])])),e[16]||(e[16]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[21]||(e[21]=o(" parsing work until a property is strictly read.",-1))])]),e[32]||(e[32]=a("",7)),t("ul",null,[t("li",null,[e[28]||(e[28]=t("strong",null,"Instantiation Overhead",-1)),e[29]||(e[29]=o(": ~523µs on average (passing the Master Guard). ",-1)),t("em",null,[e[26]||(e[26]=o("(Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Validates the Zero-Cost ",-1)),t("mjx-container",y,[(r(),i("svg",T,[...e[24]||(e[24]=[a("",1)])])),e[25]||(e[25]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[27]||(e[27]=o(" objective on this hardware.)",-1))])]),e[30]||(e[30]=t("li",null,[t("strong",null,"Fast-Fail Rejection"),o(": ~359µs on average (failing the Master Guard). "),t("em",null,"(Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Demonstrates the Master Guard's low-latency rejection performance.)")],-1))]),e[33]||(e[33]=a("",14))])}const q=n(s,[["render",f]]);export{S as __pageData,q as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.js new file mode 100644 index 00000000..0b4d30f6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.js @@ -0,0 +1,20 @@ +import{_ as l,o as a,c as i,j as e,a as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"The Immutable Proxy-Delegator Lazy Evaluation Pattern","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/lazy-evaluation-pattern.md","filePath":"doc/5-architecture-and-internals/lazy-evaluation-pattern.md"}'),o={name:"doc/5-architecture-and-internals/lazy-evaluation-pattern.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function k(y,t,Q,c,x,w){return a(),i("div",null,[t[27]||(t[27]=e("h1",{id:"the-immutable-proxy-delegator-lazy-evaluation-pattern",tabindex:"-1"},[s("The Immutable Proxy-Delegator Lazy Evaluation Pattern "),e("a",{class:"header-anchor",href:"#the-immutable-proxy-delegator-lazy-evaluation-pattern","aria-label":'Permalink to "The Immutable Proxy-Delegator Lazy Evaluation Pattern"'},"​")],-1)),t[28]||(t[28]=e("p",null,'When building complex JavaScript libraries (like date-time utilities), exposing numerous computed properties as getters on an object is common. However, computing them all upfront is expensive, and re-computing them on every access is wasteful. The standard solution is "Lazy Evaluation": evaluate the getter on first access, and then overwrite the getter with the literal value.',-1)),t[29]||(t[29]=e("p",null,[s("But what if the base object is strictly "),e("strong",null,"immutable"),s(" (via "),e("code",null,"Object.freeze"),s(")?")],-1)),e("p",null,[t[2]||(t[2]=s("This article details a highly optimized ",-1)),e("mjx-container",r,[(a(),i("svg",p,[...t[0]||(t[0]=[n('',1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[3]||(t[3]=s(" pattern for securely lazy-evaluating properties on immutable objects using a Proxy-based delegator and private fields.",-1))]),t[30]||(t[30]=e("h2",{id:"the-problem-mutating-frozen-state",tabindex:"-1"},[s("The Problem: Mutating Frozen State "),e("a",{class:"header-anchor",href:"#the-problem-mutating-frozen-state","aria-label":'Permalink to "The Problem: Mutating Frozen State"'},"​")],-1)),t[31]||(t[31]=e("p",null,[s("A traditional lazy evaluation approach destroys and recreates the properties on the parent object. If the parent object is "),e("code",null,"Object.freeze()"),s("'d for security (preventing API consumers from tampering with state), you cannot simply "),e("code",null,"Object.defineProperty"),s(" to overwrite the getter with a literal value.")],-1)),e("p",null,[t[6]||(t[6]=s("To get around freezing, you might try taking all property descriptors, wiping the object, mapping the other getters to a new object, adding the evaluated value, and calling ",-1)),t[7]||(t[7]=e("code",null,"Object.freeze()",-1)),t[8]||(t[8]=s(" on the new object. This operation runs in ",-1)),e("mjx-container",h,[(a(),i("svg",d,[...t[4]||(t[4]=[n('',1)])])),t[5]||(t[5]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mi",null,"N"),e("mo",{stretchy:"false"},")")])],-1))]),t[9]||(t[9]=s(" time every single time ",-1)),t[10]||(t[10]=e("em",null,"any",-1)),t[11]||(t[11]=s(" getter is accessed.",-1))]),t[32]||(t[32]=e("h2",{id:"the-solution-proxy-delegator-with-memoization",tabindex:"-1"},[s("The Solution: Proxy-Delegator with Memoization "),e("a",{class:"header-anchor",href:"#the-solution-proxy-delegator-with-memoization","aria-label":'Permalink to "The Solution: Proxy-Delegator with Memoization"'},"​")],-1)),e("p",null,[t[14]||(t[14]=s("Tempo achieves lazy evaluation in ",-1)),e("mjx-container",m,[(a(),i("svg",g,[...t[12]||(t[12]=[n('',1)])])),t[13]||(t[13]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[15]||(t[15]=s(" time using a ",-1)),t[16]||(t[16]=e("strong",null,"Delegator Proxy",-1)),t[17]||(t[17]=s(" that memoizes results back onto the target object.",-1))]),t[33]||(t[33]=n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    #setLazy(target, name, defineFunction) {
+    // Note: The \`target\` object must remain unfrozen so we can memoize properties onto it.
+    // It is kept secure by being stored in a private field (e.g., \`#term\`).
+    const get = () => {
+        const value = defineFunction.call(this); // Evaluate the value
+        
+        // Memoize the value by defining it as a static property on the mutable target
+        Object.defineProperty(target, name, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: false
+        });
+        
+        return value;
+    };
+
+    // Define the initial getter
+    Object.defineProperty(target, name, { get, enumerable: true, configurable: true });
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Proxy Entry Point: Tempo uses a single Proxy (the delegate helper) to catch the very first access to a property. This Proxy doesn't store state; it just routes the request to the lazy evaluator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Private Fields Keep the Mutable Target Secure: The internal containers (#term, #fmt) are private fields. Native JS Private Fields don't exist as public properties on the object. Thus, even if the public Tempo instance is frozen, we can safely keep the internal target objects unfrozen to allow for memoization without exposing them to tampering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Innate JS Engine Optimizations: Once a property (e.g., .quarter) is evaluated, it is "baked" into the target object as a standard value property. Subsequent lookups bypass the Proxy and the getter entirely. The JS engine treats it as a raw property access, which is the fastest possible operation in JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Zero Over-allocation: Unused getters remain as simple function pointers. They cost absolutely nothing in execution time or memory until they are needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By combining Private Fields, Proxies, and Property Memoization, Tempo builds securely immutable APIs that lazy-load computed getters with zero overhead after the initial call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌈 The Best of All Worlds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of v2.1.2, Tempo uses a Proxy-Delegator that combines the security of immutability with the speed of raw property access:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,7)),e("ol",null,[t[24]||(t[24]=e("li",null,[e("strong",null,"Lazy by Default"),s(": Properties are only evaluated when accessed, keeping the constructor near-instant.")],-1)),t[25]||(t[25]=e("li",null,[e("strong",null,"Memoized Evaluation"),s(": Once accessed (e.g., "),e("code",null,"t.term.quarter"),s('), the result is "baked" into the instance using '),e("code",null,"Object.defineProperty"),s(".")],-1)),e("li",null,[e("strong",null,[e("mjx-container",u,[(a(),i("svg",T,[...t[18]||(t[18]=[n('',1)])])),t[19]||(t[19]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[20]||(t[20]=s(" Performance",-1))]),t[21]||(t[21]=s(": Every access ",-1)),t[22]||(t[22]=e("em",null,"after",-1)),t[23]||(t[23]=s(" the first is a direct property lookup—no Proxy traps, no prototype traversal.",-1))]),t[26]||(t[26]=e("li",null,[e("strong",null,"Transparent Discovery"),s(": Because properties are enumerable, "),e("code",null,"console.log(t.term)"),s(" or "),e("code",null,"JSON.stringify"),s(' will trigger the evaluation of all registered Terms at once, providing a perfect "snapshot" of the instance state.')],-1))]),t[34]||(t[34]=e("p",null,[s("To prevent diagnostic noise during these full-evaluation events, initialize Tempo with "),e("strong",null,[e("code",null,"silent: true")]),s(".")],-1))])}const b=l(o,[["render",k]]);export{E as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.lean.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.lean.js new file mode 100644 index 00000000..c5597c97 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_lazy-evaluation-pattern.md.CVU82iN_.lean.js @@ -0,0 +1 @@ +import{_ as l,o as a,c as i,j as e,a as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"The Immutable Proxy-Delegator Lazy Evaluation Pattern","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/lazy-evaluation-pattern.md","filePath":"doc/5-architecture-and-internals/lazy-evaluation-pattern.md"}'),o={name:"doc/5-architecture-and-internals/lazy-evaluation-pattern.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function k(y,t,Q,c,x,w){return a(),i("div",null,[t[27]||(t[27]=e("h1",{id:"the-immutable-proxy-delegator-lazy-evaluation-pattern",tabindex:"-1"},[s("The Immutable Proxy-Delegator Lazy Evaluation Pattern "),e("a",{class:"header-anchor",href:"#the-immutable-proxy-delegator-lazy-evaluation-pattern","aria-label":'Permalink to "The Immutable Proxy-Delegator Lazy Evaluation Pattern"'},"​")],-1)),t[28]||(t[28]=e("p",null,'When building complex JavaScript libraries (like date-time utilities), exposing numerous computed properties as getters on an object is common. However, computing them all upfront is expensive, and re-computing them on every access is wasteful. The standard solution is "Lazy Evaluation": evaluate the getter on first access, and then overwrite the getter with the literal value.',-1)),t[29]||(t[29]=e("p",null,[s("But what if the base object is strictly "),e("strong",null,"immutable"),s(" (via "),e("code",null,"Object.freeze"),s(")?")],-1)),e("p",null,[t[2]||(t[2]=s("This article details a highly optimized ",-1)),e("mjx-container",r,[(a(),i("svg",p,[...t[0]||(t[0]=[n("",1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[3]||(t[3]=s(" pattern for securely lazy-evaluating properties on immutable objects using a Proxy-based delegator and private fields.",-1))]),t[30]||(t[30]=e("h2",{id:"the-problem-mutating-frozen-state",tabindex:"-1"},[s("The Problem: Mutating Frozen State "),e("a",{class:"header-anchor",href:"#the-problem-mutating-frozen-state","aria-label":'Permalink to "The Problem: Mutating Frozen State"'},"​")],-1)),t[31]||(t[31]=e("p",null,[s("A traditional lazy evaluation approach destroys and recreates the properties on the parent object. If the parent object is "),e("code",null,"Object.freeze()"),s("'d for security (preventing API consumers from tampering with state), you cannot simply "),e("code",null,"Object.defineProperty"),s(" to overwrite the getter with a literal value.")],-1)),e("p",null,[t[6]||(t[6]=s("To get around freezing, you might try taking all property descriptors, wiping the object, mapping the other getters to a new object, adding the evaluated value, and calling ",-1)),t[7]||(t[7]=e("code",null,"Object.freeze()",-1)),t[8]||(t[8]=s(" on the new object. This operation runs in ",-1)),e("mjx-container",h,[(a(),i("svg",d,[...t[4]||(t[4]=[n("",1)])])),t[5]||(t[5]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mi",null,"N"),e("mo",{stretchy:"false"},")")])],-1))]),t[9]||(t[9]=s(" time every single time ",-1)),t[10]||(t[10]=e("em",null,"any",-1)),t[11]||(t[11]=s(" getter is accessed.",-1))]),t[32]||(t[32]=e("h2",{id:"the-solution-proxy-delegator-with-memoization",tabindex:"-1"},[s("The Solution: Proxy-Delegator with Memoization "),e("a",{class:"header-anchor",href:"#the-solution-proxy-delegator-with-memoization","aria-label":'Permalink to "The Solution: Proxy-Delegator with Memoization"'},"​")],-1)),e("p",null,[t[14]||(t[14]=s("Tempo achieves lazy evaluation in ",-1)),e("mjx-container",m,[(a(),i("svg",g,[...t[12]||(t[12]=[n("",1)])])),t[13]||(t[13]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[15]||(t[15]=s(" time using a ",-1)),t[16]||(t[16]=e("strong",null,"Delegator Proxy",-1)),t[17]||(t[17]=s(" that memoizes results back onto the target object.",-1))]),t[33]||(t[33]=n("",7)),e("ol",null,[t[24]||(t[24]=e("li",null,[e("strong",null,"Lazy by Default"),s(": Properties are only evaluated when accessed, keeping the constructor near-instant.")],-1)),t[25]||(t[25]=e("li",null,[e("strong",null,"Memoized Evaluation"),s(": Once accessed (e.g., "),e("code",null,"t.term.quarter"),s('), the result is "baked" into the instance using '),e("code",null,"Object.defineProperty"),s(".")],-1)),e("li",null,[e("strong",null,[e("mjx-container",u,[(a(),i("svg",T,[...t[18]||(t[18]=[n("",1)])])),t[19]||(t[19]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mi",null,"O"),e("mo",{stretchy:"false"},"("),e("mn",null,"1"),e("mo",{stretchy:"false"},")")])],-1))]),t[20]||(t[20]=s(" Performance",-1))]),t[21]||(t[21]=s(": Every access ",-1)),t[22]||(t[22]=e("em",null,"after",-1)),t[23]||(t[23]=s(" the first is a direct property lookup—no Proxy traps, no prototype traversal.",-1))]),t[26]||(t[26]=e("li",null,[e("strong",null,"Transparent Discovery"),s(": Because properties are enumerable, "),e("code",null,"console.log(t.term)"),s(" or "),e("code",null,"JSON.stringify"),s(' will trigger the evaluation of all registered Terms at once, providing a perfect "snapshot" of the instance state.')],-1))]),t[34]||(t[34]=e("p",null,[s("To prevent diagnostic noise during these full-evaluation events, initialize Tempo with "),e("strong",null,[e("code",null,"silent: true")]),s(".")],-1))])}const b=l(o,[["render",k]]);export{E as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.js new file mode 100644 index 00000000..62b7b6c4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.js @@ -0,0 +1,23 @@ +import{_ as i,o as e,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Soft Freeze Strategy","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/soft_freeze_strategy.md","filePath":"doc/5-architecture-and-internals/soft_freeze_strategy.md"}'),n={name:"doc/5-architecture-and-internals/soft_freeze_strategy.md"};function r(l,s,h,o,p,k){return e(),a("div",null,[...s[0]||(s[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Soft Freeze Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Soft Freeze is a design pattern used in the Tempo library to balance Public Immutability with Internal Extensibility. It ensures that shared registries (like NUMBER, FORMAT, or DURATION) are read-only for users while remaining mutable for internal library features like plugin and runtime updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard JavaScript Object.freeze() is a "Hard Freeze":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pros: Guaranteed immutability; prevents accidental state corruption.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cons: Impossible to extend. Once frozen, even the library itself cannot add new formats or number-words (e.g., during plugin registration or configuration via Tempo.use()).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An unfrozen object is even riskier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Risk: A user could accidentally write NUMBER['one'] = 'two', which would break the library globally for all instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Solution: Soft Freeze ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Soft Freeze uses a Read-Only Proxy wrapped around a Mutable Target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Proxy (Public Shield) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Proxy traps all mutation attempts (set, deleteProperty, defineProperty) and returns false. This makes the object look and feel like a frozen object to the public API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Target (Internal Source of Truth) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The underlying object remains mutable. It is NOT passed through Object.freeze(). This allows the library to perform controlled mutations when explicitly requested (e.g., during plugin registration).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Access Control ($Target Symbol) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library uses a private Symbol called $Target. Only code with access to this symbol can "unwrap" the proxy to access the mutable underlying object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Details ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    proxy.library.ts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core logic resides in proxify, which now supports an optional lock parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hard Freeze (frozen=true, lock=true): Both the proxy and the target are immutable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Soft Freeze (frozen=true, lock=false): The proxy is read-only, but the target stays mutable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export function proxify<T extends object>(target: T, frozen = true, lock = frozen) {
+    const tgt = (target as any)[$Target] ?? target;         // unwrap proxy
+
+    // Hard Freeze: prevent all mutation to the target
+    if (lock) secure(tgt); 
+
+    return new Proxy(tgt, {
+        set: (_, key, val) => {
+            // Soft Freeze: Proxy blocks mutation, but target stays mutable
+            return frozen ? false : Reflect.set(tgt, key, val);
+        },
+        deleteProperty: (_, key) => {
+            return frozen ? false : Reflect.deleteProperty(tgt, key);
+        },
+        // ... other traps
+    });
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumerate.library.ts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The enumify utility uses Soft Freeze by default for registries that are intended to be extensible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export function enumify(list, frozen = false) {
+    const target = Object.create(proto, descriptors);
+    
+    // By defaulting to frozen=false, we create a Soft Freeze (proxy is frozen, target is not locked).
+    // This allows extensible library registries to be safely updated via the private symbol.
+    return proxify(target, true, frozen); 
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Bulletproof Public API: Users cannot accidentally overwrite library constants.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Library Extensibility: A plugin can add new data to registries at runtime without bypasses or 'hacks'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Safe Global Discovery: External discovery objects (via Symbol.for('$Tempo')) can extend the library with new aliases but are prevented from overwriting core keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Internal State Integrity: Centralized STATE objects are protected from direct access while providing a single source of truth.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Transparent Experience: The object behaves like a POJO (Plain Old JavaScript Object) in the debugger and typical usage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The "Safe Merge" Rule ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To prevent a global discovery object from "trashing" the registry, the library implements a Safe Merge rule for all shared states.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When merging external data (discovery or plugin):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Additive Only: New keys are added.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Root Protection: Core building blocks (like NUMBER['one'] or FORMAT['iso']) are protected from being overwritten.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This ensures that while the library is extensible, its fundamental logic remains deterministic and secure across all environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.1.2 Update: The Soft Freeze is now tightly integrated with the Diagnostic Engine. Internal state updates bypass the Proxy using a private Symbol, allowing the engine to remain "Silent" while performing complex transactional updates during the discovery phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,33)])])}const g=i(n,[["render",r]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.lean.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.lean.js new file mode 100644 index 00000000..075c9910 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_soft_freeze_strategy.md.CTiWNYBs.lean.js @@ -0,0 +1 @@ +import{_ as i,o as e,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Soft Freeze Strategy","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/soft_freeze_strategy.md","filePath":"doc/5-architecture-and-internals/soft_freeze_strategy.md"}'),n={name:"doc/5-architecture-and-internals/soft_freeze_strategy.md"};function r(l,s,h,o,p,k){return e(),a("div",null,[...s[0]||(s[0]=[t("",33)])])}const g=i(n,[["render",r]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.js new file mode 100644 index 00000000..e70c9c87 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.js @@ -0,0 +1,15 @@ +import{_ as n,o as i,c as l,j as t,a as s,a2 as a}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"🚀 Tempo Performance Benchmarks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/tempo.benchmarks.md","filePath":"doc/5-architecture-and-internals/tempo.benchmarks.md"}'),o={name:"doc/5-architecture-and-internals/tempo.benchmarks.md"},r={tabindex:"0"},d={style:{"text-align":"left"}},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},m={id:"_1-proxy-delegator-delegation",tabindex:"-1"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},Q={class:"info custom-block"},f={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},x={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function w(b,e,E,v,M,C){return i(),l("div",null,[e[36]||(e[36]=t("h1",{id:"🚀-tempo-performance-benchmarks",tabindex:"-1"},[s("🚀 Tempo Performance Benchmarks "),t("a",{class:"header-anchor",href:"#🚀-tempo-performance-benchmarks","aria-label":'Permalink to "🚀 Tempo Performance Benchmarks"'},"​")],-1)),e[37]||(e[37]=t("p",null,'To ensure high performance in mass-instantiation scenarios, Tempo implements a "Zero-Cost Constructor" architecture using prototype shadowing and lazy delegation. This document outlines the benchmark results for these optimizations.',-1)),e[38]||(e[38]=t("h2",{id:"📊-summary-of-timings",tabindex:"-1"},[s("📊 Summary of Timings "),t("a",{class:"header-anchor",href:"#📊-summary-of-timings","aria-label":'Permalink to "📊 Summary of Timings"'},"​")],-1)),e[39]||(e[39]=t("p",null,[s("Timings were captured over "),t("strong",null,"1,000 iterations"),s(" to measure micro-overhead and compare different instantiation strategies.")],-1)),t("table",r,[e[10]||(e[10]=t("thead",null,[t("tr",null,[t("th",{style:{"text-align":"left"}},"Method"),t("th",{style:{"text-align":"left"}},"Total Time"),t("th",{style:{"text-align":"left"}},"µs / op"),t("th",{style:{"text-align":"left"}},"Notes")])],-1)),t("tbody",null,[t("tr",null,[e[4]||(e[4]=t("td",{style:{"text-align":"left"}},[t("strong",null,"Default (Lazy Proxy)")],-1)),e[5]||(e[5]=t("td",{style:{"text-align":"left"}},"523.14ms",-1)),e[6]||(e[6]=t("td",{style:{"text-align":"left"}},[t("strong",null,"523.14µs")],-1)),t("td",d,[e[2]||(e[2]=s("Current ",-1)),t("mjx-container",h,[(i(),l("svg",p,[...e[0]||(e[0]=[a('',1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[3]||(e[3]=s(" constructor.",-1))])]),e[7]||(e[7]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Eager Simulation")]),t("td",{style:{"text-align":"left"}},"1394.51ms"),t("td",{style:{"text-align":"left"}},[t("strong",null,"1394.51µs")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"~2.7x slower"),s(" (simulating pre-refactor impact).")])],-1)),e[8]||(e[8]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Fast-Fail @sync")]),t("td",{style:{"text-align":"left"}},"359.04ms"),t("td",{style:{"text-align":"left"}},[t("strong",null,"359.04µs")]),t("td",{style:{"text-align":"left"}},"Rejected instantly by the Master Guard.")],-1)),e[9]||(e[9]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Object.create Baseline")]),t("td",{style:{"text-align":"left"}},"0.22ms"),t("td",{style:{"text-align":"left"}},"0.22µs"),t("td",{style:{"text-align":"left"}},"Raw JS overhead for comparison.")],-1))])]),e[40]||(e[40]=t("hr",null,null,-1)),e[41]||(e[41]=t("h2",{id:"🏗️-architectural-impact",tabindex:"-1"},[s("🏗️ Architectural Impact "),t("a",{class:"header-anchor",href:"#🏗️-architectural-impact","aria-label":'Permalink to "🏗️ Architectural Impact"'},"​")],-1)),t("h3",m,[e[13]||(e[13]=s("1. Proxy-Delegator Delegation (",-1)),t("mjx-container",g,[(i(),l("svg",T,[...e[11]||(e[11]=[a('',1)])])),e[12]||(e[12]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[14]||(e[14]=s(") ",-1)),e[15]||(e[15]=t("a",{class:"header-anchor",href:"#_1-proxy-delegator-delegation","aria-label":'Permalink to "1. Proxy-Delegator Delegation ($O(1)$)"'},"​",-1))]),e[42]||(e[42]=t("p",null,[s("By using a "),t("strong",null,"Proxy-Delegator"),s(" pattern, the constructor returns near-instantly without populating the formatting ("),t("code",null,"fmt"),s(") or Term ("),t("code",null,"term"),s(") objects. These registries are only discovered and memoized on the first property access.")],-1)),t("ul",null,[e[21]||(e[21]=t("li",null,[t("strong",null,"Gain"),s(": ~65% reduction in instantiation overhead.")],-1)),t("li",null,[e[18]||(e[18]=t("strong",null,"v2.1.2 Update",-1)),e[19]||(e[19]=s(': The Scan-and-Consume guard further stabilizes the "Zero-Cost Constructor" by ensuring that even with massive plugin lists, the entry-point remains ',-1)),t("mjx-container",u,[(i(),l("svg",c,[...e[16]||(e[16]=[a('',1)])])),e[17]||(e[17]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[20]||(e[20]=s(".",-1))])]),e[43]||(e[43]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Master Guard (Fast-Fail) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The dynamic Master Guard acts as a rapid scan-and-consume gatekeeper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Efficiency: Invalid inputs are rapidly rejected via a fast greedy scan, bounding failure costs tightly to string length.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance: Validating a string against the guard is ~30% faster than a full parsing cycle, even for simple ISO strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Benchmark Methodology ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The benchmark script used performance.now() within a Vitest environment to ensure accurate module resolution and test environment isolation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',6)),t("ol",null,[e[29]||(e[29]=t("li",null,[t("strong",null,"Lazy Creation"),s(": Creates a "),t("code",null,"new Tempo('2024-05-20')"),s(" without accessing any properties.")],-1)),t("li",null,[e[24]||(e[24]=t("strong",null,"Eager Simulation",-1)),e[25]||(e[25]=s(": Creates a ",-1)),e[26]||(e[26]=t("code",null,"new Tempo()",-1)),e[27]||(e[27]=s(" and manually triggers discovery on 5 core properties to simulate ",-1)),t("mjx-container",k,[(i(),l("svg",y,[...e[22]||(e[22]=[a('',1)])])),e[23]||(e[23]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[28]||(e[28]=s(" initialization.",-1))]),e[30]||(e[30]=t("li",null,[t("strong",null,"Invalid Parse"),s(": Passes a string that fails the Master Guard (e.g., includes emojis or exotic symbols) to measure rejection speed.")],-1))]),t("div",Q,[e[35]||(e[35]=t("p",{class:"custom-block-title"},"INFO",-1)),t("p",null,[e[33]||(e[33]=s("These benchmarks represent the library's performance under Node.js v22+. Results may vary based on the JS engine (V8, JavaScriptCore, etc.) but the ",-1)),t("mjx-container",f,[(i(),l("svg",x,[...e[31]||(e[31]=[a('',1)])])),e[32]||(e[32]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[34]||(e[34]=s(" complexity remains constant.",-1))])]),e[44]||(e[44]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈 Self-Service Benchmark Module ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a built-in BenchmarkModule to allow developers to prove the performance ROI in their own exact environment (e.g. comparing Node.js memory metrics against Browser DOM performance).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This module is completely decoupled from the core to keep the bundle light, but accepts your specific configured Tempo instance to give accurate results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BenchmarkModule } from '@magmacomputing/tempo/module/benchmark';
+
+// 1. Configure your Tempo instance (e.g. plugins, timezone, etc)
+Tempo.init({ timeZone: 'America/New_York' });
+
+// 2. Run the benchmark against your datasets
+const results = BenchmarkModule.run(Tempo, {
+  data: ['2026-05-20', '2026-05-21', 'Invalid-Pizza-String'], // production datasets
+  iterations: 100, // stress-test count
+  baseline: true,  // compare against native \`new Date()\`
+  modes: ['auto', 'defer']
+});
+
+console.table(results);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Metrics Collected ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The BenchmarkModule is platform-aware. Using the internal getContext() utility, it tracks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • totalTimeMs: Total elapsed time using high-resolution timers (performance.now()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • microSecPerOp: The average number of microseconds (µs) taken per operation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • successRate: The percentage of strings that successfully resolved to a valid date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • heapUsedDeltaMb: (Node.js Only) The change in memory allocation to measure Garbage Collection overhead and memory safety.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Indicative Benchmark Results ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When evaluated against a mixed dataset (Strict ISO, US Localized, Timestamps, and Garbage strings) over 3,500 operations in Node.js (Vitest), the BenchmarkModule yields the following performance profiles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strategyµs / OpSuccess RateMemory OverheadNotes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Date0.18 µs57.1%0.39 MBRaw C++ speed, but fails on localized strings (e.g., 10/31/2026 11:59 PM).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Auto)778.8 µs71.4%108.84 MB~0.77ms: Fully parses US localized strings and timestamps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Defer)704.7 µs71.4%-36.27 MB~0.70ms: Noticeably faster, reduced Garbage Collection pressure.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Strict)700.7 µs71.4%26.10 MB~0.70ms: Fastest mode; bypasses parsing fallback attempts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Key Takeaways ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Sub-Millisecond Rich Parsing: While native Date has raw native engine speed (0.18 µs), it sacrifices reliability and formatting, failing entirely on localized formats like 10/31/2026. Tempo achieves a robust 71% success rate while still maintaining blazing fast sub-millisecond (~0.7ms) parsing speeds! In real-world terms, processing 100 complex localized dates on a page will only take 70 milliseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Defer Mode is Highly Optimized: Looking at the memory overhead (heapUsedDeltaMb), defer mode actually resulted in a negative memory delta (-36.27 MB). Note that this is simply an observed lower end-of-run heap measurement due to incidental GC timing, but demonstrates the inherently low memory pressure of deferred initialization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Adapt This Test: The runner script used to generate these results is available in the bench/runner.test.ts directory. You can use it as a scaffold to test Tempo against your own unique datasets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,15))])}const S=n(o,[["render",w]]);export{F as __pageData,S as default}; diff --git a/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.lean.js b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.lean.js new file mode 100644 index 00000000..1f881494 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_5-architecture-and-internals_tempo.benchmarks.md.CXZ3BzvK.lean.js @@ -0,0 +1 @@ +import{_ as n,o as i,c as l,j as t,a as s,a2 as a}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"🚀 Tempo Performance Benchmarks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/5-architecture-and-internals/tempo.benchmarks.md","filePath":"doc/5-architecture-and-internals/tempo.benchmarks.md"}'),o={name:"doc/5-architecture-and-internals/tempo.benchmarks.md"},r={tabindex:"0"},d={style:{"text-align":"left"}},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},m={id:"_1-proxy-delegator-delegation",tabindex:"-1"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},T={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},k={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.495ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2429 1000","aria-hidden":"true"},Q={class:"info custom-block"},f={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},x={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function w(b,e,E,v,M,C){return i(),l("div",null,[e[36]||(e[36]=t("h1",{id:"🚀-tempo-performance-benchmarks",tabindex:"-1"},[s("🚀 Tempo Performance Benchmarks "),t("a",{class:"header-anchor",href:"#🚀-tempo-performance-benchmarks","aria-label":'Permalink to "🚀 Tempo Performance Benchmarks"'},"​")],-1)),e[37]||(e[37]=t("p",null,'To ensure high performance in mass-instantiation scenarios, Tempo implements a "Zero-Cost Constructor" architecture using prototype shadowing and lazy delegation. This document outlines the benchmark results for these optimizations.',-1)),e[38]||(e[38]=t("h2",{id:"📊-summary-of-timings",tabindex:"-1"},[s("📊 Summary of Timings "),t("a",{class:"header-anchor",href:"#📊-summary-of-timings","aria-label":'Permalink to "📊 Summary of Timings"'},"​")],-1)),e[39]||(e[39]=t("p",null,[s("Timings were captured over "),t("strong",null,"1,000 iterations"),s(" to measure micro-overhead and compare different instantiation strategies.")],-1)),t("table",r,[e[10]||(e[10]=t("thead",null,[t("tr",null,[t("th",{style:{"text-align":"left"}},"Method"),t("th",{style:{"text-align":"left"}},"Total Time"),t("th",{style:{"text-align":"left"}},"µs / op"),t("th",{style:{"text-align":"left"}},"Notes")])],-1)),t("tbody",null,[t("tr",null,[e[4]||(e[4]=t("td",{style:{"text-align":"left"}},[t("strong",null,"Default (Lazy Proxy)")],-1)),e[5]||(e[5]=t("td",{style:{"text-align":"left"}},"523.14ms",-1)),e[6]||(e[6]=t("td",{style:{"text-align":"left"}},[t("strong",null,"523.14µs")],-1)),t("td",d,[e[2]||(e[2]=s("Current ",-1)),t("mjx-container",h,[(i(),l("svg",p,[...e[0]||(e[0]=[a("",1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[3]||(e[3]=s(" constructor.",-1))])]),e[7]||(e[7]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Eager Simulation")]),t("td",{style:{"text-align":"left"}},"1394.51ms"),t("td",{style:{"text-align":"left"}},[t("strong",null,"1394.51µs")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"~2.7x slower"),s(" (simulating pre-refactor impact).")])],-1)),e[8]||(e[8]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Fast-Fail @sync")]),t("td",{style:{"text-align":"left"}},"359.04ms"),t("td",{style:{"text-align":"left"}},[t("strong",null,"359.04µs")]),t("td",{style:{"text-align":"left"}},"Rejected instantly by the Master Guard.")],-1)),e[9]||(e[9]=t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,"Object.create Baseline")]),t("td",{style:{"text-align":"left"}},"0.22ms"),t("td",{style:{"text-align":"left"}},"0.22µs"),t("td",{style:{"text-align":"left"}},"Raw JS overhead for comparison.")],-1))])]),e[40]||(e[40]=t("hr",null,null,-1)),e[41]||(e[41]=t("h2",{id:"🏗️-architectural-impact",tabindex:"-1"},[s("🏗️ Architectural Impact "),t("a",{class:"header-anchor",href:"#🏗️-architectural-impact","aria-label":'Permalink to "🏗️ Architectural Impact"'},"​")],-1)),t("h3",m,[e[13]||(e[13]=s("1. Proxy-Delegator Delegation (",-1)),t("mjx-container",g,[(i(),l("svg",T,[...e[11]||(e[11]=[a("",1)])])),e[12]||(e[12]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[14]||(e[14]=s(") ",-1)),e[15]||(e[15]=t("a",{class:"header-anchor",href:"#_1-proxy-delegator-delegation","aria-label":'Permalink to "1. Proxy-Delegator Delegation ($O(1)$)"'},"​",-1))]),e[42]||(e[42]=t("p",null,[s("By using a "),t("strong",null,"Proxy-Delegator"),s(" pattern, the constructor returns near-instantly without populating the formatting ("),t("code",null,"fmt"),s(") or Term ("),t("code",null,"term"),s(") objects. These registries are only discovered and memoized on the first property access.")],-1)),t("ul",null,[e[21]||(e[21]=t("li",null,[t("strong",null,"Gain"),s(": ~65% reduction in instantiation overhead.")],-1)),t("li",null,[e[18]||(e[18]=t("strong",null,"v2.1.2 Update",-1)),e[19]||(e[19]=s(': The Scan-and-Consume guard further stabilizes the "Zero-Cost Constructor" by ensuring that even with massive plugin lists, the entry-point remains ',-1)),t("mjx-container",u,[(i(),l("svg",c,[...e[16]||(e[16]=[a("",1)])])),e[17]||(e[17]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[20]||(e[20]=s(".",-1))])]),e[43]||(e[43]=a("",6)),t("ol",null,[e[29]||(e[29]=t("li",null,[t("strong",null,"Lazy Creation"),s(": Creates a "),t("code",null,"new Tempo('2024-05-20')"),s(" without accessing any properties.")],-1)),t("li",null,[e[24]||(e[24]=t("strong",null,"Eager Simulation",-1)),e[25]||(e[25]=s(": Creates a ",-1)),e[26]||(e[26]=t("code",null,"new Tempo()",-1)),e[27]||(e[27]=s(" and manually triggers discovery on 5 core properties to simulate ",-1)),t("mjx-container",k,[(i(),l("svg",y,[...e[22]||(e[22]=[a("",1)])])),e[23]||(e[23]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mi",null,"N"),t("mo",{stretchy:"false"},")")])],-1))]),e[28]||(e[28]=s(" initialization.",-1))]),e[30]||(e[30]=t("li",null,[t("strong",null,"Invalid Parse"),s(": Passes a string that fails the Master Guard (e.g., includes emojis or exotic symbols) to measure rejection speed.")],-1))]),t("div",Q,[e[35]||(e[35]=t("p",{class:"custom-block-title"},"INFO",-1)),t("p",null,[e[33]||(e[33]=s("These benchmarks represent the library's performance under Node.js v22+. Results may vary based on the JS engine (V8, JavaScriptCore, etc.) but the ",-1)),t("mjx-container",f,[(i(),l("svg",x,[...e[31]||(e[31]=[a("",1)])])),e[32]||(e[32]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[34]||(e[34]=s(" complexity remains constant.",-1))])]),e[44]||(e[44]=a("",15))])}const S=n(o,[["render",w]]);export{F as __pageData,S as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.js new file mode 100644 index 00000000..8274a1da --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.js @@ -0,0 +1,60 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Tempo Enumerators (enumify)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.enumerators.md","filePath":"doc/6-utility-library/tempo.enumerators.md"}'),t={name:"doc/6-utility-library/tempo.enumerators.md"};function h(p,s,l,k,r,o){return a(),e("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Enumerators (enumify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a custom enumify utility to define enumerations rather than relying on native TypeScript enums. This gives consumers of the library access to a robust set of iteration and lookup methods out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains how they are defined, how you use them as a consumer of the Tempo library, and why this design pattern was chosen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. How Tempo Enums are Defined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's core enumerators (like Weekdays, Months, Seasons) are built using the exported enumify function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Under the hood, enumify returns a Proxy-wrapped, frozen object based on a null-prototype:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Null-Prototype Root (Object.create(null)): The base prototype is completely detached from Object.prototype. Standard prototype properties like toString, valueOf, constructor, or hasOwnProperty do not exist on the object, eliminating key collision and prototype pollution risks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Strict Runtime Immutability: The object is locked down with Object.freeze() and wrapped in a read-only Proxy that rejects writes, deletions, or runtime property additions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Prototypal Extensibility: Even though each enum is deeply frozen and immutable, enums remain extensible through JavaScript prototypal inheritance via .extend().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array-based Definitions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you pass an array to enumify, the strings become the keys, and the values are their zero-indexed positions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const WEEKDAY = enumify(['All', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']);
+// Result: { All: 0, Mon: 1, Tue: 2 ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object-based Definitions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you need specific string-to-string mappings, you pass an object literal directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const SEASON = enumify({ Summer: 'summer', Autumn: 'autumn', Winter: 'winter', Spring: 'spring' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Inference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    After defining the enumify object, simple TypeScript helper aliases pull out the types so you can use them reliably in function signatures:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export type SEASON = ValueOf<typeof SEASON>; // Type: 'summer' | 'autumn' | 'winter' | 'spring'
+export type Season = KeyOf<typeof SEASON>;   // Type: 'Summer' | 'Autumn' | 'Winter' | 'Spring'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The above types allow for the use of Season and SEASON as type arguments, providing type safety for both the keys and values of the enum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is generally recommended to use the values (lowercase) as type arguments, as they are used as the actual values in the enumify object. This allows for easier use of the enumify methods, which operate on the values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: TypeScript provides automatic typing for native enums, but it is not the case with enumify.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Using Enums Outside of Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For consumers of the library, these enumerations are exposed via public package exports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As static properties on Tempo (convenient in app code already using Tempo)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As the default export from @magmacomputing/tempo/enums
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As individual named exports from @magmacomputing/tempo/enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Avoid referencing internal source files (such as tempo.index.ts) in application code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Static Properties on Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access all enums via the unified Tempo.enums getter, or use top-level getters for core calendar and direction enums (WEEKDAY, WEEKDAYS, MONTH, MONTHS, DURATION, DURATIONS, SEASON, COMPASS):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// Core domain enums directly on Tempo:
+const direction = Tempo.COMPASS.North; // 'north'
+const monthIndex = Tempo.MONTH.Feb;    // 2 (since 'All' was index 0)
+
+// All enums via the unified Tempo.enums accessor:
+const first = Tempo.enums.ORDINAL.first; // 1
+const dateFormat = Tempo.enums.FORMAT.date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Canonical Namespace Import ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Import the full enums object via the default export:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import enums from '@magmacomputing/tempo/enums';
+
+const { COMPASS, MONTH } = enums;
+const direction = COMPASS.North;
+const monthIndex = MONTH.Feb;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Direct Named Import ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Import individual enumerators directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { COMPASS, MONTH, WEEKDAY, ORDINAL, Enum } from '@magmacomputing/tempo/enums';
+
+console.log('compass keys: ', Enum.keys(COMPASS));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static-First Reflection Suite (Enum.*) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In modern Tempo, enum reflection is performed using the Enum.* static helper suite, mirroring ECMAScript's standard Object.hasOwn and Object.keys:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Enum } from '@magmacomputing/tempo/enums';
+// or: import { Enum } from '@magmacomputing/tempo/library';
+
+// Iterating over properties (Type-safe & collision-proof)
+const days = Enum.keys(Tempo.WEEKDAY);                  // readonly ('All' | 'Mon' | 'Tue' | ...)[]
+const values = Enum.values(Tempo.WEEKDAY);              // readonly (0 | 1 | 2 | ...)[]
+const entries = Enum.entries(Tempo.WEEKDAY);            // readonly (readonly [key, value])[]
+const count = Enum.count(Tempo.WEEKDAY);                // 8
+
+// Validation
+if (Enum.has(Tempo.SEASON, 'Spring')) { ... }           // true if 'Spring' is a key
+if (Enum.hasOwn(Tempo.SEASON, 'Spring')) { ... }        // true if 'Spring' is a direct own key
+if (Enum.includes(Tempo.SEASON, 'spring')) { ... }      // true if 'spring' is a value
+
+// Reverse lookups! Get the Key Name from the Value
+const keyName = Enum.keyOf(Tempo.MONTH, 2);             // 'Feb'
+
+// Inversion & Aliasing support (last-key-wins)
+const byCode = Enum.invert(Tempo.SEASON);               // { summer: 'Summer', ... }
+
+// Native iteration
+for (const [key, val] of Tempo.WEEKDAY) {
+  console.log(key, val);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Creating Custom Enums ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can utilize the same enumify engine for your own application logic by importing it from the library subpath. This is particularly useful for maintaining consistent data patterns and iteration capabilities throughout your project.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Custom Enum ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { enumify, Enum } from '@magmacomputing/tempo/library';
+
+// 1. Define your Enum
+export const STATUS = enumify(['Pending', 'Active', 'Resolved', 'Archived']);
+
+// 2. Use the static reflection helpers
+const allKeys = Enum.keys(STATUS);           // ['Pending', 'Active', 'Resolved', 'Archived']
+const isActive = Enum.has(STATUS, 'Active'); // true
+const value = STATUS.Resolved;               // 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extending Enums via Prototypal Inheritance (Enum.extend()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A standout capability of enumify is that enums are immutable yet extendable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Developers typically assume that freezing an object (Object.freeze) prevents adding fields. However, enumify achieves non-destructive extensibility through JavaScript prototype delegation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { enumify, Enum } from '@magmacomputing/tempo/library';
+
+// Base enum (frozen and immutable)
+export const BASE_ROLE = enumify(['Viewer', 'Editor']);
+
+// Extend with additional roles
+export const ADMIN_ROLE = Enum.extend(BASE_ROLE, ['Admin', 'SuperAdmin']);
+
+console.log(Enum.keys(ADMIN_ROLE));             // ['Viewer', 'Editor', 'Admin', 'SuperAdmin']
+console.log(Enum.count(ADMIN_ROLE));            // 4
+console.log(Enum.has(ADMIN_ROLE, 'Viewer'));    // true (inherited from BASE_ROLE)
+console.log(Enum.hasOwn(ADMIN_ROLE, 'Viewer')); // false (inherited, not an own property)
+console.log(Enum.hasOwn(ADMIN_ROLE, 'Admin'));  // true (direct own property on ADMIN_ROLE)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How Prototypal Inheritance Works Here: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero Mutation on Parent: BASE_ROLE remains untouched and completely immutable. Existing code relying on BASE_ROLE is guaranteed never to see unwanted keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Delegation (Object.create(this)): Calling extend() creates a new frozen child enum whose prototype is the parent enum. The child inherits all parent keys, values, and methods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stealth Traversal: Methods like .keys(), .values(), .entries(), .count(), and even JSON.stringify() seamlessly traverse the prototype chain to treat the extended enum as a unified collection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Key Shadowing: Child enums can cleanly shadow inherited keys with new values without polluting the ancestor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-tier Hierarchies: Enums can be extended multiple times (BASE -> TENANT -> USER) while keeping each level individually sealed and safe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. How They Are Used Inside Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internally, the Tempo logic relies heavily on these enumerators. This gives the parsing and formatting engines guaranteed type-safety and robust lookup dictionaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For instance, the .format() logic can map tokens efficiently, and parser configuration (e.g., regex Snippet mapping) loops through them safely without manually declaring Object.keys() combinations everywhere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The overarching design ensures the library stays strongly typed, internally consistent, and protected against accidental runtime mutation via Object.freeze().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. enumify vs. TypeScript enum (The Trade-Offs) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TypeScript's native enum is one of the few TS features that generates structural runtime JavaScript, and it has known friction points in the JavaScript community.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using enumify is a deliberate choice for high-quality library design.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Wins for enumify ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich API (Methods): Native TS enums are plain JavaScript objects at runtime. To get the keys, you must write Object.keys(MyEnum). The enumify wrapper gives developers .keys(), .values(), .has(), .includes(), .map(), .filter(), and native iteration ([Symbol.iterator]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Namespace (Null-Prototype): Native enums and plain objects inherit from Object.prototype, creating potential collisions with keys like toString, valueOf, or constructor. enumify uses a null prototype, keeping the namespace completely unpolluted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototypal Extensibility (.extend()): TypeScript native enums cannot be extended, inherited, or composed. enumify allows enums to inherit from base enums cleanly without mutating the parent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Predictable Serialization: TypeScript numeric enums generate strange "reverse mappings" in compiled JS (e.g., { 0: "Up", "Up": 0 }). This makes iterating over them or stringifying them to JSON very messy. enumify objects serialize cleanly and safely.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutability: enumify freezes the object at runtime (Object.freeze) and seals it with a Proxy. Standard TS enums can technically be mutated at runtime by malicious or sloppy ES code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • NodeJS/ESM Compatibility: Standard TS enums can cause friction with isolated module compilers (like Vite or esbuild) or when importing into vanilla JS. enumify generates 100% standard ES2015 JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Losses (Trade-offs) for enumify ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Slightly More Boilerplate Definition: Defining an enumify dictionary takes 2-3 lines of code (exporting the const, then exporting the type alias). TS native enums do both (value and type) as part of the enum keyword.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Missing Nominal Typing: TypeScript native enums offer "nominal" typing (e.g., enum A { X } cannot be passed to a function expecting enum B { X } even if the keys/structures match). enumify relies on structural typing (union of literals), meaning TypeScript allows passing the raw string 'spring' into a function rather than forcing you to strictly use Tempo.SEASON.Spring.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Slight Runtime Overhead: Instantiating the proxy/prototype wrapper and freezing it adds a microscopic runtime cost compared to evaluating a plain object literal, though parsing the library is typically a one-time engine cost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • More Verbose Setup: TypeScript's enum can use auto-incrementing numeric values, but enumify requires explicit values for each key.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,56)])])}const E=i(t,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.lean.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.lean.js new file mode 100644 index 00000000..0a60f298 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.enumerators.md.Csq1zWUC.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Tempo Enumerators (enumify)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.enumerators.md","filePath":"doc/6-utility-library/tempo.enumerators.md"}'),t={name:"doc/6-utility-library/tempo.enumerators.md"};function h(p,s,l,k,r,o){return a(),e("div",null,[...s[0]||(s[0]=[n("",56)])])}const E=i(t,[["render",h]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.js new file mode 100644 index 00000000..77fc58a2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.js @@ -0,0 +1 @@ +import{_ as n,o as t,c as o,a2 as s,j as i,a}from"./chunks/framework.DNL3hc5c.js";const r="/magma/v4/library-logo.svg",f=JSON.parse('{"title":"Tempo Library Functionality","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.library.md","filePath":"doc/6-utility-library/tempo.library.md"}'),l={name:"doc/6-utility-library/tempo.library.md"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function p(h,e,u,m,g,y){return t(),o("div",null,[e[10]||(e[10]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Library

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Library Functionality ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Tempo is primarily a Date-Time engine, it relies on several custom utilities under the hood to handle data structures, deep cloning, and serialization safely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These utilities are robust enough that they are exported as public API methods for use within your own application logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document serves as an index summarizing these core library features.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Enumerators (enumify, Enum.*) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a custom utility called enumify to create heavily-protected, iterable enum-like objects instead of relying on native TypeScript enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This allows for structural typing, easy type-safe iteration via static reflection helpers (Enum.keys(), Enum.values()), and runtime safety without the overhead or compilation quirks of standard TS Enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is heavily used internally for concepts like Weekdays, Months, Compass cardinal points and Meteorological Seasons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Enumerators Guide for details on definition, methods, and a comparison with native enums.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Serialization (stringify, objectify, cloneify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native JSON methods (JSON.stringify and JSON.parse) often fail or destructively mutate rich JavaScript data types like BigInt, Map, Set, Symbol, and Date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure safe data persistence across localStorage, IndexedDB, or network boundaries, Tempo implements its own serialization suite:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stringify(): Safely serializes rich objects, protecting circular references and complex types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • objectify(): Safely reconstructs objects previously serialized by stringify().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cloneify(): Performs a deep-copy of an object, preserving all rich data types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Serializers Guide for detailed usage, benefits, and trade-offs compared to native JSON methods or structuredClone.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. High-Performance Push/Pull Streams (Reactive) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',19)),i("p",null,[e[2]||(e[2]=a("Tempo includes ",-1)),e[3]||(e[3]=i("code",null,"Reactive",-1)),e[4]||(e[4]=a(", a bidirectional asynchronous stream primitive that unifies push-based event listeners and pull-based async iterators (",-1)),e[5]||(e[5]=i("code",null,"for await",-1)),e[6]||(e[6]=a(") with ",-1)),i("mjx-container",c,[(t(),o("svg",d,[...e[0]||(e[0]=[s('',1)])])),e[1]||(e[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),e[7]||(e[7]=a(" dispatch, backpressure buffering, and explicit resource management (",-1)),e[8]||(e[8]=i("code",null,"using",-1)),e[9]||(e[9]=a(").",-1))]),e[11]||(e[11]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Push/Pull Duality: Seamlessly switch between event subscribers (stream.on('data', cb)) and async pull iteration (await stream.pull(), for await).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Disposable Subscriptions: stream.on() returns a Reactive.Subscription implementing TC39 Disposable (using sub = stream.on(...)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stream Truncation: Easily gate or bound streams via stream.until(signal | promise | otherStream).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Leak-Proof Finalization: Backed by Finalizer to ensure unclosed abandoned streams are safely reclaimed by the garbage collector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Reactive Streams Guide for detailed usage, patterns, and state inspection.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Deferred Promises (Pledge) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a specialized wrapper around Promise.withResolvers() called Pledge. It is designed to simplify modern asynchronous patterns where you need to manage a promise's lifecycle externally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State Tracking: Transparent access to isPending, isResolved, and isRejected flags.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Lifecycle Hooks: Support for onResolve, onReject, and onSettle callbacks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Shell: Once created, the Pledge instance is frozen, ensuring the promise reference cannot be swapped.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resource Management: Implements Symbol.dispose to automatically reject pending promises when they go out of scope, preventing deadlocks or memory leaks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Pledge Guide for advanced usage with callbacks, debugging tags, and lifecycle management.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. GC Safety & Memory Management (WeakCache, Finalizer) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For performance-critical and memory-sensitive architectures, Tempo exports two key garbage-collection primitives:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • WeakCache<K, V>: High-performance, GC-cooperative memoization cache that allows unreferenced keys or values to be collected without memory retention.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Finalizer: Safe abstraction over FinalizationRegistry to register automatic teardown callbacks for timers, streams, or proxies without pinning object references.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Functional Evaluation (evaluate, dynamicProxy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo exports functional evaluation utilities for resolving static values, lazy suppliers, and dynamic object proxies:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluate(...values): Synchronously resolves candidate values or zero-argument supplier functions (() => T) in order, returning the first defined result (lazy coalesce with short-circuiting).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluateAsync(...values): Asynchronously resolves static values, sync/async suppliers, or Promises (() => Promise<T> | T) in order with short-circuiting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluateConfig(config) / evaluateConfigAsync(config): Resolves Evaluable property suppliers on the top-level properties of a configuration dictionary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dynamicProxy(target): Wraps a target object with dynamic property traps that evaluate function-valued properties lazily on-access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evaluable<T> / AsyncEvaluable<T>: TypeScript utility types representing values that can be provided directly or supplied lazily via functions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { evaluate, evaluateAsync, dynamicProxy } from '@magmacomputing/tempo/library';\n\n// Synchronous supplier evaluation with lazy cascading fallback (short-circuited)\nconst tz = evaluate(options.timeZone, () => process.env.TZ, 'UTC');\n\n// Asynchronous supplier evaluation (e.g. secret vault / remote config)\nconst apiKey = await evaluateAsync(provider.key, async () => await vault.getKey('openai'));\n\n// Dynamic proxy with lazy on-access getters\nconst dynamicSettings = dynamicProxy({\n  timeout: 5000,\n  token: () => getActiveToken()\n});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Class Decorators (@Immutable, @Serializable, @Static) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses lightweight TypeScript class decorators internally to enforce immutability (@Immutable), register custom serialization handlers (@Serializable), and prevent instantiation of static-only classes (@Static).


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8. Exhaustive API Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These are isolated, standalone utility functions and classes developed internally to support our various applications. They are entirely free to use and are documented here as a convenience reference for our users.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While some of these utilities may be used internally by the Tempo library, many are completely independent (such as the browser and server-specific functions). They do not declare external dependencies, keeping them lightweight and portable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library is split into domain-specific modules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Browser: Functions and classes that rely on browser APIs (e.g., window, localStorage, Geolocation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Server: Node.js specific utilities (e.g., file system access, server-side JWT decoding).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Common: Runtime-agnostic utilities shared across all environments (evaluation, assertion, coercion, cipher, json, calendar, recurrence, proxy).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can browse the full API reference in the sidebar below this section.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',27))])}const b=n(l,[["render",p]]);export{f as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.lean.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.lean.js new file mode 100644 index 00000000..99cfcc31 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.library.md.CFDR8vK6.lean.js @@ -0,0 +1 @@ +import{_ as n,o as t,c as o,a2 as s,j as i,a}from"./chunks/framework.DNL3hc5c.js";const r="/magma/v4/library-logo.svg",f=JSON.parse('{"title":"Tempo Library Functionality","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.library.md","filePath":"doc/6-utility-library/tempo.library.md"}'),l={name:"doc/6-utility-library/tempo.library.md"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function p(h,e,u,m,g,y){return t(),o("div",null,[e[10]||(e[10]=s("",19)),i("p",null,[e[2]||(e[2]=a("Tempo includes ",-1)),e[3]||(e[3]=i("code",null,"Reactive",-1)),e[4]||(e[4]=a(", a bidirectional asynchronous stream primitive that unifies push-based event listeners and pull-based async iterators (",-1)),e[5]||(e[5]=i("code",null,"for await",-1)),e[6]||(e[6]=a(") with ",-1)),i("mjx-container",c,[(t(),o("svg",d,[...e[0]||(e[0]=[s("",1)])])),e[1]||(e[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),e[7]||(e[7]=a(" dispatch, backpressure buffering, and explicit resource management (",-1)),e[8]||(e[8]=i("code",null,"using",-1)),e[9]||(e[9]=a(").",-1))]),e[11]||(e[11]=s("",27))])}const b=n(l,[["render",p]]);export{f as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.js new file mode 100644 index 00000000..3b31fdfe --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.js @@ -0,0 +1,35 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Pledge: Advanced Asynchronous Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.pledge.md","filePath":"doc/6-utility-library/tempo.pledge.md"}'),t={name:"doc/6-utility-library/tempo.pledge.md"};function l(h,s,p,k,d,r){return a(),e("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge: Advanced Asynchronous Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Pledge utility is a specialized wrapper around Promise.withResolvers() designed for modern asynchronous workflows where promise management needs to be handled externally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Basic Lifecycle ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Pledge provides direct access to its state and resolution methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Pledge } from '@magmacomputing/tempo/library';
+
+// 1. Instantiate
+const p = new Pledge<string>('DataFetch');
+
+// 2. Resolve or Reject externally
+p.resolve('Success!'); 
+// or p.reject(new Error('Failed'));
+
+// 3. Await the promise anywhere
+const result = await p.promise;
+
+// Note: resolve/reject are idempotent. Calling them on an already-settled 
+// \`Pledge\` is safe; it will log a warning but won't change the state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Then-ability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Pledge is a first-class "Then-able". You don't need to access .promise to chain your logic; you can call .then() and .catch() directly on the Pledge instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const p = new Pledge('NaturalAction');
+
+p.then(val => console.log(val))
+ .catch(err => console.error(err));
+
+p.resolve('Victory!');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Advanced Callbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can register lifecycle hooks during instantiation. These are useful for cross-cutting concerns like logging or resource cleanup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const p = new Pledge<string>({
+  tag: 'Task-123',
+  onResolve: (val) => console.log('Resolved with:', val),
+  onReject:  (err) => console.error('Rejected with:', err),
+  onSettle:  () =>    console.log('Pledge settled.')
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onResolve: Triggered when p.resolve() is called.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onReject: Triggered when p.reject() is called.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onSettle: Triggered regardless of outcome (analogous to finally).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Debugging with Tags ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each Pledge can be assigned a tag string. This tag is included in logs and error messages if the debug or catch flags are set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Enable debug logging for this instance
+const p = new Pledge({ tag: 'DatabaseQuery', debug: 5 });
+
+// If p is rejected, the tag will be included in the trace
+p.reject('Timeout');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can set global defaults for all future Pledge instances using Pledge.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge.init({
+  debug: 5,
+  onSettle: () => GlobalSpinner.stop()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To reset to library defaults:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge.init();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Automatic Cleanup (Symbol.dispose) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge implements the Disposable interface. You can automatically reject a pending pledge at the end of a scope by declaring it with the using keyword, or by explicitly invoking [Symbol.dispose](). Ordinary block exit (without using) or garbage collection will not trigger disposal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using p = new Pledge('ScopedOperation');
+  // if p is not resolved/rejected by the end of this block, 
+  // it is automatically rejected with "Pledge disposed".
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. State Accessors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.state: Returns 'pending', 'resolved', or 'rejected'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isPending: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isResolved: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isRejected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isSettled: boolean (resolved or rejected)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.status: Returns a snapshot of the full status object (tag, state, settled value, error).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,25)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.lean.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.lean.js new file mode 100644 index 00000000..5da12633 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.pledge.md.Cb7-u_mT.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as e,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Pledge: Advanced Asynchronous Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.pledge.md","filePath":"doc/6-utility-library/tempo.pledge.md"}'),t={name:"doc/6-utility-library/tempo.pledge.md"};function l(h,s,p,k,d,r){return a(),e("div",null,[...s[0]||(s[0]=[n("",25)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.js new file mode 100644 index 00000000..88cfd03a --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.js @@ -0,0 +1,55 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Reactive: High-Performance Push/Pull Streams","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.reactive.md","filePath":"doc/6-utility-library/tempo.reactive.md"}'),e={name:"doc/6-utility-library/tempo.reactive.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive: High-Performance Push/Pull Streams ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> is a modern, lightweight asynchronous stream primitive built into the Tempo Utility Library. It bridges the gap between push-based event listeners and pull-based async iterators without the overhead of heavy third-party reactive extensions.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Core Concepts: Push/Pull Duality ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unlike standard EventEmitter (push-only) or AsyncGenerator (pull-only), Reactive<T> operates seamlessly in both directions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Producer Push (stream.push(value)): Dispatches the next value to a single pending pull waiter or buffers for future consumers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Producer Cast (stream.cast(value)): Multicasts the value to all concurrent pull waiters and push listeners simultaneously (fan-out).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Pull (await stream.pull()): Pulls the next available value directly as Promise<T | undefined>, eliminating { value, done } unwrapping boilerplate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Push (stream.on('data', listener)): Subscribes callback listeners for event-driven workflows.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Iteration (for await (const item of stream)): Native ES2018 iteration with backpressure buffering and zero lost items.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Reactive } from '@magmacomputing/tempo/library';
+
+// Create a typed reactive stream
+const stream = new Reactive<string>({ tag: 'TaskStream' });
+
+// Producer pushes data
+stream.push('First Event');
+stream.cast('Broadcast Event'); // Casts to all active pull waiters and listeners
+
+// Consumer pulls data directly
+const first = await stream.pull();  // 'First Event'
+const second = await stream.pull(); // 'Broadcast Event'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Push-Based Event Subscriptions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Register event listeners using familiar on(), once(), and off() methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Register data listener with early-stop capability
+stream.on('data', (item, stop) => {
+  console.log('Received:', item);
+  if (item === 'HALT') stop(); // Completes the stream
+});
+
+// Register error or completion listeners
+stream.on('error', (err) => console.error('Stream error:', err));
+stream.on('end', () => console.log('Stream completed'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Disposal with using ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stream.on() returns a disposable Reactive.Subscription object conforming to the TC39 Explicit Resource Management standard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using sub = stream.on('data', (data) => {
+    console.log('Scoped data:', data);
+  });
+  
+  // When execution leaves this scope, sub[Symbol.dispose]() is called automatically
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also unsubscribe manually at any time via sub.unsubscribe() or sub[Symbol.dispose]().


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Pull-Based Async Iteration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> implements AsyncIterable<T>, making it natively consumable with for await:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    async function processEvents(stream: Reactive<number>) {
+  for await (const value of stream) {
+    console.log('Processing:', value);
+  }
+  console.log('All events processed!');
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Stream Truncation with .until() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Easily terminate or gate a stream using an AbortSignal, a Promise, or another Reactive stream:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const controller = new AbortController();
+const boundedStream = stream.until(controller.signal);
+
+// Or bound by another reactive event:
+const stopper = new Reactive<void>();
+const gated = stream.until(stopper);
+
+// When stopper.push() or controller.abort() fires, gated stream cleanly completes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Resource Management & GC Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> implements both Disposable and AsyncDisposable:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using managedStream = new Reactive<number>();
+  // Producer and consumer operations...
+  // Stream is automatically completed upon block exit
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automatic Finalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Backed by Finalizer, any unclosed reactive stream that is dropped and garbage-collected will automatically settle pending promise waiters and tear down internal buffers, preventing orphaned promises and memory leaks.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Static Factory Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Convert existing collections, promises, or async iterables into reactive streams using Reactive.from():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // From an array
+const streamFromArray = Reactive.from(['alpha', 'beta', 'gamma']);
+
+// From an async iterable or Promise
+const streamFromPromise = Reactive.from(fetchDataAsync());

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Stream State Inspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspect stream statistics and runtime status via stream.state:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(stream.state);
+// {
+//   tag: 'TaskStream',
+//   active: true,
+//   completed: false,
+//   emitted: 42,
+//   subscribers: 2,
+//   queued: 0,
+//   buffered: 0
+// }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,37)])])}const E=i(e,[["render",l]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.lean.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.lean.js new file mode 100644 index 00000000..88466e93 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.reactive.md.Cr92yDbJ.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Reactive: High-Performance Push/Pull Streams","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.reactive.md","filePath":"doc/6-utility-library/tempo.reactive.md"}'),e={name:"doc/6-utility-library/tempo.reactive.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n("",37)])])}const E=i(e,[["render",l]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.js new file mode 100644 index 00000000..3c102cad --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.js @@ -0,0 +1,15 @@ +import{_ as i,o as s,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Tempo Serializers (stringify, objectify, cloneify)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.serializers.md","filePath":"doc/6-utility-library/tempo.serializers.md"}'),n={name:"doc/6-utility-library/tempo.serializers.md"};function o(r,e,l,d,h,c){return s(),a("div",null,[...e[0]||(e[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Serializers (stringify, objectify, cloneify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a custom serialization suite designed to succeed where standard native JSON methods fail. Complex JavaScript types like Map, Set, BigInt, Symbol, and Date routinely break or mangle when passed through standard JSON.stringify().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains what the serialization tools do, their benefits over native methods, how they are used inside the library, and their trade-offs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Core Functions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The serializers are heavily utilized under the hood but are also exposed for robust data handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(obj) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Serializes variables, primitives, and rich objects into string-safe representations. Unlike standard JSON, it detects complex types and translates them into identifiable single key:value structures (e.g., {"$BigInt":"123"}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { stringify } from '@magmacomputing/tempo/library';
+
+const richData = new Map([
+  ['time', new Date()],
+  ['id', Symbol.for('session')],
+  ['count', 100n]
+]);
+
+const safeString = stringify(richData);
+// Safely serialized, preserving Map, Date, Symbol, and BigInt topologies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    objectify(str, sentinel?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The inverse of stringify. It rebuilds an object from its stringified representation, parsing the specialized { $Type: value } signatures back into their native JavaScript object instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { objectify } from '@magmacomputing/tempo/library';
+
+const restored = objectify(safeString);
+// restored instance is a true Map, containing true Date, Symbol, and BigInt primitives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cloneify(obj, sentinel?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a deep-copy of an object by piping it through stringify and immediately back through objectify. This results in a detached, deeply cloned object that retains its rich types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { cloneify } from '@magmacomputing/tempo/library';
+
+const detachedCopy = cloneify(richData);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Both objectify and cloneify accept an optional sentinel function, which allows you to dynamically replace undefined values during the rebuild phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Selling the Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why not just use JSON.parse(JSON.stringify(obj)) or structuredClone()?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Preservation of Rich Types: JSON.stringify() instantly throws a TypeError if it encounters a BigInt. It silently strips undefined, reduces Date to a dumb string, and mangles Set/Map into empty {} objects. Tempo's stringify preserves all of these.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fallback for structuredClone: While structuredClone is great, it is not universally available in older environments and throws an error if it encounters functions. cloneify gives you a guaranteed deep-clone that resurrects your precise types reliably.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Safe Encoding: Strings are natively URI-encoded for control characters, ensuring safe stashing in fragile WebStorage or cache environments without injection/corruption vulnerabilities.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Class Registration: User-defined classes can be resurrected after stringification if they are decorated with Tempo's @Serialize() registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. How They Are Used Inside Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internally, these robust guarantees allow Tempo to safely toss memory-heavy or complex objects around asynchronously:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Caching & Storage (storage.library.ts): Used to safely serialize and deserialize internal state and user settings to localStorage, sessionStorage, or NodeJS process.env.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cryptography (cipher.class.ts): Complex payloads are reliably stringified prior to hashing and encryption, guaranteeing that decrypting the payload yields the exact original JavaScript topology.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deep Cloning Templates (term.season.ts, etc): Core plugins define fixed objects or arrays (like meteorological season date boundaries). cloneify is used extensively to serve detached copies of those arrays to standard operations, ensuring that the original base configuration can never be accidentally mutated by reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Drawbacks (Over JSON Methods) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance / Execution Speed: Operations that map, inspect, and safely cast specialized strings are slower than the highly-optimized C++ engine driving the native JSON namespace. If you only have raw text and numbers, standard JSON.stringify will be faster.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Payload Size: Because unsupported types are wrapped in identifier signatures (e.g., Set -> {"$Set":"[1,2,3]"}), the resulting string weight can be slightly heavier than stripped-down raw JSON.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unsupported Memory Types: Just like JSON, stringify cannot safely serialize transient memory references. Standard JS Function, AsyncFunction, WeakMap, WeakSet, and WeakRef are ignored/bypassed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,27)])])}const y=i(n,[["render",o]]);export{k as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.lean.js b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.lean.js new file mode 100644 index 00000000..1f7222d4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_6-utility-library_tempo.serializers.md.CEZ8my07.lean.js @@ -0,0 +1 @@ +import{_ as i,o as s,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Tempo Serializers (stringify, objectify, cloneify)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/6-utility-library/tempo.serializers.md","filePath":"doc/6-utility-library/tempo.serializers.md"}'),n={name:"doc/6-utility-library/tempo.serializers.md"};function o(r,e,l,d,h,c){return s(),a("div",null,[...e[0]||(e[0]=[t("",27)])])}const y=i(n,[["render",o]]);export{k as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.js new file mode 100644 index 00000000..fc5c3112 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.js @@ -0,0 +1 @@ +import{_ as e,o,c as a,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"🥊 Tempo vs. The Competition","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/comparison.md","filePath":"doc/7-ecosystem/comparison.md"}'),i={name:"doc/7-ecosystem/comparison.md"};function r(s,t,l,d,c,g){return o(),a("div",null,[...t[0]||(t[0]=[n('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🥊 Tempo vs. The Competition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are choosing a date library today, you are likely looking at Day.js, Luxon, or date-fns. While these are excellent tools, they were all built for the legacy Date era.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is the first premium wrapper built specifically for the Temporal API (Stage 4), giving it unique advantages that legacy libraries simply cannot match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    At a Glance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureTempo 💎Raw Temporal APIDay.js / MomentLuxondate-fns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FoundationNative TemporalNative TemporalLegacy DateLegacy Intl + DateLegacy Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PrecisionNanosecondsNanosecondsMillisecondsMillisecondsMilliseconds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ParsingHuman-CentricStrict ISO OnlyStrict / PluginStrictModular / Strict
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FormattingSmart Tokens & GettersVerbose Intl OnlyToken-Based (Moment style)Token-Based (Unicode)Token-Based (Unicode helper)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business LogicTerms SystemManual MathManual MathManual MathManual Math
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time ZonesFirst-ClassFirst-ClassPlugin-basedBuilt-inSeparate Lib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Future-Proof100% (Native)100% (Native)Maintenance ModePlanned SunsetTransitioning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💎 Why Tempo Wins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The "Terms" Engine (Business Intelligence) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Most libraries stop at "adding 2 days." Tempo introduces the Terms system, allowing you to encode domain-specific logic (Fiscal Quarters, Meteorological Seasons, Academic terms, Zodiac Signs) directly into the Tempo term object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: You have to write custom utility functions and import them everywhere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Human-Centric Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day.js and Luxon are quite strict. If your string isn't in exactly the right format, they fail. Tempo’s Snippet & Layout engine is designed to be forgiving, extensible, and human-centric, handling relative dates like "next Friday" or "Christmas" out of the box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Often requires an external library like Chrono or complex regex boilerplate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Nanosecond Precision ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Date (and thus Day.js/Luxon/date-fns) is limited to milliseconds. For high-frequency trading, scientific data, or distributed systems, this isn't enough. Tempo inherits nanosecond precision from the Temporal API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Capped at 1/1000th of a second.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Zero "Leaky Abstractions" ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a legacy library, you are often fighting the weirdness of the 1995 Date object (like months being 0-indexed). Tempo is built on Temporal, which was designed from the ground up to be mathematically sound and developer-friendly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Intelligent Formatting & Shorthands ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While native Temporal is highly precise, formatting dates for a UI in native Temporal is extremely verbose. It relies entirely on the native Intl API, requiring you to construct complex option objects or use long .toLocaleString() boilerplate just to output simple strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo solves this by offering a Smart Token Engine (using {yyyy}-{mm}-{dd} placeholders) alongside built-in, highly optimized format getters like .fmt.date, .fmt.time, or .fmt.dateTime. In addition, Tempo automatically memoizes internal formatters under the hood, delivering top-tier performance without developer boilerplate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Raw Temporal requires verbose Intl configurations; legacy libraries require large plugins or separate helper imports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Temporal Transition Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As JavaScript transitions natively to the Temporal API, the existing ecosystem is taking different paths. This presents a unique opportunity for new, Temporal-first architectures like Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Luxon: The creators have explicitly stated they plan to sunset Luxon as Temporal adoption grows, eventually becoming "a distant memory."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Day.js: Architecturally bound to the legacy Date object to maintain its <2kB size and Moment.js compatibility. It cannot evolve to support native Temporal objects and will remain a tool for legacy codebases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • date-fns: Transforming into a companion utility kit tailored around native Temporal objects (evidenced by their bridging project, date-fns/interim), while maintaining dual support for legacy Date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Luxon is bowing out and Day.js cannot evolve architecturally without losing its identity, Tempo steps in as the premier, dedicated premium wrapper built specifically for the Temporal era from day one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Which should you choose? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Day.js if: You have a legacy codebase and need a tiny <2KB patch for simple tasks, and are comfortable using a library in maintenance mode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Luxon if: You need a stable bridge for environments that don't yet support Temporal, but keep in mind it is actively planning for sunset.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose date-fns if: You have an existing codebase heavily invested in date-fns pipelines and want to leverage their transitional bridge as you migrate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose @magmacomputing/tempo-fns if: You prefer pure, tree-shakeable functional utilities designed natively for Temporal objects (and Tempo terms) without the overhead of a class-based wrapper.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Tempo if: You want a premium, Temporal-first architecture that provides fluent chaining, high precision, human-centric parsing, and the ability to model complex business-date logic directly into your application.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready to start? See the Quick Start Guide →

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',32)])])}const u=e(i,[["render",r]]);export{m as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.lean.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.lean.js new file mode 100644 index 00000000..30fc08b6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_comparison.md.B9HAtuQF.lean.js @@ -0,0 +1 @@ +import{_ as e,o,c as a,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"🥊 Tempo vs. The Competition","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/comparison.md","filePath":"doc/7-ecosystem/comparison.md"}'),i={name:"doc/7-ecosystem/comparison.md"};function r(s,t,l,d,c,g){return o(),a("div",null,[...t[0]||(t[0]=[n("",32)])])}const u=e(i,[["render",r]]);export{m as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.js new file mode 100644 index 00000000..ed639028 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.js @@ -0,0 +1,46 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"🤝 Extending Native Temporal","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/extending-temporal.md","filePath":"doc/7-ecosystem/extending-temporal.md"}'),e={name:"doc/7-ecosystem/extending-temporal.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Extending Native Temporal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORTANT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is NOT a replacement for Native Temporal. Temporal provides an excellent, mathematically sound foundation for dates in JavaScript, and Tempo is built directly on top of it. Tempo acts as a developer-friendly wrapper that eliminates boilerplate and makes common tasks effortless, while retaining the rock-solid reliability of Temporal under the hood.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To complement Temporal's explicit strictness, Tempo adds:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Flexibility: Out-of-the-box natural language parsing and intelligent formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Convenience: Extensive getters, method chaining, and zero-configuration defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configurability: Dynamic semantic aliases for resolving events and periods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extensibility: A lazy-loaded plugin architecture for domain-specific calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Here is a side-by-side comparison demonstrating how Tempo drastically reduces boilerplate for standard operations, while unlocking capabilities that are difficult to achieve with native Temporal alone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Parsing: Strict vs. Intelligent ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal only accepts strict ISO 8601 strings. If you have user input, database dumps, or human-readable dates, you have to write your own parser first. Tempo handles it out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal ❌

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+Temporal.PlainDate.from('2026/01/24');    // Throws RangeError: invalid ISO 8601 string
+Temporal.PlainDate.from('next Friday');   // Throws RangeError: invalid ISO 8601 string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo ✅

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+new Tempo('2026/01/24');                  // Parses perfectly
+new Tempo('next Friday');                 // Parses relative natural language perfectly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information on handling natural language and complex strings, read the dedicated Parsing Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Formatting: Verbose vs. Expressive Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal relies on the Intl.DateTimeFormat API for formatting. While powerful for localization, it is incredibly verbose for simple, specific string outputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = Temporal.Now.plainDateISO();
+date.toLocaleString('en-GB', { day: 'numeric', month: 'short', year: 'numeric' });  // Output: "24 Jan 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-24T12:00:00');
+
+// Use the format method to create custom formats, or use the pre-built getters (on the 'fmt' property)
+t.format('{dd} {mmm} {yyyy}');            // Output: "24 Jan 2026"
+t.fmt.date;                               // Output: "2026-01-24"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For comprehensive examples of localized output and custom layouts, read the dedicated Formatting Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Extensibility: Domain-Specific Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal deals strictly with standard calendar units (days, months, years). If you need to map a date to domain-specific logic (like a fiscal quarter or a meteorological season), you have to write and maintain your own math utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = Temporal.Now.plainDateISO();
+
+// 1. Calculate the fiscal quarter
+const month = date.month;
+const fiscalQuarter = \`Q\${Math.ceil(month / 3)}\`; // Manual math
+
+// 2. Calculate the meteorological season (Northern Hemisphere)
+let season;
+if (month === 12 || month <= 2) season = 'Winter';
+else if (month >= 3 && month <= 5) season = 'Spring';
+else if (month >= 6 && month <= 8) season = 'Summer';
+else season = 'Autumn';
+
+// And what if you need to support the Southern Hemisphere? 
+// You have to write and maintain even more utility functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀 Tempo solves this elegantly using the Terms plugin system. Terms are lazy-loaded plugins that evaluate the current date against semantic boundaries without adding memory bloat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-24T12:00:00', { sphere: 'north' });
+
+// Built-in complex Terms via the standard plugin
+t.term.qtr; // → 'Q1' (Calculates fiscal quarter)
+t.term.szn; // → 'Winter' (Calculates meteorological season, respecting hemisphere)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information on adding your own domain-specific logic, read the dedicated Terms Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Duration Logic: Strict Math vs. Human Readable ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculating the difference between two dates in native Temporal is mathematically sound, but it strictly returns a Temporal.Duration object. Tempo gives you the flexibility to return a Duration object, a precise floating-point number, or a human-readable string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Calculate the raw duration
+const now = Temporal.Now.plainDateISO();
+const target = Temporal.PlainDate.from('2026-12-25');
+now.until(target); // → Returns a complex Duration object
+
+// 2. Format a past date into a human-readable string (relative to a fixed point)
+const refDate = Temporal.PlainDate.from('2026-07-09');
+const pastDate = Temporal.PlainDate.from('2026-07-06');
+const diff = pastDate.until(refDate, { largestUnit: 'days' });
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+rtf.format(-Math.abs(diff.days), 'day'); // → "3 days ago"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀 Tempo understands natural language targets and provides multiple ways to measure and format the resulting elapsed time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-05-20T08:00:00');
+
+// 1. .until() returns an EDO or a precise number
+t.until('2026-12-25').duration; // → The underlying Temporal.Duration object
+t.until('2026-12-25', 'days');  // → 219
+
+// 2. .since() instantly returns human-readable relative strings
+const t2 = new Tempo('2026-07-09');
+t2.since('2026-07-06', 'days'); // → "3 days ago"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.until() returns a highly functional Extended Data Object (EDO) or a precise decimal number depending on your arguments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.since() leverages Intl.RelativeTimeFormat to instantly return human-readable relative strings (like "3 days ago").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For comprehensive examples of duration mathematics, intelligent balancing, and localization formatting, read the dedicated Duration Logic Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,34)])])}const E=i(e,[["render",l]]);export{g as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.lean.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.lean.js new file mode 100644 index 00000000..96b257fd --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_extending-temporal.md.DwO8Wlze.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"🤝 Extending Native Temporal","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/extending-temporal.md","filePath":"doc/7-ecosystem/extending-temporal.md"}'),e={name:"doc/7-ecosystem/extending-temporal.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n("",34)])])}const E=i(e,[["render",l]]);export{g as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.js new file mode 100644 index 00000000..6a5116bc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.js @@ -0,0 +1 @@ +import{_ as a,o as i,c as t,a2 as o}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"The Vision for Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/vision.md","filePath":"doc/7-ecosystem/vision.md"}'),n={name:"doc/7-ecosystem/vision.md"};function r(s,e,l,c,d,h){return i(),t("div",null,[...e[0]||(e[0]=[o('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Vision for Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduction: Humanizing Temporal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The ECMAScript Temporal specification represents a monumental leap forward for JavaScript dates, providing mathematical rigor, timezone correctness, and nanosecond precision. However, as an engine-level foundation, native Temporal is intentionally low-level, verbose, and rigid. Answering everyday human questions—such as "What time is it where our client is right now?", "Is it daylight or business hours at their location?", or "How many business days until the next fiscal quarter?"—can feel mechanically clunky, requiring developers to stitch together multiple disjoint types, offset normalizers, calendar converters, and external APIs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's primary mission is to humanize Temporal: transforming low-level precision into an intuitive, expressive, and effortless developer experience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We believe that developer ergonomics should never compromise mathematical correctness. Tempo achieves this balance by providing a rock-solid ISO 8601 baseline—ensuring deterministic calendar arithmetic, guaranteed immutable safety, and explicit ISO escape hatches—paired with rich regional and cultural awareness (standardized Intl.Locale info) that understands human intent and local calendar conventions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Core Value Proposition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Closing the Onboarding Gap ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modern developers expect a "warm" API for common tasks. Native Temporal requires explicit types and strict ISO formats for almost every operation. Tempo provides a familiar, intuitive entry point (similar to the ease of Day.js) while maintaining the rock-solid reliability of Temporal under the hood.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Human-Centric Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data in the real world is messy. Tempo's Layout and Snippet engine allows developers to interpret human-readable strings, aliases, and custom formats without writing complex custom utility functions. It turns "today", "next Friday 3pm", or "Christmas" into machine-exact time points effortlessly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Contextual & Business Intelligence via Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time and physical reality are inseparable: civil time only has meaning relative to a location, a business calendar, or natural cycles. Through its modular plugin architecture, Tempo bridges time with real-world context—such as IP and GPS geolocation, fiscal quarters, meteorological seasons, and astronomical cycles—moving domain-specific complexity out of application code and into reusable, extensible plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Lean, Deterministic, and Hardened ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed to be a thin, highly capable layer. It prioritizes a lightweight, ergonomic API surface for the developer while maintaining robust internal logic to handle the complexities of timezones, calendars, and durations with zero mutable side effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Conclusion ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is not intended to replace Temporal, but to humanize it. It is the tool for developers who want the future of JavaScript dates today, without the overhead of building their own high-level utility library from scratch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',16)])])}const p=a(n,[["render",r]]);export{u as __pageData,p as default}; diff --git a/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.lean.js b/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.lean.js new file mode 100644 index 00000000..86021324 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_7-ecosystem_vision.md.D1ERmYL4.lean.js @@ -0,0 +1 @@ +import{_ as a,o as i,c as t,a2 as o}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"The Vision for Tempo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/7-ecosystem/vision.md","filePath":"doc/7-ecosystem/vision.md"}'),n={name:"doc/7-ecosystem/vision.md"};function r(s,e,l,c,d,h){return i(),t("div",null,[...e[0]||(e[0]=[o("",16)])])}const p=a(n,[["render",r]]);export{u as __pageData,p as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.js new file mode 100644 index 00000000..380d3df3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.js @@ -0,0 +1 @@ +import{_ as i,o,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"🤝 Magma Computing Solutions: Professional Services","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/commercial.md","filePath":"doc/8-project-and-support/commercial.md"}'),r={name:"doc/8-project-and-support/commercial.md"};function n(s,e,l,c,m,u){return o(),a("div",null,[...e[0]||(e[0]=[t('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Magma Computing Solutions: Professional Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a high-performance, precision date-time library maintained by Magma Computing Solutions. We offer a range of professional services and private extensions to help teams build robust, time-sensitive applications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Our Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Custom Plugin Development ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need a specialized plugin for your industry? We design and implement high-performance Tempo extensions such as:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Financial Tickers: Real-time market-aware pulses with weekend/holiday suppression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Timelines: Complex shift-based scheduling and resource allocation generators.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Terms: Domain-specific date ranges (e.g., academic years, retail seasons, or medical billing cycles).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏛️ Architecture & Migration Consulting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transitioning from legacy libraries like Moment.js or Luxon? Our team can:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Audit your existing date-time logic for Temporal compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Perform high-fidelity migrations of complex "relative time" calculations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optimize performance for large-scale data processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Enterprise Support & Commercial Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For mission-critical applications, we provide:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Priority commercial support and SLA guarantees.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Security auditing and bespoke feature engineering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom enterprise plugins tailored to private infrastructures.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📬 Contact Us ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready to discuss your project? Get in touch with our engineering team:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Core is 100% open source under the MIT license. Our professional services are designed to complement the open-source library with deep domain expertise, custom plugin engineering, and enterprise SLA support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',18)])])}const d=i(r,[["render",n]]);export{g as __pageData,d as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.lean.js new file mode 100644 index 00000000..553cd1b4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_commercial.md.BiO4Lygj.lean.js @@ -0,0 +1 @@ +import{_ as i,o,c as a,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"🤝 Magma Computing Solutions: Professional Services","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/commercial.md","filePath":"doc/8-project-and-support/commercial.md"}'),r={name:"doc/8-project-and-support/commercial.md"};function n(s,e,l,c,m,u){return o(),a("div",null,[...e[0]||(e[0]=[t("",18)])])}const d=i(r,[["render",n]]);export{g as __pageData,d as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.js new file mode 100644 index 00000000..f2a27a9d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.js @@ -0,0 +1,60 @@ +import{_ as e,o as a,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"⚠️ Migrating to Tempo v4.x","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/migration-guide.md","filePath":"doc/8-project-and-support/migration-guide.md"}'),n={name:"doc/8-project-and-support/migration-guide.md"};function o(l,i,p,r,d,h){return a(),s("div",null,[...i[0]||(i[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v4.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.x introduces a standardized plugin & registry architecture, strict configuration namespaces, cascading configuration inheritance, and deterministic resource disposal while excising legacy v3.x deprecated interfaces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Dynamic Functional Context (DFC) & Supplier Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.0.0, core configuration options (timeZone, locale, calendar, sphere) accept lazy Evaluable<T> supplier functions (() => T) as well as static scalars. This enables dynamic, per-request context resolution (e.g. multi-tenant session headers, request-scoped localizations) without recreating Tempo options or rebuilding configuration objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ✅ v4.0.0 - Dynamic per-request timezone resolution
+import { Tempo } from '@magmacomputing/tempo';
+import { getActiveTenantTimezone } from './session';
+
+Tempo.init({
+  timeZone: () => getActiveTenantTimezone(), // Re-evaluated dynamically when context getters execute
+  locale: () => getCurrentUserLocale()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Plugin SDK Subpath (@magmacomputing/tempo/plugin/sdk) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.0.0, all custom plugin, term, module, and namespace development is standardized on @magmacomputing/tempo/plugin/sdk.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy Imports: Deprecated plugin-api.index.ts and #tempo/license subpath imports have been removed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SDK Import: Import definePlugin, defineTerm, defineModule, defineNamespace, defineRange, and evaluation utilities directly from @magmacomputing/tempo/plugin/sdk.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ v3.x (Deprecated)
+import { definePlugin } from '@magmacomputing/tempo/plugin-api';
+
+// ✅ v4.0.0
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Zero-await Synchronous JSONC Config Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 introduces resolveConfigSync() for zero-await synchronous configuration discovery when using .json or .jsonc configuration files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .json / .jsonc files: Dynamically discovered and parsed synchronously during module initialization via parseJSONC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .ts / .mts / .mjs / .js files: Asynchronously loaded via resolveConfig().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated .cjs config discovery files are no longer automatically scanned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔓 100% Open-Source Community Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 Community Core is 100% open-source without commercial license validation hooks or JWT scope checks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • License keys (licenseKey, TEMPO_LICENSE_KEY) are no longer required or checked in the Community Edition.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.ready() returns 'none' for community core compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Commercial plugin management and domain-locking hooks have been relocated into the @magmacomputing/tempo-pro enterprise package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Tempo v4.1.0 Updates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.1.0 introduces cascading configuration inheritance (extends), a dedicated pluginOptions configuration slot, and overloaded Tempo.create() with deterministic resource cleanup (TC39 using).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Configuration Inheritance (extends), plugins, and pluginOptions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.1.0, configuration, plugin registration, and runtime options have been cleanly separated:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Inheritance (extends): The extends option in Tempo.init() or tempo.config.json is strictly reserved for cascading configuration inheritance via local file paths or file:// URLs (mirroring tsconfig.json and ESLint conventions): extends: './tempo-base.json'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Registration (plugins): Pass executable plugins, terms, and modules into plugins: [TickerPlugin, CelestialPlugin].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Configuration Slot (pluginOptions): Pass runtime configuration defaults for plugins into pluginOptions: { ticker: { interval: 500 } }. The 'plugins' key as a JSON of plugin-configuration settings has been migrated to pluginOptions so as not to overload the plugins key (which registers Plugin instances / Terms / Modules / Namespaces).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Imperative Registration (Tempo.use): Use the standard Tempo.use(Plugin) static method to register plugins, terms, or modules at runtime. Tempo.extend() is @deprecated Use Tempo.use(...) instead..

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ✅ v4.1.0: Clean Separation
+Tempo.init({
+  extends: './tempo-base.json',                                     // Configuration inheritance
+  plugins: [TickerPlugin, CelestialPlugin],                         // Feature & Term registration
+  pluginOptions: {                                                  // Plugin runtime options
+    ticker: { interval: 500 }
+  }
+});
+
+// ✅ Imperative registration
+Tempo.use(TickerPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔒 Overloaded Tempo.create() & Scoped Disposal (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.1.0, Tempo.create() introduces deterministic resource cleanup via TC39 Explicit Resource Management:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Callback Mode: Run isolated operations without leaking sandbox state to the global scope:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const season = Tempo.create((sb) => {
+  sb.use(CelestialPlugin);
+  return sb('2026-06-21').term.astronomy.season;
+}); // sandbox automatically disposed upon completion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TC39 Explicit Resource Management (using):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
+  using sb = Tempo.create({ discovery: 'ephemeral' });
+  sb.use(MyPlugin);
+} // sb[Symbol.dispose]() called automatically

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📂 Data Augmentation (registry: { ... }) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All custom format definitions, locale mappings, modifiers, tokens, snippets, layouts, events, periods, ignores, and number-word definitions are consolidated under the registry namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Number-Word Mappings: Top-level numbers: { ... } has been moved to registry: { numbers: { ... } }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Formats: Top-level formats: { ... } has been moved to registry: { formats: { ... } }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Discovery: Discovery objects (Symbol.for('$Tempo')) use registry: { numbers: { ... }, formats: { ... } } instead of top-level discovery.numbers or discovery.formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example Migration: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ v3.x (Deprecated)
+Tempo.init({
+  numbers: { un: 1, deux: 2 },
+  formats: { customDate: '{yyyy}-{mm}-{dd}' }
+});
+
+// ✅ v4.0.0
+Tempo.init({
+  registry: {
+    numbers: { un: 1, deux: 2 },
+    formats: { customDate: '{yyyy}-{mm}-{dd}' }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧹 Deprecated Type & API Cleanup ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use vs Tempo.uses: The legacy alias Tempo.uses has been excised. Use Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TempoInstance Type: TempoInstance interface alias has been removed in favor of standard Tempo class/instance types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mutable<T> to MutableObject<T>: The utility type Mutable<T> has been renamed to MutableObject<T> to prevent naming collisions with the @Mutable member decorator and clarify object-level readonly stripping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v3.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v3.x finalizes the plugin ecosystem by extracting advanced features into standalone, licensed packages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating to Tempo v3.x (Ticker Extraction) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The TickerPlugin has been extracted from the core engine into a standalone open-source Community plugin (@magmacomputing/tempo-plugin-ticker).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. If you use Tempo.ticker(), install @magmacomputing/tempo-plugin-ticker alongside @magmacomputing/tempo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Import and register the plugin in your application initialization:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+Tempo.init({
+  plugins: [TickerPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v2.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.x introduces architectural improvements and a more modular engine. While we strive for backward compatibility, there are some key changes to consider when upgrading from v1.x.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Modular Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is now split into a core engine and optional modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you use the full package: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you import from @magmacomputing/tempo, everything (except Plugin extensions, like .ticker()) is included and works exactly like v1.x. No changes are required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want a lean bundle: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now import the core engine only:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you do this, you must manually import the features you need. Built-in features now self-register on import via side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Feature Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Features like mutation, duration, format, and the ticker are now modular.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1.x (Automatic) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v1.x, all features were always present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.x (Opt-in for Core) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If using the Core engine, simply import the module to activate the feature:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/duration';
+import '@magmacomputing/tempo/ticker';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ Term Logic Refactor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The way Terms (Quarters, Seasons, Zodiacs, etc.) are handled has been unified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1.x: Some Term properties were ad-hoc on the instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.x: All Term logic is centralized under the .term property or accessible via the # shorthand in .set() and .add().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example of new syntax:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Snap to start of quarter
+t.set({ '#quarter': 'start' });
+
+// Add two quarters while preserving day-of-quarter
+t.add({ '#quarter': 2 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Tempo v2.4.0: Standalone Utilities & Path Deprecation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.4.0 introduces standalone utility entry points for parse and format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Standalone Imports ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now import lightweight, tree-shakable versions of our parsing and formatting engines without the Tempo class:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parse } from '@magmacomputing/tempo/parse';
+import { format } from '@magmacomputing/tempo/format';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Reorganized Paths ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We have reorganized the package structure to support these standalone entry points more cleanly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Use package subpath maps: Update your imports to use the official entry points:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ❌ @magmacomputing/tempo/module/parse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ❌ @magmacomputing/tempo/module/format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ✅ @magmacomputing/tempo/parse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ✅ @magmacomputing/tempo/format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Check your Import Maps: If you use browser-side import maps, ensure they point to package subpath locations rather than internal folder paths. A maintained importmap.json is included in the package root (packages/tempo/importmap.json) as the sanctioned reference for each release.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note: The shipped packages/tempo/importmap.json is the supported exception for version-locked internal mappings. Use it as-is for your installed Tempo version instead of hand-authoring dist/ paths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+    "imports": {
+        "@magmacomputing/tempo/parse": "./node_modules/@magmacomputing/tempo/parse",
+        "@magmacomputing/tempo/format": "./node_modules/@magmacomputing/tempo/format"
+    }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.4 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As Tempo grows, it has become much more efficient for our developers to logically re-group certain modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Review your browser importmap entries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Replace any older internal paths with the current package subpath entries (for example, @magmacomputing/tempo/duration, @magmacomputing/tempo/mutate, @magmacomputing/tempo/parse, and @magmacomputing/tempo/format).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Do not pin imports in your code directly to internal folder layouts in dist/, since those paths may change as modules are reorganized. Instead rely wholly on your import maps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.6.0 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Season Term scope output has been simplified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. If you previously relied on the Chinese-specific object attached to term.season scope output, remove that dependency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Resolve Chinese season context by creating a dedicated Tempo instance with the appropriate Chinese timeZone for the interpretation you need.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.7.0 (Grouped Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo has rationalized its configuration surface by grouping related options into nested objects. This improves discoverability and allows for easier additive merging across the prototype chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month-Day (Regional Parsing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The individual mdyLocales and mdyLayouts options have been consolidated into a single monthDay object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.6.x: new Tempo({ mdyLocales: ['en-US'] })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.7.x: new Tempo({ monthDay: { locales: ['en-US'] } })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shortcut: new Tempo({ monthDay: true }) (enables forced MDY parsing using default locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The individual rtfFormat and rtfStyle options have been consolidated into a single relativeTimeFormat object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.6.x: new Tempo({ rtfStyle: 'long' })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.7.x: new Tempo({ relativeTimeFormat: { style: 'long' } })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only the deprecated top-level keys rtfFormat and rtfStyle are still accepted as legacy fallbacks in the current release, handled specifically in the Tempo class constructor for backward compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In contrast, the old mdyLocales and mdyLayouts keys are not treated as aliases and will be ignored; these must be migrated to the new nested monthDay structure. Update your configuration to ensure compatibility with future versions and the optimization engine. Refer to the Tempo constructor for implementation details on legacy alias handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating to version 2.9.3 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📏 BigInt Precision Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A breaking change was introduced to harmonize BigInt handling with numeric inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-v2.9.3: BigInt inputs were always treated as raw nanoseconds, regardless of the timeStamp configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.9.3+: BigInt inputs now respect the configured unit (default 'ms').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Before v2.9.3
+new Tempo(1000n).ts; // 1000 (nanoseconds)
+
+// After v2.9.3
+new Tempo(1000n).ts; // 1000 (milliseconds)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you previously relied on BigInt being treated as nanoseconds, you must now explicitly set the timeStamp unit to 'ns':

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo(1000n, { timeStamp: 'ns' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Removed Features (v3.0.0) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated Boolean Debug Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The debug configuration property no longer accepts boolean values. It has been strictly typed to accept numeric verbosity levels matching the internal LOG enum, or lowercase string labels (e.g. 'trace', 'info').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed: new Tempo({ debug: true })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recommended: new Tempo({ debug: 4 }), new Tempo({ debug: 'debug' }), or new Tempo({ debug: LOG.Debug }) (for parsing verbosity).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalization Naming ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To better align with ECMAScript standards (specifically Intl.RelativeTimeFormat), the relativeTime configuration option inside intl is no longer supported in v3.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed: new Tempo({ intl: { relativeTime: { style: 'long' } } })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recommended: new Tempo({ intl: { relativeTimeFormat: { style: 'long' } } })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Please migrate your configurations from relativeTime to relativeTimeFormat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Testing and Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.x has been hardened with a 100% pass rate on our regression suite. If you were relying on undocumented "quirks" or bugs in v1.x parsing, you may find that v2.x is more strict and deterministic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,116)])])}const k=e(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.lean.js new file mode 100644 index 00000000..bd95321b --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_migration-guide.md.DqJQcvlj.lean.js @@ -0,0 +1 @@ +import{_ as e,o as a,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"⚠️ Migrating to Tempo v4.x","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/migration-guide.md","filePath":"doc/8-project-and-support/migration-guide.md"}'),n={name:"doc/8-project-and-support/migration-guide.md"};function o(l,i,p,r,d,h){return a(),s("div",null,[...i[0]||(i[0]=[t("",116)])])}const k=e(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.js new file mode 100644 index 00000000..d55ae6b6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.js @@ -0,0 +1 @@ +import{_ as a,o as r,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"🚀 Releases","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/index.md","filePath":"doc/8-project-and-support/releases/index.md"}'),i={name:"doc/8-project-and-support/releases/index.md"};function o(s,e,l,c,d,h){return r(),t("div",null,[...e[0]||(e[0]=[n('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Releases ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore the evolution of Tempo through its version history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Release Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo follows Semantic Versioning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Major: Breaking changes and architectural shifts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Minor: New features and significant enhancements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Patch: Bug fixes and performance optimizations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',7)])])}const u=a(i,[["render",o]]);export{m as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.lean.js new file mode 100644 index 00000000..1e98986f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_index.md.GiHF45Dm.lean.js @@ -0,0 +1 @@ +import{_ as a,o as r,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"🚀 Releases","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/index.md","filePath":"doc/8-project-and-support/releases/index.md"}'),i={name:"doc/8-project-and-support/releases/index.md"};function o(s,e,l,c,d,h){return r(),t("div",null,[...e[0]||(e[0]=[n("",7)])])}const u=a(i,[["render",o]]);export{m as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.js new file mode 100644 index 00000000..877589ab --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.js @@ -0,0 +1 @@ +import{_ as a,o as t,c as r,a2 as o}from"./chunks/framework.DNL3hc5c.js";const p=JSON.parse('{"title":"📜 Version 0.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v0.x.md","filePath":"doc/8-project-and-support/releases/v0.x.md"}'),n={name:"doc/8-project-and-support/releases/v0.x.md"};function s(i,e,d,l,c,u){return t(),r("div",null,[...e[0]||(e[0]=[o('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 0.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v0.3.0] - 2025-07-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced an immutable property decorator and a deep-freeze utility for objects and arrays. Added a secure, default configuration module for date/time parsing. Extended global browser support for the Temporal API via polyfill.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Corrected the enumerable decorator to ensure proper closure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Refactor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Centralised and secured date/time parsing constants and layouts. Improved typing and immutability for enums and configuration objects. Updated logging and state management to use object-based constants instead of enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enhanced inline documentation and added detailed usage examples for enum utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated development dependencies to latest versions. Reformatted TypeScript configuration for clarity.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v0.2.0] - 2024-10-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated the version of the Tempo class to 0.2.0, ensuring users have access to the latest enhancements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolved versioning discrepancies in the Default configuration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',17)])])}const f=a(n,[["render",s]]);export{p as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.lean.js new file mode 100644 index 00000000..e6e0b6aa --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v0.x.md.QAGHuEEy.lean.js @@ -0,0 +1 @@ +import{_ as a,o as t,c as r,a2 as o}from"./chunks/framework.DNL3hc5c.js";const p=JSON.parse('{"title":"📜 Version 0.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v0.x.md","filePath":"doc/8-project-and-support/releases/v0.x.md"}'),n={name:"doc/8-project-and-support/releases/v0.x.md"};function s(i,e,d,l,c,u){return t(),r("div",null,[...e[0]||(e[0]=[o("",17)])])}const f=a(n,[["render",s]]);export{p as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.js new file mode 100644 index 00000000..d20b4fa9 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.js @@ -0,0 +1 @@ +import{_ as a,o as t,c as o,a2 as r}from"./chunks/framework.DNL3hc5c.js";const p=JSON.parse('{"title":"📜 Version 1.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v1.x.md","filePath":"doc/8-project-and-support/releases/v1.x.md"}'),i={name:"doc/8-project-and-support/releases/v1.x.md"};function n(s,e,d,c,l,u){return t(),o("div",null,[...e[0]||(e[0]=[r('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 1.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.3] - 2026-03-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser: persistent storage wrapper, multi‑tap gesture helper, geolocation + maps/address utilities, simple alert/prompt/confirm helpers. Server: sandboxed temp‑file API, HTTP helpers with timeouts, Base64 encode/decode, JWT payload decoder. Tempo v2.0.0: lazy initialization, unified Term math/format tokens (#{...}), anchor/term utilities and faster startup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Expanded API/type docs, architecture, benchmarks, migration and cookbook guidance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package scope renamed to @magmacomputing/*; new build/release scripts and updated TypeScript/test configs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.2] - 2026-03-23 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unified plugin system via Tempo.load() for plugins, Term plugins, and discovery configuration. Made Pledge thenable and awaitable via .then() method support. Enhanced makeTemplate() with safe placeholder substitution instead of code evaluation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Improved asCurrency() to properly coerce string inputs. Fixed constructor error handling to throw instead of returning empty objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added Target Audience section describing intended users and migration scenarios. Expanded Node.js documentation with native subpath import details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.1] - 2026-03-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin-based extension architecture for extending Tempo functionality Automatic plugin discovery via static Tempo.discover() method New subpath exports for enums, serialisation, Pledge utility, and Ticker plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changed ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker functionality now available as optional plugin; requires explicit installation Selective immutability for decorated classes instead of full object freeze Core methods (format, add, set) are now protected from overwrites

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive overhaul reflecting new plugin architecture Dedicated Pledge utility documentation added

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.0] - 2026-03-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced Tempo.ticker() — reactive clock streams via async-generator (for await...of) or callback subscription with stop control.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added a dedicated Ticker guide and updated Tempo docs with examples and API reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added unit tests covering callback mode, async-iterator mode and input validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bumped package version to 1.1.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',31)])])}const m=a(i,[["render",n]]);export{p as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.lean.js new file mode 100644 index 00000000..20d21c2a --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v1.x.md.Db-bMcxJ.lean.js @@ -0,0 +1 @@ +import{_ as a,o as t,c as o,a2 as r}from"./chunks/framework.DNL3hc5c.js";const p=JSON.parse('{"title":"📜 Version 1.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v1.x.md","filePath":"doc/8-project-and-support/releases/v1.x.md"}'),i={name:"doc/8-project-and-support/releases/v1.x.md"};function n(s,e,d,c,l,u){return t(),o("div",null,[...e[0]||(e[0]=[r("",31)])])}const m=a(i,[["render",n]]);export{p as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.js new file mode 100644 index 00000000..54930b80 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.js @@ -0,0 +1 @@ +import{_ as i,o as t,c as a,a2 as o}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"📜 Version 2.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v2.x.md","filePath":"doc/8-project-and-support/releases/v2.x.md"}'),n={name:"doc/8-project-and-support/releases/v2.x.md"};function r(l,e,s,d,c,u){return t(),a("div",null,[...e[0]||(e[0]=[o('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 2.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.11.0] - 2026-05-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Mathematics: Introduced the .balance() method to Tempo.Duration objects to allow intelligent mathematical roll-up of duration units (e.g., converting 365 days into 1 year), with support for both strict calendar math and nominal overrides ({ nominal: true }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Formatting: Introduced the .format() method to Tempo.Duration objects. This uses a shared, memoized internal implementation of Intl.NumberFormat to generate highly localized, plural-aware duration strings with excellent performance and robust cross-environment execution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Configuration: Added numberFormat to the IntlOptions interface, allowing developers to set global formatting defaults (like unitDisplay: 'short') via Tempo.init() that seamlessly cascade down to all .format() calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fixed ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Open Core Build Fallback: Updated the build:resolve script to gracefully fallback to Open Core licensing types when the proprietary @core module is unavailable, resolving CI build failures in public GitHub Actions environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.10.1] - 2026-05-23 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added support for license key discovery via global browser context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced license object output with formatted timestamps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved terms registry with better key-based indexing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced Free Showcase Astronomical Seasons premium plugin option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded license application guidance for browser, Node.js, and micro-frontend environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added network synchronization and offline behavior documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clarified logStamp format customization examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved relative time and duration string documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.10.0] - 2026-05-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added licensing system with JWT validation and revocation checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced Tempo.license public API for license state management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced Terms display with license metadata support
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term registration now enforces naming collision detection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed parsing side-effects and state leakage issues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved epoch timestamp precision with nanosecond-level fractional resolution for 9–10 digit timestamps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Comprehensive licensing architecture and strategy documentation added.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added guidance for CI-safe licensing stubs and cross-repo dependency management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.3] - 2026-05-10 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Engine Stabilization & Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Timestamp Resolution Fix: Corrected configuration propagation for timeStamp settings, ensuring consistent persistence across nested Tempo instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Epoch Precedence Logic: Optimized parseLayout to prioritize epoch-style numeric inputs, preventing layout misidentification for large timestamps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Unit Enforcement: Consolidated numeric resolution to strictly respect configured unit preferences for both Number and BigInt types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Normalizer Leak Protection: Hardened the alias normalizer with try/finally blocks to ensure proper cleanup of internal resolution keys, preventing memory leaks during high-frequency parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Type Safety & Environment Engine Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ZonedDateTime Mutation Ordering: Refined the internal mutation pipeline to ensure time zone and calendar application always precedes wall-clock updates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Interface Hardening: Resolved DOM interface collisions in internal types by correcting PluginContainer inheritance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Build Recovery: Patched dependency resolution between VitePress and MathJax to stabilize the documentation generation environment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Universal Type Guard Fix: Overhauled the internal assertion.library to eliminate "never poisoning" during complex union narrowing. Every type guard now explicitly specifies its target type, ensuring reliable Exclude and Extract behavior in downstream logic.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context Parity: Synchronized the functional alias "Resolution Context" (Host) with the public Tempo API. Methods like this.add() and this.set() in functional aliases now support the full range of Terms (#) and configuration overrides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Dependency Updates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Synchronized Monorepo: Updated @magmacomputing/library to 2.9.3.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Infrastructure Refresh: Updated core toolchain including TypeScript, Vitest, and Rollup to their latest compatible versions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.2] - 2026-05-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced Temporal support with improved timezone and calendar handling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added documentation for prototyping with regexp patterns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded installation guidance for Node.js Temporal support

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved parsing robustness with better symbol mapping and prototype-shadowing fixes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced identity-based layout resolution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strengthened lifecycle handling for timezone and calendar operations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optimized performance with dedicated guard and normalizer modules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Updated UI styling with theme-aware color variables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Refined error handling in engine components

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded main branch protection guidance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced architecture documentation with modular design overview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.0] - 2026-05-06 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Alias Architecture Stabilization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Alias Engine: Completed the architectural migration to the AliasEngine, centralizing all registration and resolution logic for Events and Periods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich Metadata Results: Enhanced the resolution engine to return structured AliasResult objects, providing better traceability and granular control over alias-driven parses.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened Clock Snapping: Finalized the standardization of clock-like alias resolution, ensuring consistent sub-second precision clearing for all static and functional time aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance Optimized Monitoring: Introduced a lightweight version-tracking system to detect registry mutations, enabling O(1) change detection during the Tempo lifecycle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Parser & Registry Refinement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consolidated Host Context: Modularized the construction of the functional alias "pseudo-Tempo" context, improving separation of concerns in the parsing pipeline.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy Decoupling: Successfully decoupled Term-based alias registration from internal raw objects, moving toward a more encapsulated and secure registry design.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • VitePress 404 Patch: Corrected root directory resolution to fix "404 Not Found" errors on the landing page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build Resilience: Implemented targeted folder exclusion to prevent build-time dead-link errors in non-public directories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.8.0] - 2026-04-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Immutability System Refined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The project evaluated mutation-throwing Proxies for all immutable objects, but reverted to using Object.freeze for stability and compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • All core objects remain protected with Object.freeze. No mutation-throwing Proxies are used for core objects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • See plan for architectural and migration details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Parse Planner Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Parse Planner: Introduced planner.layoutOrder to explicitly control the parsing priority of date layouts (like mdy or iso).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-Filtering Optimization: Moved parsePrefilter to planner.preFilter. Legacy parsePrefilter configurations remain fully backward compatible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Resilience & Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • MonthDay Auto-Detection: Hardened the monthDay options resolver so that boolean shortcuts (e.g. monthDay: true) and manual overrides are properly tracked and never overwritten by auto-detection heuristics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Factory Stability: Fixed bugs in the Tempo.create() sandbox where period alias collisions were failing silently; console.warn is now properly emitted when aliases overlap in local sandboxes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol Discovery Isolation: Patched the $setConfig resolution flow to correctly merge custom formats provided via discovery symbols before evaluating global option extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.7.0] - 2026-04-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Configuration Rationalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Grouped Options: Consolidated regional parsing and relative time options into nested objects for improved discoverability and additive merging support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mdyLocales and mdyLayouts → monthDay: { locales, layouts }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • rtfFormat and rtfStyle → relativeTime: { format, style }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Internal Hardening: Added isMonthDay internal detection to more accurately resolve parse-order layouts in regional contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Resilience & Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Event Registry Overrides: Fixed $setEvents logic to ensure user-defined event aliases correctly override or merge with built-in patterns without duplication or stale matches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TimeZone Fallback Resilience: Enhanced the IANA TimeZone fallback mechanism with a cleaned-up, prioritized list of regional aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl.Locale Debugging: Improved diagnostic logging for Intl.Locale resolution to assist in cross-environment consistency issues.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ticker Stabilization: Further refined async generator pulse counts and termination logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ CI/CD & Infrastructure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance Benchmarking: Integrated a dedicated bench/ suite into the CI pipeline to monitor performance impact on core parsing and mutation logic.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Workflow Optimization: Refactored the GitHub Actions workflow for better test isolation and Node.js 24 compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.6.0] - 2026-04-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migration Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New Features

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added normalizeUtcOffset utility for transforming informal UTC-offset strings to standard format. Added layoutOrder option to customize parsing element precedence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Breaking Changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Season Scope Simplification: Removed the Chinese-specific object previously attached to all term.season scope's output. For Chinese season interpretation, create a dedicated Tempo instance with {timeZone: 'Asia/Shanghai'} or {timeZone: '+08:00'}. Note that Chinese zodiac will still be supported on term.zodiac.CN as before.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bug Fixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fixed layout pattern resolution ordering to respect intended sequence. Enhanced timezone normalization for UTC offset handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated architecture documentation and configuration guidance. Clarified plugin/module callback parameter ordering in examples. Added v2.6.0 migration guide for season changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.5.0] - 2026-04-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Sandbox Factory pattern for isolated Tempo configurations via Tempo.create(options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • User-defined aliases now evaluated before built-in aliases for custom precedence.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Support for shorthand duration construction: new Tempo({ hours: 2 }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Debug option now accepts numeric log levels for granular control.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added fortnight event and half-hour period aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved compact time/date parsing for 6 and 8-digit inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced installation guidance with Temporal polyfill details.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New modularity documentation and sandbox factory pattern guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added parsing cookbook with digit-only string precedence examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.4.0] - 2026-04-24 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Parsing Infrastructure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Order Resolver: Extracted layout-ordering decision logic into a dedicated engine.layout module (src/engine/engine.layout.ts), improving internal modularity and enabling future per-input classification support. The resolver maintains 100% behavior parity with prior ordering semantics (locale-based dmy↔mdy swaps).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Controller Framework: Introduced a minimal but extensible controller-map structure to support future input classifications (e.g., "6 digits only", "contains colon"). Currently ships with a single default classification that mirrors the existing layout order, ensuring zero overhead today and a clear path for Release B/C enhancements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Isolation & Sandboxing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Factory Mode: Introduced Tempo.create(), a static factory method that generates a completely isolated Tempo subclass. Each sandbox maintains its own independent configuration, registry, and plugin state while inheriting from the parent, enabling multi-tenant or modular configurations within a single process without global state collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Internal Refactoring & Type Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Separation: Extracted the core ordering logic from Tempo.#swapLayout, improving code organization and unit testability without affecting public APIs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol-Based Safety: Protected the default layout classification key with a Symbol('default'), reducing accidental tampering risk and improving internal API robustness.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Determinism Coverage: Added comprehensive tests for layout order resolution, classification fallback, and multi-pair swap handling to ensure predictable behavior across locales and configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Module Path Flattening: Relocated core modules (e.g., mutate, duration) from src/plugin/module/ to a top-level src/module/ directory. This simplifies the internal architecture and provides cleaner internal import paths, reflecting their role as core library features rather than just "plugins".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Diagnostics & Debug Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Order Tracing: Added optional debug emission to show the final resolved layout order when debug: 5 is set, helping developers understand parse-order decisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.3.0] - 2026-04-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Parsing Innovations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standalone Logic: Extracted the natural language engine into a dedicated parse() function, enabling independent datetime string resolution without requiring a full Tempo instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Noise Filtering: Introduced a configurable ignore option to strip "noise words" during parsing, significantly increasing the robustness of the natural language interpreter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Backtracking Security: Implemented a centralized regex safety guard (Match.backtrack) in the snippet registry to block potentially malicious patterns and prevent catastrophic backtracking.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ecosystem Installation: Released a comprehensive installation guide covering Node.js (npm/pnpm/yarn), Deno, standard browser ESM, and specialized "Lite" build configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Interactive Demo: Enhanced the browser-based playground with a live timezone selector and real-time clock updates to demonstrate Temporal integration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Quick Start Refinement: Streamlined the README and configuration documentation to highlight simplified entry points and noise-filtering capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Refactor & Type Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State Management: Optimized the internal parser state machine to reduce memory pressure and improve resolution speed for complex strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Safety: Hardened the TypeScript definitions for all parse and term resolution functions, ensuring strict type-checking without consumer-side casting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic Context Sync: The engine now automatically synchronizes the hemisphere (sphere) configuration whenever the timezone is updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resilience: Hardened the resolution loop with safety-valves to prevent infinite loops during extreme date-range traversals and improved parse-error detection to prevent silent state corruption.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.6] - 2026-04-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚑 Emergency Hotfix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isomorphic Export Architecture: Refactored tempo.entry.ts and Rollup configuration to ensure the browser ESM bundle exports Tempo as both a default and a named export. This guarantees that import { Tempo } from '@magmacomputing/tempo' functions identically across Node.js and browser environments without throwing resolution errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dependency Resolution: Added jsbi explicitly to all documentation importmap examples to correctly resolve @js-temporal/polyfill internal bare module references and eliminate Failed to resolve module specifier "jsbi" errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation & UI: Fixed orphaned markdown script tags, formatted HTML browser usage blocks, and completely revamped the browser test UI pages with a premium jazzy aesthetic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.5] - 2026-04-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Modular Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Singleton Resilience: Replaced instanceof checks in TempoRuntime with a cross-bundle brand check, ensuring singletons are correctly adopted across bundle boundaries and HMR reloads.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Discovery: Consolidated internal storage for Term and extension plugins into a single, validated pluginsDb structure.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved Shadowing: Eliminated parameter shadowing in runtime hook methods to ensure reliable event emission.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Term Resolution Refinements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chronological Stability: Enforced chronological sorting in resolveCycleWindow for accurate cycle anchor identification.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Absolute vs Relative Years: Normalized year handling to allow templates to mix relative offsets and absolute historical years seamlessly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standards Mode: Modernized all public demonstration files with proper HTML5 skeletons and metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Contextual Guidance: Updated architecture docs and READMEs with accurate module paths and functional importmap examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.4] - 2026-04-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Production Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Compatibility: Added redefinition guards to TickerModule to prevent errors on already-frozen classes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ESM Integrity: Bundled tslib into granular ESM builds to resolve resolution failures in standard browser environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.3] - 2026-04-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Parsing: Initial decoupling of the parse engine to support standalone usage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Snippets: Introduced pattern-based layout customization for granular formatting control.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Project Governance: Integrated the MIT license and established a dedicated release history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🐛 Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Match Propagation: Ensured parse results correctly propagate through instance clones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Drift Resolution: Corrected timezone and calendar drift during intensive mutation cycles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Knowledge Architecture: Reorganized navigation into focused tracks: Cookbook, Advanced Reference, and Utility Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • API Reference: Expanded constructor documentation and added guidance for custom enum implementations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Diagnostics: Improved internal module-loading error messages for easier troubleshooting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.2] - 2026-04-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Registry Stabilization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Globalized module and serialization registries using Symbol.for() on globalThis to ensure state consistency across module reloads, HMR, and bundled distributions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented secure, local Proxy wrapping for registries to prevent closure persistence across library reloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Hardened Reflection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed static property reflection for decorated classes by implementing recursive prototype chain traversal in getAccessors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Refined prototype walking logic to prevent leaks from Object.prototype and Function.prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Production Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Achieved 100% build parity and test coverage in the production distribution (test:dist).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reduced NPM package size by nearly 50% by excluding non-essential documentation and image assets from the public package.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened Rollup build paths to be context-aware and defensive against missing artifacts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎨 Premium Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Redesigned the documentation landing page with a custom, high-performance Hero section and a live Tempo-driven analog clock.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Harmonized branding across README and documentation sites with "Tempo Blue" styling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed routing and asset resolution for GitHub Pages deployments using VitePress base-path helpers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧬 Mutation Engine & State Preservation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stabilized the mutation engine (.add(), .set()) to correctly accumulate and preserve parse results across instance clones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented robust parse result propagation in MutateModule using the internal state.matches registry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized cross-module state access using the [sym.$Internal] symbol, enabling safe cloning without violating private encapsulation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved timezone and calendar drift during complex mutations by enforcing authoritative state-merging in the mutation pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modular Parse Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Successfully decoupled internal parsing logic into ParseModule, reducing core class complexity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented a hybrid static Tempo.parse configuration/method pattern to maintain full backward compatibility while supporting modular delegation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened the interpret utility to ensure reliable method dispatching even when modules are loaded lazily or via HMR.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ CI/CD & Tooling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Upgraded GitHub Actions pipeline to Node.js 24 to resolve deprecation warnings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Restored separate "Full" and "Core" test suite isolation in local and workspace Vitest configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized documentation build order to ensure artifacts are compiled before generation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Achieved 100% Test Pass Rate (384/384) across all environments and distribution bundles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.1.3] - 2026-04-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • VitePress Migration: Launched a modern documentation system with integrated TypeDoc API references.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Loading Patterns: Introduced interactive browser demos for ESM, IIFE, and granular module resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized README: Refreshed the main project entry point with improved formatting and developer guides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Performance & Extensibility ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Refactor: Migrated the plugin system to a flexible object-based API for better extensibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cache Optimization: Enhanced memoization performance across the core engine.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Exports: Streamlined library entry points to improve tree-shaking and reduce bundle sizes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Temporal Utilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • High Precision: Expanded Temporal utility functions with native support for nanosecond-precision calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.1.2] - 2026-04-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.1.2 is a major milestone, delivering a more reactive architecture and rock-solid stability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Modular Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is now split into core and optional modules, allowing you to include only what you need. This reduces bundle size for users who only need the basic engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📝 Improved Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internal logging now uses context-aware Symbols. This decouples the logging logic from the core engine, allowing for cleaner diagnostics without performance overhead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Static API ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Tempo.duration() static method for convenient duration creation without instantiating a full Tempo date object first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Side Effect Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins now support automatic registration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The full @magmacomputing/tempo package includes all modules by default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core users (@magmacomputing/tempo/core) can activate features simply by importing the corresponding module (e.g., import '@magmacomputing/tempo/ticker').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ 100% Reliability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine passes all regression tests, ensuring complete stability across:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parsing complex date strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calculation and relative math.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formatting routines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ Unified Term Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms (like Quarters and Seasons) are now fully integrated:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use # in set() to jump to boundaries (e.g., t.set({ start: '#quarter' })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {#term} in format() to embed semantic labels (e.g. "Second Quarter") directly into strings (e.g., t.format('Today is {yyyy}-{mm}-{dd} in the {#quarter}').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ➗ Relational Term Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A category-first feature. Shift dates by semantic "steps" with .add({ '#quarter': 1 }). Tempo preserves your relative duration within the Term, jumping across gaps and handling overflows with mathematical precision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔗 Fluent Immutable Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Term ranges now return fully functional, frozen Tempo instances for start and end. This allows for seamless chaining:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.term.qtr.start.format('{dd} {mmm}')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Ticker Reliability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fully stabilized the Ticker subsystem:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved async generator hangs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Synchronized pulse counts (N pulses for limit: N), guaranteeing 100% predictable reactive streams.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Parsing Engine Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Re-engineered pattern generation for O(1) instance creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved support for custom layout literals in local/one-off parsers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Significant refinements to the natural language engine for even more intuitive relative-date handling ("next Friday", "two days ago", etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',155)])])}const g=i(n,[["render",r]]);export{m as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.lean.js new file mode 100644 index 00000000..b0c706d2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v2.x.md.DLrHz2MI.lean.js @@ -0,0 +1 @@ +import{_ as i,o as t,c as a,a2 as o}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"📜 Version 2.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v2.x.md","filePath":"doc/8-project-and-support/releases/v2.x.md"}'),n={name:"doc/8-project-and-support/releases/v2.x.md"};function r(l,e,s,d,c,u){return t(),a("div",null,[...e[0]||(e[0]=[o("",155)])])}const g=i(n,[["render",r]]);export{m as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.js new file mode 100644 index 00000000..b667452c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.js @@ -0,0 +1,68 @@ +import{_ as i,o as a,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"📜 Version 3.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v3.x.md","filePath":"doc/8-project-and-support/releases/v3.x.md"}'),n={name:"doc/8-project-and-support/releases/v3.x.md"};function o(r,e,l,d,c,h){return a(),s("div",null,[...e[0]||(e[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 3.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.11.1] - 2026-08-10 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Dedicated Config Subpath (@magmacomputing/tempo/config) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo configuration can now be authored with full IDE typing and autocomplete via the dedicated @magmacomputing/tempo/config entry point. It exports defineConfig for type-safe configuration authoring and resolveConfig for programmatic discovery:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineConfig } from '@magmacomputing/tempo/config';
+
+export default defineConfig({
+  timeZone: 'Australia/Sydney',
+  locale: 'en-AU',
+  cache: {
+    ttl: 3600000,
+    maxSize: 500,
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ JSONC Configuration Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The filesystem configuration resolver now natively parses JSON with comments (tempo.config.jsonc and tempo.config.json), supporting single-line (//), multi-line (/* */) comments, and trailing commas for clean, human-readable config files without requiring build steps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Timezone Abbreviations & Humanized Offsets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The natural-language and layout parsers now natively recognize common 3–4 letter timezone abbreviations (e.g. AEST, PST, EST, CET, JST) as well as explicit GMT/UTC offset prefixes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('Aug 6, 2026 16:16 GMT+10');
+new Tempo('August 6, 2026 16:16 AEST');
+new Tempo('2026-08-08 10:30 +5:30'); // Fractional and half-hour offsets supported

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ SQL & Space-Delimited Timestamp Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo automatically detects and normalizes SQL and space-delimited timestamps (such as 2026-08-08 10:30:00 [America/New_York]) into standard ISO 8601 strings during initialization, collapsing extraneous whitespace while safely preserving complex timezone identifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Cache Inspection & Serialization (toJSON) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.cache and the underlying BoundedCache engine now support native .toJSON() serialization, allowing you to easily inspect active, non-expired cache entries or serialize them with JSON.stringify(Tempo.cache) for diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 AI Context & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Published official, standardized llms.txt and llms-full.txt context bundles at tempo.magmacomputing.com.au to provide rich, curated project context for modern AI coding tools (Cursor, Copilot, Antigravity, Claude, ChatGPT). Added a dedicated AI & IDE Integration guide to the documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.11.0] - 2026-07-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Centralized Cache Engine (Tempo.cache) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced a high-performance BoundedCache singleton managing date resolution, layout compilation, and AI operations. It supports configurable LRU capacity eviction (maxSize) and time-to-live (ttl) expiration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  cache: {
+    maxSize: 1000,
+    ttl: 60 * 60 * 1000, // 1 hour TTL
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Glossary Seeding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now seed domain-specific terms or pre-resolved glossary mappings into the cache during initialization. Seeded glossary items remain permanently cached as immortal entries exempt from LRU eviction and TTL expiration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const glossary = new Map([
+  ['fiscal_kickoff', '2026-07-01T00:00:00Z'],
+  ['release_v3', '2026-08-10T12:00:00Z'],
+]);
+
+Tempo.init({ cache: glossary });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Multi-Provider AI Farm & Batching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Upgraded @magmacomputing/tempo-plugin-ai to support multi-provider orchestration modes (AiMode.Fallback, AiMode.Race, AiMode.Consensus, AiMode.Hedged, AiMode.RoundRobin, AiMode.Adaptive), bounded concurrency batch processing, and softErrors error boundaries for robust resilience in production environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scaffolded the Cache Management (tempo.cache.md) Core Concepts guide, detailing cache topology, glossary vs alias decision matrices, and integration across core and plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.3] - 2026-07-29 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Zero-Overhead Instantiation & Lazy System Clock ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Construction of Tempo instances has been further optimized to deliver true zero-overhead instantiation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deferred System Clock (#now): System clock acquisition (Temporal.Instant.fromEpochNanoseconds) is deferred until relative duration math or parsing fallbacks explicitly require the current time. Constructing instances from explicit date strings, numbers, or objects skips system clock calls entirely.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lazy Delegators (#fmt, #term): Internal proxy delegator objects are constructed on-demand only when .fmt or .term properties are accessed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • High-Frequency Acceleration: Substantially boosts throughput for loops, high-volume data transformation, and Tempo.Interval boundary operations (overlaps, contains, intersection, union).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.2] - 2026-07-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Experimental AI Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • parseAI Plugin: Officially introduced the @magmacomputing/tempo-plugin-ai experimental plugin for natural language date parsing via LLMs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Observability & Control: Added debug: true (development-only verbose logging of system prompts, localized context, and raw LLM responses; enable only with non-sensitive inputs) and force: true configuration flags to the AI plugin to easily monitor CoT (Chain-of-Thought) JSON schemas and bypass native parsing caching layers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fixes & Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Silent Native Parsing: Added a new silent: false configuration flag to Tempo Core (Tempo.init({ silent: true })). When enabled, this cleanly suppresses internal console error logging when native parsing throws a TempoError, providing a pristine terminal experience when falling back to AI parsers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Integrity: Hardened the internal enumify registry constructor in @magmacomputing/library to strictly verify its execution context (isFunction(this?.has)). This prevents prototype corruption when resolving ES Modules across mixed bundler environments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Test Environment Collisions: Resolved an isolated bug in Vitest workspace orchestration where duplicate core monorepo instances were loaded into memory, causing false-positive failures in plugin extensions (such as BatchPlugin).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.0] - 2026-07-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Token Modifiers & Custom Tokens Introduced new capabilities for chained formatting modifiers and finalized the complete architecture for Custom Format Tokens. Developers can now register custom zero-overhead logic evaluators (like Fiscal Years or native Intl bridges) that seamlessly hook into the t.format() engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cookbook Refactoring: Trimmed architectural "bloat" from the Cookbook (including Localized Parsing, Slick Mutations, and Custom Tokens). This content has been moved into dedicated Core Concepts guides (tempo.parse.md, tempo.mutate.md, tempo.format.md) to provide a much punchier, fast-paced onboarding experience for new users, while keeping deep-dive details just one click away.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.9.0] - 2026-07-14 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical Era Support Introduced first-class support for historical dates. The new {era} formatting token automatically resolves to localized BC/AD or BCE/CE designations. Additionally, the core Tempo class now exposes .era and .eon zero-cost getters, providing immediate access to the underlying historical date components.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Typographical Auto-Meridiem Expanded the {h12} token modifiers with a new :space option. When chaining modifiers (like {h12:space:dots}), Tempo will now gracefully inject a readability space before the auto-appended meridiem, yielding typographically correct strings like "10:30 a.m." instead of "10:30a.m.".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Educational Guides: Created a brand new tempo.getters.md document in the Core Concepts section, serving as the definitive guide to Tempo's zero-cost lazy-evaluation properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ecosystem Alignment: Updated tempo.config.md to remove deprecated plugin references, replacing them with accurate examples from the current tempo-workspace (FinanceNamespace and CelestialPlugin).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fixes & Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core Typings: Resolved any leakage in Tempo core methods by injecting strict overloads for until() and since() directly into tempo.class.ts, ensuring full IDE type-inference flows through to .format().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Badges: Standardized the Shields.io badge layout across the monorepo to use <p> tags with inline-block styling, fixing horizontal alignment issues caused by VitePress CSS overrides and eliminating malformed HTML <table> hydration errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Vue Compiler Hydration: Fixed a rogue unclosed </p> tag in the Ticker plugin documentation that was silently causing downstream Vue SFC parsing errors during VitePress compilation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CLI Pipeline: Validated the magma-cli build pipeline to correctly propagate non-zero exit codes during workspace orchestration operations, preventing silent failures.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.8.0] - 2026-07-11 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interval Primitive Introduced Interval as a first-class, tree-shakeable core primitive. It provides mathematically pure, high-performance boundary evaluations (overlaps, abuts, contains) and set operations (union, intersection) for Temporal points. Interval is accessible ergonomically via Tempo.Interval or independently as a named export for strict tree-shaking purists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespace Architecture Introduced the defineNamespace plugin factory. While Terms (like quarter or season) teach Tempo how to parse natural language, Namespaces provide a clean way to attach grouped business logic directly to the Tempo instance without polluting the global scope. For example, t.finance.isFiscalYearStart() or t.finance.taxYear keeps financial computations neatly isolated from standard date mechanics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Plugin Discrimination: The plugin registry now enforces strict 'type' discrimination ('plugin' | 'namespace' | 'term' | 'module') across all plugin factories, replacing brittle object-sniffing and making introspection significantly more robust.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Architecture: The documentation source code has been completely reorganized into numbered sub-directories (1-getting-started, 2-core-concepts, etc.) to map 1:1 with the visual VitePress sidebar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.7.1] - 2026-07-09 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • License Admin Isolation: Improved license handling so administrative access is tracked separately, reducing incorrect license/permission information appearing in the app.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Admin Cache Protection: Prevented outdated role information from lingering after license updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.7.0] - 2026-07-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Runtime Version Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo now features a fully automated runtime version registry accessible via Tempo.versions. This allows developers to instantly query exactly which core modules, terms, and community plugins are loaded into their current Tempo environment and what versions they are running. This system is completely zero-burden for plugin authors, utilizing a virtual build pipeline to auto-inject version strings without requiring manual updates or magic strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Architectural Security: The internal state management (including term registries and configuration variables) has been modernized to use true ECMAScript private fields (#), ensuring that Tempo's runtime state is strictly impenetrable from the outside.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.6.0] - 2026-07-05 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Shorthand Mutation Keys ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added native support for Tempo's shorthand format tokens (e.g., mi, ss, yy, ww) across both .add() and .set() mutations, streamlining developer experience and aligning TypeScript definitions with the underlying runtime engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Shorthand Duration Keys ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Expanded shorthand token support directly into the DurationModule. You can now seamlessly use shorthand keys for duration instantiation (Tempo.duration({ mi: 5 })), comparisons (t.until(other, 'mi')), and strict balancing (t.until(other).balance({ largestUnit: 'mi' })), bringing total API consistency across the core library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.2] - 2026-07-04 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Minified Global Bundles ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The build pipeline now natively produces highly optimized, minified IIFE bundles (*.min.js) for both Tempo Core and all Community Plugins, significantly reducing payload size for developers using CDN <script> tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Additionally, the browser-global export strategy has been re-architected. Both the core library and all <script> tag plugins now elegantly attach to a single, collision-free window.Magma namespace (e.g., window.Magma.Tempo and window.Magma.plugins.astro), dramatically improving developer experience and eliminating global variable pollution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Timezone Formatting Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The {tz} format token now natively supports a full suite of lowercase modifiers (:z, :zz, :zzz, :zzzz, :zzzzz)! This seamlessly outputs various localized timezone names and standard offset formats directly from the native Intl engine, eliminating the need to rely purely on raw IANA Timezone IDs for UI rendering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Module Augmentation Typings: Hardened the "batteries-included" tempo.index.ts entry point by explicitly exporting core module types (e.g. DurationModule, FormatModule). This forces TypeScript to preserve their module augmentations in the compiled .d.ts bundle, guaranteeing that methods like .until() and .since() correctly appear in IDE autocomplete out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.1] - 2026-06-28 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Registration Resilience: Hardened Tempo.extend with structural deduplication to safely ignore redundant registrations of identical core terms. This prevents edge-case term collisions (e.g., qtr) in mixed module-loader environments like Vitest where Node ESM and Vite may evaluate plugins multiple times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.0] - 2026-06-28 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Unified Plugin API ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v3.5.0 introduces a brand new barrel export for plugin developers: @magmacomputing/tempo/plugin-api.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This new endpoint centralizes all plugin-authoring utilities (defineModule, definePlugin, defineTerm) and internal types into a single location. This architecture significantly cleans up application-level code by formally separating end-user imports from Plugin Developer imports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are developing a custom plugin, you simply update your imports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Old Way
+// import { defineModule } from '@magmacomputing/tempo/plugin';
+
+// New Way
+import { defineModule } from '@magmacomputing/tempo/plugin-api';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Static vs Smart CDNs: We have completely overhauled the installation documentation to clarify the distinction between using Smart CDNs (like esm.sh which automatically resolve dependencies) for prototyping, versus Static CDNs (with manual importmap configurations) for hardened production environments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evergreen Temporal Wording: Removed explicit version claims for upcoming Node.js native Temporal support, future-proofing our guides against shifting V8 release timelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.4.0] - 2026-06-26 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Dynamic Format Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's formatting engine now supports completely custom format evaluators via the registry.tokens configuration. This allows you to define your own syntax tokens that execute complex math or delegate deeply localized formatting directly to the native Intl API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+	locale: 'fr-FR',
+	registry: {
+		tokens: {
+			'wkd-fr': (zdt, { config }) => {
+				const dtOptions = config?.intl?.dateTimeFormat ?? {};
+				return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
+			}
+		}
+	}
+});
+
+const t = new Tempo('2024-05-20');
+t.format('{wkd-fr}'); // "lundi"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Compound Token Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The compound date tokens ({dmy}, {mdy}, {ymd}) now support the :yy modifier to easily truncate their internal year components to 2 digits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.format('{dmy:yy}'); // "200524"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This officially supersedes the legacy *6 tokens (e.g., {dmy6}) which have now been deprecated from documentation to keep the API clean, though they remain fully supported in the engine for backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.3.1] - 2026-06-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo has always allowed jumping to boundaries using the Slick Shorthand (#qtr.>2q1) or semantic strings (next Friday). v3.3.1 extends this power directly to .set() object properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now use SLICK_KEYS (yy, mm, ww, dd, hh, mi, ss, wkd) as object keys in .set(), passing a directional string payload:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+
+// Jump forward two months
+t.set({ mm: '>2' }); // July 20
+
+// Jump to the next Friday
+t.set({ wkd: '>Fri' }); // May 24
+
+// "Double-negation" math is fully supported:
+t.set({ mm: '<-3' }); // Equivalent to >3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This makes relative programmatic date construction cleaner and keeps numeric jumps distinct from absolute assignments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Extended Shorthand Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Slick Regex parser has been upgraded to natively support equality logic and aliases. Modifiers like >=, <=, =, + (alias for >), and - (alias for <) are now fully supported for both numeric offsets and semantic loops (like wkd).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Jump to next Monday, or stay on Monday if today is Monday
+t.set({ wkd: '>=Mon' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.3.0] - 2026-06-21 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Localized Modifier Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's relative-date keywords (next, last, this, ago, hence) were previously hardcoded as English-only constructs built into the core regex engine. v3.3.0 opens this up completely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now register your own locale-specific words for any directional operator using registry.modifiers. These words integrate transparently with all standard parsing paths — prefix position, suffix position, and the high-performance # slick shorthand:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',            // teaches Tempo French months & weekdays via Intl
+  registry: {
+    modifiers: {
+      '>': ['prochain', 'suivant'],   // "next" synonyms
+      '<': ['dernier', 'passé'],      // "last / previous" synonyms
+      '=': ['ce', 'cette'],           // "this" synonyms
+    }
+  }
+});
+
+new Tempo('vendredi prochain');    // ✅ "next Friday" — fully French
+new Tempo('1 mai prochain');       // ✅ "next May 1st"
+new Tempo('#qtr.dernier');         // ✅ "previous quarter" via slick shorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    English keywords (next, last, ago, hence, this) remain active by default and are additively merged — you never lose built-in behaviour when adding your own.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Frozen Default Registry Fixed: The internal Default configuration object is wrapped in a deep-freeze Proxy (secure()). Previously, every Tempo.init() call silently failed to write formats, locales, and modifiers into the frozen registry sub-object, logging three setProperty warnings per call and abandoning the writes. The registry is now correctly shallow-cloned into a mutable copy on initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lexer Token Cleanup: All hardcoded English modifier keywords have been stripped from the core regex tokens (Match.modifier, Match.shorthand, Match.slick). The engine now operates purely on symbolic operators (>, <, =, +, -) internally and resolves all natural-language words through the registry at runtime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-filter Guard Accuracy: Refined the numeric-safety guard bypass to trigger only when the input actually contains a registered modifier keyword. Previously the guard was bypassed unconditionally whenever modifier config was present, which could silently accept invalid nanosecond epoch strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Slick Modifier Semantics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Localized slick modifiers behave identically to their symbolic counterparts. #qtr.prochain is an exact alias for #qtr.>:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From inside Q2 (any day from April 1 to June 29) → July 1 (start of Q3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From June 30 (last day of Q2) → July 1 (start of Q3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From July 1 (first day of Q3) → October 1 (start of Q4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This mirrors how next Friday works: from any non-Friday you get the very next Friday; if you are already on Friday, you get the following Friday. Fully deterministic — "next" always means "the start of the next occurrence of this term".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.3] - 2026-06-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Project Scaffolding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tempo.config.ts Pattern: Introduced centralized project configuration via a discoverable tempo.config.ts / tempo.config.js file. This mirrors the vite.config.ts / tailwind.config.js convention — one file, one place, loaded once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.bootstrap(): A new async entry point that auto-discovers and loads your tempo.config.ts before any domain logic runs. Safe to await at application startup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CLI Scaffold: npx @magmacomputing/tempo scaffold:all bootstraps a tempo.config.ts and HTML sandbox into your project in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.2] - 2026-06-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Compact Date Tokens: New 6-digit compact format tokens {dmy6}, {mdy6}, {ymd6} (e.g. 200626), plus ISO week-of-year helpers {yywy} and {yyww}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {wy} Rename: The former {ww} token is now {wy} (week-of-year) to eliminate visual ambiguity with structural format tokens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recursive deepMerge Hardened: The Intl options merge pipeline now uses a fully recursive deepMerge rather than a shallow spread, preventing nested keys like intl.dateTimeFormat from clobbering intl.relativeTimeFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Pollution Guards: Added strict guards against __proto__, constructor, and prototype key assignments in deepMerge and deepFreeze utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.1] - 2026-06-17 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinal Localization Fallback: Added support for custom Intl.PluralRules dictionaries. By supplying an ordinal dictionary inside your global locales registry, Tempo natively evaluates the active plural category (e.g., 'one', 'other') and appends the localized suffix automatically (such as '1er' and '15e' for French).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved Cookbook Ergonomics: Extensively reorganized the tempo.cookbook.md to make it easier to read. Related functionality is now logically grouped together—for example, merging native and semantic .add() math examples, and expanding on boundary .set() capabilities.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clarified Configurations: Updated tempo.config.md to remove outdated properties and explicitly document nested options like intl.durationFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • REPL Traps: Added prominent warnings to the documentation about the strict idempotency of Tempo.init(), helping new developers avoid silent configuration failures in hot-reload and REPL environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Alias Collision Prevention: Hardened the sandbox alias detection engine to prevent redundant collision warnings in the console when Tempo.init is invoked in sandboxed contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.0] - 2026-06-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-lingual Parsing: The locale configuration property now officially accepts an array of strings (string | string[]). This enables the ParseModule to intelligently extract terminology from multiple languages simultaneously, generating a single engine capable of parsing dates from any of the specified locales interchangeably.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl.DateTimeFormatOptions Passthrough: The .format() method now officially supports passing a native Intl.DateTimeFormatOptions object. This provides a highly flexible, "humanized" wrapper around the rigid Temporal API for complex cultural formatting (e.g., Arabic numerals, Japanese Reiwa eras).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • BigInt Overload for Epoch Nanoseconds: The {nano} formatting token (epoch nanoseconds) correctly coerces to and returns a precision-preserving BigInt instead of a string, bypassing standard Number limits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Domain-Locked Licensing: Stabilized the premium plugin licensing engine with a robust domain-locked validation mechanism.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SSR & VitePress Fixes: Fixed Temporal is not defined crashes during SSR builds and simplified our documentation pipeline by removing heavy Markdown plugins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New Locale Guides: Added comprehensive Internationalization (tempo.locale.md) guides to the primary navigation structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • O(1) Locale Traceability: Upgraded the internal dictionary architecture. The Normalizer can now resolve the winning language of a matched token in pure O(1) time without any expensive Regex sub-capture scanning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Polyfill Formatting Bypass: Bypassed a known bug in the Temporal polyfill's toLocaleString() method that incorrectly dropped Kanji constraints in Japanese formatting contexts, guaranteeing precise Intl fallback correctness.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parser Map Safety: Architecturally split the internal reverse-lookup into distinct monthMap and weekdayMap dictionaries, eliminating the risk of cross-locale abbreviation collisions (e.g., if "mai" is a month in one language but a weekday in another).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.1.0] - 2026-06-13 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chained Formatting Modifiers: A powerful new format modifier engine ({mon:locale:upper}) allowing dynamic casing (:upper, :lower), ordinal suffixes (:ord), and deep localization (:locale) dynamically via the native Intl API.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Localization Engine: Global configurations for format: { localize: true } and parse: { localize: true } provide a massive leap forward in out-of-the-box internationalization. Tempo can now intelligently parse localized input (months, weekdays, relative terms like 'demain') and automatically format localized output using memoized, high-performance Intl strategies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global locales Registry: Centralized management for augmenting specific term strings per locale globally across instances via Tempo.init({ locale: 'fr-FR', registry: { locales: { ... } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl Instantiation: Upgraded internal architectures to memoize and pool Intl.DateTimeFormat objects seamlessly, ensuring parsing localization generation and output formatting impose virtually zero performance hit on hot execution paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Localization: Upgraded the Term formatting resolution pipeline to support falling back across a strict precedence: Global Registry > Plugin Bundled Dictionary > term's existing label/value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.0.0] - 2026-06-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Major Breaking Changes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Registry Consolidation: Removed the legacy and deprecated term property from the Discovery configuration object. All Term-based plugins must now be registered via the terms (plural) array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shorthand Configuration Removal: Removed support for shorthand root-level properties in the Discovery object that have been superseded by nested configuration groups:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • relativeTime shorthand has been removed; use intl.relativeTime instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • term shorthand has been removed; use terms instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Parsing Mode: The parser now enforces a stricter guard check by default, reducing the likelihood of "false positive" matches on ambiguous strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ticker Module Extraction: To lighten the core bundle, the TickerPlugin has been extracted into its own standalone Community plugin (@magmacomputing/tempo-plugin-ticker).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formatting Module Additions: Added new compact date tokens ({dmy}, {mdy}, {ymd}) for generating 8-digit compact date strings (e.g. 24102026). {hhmiss} has been renamed to {hms} for consistency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinal Tokens: Uppercase variants of standard date tokens ({DAY}, {WW}, {MM}) now output their ordinal string representation (e.g., 24th, 1st, 2nd).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Migration Path for Tempo.ticker() Users ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are upgrading from v2.x and your application relies on Tempo.ticker(), you will need to update your integration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Install the Plugin: npm install @magmacomputing/tempo-plugin-ticker
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Register the Plugin: Wire the plugin into your application during initialization:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+// Register the extracted plugin
+Tempo.init({
+  plugins: [TickerPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero-Fallback Initialization: Cleaned up the Tempo.init() bootstrap logic to remove legacy compatibility layers, resulting in a cleaner internal state and reduced bundle size.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build Pipelines: Fully synchronized build pipelines and TS declarations to ensure vitest and tsc operate seamlessly across local and premium workspaces.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,170)])])}const k=i(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.lean.js new file mode 100644 index 00000000..e7c8ca1b --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v3.x.md.CK4PnQ-6.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as s,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"📜 Version 3.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v3.x.md","filePath":"doc/8-project-and-support/releases/v3.x.md"}'),n={name:"doc/8-project-and-support/releases/v3.x.md"};function o(r,e,l,d,c,h){return a(),s("div",null,[...e[0]||(e[0]=[t("",170)])])}const k=i(n,[["render",o]]);export{g as __pageData,k as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.js new file mode 100644 index 00000000..5ee0772f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.js @@ -0,0 +1,44 @@ +import{_ as o,o as t,c as n,a2 as a,j as i,a as s}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"📜 Version 4.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v4.x.md","filePath":"doc/8-project-and-support/releases/v4.x.md"}'),l={name:"doc/8-project-and-support/releases/v4.x.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function c(h,e,p,g,k,m){return t(),n("div",null,[e[8]||(e[8]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 4.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.7.0] - 2026-10-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.7.0 brings first-class Roman Numeral Date Support across parsing and formatting, full format-mask round-tripping, and canonical ISO Week-Numbering Getters (.woy and .yow) — providing developer-friendly date handling for archival publishing, epigraphy, and ISO week-calendar schedules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary of Highlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symmetric Roman Numeral Formatting & Parsing: Format any date token as a Roman numeral using {token:roman} (e.g. {yy:roman}-{mm:roman}-{dd:roman} → XXVI-X-XVI) and round-trip parse it back cleanly with custom format masks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Archival & Epigraphic Date Parsing: Natively parse archival Roman date strings out-of-the-box, such as 14.X.2026, Copyright © MMXXVI, and anno domini MCMXCIV.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Guard Pre-Filtering: Guard pre-filter prevents accidental false positives by intelligently differentiating Roman numerals from everyday lowercase English words (did, mix, civil).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Week Getters & Tokens: Access ISO week numbering through canonical instance getters .woy (week of year) and .yow (ISO week-numbering year), complemented by {woy}, {woy:raw}, {woy:ord}, and {yow} format tokens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Developer Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Roman Numeral Format Modifiers & Round-Trip Symmetry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting dates using Roman numerals is now as simple as adding the :roman modifier to any date component:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('2026-10-16');
+
+// Format with Roman numerals
+const romanDate = t.format('{yy:roman}-{mm:roman}-{dd:roman}');
+// 'XXVI-X-XVI'
+
+// Parse it right back with mask symmetry!
+const restored = new Tempo(romanDate, { format: '{yy:roman}-{mm:roman}-{dd:roman}' });
+console.log(restored.format('iso')); // '2026-10-16'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Archival & Inscription Date Lexing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Archival dates, book copyright lines, and European-style day-RomanMonth-year strings are recognized automatically by the parser:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('14.X.2026').format('iso'); // '2026-10-14'
+new Tempo('MMXXVI').format('iso');     // '2026-01-01'
+new Tempo('Copyright © MMXXVI').year;  // 2026
+new Tempo('anno domini MCMXCIV').year; // 1994

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The lexer introduces dedicated internal tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Rm: Roman month numbers (I through XII).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Ry: Roman years (1–3999).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.dRy: Day-RomanMonth-Year structures (14.X.2026).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Ryy: Archival year expressions (anno domini MMXXVI, Copyright © MMXXVI).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Smart Sequence Guard Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To avoid false-positive date matches during natural language parsing, Tempo includes enhanced sequence validation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Valid uppercase Roman numerals (MMXXVI, XIV) and separator-adjacent Roman months (14.X.2026) are accepted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Common lowercase English words that coincide with Roman letters (did, mix, civil, dim, id) are rejected by the guard filter, preventing unwanted date triggers in standard prose.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Canonical ISO Week-Numbering Getters (.woy & .yow) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Working with ISO week-numbering schedules is now clearer with dedicated instance getters:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-01');
+
+console.log(t.woy); // 1 (ISO week of year, 1-53)
+console.log(t.yow); // 2026 (4-digit ISO week-numbering year)
+
+// Native token formatting
+t.format('{yow}-W{woy}');     // '2026-W01'
+t.format('Week {woy:ord}');   // 'Week 1st'
+t.format('{woy:raw}');        // '1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Legacy .ww is deprecated in favor of .woy and will be phased out in v5.0.0. Shorthand .wy and .yw remain available for internal compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Object Key Assertion Primitives & Disambiguation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Underlying utility helpers provide dedicated property assertion and narrowing primitives:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasKey(obj, key, ...guards): Verifies and narrows a single property key using optional type tags ('string', 'number') or predicate functions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasKeys(obj, ...keys): Conjunction check verifying all candidate keys exist simultaneously (AND).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasAnyOf(obj, ...keys): Disjunction check verifying at least one candidate key exists (OR).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasNoneOf(obj, ...keys): Exclusion check verifying none of the candidate keys exist (NOT).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.6.0] - 2026-10-11 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.6.0 introduces the Term Lifecycle Hooks Protocol, enabling domain plugins (such as fiscal quarters, seasons, academic calendars, and custom business cycles) to deeply integrate into Tempo's natural language parser, date arithmetic, range boundary snapping, difference calculation, and token formatting — all with zero overhead on standard ISO operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary of Highlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Plugins: Customize parsing, ordinal matching, step arithmetic, range boundaries, date spans (.until()/.since()), and formatting for domain terms (#).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standard & Celestial Terms: Standard terms (#qtr, #szn, #zdc, #tod, #sign) and celestial plugins (#solar, #moon, #tide, #astro) natively implement lifecycle hooks for ordinals, cycle diffs, boundary snapping, and sub-attribute formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Written & Negative Ordinals: Parse natural expressions like "first Wednesday of October" or "-2nd day of #qtr.2". Custom ordinals and number words can be registered globally or per-instance, with negative ordinals counting backward from month/cycle ends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Enums & Compatibility: Live enumerators are organized under Tempo.enums.*, while classic static getters remain directly accessible with deprecation notices for seamless backward compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dialect Precision & Boundary Shorthands: Escaped literal braces cleanly fall back to dialect parsers, and term boundary shortcuts (start, mid, end) provide fluent range snapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Protocol Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Well-Known Symbol Lifecycle Protocol (TermHook) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Protected Protocol Symbols: Protects term hooks against naming collisions and dual-package hazards using cross-realm well-known symbols (Symbol.for('magmacomputing/tempo/term/...')):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.parse]: Intercepts explicit #term expressions (e.g. new Tempo('#fiscal.q1')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.ordinal]: Powers anchored ordinal expressions (e.g. Tempo.from('3rd day of #sprint.2', { anchor })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.step]: Enables stepping arithmetic via dictionary mutations (t.add({ '#qtr': 1 }), t.sub({ '#qtr': 1 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.bound]: Snaps boundaries for custom term periods (t.set({ '#term': 'start' | 'mid' | 'end' }), t.set({ start: '#term' }), and t.set('#term.mid')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.diff]: Calculates differences in term units (t1.until(t2, '#term'), t1.since(t2, '#term')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.format]: Dispatches custom term format tokens (e.g. t.format('{#academic}'), t.format('{#academic:upper}')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Native Term Units in .until() & .since() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Term Differences: Tempo.Unit and Tempo.Until now accept custom term units (#\${string}), providing full IDE autocompletion and compile-time type safety when calculating spans between dates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const quartersRemaining = t1.until(t2, '#quarter');
+const elapsed = t2.since(t1, '#fiscal');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Standard & Celestial Terms Lifecycle Integration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Natural Range Ordinals: Standard terms (#qtr, #szn, #zdc) implement [TermHook.ordinal], enabling natural ordinal offset expressions like Tempo.from('3rd day of #qtr.2', { anchor }), Tempo.from('-2nd day of #qtr.2', { anchor }), and Tempo.from('last day of #szn.summer', { anchor }) with strict cycle boundary guarding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Unit Differences (.until() & .since()): Standard terms implement [TermHook.diff] via resolveRangeDiff(), calculating elapsed cycle intervals:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      t1.until(t2, '#qtr'); // 3
+t2.since(t1, '#qtr'); // "-3 #qtr"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Token Formatting: Standard terms implement [TermHook.format] via resolveRangeFormat(), resolving top-level keys ({#qtr} → "Q2"), descriptive scopes ({#quarter} → "Second Quarter"), and arbitrary nested sub-attributes ({#qtr.label}, {#szn.symbol}, {#zdc.emoji}, {#sign.animal}, {#tod.hour}) with automatic modifier support ({#qtr.label:upper}).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shared Plugin SDK Utilities: Exported resolveRangeOrdinal, resolveRangeDiff, and resolveRangeFormat via @magmacomputing/tempo/plugin/sdk.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Celestial Plugin Support: Celestial terms (#solar, #moon, #tide, #astro) implement lifecycle hooks for boundary snapping, synodic stepping, interval calculations, and astrological/solar formatting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Unified Tempo.enums Namespace & Extensible Ordinals ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Tempo.enums Accessor: Consolidates all live enum dictionaries under Tempo.enums.*. For 100% backward compatibility with existing v4 call sites, legacy static getters on Tempo (ELEMENT, FORMAT, NUMBER, ORDINAL, TIMEZONE, MONTH_DAY, MODE, CACHE, LIMIT) remain available directly on the Tempo class with @deprecated notices.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native Written Word Ordinals: Natively parses natural ordinal expressions like "first Wednesday of October", "second day of next month", "tenth Friday of the year", and "last day of May".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ORDINAL Enumerator: Exported through @magmacomputing/tempo/enums and accessible via Tempo.enums.ORDINAL, mapping words to numeric offsets (current: 0, first: 1 through tenth: 10, last: -1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dynamic & Per-Instance Extensibility: Configure custom ordinals globally via Tempo.init({ registry: { ordinals: { ... } } }) or per-instance via constructor options (new Tempo('...', { registry: { ordinals: { ... } } })). Per-instance ordinals are dynamically compiled into instance regexes without polluting global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Plugin Integration: Directly leveraged by [TermHook.ordinal] for resolving custom term offsets (such as sprint days or fiscal cycles).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Shorthand Boundary Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct Snap Shorthands: Term boundary selection (start, mid, end) can be expressed directly via dictionary mutations (t.set({ '#term': 'start' | 'mid' | 'end' }), t.set({ start: '#term' })) or property shorthand (t.set('#term.start'), t.set('#term.mid'), t.set('#term.end')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Dialect Mask Precision & Engine Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dialect Literal Brace Escaping: Added hasNativeFormatBraces to strip dialect-specific escaped literals ([...] in Moment/Day.js, '...' in LDML/Luxon) before testing for native {token} masks, ensuring masks with escaped braces cleanly fall back to external dialect formatters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolated # Sigil Guards: Hook dispatch occurs strictly for domain term expressions (#), ensuring everyday ISO date parsing, standard formatting, and core unit arithmetic bypass hook execution paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Complete Backward Compatibility: Existing term plugins continue to function without any modifications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.5.1] - 2026-10-05 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.5.1 focuses on Seamless Dynamic Plugin Loading & Sandbox Resilience, ensuring interactive REPLs, browser playgrounds, and dynamically bundled micro-frontends can load and register plugins on-the-fly without friction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Improvements & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Plugin Registry Resilience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Late-Loaded Plugin Support: When loading plugins asynchronously via import() inside dynamic environments or browser sandboxes, internal plugin tables are protected with extensible metadata symbols.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copy-on-Write Registrations: Registering terms and plugins after initialization safely falls back to copy-on-write updates on non-extensible registry arrays and pluginsDb objects when the parent container permits reassignment (replacing pluginsDb can still throw a TypeError if the owning state itself is frozen).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.5.0] - 2026-10-02 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.5.0 introduces the Structured t.intl Namespace (intl.info & intl.locale), the high-performance Tempo.intl Formatter Hub, and Hierarchical Translation Token Support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Structured t.intl Sub-Namespace (intl.info & intl.locale) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Regional Metadata (t.intl.info): Regional insights are now cleanly grouped under .info, giving direct access to frozen locale characteristics:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('now', { locale: 'en-AU' });
+console.log(t.intl.info.firstDay);        // 1 (Monday)
+console.log(t.intl.info.weekend);         // [6, 7] (Saturday, Sunday)
+console.log(t.intl.info.hourCycle);       // 'h12'
+console.log(t.intl.info.direction);       // 'ltr'
+console.log(t.intl.info.numberingSystem); // 'latn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native Locale Inspection (t.intl.locale): Inspect the active Intl.Locale instance directly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Backward Compatibility: Top-level convenience properties (like t.intl.firstDay and t.intl.region) remain fully supported throughout the v4.x lifecycle with gentle deprecation notices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Tempo.intl Formatter Hub ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instant Pre-Bound Formatters: Perform standard internationalization formatting directly through static helpers without manually configuring Intl.* classes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Relative Time Formatting
+Tempo.intl.relativeTime(-2, 'days'); // "2 days ago"
+
+// Natural List Formatting
+Tempo.intl.list(['Sydney', 'Tokyo', 'London']); // "Sydney, Tokyo, and London"
+
+// Number & Currency Formatting
+Tempo.intl.number(1234567.89); // "1,234,567.89"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fast Factory Getters: Access cached constructor factories for dtf() (DateTime), rtf() (RelativeTime), lf() (List), and nf() (Number).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Advanced Format & Translation Capabilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Translations: Formatting strings support nested tokens for namespaced plugin keys (e.g. {geo.sphere:locale}).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Combined Timezone Offset Styles: Enhanced time-zone offset formatting modifiers like {offset:iso}, {offset:gmt}, and composite modifiers like {tz:offset:short}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.4] - 2026-09-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.4 introduces the Reactive Stream Engine (Reactive<T>) in the utility library, ergonomic Type Casting Helpers (cast<T>()), and explicit Tempo.Interval Types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Reactive Stream Engine (Reactive<T>) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,71)),i("ul",null,[e[7]||(e[7]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Lightweight Event Streaming: Exported via @magmacomputing/tempo/library and the Plugin SDK, Reactive<T> offers push/pull streaming with zero external dependencies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Reactive } from '@magmacomputing/tempo/library';
+
+const clockStream = new Reactive<string>();
+
+// Subscribe with automatic cleanup via TC39 explicit resource management:
+{
+  using sub = clockStream.on((iso) => console.log('Tick:', iso));
+  clockStream.cast(new Tempo().iso);
+} // Subscription automatically unsubscribes when exiting block!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Async Iteration: Consume events naturally using standard for await (const tick of clockStream) loops.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • `,2)),i("li",null,[e[2]||(e[2]=i("strong",null,"Multicast Fan-Out",-1)),e[3]||(e[3]=s(": High-performance ",-1)),i("mjx-container",r,[(t(),n("svg",d,[...e[0]||(e[0]=[a('',1)])])),e[1]||(e[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=s(" broadcasting across all active push subscribers and async waiters via ",-1)),e[5]||(e[5]=i("code",null,"stream.cast(value)",-1)),e[6]||(e[6]=s(".",-1))])]),e[9]||(e[9]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Ergonomic Type Casting (cast<T>()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Replaces awkward (value as unknown as TargetType) double-assertions with a clean runtime and compile-time casting helper:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { cast } from '@magmacomputing/tempo/library';\nconst config = cast<CustomConfig>(rawPayload);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.3] - 2026-09-29 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Performance Boosts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.3 delivers Massive Parsing Speedups via automated regular expression memoization and introduces the public Tempo.cache.weak Object Cache Facade.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Public Weak Object Cache (Tempo.cache.weak) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Attach temporary metadata or computed results to object instances without risking memory leaks:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const cache = Tempo.cache.weak<object, ComputedData>();\ncache.set(domElement, { lastUpdated: new Tempo() });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Automated Regular Expression & Date Interning ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Evicting Regex Cache: Dynamically compiled braced format masks and layout matchers are cached with garbage-collection-friendly weak maps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Up to 120x Faster Parsing Loops: Repeated ISO parsing and timezone offset conversions are memoized, reducing heap pressure by ~99.9% in high-throughput data processing pipelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.2] - 2026-09-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.2 enhances Global Multi-Script Language Support in the natural language date parsing engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Improvements & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Unicode Multi-Script Keyword Matching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Script Support: Natural language relative date parsing (like "next Friday" or localized calendar terms) now uses Unicode character property matching and NFC normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero False Collision Warnings: Non-Latin scripts (such as Arabic, Japanese, Chinese, Cyrillic, and Hebrew) are preserved accurately without triggering duplicate alias warnings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.1] - 2026-09-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.1 introduces Braced Format Mask Parsing ({format: '...'}) & Wildcards ({*}), Evaluable<T> dynamic format & dialect configuration, and official launch integration for @magmacomputing/tempo-plugin-dialects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Core Braced Format Mask Parsing & Wildcard Matching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parse structured date strings using Tempo's standard braced token format:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('24-10-2026', { format: '{dd}-{mm}-{yyyy}' });\nconst t2 = Tempo.from('2026/10/24 15:30:45', { format: '{yyyy}/{mm}/{dd} {hh}:{mi}:{ss}' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Candidate Format Arrays: Supply multiple candidate masks to match the first matching format:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo(input, { format: ['{yyyy}-{mm}-{dd}', '{dd}/{mm}/{yyyy}'] });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Wildcard Token {*}: Skip arbitrary substrings or log prefixes without complex regular expressions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('Log entry [2026-10-24 15:30] server-01', {\n  format: '{*} [{yyyy}-{mm}-{dd} {hh}:{mi}] {*}'\n});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Actionable Dialect Guidance: Passing unbraced masks (e.g. 'yyyy-MM-dd') without the dialects plugin throws clear guidance directing users to @magmacomputing/tempo-plugin-dialects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dynamic Evaluable<T> Format & Dialect Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration and call-site options for format and dialect now accept dynamic resolver functions (() => string), seamlessly evaluated at runtime via evaluate():
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo(input, {\n  format: () => getUserPreferredFormat()\n});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Dialects Plugin Integration (@magmacomputing/tempo-plugin-dialects) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Official v1.0.0 release of the Dialects plugin enabling Unicode LDML (Luxon/date-fns), POSIX strftime, and Moment.js mask translation, formatting, and parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.0] - 2026-09-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.0 introduces Order-Independent Plugin Auto-Installation (/install) and global pending queues, bringing zero-boilerplate side-effect imports for browser scripts, quick prototypes, and interactive REPLs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Zero-Boilerplate Side-Effect Imports (/install) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Official and community plugins can now be installed with a single import statement:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import '@magmacomputing/tempo-plugin-geo/install';\nimport '@magmacomputing/tempo-plugin-ai/install';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Order-Independent Registration ($pendingAutoInstalls): If a bundler or browser module loader evaluates a plugin's /install subpath before { Tempo } has finished initializing, registrations are safely buffered in an ambient queue and automatically drained as soon as Tempo boots.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tree-Shaking Preserved: Standard imports (import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo') retain 100% tree-shakeability with zero automatic side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.3.0] - 2026-09-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.3.0 brings Colocated Plugin Options & Hybrid Factories, deep Intl.LocaleInfo Regional Calendar Context, and a direct Native Temporal Gateway (t.zdt).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Colocated Plugin Options & Callable Factories ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Vite / Rollup Style Factory Invocations: Plugins constructed via definePlugin now function as hybrid callable factories. Pass options directly at call-site:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo.init({\n  plugins: [\n    TickerPlugin({ interval: 1000 }),\n    [GeoPlugin, { timeout: 5000 }] // Tuple syntax also fully supported!\n  ]\n});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Uncalled Plugins Retained: Passing uncalled plugins (plugins: [CelestialPlugin]) continues to work seamlessly without breaking changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Intl.Locale Info & Culturally Authentic Calendars (t.intl) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • First-Class Regional Metadata: Direct access via t.intl (and Tempo.intl) providing frozen regional insights (firstDay, weekend, hourCycle, direction, numberingSystem), alongside t.intl.locale for native Intl.Locale inspection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Adaptive Week Arithmetic (localeInfo: true): With localeInfo: true, operations like t.set({ week: 'start' }) automatically align to the locale's culturally authentic first day (e.g. Sunday in the US, Monday in the UK, Saturday in Saudi Arabia).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dedicated ISO Invariants: Use isoWeek and wy (t.set({ isoWeek: 'start' })) to guarantee Monday-start snapping regardless of locale settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Localized Format Tokens: Added {dow:locale}, {hh:locale}, {time:locale}, and localized numeral formatting ({yyyy:locale} producing ٢٠٢٦ in Arabic locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Direct Native Temporal Gateway (t.zdt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct read-only getter t.zdt exposing the underlying Temporal.ZonedDateTime instance for zero-overhead access to native Temporal properties (daysInMonth, inLeapYear, offset, hoursInDay) without method ceremony.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Day-of-Year Property & Token (t.doy, {doy}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct t.doy accessor (1..366) and formatting token {doy} with width padding support ({doy:3}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.2.0] - 2026-09-09 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.2.0 introduces Dynamic Spatial & Namespace Format Tokens and Universal Geographic Context (options.geo).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Namespace & Spatial Tokens in t.format() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Format strings can now dynamically interpolate active plugin namespaces and spatial properties:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      t.format('{geo.city}, {geo.country} — Fiscal Year: {finance.taxYear}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supports formatting modifiers such as {geo.country:upper} and {geo.city:title} with graceful fallbacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Universal Geographic Context & Hemisphere Inferences ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Provide geolocation coordinates directly on instantiation (new Tempo('today', { geo: { lat: -33.86, lng: 151.2 } })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatically infers hemisphere (t.sphere: 'north' | 'south' | 'equator') and exposes frozen t.geo configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Hardened Static Configuration Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decoupled configuration inheritance (extends) strictly to static data payloads, eliminating dynamic execution vectors and hardening supply chain boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.1.0] - 2026-09-04 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.1.0 expands enterprise configuration governance and developer ergonomics with Remote & Cascading Configuration Resolution ("extends"), a dedicated pluginOptions Configuration Slot, and Overloaded Tempo.create() with Deterministic Resource Disposal (TC39 using).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Remote & Cascading Configuration Resolution (resolveConfig) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Remote URL Config Fetching: Enhanced resolveConfig() and Tempo.bootstrap() to fetch tempo.config.jsonc and tempo.config.json over http:// and https:// URLs (including http://localhost:... or http://127.0.0.1:... for dev servers, container environments, and central governance APIs).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • file:// URL Support: Added native support for file:// URLs in Node.js environments via fileURLToPath.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Inheritance ("extends"): Introduced recursive "extends" resolution in configuration files (string URL/path or array of URLs/paths). Parent configurations are resolved and merged under child local overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Security Boundaries & Loop Protection: HTTP requests are bounded by a 3-second timeout and 128KB payload size cap to prevent hangs and DoS attacks. Remote configs are restricted to static data-only JSON/JSONC payloads. Circular inheritance is detected and prevented.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dedicated pluginOptions Configuration Slot ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced pluginOptions?: Record<string, any> across BaseOptions, Discovery, and Config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enforces clean architectural separation:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • plugins: Strictly reserved for executable code registration (plugins, terms, modules).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • pluginOptions: Dedicated dictionary holding serializable runtime options and defaults for plugins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deep, recursive namespace merging across extends inheritance layers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supplying plain configuration dictionaries directly under plugins is marked @deprecated in favor of pluginOptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Overloaded Tempo.create() & Deterministic Resource Disposal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Explicit Resource Management (TC39 using): Tempo.create() returns SandboxTempo subclasses that implement the TC39 Disposable protocol (Symbol.dispose) and expose an isDisposed getter. Disposing a sandbox clears its discovery slot from globalThis and cleans up internal registry state (ClassStates).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Callback Mode (Tempo.create(fn) / Tempo.create(options, fn)): Overloaded Tempo.create() to accept an execution callback, automatically disposing the ephemeral sandbox upon completion (supporting both synchronous results and async Promises via try...finally).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native using Block Scoping: Full support for TypeScript 5.2+ block-scoped disposable sandboxes: { using sb = Tempo.create({ ... }); ... }.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Architectural Separation of extends and plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extends: Strictly reserved for configuration inheritance via URLs or file paths (string | string[]), mirroring tsconfig.json and ESLint conventions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • plugins: Dedicated for registering executable plugins and terms ((Plugin | Term)[]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use() & Deprecation of Tempo.extend(): Standardized Tempo.use(...) as the runtime registration method. Marked Tempo.extend() as @deprecated Use Tempo.use(...) instead. while preserving backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🐛 Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Symbol.dispose Global State Leakage: Fixed a critical bug where invoking [Symbol.dispose]() on a sandbox class (e.g., via the TC39 using keyword or scoped callback mode) inherited Tempo[Symbol.dispose]() via the prototype chain and inadvertently executed Tempo.init(), wiping the global library configuration and registered plugins. Sandboxed classes now implement an isolated [Symbol.dispose]() that strictly cleans up local sandbox state and discovery slots without mutating global defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.0.0] - 2026-08-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Paradigm Shifts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 is a major architectural milestone introducing Dynamic Functional Context (DFC), a 100% Open-Source Community Core, zero-await Synchronous JSONC Config Discovery, standardized Plugin SDK Facade, and unified {Term: Value} Mutation Payloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Major Breaking Changes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 100% Open-Source Community Core: Completely removed commercial licensing enforcement, JWT verification, JWS claims validation, domain-locking, and premium plugin gating (license.manager.ts, license.validator.ts, Tempo.license, validateLicenseState, LICENSE enum, and $updateScopeStatus).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Commercial Package Decoupling: Relocated all enterprise licensing hooks and commercial plugin management to the @magmacomputing/tempo-pro wrapper package.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Config Auto-Discovery Modernization: Dropped .cjs configuration discovery support in favor of modern ES-preferred module extensions (.mts, .ts, .mjs, .js, .jsonc, .json).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.ready() Return Signature: Simplified Tempo.ready() return value to a static 'none' status for community core compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Namespace Enforcement: Fully excised legacy root-level property access that was deprecated during v3.x.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • formats configuration key has been entirely removed from top-level Options and Discovery. Use registry: { formats: ... } instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • numbers configuration key has been entirely removed from top-level Options. Use registry: { numbers: ... } instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Architectural Modernizations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Functional Context (DFC) & Options Evaluation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Upgraded BaseOptions and Tempo options (timeZone, locale, calendar, sphere) to support Evaluable<T> suppliers (T | (() => T)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context options are dynamically evaluated on a per-request basis without requiring instantiation or re-building configuration state, perfect for multi-tenant applications (e.g., dynamic request headers or per-tenant session resolvers).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Synchronous JSON & JSONC Config Discovery (resolveConfigSync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced zero-await static startup configuration discovery (resolveConfigSync()) utilizing parseJSONC for .jsonc and .json files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ESM and TypeScript config modules (.mts, .ts, .mjs, .js) continue to utilize the asynchronous resolveConfig() path.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatically executed inside Tempo's static { ... } initialization block at module load time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Standardized Plugin SDK Facade (@magmacomputing/tempo/plugin/sdk) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized plugin development on @magmacomputing/tempo/plugin/sdk, replacing legacy plugin-api imports.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Exposes definePlugin, defineTerm, defineModule, defineNamespace, defineRange, and internal evaluation utilities via a single, CDN-friendly facade.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Expanded Utility Stack Exports (@magmacomputing/tempo/library) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Re-exported core evaluation and runtime primitives (Evaluable, AsyncEvaluable, evaluate, evaluateAsync, evaluateConfig, evaluateConfigAsync, dynamicProxy, Pledge, cipher, webToken, enumify) via the @magmacomputing/tempo/library export surface for downstream plugins and custom extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. API Standardization for Boundary & Mutation Payloads ({Term: Value}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized mutation object signatures across .set(), .add(), and plugin payloads to follow the unified {Term: Value} pattern (e.g., .set({ year: 'start' }), .set({ month: 'end' }), .set({ '#qtr': 1 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy positional syntax (e.g., .set({ start: 'year' })) remains supported transparently for backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗑️ API Removals & Cleanups ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed Static Accessors: Removed Tempo.formats accessor; use Tempo.registry.formats instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed Deprecated Subpaths: Removed #tempo/license export mapping.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',105))])}const E=o(l,[["render",c]]);export{y as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.lean.js b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.lean.js new file mode 100644 index 00000000..5c156d7b --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_8-project-and-support_releases_v4.x.md.BIqG5RLx.lean.js @@ -0,0 +1 @@ +import{_ as o,o as t,c as n,a2 as a,j as i,a as s}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"📜 Version 4.x History","description":"","frontmatter":{},"headers":[],"relativePath":"doc/8-project-and-support/releases/v4.x.md","filePath":"doc/8-project-and-support/releases/v4.x.md"}'),l={name:"doc/8-project-and-support/releases/v4.x.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function c(h,e,p,g,k,m){return t(),n("div",null,[e[8]||(e[8]=a("",71)),i("ul",null,[e[7]||(e[7]=a("",2)),i("li",null,[e[2]||(e[2]=i("strong",null,"Multicast Fan-Out",-1)),e[3]||(e[3]=s(": High-performance ",-1)),i("mjx-container",r,[(t(),n("svg",d,[...e[0]||(e[0]=[a("",1)])])),e[1]||(e[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),e[4]||(e[4]=s(" broadcasting across all active push subscribers and async waiters via ",-1)),e[5]||(e[5]=i("code",null,"stream.cast(value)",-1)),e[6]||(e[6]=s(".",-1))])]),e[9]||(e[9]=a("",105))])}const E=o(l,[["render",c]]);export{y as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.js b/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.js new file mode 100644 index 00000000..dc44ae44 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.js @@ -0,0 +1,33 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const d=JSON.parse('{"title":"Tempo Plugin Setup Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/_setup.index.md","filePath":"doc/9-plugins/_setup.index.md"}'),e={name:"doc/9-plugins/_setup.index.md"};function p(l,s,h,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin Setup Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains how to install, register, and activate Tempo plugins in your projects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Overview ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo features an extensible plugin architecture that allows developers to add custom business logic, date generators, term calculators, and domain-specific APIs (such as financial tickers or astronomy calculations) to the Tempo engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All official and community plugins are 100% open source under the MIT license and run without runtime license checks or key configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo plugins are published as scoped packages on the standard npm registry (npmjs.com). Install plugins using your package manager of choice:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo @magmacomputing/tempo-plugin-ticker @magmacomputing/tempo-plugin-celestial  # npm
+pnpm add @magmacomputing/tempo @magmacomputing/tempo-plugin-ticker @magmacomputing/tempo-plugin-celestial     # pnpm
+yarn add @magmacomputing/tempo @magmacomputing/tempo-plugin-ticker @magmacomputing/tempo-plugin-celestial     # yarn
+bun add @magmacomputing/tempo @magmacomputing/tempo-plugin-ticker @magmacomputing/tempo-plugin-celestial      # bun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Registration & Activation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides flexible registration options depending on your application structure and bundler setup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pass plugins directly to Tempo.init() during application initialization via the plugins array. This guarantees clean execution order regardless of import hoisting:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+Tempo.init({
+  plugins: [TickerPlugin]
+});
+
+const t = new Tempo();
+console.log(Tempo.tickers);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Option B: Explicit Extension (Tempo.extend) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Register plugins dynamically at runtime using Tempo.extend():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.extend(CelestialPlugin);
+
+const t = new Tempo('2026-03-20', { sphere: 'north' });
+console.log(t.term.astro); // Discovers equinoxes and astronomical seasons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Browser & Global Namespace Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using pre-bundled scripts directly in HTML via <script> tags, plugins attach to the Magma.plugins global object:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <!-- 1. Core Temporal Polyfill & Tempo -->
+<script src="https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.umd.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.min.js"></script>
+
+<!-- 2. Plugin Script -->
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-celestial@1/dist/index.global.min.js"></script>
+
+<script>
+  const { Tempo, plugins } = Magma;
+
+  // Register the plugin
+  Tempo.extend(plugins.celestial);
+
+  const t = new Tempo('next friday');
+  console.log(t.toString());
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Authoring Custom Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interested in creating your own plugin? Check out the Creating Custom Plugins Guide and Plugin Ecosystem Catalog to learn how to register custom getters, term definitions, and dynamic proxies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,26)])])}const c=i(e,[["render",p]]);export{d as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.lean.js new file mode 100644 index 00000000..c487562e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins__setup.index.md.BnCV1I9W.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const d=JSON.parse('{"title":"Tempo Plugin Setup Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/_setup.index.md","filePath":"doc/9-plugins/_setup.index.md"}'),e={name:"doc/9-plugins/_setup.index.md"};function p(l,s,h,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t("",26)])])}const c=i(e,[["render",p]]);export{d as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.js new file mode 100644 index 00000000..670df4c9 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.js @@ -0,0 +1,114 @@ +import{_ as t,C as l,o as i,c as p,a2 as a,b as r,w as e,a as h,E as k,a5 as o}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"Provider Architecture & Security","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.architecture.md","filePath":"doc/9-plugins/ai.architecture.md"}'),d={name:"doc/9-plugins/ai.architecture.md"};function c(E,s,g,y,u,m){const n=l("Mermaid");return i(),p("div",null,[s[1]||(s[1]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provider Architecture & Security ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ai plugin is designed to be highly flexible, supporting both direct Bring Your Own Key (BYOK) integrations for backend systems, and Proxied integrations for frontend clients.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bring Your Own Key (BYOK) & Zero-Config Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For Node.js, Deno, and Bun backends, @magmacomputing/tempo-plugin-ai supports Zero-Config Auto-Discovery. If standard environment variables (GROQ_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, MISTRAL_API_KEY) are present, calling initAI() is optional—the plugin will automatically discover credentials and wire up provider defaults lazily on first function call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alternatively, you can supply your API keys and execution options explicitly via initAI:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI } from '@magmacomputing/tempo-plugin-ai';
+
+initAI({
+  providers: [
+    ...(process.env.GROQ_API_KEY ? [{ id: 'groq', key: process.env.GROQ_API_KEY }] : []),
+    ...(process.env.GEMINI_API_KEY ? [{ id: 'gemini', key: process.env.GEMINI_API_KEY }] : []),
+    ...(process.env.OPENAI_API_KEY ? [{ id: 'openai', key: process.env.OPENAI_API_KEY }] : [])
+  ]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced Configuration (Custom Models & LLM Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, standard providers automatically map to their optimal APIs and default models. However, you can explicitly override URLs, models, and inject arbitrary LLM parameters (like temperature) for power-user control!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initAI({
+  providers: [
+    // 1. Enterprise Azure OpenAI (via Entra ID Bearer token or backend proxy wrapper)
+    // Note: BYOK requests send 'Authorization: Bearer <key>'. When connecting to Azure OpenAI,
+    // supply an Entra ID bearer token as provider.key or route through an Azure API gateway.
+    ...(process.env.AZURE_ENTRA_BEARER_TOKEN ? [{ 
+      id: 'openai', 
+      key: process.env.AZURE_ENTRA_BEARER_TOKEN,
+      url: 'https://my-enterprise.openai.azure.com/v1/chat/completions',
+      model: 'your-enterprise-model',
+      options: { temperature: 0.2, seed: 42 }
+    }] : []),
+    // 2. Local Open-Source Models (e.g. Ollama)
+    { 
+      id: 'local', 
+      key: 'no-key-needed',
+      url: 'http://localhost:11434/v1/chat/completions',
+      model: 'your-local-model',
+      options: { timeout: 5000 } // Custom provider-level timeout (5s)
+    }
+  ]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Per-Request Lazy Resolution & Fallback Defaults ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When dispatching requests via transport.ts, all provider fields (key, url, model) and execution context (timeZone, locale, calendar, sphere) are resolved lazily just-in-time using functional evaluation (evaluate / evaluateAsync):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Explicit Dynamic Suppliers: If a supplier function was provided (e.g. key: async () => await getRotatedKey()), it is called per-dispatch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Built-in Fallbacks: If a property is omitted or resolves to undefined, the transport layer seamlessly cascades to the compiled DEFAULT_PROVIDERS templates, remote manifest endpoints, and auto-discovered environment variables.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. No Configuration Mutation: The dynamic resolution runs ephemerally per HTTP dispatch without mutating or locking shared global provider state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Provider Manifests & Remote Endpoint Trust ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, @magmacomputing/tempo-plugin-ai lazily fetches provider defaults (model IDs, endpoints, token parameter keys) from https://tempo.magmacomputing.com.au/providers.v1.json once per application lifecycle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Remote Manifest Trust & Endpoint Enforcement:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • remoteConfigUrl is restricted to fixed trusted hosts (tempo.magmacomputing.com.au or trusted internal HTTPS endpoints).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Any dynamic provider.url values received from the manifest or dynamically returned via fetchDefaults are strictly validated against an enforced provider host allowlist (or must use verified HTTPS/localhost origins) before getResolvedProviderDefaults() merges them into runtime provider configurations. Untrusted or unauthenticated endpoints are rejected and stripped before merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Validation on fetchDefaults Hook: The exact same host allowlist and HTTPS origin verification is enforced when resolving custom provider options via the fetchDefaults callback. Any dynamic hook attempting to return unauthenticated or disallowed host URLs will have the url property safely discarded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Async Resolution & Promise Lifecycle: initAI() returns a Promise<void>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Synchronous Fire-and-Forget: Calling initAI(...) synchronously without await immediately initializes system state with compiled local provider defaults (DEFAULT_PROVIDERS). You can execute parseAI() immediately on the next line without blocking. The remote manifest is fetched in the background and transparently updates provider defaults once received.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Guaranteed Remote Resolution: If your application strictly requires remote provider defaults to be resolved before executing your first AI request, you can await initAI(...):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Await guaranteed remote manifest completion before proceeding
+await initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY! }]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fail-Open & Air-Gapped Fallback: If the network request fails, times out (1500ms limit), or the application is running offline or in an air-gapped environment, initAI() automatically and silently falls back to compiled local defaults (DEFAULT_PROVIDERS).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Disabling Remote Manifest: Pass remoteConfigUrl: false to disable remote manifest fetching entirely:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY! }],
+  remoteConfigUrl: false // Disable remote manifest fetching
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Frontend Security Warning ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CAUTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Never expose a raw LLM API key in a client-side browser bundle (like React, Vue, or Svelte) or store it in any browser storage (localStorage, sessionStorage, IndexedDB, OPFS, or browser cache). We strongly recommend zero browser storage for API credentials; any Cross-Site Scripting (XSS) vulnerability, compromised NPM dependency, or malicious browser extension can inspect client-side storage and extract secret keys, leading to quota drainage, unexpected billing spikes, or account bans. BYOK provider keys are only safe on backend servers and edge workers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser & Client-Side Proxy Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To execute AI functions within client-side browser applications safely, route requests through a secure self-hosted backend proxy or unified AI Gateway (such as a Cloudflare Worker, Next.js API route, Express server, OpenRouter, Portkey, or LiteLLM):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,21)),(i(),r(o,null,{default:e(()=>[k(n,{id:"mermaid-121",class:"mermaid",graph:"flowchart%20LR%0A%20%20%20%20subgraph%20Browser%20%5B%22Client-Side%20Browser%20(SPA)%22%5D%0A%20%20%20%20%20%20%20%20Client%5B%22Tempo%20AI%20Plugin%3Cbr%2F%3E(initAI%20%2F%20parseAI%20%2F%20diffAI)%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Backend%20%5B%22Self-Hosted%20Proxy%20%2F%20AI%20Gateway%22%5D%0A%20%20%20%20%20%20%20%20Proxy%5B%22Your%20Backend%20API%20%2F%20AI%20Gateway%3Cbr%2F%3E%E2%80%A2%20User%20Authentication%20%26%20Rate%20Limits%3Cbr%2F%3E%E2%80%A2%20Secure%20Secret%20Management%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Providers%20%5B%22Upstream%20LLM%20Providers%22%5D%0A%20%20%20%20%20%20%20%20LLM%5B%22Groq%20%E2%80%A2%20OpenAI%20%E2%80%A2%20Gemini%20%E2%80%A2%20Anthropic%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20Client%20--%20%221.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EBearer%20Token%20%2F%20Auth%20Header%22%20--%3E%20Proxy%0A%20%20%20%20Proxy%20--%20%222.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EPrivate%20Provider%20API%20Key%22%20--%3E%20LLM%0A%20%20%20%20LLM%20--%20%223.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3ERaw%20JSON%20Completion%22%20--%3E%20Proxy%0A%20%20%20%20Proxy%20--%20%224.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EValidated%20Payload%22%20--%3E%20Client%0A"})]),fallback:e(()=>[...s[0]||(s[0]=[h(" Loading... ",-1)])]),_:1})),s[2]||(s[2]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Browser Configuration Example ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure initAI in your browser code to target your backend proxy or AI Gateway URL:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Safe for browser deployment: No private LLM API keys are bundled
+await initAI({
+  providers: [
+    {
+      id: 'my-gateway',
+      url: 'https://api.mycompany.com/v1/ai/chat/completions', // Your secure proxy endpoint
+      key: userSessionToken, // Short-lived user Bearer JWT token
+      model: 'llama-3.3-70b-instruct'
+    }
+  ]
+});
+
+// All Tempo AI functions now execute securely through your proxy
+const date = await parseAI("Team standup next Wednesday at 9:30am");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Backend Proxy Handler Example (Next.js / Cloudflare Worker / Express) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Your backend endpoint receives the request, validates the user's session, enforces ingress quotas, attaches your private LLM API key, and forwards the validated payload to the upstream provider:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example: Next.js API Route / Cloudflare Worker / Express Proxy Handler
+export async function POST(req: Request, env?: { GROQ_API_KEY?: string }) {
+  // 1. Authenticate user session
+  const authHeader = req.headers.get('Authorization');
+  const session = await validateUserSession(authHeader);
+  if (!session) {
+    return new Response('Unauthorized', { status: 401 });
+  }
+
+  // 2. Ingress validation & per-user quota enforcement
+  const body = await req.json();
+  if (typeof body?.prompt !== 'string' || body.prompt.length > 4096) {
+    return new Response('Invalid prompt or payload exceeds size limit', { status: 400 });
+  }
+  if (!checkUserRateLimit(session.userId)) {
+    return new Response('Too Many Requests', { status: 429 });
+  }
+
+  // 3. Resolve API key (Cloudflare Worker env binding or Node/Next.js process.env)
+  const apiKey = env?.GROQ_API_KEY || (typeof process !== 'undefined' ? process.env?.GROQ_API_KEY : undefined);
+  if (!apiKey) {
+    return new Response('Provider key configuration missing', { status: 500 });
+  }
+
+  // 4. Construct upstream fetch with bounded timeout and cleanup
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s upstream limit
+
+  try {
+    const upstreamResponse = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${apiKey}\`
+      },
+      body: JSON.stringify({
+        model: 'openai/gpt-oss-120b',
+        messages: body.messages,
+        temperature: 0.1,
+      }),
+      signal: controller.signal
+    });
+
+    // 5. Return provider payload to client
+    const data = await upstreamResponse.json();
+    return new Response(JSON.stringify(data), {
+      status: upstreamResponse.status,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  } catch (err: any) {
+    if (err.name === 'AbortError' || controller.signal.aborted) {
+      return new Response(JSON.stringify({ error: 'Upstream provider gateway timeout' }), {
+        status: 504,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+    return new Response(JSON.stringify({ error: 'Upstream connection failure' }), {
+      status: 502,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔒 Security & Privacy Guarantees ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For an in-depth breakdown of our automated PII redaction, Smart Debug infrastructure, and tamper-resistant Proxy introspection, see the dedicated Security & Privacy Architecture Guide (security.md).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether running directly on backend servers (Node.js, Deno, Bun, Edge Workers) or through a client-side browser proxy, @magmacomputing/tempo-plugin-ai enforces strict security and privacy standards:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Transport Security (HTTPS / TLS) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All network communication—both from client to proxy and from proxy/server to upstream LLM endpoints—is required over HTTPS. Negotiated TLS versions (such as TLS 1.2 or TLS 1.3) depend on deployment environment and server configuration unless strictly enforced by your reverse proxy. Plaintext HTTP endpoints are disallowed in production environments (permitted only on localhost during local development).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Ephemeral Processing & Cache Retention Controls ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal processing payloads (dates, times, context snippets, prompts) are processed ephemerally. The plugin does not send telemetry or store user prompt data on external analytics servers. However, functions supporting caching (e.g. parseAI, formatAI, diffAI) may retain prompt-derived cache keys and final results in local memory or configured custom cache adapters according to the resolved TTL. Requests requiring zero cache retention must explicitly pass cache: false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. In-Memory Credential Redaction & Immutability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automated Key Redaction: Calling getAiConfig() returns a sanitized, deeply read-only snapshot of active configurations with all provider key values replaced with [REDACTED], preventing accidental exposure in log files, APM traces, or crash dumps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Frozen Metadata: All diagnostic metadata attached to Tempo instances via .ai and all structured AI result objects (TempoAiFormatResult, TempoAiExtractResult, TempoAiDiffResult, TempoScheduleResult, TempoRecurrenceResult, TempoContext) are deeply frozen with Object.freeze() and guarded via runtime Proxy wrappers, protecting against direct runtime mutation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Deterministic Schema Guardrails & Confidence Range Verification ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All LLM prompts are paired with rigid, machine-verifiable JSON schemas. Responses undergo strict boundary validation, regex parsing, confidence range verification (0.0 to 1.0), and schema verification before any native Tempo date object or structured result payload is instantiated. If an LLM returns malformed, out-of-range, or unparseable data, the plugin throws a typed TempoAiError or triggers automatic provider fallback rather than silently propagating corrupt data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Partitioned Caching & Fail-Open Storage Resilience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Cache Key Partitioning: Caches are namespaced and hashed (ai:<namespace>::...) with timezone, locale, calendar, and anchor date isolation to prevent cross-tenant or cross-regional cache poisoning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fail-Open Protection: If a custom distributed cache adapter (e.g. Redis or Cloudflare KV) encounters network disruption or errors, the plugin automatically fails open to direct LLM resolution, preserving application uptime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Provider Execution Strategies (AiMode) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because third-party APIs can experience downtime, latency spikes, or quota exhaustion, @magmacomputing/tempo-plugin-ai provides six dedicated dispatch strategies configured via AiMode (or string literals):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StrategyEnum (AiMode)Primary AdvantageTypical Use Case
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fallback (Default)AiMode.FallbackMinimum token cost (sequential cascade)Default production baseline & background tasks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HedgedAiMode.HedgedUltra-fast latency with low token overhead (~1.15x)Latency-sensitive interactive search & chatbots
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RoundRobinAiMode.RoundRobinCyclic rotation across multi-key poolsHigh-throughput batch ingestion across API keys
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AdaptiveAiMode.AdaptiveTelemetry-driven rate-limit avoidanceMulti-tier provider pools with mixed quotas
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RaceAiMode.RaceAbsolute minimum response latencyReal-time typeahead & autocomplete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConsensusAiMode.ConsensusCross-LLM verification & hallucination trappingHigh-stakes legal, financial, and contract dates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 For detailed architecture breakdowns, Mermaid decision trees, and configuration guides for each mode, see the Multi-Provider Execution Modes Guide (modes.md).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provider ID Canonicalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provider IDs are normalized case-insensitively during initAI lookup (e.g. 'Gemini', 'gemini', 'OpenAI'), automatically applying default endpoints and models while preserving the caller's registered identifier for logging and metadata.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,26))])}const f=t(d,[["render",c]]);export{A as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.lean.js new file mode 100644 index 00000000..96b60cdf --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.architecture.md.CCj_oaug.lean.js @@ -0,0 +1 @@ +import{_ as t,C as l,o as i,c as p,a2 as a,b as r,w as e,a as h,E as k,a5 as o}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"Provider Architecture & Security","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.architecture.md","filePath":"doc/9-plugins/ai.architecture.md"}'),d={name:"doc/9-plugins/ai.architecture.md"};function c(E,s,g,y,u,m){const n=l("Mermaid");return i(),p("div",null,[s[1]||(s[1]=a("",21)),(i(),r(o,null,{default:e(()=>[k(n,{id:"mermaid-121",class:"mermaid",graph:"flowchart%20LR%0A%20%20%20%20subgraph%20Browser%20%5B%22Client-Side%20Browser%20(SPA)%22%5D%0A%20%20%20%20%20%20%20%20Client%5B%22Tempo%20AI%20Plugin%3Cbr%2F%3E(initAI%20%2F%20parseAI%20%2F%20diffAI)%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Backend%20%5B%22Self-Hosted%20Proxy%20%2F%20AI%20Gateway%22%5D%0A%20%20%20%20%20%20%20%20Proxy%5B%22Your%20Backend%20API%20%2F%20AI%20Gateway%3Cbr%2F%3E%E2%80%A2%20User%20Authentication%20%26%20Rate%20Limits%3Cbr%2F%3E%E2%80%A2%20Secure%20Secret%20Management%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Providers%20%5B%22Upstream%20LLM%20Providers%22%5D%0A%20%20%20%20%20%20%20%20LLM%5B%22Groq%20%E2%80%A2%20OpenAI%20%E2%80%A2%20Gemini%20%E2%80%A2%20Anthropic%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20Client%20--%20%221.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EBearer%20Token%20%2F%20Auth%20Header%22%20--%3E%20Proxy%0A%20%20%20%20Proxy%20--%20%222.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EPrivate%20Provider%20API%20Key%22%20--%3E%20LLM%0A%20%20%20%20LLM%20--%20%223.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3ERaw%20JSON%20Completion%22%20--%3E%20Proxy%0A%20%20%20%20Proxy%20--%20%224.%20HTTPS%20(TLS%201.2%2B)%3Cbr%2F%3EValidated%20Payload%22%20--%3E%20Client%0A"})]),fallback:e(()=>[...s[0]||(s[0]=[h(" Loading... ",-1)])]),_:1})),s[2]||(s[2]=a("",26))])}const f=t(d,[["render",c]]);export{A as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.js new file mode 100644 index 00000000..c31fa10c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.js @@ -0,0 +1,44 @@ +import{_ as i,o as t,c as e,a2 as a}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"contextAI — Context & Regional Inference","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.context.md","filePath":"doc/9-plugins/ai.context.md"}'),n={name:"doc/9-plugins/ai.context.md"};function l(o,s,h,r,p,d){return t(),e("div",null,[...s[0]||(s[0]=[a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextAI — Context & Regional Inference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextAI() is designed to analyze unstructured or ambiguous text (e.g. user biographies, locations, or email bodies) and infer their regional configuration settings. It resolves these properties to a standard configuration object containing timezone, locale, calendar system, and hemisphere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Debug Telemetry: Enabling debug: true activates operational logs. In production environments (NODE_ENV === 'production'), PII (emails, phone numbers, auth tokens) is automatically sanitized and masked in console output and terminal inspections. See the Security & Privacy Architecture Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is highly useful for user onboarding settings, automatic context mapping for calendar syncs, and geolocating inputs dynamically without maintaining static geographic mapping tables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ai features zero-config auto-discovery. If provider keys exist in your environment (GROQ_API_KEY, OPENAI_API_KEY, etc.) or tempo.config.json, calling initAI() is completely optional.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { contextAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Infer contextual settings directly from unstructured text (auto-discovers provider keys)
+const context = await contextAI("I'm a photographer based in Sydney, Australia.");
+
+console.log(context.timeZone);  // "Australia/Sydney"
+console.log(context.locale);    // "en-AU"
+console.log(context.calendar);  // "gregory"
+console.log(context.sphere);    // "south"
+console.log(context.confidence);// 0.98

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (AiContextOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanIf true, bypasses the cache to initiate a fresh LLM query.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cachebooleanIf false, disables writing to and reading from cache adapters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheAdapterAiCacheAdapterCustom cache engine (e.g., Redis) for caching results on this request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttlnumberTime-to-live override in milliseconds for cached results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumberMinimum confidence score threshold (0.0 to 1.0) required to return a valid slot. Throws TempoAiError(422) if lower.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeConcurrency routing strategy (fallback, race, consensus, hedged, roundrobin, adaptive). Refer to the Multi-Provider Execution Modes Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providersAiProvider[]Per-request provider configuration overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeoutnumberPer-request timeout in milliseconds (overrides provider and global timeouts).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hedgeDelaynumberDelay in milliseconds before initiating speculative hedging in AiMode.Hedged (default: 800ms).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debugbooleanIf true, logs prompt context and cache operations to console (automatically PII-sanitized in production).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    softErrorsbooleanIf true, returns TempoAiError into array index position instead of rejecting the entire batch query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Schema (TempoContext) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoContext {
+  /** Inferred IANA time zone identifier (e.g. 'America/New_York') */
+  timeZone: string;
+  
+  /** Inferred BCP 47 language/region tag (e.g. 'en-US') */
+  locale: string;
+  
+  /** Inferred Unicode calendar system type (e.g. 'gregory') */
+  calendar: string;
+  
+  /** Inferred hemisphere, or undefined if ambiguous */
+  sphere?: 'north' | 'south' | undefined;
+  
+  /** Confidence rating from 0.0 (unparseable) to 1.0 (certain) */
+  confidence: number;
+  
+  /** Resolution source ('cache' or provider ID like 'groq', 'gemini', 'openai') */
+  provider: string;
+  
+  /** Step-by-step reasoning or justification provided by the engine/LLM */
+  reasoning?: string | undefined;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Architectural Behaviors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Workspace Baseline Context ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextAI inspects the host runtime or current Tempo configuration (Tempo.options.timeZone, Tempo.options.locale, etc.) as a fallback baseline. If an input like "at home" is provided, the LLM will ground its inference in the workstation's baseline defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Strict Confidence Thresholds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using minConfidence, developers can guarantee that low-certainty or completely ambiguous inputs (e.g., "in the park") throw a TempoAiError(422) rather than silently returning guessed context parameters:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const context = await contextAI("meeting somewhere online", { minConfidence: 0.9 });
+// Throws TempoAiError(422): Inferred context confidence (0.4) is below the required threshold of 0.9.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Timezone Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before returning, the returned IANA timezone string is dynamically validated against the runtime's native JavaScript Intl API. If the LLM returns an unsupported or fake timezone identifier, contextAI throws a TempoAiError(422) to prevent application runtime failures.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Parallel Batch Processing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can pass an array of strings to process multiple contexts concurrently:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const [context1, context2] = await contextAI([
+  "Working from Kyoto",
+  "Living in Melbourne"
+]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Combining contextAI with parseAI (The Pivot Flow) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Often, a user will mention their location in one sentence and a relative time in another. You can chain these APIs together to form a seamless date-resolution pipeline:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { contextAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Deduces the context
+const ticketContext = await contextAI("customer issue from our London office");
+// ticketContext = { timeZone: 'Europe/London', locale: 'en-GB', sphere: 'north' }
+
+// 2. Feed the output context directly as options into parseAI
+const resolutionTime = await parseAI("issue occurred on 04/05/2026 at 3 PM", ticketContext);
+// 1. Correctly parses 04/05 to May 4th (UK format) rather than April 5th.
+// 2. Adjusts to BST/GMT (Europe/London).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,31)])])}const g=i(n,[["render",l]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.lean.js new file mode 100644 index 00000000..7f47631e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.context.md.CpTdp7nz.lean.js @@ -0,0 +1 @@ +import{_ as i,o as t,c as e,a2 as a}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"contextAI — Context & Regional Inference","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.context.md","filePath":"doc/9-plugins/ai.context.md"}'),n={name:"doc/9-plugins/ai.context.md"};function l(o,s,h,r,p,d){return t(),e("div",null,[...s[0]||(s[0]=[a("",31)])])}const g=i(n,[["render",l]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.js new file mode 100644 index 00000000..d8410689 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.js @@ -0,0 +1,57 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"diffAI — Contextual & Business Date Deltas","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.diff.md","filePath":"doc/9-plugins/ai.diff.md"}'),e={name:"doc/9-plugins/ai.diff.md"};function l(h,s,p,d,k,r){return a(),t("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diffAI — Contextual & Business Date Deltas ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diffAI() expresses the temporal delta between two Tempo instances, timestamps, or date strings in human, business, or operational terms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While core Tempo provides precise numeric calculations (start.until(end, 'day')), diffAI bridges the gap to domain-specific narrative explanations (e.g. accounting working days, delivery SLAs, relative countdowns, and sprint planning summaries) backed by arithmetic grounding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { initAI, diffAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize AI providers
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY }
+  ]
+});
+
+const start = new Tempo('2026-08-01T09:00:00Z'); // Saturday
+const end = new Tempo('2026-08-10T17:00:00Z');   // Next Monday
+
+const diff = await diffAI(start, end, 'explain in terms of business working days');
+
+console.log(diff.formatted);    // "5 business days (approx. 224 calendar hours)"
+console.log(diff.businessDays); // 5
+console.log(diff.days);         // 9.33
+console.log(diff.hours);        // 224
+console.log(diff.confidence);   // 0.96

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (AiDiffOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    holidaysstring[]Explicit array of holiday dates ('YYYY-MM-DD') to exclude from business days.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    regionstringRegional context (e.g., 'AU-NSW', 'US') passed to LLM grounding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonestringTarget IANA timezone for date boundaries and calculation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localestring | string[]Locale for narrative language formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanIf true, bypasses the cache to initiate a fresh LLM query.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cachebooleanIf false, disables writing to and reading from cache adapters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheAdapterAiCacheAdapterCustom cache engine (e.g., Redis) for caching results on this request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttlnumberTime-to-live override in milliseconds for cached results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumberMinimum confidence score threshold (0.0 to 1.0) required. Throws TempoAiError(422) if lower.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeConcurrency routing strategy (fallback, race, consensus, hedged, roundrobin, adaptive). Refer to the Multi-Provider Execution Modes Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    softErrorsbooleanIf true, returns TempoAiError into array indices instead of rejecting batch queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Schema (TempoAiDiffResult) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoAiDiffResult {
+  /** Human-friendly, contextual narrative text summarizing the difference */
+  formatted: string;
+  
+  /** Total calendar days between start and end */
+  days?: number | undefined;
+  
+  /** Total elapsed calendar hours between start and end */
+  hours?: number | undefined;
+  
+  /** Total business working days (excluding weekends and matching holidays) */
+  businessDays?: number | undefined;
+  
+  /** List of holiday dates (YYYY-MM-DD) encountered within the interval */
+  holidays?: string[] | undefined;
+  
+  /** Confidence rating from 0.0 (unparseable) to 1.0 (certain) */
+  confidence: number;
+  
+  /** Resolution source ('cache' or provider ID like 'groq', 'gemini', 'openai') */
+  provider: string;
+  
+  /** Step-by-step reasoning or justification provided by the engine/LLM */
+  reasoning?: string | undefined;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Architectural Behaviors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Native Grounding Context ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To guarantee arithmetic precision and prevent LLM hallucinations, diffAI natively computes exact calendar days, elapsed hours, and business working days using Tempo before dispatching to the LLM. Business day grounding automatically respects regional weekend definitions via Intl.LocaleInfo (e.g. Friday/Saturday in ar-SA, Friday-only in fa-IR, or Saturday/Sunday in standard ISO regions) as well as explicitly provided holidays. These metrics are supplied as grounding constraints in the system prompt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Public Holiday Exclusions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can supply regional public holidays (e.g., from @magmacomputing/tempo-fns via getPublicHolidays) to automatically adjust business day counters:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { getPublicHolidays } from '@magmacomputing/tempo-fns';
+
+const holidays = (await getPublicHolidays(2026, 'AU')).map(h => h.date);
+
+const result = await diffAI('2026-12-24', '2027-01-04', 'calculate net business days', {
+  holidays,
+  region: 'AU',
+});
+
+console.log(result.businessDays); // 5 (Christmas, Boxing Day, New Year's Day excluded)
+console.log(result.holidays);     // ['2026-12-25', '2026-12-26', '2027-01-01']

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Directional Awareness & Reverse Intervals ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When the end date is earlier than the start date, diffAI indicates past/backward direction and provides negative business day counts (e.g. -5 business days), allowing the LLM to format relative past descriptions (e.g. "5 business days ago").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Parallel Batch Processing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can pass an array of diff pairs to resolve multiple deltas concurrently:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const [diff1, diff2] = await diffAI([
+  { start: '2026-08-01', end: '2026-08-05', prompt: 'summarize for billing' },
+  { start: '2026-08-05', end: '2026-08-15', prompt: 'explain project sprint' },
+]);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,26)])])}const g=i(e,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.lean.js new file mode 100644 index 00000000..765322c2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.diff.md.BYs4NFiQ.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"diffAI — Contextual & Business Date Deltas","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.diff.md","filePath":"doc/9-plugins/ai.diff.md"}'),e={name:"doc/9-plugins/ai.diff.md"};function l(h,s,p,d,k,r){return a(),t("div",null,[...s[0]||(s[0]=[n("",26)])])}const g=i(e,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.js new file mode 100644 index 00000000..cd3551e2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.js @@ -0,0 +1,73 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"extractAI — Unstructured Text & Calendar Event Extraction","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.extract.md","filePath":"doc/9-plugins/ai.extract.md"}'),n={name:"doc/9-plugins/ai.extract.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extractAI — Unstructured Text & Calendar Event Extraction ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extractAI() scans unstructured, multi-paragraph text (emails, meeting transcripts, chat logs, task notes, calendar invitations) to automatically identify, parse, and extract all embedded temporal entities and time-bound events into structured TempoAiExtractResult records containing native Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative expressions (such as "tomorrow at 10am", "next Tuesday from 1 to 3pm", "final deliverables due Friday EOD") are resolved and mathematically grounded against an explicit or current reference anchor timestamp, timezone, and calendar system.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { initAI, extractAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize AI providers
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY }
+  ]
+});
+
+const emailText = \`
+Hi team,
+Let's schedule our Sprint Review tomorrow from 10:00 AM to 11:30 AM in Room 4A.
+Also, reminder that all pull requests and documentation are due next Friday by 5:00 PM.
+\`;
+
+const anchor = new Tempo('2026-08-10T09:00:00Z'); // Monday morning
+
+const result = await extractAI(emailText, { anchor, timeZone: 'America/New_York' });
+
+for (const event of result.events) {
+  console.log(\`[\${event.type}] \${event.label}\`);
+  console.log(\`  Start: \${event.start.format('{yyyy}-{mm}-{dd} {hh}:{mi}')}\`);
+  if (event.end) {
+    console.log(\`  End:   \${event.end.format('{yyyy}-{mm}-{dd} {hh}:{mi}')}\`);
+  }
+  console.log(\`  Source: "\${event.rawText}" (Confidence: \${event.confidence})\`);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (AiExtractOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    anchorTempoDateInputReference anchor date for relative expressions (defaults to current time).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonestringTarget IANA timezone for grounding and output Tempo instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localestring | string[]Target BCP 47 locale or language tag (e.g. 'en-US', 'fr-FR').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendarstringCalendar system (e.g. 'gregory', 'hebrew', 'islamic').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    categoriesstring[]Optional list of categories to filter entities (e.g. ['meeting', 'deadline']).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    regionstringRegional context (e.g. 'AU-NSW', 'US-NY') passed to LLM grounding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanIf true, bypasses cache to force a fresh LLM query.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cachebooleanIf false, disables writing to and reading from cache adapters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheAdapterAiCacheAdapterCustom cache engine (e.g., Redis, Cloudflare KV) for caching results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttlnumberTime-to-live override in milliseconds for cached results (defaults to 24h).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumberMinimum confidence score threshold (0.0 to 1.0) required. Throws TempoAiError(422) if lower.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeConcurrency routing strategy (fallback, race, consensus, hedged, roundrobin, adaptive). Refer to the Multi-Provider Execution Modes Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    softErrorsbooleanIf true, returns TempoAiError into array indices instead of rejecting batch queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Schema (TempoAiExtractResult) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoAiExtractResult {
+  /** Array of extracted events with instantiated Tempo objects. */
+  events: TempoExtractedEvent[];
+  
+  /** Overall extraction confidence score between 0.0 and 1.0. */
+  confidence: number;
+  
+  /** ID of the provider that fulfilled the request (or 'cache'). */
+  provider: string;
+  
+  /** Optional summary or reasoning from the LLM. */
+  reasoning?: string | undefined;
+}
+
+export interface TempoExtractedEvent {
+  /** Short descriptive label or title of the extracted event/activity. */
+  label: string;
+  
+  /** Start date-time point as an instantiated Tempo instance. */
+  start: Tempo;
+  
+  /** Optional end date-time point (if an interval or duration was mentioned). */
+  end?: Tempo | undefined;
+  
+  /** Classification category ('point' | 'interval' | 'deadline' | 'recurrence' | 'tentative'). */
+  type: TempoEventType;
+  
+  /** Raw text snippet extracted from the source document. */
+  rawText?: string | undefined;
+  
+  /** Confidence score for this specific entity extraction (0.0 to 1.0). */
+  confidence: number;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Architectural Behaviors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Mathematical Grounding & Hallucination Suppression ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To prevent hallucinated dates, extractAI calculates grounding anchor coordinates before dispatching to the LLM:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Localized ISO reference timestamp and timezone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Day of the week name and ordinal index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Target calendar system and regional context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constrained JSON schema ensuring valid ISO dates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Native Tempo Instances ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extracted start and end points are immediately instantiated as live Tempo objects, ready for subsequent date math, interval arithmetic, or timezone shifting:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const result = await extractAI(transcript);
+const meeting = result.events[0];
+
+// Instant date operations with Tempo
+const reminderTime = meeting.start.subtract('15 minutes');
+console.log(\`Set alarm for: \${reminderTime.format('{h12}:{mi} {mer}')}\`);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Multi-Tier Distributed Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extractAI integrates multi-tier caching (in-memory and optional asynchronous AiCacheAdapter such as Redis or Cloudflare KV). Cached ISO timestamps are rehydrated into live Tempo objects upon cache hits:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const result = await extractAI(documentText, {
+  cacheAdapter: redisCacheAdapter,
+  ttl: 86_400_000, // 24 hours
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Parallel Batch Extraction ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Process arrays of documents concurrently with optional softErrors fault-tolerance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const documents = [
+  "Team offsite next Thursday from 9am to 5pm.",
+  "Project proposal submission deadline is August 20 at midnight."
+];
+
+const results = await extractAI(documents, { softErrors: true });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,28)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.lean.js new file mode 100644 index 00000000..97d37acc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.extract.md.C5CeS4nG.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"extractAI — Unstructured Text & Calendar Event Extraction","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.extract.md","filePath":"doc/9-plugins/ai.extract.md"}'),n={name:"doc/9-plugins/ai.extract.md"};function l(h,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[e("",28)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.js new file mode 100644 index 00000000..7947f2f1 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.js @@ -0,0 +1,40 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"formatAI — Contextual & Narrative Date Formatting","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.format.md","filePath":"doc/9-plugins/ai.format.md"}'),n={name:"doc/9-plugins/ai.format.md"};function l(r,s,h,p,o,d){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    formatAI — Contextual & Narrative Date Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    formatAI() formats a Tempo instance, TC39 Temporal object, Date, or timestamp into human-friendly, contextual narrative text tailored to specific UI tones, relative time frames, or business domains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While core Tempo provides token-based template formatting (t.format('{yyyy}-{mm}-{dd}')), formatAI bridges the gap to contextual, localized human descriptions that token patterns alone cannot capture (e.g. countdowns, calendar invites, conversational reminders, and domain summaries), backed by mathematical grounding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { initAI, formatAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize AI providers
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY }
+  ]
+});
+
+const target = new Tempo('2026-08-07T17:00:00[America/New_York]');
+const anchor = new Tempo('2026-08-02T17:00:00[America/New_York]');
+
+// "this Friday at 5:00 PM EDT (in 5 days)"
+const result = await formatAI(target, 'friendly reminder tone with relative countdown', { anchor });
+
+console.log(result.formatted);  // "this Friday at 5:00 PM EDT (in 5 days)"
+console.log(result.confidence); // 0.98
+console.log(result.provider);   // 'groq'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (AiFormatOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    anchorTempoDateInputReference anchor date for relative delta calculations (defaults to current time).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stylestringNarrative style or tone hint (e.g. 'casual', 'formal', 'compact', 'countdown').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    regionstringRegional context (e.g., 'AU-NSW', 'US-CA') passed to LLM grounding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonestringTarget IANA timezone for output formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localestring | string[]Target BCP 47 locale or language tag (e.g. 'fr-FR', 'en-US').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanIf true, bypasses the cache to initiate a fresh LLM query.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cachebooleanIf false, disables writing to and reading from cache adapters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheAdapterAiCacheAdapterCustom cache engine (e.g., Redis, Cloudflare KV) for caching results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttlnumberTime-to-live override in milliseconds for cached results (defaults to 24h).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumberMinimum confidence score threshold (0.0 to 1.0) required. Throws TempoAiError(422) if lower.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeConcurrency routing strategy (fallback, race, consensus, hedged, roundrobin, adaptive). Refer to the Multi-Provider Execution Modes Guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    softErrorsbooleanIf true, returns TempoAiError into array indices instead of rejecting batch queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Schema (TempoAiFormatResult) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoAiFormatResult {
+  /** Formatted narrative string. */
+  formatted: string;
+  
+  /** Confidence score between 0.0 and 1.0. */
+  confidence: number;
+  
+  /** ID of the provider that fulfilled the request (or 'cache'). */
+  provider: string;
+  
+  /** Optional step-by-step rationale from the LLM. */
+  reasoning?: string | undefined;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Architectural Behaviors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Native Grounding Context ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To eliminate LLM date and day-of-week hallucinations, formatAI computes deterministic grounding metrics before constructing the prompt:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Exact ISO timestamp and timezone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Day of the week name and ordinal (e.g. Friday, Day 5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relative delta in calendar days and elapsed hours compared to anchor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Directionality ('past', 'present', 'future')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These metrics are injected into the system prompt as immutable constraints.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. TC39 Temporal & Universal Interoperability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    formatAI seamlessly accepts Tempo instances, native JavaScript Date objects, ISO strings, timestamps, and TC39 Temporal objects (Temporal.ZonedDateTime, Temporal.Instant, Temporal.PlainDateTime, Temporal.PlainDate):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Temporal } from '@magmacomputing/tempo/library';
+
+const zdt = Temporal.ZonedDateTime.from('2026-08-05T15:00:00+10:00[Australia/Sydney]');
+const result = await formatAI(zdt, 'compact relative format');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Multi-Tier Distributed Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    formatAI integrates multi-tier caching (in-memory + optional asynchronous AiCacheAdapter such as Redis or Cloudflare KV). Cache keys incorporate input timestamp, anchor timestamp, normalized prompt, timezone, locale, region, and style to ensure complete cache correctness:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const result = await formatAI(target, 'casual invitation', {
+  cacheAdapter: redisCacheAdapter,
+  ttl: 3_600_000, // 1 hour
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Parallel Batch Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format multiple dates and prompts concurrently with optional softErrors resilience:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const results = await formatAI([
+  { date: '2026-08-03T09:00:00Z', prompt: 'calendar invite' },
+  { date: '2026-08-05T18:00:00Z', prompt: 'flight departure notification' },
+], { softErrors: true });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,29)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.lean.js new file mode 100644 index 00000000..580715cc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.format.md.Coh7SWV_.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"formatAI — Contextual & Narrative Date Formatting","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.format.md","filePath":"doc/9-plugins/ai.format.md"}'),n={name:"doc/9-plugins/ai.format.md"};function l(r,s,h,p,o,d){return a(),t("div",null,[...s[0]||(s[0]=[e("",29)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.js new file mode 100644 index 00000000..4f29a990 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.js @@ -0,0 +1,21 @@ +import{_ as a,o as i,c as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Grounding & Natural Language Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.grounding.md","filePath":"doc/9-plugins/ai.grounding.md"}'),t={name:"doc/9-plugins/ai.grounding.md"};function o(r,e,l,d,c,p){return i(),s("div",null,[...e[0]||(e[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Grounding & Natural Language Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because natural language dates are entirely relative (e.g., "next Tuesday") and culturally ambiguous (e.g., "11/12"), an LLM cannot reliably parse them in a vacuum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo AI plugin solves this by automatically injecting deterministic temporal and regional grounding coordinates before dispatching queries to the LLM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal & Regional Grounding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin automatically resolves the active Tempo.config to establish the exact reference time and regional coordinates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anchor Reference Clock: The exact ISO timestamp at the moment of invocation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Regional Coordinates: TimeZone (e.g., America/New_York), Calendar system (iso8601), Locale (en-US), and Hemisphere (northern).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Along with your text query, the plugin passes these grounding coordinates directly to the model's system prompt:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Grounding Anchor: [Anchor], Timezone: [TZ], Calendar: [Cal], Locale: [Loc], Hemisphere: [Sphere]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Grounding Anchors & Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can explicitly override any grounding coordinate on a per-request basis by passing an options object as the second argument, identical to how you pass configuration options to a standard new Tempo() constructor:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Explicitly evaluate this complex relative query from the perspective of September 1st
+const dt = await parseAI("The penultimate Tuesday before Thanksgiving", { 
+  anchor: '2026-09-01T00:00:00Z' 
+});
+
+// Explicitly parse assuming a Japanese locale and timezone
+const tokyoDt = await parseAI("The second Sunday of May", { 
+  locale: 'ja-JP', 
+  timeZone: 'Asia/Tokyo' 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why Cultural & Regional Grounding is Critical ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing the Locale and TimeZone is critical for the LLM to know whether "11/12" represents November 12th (US format) or 11th of December (UK/EU format). The plugin grounds these ambiguous tokens transparently based on your standard Tempo configuration!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calendar Math Hallucinations: LLMs are language predictors, not calculators. While they excel at parsing conversational times (like "tomorrow at 5pm"), smaller models are notoriously prone to hallucinations on complex, cross-year calendar math. For example, asking a lightweight model for "Thanksgiving in 2026" may result in a hallucinated day of the week because the model doesn't natively compute "the fourth Thursday of November 2026." If your application relies on heavy holiday logic or complex multi-year math, you must use a capable frontier model or rely on deterministic plugins instead of AI.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Decoupled Output Bridge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure deterministic, type-safe behavior, the plugin enforces a strict decoupled bridge between AI text generation and JavaScript object hydration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • For Point-in-Time Parsing (parseAI): The LLM is instructed to return a strict local ISO 8601 string without a timezone offset or 'Z' suffix (e.g. "2026-11-26T00:00:00"). The plugin immediately constructs a native new Tempo() instance with caller-defined timezone and calendar context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • For Structured Functions (formatAI, extractAI, diffAI, contextAI): The LLM completes rigid JSON schemas validated against strict boundary rules, instantiating typed result objects (TempoAiFormatResult, TempoAiExtractResult, TempoAiDiffResult, TempoContext).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • For Intervals & Generators (scheduleAI, recurrenceAI): The plugin hydrates interval boundaries into a proxied Interval<Tempo> or exposes an iterable generator yielding sequential Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This eliminates AST-construction ambiguity and provides clean runtime contracts for every operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative Date Ambiguity Tie-Breakers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To eliminate model variance on idioms like "Next Friday" or "Last Tuesday", the plugin enforces static system prompt ambiguity rules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "next [weekday/unit]": Evaluated as the immediate next chronological occurrence after the grounding anchor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "last [weekday/unit]" / "previous [weekday/unit]": Evaluated as the most recent past occurrence prior to the grounding anchor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "this [weekday]": Evaluated as the occurrence within the current calendar week containing the grounding anchor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Confidence Thresholds & Metadata Handling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When minConfidence is supplied in options (e.g. { minConfidence: 0.85 }):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • parseAI: Any LLM response returning a confidence score below the threshold produces a Tempo instance with isValid === false (when using softErrors: true) or throws a TempoAiError(422).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Structured Functions (formatAI, extractAI, diffAI, contextAI, scheduleAI, recurrenceAI): Low-confidence completions immediately throw a TempoAiError(422) (or return a TempoAiError in batch arrays when softErrors: true is enabled).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every resolved Tempo instance returned by parseAI has a non-writable, frozen .ai metadata descriptor containing execution audit data:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI("Christmas 2026", { debug: true });
+console.log(dt.ai);
+// {
+//   provider: 'openai',
+//   cached: false,
+//   confidence: 0.95,
+//   ambiguous: false,
+//   granularity: 'day',
+//   rawIso: '2026-12-25T00:00:00',
+//   rawPrompt: 'Christmas 2026',        // Present when debug is enabled
+//   normalizedPrompt: 'christmas 2026' // Present when debug is enabled
+// }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (For other AI functions like extractAI or diffAI, diagnostic metadata including confidence, reasoning, and provider is attached directly to the returned result object.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,29)])])}const g=a(t,[["render",o]]);export{u as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.lean.js new file mode 100644 index 00000000..c97fb81e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.grounding.md.C_kPBIVa.lean.js @@ -0,0 +1 @@ +import{_ as a,o as i,c as s,a2 as n}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Grounding & Natural Language Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.grounding.md","filePath":"doc/9-plugins/ai.grounding.md"}'),t={name:"doc/9-plugins/ai.grounding.md"};function o(r,e,l,d,c,p){return i(),s("div",null,[...e[0]||(e[0]=[n("",29)])])}const g=a(t,[["render",o]]);export{u as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.js new file mode 100644 index 00000000..7caea7e3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.js @@ -0,0 +1,18 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as l,C as o,o as r,c as d,a2 as a,E as p,j as t,a as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ai","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.index.md","filePath":"doc/9-plugins/ai.index.md"}'),c={name:"doc/9-plugins/ai.index.md"};function h(u,i,g,m,k,y){const n=o("PluginRepl");return r(),d("div",null,[i[0]||(i[0]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ai ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin for LLM-powered natural language date parsing, schedule compilation, and temporal processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This plugin bridges the gap between deterministic date-math and unstructured NLP inputs, utilizing large language models (like Gemini, Groq, or OpenAI) to safely and asynchronously parse, format, and process complex natural language temporal expressions into Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔒 Security Notice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Raw LLM API keys must never be exposed in client-side browser bundles or stored in any client-side storage mechanisms (localStorage, sessionStorage, IndexedDB, OPFS / Origin Private File System, or browser cache). We recommend zero browser storage for API credentials; BYOK (Bring Your Own Key) is only secure on backend servers (Node, edge workers). For public frontend applications, route requests through a secure backend proxy service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation & Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-ai
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),p(n,{plugin:"ai"}),i[1]||(i[1]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Two Usage Patterns: Namespace vs Tree-Shakeable Functions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The AI plugin provides two distinct integration approaches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ApproachImport SyntaxIdeal For
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cohesive Namespaceimport { AiPlugin } from '@magmacomputing/tempo-plugin-ai'Full-featured apps, Node.js backends, REPLs, and IDE auto-complete via Tempo.ai.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tree-Shakeable Functionsimport { parseAI, initAI } from '@magmacomputing/tempo-plugin-ai'Minimal client-side bundles and microservices importing only specific functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern A: Tempo.ai Cohesive Namespace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installing AiPlugin mounts the frozen Tempo.ai static action namespace onto Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { AiPlugin } from '@magmacomputing/tempo-plugin-ai';
+
+Tempo.use(AiPlugin);
+
+// All AI capabilities are available under Tempo.ai.*
+await Tempo.ai.init({ provider: 'tempo' });
+const event = await Tempo.ai.parse("next Tuesday around 2:30pm");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ai/install';
+
+const event = await Tempo.ai.parse("next Tuesday around 2:30pm");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern B: Tree-Shakeable Standalone Functions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For bundle-sensitive projects, import individual functions directly without attaching anything to Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize trial sandbox or explicit providers
+await initAI({ provider: 'tempo' });
+
+// 2. Call standalone function directly
+const dt = await parseAI("The penultimate Tuesday before Thanksgiving in 2026");
+console.log(dt.format('{yyyy}-{mm}-{dd}')); // 2026-11-17

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AI Function Catalog ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All AI functions return a standard ES Promise and are accessible either as standalone tree-shakeable functions or via the cohesive Tempo.ai.* namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,16)),i[2]||(i[2]=t("table",{tabindex:"0"},[t("thead",null,[t("tr",null,[t("th",{style:{"text-align":"left"}},[e("Standalone Function / "),t("code",null,"Tempo.ai"),e(" Method")]),t("th",{style:{"text-align":"left"}},"Input"),t("th",{style:{"text-align":"left"}},[e("Returns ("),t("code",null,"Promise<...>"),e(")")]),t("th",{style:{"text-align":"left"}},"Description"),t("th",{style:{"text-align":"center"}},"Doc")])]),t("tbody",null,[t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"parseAI")]),t("br"),t("code",null,"Tempo.ai.parse")]),t("td",{style:{"text-align":"left"}},"Natural language text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"Tempo"),e(" | "),t("code",null,"Tempo[]"),e(" | "),t("code",null,"(Tempo | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[e("Single point-in-time "),t("code",null,"Tempo"),e(" instance (or batch array)")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.parse.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"formatAI")]),t("br"),t("code",null,"Tempo.ai.format")]),t("td",{style:{"text-align":"left"}},"Date-time + prompt / style"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiFormatResult"),e(" | "),t("code",null,"TempoAiFormatResult[]"),e(" | "),t("code",null,"(TempoAiFormatResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Contextual narrative date formatting"),e(" ("),t("code",null,"formatted"),e(", "),t("code",null,"confidence"),e(", "),t("code",null,"provider"),e(", "),t("code",null,"reasoning"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.format.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"extractAI")]),t("br"),t("code",null,"Tempo.ai.extract")]),t("td",{style:{"text-align":"left"}},"Unstructured text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiExtractResult"),e(" | "),t("code",null,"TempoAiExtractResult[]"),e(" | "),t("code",null,"(TempoAiExtractResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Extracted temporal entities & calendar events"),e(" ("),t("code",null,"events: TempoExtractedEvent[]"),e(", "),t("code",null,"confidence"),e(", "),t("code",null,"reasoning"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.extract.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"recurrenceAI")]),t("br"),t("code",null,"Tempo.ai.recurrence")]),t("td",{style:{"text-align":"left"}},"Natural language pattern or RRULE string"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoRecurrenceResult")]),t("td",{style:{"text-align":"left"}},[t("strong",null,[e("Iterable series of "),t("code",null,"Tempo"),e(" dates")]),e(" (with "),t("code",null,".take(n)"),e(", "),t("code",null,"[Symbol.iterator]"),e(", & RRULE string)")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.recurrence.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"scheduleAI")]),t("br"),t("code",null,"Tempo.ai.schedule")]),t("td",{style:{"text-align":"left"}},"Booking prompt + busy constraints"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoScheduleResult")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Resolved appointment slot"),e(" ("),t("code",null,"start"),e(", "),t("code",null,"end"),e(", "),t("code",null,"slot"),e(", "),t("code",null,"alternatives"),e(", "),t("code",null,"ai.conflictBumped"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.schedule.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"diffAI")]),t("br"),t("code",null,"Tempo.ai.diff")]),t("td",{style:{"text-align":"left"}},"Start & End dates + prompt"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiDiffResult"),e(" | "),t("code",null,"TempoAiDiffResult[]"),e(" | "),t("code",null,"(TempoAiDiffResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Narrative time delta & business days"),e(" ("),t("code",null,"formatted"),e(", "),t("code",null,"businessDays"),e(", "),t("code",null,"days"),e(", "),t("code",null,"hours"),e(", "),t("code",null,"holidays"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.diff.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"contextAI")]),t("br"),t("code",null,"Tempo.ai.context")]),t("td",{style:{"text-align":"left"}},"Context text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoContext"),e(" | "),t("code",null,"TempoContext[]"),e(" | "),t("code",null,"(TempoContext | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Inferred regional context"),e(" ("),t("code",null,"timeZone"),e(", "),t("code",null,"locale"),e(", "),t("code",null,"calendar"),e(", "),t("code",null,"sphere"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.context.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"initAI")]),t("br"),t("code",null,"Tempo.ai.init")]),t("td",{style:{"text-align":"left"}},"Provider config & API keys"),t("td",{style:{"text-align":"left"}},[t("code",null,"void")]),t("td",{style:{"text-align":"left"}},"Configured AI provider farm"),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.init.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])])])],-1)),i[3]||(i[3]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary of Distinct Return Contracts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To streamline error handling and data consumption, return shapes across the AI plugin follow three distinct contracts:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CategoryFunctionsReturn TypeSingle Query Low-Confidence / FailureBatch Array softErrors: true Contract
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Point-in-Time DateparseAITempo (with .ai)Throws TempoAiError (or returns invalid Tempo if minConfidence threshold unmet)Returns invalid Tempo (isValid === false) in array position
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Structured AI ObjectsformatAI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extractAI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    diffAI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextAI                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		TempoAiFormatResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoAiExtractResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoAiDiffResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoContext                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		Throws TempoAiError (422 for low confidence, 429 for quota, 500 for network)Returns typed TempoAiError object directly in array position
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Intervals & GeneratorsscheduleAI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    recurrenceAI                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		TempoScheduleResult (Proxied Interval<Tempo>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoRecurrenceResult (.take(n))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		Throws TempoAiError (Single item query only)N/A (Single query operations)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture & Infrastructure Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORTANT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Recommendation: Due to the complexities of LLM APIs, including caching gotchas, context injection, rate limits, and calendar math hallucinations, we strongly recommend reading the dedicated guides below before deploying this plugin in a production environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Community Feedback & Production Notice ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Community Feedback & Prompt Engineering While @magmacomputing/tempo-plugin-ai utilizes deterministic grounding, schema enforcement, and confidence validation, LLM outputs can vary across models and prompt styles. We actively welcome community feedback and prompt optimizations—please report any edge cases or suggestions on the Magma GitHub Issue Tracker.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Notice & "As-Is" Disclaimer: Magma Computing Solutions and the Tempo core maintainers provide @magmacomputing/tempo-plugin-ai "as-is" without warranty of any kind. Large Language Models operate probabilistically; developers and system architects are responsible for validating AI-generated temporal outputs before committing them to financial, legal, medical, or life-critical applications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',10))])}const x=l(c,[["render",h]]);export{E as __pageData,x as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.lean.js new file mode 100644 index 00000000..542371a1 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.index.md.rTtq43n1.lean.js @@ -0,0 +1 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as l,C as o,o as r,c as d,a2 as a,E as p,j as t,a as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ai","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.index.md","filePath":"doc/9-plugins/ai.index.md"}'),c={name:"doc/9-plugins/ai.index.md"};function h(u,i,g,m,k,y){const n=o("PluginRepl");return r(),d("div",null,[i[0]||(i[0]=a("",8)),p(n,{plugin:"ai"}),i[1]||(i[1]=a("",16)),i[2]||(i[2]=t("table",{tabindex:"0"},[t("thead",null,[t("tr",null,[t("th",{style:{"text-align":"left"}},[e("Standalone Function / "),t("code",null,"Tempo.ai"),e(" Method")]),t("th",{style:{"text-align":"left"}},"Input"),t("th",{style:{"text-align":"left"}},[e("Returns ("),t("code",null,"Promise<...>"),e(")")]),t("th",{style:{"text-align":"left"}},"Description"),t("th",{style:{"text-align":"center"}},"Doc")])]),t("tbody",null,[t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"parseAI")]),t("br"),t("code",null,"Tempo.ai.parse")]),t("td",{style:{"text-align":"left"}},"Natural language text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"Tempo"),e(" | "),t("code",null,"Tempo[]"),e(" | "),t("code",null,"(Tempo | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[e("Single point-in-time "),t("code",null,"Tempo"),e(" instance (or batch array)")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.parse.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"formatAI")]),t("br"),t("code",null,"Tempo.ai.format")]),t("td",{style:{"text-align":"left"}},"Date-time + prompt / style"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiFormatResult"),e(" | "),t("code",null,"TempoAiFormatResult[]"),e(" | "),t("code",null,"(TempoAiFormatResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Contextual narrative date formatting"),e(" ("),t("code",null,"formatted"),e(", "),t("code",null,"confidence"),e(", "),t("code",null,"provider"),e(", "),t("code",null,"reasoning"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.format.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"extractAI")]),t("br"),t("code",null,"Tempo.ai.extract")]),t("td",{style:{"text-align":"left"}},"Unstructured text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiExtractResult"),e(" | "),t("code",null,"TempoAiExtractResult[]"),e(" | "),t("code",null,"(TempoAiExtractResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Extracted temporal entities & calendar events"),e(" ("),t("code",null,"events: TempoExtractedEvent[]"),e(", "),t("code",null,"confidence"),e(", "),t("code",null,"reasoning"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.extract.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"recurrenceAI")]),t("br"),t("code",null,"Tempo.ai.recurrence")]),t("td",{style:{"text-align":"left"}},"Natural language pattern or RRULE string"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoRecurrenceResult")]),t("td",{style:{"text-align":"left"}},[t("strong",null,[e("Iterable series of "),t("code",null,"Tempo"),e(" dates")]),e(" (with "),t("code",null,".take(n)"),e(", "),t("code",null,"[Symbol.iterator]"),e(", & RRULE string)")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.recurrence.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"scheduleAI")]),t("br"),t("code",null,"Tempo.ai.schedule")]),t("td",{style:{"text-align":"left"}},"Booking prompt + busy constraints"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoScheduleResult")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Resolved appointment slot"),e(" ("),t("code",null,"start"),e(", "),t("code",null,"end"),e(", "),t("code",null,"slot"),e(", "),t("code",null,"alternatives"),e(", "),t("code",null,"ai.conflictBumped"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.schedule.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"diffAI")]),t("br"),t("code",null,"Tempo.ai.diff")]),t("td",{style:{"text-align":"left"}},"Start & End dates + prompt"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoAiDiffResult"),e(" | "),t("code",null,"TempoAiDiffResult[]"),e(" | "),t("code",null,"(TempoAiDiffResult | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Narrative time delta & business days"),e(" ("),t("code",null,"formatted"),e(", "),t("code",null,"businessDays"),e(", "),t("code",null,"days"),e(", "),t("code",null,"hours"),e(", "),t("code",null,"holidays"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.diff.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"contextAI")]),t("br"),t("code",null,"Tempo.ai.context")]),t("td",{style:{"text-align":"left"}},"Context text string(s)"),t("td",{style:{"text-align":"left"}},[t("code",null,"TempoContext"),e(" | "),t("code",null,"TempoContext[]"),e(" | "),t("code",null,"(TempoContext | TempoAiError)[]")]),t("td",{style:{"text-align":"left"}},[t("strong",null,"Inferred regional context"),e(" ("),t("code",null,"timeZone"),e(", "),t("code",null,"locale"),e(", "),t("code",null,"calendar"),e(", "),t("code",null,"sphere"),e(")")]),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.context.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])]),t("tr",null,[t("td",{style:{"text-align":"left"}},[t("strong",null,[t("code",null,"initAI")]),t("br"),t("code",null,"Tempo.ai.init")]),t("td",{style:{"text-align":"left"}},"Provider config & API keys"),t("td",{style:{"text-align":"left"}},[t("code",null,"void")]),t("td",{style:{"text-align":"left"}},"Configured AI provider farm"),t("td",{style:{"text-align":"center"}},[t("a",{href:"./ai.init.html",class:"btn btn-secondary icon-btn",title:"View Documentation"},[t("svg",{width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round",title:"View Documentation"},[t("path",{d:"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"}),t("path",{d:"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"})])])])])])],-1)),i[3]||(i[3]=a("",10))])}const x=l(c,[["render",h]]);export{E as __pageData,x as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.js new file mode 100644 index 00000000..90dc2968 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.js @@ -0,0 +1,136 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"initAI — Provider Initialization & Farm Configuration","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.init.md","filePath":"doc/9-plugins/ai.init.md"}'),n={name:"doc/9-plugins/ai.init.md"};function l(p,s,h,d,k,r){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initAI — Provider Initialization & Farm Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initAI() sets up the global configuration for @magmacomputing/tempo-plugin-ai, managing provider authentication, multi-provider execution modes, global SLAs/timeouts, and caching strategies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Config Auto-Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ai features a zero-boilerplate auto-discovery architecture. In server environments (Node.js, Deno, Bun), calling initAI() is completely optional when standard environment variables (GROQ_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, MISTRAL_API_KEY) or a tempo.config.json file are present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// When GROQ_API_KEY is present in the environment:
+// Zero setup required — providers and SLAs are auto-discovered lazily on first call!
+const dt = await parseAI("The third Thursday in November after Thanksgiving");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Resolution Order ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration is automatically discovered and resolved in the following priority:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Call-site explicit overrides (options.providers, options.mode).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit initAI(config) parameters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Active Tempo.config.plugins.ai (in-memory or loaded via Tempo.bootstrap()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Filesystem tempo.config.* files (JSON, JSONC, JS, TS).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Runtime Environment Variables (GROQ_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, MISTRAL_API_KEY).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.config.json Example ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can declare AI provider configurations directly within your project's tempo.config.json using template variable interpolation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  "timeZone": "Australia/Sydney",
+  "locale": "en-AU",
+  "plugins": {
+    "ai": {
+      "mode": "fallback",
+      "timeout": 5000,
+      "minConfidence": 0.85,
+      "providers": [
+        { "id": "groq", "key": "\${GROQ_API_KEY}" },
+        { "id": "openai", "key": "$env:OPENAI_API_KEY", "model": "gpt-4o-mini" }
+      ]
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage (Explicit Configuration) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Single Provider Shorthand ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For single-provider workflows, use the concise provider and apiKey properties:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Free evaluation trial sandbox (zero external keys needed):
+await initAI({ provider: 'tempo' });
+
+// 2. Direct provider with API key:
+await initAI({ provider: 'groq', apiKey: process.env.GROQ_API_KEY });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Provider Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Initialize with custom provider credentials and execution options
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY },
+    { id: 'openai', key: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
+  ],
+  timeout: 5000, // 5-second global SLA default
+  debug: true    // Enable operational trace logging (automatically PII-sanitized in production)
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Backend Proxy (endpoint) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For browser applications and client-side frontends where API keys must remain hidden, you can supply a single global endpoint:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Connect client-side Tempo AI to your backend proxy
+await initAI({
+  endpoint: 'https://api.yourdomain.com/api/aiProxy'
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All AI calls will route requests through your backend endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Gateway Endpoints ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When configuring custom gateways, proxy routes, or private LLM instances, specify the endpoint:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    await initAI({
+  providers: [
+    {
+      id: 'custom-gateway',
+      endpoint: 'https://ai.internal.corp/v1/chat/completions',
+      key: process.env.INTERNAL_AI_KEY,
+      model: 'llama-3.3-70b-versatile'
+    }
+  ]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tip: initAI returns a Promise<void> and is fully re-callable! Calling it synchronously without await instantly initializes local configurations so you can call parseAI immediately, while await initAI() guarantees that remote provider manifest defaults are fetched and applied before proceeding (with explicit provider configuration values always taking precedence over remote manifest defaults).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Provider Credentials & Context Suppliers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The provider key configuration supports asynchronous or synchronous supplier functions (AsyncEvaluable<string>), allowing automated secret vault retrieval and dynamic token refreshing. Provider attributes (url, model) as well as global context settings (timeZone, locale, calendar, sphere) accept synchronous supplier functions (Evaluable<T>).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This enables automated secret vault rotation, dynamic AI gateways, and multi-tenant context resolution evaluated just-in-time on every HTTP dispatch:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Initialize with dynamic async key resolver and per-request context
+initAI({
+  providers: [
+    {
+      id: 'openai',
+      // Resolved dynamically per-request: enables secret vault rotation without restarting
+      key: async () => await secretVault.getApiKey('openai'),
+      // Dynamic proxy endpoint
+      url: () => getActiveGatewayUrl()
+    }
+  ],
+  // Dynamic timezone / locale resolution
+  timeZone: () => currentRequestContext.timeZone,
+  locale: () => currentRequestContext.locale
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Execution Modes & Multi-Provider Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The AI plugin supports six multi-provider execution strategies (fallback, race, consensus, adaptive, hedged, roundrobin):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fallback (default): Queries providers sequentially in array order until one succeeds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • race: Sends concurrent requests to all providers, returning the fastest valid response.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • consensus: Queries providers concurrently and boosts confidence when outputs agree.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hedged: Initiates staggered latency hedging, querying subsequent providers if the primary is slow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • roundrobin: Cyclic load balancing across the provider pool.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • adaptive: Proactive telemetry-aware rate-limit avoidance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For a comprehensive guide, decision flowcharts, and configuration details for all execution modes, refer to the Multi-Provider Execution Modes Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Fallback mode (default): query providers sequentially in array order until one succeeds
+initAI({
+  mode: 'fallback',
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY },    // Primary provider
+    { id: 'openai', key: process.env.OPENAI_API_KEY } // Fallback provider
+  ]
+});
+
+// 2. Race mode: send concurrent requests to all providers, returning the fastest valid response
+const fastest = await parseAI("Third Friday of October", { mode: 'race' });
+
+// 3. Consensus mode: query providers concurrently and boost confidence when outputs agree
+const agreed = await parseAI("The penultimate Tuesday before Thanksgiving", { 
+  mode: 'consensus',
+  minConfidence: 0.85
+});
+
+// 4. Hedged mode: speculative concurrency with staggered delay (e.g. 800ms)
+const hedged = await parseAI("First Monday of December", {
+  mode: 'hedged',
+  hedgeDelay: 800
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timeout Controls & SLAs ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prevent hanging requests using the 3-tier timeout hierarchy (call-site > provider > global > default 15s):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY, options: { timeout: 2000 } } // 2s timeout for fast provider
+  ],
+  timeout: 5000 // 5s global default timeout
+});
+
+// Hard 3-second SLA override for a specific call-site
+const dt = await parseAI("Next Tuesday at 4pm", { timeout: 3000 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Operational Trace Logging & Debugging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Operational Trace Logging Passing debug: true into initAI (or setting { debug: true } on a per-request options object) outputs concise operational trace logs (prefixed with [tempo-plugin-ai]) to the developer console for monitoring provider fallback decisions and execution timing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Detailed diagnostic context—including provider resolution, execution lineage, confidence scores, and when debug: true is active, rawPrompt, normalizedPrompt, and rate-limit snapshots—is attached directly to the returned Tempo instance via the .ai property for parseAI. Structured functions (formatAI, diffAI, extractAI, contextAI, scheduleAI) surface their respective typed properties directly on the result object (such as res.confidence, res.provider, and optional res.reasoning).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Debug & Proxy Introspection: In production environments (NODE_ENV === 'production'), terminal logging via console.log(date.ai) or console.log(result) automatically sanitizes and masks PII (emails, phones, bearer tokens) while preserving 100% in-memory data integrity for application code. Refer to the Security & Privacy Architecture Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providerstring | AiProvider'tempo'Single provider shorthand (e.g. 'tempo', 'groq').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apiKeystring | (() => string | Promise<string>)undefinedSingle provider API key shorthand (used with provider).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providersAiProvider[][]Array of configured AI providers for multi-provider orchestration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endpointstring | (() => string)undefinedGlobal fallback base URL or backend proxy endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiMode | string'fallback'Multi-provider execution strategy ('fallback', 'race', 'consensus', 'hedged', 'roundrobin', 'adaptive').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hedgeDelaynumber800Speculative hedge delay in milliseconds (for hedged mode).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeoutnumber15000Global SLA timeout in milliseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanfalseIf true, forces fresh LLM fetches globally and bypasses deterministic pre-parsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debugbooleanfalseGlobal debug flag for operational trace logging and diagnostic metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheMap | booleantrueIn-memory cache map or boolean toggle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheAdapterAiCacheAdapterundefinedCustom cache adapter for distributed storage (e.g. Redis, KV).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttlnumberundefinedGlobal default time-to-live in milliseconds for cache adapters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumber0.0Minimum confidence threshold for AI parsing results (0.0 to 1.0).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonestring | (() => string)Host / ConfigDynamic or static default timezone context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localestring | string[] | (() => string | string[])Host / ConfigDynamic or static default locale context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendarstring | (() => string)'iso8601'Dynamic or static default calendar context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    spherestring | (() => string)'earth'Dynamic or static default celestial sphere context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    remoteConfigUrlstring | falseproviders.v1.jsonURL for dynamic remote provider manifest updates, or false to disable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    telemetrybooleantrueFlag to enable/disable anonymous usage telemetry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TypeScript Interface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface AiConfig {
+  /** Optional single provider shorthand (e.g. 'tempo', 'groq', or an AiProvider object) */
+  provider?: string | AiProvider;
+  /** Optional single provider API key shorthand (used in combination with \`provider\`) */
+  apiKey?: AsyncEvaluable<string>;
+  /** List of configured AI providers */
+  providers?: AiProvider[];
+  /** Global fallback base URL / proxy endpoint for providers (e.g. 'https://api.yourdomain.com/ai') */
+  endpoint?: Evaluable<string>;
+  /** Default execution mode across providers ('fallback' | 'race' | 'consensus' | 'hedged' | 'roundrobin' | 'adaptive') */
+  mode?: 'fallback' | 'race' | 'consensus' | 'hedged' | 'roundrobin' | 'adaptive';
+  /** Speculative hedge delay in milliseconds (hedged mode only, default: 800ms) */
+  hedgeDelay?: number;
+  /** Global SLA timeout in milliseconds (default: 15000ms) */
+  timeout?: number;
+  /** If true, forces fresh LLM fetches globally and bypasses deterministic pre-parsing */
+  force?: boolean;
+  /** Global debug flag for operational trace logging and diagnostic metadata attachment */
+  debug?: boolean;
+  /** Synchronous Map or BoundedCache for static glossary terms */
+  cache?: Map<string, string> | boolean;
+  /** Custom cache adapter for distributed storage (e.g. Redis, KV) */
+  cacheAdapter?: AiCacheAdapter;
+  /** Global default time-to-live in milliseconds for cache adapters */
+  ttl?: number;
+  /** Minimum confidence threshold for AI parsing results (0.0 to 1.0) */
+  minConfidence?: number;
+  /** Dynamic or static default timezone context (string | (() => string)) */
+  timeZone?: Evaluable<string>;
+  /** Dynamic or static default locale context (string | string[] | (() => string | string[])) */
+  locale?: Evaluable<string | string[]>;
+  /** Dynamic or static default calendar context (string | (() => string)) */
+  calendar?: Evaluable<string>;
+  /** Dynamic or static default celestial sphere context (string | (() => string)) */
+  sphere?: Evaluable<string>;
+  /** Optional hook to intercept and resolve dynamic provider defaults */
+  fetchDefaults?: (providerId: string) => Promise<Partial<AiProvider> | null> | Partial<AiProvider> | null;
+  /** URL for dynamic remote provider manifest updates, or \`false\` to disable */
+  remoteConfigUrl?: string | false;
+  /** Optional flag to disable/enable anonymous usage telemetry (default: true). Set to false to opt-out. */
+  telemetry?: boolean;
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,47)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.lean.js new file mode 100644 index 00000000..55eb78f2 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.init.md.hCf30wXQ.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"initAI — Provider Initialization & Farm Configuration","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.init.md","filePath":"doc/9-plugins/ai.init.md"}'),n={name:"doc/9-plugins/ai.init.md"};function l(p,s,h,d,k,r){return a(),t("div",null,[...s[0]||(s[0]=[e("",47)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.js new file mode 100644 index 00000000..30e74304 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.js @@ -0,0 +1,44 @@ +import{_ as d,C as p,o as i,c as h,a2 as a,b as n,w as s,a as l,E as o,a5 as r}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"Multi-Provider Execution Modes (AiMode)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.modes.md","filePath":"doc/9-plugins/ai.modes.md"}'),c={name:"doc/9-plugins/ai.modes.md"};function k(g,e,E,u,y,m){const t=p("Mermaid");return i(),h("div",null,[e[2]||(e[2]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Provider Execution Modes (AiMode) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ai provides a robust, multi-provider dispatch orchestrator that handles latency hedging, quota load-balancing, consensus verification, and fault-tolerant failovers across diverse LLM providers (e.g. OpenAI, Anthropic, Groq, Mistral, Google Gemini, Ollama, local vLLM).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Execution modes can be configured globally during plugin initialization or overridden per request:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI, AiMode } from '@magmacomputing/tempo-plugin-ai';
+
+// Global configuration
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY },
+    { id: 'openai', key: process.env.OPENAI_API_KEY }
+  ],
+  mode: AiMode.Hedged
+});
+
+// Per-request override
+const dt = await parseAI('next friday at 3pm', {
+  mode: AiMode.Adaptive
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strategy Comparison ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModeDispatchToken CostLatencyRate-Limit Resilience
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fallback (Default)Sequential🟢 1 request🟡 Moderate🟢 Proactive Cooldown Filter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HedgedStaggered (primary + timer)🟢 ~1.15 avg🟢 Ultra-Fast🟢 Proactive Cooldown Filter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RoundRobinCyclic rotation🟢 1 request🟡 Moderate🟢 High (Cyclic + Filter)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AdaptiveQuota-sorted rotation🟢 1 request🟡 Moderate🟢 Maximum (Telemetry-Ranked)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RaceFull parallel🔴 N requests🟢 Ultra-Fast🟢 Proactive Cooldown Filter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConsensusFull parallel + voting🔴 N requests🟡 Moderate🟢 Proactive Cooldown Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Telemetry & Cooldown Filtering ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regardless of the execution mode chosen, the AI dispatch engine actively monitors per-provider rate-limiting metadata across all network responses (x-ratelimit-remaining-requests, x-ratelimit-remaining-tokens, x-ratelimit-reset-requests, retry-after).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,12)),(i(),n(r,null,{default:s(()=>[o(t,{id:"mermaid-148",class:"mermaid",graph:"flowchart%20LR%0A%20%20%20%20A%5B%22Incoming%20Request%5Cn(Any%20AiMode)%22%5D%20--%3E%20B%7B%22Check%20Provider%20Farm%5CnCooldown%20State%22%7D%0A%20%20%20%20B%20--%20%22Exhausted%20(remaining%20%3D%3D%3D%200%5Cn%26%20resetAt%20%3E%20now)%22%20--%3E%20C%5B%22%F0%9F%9A%AB%20Proactively%20Filter%20Out%5Cn(Skip%20429%20endpoints)%22%5D%0A%20%20%20%20B%20--%20%22Ready%20%2F%20High%20Quota%22%20--%3E%20D%5B%22%E2%9C%85%20Active%20Provider%20Pool%22%5D%0A%20%20%20%20C%20-.%20%22If%20ALL%20in%20cooldown%22%20.-%3E%20D%0A%20%20%20%20D%20--%3E%20E%5B%22Dispatch%20via%20Selected%20Mode%5Cn(Fallback%2C%20Race%2C%20Hedged%2C%20etc.)%22%5D%0A"})]),fallback:s(()=>[...e[0]||(e[0]=[l(" Loading... ",-1)])]),_:1})),e[3]||(e[3]=a('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Proactive Cooldown Avoidance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before dispatching any request:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cooldown Detection: The orchestrator checks if any configured provider has exhausted its request or token quota (remainingRequests === 0 or remainingTokens === 0) and is within an active reset window (resetAt > now, derived from response reset timestamps or retry-after metadata).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Pre-Dispatch Filtering: In Fallback, Race, Hedged, and RoundRobin modes, exhausted providers are automatically removed from the active candidate pool for that request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Fallback & Hedged: Avoids stalling on primary providers that are guaranteed to reject with HTTP 429.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Race: Saves network bandwidth and avoids firing wasted requests to rate-limited models.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • RoundRobin: Skips over cooling-down keys without breaking the cyclic load-balancing progression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Fail-Open Resilience: If all providers in the farm are currently in a cooldown window, the orchestrator keeps all providers available rather than failing prematurely, allowing the request to cascade or surface accurate rate-limit errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dispatch Decision Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',5)),(i(),n(r,null,{default:s(()=>[o(t,{id:"mermaid-193",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20Start(%5B%22Where%20does%20this%20run%3F%22%5D)%20--%3E%20UI%5B%22User-facing%5Cn(search%20bar%2C%20chatbot%2C%20form)%22%5D%0A%20%20%20%20Start%20--%3E%20Batch%5B%22Background%20%2F%20batch%5Cn(ingestion%2C%20ETL%2C%20reports)%22%5D%0A%20%20%20%20Start%20--%3E%20Audit%5B%22High-stakes%20audit%5Cn(legal%2C%20financial%2C%20scheduling)%22%5D%0A%0A%20%20%20%20UI%20--%3E%20MultiUI%7B%22Multiple%20providers%5Cnor%20API%20keys%3F%22%7D%0A%20%20%20%20MultiUI%20--%20No%20--%3E%20Fallback%5B%22%E2%AC%87%EF%B8%8F%20AiMode.Fallback%5CnDefault%20%E2%80%A2%20Most%20cost-efficient%22%5D%0A%20%20%20%20MultiUI%20--%20Yes%20--%3E%20CostSpeed%7B%22Latency%20sensitive%5Cnor%20cost%20concern%3F%22%7D%0A%20%20%20%20CostSpeed%20--%20%22Fastest%20response%20(high%20cost)%22%20--%3E%20Race%5B%22%F0%9F%8F%81%20AiMode.Race%5CnAbsolute%20fastest%20response%22%5D%0A%20%20%20%20CostSpeed%20--%20%22Staggered%20concurrency%20(lower%20cost)%22%20--%3E%20Hedged%5B%22%E2%8F%B3%20AiMode.Hedged%5CnStaggered%20latency%20hedging%22%5D%0A%0A%20%20%20%20Batch%20--%3E%20Quota%7B%22Quota%20pressure%5Cnor%20multiple%20keys%3F%22%7D%0A%20%20%20%20Quota%20--%20%22Spread%20evenly%22%20--%3E%20RR%5B%22%F0%9F%94%84%20AiMode.RoundRobin%5CnCyclic%20key%20rotation%22%5D%0A%20%20%20%20Quota%20--%20%22Avoid%20429%20proactively%22%20--%3E%20Adaptive%5B%22%F0%9F%93%A1%20AiMode.Adaptive%5CnTelemetry-driven%20ordering%22%5D%0A%20%20%20%20Quota%20--%20%22Single%20key%2C%20simple%22%20--%3E%20Fallback%5B%22%E2%AC%87%EF%B8%8F%20AiMode.Fallback%5CnDefault%20%E2%80%A2%20Most%20cost-efficient%22%5D%0A%0A%20%20%20%20Audit%20--%3E%20Consensus%5B%22%F0%9F%97%B3%EF%B8%8F%20AiMode.Consensus%5CnCross-LLM%20voting%20%E2%80%A2%20Highest%20accuracy%22%5D%0A"})]),fallback:s(()=>[...e[1]||(e[1]=[l(" Loading... ",-1)])]),_:1})),e[4]||(e[4]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode Deep-Dives & Code Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. AiMode.Fallback — Sequential Cascade (Default) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dispatches requests to providers sequentially in configured order until a provider succeeds and satisfies minConfidence. The most cost-efficient mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Standard production baseline — general date parsing and background tasks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI('first monday in october 2026', {
+  mode: AiMode.Fallback,
+  minConfidence: 0.85 // Automatically cascades to next provider if score is too low
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. AiMode.Hedged — Speculative Latency Hedging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sends a request to the primary provider immediately. If no valid response arrives within hedgeDelay (default: 800ms), launches a speculative concurrent request to the secondary provider. The first valid response wins; all in-flight requests are aborted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Latency-sensitive user-facing APIs — search bars, chatbots, web forms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI('schedule team sync for next wednesday at 2pm', {
+  mode: AiMode.Hedged,
+  hedgeDelay: 600 // Launch hedge after 600ms if primary is still pending
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hedgeDelay can also be set globally in initAI({ hedgeDelay: 600 }) so it applies to all functions (parseAI, recurrenceAI, scheduleAI, extractAI).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. AiMode.RoundRobin — Multi-Key Cyclic Load Balancing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cycles through the configured provider pool on each invocation (0 → 1 → 2 → 0 ...). If the selected starting provider fails, automatically falls over to the remaining providers in cyclic order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: High-throughput batch processing — ingesting large volumes of dates across multiple API keys to avoid single-account RPM throttling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    await initAI({
+  providers: [
+    { id: 'groq-key-1', key: process.env.GROQ_KEY_1 },
+    { id: 'groq-key-2', key: process.env.GROQ_KEY_2 },
+    { id: 'groq-key-3', key: process.env.GROQ_KEY_3 }
+  ],
+  mode: AiMode.RoundRobin
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. AiMode.Adaptive — Rate-Limit Telemetry Prioritization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reads x-ratelimit-* HTTP headers after every provider response and stores per-provider quota snapshots. On subsequent requests, providers are ranked dynamically by highest remaining quota descending, guaranteeing that providers with ample headroom are prioritized ahead of constrained models.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Multi-tier production gateways — mixed free/paid provider pools where proactively avoiding 429 Too Many Requests is essential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI('quarterly review deadline next quarter', {
+  mode: AiMode.Adaptive
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Telemetry accumulates across calls. The first request in a session uses original provider order; sorting kicks in from the second call onward once header data is available.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. AiMode.Race — Speculative Parallel Execution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dispatches requests concurrently across all configured providers. The fastest successful response is returned, and all remaining requests are immediately cancelled via AbortSignal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Real-time interactive typeahead — live search inputs or autocomplete where the fastest possible response is required regardless of token cost.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI('tomorrow at noon', {
+  mode: AiMode.Race
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. AiMode.Consensus — Multi-LLM Cross-Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dispatches requests concurrently across all providers and compares the normalized outputs (e.g. ISO timestamps for parseAI, RRULE strings for recurrenceAI, formatted strings for diffAI/formatAI, or structured entity counts for extractAI). If all responding providers agree, confidence is elevated to 1.0 (unanimous). If providers disagree, the highest-confidence candidate is returned and flagged with ai.ambiguous = true (attached to Tempo.ai on parseAI or returned on structured result objects).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: High-stakes legal, financial, and scheduling — contract dates, event conflict resolution, or auditing where hallucination prevention requires unanimous LLM agreement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Point-in-time cross validation
+const dt = await parseAI('contract renewal date', {
+  mode: AiMode.Consensus
+});
+
+if (dt.ai?.ambiguous) {
+  console.warn('Providers disagreed — treat this date with caution.');
+}
+
+// 2. High-precision duration calculation across multiple providers
+const diff = await diffAI(startDate, endDate, 'in business days excluding UK bank holidays', {
+  mode: AiMode.Consensus
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,33))])}const A=d(c,[["render",k]]);export{F as __pageData,A as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.lean.js new file mode 100644 index 00000000..a067a362 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.modes.md.JT-kGfff.lean.js @@ -0,0 +1 @@ +import{_ as d,C as p,o as i,c as h,a2 as a,b as n,w as s,a as l,E as o,a5 as r}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"Multi-Provider Execution Modes (AiMode)","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.modes.md","filePath":"doc/9-plugins/ai.modes.md"}'),c={name:"doc/9-plugins/ai.modes.md"};function k(g,e,E,u,y,m){const t=p("Mermaid");return i(),h("div",null,[e[2]||(e[2]=a("",12)),(i(),n(r,null,{default:s(()=>[o(t,{id:"mermaid-148",class:"mermaid",graph:"flowchart%20LR%0A%20%20%20%20A%5B%22Incoming%20Request%5Cn(Any%20AiMode)%22%5D%20--%3E%20B%7B%22Check%20Provider%20Farm%5CnCooldown%20State%22%7D%0A%20%20%20%20B%20--%20%22Exhausted%20(remaining%20%3D%3D%3D%200%5Cn%26%20resetAt%20%3E%20now)%22%20--%3E%20C%5B%22%F0%9F%9A%AB%20Proactively%20Filter%20Out%5Cn(Skip%20429%20endpoints)%22%5D%0A%20%20%20%20B%20--%20%22Ready%20%2F%20High%20Quota%22%20--%3E%20D%5B%22%E2%9C%85%20Active%20Provider%20Pool%22%5D%0A%20%20%20%20C%20-.%20%22If%20ALL%20in%20cooldown%22%20.-%3E%20D%0A%20%20%20%20D%20--%3E%20E%5B%22Dispatch%20via%20Selected%20Mode%5Cn(Fallback%2C%20Race%2C%20Hedged%2C%20etc.)%22%5D%0A"})]),fallback:s(()=>[...e[0]||(e[0]=[l(" Loading... ",-1)])]),_:1})),e[3]||(e[3]=a("",5)),(i(),n(r,null,{default:s(()=>[o(t,{id:"mermaid-193",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20Start(%5B%22Where%20does%20this%20run%3F%22%5D)%20--%3E%20UI%5B%22User-facing%5Cn(search%20bar%2C%20chatbot%2C%20form)%22%5D%0A%20%20%20%20Start%20--%3E%20Batch%5B%22Background%20%2F%20batch%5Cn(ingestion%2C%20ETL%2C%20reports)%22%5D%0A%20%20%20%20Start%20--%3E%20Audit%5B%22High-stakes%20audit%5Cn(legal%2C%20financial%2C%20scheduling)%22%5D%0A%0A%20%20%20%20UI%20--%3E%20MultiUI%7B%22Multiple%20providers%5Cnor%20API%20keys%3F%22%7D%0A%20%20%20%20MultiUI%20--%20No%20--%3E%20Fallback%5B%22%E2%AC%87%EF%B8%8F%20AiMode.Fallback%5CnDefault%20%E2%80%A2%20Most%20cost-efficient%22%5D%0A%20%20%20%20MultiUI%20--%20Yes%20--%3E%20CostSpeed%7B%22Latency%20sensitive%5Cnor%20cost%20concern%3F%22%7D%0A%20%20%20%20CostSpeed%20--%20%22Fastest%20response%20(high%20cost)%22%20--%3E%20Race%5B%22%F0%9F%8F%81%20AiMode.Race%5CnAbsolute%20fastest%20response%22%5D%0A%20%20%20%20CostSpeed%20--%20%22Staggered%20concurrency%20(lower%20cost)%22%20--%3E%20Hedged%5B%22%E2%8F%B3%20AiMode.Hedged%5CnStaggered%20latency%20hedging%22%5D%0A%0A%20%20%20%20Batch%20--%3E%20Quota%7B%22Quota%20pressure%5Cnor%20multiple%20keys%3F%22%7D%0A%20%20%20%20Quota%20--%20%22Spread%20evenly%22%20--%3E%20RR%5B%22%F0%9F%94%84%20AiMode.RoundRobin%5CnCyclic%20key%20rotation%22%5D%0A%20%20%20%20Quota%20--%20%22Avoid%20429%20proactively%22%20--%3E%20Adaptive%5B%22%F0%9F%93%A1%20AiMode.Adaptive%5CnTelemetry-driven%20ordering%22%5D%0A%20%20%20%20Quota%20--%20%22Single%20key%2C%20simple%22%20--%3E%20Fallback%5B%22%E2%AC%87%EF%B8%8F%20AiMode.Fallback%5CnDefault%20%E2%80%A2%20Most%20cost-efficient%22%5D%0A%0A%20%20%20%20Audit%20--%3E%20Consensus%5B%22%F0%9F%97%B3%EF%B8%8F%20AiMode.Consensus%5CnCross-LLM%20voting%20%E2%80%A2%20Highest%20accuracy%22%5D%0A"})]),fallback:s(()=>[...e[1]||(e[1]=[l(" Loading... ",-1)])]),_:1})),e[4]||(e[4]=a("",33))])}const A=d(c,[["render",k]]);export{F as __pageData,A as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.js new file mode 100644 index 00000000..c757cfb7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.js @@ -0,0 +1,81 @@ +import{_ as n,C as l,o as i,c as p,a2 as a,b as h,w as t,a as r,E as k,a5 as d}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"AI Configuration & Onboarding Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.onboarding.md","filePath":"doc/9-plugins/ai.onboarding.md"}'),o={name:"doc/9-plugins/ai.onboarding.md"};function E(g,s,c,y,F,u){const e=l("Mermaid");return i(),p("div",null,[s[1]||(s[1]=a('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AI Configuration & Onboarding Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides two complementary parsing layers:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Core Tempo Deterministic Engine: Resolves standard dates, ISO strings, and regular relative expressions (e.g. "tomorrow at 5pm", "next Tuesday", "3 days ago") instantly at zero token cost and zero network latency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Tempo AI Plugin: Leverages LLMs for complex semantic reasoning, cultural calendars, event-anchored dates, and ambiguous colloquialisms (e.g. "The Friday before Melbourne Cup", "Third Thursday in November after Thanksgiving", "First business day after Orthodox Easter").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3-Tier Configuration Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Choose the setup that fits your environment:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),(i(),h(d,null,{default:t(()=>[k(e,{id:"mermaid-27",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20Start%5B%22Developer%20starts%20with%20Tempo%20AI%22%5D%20--%3E%20Q1%7B%22Where%20is%20code%20running%3F%22%7D%0A%20%20%20%20Q1%20--%20%22Browser%20%2F%20Client%20%2F%20Sandbox%22%20--%3E%20Q2%7B%22Have%20your%20own%20backend%3F%22%7D%0A%20%20%20%20Q1%20--%20%22Server%20%2F%20Node.js%20%2F%20Deno%20%2F%20Bun%22%20--%3E%20S1%5B%22Tier%203%3A%20Environment%20Variables%20or%20Direct%20Key%3Cbr%2F%3E%3Ccode%3EGROQ_API_KEY%3D...%3C%2Fcode%3E%20or%20%3Ccode%3EinitAI(%7B%20provider%3A%20'groq'%2C%20apiKey%3A%20'...'%20%7D)%3C%2Fcode%3E%22%5D%0A%20%20%20%20Q2%20--%20%22No%20(Evaluation%20Sandbox)%22%20--%3E%20T1%5B%22Tier%201%3A%20Tempo%20Trial%20Sandbox%3Cbr%2F%3E%3Ccode%3EinitAI(%7B%20provider%3A%20'tempo'%20%7D)%3C%2Fcode%3E%3Cbr%2F%3E%3Ci%3E(Free%2020%20req%2Fhr%20trial%20sandbox)%3C%2Fi%3E%22%5D%0A%20%20%20%20Q2%20--%20%22Yes%20(Secure%20Proxy)%22%20--%3E%20T2%5B%22Tier%202%3A%20Backend%20Proxy%20Endpoint%3Cbr%2F%3E%3Ccode%3EinitAI(%7B%20endpoint%3A%20'https%3A%2F%2Fapi.yourdomain.com%2Fapi%2Fai'%20%7D)%3C%2Fcode%3E%22%5D%0A"})]),fallback:t(()=>[...s[0]||(s[0]=[r(" Loading... ",-1)])]),_:1})),s[2]||(s[2]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier Comparison Matrix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TierBest ForConfigurationRate Limits & Data Handling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier 1: Tempo SandboxRapid prototyping, browser REPL, onboarding tutorialsinitAI({ provider: 'tempo' })Free community evaluation sandbox: 20 req/hr per IP (powered by a managed high-reasoning model). Queries are sanitized and retained for up to 30 days for prompt diagnostics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier 2: Backend ProxyProduction web apps, mobile apps, SPAsinitAI({ endpoint: 'https://api.yourdomain.com/api/ai' })Your backend manages quotas, authentication, and secret storage. Zero data touches Tempo servers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier 3: Direct KeysServer-side APIs, microservices, CLI tools, serverlessinitAI({ provider: 'groq', apiKey: '...' }) or initAI({ providers: [...] })Full direct provider quota with dynamic key/endpoint supplier support. Direct client-to-provider egress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier 1: Tempo Trial Sandbox (Evaluation) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To quickly explore semantic date parsing without provisioning external API keys or setting up a proxy backend, opt-in to the free Tempo trial sandbox:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Initialize with Tempo's free evaluation sandbox
+await initAI({ provider: 'tempo' });
+
+const dt = await parseAI("The third Thursday in November after Thanksgiving");
+console.log(dt.format());

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Attention: Trial Gateway Telemetry & Rate Limits: The public Tempo trial evaluation gateway (provider: 'tempo') collects pseudonymous, de-identified telemetry regarding sandbox usage (latency, error rates, model performance, token counts, and HMAC-SHA-256 salted IP hashes) to shape the plugin roadmap and improve parsing schemas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you require strict zero data retention or do not wish to participate in trial sandbox diagnostics, configure your own secure backend proxy (Tier 2) or direct BYOK provider credentials (Tier 3). Learn more in our Security & Privacy Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Trial Rate Limits: The free sandbox enforces an IP rate limit of 20 requests/hour. When exceeded, Tempo AI raises a descriptive TempoAiError(429) guiding you to Tier 2 or Tier 3. To continually improve prompt accuracy and diagnose parsing edge cases, queries sent through the free sandbox are scrubbed of credentials and personal identifiers and stored for up to 30 days. Do not submit sensitive personal information through the trial sandbox.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Never expose private LLM API tokens in client-side browser JavaScript. Instead, configure a single root proxy endpoint:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Configure proxy endpoint once at app startup
+initAI({
+  endpoint: 'https://api.yourdomain.com/api/aiProxy'
+});
+
+// All subsequent AI calls route through your backend proxy (unless a provider specifies an explicit per-provider endpoint override):
+const meeting = await parseAI("The last Friday before Melbourne Cup Day");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Your backend server (Express, Cloud Functions, Next.js API route) terminates client requests, attaches server-bound secrets, forwards requests upstream with timeout and abort management, and handles client disconnects:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Backend handler example (Firebase Cloud Function / Express)
+export const handleAiProxy = async (req, res) => {
+  // 1. Authenticate caller (verify JWT / session token)
+  const authHeader = req.headers.authorization;
+  if (!authHeader?.startsWith('Bearer '))
+    return res.status(401).json({ error: 'Unauthorized: Missing or invalid authentication token.' });
+
+  // 2. Verify caller authorization and enforce caller-specific rate limits
+  const user = await verifyUserSession(authHeader.split('Bearer ')[1]);
+  if (!user)
+    return res.status(403).json({ error: 'Forbidden: Caller not authorized for AI proxy routing.' });
+
+  // 3. Configure AbortController with 15s timeout & client disconnect listener
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 15_000);
+  const onClientDisconnect = () => controller.abort();
+  res.on('close', onClientDisconnect);
+
+  try {
+    // 4. Forward sanitized payload upstream with server-side private key & signal
+    const payload = req.body;
+    const upstreamRes = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': \`Bearer \${process.env.GROQ_API_KEY}\`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+
+    const data = await upstreamRes.json();
+    res.status(upstreamRes.status).json(data);
+  } catch (err: any) {
+    if (controller.signal.aborted) {
+      if (res.writableEnded || res.headersSent) return;
+      return res.status(504).json({ error: 'Gateway Timeout: Upstream AI inference timed out or client disconnected.' });
+    }
+    res.status(500).json({ error: \`AI Proxy Error: \${err.message}\` });
+  } finally {
+    clearTimeout(timeoutId);
+    res.removeListener?.('close', onClientDisconnect);
+  }
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tier 3: Direct Keys & Environment Variables (Server-Side) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Method A: Environment Variables (Auto-Discovery) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Node.js, Deno, or Bun environments, standard provider environment variables are detected automatically:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # In your .env or shell:
+GROQ_API_KEY="gsk_..."
+OPENAI_API_KEY="sk-..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parseAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Automatically discovers GROQ_API_KEY and OPENAI_API_KEY:
+const result = await parseAI("Two weeks after our Q3 quarterly investor dinner");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Method B: Explicit initAI ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, AiMode } from '@magmacomputing/tempo-plugin-ai';
+
+await initAI({
+  mode: AiMode.Fallback,
+  providers: [
+    {
+      id: 'groq',
+      key: process.env.GROQ_API_KEY
+      // Automatically resolves default endpoint & latest model from DEFAULT_PROVIDERS / live manifest
+    },
+    {
+      id: 'custom-internal-gateway',
+      endpoint: 'https://ai-gateway.internal.corp/v1/chat/completions',
+      key: () => getVaultSecret('gateway-token'), // Dynamic supplier
+      model: 'gpt-4o-mini' // Optional: override or specify custom model identifier
+    }
+  ],
+  timeout: 5000
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Manifest & Zero-Maintenance Model Defaults: For standard providers (groq, openai, gemini), specifying model or endpoint is optional. Tempo AI automatically populates them from built-in DEFAULT_PROVIDERS and continuously synchronizes the latest optimal models at runtime via the remote provider manifest (providers.v1.json). Explicit model parameters are only required when overriding defaults or routing to private custom gateways.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Parameter Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ParameterTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endpointstring | (() => string)Global backend proxy URL for all unconfigured providers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providersAiProvider[]Array of configured AI providers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providers[].endpointstring | (() => string)Target chat completions API endpoint URL.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providers[].keystring | (() => string | Promise<string>)Provider API key or dynamic async key resolver.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providers[].modelstring | (() => string)Model identifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeExecution strategy (fallback, race, consensus, hedged, roundrobin, adaptive).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeoutnumberSLA timeout in milliseconds (default: 15000).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forcebooleanSet to true to force fresh LLM fetches and bypass deterministic pre-parsing globally.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheboolean | CacheAdapterCache configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    telemetrybooleanSet to false to opt-out of anonymous usage telemetry (default: true).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,25))])}const C=n(o,[["render",E]]);export{A as __pageData,C as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.lean.js new file mode 100644 index 00000000..de963c90 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.onboarding.md.DZY17T47.lean.js @@ -0,0 +1 @@ +import{_ as n,C as l,o as i,c as p,a2 as a,b as h,w as t,a as r,E as k,a5 as d}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"AI Configuration & Onboarding Guide","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.onboarding.md","filePath":"doc/9-plugins/ai.onboarding.md"}'),o={name:"doc/9-plugins/ai.onboarding.md"};function E(g,s,c,y,F,u){const e=l("Mermaid");return i(),p("div",null,[s[1]||(s[1]=a("",8)),(i(),h(d,null,{default:t(()=>[k(e,{id:"mermaid-27",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20Start%5B%22Developer%20starts%20with%20Tempo%20AI%22%5D%20--%3E%20Q1%7B%22Where%20is%20code%20running%3F%22%7D%0A%20%20%20%20Q1%20--%20%22Browser%20%2F%20Client%20%2F%20Sandbox%22%20--%3E%20Q2%7B%22Have%20your%20own%20backend%3F%22%7D%0A%20%20%20%20Q1%20--%20%22Server%20%2F%20Node.js%20%2F%20Deno%20%2F%20Bun%22%20--%3E%20S1%5B%22Tier%203%3A%20Environment%20Variables%20or%20Direct%20Key%3Cbr%2F%3E%3Ccode%3EGROQ_API_KEY%3D...%3C%2Fcode%3E%20or%20%3Ccode%3EinitAI(%7B%20provider%3A%20'groq'%2C%20apiKey%3A%20'...'%20%7D)%3C%2Fcode%3E%22%5D%0A%20%20%20%20Q2%20--%20%22No%20(Evaluation%20Sandbox)%22%20--%3E%20T1%5B%22Tier%201%3A%20Tempo%20Trial%20Sandbox%3Cbr%2F%3E%3Ccode%3EinitAI(%7B%20provider%3A%20'tempo'%20%7D)%3C%2Fcode%3E%3Cbr%2F%3E%3Ci%3E(Free%2020%20req%2Fhr%20trial%20sandbox)%3C%2Fi%3E%22%5D%0A%20%20%20%20Q2%20--%20%22Yes%20(Secure%20Proxy)%22%20--%3E%20T2%5B%22Tier%202%3A%20Backend%20Proxy%20Endpoint%3Cbr%2F%3E%3Ccode%3EinitAI(%7B%20endpoint%3A%20'https%3A%2F%2Fapi.yourdomain.com%2Fapi%2Fai'%20%7D)%3C%2Fcode%3E%22%5D%0A"})]),fallback:t(()=>[...s[0]||(s[0]=[r(" Loading... ",-1)])]),_:1})),s[2]||(s[2]=a("",25))])}const C=n(o,[["render",E]]);export{A as __pageData,C as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.js new file mode 100644 index 00000000..501c3da3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.js @@ -0,0 +1,38 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"parseAI — Natural Language Point-in-Time Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.parse.md","filePath":"doc/9-plugins/ai.parse.md"}'),t={name:"doc/9-plugins/ai.parse.md"};function p(l,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parseAI — Natural Language Point-in-Time Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parseAI() is the primary entry point for converting complex, unstructured natural language date/time expressions into deterministic Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parseAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+// Initialize AI providers
+await initAI({
+  providers: [
+    { id: 'groq', key: process.env.GROQ_API_KEY }
+  ]
+});
+
+// Parse natural language
+const dt = await parseAI("The penultimate Tuesday before Thanksgiving in 2026");
+
+console.log(dt.format('{yyyy}-{mm}-{dd}')); // 2026-11-17
+console.log(dt.ai?.confidence);             // 0.98

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options & Overrides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parseAI(input, options) accepts per-request options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI("Third Friday of October", {
+  anchor: '2026-05-10T12:00:00Z', // Anchor date for relative calculations
+  timeZone: 'Australia/Sydney',   // Context timezone
+  locale: 'en-AU',                // Context locale
+  minConfidence: 0.85,            // Require at least 0.85 confidence score
+  timeout: 3000,                  // 3-second request timeout (throws TempoAiError(504) if exceeded)
+  force: true,                    // Skip native pre-parsing & cache lookup
+  debug: true                     // Enable operational trace logging & .ai metadata
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Provider Execution Modes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parseAI supports all six multi-provider execution strategies (fallback, race, consensus, hedged, roundrobin, adaptive) configured globally or overridden per-request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For a comprehensive guide, decision flowcharts, and configuration details for all execution modes, refer to the Multi-Provider Execution Modes Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Batch Array Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pass an array of prompts to process multiple queries in parallel while preserving index ordering:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const [dt1, dt2] = await parseAI([
+  "New Years Day 2026",
+  "Groundhog Day 2026"
+]);
+
+console.log(dt1.format('{yyyy}-{mm}-{dd}')); // 2026-01-01
+console.log(dt2.format('{yyyy}-{mm}-{dd}')); // 2026-02-02

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Diagnostic Metadata (.ai) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a date is parsed, a frozen diagnostic metadata object is attached to the returned Tempo instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(dt.ai);
+/*
+{
+  provider: 'groq',
+  cached: false,
+  confidence: 0.98,
+  ambiguous: false,
+  granularity: 'day',
+  rawIso: '2026-11-17T00:00:00'
+}
+*/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18)])])}const g=i(t,[["render",p]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.lean.js new file mode 100644 index 00000000..80a1c340 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.parse.md.DjpOjI9I.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"parseAI — Natural Language Point-in-Time Parsing","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.parse.md","filePath":"doc/9-plugins/ai.parse.md"}'),t={name:"doc/9-plugins/ai.parse.md"};function p(l,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e("",18)])])}const g=i(t,[["render",p]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.js new file mode 100644 index 00000000..bdce5d80 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.js @@ -0,0 +1,86 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Rate Limits & Cache Management","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.rate-limits.md","filePath":"doc/9-plugins/ai.rate-limits.md"}'),e={name:"doc/9-plugins/ai.rate-limits.md"};function h(l,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rate Limits & Cache Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using third-party AI APIs, your application is subject to strict rate limits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin automatically tracks these limits by reading the standard x-ratelimit-* HTTP headers returned by providers like OpenAI and Groq.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tracking Quota Real-time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quota and rate-limit metadata can be inspected in two convenient ways:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Request-Locked Instance Metadata (dt.ai.limits) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For parseAI, every resolved Tempo instance includes a frozen .ai.limits snapshot representing the rate limit state returned by provider HTTP headers for that specific request. Note that .ai.limits is guaranteed only for provider-backed network requests where rate-limit headers are returned by the selected provider; results resolved via native parsing (provider: 'native') or cache hits (provider: 'cache') may omit .ai.limits (undefined).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI("The third Friday of next month");
+
+if (dt.ai?.limits) {
+  console.log(\`Remaining Tokens: \${dt.ai.limits.remainingTokens}\`);
+  console.log(\`Remaining Requests: \${dt.ai.limits.remainingRequests}\`);
+  console.log(\`Resets At: \${dt.ai.limits.resetAt?.format('{hh}:{mi}:{ss}')}\`);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Global State Utility (getAiRateLimits()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For quick status checks or global monitoring across the application lifecycle, getAiRateLimits() exposes the stats from the most recent LLM request:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { getAiRateLimits } from '@magmacomputing/tempo-plugin-ai';
+
+// Returns global stats from the most recent LLM proxy request
+const stats = getAiRateLimits(); 
+
+if (stats) {
+  console.log(\`Remaining Tokens: \${stats.remainingTokens}\`); 
+  console.log(\`Remaining Requests: \${stats.remainingRequests}\`); 
+  console.log(\`Limits Reset At: \${stats.resetAt?.format('{hh}:{mi}:{ss}')}\`); 
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Handling Quota Exhaustion (429s) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you actually exhaust your quota and the provider rejects the request (e.g., HTTP 429 Too Many Requests), the plugin will instantly attempt to failover to the next provider in your configuration array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If all providers fail, the plugin will throw a TempoAiError. This custom error class includes a highly valuable retryAt property:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parseAI, TempoAiError } from '@magmacomputing/tempo-plugin-ai';
+
+try {
+  const dt = await parseAI("The third Friday of next month");
+} catch (error) {
+  if (error instanceof TempoAiError && error.code === 429) {
+    // Safely queue the remaining batch of dates until your minute-limit resets!
+    console.warn(\`All API quotas exhausted. Retry after: \${error.retryAt}\`);
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo AI functions integrate directly with Tempo.cache (BoundedCache) to store pre-resolved ISO 8601 results, drastically reducing LLM API calls and network latency on repetitive queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array Processing & Token Economics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you pass an array of inputs to AI functions (such as parseAI), the plugin intentionally does not batch them into a single massive LLM request. Instead, it iterates through the array and processes each item individually.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is by design for three critical reasons:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cache Efficiency: Individual processing allows AI functions to instantly resolve duplicate strings against Tempo.cache, saving massive amounts of API tokens. If you pass an array of 10,000 dates, but only 1,000 are unique, only 1,000 network requests are made.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Token Economics: A single request consumes ~100 tokens (System Prompt + User String + Output ISO). Given that frontier models cost cents per million tokens, the risk of array-misalignment bugs (see below) far outweighs the negligible savings of batching system prompts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Deterministic Safety: LLMs are language models, not arrays. If you pass 50 strings in a single prompt, smaller models often hallucinate and return 49 strings, completely breaking your array indexing. By dispatching items individually, we guarantee a strict 1:1 index alignment, prevent hallucinations from corrupting sibling entries, and allow granular per-item error isolation when softErrors: true is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Granular Time Gotcha: The cache key is automatically salted with the calendar date (yyyy-mm-dd) of the execution anchor. By default this uses the system execution date, but when options.anchor is explicitly set, it uses the caller-provided anchor date. Note that keeping a fixed anchor date retains the same cache key across midnight boundaries, so an automatic midnight cache miss is not guaranteed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Soft Errors in Array Batches ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When processing arrays of inputs, an unparseable input or provider failure on one item will throw an error and reject the entire batch operation by default. Passing softErrors: true allows batch operations to continue processing all items and return per-item failure representations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • For parseAI: Failed array items return an invalid Tempo instance (isValid === false).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • For Structured Functions (formatAI, extractAI, diffAI, contextAI): Failed array items return the typed TempoAiError object directly in that array position.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. parseAI with softErrors returns invalid Tempo instances
+const dates = await parseAI(["Thanksgiving 2026", "INVALID_PROMPT_STRING"], { softErrors: true });
+console.log(dates[0].isValid); // true
+console.log(dates[1].isValid); // false
+
+// 2. Structured functions return TempoAiError objects into the array
+import { formatAI, TempoAiError } from '@magmacomputing/tempo-plugin-ai';
+
+const formatted = await formatAI([validDate, invalidDate], 'casual tone', { softErrors: true });
+if (formatted[1] instanceof TempoAiError) {
+  console.warn(\`Format failed with code: \${formatted[1].code}\`);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static Glossary Seeding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In addition to dynamic cache lookups, initAI can be initialized with a pre-seeded BoundedCache or synchronous Map containing immortal static business terms (e.g. company glossaries). Static entries bypass TTL expiration and LLM network requests:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const glossary = new Map([
+  ['fiscal_q3_start', '2026-07-01T00:00:00Z'],
+  ['annual_shutdown', '2026-12-24T00:00:00Z']
+]);
+
+initAI({
+  providers: [{ id: 'openai', key: process.env.OPENAI_API_KEY }],
+  cache: glossary
+});
+
+const start = await parseAI('fiscal_q3_start'); // Resolves instantly from static cache without hitting network!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bypassing Cache & Forcing Network Requests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing cache: false disables reading and writing to the cache, but native pre-parsing may still resolve standard phrases. To guarantee an LLM provider request while disabling caching of the response, combine force: true with cache: false:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Forces an LLM network request and prevents reading or writing to cache
+const dt = await parseAI("The last Friday before Christmas", { force: true, cache: false });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Evicting Bad Parses ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If the LLM hallucinates or returns an incorrect absolute date, you can explicitly purge the string from the cache:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { aiCache } from '@magmacomputing/tempo-plugin-ai';
+
+// Evict a single string
+await aiCache.clear("2nd tuesday in nov");
+
+// Or purge all AI cached entries
+await aiCache.clear();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Forcing a Refresh ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want to explicitly query the LLM again and overwrite the existing cache entry with the new result, use the force: true flag:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dt = await parseAI("Q3_START", { force: true });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extensible Caching & Async Storage Adapters (AiCacheAdapter) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, parsed AI responses are cached in memory using Tempo.cache (BoundedCache). For distributed serverless environments (e.g. Next.js, Cloudflare Workers, Express) or cluster nodes, you can pass a custom synchronous or asynchronous storage adapter (AiCacheAdapter):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { initAI, parseAI, type AiCacheAdapter } from '@magmacomputing/tempo-plugin-ai';
+import { Redis } from '@upstash/redis';
+
+const redis = new Redis({ url: process.env.UPSTASH_URL!, token: process.env.UPSTASH_TOKEN! });
+
+// Implement custom async Redis storage adapter with namespacing & prefix deletion support
+const redisAdapter: AiCacheAdapter = {
+  get: async (key) => (await redis.get<string>(\`tempo:ai:\${key}\`)) ?? undefined,
+  set: async (key, value, ttlMs) => {
+    if (ttlMs !== undefined) await redis.set(\`tempo:ai:\${key}\`, value, { px: ttlMs });
+    else await redis.set(\`tempo:ai:\${key}\`, value);
+  },
+  delete: async (key) => {
+    await redis.del(\`tempo:ai:\${key}\`);
+  },
+  clear: async (prefix) => {
+    const pattern = prefix ? \`tempo:ai:\${prefix}*\` : \`tempo:ai:*\`;
+    let cursor = '0';
+    do {
+      const [nextCursor, keys] = await redis.scan(cursor, { match: pattern, count: 100 });
+      cursor = nextCursor;
+      if (keys.length > 0) await redis.del(...keys);
+    } while (cursor !== '0');
+  }
+};
+
+initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY!, ttl: 7200000 }], // Provider-specific TTL (2 hours)
+  cacheAdapter: redisAdapter,
+  ttl: 3600000 // Global default TTL (1 hour)
+});
+
+// Call-site TTL override (15 minutes)
+const dt = await parseAI("next Monday at 9am", { ttl: 900000 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cascading TTL Resolution Policies ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin calculates cache TTL per entry using a strict resolution hierarchy:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Call-site options.ttl: parseAI(prompt, { ttl: 900000 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Provider-level provider.ttl: providers: [{ id: 'groq', ttl: 7200000 }]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Global initAI({ ttl: 3600000 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Default TTL: 3,600,000 ms (1 hour)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fail-Open Cache Resilience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom storage adapter calls (adapter.get and adapter.set) are wrapped in safe error handlers. If an external Redis instance crashes or encounters a network partition, the plugin logs a debug warning (if debug: true) and gracefully fails open to direct LLM resolution without crashing the application request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,48)])])}const g=i(e,[["render",h]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.lean.js new file mode 100644 index 00000000..17d5a62d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.rate-limits.md.b5TsWC2C.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Rate Limits & Cache Management","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.rate-limits.md","filePath":"doc/9-plugins/ai.rate-limits.md"}'),e={name:"doc/9-plugins/ai.rate-limits.md"};function h(l,s,p,k,r,d){return a(),t("div",null,[...s[0]||(s[0]=[n("",48)])])}const g=i(e,[["render",h]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.js new file mode 100644 index 00000000..f131c1f8 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.js @@ -0,0 +1,64 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"recurrenceAI — Recurrence Rules & Schedule Translation","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.recurrence.md","filePath":"doc/9-plugins/ai.recurrence.md"}'),t={name:"doc/9-plugins/ai.recurrence.md"};function h(l,s,p,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    recurrenceAI — Recurrence Rules & Schedule Translation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    recurrenceAI() provides multi-directional translation between natural language repeating schedule descriptions ("Every 2nd Tuesday of the month at 3pm") and RFC 5545 RRULE strings, generating paged Tempo instance batches on demand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { recurrenceAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize provider configuration
+await initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY }]
+});
+
+// 2. Natural Language Input (human-in -> RRule & Tempo batches out)
+const result = await recurrenceAI("Every 2 weeks on Friday at 9am", {
+  locale: 'fr-FR',  // Output localized human summary
+  count: 5          // Default batch size
+});
+
+console.log(result.rrule);     // "FREQ=WEEKLY;INTERVAL=2;BYDAY=FR;BYHOUR=9"
+console.log(result.summary);   // "Chaque 2 semaines le vendredi à 09:00"
+console.log(result.isFinite);  // false (recurs indefinitely)
+console.log(result.size);      // Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Stateful Paged Batching (.take(n)) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    recurrenceAI maintains an internal date cursor. Calling .take(n) repeatedly returns consecutive batches of Tempo instances:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Fetch initial batch of 5 items
+const batch1 = result.take(5);
+console.log(batch1.length); // 5
+
+// Fetch NEXT batch of 5 items starting right where batch 1 left off
+const batch2 = result.take(5);
+console.log(batch2.length); // 5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a finite schedule (e.g. COUNT=10) completes, .take(n) returns an empty array [] to signal exhaustion:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const finiteResult = await recurrenceAI("FREQ=MONTHLY;BYDAY=1MO;COUNT=2");
+
+const b1 = finiteResult.take(2); // [ Tempo(Month 1), Tempo(Month 2) ]
+const b2 = finiteResult.take(2); // [] (Exhausted)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native RRULE Parsing (Zero Network Overhead) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing a raw RFC 5545 RRULE string directly to recurrenceAI bypasses network LLM calls entirely (provider: 'rrule-parser'), functioning as an instant native parser:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const native = await recurrenceAI("FREQ=MONTHLY;BYDAY=1MO;COUNT=12");
+
+console.log(native.provider); // "rrule-parser" (Instant native resolution)
+console.log(native.isFinite); // true
+console.log(native.size);     // 12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lazy Iteration (for...of) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoRecurrenceResult implements [Symbol.iterator], allowing lazy iteration over occurrences up to the batch limit (count: 5 by default).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When iterating over open-ended schedules (isFinite === false), build a break termination clause into the loop:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const schedule = await recurrenceAI("Every Friday");
+
+for (const occurrence of schedule) {
+  // Always include a termination condition for open-ended schedules
+  if (occurrence.yy > 2028) break;
+
+  console.log(occurrence.format('{yyyy}-{mm}-{dd}'));
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Interface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoRecurrenceResult {
+  /** Standard RFC 5545 RRULE string (e.g. 'FREQ=WEEKLY;BYDAY=TU') */
+  rrule: string;
+  
+  /** Localized human-friendly schedule summary */
+  summary: string;
+  
+  /** Reasoning / explanation of how the recurrence pattern was parsed */
+  reasoning?: string;
+  
+  /** True if schedule has an explicit end date or count limit; false if infinite */
+  isFinite: boolean;
+  
+  /** Total count of occurrences if finite, or Infinity (Number.POSITIVE_INFINITY) */
+  size: number;
+  
+  /** Advances cursor and returns the next batch of N Tempo instances */
+  take(count?: number): Tempo[];
+  
+  /** Lazy generator yielding Tempo instances */
+  [Symbol.iterator](): Generator<Tempo, void, unknown>;
+  
+  /** Confidence score (0.0 to 1.0) */
+  confidence: number;
+  
+  /** Provider ID responsible for processing or 'rrule-parser' */
+  provider: string;
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,20)])])}const g=i(t,[["render",h]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.lean.js new file mode 100644 index 00000000..3acf2132 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.recurrence.md.TD2CI-q_.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"recurrenceAI — Recurrence Rules & Schedule Translation","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.recurrence.md","filePath":"doc/9-plugins/ai.recurrence.md"}'),t={name:"doc/9-plugins/ai.recurrence.md"};function h(l,s,p,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[e("",20)])])}const g=i(t,[["render",h]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.js new file mode 100644 index 00000000..5dda51c1 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.js @@ -0,0 +1,52 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"scheduleAI — Intelligent Appointment Booking & Conflict Resolution","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.schedule.md","filePath":"doc/9-plugins/ai.schedule.md"}'),e={name:"doc/9-plugins/ai.schedule.md"};function l(h,s,p,k,d,r){return a(),t("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scheduleAI — Intelligent Appointment Booking & Conflict Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scheduleAI() provides automated slot booking, calendar conflict detection, working hour verification, and iterative slot bumping. It evaluates a natural language booking request (e.g. "45 min sync next Wednesday afternoon") alongside a list of existing busy intervals and working hours to find the best available appointment slots.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { scheduleAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+// 1. Initialize provider
+await initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY }]
+});
+
+// 2. Schedule a meeting avoiding team standups
+const booking = await scheduleAI("45 min sync next Wednesday afternoon", {
+  anchor: "2026-08-10 09:00",
+  timeZone: "America/New_York",
+  events: [
+    { start: "2026-08-12 14:00", end: "2026-08-12 15:00", title: "Team standup" }
+  ],
+  workingHours: { start: "09:00", end: "17:00" } // only match New York business hours
+});
+
+console.log(booking.start.format('{yyyy}-{mm}-{dd} {hh}:{mi}')); // 2026-08-12 15:00
+console.log(booking.end.format('{yyyy}-{mm}-{dd} {hh}:{mi}'));   // 2026-08-12 15:45
+console.log(booking.durationMinutes);                            // 45
+console.log(booking.ai?.conflictBumped);                         // true (pushed past team standup)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (TempoScheduleOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    anchorTempoDateInputAnchor reference time to evaluate relative dates from. Defaults to workstation/browser current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eventsArray<ScheduleEventInput>A list of existing busy calendar intervals or booked events that the meeting must not overlap with.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    workingHoursTempoWorkingHoursDaily time window constraint (HH:MM formats) inside which slots must fit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonestringTarget IANA timezone to calculate the booking slot and boundaries within.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minConfidencenumberMinimum confidence score threshold (0.0 to 1.0) required to return a valid slot.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modeAiModeConcurrency routing strategy (fallback, race, consensus, hedged, roundrobin, adaptive). Refer to the Multi-Provider Execution Modes Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoInterval Interface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoInterval {
+  start: Tempo;
+  end: Tempo;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Event Input Shape (ScheduleEventInput) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The events (or intervals) option accepts raw event objects, continuous TempoInterval pairs, native Interval<Tempo> instances, or [start, end] tuples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export type ScheduleEventInput =
+  | { start: TempoDateInput; end: TempoDateInput; title?: string; label?: string }
+  | TempoInterval
+  | Interval<Tempo>
+  | [TempoDateInput, TempoDateInput]
+  | TempoDateInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Result Schema (TempoScheduleResult) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface TempoScheduleResult {
+  /** The calculated start timestamp of the selected slot */
+  start: Tempo;
+  
+  /** The calculated end timestamp of the selected slot */
+  end: Tempo;
+  
+  /** The resolved slot represented as a Tempo Interval object */
+  slot: Interval<Tempo>;
+  
+  /** The duration of the resolved meeting in minutes */
+  durationMinutes: number;
+  
+  /** Alternative available slot intervals that also satisfy all constraints */
+  alternatives: Interval<Tempo>[];
+  
+  /** Metadata on the AI resolution process */
+  ai?: {
+    provider: string;
+    confidence: number;
+    conflictBumped: boolean; // True if the slot was pushed/bumped to avoid a busyEvent conflict
+    reasoning?: string;
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internal Conflict Bumping Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When an LLM proposes a slot (like Wednesday at 2:00 PM), scheduleAI doesn't just trust it blindly. It runs a deterministic check using Tempo's native Interval.overlaps() method against your events list:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. If the proposed slot overlaps with any busy event, the engine shifts (bumps) the slot forward iteratively.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. It re-verifies the new slot against all other busy events and working hours constraints.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. If it successfully lands on a free spot, it marks ai.conflictBumped: true.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. If no free spot can be found within the proposed date frame, it returns a failed interval with low confidence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This decoupled architecture ensures that the LLM is used for parsing intent (finding the duration and preferred time slot) while Tempo's math engine handles the strict conflict prevention.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,23)])])}const c=i(e,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.lean.js new file mode 100644 index 00000000..01f56d47 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.schedule.md.DLknXOHY.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"scheduleAI — Intelligent Appointment Booking & Conflict Resolution","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.schedule.md","filePath":"doc/9-plugins/ai.schedule.md"}'),e={name:"doc/9-plugins/ai.schedule.md"};function l(h,s,p,k,d,r){return a(),t("div",null,[...s[0]||(s[0]=[n("",23)])])}const c=i(e,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.js new file mode 100644 index 00000000..a4cd95af --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.js @@ -0,0 +1,52 @@ +import{_ as r,C as o,o as s,c as l,j as i,a as t,b as d,w as a,E as c,a5 as p,a2 as h}from"./chunks/framework.DNL3hc5c.js";const v=JSON.parse('{"title":"Security & Privacy Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.security.md","filePath":"doc/9-plugins/ai.security.md"}'),g={name:"doc/9-plugins/ai.security.md"};function u(k,e,y,m,E,f){const n=o("Mermaid");return s(),l("div",null,[e[1]||(e[1]=i("div",{class:"plugin-eyebrow"},[i("a",{href:"./ai.index.html"},"← @magmacomputing/tempo-plugin-ai")],-1)),e[2]||(e[2]=i("br",null,null,-1)),e[3]||(e[3]=i("h1",{id:"security-privacy-architecture",tabindex:"-1"},[t("Security & Privacy Architecture "),i("a",{class:"header-anchor",href:"#security-privacy-architecture","aria-label":'Permalink to "Security & Privacy Architecture"'},"​")],-1)),e[4]||(e[4]=i("p",null,[t("The "),i("code",null,"@magmacomputing/tempo-plugin-ai"),t(" plugin is engineered with a "),i("strong",null,'"Privacy and Security by Default"'),t(" philosophy. Because date parsing and calendar scheduling frequently interact with Personally Identifiable Information (PII)—such as meeting attendees, emails, phone numbers, and sensitive notes—the plugin incorporates multi-layered security controls to protect user data across transit, runtime memory, log output, and caching tiers.")],-1)),(s(),d(p,null,{default:a(()=>[c(n,{id:"mermaid-8",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20subgraph%20Input%20%5B%221.%20Ingress%20%26%20Transport%22%5D%0A%20%20%20%20%20%20%20%20User%5B%22User%20Prompt%20%2F%20Event%20Data%22%5D%20--%3E%7C%22HTTPS%20%2F%20TLS%201.3%20Enforcement%22%7C%20Transport%5B%22Secure%20Transport%20Layer%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Memory%20%5B%222.%20In-Memory%20Processing%20%26%20Storage%22%5D%0A%20%20%20%20%20%20%20%20Transport%20--%3E%20Schema%5B%22Rigid%20Schema%20Validation%20%26%20Grounding%22%5D%0A%20%20%20%20%20%20%20%20Schema%20--%3E%20Runtime%5B%22In-Memory%20Execution%3Cbr%2F%3E(Full%20Fidelity%20Access)%22%5D%0A%20%20%20%20%20%20%20%20Runtime%20--%3E%20Cache%5B%22Partitioned%20Multi-Tier%20Cache%3Cbr%2F%3E(Namespaced%20by%20Tenant%2FTZ%2FLocale)%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Egress%20%5B%223.%20Egress%20%26%20Smart%20Debugging%22%5D%0A%20%20%20%20%20%20%20%20Runtime%20--%3E%20ProxyMeta%5B%22Proxy-Wrapped%20Result%20Objects%3Cbr%2F%3E(attachCustomInspect)%22%5D%0A%20%20%20%20%20%20%20%20ProxyMeta%20--%3E%20Logic%5B%22Application%20Business%20Logic%3Cbr%2F%3E(100%25%20Raw%20Data%20Access)%22%5D%0A%20%20%20%20%20%20%20%20ProxyMeta%20--%3E%7C%22console.log()%20%2F%20util.inspect%22%7C%20Logger%5B%22Smart%20Logger%20(logDebug)%3Cbr%2F%3E%E2%80%A2%20NODE_ENV%3Dproduction%3A%20Auto-Masked%20PII%3Cbr%2F%3E%E2%80%A2%20NODE_ENV%3Ddevelopment%3A%20Full%20Diagnostic%20Logs%22%5D%0A%20%20%20%20end%0A"})]),fallback:a(()=>[...e[0]||(e[0]=[t(" Loading... ",-1)])]),_:1})),e[5]||(e[5]=h(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Smart Debug Telemetry & PII Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Debugging LLM integrations traditionally presents a major security dilemma: enabling debug logs often inadvertently dumps raw prompts containing sensitive user emails, phone numbers, and auth tokens into centralized log aggregators (e.g. Datadog, CloudWatch, Sentry).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ai significantly mitigates this risk through Smart Debug Infrastructure:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Universal Environment Detection & Zero-Config Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Flag: Telemetry is enabled directly using { debug: true } on individual requests or globally via initAI({ debug: true }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Environment-Aware Sanitization: The runtime automatically inspects NODE_ENV. In production environments (NODE_ENV === 'production'), all debug logs and terminal outputs automatically sanitize sensitive data before printing to console.log or console.warn.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Development Fidelity: In non-production environments (local development, testing), full diagnostic strings are preserved for seamless prompt debugging.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automatic PII Redaction ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In production mode, all debug telemetry is scrubbed through automated regex sanitizers:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Email Addresses: Masked to initial and domain (e.g., john.doe@enterprise.com → j***@enterprise.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Phone Numbers: Masked to last four digits (e.g., +1-555-867-5309 → ***-***-5309).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bearer & API Tokens: Redacted with prefix/suffix preservation (e.g., Bearer sk-proj-1234... → Bearer sk-p...1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Length Bounds: Exceptionally long strings (> 256 characters) are safely truncated with character count annotations to prevent log bloat and denial-of-service attacks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parseAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+await initAI({
+  providers: [{ id: 'groq', key: process.env.GROQ_API_KEY }],
+  debug: true // Safe in all environments
+});
+
+// Input containing sensitive attendee data
+const date = await parseAI("Meeting with john.smith@company.org (call 555-123-4567) next Friday");
+
+// In Production, console.log(date.ai) outputs:
+// {
+//   provider: 'groq',
+//   confidence: 0.98,
+//   rawPrompt: 'Meeting with j***@company.org (call ***-***-4567) next Friday',
+//   reasoning: 'Parsed meeting for next Friday with j***@company.org'
+// }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Tamper-Resistant Proxy Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All AI return objects (Tempo.ai, TempoAiFormatResult, TempoAiExtractResult, TempoAiDiffResult, TempoScheduleResult, TempoRecurrenceResult) utilize JavaScript Proxy wrappers and Node.js custom inspection hooks (Symbol.for('nodejs.util.inspect.custom') and .toJSON()):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Terminal & Log Safety: When an AI result object is logged via console.log(), util.inspect(), or serialized for telemetry, the custom inspection hook intercepts the call and outputs the PII-masked view.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. 100% In-Memory Code Integrity: In-memory property access within your application code (date.ai?.rawPrompt, result.events[0].rawText, res.reasoning) retains full, unmodified data fidelity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Deep Immutability: Metadata properties attached to Tempo instances are frozen using Object.freeze(), preventing runtime tampering or prototype pollution by downstream code or dependencies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const result = await formatAI(targetDate, 'Notify alice.cooper@domain.com');
+
+// 1. Terminal / Log Aggregators see sanitized PII in production:
+console.log(result); 
+// => { formatted: '...', reasoning: '... client a***@domain.com ...' }
+
+// 2. Your application code receives full raw fidelity:
+const rawReasoning = result.reasoning; 
+// => "Formatted for client alice.cooper@domain.com"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Transport Security & Network Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enforced HTTPS / TLS ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict HTTPS Requirement: All network communication with upstream LLM APIs and remote configuration servers must use HTTPS with modern TLS (TLS 1.2 or TLS 1.3).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plaintext HTTP Disallowed: Unencrypted HTTP endpoints are rejected at runtime, with an exception allowed exclusively for localhost origins during local development or unit testing with mock servers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Manifest Host Verification ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Trusted Remote Endpoints: When loadRemoteManifest resolves provider manifests, it enforces trusted origin allowlists.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Provider URL Sanitization: Any dynamic endpoint received via remote manifests or the fetchDefaults hook is verified before runtime merging. Disallowed hosts are rejected and stripped to prevent server-side request forgery (SSRF).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Credential Isolation & BYOK Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automated In-Memory Key Redaction ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calling getAiConfig() returns a sanitized, read-only configuration snapshot.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • All provider key values, authorization tokens, and shared secrets are permanently replaced with [REDACTED], ensuring secrets cannot be leaked via diagnostic endpoints or error monitors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Secret Vaults & Automated Key Rotation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Provider key parameters support synchronous and asynchronous supplier functions (AsyncEvaluable<string> / () => Promise<string> | string), while url, model, and temporal context fields accept synchronous suppliers (Evaluable<T>).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enterprise Secret Vaults: Instead of pinning long-lived static API keys in memory, applications can integrate cloud key vaults (e.g. AWS Secrets Manager, HashiCorp Vault, Azure Key Vault, Doppler):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initAI({
+  providers: [
+    {
+      id: 'openai',
+      // Evaluated just-in-time on every provider HTTP dispatch
+      key: async () => await secretVault.getSecret('OPENAI_API_KEY')
+    }
+  ]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-Tenant / Per-Request Key Isolation: In SaaS applications where each tenant supplies their own BYOK credentials, resolve keys dynamically from the active request context without re-initializing global AI state:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initAI({
+  providers: [
+    {
+      id: 'openai',
+      // Pulls tenant-specific key from AsyncLocalStorage or request session
+      key: () => {
+        const tenant = tenantStore.getStore();
+        if (!tenant) throw new Error('No tenant context found');
+        return tenant.openaiApiKey;
+      }
+    }
+  ]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Short-Lived & OAuth Token Refreshers: Dynamic suppliers allow automatic token refresh for short-lived credentials (e.g. Google Cloud Vertex AI / Azure Entra ID OAuth tokens) without service disruption:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initAI({
+  providers: [
+    {
+      id: 'gemini',
+      key: async () => (await authClient.getAccessToken()).token
+    }
+  ]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Keys are fetched just-in-time prior to the HTTP request and never stored in plain text in persistent global state, enabling zero-downtime key rotation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Frontend Zero-Storage Principle ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • No Client-Side Secrets (Zero Browser Storage): LLM API keys must never be bundled into client-side single-page applications (React, Vue, Svelte) or stored in any browser storage (localStorage, sessionStorage, IndexedDB, OPFS, Web Locks, or browser cache). We recommend zero browser storage for API credentials; any client-side persistence remains accessible to same-origin scripts and vulnerable to XSS exfiltration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Proxy Architecture: Public frontend web applications must route requests through a self-hosted backend proxy or secure AI Gateway (Cloudflare Worker, Next.js API Route) where private API keys are kept server-side.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Ephemeral Processing, Partitioned Caching & Trial Gateway Data Handling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Local Libraries Zero Telemetry Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The @magmacomputing/tempo core library and @magmacomputing/tempo-plugin-ai package collect zero telemetry, analytics, or prompt logs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • When using Tier 2 (Private Backend Proxy) or Tier 3 (Direct Provider Keys / BYOK), prompt processing and temporal computations occur ephemerally during request execution directly between your infrastructure and your configured LLM provider. Zero data touches Magma Computing servers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Trial Sandbox Gateway (provider: 'tempo') Data Handling & Diagnostics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Attention: Trial Gateway Telemetry Notice The public Tempo trial evaluation gateway (provider: 'tempo') collects pseudonymous telemetry regarding sandbox usage (latency, error rates, model performance, token counts, and HMAC-SHA-256 salted IP hashes). This information is used to diagnose parsing failures, tune prompt schemas, and shape the plugin roadmap. For developers requiring strict zero retention or zero external logging, route requests through your own backend proxy (Tier 2) or direct BYOK provider keys (Tier 3) as detailed in our Configuration & Onboarding Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prompt Engineering & Diagnostics: Natural language date expressions and model completion responses sent to the free trial gateway may be recorded in diagnostic telemetry records (when payload capture is enabled) to diagnose parsing edge cases, detect hallucinations, and tune temporal context prompts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pseudonymous IP Hashing: Client IP addresses are hashed using HMAC-SHA-256 with a secure server-side salt prior to storage; the gateway stores this HMAC-derived pseudonymous IP identifier, while raw IP addresses are not stored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero Retention Choice (Tier 2 & Tier 3): The free trial gateway provides community-subsidized compute for rapid prototyping. If your application handles sensitive data or requires strict zero data retention, use Tier 2 (custom backend proxy) or Tier 3 (direct BYOK keys).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Retention Policy: Trial gateway telemetry records (including recorded prompt and completion diagnostic bodies) become eligible for automated deletion after 30 days via Firestore TTL. Firestore TTL deletion executes asynchronously in the background, typically within 24 to 72 hours of TTL expiration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sensitive Data: Do not submit proprietary or sensitive personal information through the trial sandbox gateway. For strict zero retention, configure your own backend proxy (initAI({ endpoint })) or private provider keys (initAI({ provider: 'groq', apiKey })) together with provider-side zero-data-retention controls and request-level cache bypass (cache: false or force: true) or a non-persisting cache adapter; local cache management via Tempo.cache or AiCacheAdapter provides caller-controlled client persistence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partitioned Multi-Tier Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Namespaced Cache Keys: Cache keys are generated with multi-factor domain partitioning (e.g., diff::, format::, extract::) incorporating the prompt text, anchor epoch, target timezone, locale, calendar system, and regional parameters to prevent contextual collision.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Storage Lifecycle: Cached entries persist in the local Tempo.cache (BoundedCache) or caller-provided AiCacheAdapter (e.g. Redis, KV) strictly until TTL expiration or LRU capacity eviction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Granular Bypass Controls: Operations requiring zero cache persistence can supply cache: false or force: true on any individual request, or programmatically flush entries using await aiCache.clear().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Schema Enforcement & Hallucination Defense ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Large Language Models can occasionally hallucinate dates or output non-deterministic formats. @magmacomputing/tempo-plugin-ai prevents invalid data propagation through strict input/output boundaries:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Rigid Schema Validation: All provider completions are validated against deterministic schemas and regex patterns prior to object construction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Confidence Threshold Gating: The plugin enforces configurable minConfidence thresholds (e.g. minConfidence: 0.85). Results falling below the threshold throw a typed TempoAiError or trigger automatic fallback.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Deterministic Grounding Fallbacks: Grounding metrics (such as business days, calendar day offsets, and duration calculations) are verified using deterministic Tempo calculations rather than unverified LLM assumptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Residual Risks & Threat Model Matrix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORTANT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primary Production Strategy: The primary recommendation for production environments is to keep debug: false (the default). Smart Debug is designed as an automated safety net to prevent catastrophic PII leaks when developers troubleshoot live issues, but no automated sanitization layer can eliminate 100% of risk when raw diagnostic telemetry is captured.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The following matrix documents residual threat vectors and recommended mitigations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Threat VectorSourceRisk LevelArchitectural BehaviorRecommended Mitigation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Direct Primitive LoggingDeveloper console.log(res.reasoning)MediumEvaluates to the raw in-memory string and bypasses object inspection hooks.Log entire result objects (console.log(res)) or leave debug: false.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object Spread Loggingconsole.log({ ...res })LowSpreading copies raw enumerable keys into a plain object without non-enumerable inspect symbols.Log the object directly (console.log(res)) rather than shallow spreading.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Network-Layer APM TracingDatadog, OpenTelemetry, Sentry HTTP captureHighAPM agents monkey-patching fetch capture raw outbound HTTP payloads in transit.Disable full HTTP body capture on LLM routes in your APM configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Semantic PIIUnstructured names, physical addresses, health infoMediumRegexes catch structured PII (emails, phones, tokens) but not unstructured names/addresses.Rely on payload truncation limits (< 256 chars) and avoid debug: true on sensitive workflows.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Environment Variable DriftNODE_ENV not set or misconfiguredLowLogger checks NODE_ENV (production, prod, live) and PROD=true. If unset, defaults to dev mode.Verify deployment manifests explicitly export NODE_ENV=production.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    External Cache Driver LogsThird-party Redis/DB client debug logsLowDistributed cache adapters store raw JSON required to rehydrate Tempo instances.Ensure production Redis/database clients have debug logging disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,47))])}const A=r(g,[["render",u]]);export{v as __pageData,A as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.lean.js new file mode 100644 index 00000000..8da562d9 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.security.md.DUzWk1EB.lean.js @@ -0,0 +1 @@ +import{_ as r,C as o,o as s,c as l,j as i,a as t,b as d,w as a,E as c,a5 as p,a2 as h}from"./chunks/framework.DNL3hc5c.js";const v=JSON.parse('{"title":"Security & Privacy Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.security.md","filePath":"doc/9-plugins/ai.security.md"}'),g={name:"doc/9-plugins/ai.security.md"};function u(k,e,y,m,E,f){const n=o("Mermaid");return s(),l("div",null,[e[1]||(e[1]=i("div",{class:"plugin-eyebrow"},[i("a",{href:"./ai.index.html"},"← @magmacomputing/tempo-plugin-ai")],-1)),e[2]||(e[2]=i("br",null,null,-1)),e[3]||(e[3]=i("h1",{id:"security-privacy-architecture",tabindex:"-1"},[t("Security & Privacy Architecture "),i("a",{class:"header-anchor",href:"#security-privacy-architecture","aria-label":'Permalink to "Security & Privacy Architecture"'},"​")],-1)),e[4]||(e[4]=i("p",null,[t("The "),i("code",null,"@magmacomputing/tempo-plugin-ai"),t(" plugin is engineered with a "),i("strong",null,'"Privacy and Security by Default"'),t(" philosophy. Because date parsing and calendar scheduling frequently interact with Personally Identifiable Information (PII)—such as meeting attendees, emails, phone numbers, and sensitive notes—the plugin incorporates multi-layered security controls to protect user data across transit, runtime memory, log output, and caching tiers.")],-1)),(s(),d(p,null,{default:a(()=>[c(n,{id:"mermaid-8",class:"mermaid",graph:"flowchart%20TD%0A%20%20%20%20subgraph%20Input%20%5B%221.%20Ingress%20%26%20Transport%22%5D%0A%20%20%20%20%20%20%20%20User%5B%22User%20Prompt%20%2F%20Event%20Data%22%5D%20--%3E%7C%22HTTPS%20%2F%20TLS%201.3%20Enforcement%22%7C%20Transport%5B%22Secure%20Transport%20Layer%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Memory%20%5B%222.%20In-Memory%20Processing%20%26%20Storage%22%5D%0A%20%20%20%20%20%20%20%20Transport%20--%3E%20Schema%5B%22Rigid%20Schema%20Validation%20%26%20Grounding%22%5D%0A%20%20%20%20%20%20%20%20Schema%20--%3E%20Runtime%5B%22In-Memory%20Execution%3Cbr%2F%3E(Full%20Fidelity%20Access)%22%5D%0A%20%20%20%20%20%20%20%20Runtime%20--%3E%20Cache%5B%22Partitioned%20Multi-Tier%20Cache%3Cbr%2F%3E(Namespaced%20by%20Tenant%2FTZ%2FLocale)%22%5D%0A%20%20%20%20end%0A%0A%20%20%20%20subgraph%20Egress%20%5B%223.%20Egress%20%26%20Smart%20Debugging%22%5D%0A%20%20%20%20%20%20%20%20Runtime%20--%3E%20ProxyMeta%5B%22Proxy-Wrapped%20Result%20Objects%3Cbr%2F%3E(attachCustomInspect)%22%5D%0A%20%20%20%20%20%20%20%20ProxyMeta%20--%3E%20Logic%5B%22Application%20Business%20Logic%3Cbr%2F%3E(100%25%20Raw%20Data%20Access)%22%5D%0A%20%20%20%20%20%20%20%20ProxyMeta%20--%3E%7C%22console.log()%20%2F%20util.inspect%22%7C%20Logger%5B%22Smart%20Logger%20(logDebug)%3Cbr%2F%3E%E2%80%A2%20NODE_ENV%3Dproduction%3A%20Auto-Masked%20PII%3Cbr%2F%3E%E2%80%A2%20NODE_ENV%3Ddevelopment%3A%20Full%20Diagnostic%20Logs%22%5D%0A%20%20%20%20end%0A"})]),fallback:a(()=>[...e[0]||(e[0]=[t(" Loading... ",-1)])]),_:1})),e[5]||(e[5]=h("",47))])}const A=r(g,[["render",u]]);export{v as __pageData,A as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.js new file mode 100644 index 00000000..fc10c460 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.js @@ -0,0 +1,89 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.use-cases-and-patterns.md","filePath":"doc/9-plugins/ai.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/ai.use-cases-and-patterns.md"};function l(p,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Integrating Large Language Models (LLMs) with date-time logic presents severe reliability hazards in production:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Hallucinated Dates: Models routinely miscalculate weekday-to-date mappings (e.g. claiming "next Friday" is the 14th when it is actually the 15th).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Missing Reference Anchors: Without an explicit reference anchor, relative expressions ("in 3 days", "tomorrow afternoon") resolve against arbitrary training cutoff dates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. PII Leakage: Sending full user prompts to third-party LLMs exposes sensitive user identities and private calendar details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ai plugin bridges LLM intelligence with Tempo's deterministic temporal engine, enforcing strict PII protection, anchor grounding, and schema validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Natural Language Booking: Ambiguous Input to Validated Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In conversational scheduling bots (such as appointment booking agents or support chatbots), users describe meeting times in informal natural language:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "Can we meet next Wednesday at 2:30pm for 45 minutes?"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "Schedule a review session on the second Friday of next month at 10am"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ai.parse grounds the prompt against an absolute server reference anchor (anchor) and user timezone, resolving a strongly typed Tempo instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ai/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export async function parseAppointmentPrompt(
+  userInput: string,
+  userTimeZone: string
+): Promise<{ scheduledStart: Tempo; durationMinutes: number }> {
+  // Ground the prompt against current time and user timezone
+  const anchorTime = new Tempo('now', { timeZone: userTimeZone });
+
+  const appointment = await Tempo.ai.parse(userInput, {
+    anchor: anchorTime,
+    timeZone: userTimeZone
+  });
+
+  return {
+    scheduledStart: appointment,
+    durationMinutes: 45
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Converting Natural Language Recurrence to RFC 5545 RRULE ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calendar applications (Google Calendar, Outlook, Apple Calendar) require standard RFC 5545 iCalendar RRULE strings to synchronize recurring events. Parsing human recurrence patterns into valid RRULEs with deterministic end dates is error-prone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ai.recurrence converts natural language patterns directly into validated RRULE strings:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ai/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export async function generateCalendarRule(recurrencePrompt: string): Promise<string> {
+  const result = await Tempo.ai.recurrence(recurrencePrompt, {
+    anchor: new Tempo('now')
+  });
+
+  // Returns standard iCalendar RRULE format:
+  // e.g. "FREQ=WEEKLY;INTERVAL=2;BYDAY=TU;COUNT=10"
+  return result.rrule;
+}
+
+// Example prompts:
+// "every other Tuesday for 10 sessions" -> FREQ=WEEKLY;INTERVAL=2;BYDAY=TU;COUNT=10
+// "first Monday of every month"         -> FREQ=MONTHLY;BYDAY=1MO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Conflict-Free Slot Scheduling Around Busy Calendar Events ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building scheduling platforms (such as Calendly or Cal.com workflows), booking engines must calculate the first open slot that fits between existing busy event bounds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ai.schedule inspects an array of existing busy bounds and finds non-overlapping appointment slots within working hours:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ai/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+interface BusyBlock {
+  start: string;
+  end: string;
+}
+
+export async function findNextAvailableSlot(
+  busyCalendar: BusyBlock[],
+  requestedDurationMinutes: number
+): Promise<{ slotStart: Tempo; slotEnd: Tempo }> {
+  const scheduleResult = await Tempo.ai.schedule({
+    busy: busyCalendar,
+    durationMinutes: requestedDurationMinutes,
+    workingHours: { start: '09:00', end: '17:00' },
+    anchor: new Tempo('now')
+  });
+
+  return {
+    slotStart: scheduleResult.start,
+    slotEnd: scheduleResult.end
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Contextual Narrative Summaries for Customer Notifications ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Raw ISO-8601 strings (2026-10-05T14:30:00Z) or mechanical countdowns ("in 48 hours") feel impersonal in user-facing delivery updates or customer notifications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ai.format generates human-friendly, contextual narrative summaries with reasoning metadata:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ai/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export async function createDeliveryNotification(deliveryDateIso: string): Promise<string> {
+  const delivery = new Tempo(deliveryDateIso);
+
+  const narrative = await Tempo.ai.format(delivery, {
+    style: 'concise',
+    context: 'e-commerce package arrival'
+  });
+
+  // Generates contextual prose:
+  // "Arriving this Monday afternoon (in about 2 days)"
+  return narrative.formatted;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Enterprise PII Masking & Air-Gapped Fallback ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In regulated enterprise environments (healthcare, finance, government), sending raw customer text to external LLMs breaches data privacy mandates (HIPAA, GDPR).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo-plugin-ai provides built-in PII redaction and multi-provider race/fallback modes. You can configure sensitive queries to route through an on-premise local model (e.g. Ollama) while falling back to cloud providers:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ai/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// Initialize with local on-premise provider and cloud fallback
+await Tempo.ai.init({
+  mode: 'fallback',
+  providers: [
+    {
+      id: 'ollama',
+      endpoint: 'http://localhost:11434/api/generate',
+      models: { default: 'llama3:8b' }
+    },
+    {
+      id: 'groq',
+      key: process.env.GROQ_API_KEY
+    }
+  ]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,32)])])}const g=i(e,[["render",l]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.lean.js new file mode 100644 index 00000000..4145e49d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ai.use-cases-and-patterns.md.CMIx3E8I.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ai.use-cases-and-patterns.md","filePath":"doc/9-plugins/ai.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/ai.use-cases-and-patterns.md"};function l(p,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t("",32)])])}const g=i(e,[["render",l]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.js new file mode 100644 index 00000000..73895ffa --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.js @@ -0,0 +1,17 @@ +import{_ as i}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as s,E as o}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-batch","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.index.md","filePath":"doc/9-plugins/batch.index.md"}'),r={name:"doc/9-plugins/batch.index.md"};function h(c,t,d,k,g,m){const a=n("PluginRepl");return l(),p("div",null,[t[0]||(t[0]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-batch ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin for the Tempo library that parallelizes massive epoch mutation tasks across worker threads utilizing lock-free SharedArrayBuffer shared memory architecture for extreme throughput.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perfect For

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Heavy data ETL pipelines, massive IoT telemetry ingestion, financial ledger backtesting, and parallel bulk date-processing workloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Installation & Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-batch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),o(a,{plugin:"batch"}),t[1]||(t[1]=s(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BatchPlugin } from '@magmacomputing/tempo-plugin-batch';
+
+Tempo.use(BatchPlugin);
+
+// Assume \`epochs\` is a massive array of integers representing timestamps
+const epochs = [1700000000000, 1700000001000, /* ... millions more ... */];
+
+// Mutate millions of dates concurrently using the background worker pool!
+// The engine automatically splits the payload and offloads to workers
+const batchResult = await Tempo.batch(epochs, '+1w', { threads: 4 });
+
+console.log(batchResult); // Returns an array of mutated timestamp integers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Boilerplate Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-batch/install';
+
+const epochs = [1700000000000, 1700000001000];
+const batchResult = await Tempo.batch(epochs, '+1w');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 API Surface Catalog ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Batch plugin mounts the static Tempo.batch() method and exports the underlying BatchOrchestrator:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Export / MethodSignatureReturnsDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.batch()(epochs: number[], operation: string, options?: BatchOptions)Promise<number[] | Tempo[]>Splits the input array across worker threads and applies duration mutation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BatchOrchestratorStatic classBatchOrchestratorLow-level orchestration engine with transform() and sanitizeExecArgv() tools.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (BatchOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    threadsnumberos.cpus().lengthNumber of worker threads to allocate for the pool.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rehydratebooleanfalseWhen false, returns raw numeric timestamps (number[]) for peak throughput. When true, rehydrates output numbers into Tempo[] instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Mutation Operations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The operation parameter accepts either standard duration strings or shorthand intervals:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Days: '+1d', '+2 days', '-5d'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Weeks: '+1w', '+4 weeks'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hours: '+1h', '+8 hours'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Minutes: '+30m', '-15 mins'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Months / Years: '+1mo', '+1y'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Architecture & Specialized Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18))])}const f=e(r,[["render",h]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.lean.js new file mode 100644 index 00000000..fcda3b31 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.index.md.BsL4sRb1.lean.js @@ -0,0 +1 @@ +import{_ as i}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as s,E as o}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-batch","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.index.md","filePath":"doc/9-plugins/batch.index.md"}'),r={name:"doc/9-plugins/batch.index.md"};function h(c,t,d,k,g,m){const a=n("PluginRepl");return l(),p("div",null,[t[0]||(t[0]=s("",8)),o(a,{plugin:"batch"}),t[1]||(t[1]=s("",18))])}const f=e(r,[["render",h]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.js new file mode 100644 index 00000000..17e2cef7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.js @@ -0,0 +1,80 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.use-cases-and-patterns.md","filePath":"doc/9-plugins/batch.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/batch.use-cases-and-patterns.md"};function l(h,s,p,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-batch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explores real-world systems patterns where @magmacomputing/tempo-plugin-batch accelerates high-volume temporal processing across multi-core server environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. High-Throughput IoT Telemetry Skew Normalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An industrial IoT gateway collects sensor packets from thousands of field devices. Due to firmware clock drift, timestamps must be shifted forward by a calibrated skew correction (e.g. +12 seconds or +2 hours) before being inserted into a time-series database. Processing 500,000 timestamps on the main Node.js event loop blocks incoming network sockets and causes packet loss.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Tempo.batch() to offload the transformation to worker threads. The raw epoch numbers are transformed directly in shared memory (SharedArrayBuffer), keeping the main thread free to handle HTTP/MQTT connections.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Incoming Telemetry Batch (500k Epochs)
+                 │
+                 ▼
+       Tempo.batch(epochs, '+12s')
+                 │
+     ┌───────────┼───────────┐
+     ▼           ▼           ▼
+ Worker #1   Worker #2   Worker #3
+ (SharedArrayBuffer Float64Array Slices)
+                 │
+                 ▼
+  Zero-Copy Mutated Epoch Array -> PostgreSQL TimescaleDB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Implementation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BatchPlugin } from '@magmacomputing/tempo-plugin-batch';
+
+Tempo.use(BatchPlugin);
+
+export interface IngestedTelemetryBatch {
+  deviceId: string;
+  skewOffset: string; // e.g. "+12s" or "-30m"
+  rawEpochs: number[];
+}
+
+/**
+ * Normalizes device telemetry timestamps in background workers.
+ */
+export async function normalizeDeviceBatch(batch: IngestedTelemetryBatch): Promise<number[]> {
+  // Parallelize the mutation across available CPU cores
+  const normalizedEpochs = await Tempo.batch(batch.rawEpochs, batch.skewOffset, {
+    rehydrate: false // keep as primitive numbers for maximum database bulk-copy throughput
+  });
+
+  return normalizedEpochs;
+}
+
+// Example Execution
+const sampleEpochs = [1700000000000, 1700000001000, 1700000002000];
+const normalized = await normalizeDeviceBatch({
+  deviceId: 'turbine-north-4',
+  skewOffset: '+1h',
+  rawEpochs: sampleEpochs
+});
+
+console.log('Original first epoch:  ', sampleEpochs[0]);
+console.log('Normalized first epoch:', normalized[0]); // 3600000 ms later

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Financial Tick Data Backtesting & Interval Rolling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quantitative trading algorithms simulate portfolio strategies over millions of historical trade ticks. Backtesting requires rolling timestamps forward across multiple simulation runs (e.g. testing strategy execution across shifted trading windows: +1 week, +2 weeks, +1 month). Processing 10,000,000 ticks sequentially in JavaScript takes tens of seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By specifying a dedicated thread pool size ({ threads: 8 }), Tempo.batch divides the 10M record array evenly across 8 workers, utilizing SIMD-like concurrent chunking to complete the transformation in a fraction of the time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BatchPlugin } from '@magmacomputing/tempo-plugin-batch';
+
+Tempo.use(BatchPlugin);
+
+export class BacktestEngine {
+  /**
+   * Shifts historical trade tick epochs into a prospective simulation window.
+   */
+  static async shiftSimulationWindow(historicalEpochs: number[], windowShift = '+1w'): Promise<number[]> {
+    console.time('Parallel Batch Shift');
+
+    const shiftedEpochs = await Tempo.batch(historicalEpochs, windowShift, {
+      threads: 8,
+      rehydrate: false
+    });
+
+    console.timeEnd('Parallel Batch Shift');
+    return shiftedEpochs;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Large-Scale CSV Payroll Date Processing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A payroll processing SaaS application receives monthly employee attendance CSV files containing hundreds of thousands of punch-clock records. The system needs to validate overtime boundaries by rolling dates forward to the nearest pay-period closing cycle and rehydrating them as full Tempo objects for business logic inspection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use { rehydrate: true } to receive fully initialized, immutable Tempo instances directly from the worker pool once parallel arithmetic finishes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BatchPlugin } from '@magmacomputing/tempo-plugin-batch';
+
+Tempo.use(BatchPlugin);
+
+export async function processPayrollEpochs(attendancePunchEpochs: number[]): Promise<Tempo[]> {
+  // Shift punch times to the closing cycle and rehydrate into Tempo instances
+  const payrollInstances: Tempo[] = await Tempo.batch(attendancePunchEpochs, '+14d', {
+    rehydrate: true // returns Tempo[] instances
+  });
+
+  return payrollInstances;
+}
+
+// Result: Array of fully featured Tempo objects ready for business rules
+const instances = await processPayrollEpochs([1700000000000, 1700000005000]);
+console.log(instances[0].format('{yyyy}-{mm}-{dd}'));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,27)])])}const E=i(e,[["render",l]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.lean.js new file mode 100644 index 00000000..9f1b97d0 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.use-cases-and-patterns.md.B1JvH9aH.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.use-cases-and-patterns.md","filePath":"doc/9-plugins/batch.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/batch.use-cases-and-patterns.md"};function l(h,s,p,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t("",27)])])}const E=i(e,[["render",l]]);export{c as __pageData,E as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.js new file mode 100644 index 00000000..a38f1eaf --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.js @@ -0,0 +1,22 @@ +import{_ as a,o as e,c as i,a2 as t}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Parallel Worker Pool & SharedArrayBuffer Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.worker-architecture.md","filePath":"doc/9-plugins/batch.worker-architecture.md"}'),n={name:"doc/9-plugins/batch.worker-architecture.md"};function r(l,s,o,h,p,d){return e(),i("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-batch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parallel Worker Pool & SharedArrayBuffer Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-batch plugin accelerates bulk date mutations across multi-core systems by partitioning massive epoch arrays and executing calculations concurrently across a pool of background worker threads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dual-Mode Execution Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The orchestrator dynamically inspects the host runtime and automatically selects between zero-copy shared memory or structural cloning:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo.batch(epochs, operation, options)
+                                    │
+                         Is SharedArrayBuffer Available?
+                                ├─── YES ───► Mode A: SharedArrayBuffer (Zero-Copy)
+                                └─── NO  ───► Mode B: postMessage Structural Cloning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode A: Lock-Free SharedArrayBuffer (High Throughput) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When running in Node.js or in browsers with Cross-Origin Isolation enabled:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The master process allocates two shared memory buffers sized to the exact input length:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const inputBuffer = new SharedArrayBuffer(epochs.length * 8);
+const outputBuffer = new SharedArrayBuffer(epochs.length * 8);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. A typed Float64Array view is mounted over the buffer. Each 64-bit IEEE 754 double stores one millisecond timestamp.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. The workload is partitioned into balanced slices (chunkSize = Math.ceil(epochs.length / threadCount)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Each worker thread receives references to the shared memory buffers along with its assigned slice indices (startIdx, endIdx).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Workers access the shared buffers directly, mutating timestamps in place within their assigned slices, and post a lightweight { status: 'done' } signal upon completion. Shared buffer access avoids serialization and array cloning across the thread boundary.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode B: postMessage Structural Cloning (Graceful Degradation) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When running in browser environments where SharedArrayBuffer is restricted by security policies:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The orchestrator slices the input array into standard JavaScript array chunks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Slices are transferred to workers via standard postMessage({ chunk }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Workers compute results and post back the mutated array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. The main thread reassembles the chunked arrays into a single contiguous result.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Worker Process Isolation & CLI Flag Sanitization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Node.js, spawning worker threads via new Worker() automatically attempts to pass process.execArgv to child isolates. However, passing unverified process flags (such as --max-old-space-size, --eval, or custom CLI arguments) can crash worker isolates or cause memory segmentation faults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To guarantee worker stability, BatchOrchestrator implements strict ExecArgv Allowlist Sanitization:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const ALLOWED_FLAGS_WITH_VALUE = new Set([
+  '--import',
+  '--loader',
+  '--experimental-loader',
+  '-r',
+  '--require',
+]);
+
+const ALLOWED_STANDALONE_FLAGS = new Set([
+  '--experimental-vm-modules',
+  '--experimental-temporal',
+  '--experimental-specifier-resolution',
+  '--inspect',
+  '--inspect-brk',
+  '--trace-warnings',
+  '--no-warnings',
+]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any process-level flags, heap limit overrides, or execution scripts outside this allowlist are safely stripped before worker initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Performance Trade-Off: Raw Epochs vs Hydration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To maximize processing speed across large payloads (e.g., 100,000 to 5,000,000 timestamps):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConfigurationOutput TypeProcessing CharacteristicsIdeal For
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { rehydrate: false } (Default)number[]Ultra-Fast. Returns raw numeric timestamps. Zero object allocation overhead on the main thread.Telemetry ETL pipelines, database bulk inserts, streaming Kafka messages.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { rehydrate: true }Tempo[]Rich Object Surface. Main thread maps output numbers into full Tempo instances.UI display grids, domain models requiring immediate formatting or method access.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benchmark Guidance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For arrays exceeding 50,000 items, keeping { rehydrate: false } until final consumption reduces garbage collection pauses by up to 85%.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,26)])])}const g=a(n,[["render",r]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.lean.js new file mode 100644 index 00000000..1828cf04 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_batch.worker-architecture.md.CdcNvo1Q.lean.js @@ -0,0 +1 @@ +import{_ as a,o as e,c as i,a2 as t}from"./chunks/framework.DNL3hc5c.js";const k=JSON.parse('{"title":"Parallel Worker Pool & SharedArrayBuffer Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/batch.worker-architecture.md","filePath":"doc/9-plugins/batch.worker-architecture.md"}'),n={name:"doc/9-plugins/batch.worker-architecture.md"};function r(l,s,o,h,p,d){return e(),i("div",null,[...s[0]||(s[0]=[t("",26)])])}const g=a(n,[["render",r]]);export{k as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.js new file mode 100644 index 00000000..ebe3a814 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.js @@ -0,0 +1,47 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Astronomical Seasons, Solstices & Equinoxes","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.astro.md","filePath":"doc/9-plugins/celestial.astro.md"}'),e={name:"doc/9-plugins/celestial.astro.md"};function l(h,s,p,k,r,o){return a(),t("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Astronomical Seasons, Solstices & Equinoxes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explores astronomical solar quarters, equinoxes, solstices, and hemisphere-aware season calculations in @magmacomputing/tempo-plugin-celestial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Overview & Mechanics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AstroTerm (t.term.astro, t.term.astronomy, t.term.equinox, t.term.solstice) calculates the precise astronomical moments when the Sun crosses the celestial equator (Equinoxes) or reaches its northernmost / southernmost declinations (Solstices).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculations utilize the high-precision Jean Meeus solar ephemeris polynomial algorithms implemented in @magmacomputing/tempo-fns, providing sub-minute accuracy across historical and future years without requiring internet access.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Astronomical Events & Quarters ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Event KeyAstronomical EventNorthern Hemisphere SeasonSouthern Hemisphere SeasonApproximate Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'Vernal'Spring Equinox (Solar Longitude = 0°)SpringAutumnMarch 20–21
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'Summer'Summer Solstice (Solar Longitude = 90°)SummerWinterJune 20–22
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'Autumnal'Autumnal Equinox (Solar Longitude = 180°)AutumnSpringSeptember 22–23
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'Winter'Winter Solstice (Solar Longitude = 270°)WinterSummerDecember 21–22
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+// 1. Northern Hemisphere evaluation
+const summerNorth = new Tempo('2026-07-15', { sphere: 'north' });
+console.log(summerNorth.term.astro);             // 'Summer'
+console.log(summerNorth.term.astronomy.season);  // 'Summer'
+console.log(summerNorth.term.astronomy.event);   // 'Solstice'
+console.log(summerNorth.term.solstice);          // 'Summer'
+
+// 2. Southern Hemisphere evaluation (inverts seasonal labels)
+const winterSouth = new Tempo('2026-07-15', { sphere: 'south' });
+console.log(winterSouth.term.astro);             // 'Summer' (astronomy quarter key)
+console.log(winterSouth.term.astronomy.season);  // 'Winter' (actual hemisphere season)
+console.log(winterSouth.term.astronomy.event);   // 'Solstice'
+
+// 3. Automatic sphere derivation via geographic coordinates
+const sydney = new Tempo('2026-07-15', { geo: { lat: -33.8688, lng: 151.2093 } });
+console.log(sydney.sphere);                      // 'south' (auto-derived from negative latitude)
+console.log(sydney.term.astronomy.season);       // 'Winter'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Scoped Ephemeris Details (t.term.astronomy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Accessing t.term.astronomy provides the complete structured record for the active astronomical quarter:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-03-20T12:00:00Z', { sphere: 'north' });
+const astro = t.term.astronomy;
+
+console.log(astro.key);      // 'Vernal'
+console.log(astro.season);   // 'Spring'
+console.log(astro.event);    // 'Equinox'
+console.log(astro.year);     // 2026
+console.log(astro.month);    // 3
+console.log(astro.day);      // 20
+console.log(astro.hour);     // 14 (exact UTC hour of equinox)
+console.log(astro.minute);   // 45 (exact UTC minute)
+console.log(astro.start);    // Tempo instance for the quarter's start boundary
+console.log(astro.end);      // Tempo instance for the quarter's end boundary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Querying Specific Astronomical Events (t.term.equinox / t.term.solstice) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can filter queries directly for equinoxes or solstices:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const spring = new Tempo('2026-04-01', { sphere: 'north' });
+
+// Resolves only equinoxes
+console.log(spring.term.equinox);   // 'Vernal'
+
+// Resolves only solstices
+const june = new Tempo('2026-06-25', { sphere: 'north' });
+console.log(june.term.solstice);   // 'Summer'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Standalone Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you only need astronomical seasons without the other celestial ephemeris terms, you can import and register AstroTerm directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { AstroTerm } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(AstroTerm);
+
+const t = new Tempo('2026-09-23', { sphere: 'north' });
+console.log(t.term.astro); // 'Autumnal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,24)])])}const g=i(e,[["render",l]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.lean.js new file mode 100644 index 00000000..b49a7f77 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.astro.md.BAuT_4-r.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Astronomical Seasons, Solstices & Equinoxes","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.astro.md","filePath":"doc/9-plugins/celestial.astro.md"}'),e={name:"doc/9-plugins/celestial.astro.md"};function l(h,s,p,k,r,o){return a(),t("div",null,[...s[0]||(s[0]=[n("",24)])])}const g=i(e,[["render",l]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.js new file mode 100644 index 00000000..a9c3ed7e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.js @@ -0,0 +1,49 @@ +import{_ as e}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as n,C as t,o as l,c as o,a2 as i,E as p}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"@magmacomputing/tempo-plugin-celestial","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.index.md","filePath":"doc/9-plugins/celestial.index.md"}'),h={name:"doc/9-plugins/celestial.index.md"};function r(d,s,c,k,g,E){const a=t("PluginRepl");return l(),o("div",null,[s[0]||(s[0]=i('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-celestial ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Community plugin for Tempo providing location-aware solar twilight events (t.term.sun, t.term.solar), real-time lunar cycle phases (t.term.moon, t.term.lunar), and astronomical tidal mechanics (t.term.tide, t.term.tides).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore detailed guides on specific celestial capabilities:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Astronomical Seasons, Solstices & Equinoxes: Solar quarters, equinoxes, solstices, hemisphere-aware seasonal labels (t.term.astro, t.term.equinox, t.term.solstice), and sub-minute Meeus ephemeris boundaries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Solar Day Cycles & Ephemeris: Twilight bands (civil, nautical, astronomical), atmospheric elevation dip correction, exact apparent solar noon (solar.noon), and Local Apparent Solar Time (solar.solarTime).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lunar Ephemeris, Topocentric Ephemeris & Eclipses: 8 synodic lunar phases, illumination ratio, lunar age, hemisphere-aware emojis, topocentric horizon events (moonrise/moonset), meridian transits (transit), real-time sky position (altitude/azimuth), crescent tilt (crescentTiltDeg), orbital distance (isSupermoon/isMicromoon), and local solar/lunar eclipse detection (eclipse/obscuration).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Astronomical Tidal Mechanics: Syzygy, quadrature, and perigee calculations (spring, neap, king tides), solar-lunar alignment angles, and 745-minute tidal cycles.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Use Cases & Architectural Patterns: Photovoltaic microgrid inverter modes, greenhouse DLI supplemental lighting, maritime keel clearance windows, and golden hour drone flight scheduling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Features Overview ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Solar Day Cycles: Calculates daylight, night, civil-twilight, nautical-twilight, and astronomical-twilight.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Solar Ephemeris Data: Returns sunrise, sunset, noon, solarTime (Local Apparent Solar Time), total daylightDurationMs, and observer elevation horizon dip adjustments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lunar Phase & Topocentric Ephemeris: Calculates 8 discrete lunar phase states, illumination fraction (0.0–1.0), age in days, hemisphere-aware emojis, local moonrise and moonset events, meridian transit (transit), topocentric position (altitude/azimuth), bright limb crescent tilt (crescentTiltDeg), and orbital distance (distanceKm, angularDiameterArcmin, isSupermoon, isMicromoon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Eclipse Obscuration: Detects active solar and lunar eclipses ('total-solar', 'annular-solar', 'partial-solar', 'total-lunar', 'partial-lunar', 'penumbral-lunar') and computes local disk obscuration fraction (0.0 to 1.0).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Astronomical Tidal Mechanics: Provides pure astronomical solar/lunar alignment calculations (t.term.tide, t.term.tides) for spring, neap, and normal tides, alongside isKingTide perigee indicators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geographic Coordinates & Null Contract ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pure Astronomical Calculations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tidal state resolution and synodic lunar phases rely on deterministic celestial mechanics for reproducible, offset-independent math across all time zones.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Location-Dependent Null Contract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Astronomical Properties (t.term.moon, t.term.lunar.phase, t.term.lunar.illumination, t.term.tides.isSpringTide, t.term.tides.alignmentDeg) resolve location-independently and are always computed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Geo-Dependent Properties (t.term.sun, solar.sunrise, solar.sunset, solar.noon, solar.solarTime, lunar.moonrise, lunar.moonset, lunar.transit, lunar.altitude, lunar.azimuth, lunar.crescentTiltDeg, lunar.distanceKm, lunar.eclipse, lunar.obscuration, tides.lunarTideMinute) evaluate to null when geographic coordinates (geo: { lat, lng }) are omitted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Distinction: Property access on t.term evaluates to undefined if CelestialPlugin is not loaded, and to null if the plugin is active but location coordinates were not supplied. When debug >= 1 is enabled in Tempo configuration, a developer warning is logged when evaluating geo-dependent keys without coordinates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Coordinates, Sphere & Timezone Resolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sphere Derivation: Setting { geo: { lat, lng } } automatically computes the observer's hemisphere ('north', 'south', or 'equator').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • timeZone Requirement: Geographic coordinates (lat, lng) calculate the exact physical UTC moments of astronomical events, but do not auto-derive political timezone boundaries in core Tempo. Always supply an explicit timeZone (e.g. 'America/New_York' or 'UTC') to ensure local day and night ranges project deterministically across different host environments and CI runners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',21)),p(a,{plugin:"celestial"}),s[1]||(s[1]=i(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+// Provide geographic coordinates (e.g. New York City)
+const t = new Tempo('2026-06-21T12:00:00Z', {
+  timeZone: 'America/New_York',
+  geo: { lat: 40.7128, lng: -74.006 }
+});
+
+// --- Solar Day State & Ephemeris ---
+console.log(t.term.sun);                 // 'daylight'
+console.log(t.term.solar.phase);         // 'Daylight'
+console.log(t.term.solar.sunrise);       // Tempo instance for local sunrise
+console.log(t.term.solar.noon);          // Tempo instance for local solar noon
+console.log(t.term.solar.solarTime);     // Tempo instance for local apparent solar time (AST)
+
+// --- Lunar Phase & Ephemeris ---
+console.log(t.term.moon);                // 'waxing-crescent'
+console.log(t.term.lunar.phase);         // 'Waxing Crescent'
+console.log(t.term.lunar.illumination);  // 0.45
+console.log(t.term.lunar.moonrise);      // Tempo instance for local moonrise (or null)
+
+// --- Astronomical Tidal Mechanics ---
+console.log(t.term.tide);                // 'spring', 'neap', or 'normal'
+console.log(t.term.tides.alignmentDeg);  // Solar-lunar alignment angle (0..360°)
+console.log(t.term.tides.isSpringTide);  // true during Syzygy (New or Full Moon)
+console.log(t.term.tides.isKingTide);    // true when Spring Tide aligns with Lunar Perigee
+
+// --- Term Lifecycle Hooks ---
+// Snapping & stepping
+t.set('#moon.start');                    // Snap to start of active lunar phase
+t.add('#moon');                          // Step forward by 1 synodic lunation (~29.53 days)
+t.set('#solar.start');                   // Snap to sunrise
+t.set('#solar.mid');                     // Snap to solar noon
+t.add('#tide');                          // Step forward by 1 tidal cycle (745 min)
+
+// Semantic parsing & ordinals
+const nextSunrise = Tempo.from('#solar.sunrise', { anchor: t });
+const equinox = Tempo.from('1st day of #equinox', { anchor: t });
+
+// Dynamic token formatting
+console.log(t.format('Moon: {#moon.emoji} {#moon.phase} ({#moon.illumination})'));
+console.log(t.format('Sun: {#solar.phase} | Elev: {#solar.elevation}'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-celestial/install';
+
+const t = new Tempo('2026-06-21T12:00:00Z', { geo: { lat: 40.7128, lng: -74.006 } });
+console.log(t.term.sun);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,6))])}const F=n(h,[["render",r]]);export{y as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.lean.js new file mode 100644 index 00000000..7cc50d32 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.index.md.BEuS8lC9.lean.js @@ -0,0 +1 @@ +import{_ as e}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as n,C as t,o as l,c as o,a2 as i,E as p}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"@magmacomputing/tempo-plugin-celestial","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.index.md","filePath":"doc/9-plugins/celestial.index.md"}'),h={name:"doc/9-plugins/celestial.index.md"};function r(d,s,c,k,g,E){const a=t("PluginRepl");return l(),o("div",null,[s[0]||(s[0]=i("",21)),p(a,{plugin:"celestial"}),s[1]||(s[1]=i("",6))])}const F=n(h,[["render",r]]);export{y as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.js new file mode 100644 index 00000000..941664de --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.js @@ -0,0 +1,62 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Lunar Ephemeris, Phases & Topocentric Position","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.lunar.md","filePath":"doc/9-plugins/celestial.lunar.md"}'),e={name:"doc/9-plugins/celestial.lunar.md"};function l(h,s,p,k,r,o){return a(),t("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lunar Ephemeris, Phases & Topocentric Position ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide covers synodic lunar phase cycles, illumination ratio, lunar age, hemisphere-aware emoji rendering, topocentric horizon events (moonrise/moonset), meridian transits, real-time sky position (altitude/azimuth), crescent tilt orientation, distance, and supermoon/micromoon identification in @magmacomputing/tempo-plugin-celestial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lunar Phase Cycles (t.term.moon / t.term.lunar) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LunarTerm models the 29.53-day synodic month across 8 discrete phases:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phase KeyPhase NameIllumination (%)Age (Days)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'new-moon'New Moon0%0.0 - 3.7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'waxing-crescent'Waxing Crescent1% - 49%3.7 - 7.4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'first-quarter'First Quarter50%7.4 - 11.1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'waxing-gibbous'Waxing Gibbous51% - 99%11.1 - 14.8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'full-moon'Full Moon100%14.8 - 18.5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'waning-gibbous'Waning Gibbous99% - 51%18.5 - 22.1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'third-quarter'Third Quarter50%22.1 - 25.8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'waning-crescent'Waning Crescent49% - 1%25.8 - 29.53
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+const t = new Tempo('2026-03-03T12:00:00Z', { sphere: 'north' });
+
+console.log(t.term.moon);               // 'full-moon'
+console.log(t.term.lunar.phase);        // 'Full Moon'
+console.log(t.term.lunar.index);        // 5 (1-based index)
+console.log(t.term.lunar.illumination); // 1.0
+console.log(t.term.lunar.ageDays);      // ~14.8 days
+console.log(t.term.lunar.isWaxing);     // false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Hemisphere-Aware Visual Emoji (lunar.emoji) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because the Moon's illuminated crescent appears reversed between the Northern and Southern Hemispheres, configuring sphere: 'south' (or passing negative latitude coordinates) adjusts visual emoji indicators:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const north = new Tempo('2026-06-18', { sphere: 'north' });
+console.log(north.term.lunar.emoji); // 🌒 (Waxing Crescent - North)
+
+const south = new Tempo('2026-06-18', { sphere: 'south' });
+console.log(south.term.lunar.emoji); // 🌘 (Waxing Crescent - South)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Location-Aware Horizon & Transit Events ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When geographic coordinates are supplied, LunarTerm resolves observer-specific topocentric rise, set, and upper meridian culmination events:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: -33.8688, lng: 151.2093 } // Sydney
+});
+
+if (t.term.lunar.moonrise) {
+  console.log('Moonrise:', t.term.lunar.moonrise.format('{hh}:{mi}'));
+}
+
+if (t.term.lunar.transit) {
+  console.log('Meridian Transit (highest altitude):', t.term.lunar.transit.format('{hh}:{mi}'));
+}
+
+if (t.term.lunar.moonset) {
+  console.log('Moonset:', t.term.lunar.moonset.format('{hh}:{mi}'));
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Real-Time Topocentric Sky Position ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LunarTerm computes the real-time apparent position of the Moon in the observer's sky, corrected for horizontal parallax and atmospheric refraction:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • altitude: Degrees above (+) or below (-) the local horizon (-90°..90°).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • azimuth: Compass bearing in degrees (0°..360°, where North = 0°, East = 90°, South = 180°, West = 270°).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isAboveHorizon: Boolean flag indicating if the Moon is currently above the local horizon.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-09-02T12:00:00Z', {
+  geo: { lat: 51.5074, lng: -0.1278 } // London
+});
+
+console.log('Altitude:', t.term.lunar.altitude);             // e.g. 42.15°
+console.log('Azimuth:', t.term.lunar.azimuth);               // e.g. 172.84° (South-Southeast)
+console.log('Visible in Sky:', t.term.lunar.isAboveHorizon); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Crescent Tilt & Bright Limb Angle (lunar.crescentTiltDeg) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The visual orientation of the Moon's illuminated crescent relative to the zenith depends on observer latitude and local hour angle:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In tropical and equatorial latitudes (|lat| < 23.5°), the crescent appears "lying on its back" (the Wet Moon or Cheshire Cat Moon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In polar and temperate latitudes, the crescent appears upright.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • crescentTiltDeg resolves the angle (0°..360°) relative to the local vertical (Zenith), enabling pixel-accurate SVG and UI canvas rendering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const singapore = new Tempo('2026-09-15T12:00:00Z', {
+  geo: { lat: 1.3521, lng: 103.8198 } // Equatorial latitude
+});
+
+console.log('Crescent Tilt (Zenith-relative):', singapore.term.lunar.crescentTiltDeg); // ~92.4°

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Distance, Apparent Size, Supermoons & Micromoons ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Moon's elliptical orbit causes its distance from Earth to fluctuate between ~356,400 km (perigee) and ~406,700 km (apogee):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • distanceKm: Topocentric distance from observer to the Moon in kilometers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • angularDiameterArcmin: Apparent visual size of the lunar disk in arcminutes (~29.3' to 34.1').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isSupermoon: true when a Full Moon or New Moon occurs near perigee (distance ≤ 362,000 km).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isMicromoon: true when a Full Moon or New Moon occurs near apogee (distance ≥ 404,000 km).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const huntersMoon = new Tempo('2024-10-17T11:26:00Z', {
+  geo: { lat: 40.7128, lng: -74.006 }
+});
+
+console.log('Distance (km):', huntersMoon.term.lunar.distanceKm); // ~357,364 km
+console.log('Angular Diameter:', huntersMoon.term.lunar.angularDiameterArcmin); // ~33.43 arcmin
+console.log('Is Supermoon:', huntersMoon.term.lunar.isSupermoon); // true
+console.log('Is Micromoon:', huntersMoon.term.lunar.isMicromoon); // false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Local Solar & Lunar Eclipse Obscuration (lunar.eclipse & lunar.obscuration) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LunarTerm provides real-time local eclipse classification and disk obscuration fraction based on the observer's geographic coordinates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • eclipse: Detects active eclipses ('total-solar', 'annular-solar', 'partial-solar', 'total-lunar', 'partial-lunar', 'penumbral-lunar', or null).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • obscuration: Fraction of the solar or lunar disk obscured for the observer (0.0 to 1.0).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Solar Eclipse (April 8, 2024 - Dallas, TX)
+const solarEclipse = new Tempo('2024-04-08T18:40:00Z', {
+  geo: { lat: 32.7767, lng: -96.7970 }
+});
+
+console.log('Active Eclipse:', solarEclipse.term.lunar.eclipse);       // e.g. 'partial-solar' / 'total-solar'
+console.log('Disk Obscuration:', solarEclipse.term.lunar.obscuration); // e.g. 0.60 .. 1.0
+
+// Lunar Eclipse (May 16, 2022 - New York, NY)
+const lunarEclipse = new Tempo('2022-05-16T04:12:00Z', {
+  geo: { lat: 40.7128, lng: -74.0060 }
+});
+
+console.log('Active Eclipse:', lunarEclipse.term.lunar.eclipse);       // 'total-lunar'
+console.log('Disk Obscuration:', lunarEclipse.term.lunar.obscuration); // 1.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,37)])])}const g=i(e,[["render",l]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.lean.js new file mode 100644 index 00000000..36bc3ac1 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.lunar.md.De_P3K-r.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as n}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Lunar Ephemeris, Phases & Topocentric Position","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.lunar.md","filePath":"doc/9-plugins/celestial.lunar.md"}'),e={name:"doc/9-plugins/celestial.lunar.md"};function l(h,s,p,k,r,o){return a(),t("div",null,[...s[0]||(s[0]=[n("",37)])])}const g=i(e,[["render",l]]);export{E as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.js new file mode 100644 index 00000000..b44bc30d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.js @@ -0,0 +1,57 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Solar Day Cycles, Ephemeris & Apparent Solar Time","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.solar.md","filePath":"doc/9-plugins/celestial.solar.md"}'),n={name:"doc/9-plugins/celestial.solar.md"};function l(h,s,p,k,o,r){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Solar Day Cycles, Ephemeris & Apparent Solar Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide covers solar twilight state classifications, horizon dip elevation adjustments, exact solar noon, Local Apparent Solar Time (AST), real-time horizontal coordinates, photometric lighting phases, and polar day/night handling in @magmacomputing/tempo-plugin-celestial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Solar Phase States (t.term.sun / t.term.solar) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SolarTerm classifies the solar day into 5 deterministic states based on the Sun's center angle relative to the local geometric horizon:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Solar StateSolar Elevation Angle (α)Description
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'daylight'α ≥ -0.833° - dipSun is above the visible horizon. Full natural illumination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'civil-twilight'-6° ≤ α < -0.833° - dipBright twilight. Terrestrial objects are clearly distinguishable without artificial light.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'nautical-twilight'-12° ≤ α < -6°Medium twilight. Sea horizon is faintly visible; first-magnitude navigation stars appear.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'astronomical-twilight'-18° ≤ α < -12°Dark twilight. Sun no longer illuminates the sky; fainter stars become visible.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'night'α < -18°Total astronomical darkness.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+const t = new Tempo('2026-06-21T12:00:00Z', {
+  timeZone: 'America/New_York',
+  geo: { lat: 40.7128, lng: -74.006 }
+});
+
+console.log(t.term.sun);          // 'daylight'
+console.log(t.term.solar.key);    // 'daylight'
+console.log(t.term.solar.phase);  // 'Daylight'
+console.log(t.term.solar.phases); // ['night', 'astronomical-twilight', 'nautical-twilight', 'civil-twilight', 'daylight']

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explicit Timezone Pairing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While { geo: { lat, lng } } automatically determines sphere, it does not auto-infer political timezone rules. Always pair geographic coordinates with an explicit timeZone (e.g. 'America/New_York' or 'UTC') to ensure twilight ranges and day/night boundary timestamps project deterministically across all environments (including CI runners and cloud servers).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Apparent Solar Noon (t.term.solar.noon) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.term.solar.noon returns a Tempo instance representing the exact moment of the Sun's transit across the local observer's celestial meridian (the highest solar altitude of the day).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-06-21T12:00:00Z', { geo: { lat: 40.7128, lng: -74.006 } });
+
+const solarNoon = t.term.solar.noon;
+console.log(solarNoon.iso); // e.g. "2026-06-21T16:57:21.134Z"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Local Apparent Solar Time (t.term.solar.solarTime) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Local Apparent Solar Time (AST) is the time measured directly by the apparent position of the Sun (a true solar sundial clock).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It incorporates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Observer longitudinal displacement: Δλ × 4 min/deg from the Prime Meridian.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Equation of Time (EoT): accounting for Earth's orbital eccentricity and axial tilt (≈ -14 to +16 minutes variance across the year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    At the exact moment of solar noon, solarTime aligns to 12:00:00.000.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-06-21T12:00:00Z', { geo: { lat: 40.7128, lng: -74.006 } });
+
+// Query apparent solar time at current moment
+const ast = t.term.solar.solarTime;
+console.log(ast.format('{hh}:{mi}:{ss}')); // Local solar clock time
+
+// At exact solar noon:
+const atNoon = new Tempo(t.term.solar.noon.epoch.ms, { geo: { lat: 40.7128, lng: -74.006 } });
+console.log(atNoon.term.solar.solarTime.format('{hh}:{mi}:{ss}')); // "12:00:00"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Atmospheric Elevation Dip Correction (elevation) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Observers at higher elevations experience an expanded visible horizon due to geometric horizon dip:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dip ≈ 0.0347° × √(elevation_meters)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing elevation (in meters) automatically adjusts sunrise, sunset, and twilight timestamps:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Denver observer at 1,600 meters elevation
+const denver = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: 39.7392, lng: -104.9903, elevation: 1600 }
+});
+
+console.log(denver.term.solar.elevation);          // 1600
+console.log(denver.term.solar.daylightDurationMs); // Longer daylight duration than sea level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Real-Time Solar Coordinates & Photometric Hours ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When geographic coordinates are present, SolarTerm exposes topocentric horizontal coordinates and photography lighting metrics:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    altitudenumber | nullTopocentric solar elevation angle in degrees above (+) or below (-) horizon (-90°..+90°).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    azimuthnumber | nullSolar compass bearing in degrees (0°..360°, where 0° = North, 90° = East, 180° = South, 270° = West).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zenithnumber | nullAngular distance in degrees from the overhead zenith (90° - altitude).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isGoldenHourboolean | nullTrue when solar altitude is between -4° and +6° (warm, diffused sunlight).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBlueHourboolean | nullTrue when solar altitude is between -6° and -4° (deep blue twilight sky).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shadowRationumber | nullVertical object shadow length multiplier (cot(altitude)), or null when Sun is below the horizon.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sydney = new Tempo('2026-12-21T02:00:00Z', {
+  geo: { lat: -33.8688, lng: 151.2093 }
+});
+
+console.log(sydney.term.solar.altitude);     // e.g. 78.5°
+console.log(sydney.term.solar.azimuth);      // Compass bearing in degrees
+console.log(sydney.term.solar.shadowRatio);  // Object shadow multiplier
+console.log(sydney.term.solar.isGoldenHour); // false
+console.log(sydney.term.solar.isBlueHour);   // false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Polar Regions Handling (Midnight Sun & Polar Night) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In high-latitude regions (|lat| > 66.5°), the Sun may remain continuously above or below the horizon for extended periods:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isMidnightSun: true on dates when the Sun remains continuously above the visible horizon for 24 hours. sunrise and sunset evaluate to null, daylightDurationMs is 86,400,000 ms, and key remains 'daylight'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isPolarNight: true on dates when the Sun does not rise above the visible horizon. sunrise and sunset evaluate to null, daylightDurationMs is 0 ms, and key transitions between twilight states (such as 'civil-twilight' at midday) and total 'night'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Tromsø, Norway (69.65° N) on Summer Solstice
+const midnightSun = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: 69.6492, lng: 18.9553 }
+});
+
+console.log(midnightSun.term.solar.isMidnightSun); // true
+console.log(midnightSun.term.solar.sunrise);       // null
+console.log(midnightSun.term.solar.isDaylight);    // true
+
+// Tromsø, Norway on Winter Solstice
+const polarNight = new Tempo('2026-12-21T12:00:00Z', {
+  geo: { lat: 69.6492, lng: 18.9553 }
+});
+
+console.log(polarNight.term.solar.isPolarNight);   // true
+console.log(polarNight.term.solar.key);            // 'civil-twilight' at midday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Twilight Range Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.term.solar.civil, t.term.solar.nautical, and t.term.solar.astronomical provide sub-objects with sunrise and sunset Tempo instances for each twilight band:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const { civil, nautical, astronomical } = t.term.solar;
+
+console.log(civil.sunrise?.format('{hh}:{mi}')); // Civil dawn
+console.log(civil.sunset?.format('{hh}:{mi}'));  // Civil dusk
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,41)])])}const c=i(n,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.lean.js new file mode 100644 index 00000000..46e4068a --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.solar.md.DC44WQqc.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Solar Day Cycles, Ephemeris & Apparent Solar Time","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.solar.md","filePath":"doc/9-plugins/celestial.solar.md"}'),n={name:"doc/9-plugins/celestial.solar.md"};function l(h,s,p,k,o,r){return a(),t("div",null,[...s[0]||(s[0]=[e("",41)])])}const c=i(n,[["render",l]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.js new file mode 100644 index 00000000..509394ff --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.js @@ -0,0 +1,28 @@ +import{_ as s,o as t,c as a,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Astronomical Tidal Mechanics & Coastal Predictions","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.tidal.md","filePath":"doc/9-plugins/celestial.tidal.md"}'),n={name:"doc/9-plugins/celestial.tidal.md"};function l(h,i,r,d,p,o){return t(),a("div",null,[...i[0]||(i[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Astronomical Tidal Mechanics & Coastal Predictions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explores astronomical tidal state classification, syzygy and quadrature alignment, perigee factors, King Tide indicators, local coastal tide predictions, and lunitidal port calibration in @magmacomputing/tempo-plugin-celestial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Deterministic Astronomical Calculations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tidal state resolution in TidalTerm (t.term.tide, t.term.tides) relies purely on deterministic celestial mechanics:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ecliptic Longitude Delta (Δλ): The angular separation between the Sun and the Moon.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anomalistic Month Perigee Proximity: The Moon's orbital distance from Earth along its elliptical orbit (perigee vs. apogee).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Meridian Transit Geometry: Lunar upper and lower culminations relative to observer longitude.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Tidal States (t.term.tide / t.term.tides.state) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tidal StateAstronomical MechanismImpact on Water Levels
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'spring'Syzygy (Δλ ≈ 0° New Moon or 180° Full Moon). Gravitational forces of Sun and Moon constructively reinforce.Maximum tidal range (highest high tides, lowest low tides).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'neap'Quadrature (Δλ ≈ 90° First Quarter or 270° Third Quarter). Gravitational forces act orthogonally.Minimum tidal range (moderate high tides, moderate low tides).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'normal'Intermediate orbital positions between syzygy and quadrature.Standard daily tidal fluctuations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+const t = new Tempo('2026-03-03T12:00:00Z', {
+  geo: { lat: -33.8688, lng: 151.2093 }
+});
+
+console.log(t.term.tide);               // 'spring', 'neap', or 'normal'
+console.log(t.term.tides.alignmentDeg); // Angular separation (0..360°)
+console.log(t.term.tides.isSpringTide); // true during New or Full Moon
+console.log(t.term.tides.isNeapTide);   // true during 1st or 3rd Quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. King Tides & Perigee Factor (isKingTide / perigeeFactor) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A King Tide (Perigean Spring Tide) occurs when a Spring Tide (New or Full Moon) coincides with the Moon at or near its closest orbital approach to Earth (Perigee).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • perigeeFactor: Normalized metric from 0.0 (Apogee, farthest) to 1.0 (Perigee, closest).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • isKingTide: Evaluates to true when isSpringTide === true and perigeeFactor >= 0.75.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (t.term.tides.isKingTide) {
+  console.warn('King Tide Warning: Expect exceptionally high astronomical tides!');
+  console.log('Perigee Proximity Factor:', t.term.tides.perigeeFactor);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Local Coastal Tide Predictions & Port Calibration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When observer coordinates are supplied, TidalTerm calculates the upcoming local high and low tides based on lunar meridian transits and local hydrodynamic port lag (lunitidal interval):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextHighTideTempo | nullTempo instance for the estimated local high tide anchored to observer coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextLowTideTempo | nullTempo instance for the estimated local low tide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lunitidalIntervalMinnumber | nullPort-specific hydrodynamic phase lag offset in minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    regime'semi-diurnal' | 'diurnal' | 'mixed' | nullTidal cycle pattern for the region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sydney = new Tempo('2026-03-03T12:00:00Z', {
+  geo: { lat: -33.8688, lng: 151.2093 }
+});
+
+console.log(sydney.term.tides.nextHighTide?.iso); // e.g. "2026-03-03T15:24:10.000Z"
+console.log(sydney.term.tides.nextLowTide?.iso);  // e.g. "2026-03-03T21:36:46.000Z"
+console.log(sydney.term.tides.regime);           // 'semi-diurnal'
+
+// Custom Port Calibration (e.g. 110-minute port lag)
+const portCalibrated = new Tempo('2026-03-03T12:00:00Z', {
+  geo: { lat: -33.8688, lng: 151.2093, lunitidalIntervalMin: 110 }
+});
+console.log(portCalibrated.term.tides.lunitidalIntervalMin); // 110

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Lunar Tidal Cycle Minutes (lunarTideMinute) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When geographic coordinates are supplied, t.term.tides.lunarTideMinute reports the current minute within the 745.2-minute semi-diurnal lunar tidal cycle (≈ 12 hours 25.2 minutes between successive lunar culminations).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,25)])])}const g=s(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.lean.js new file mode 100644 index 00000000..f89e2f8f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.tidal.md.Bptft1Ks.lean.js @@ -0,0 +1 @@ +import{_ as s,o as t,c as a,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Astronomical Tidal Mechanics & Coastal Predictions","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.tidal.md","filePath":"doc/9-plugins/celestial.tidal.md"}'),n={name:"doc/9-plugins/celestial.tidal.md"};function l(h,i,r,d,p,o){return t(),a("div",null,[...i[0]||(i[0]=[e("",25)])])}const g=s(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.js new file mode 100644 index 00000000..628fb6e9 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.js @@ -0,0 +1,117 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.use-cases-and-patterns.md","filePath":"doc/9-plugins/celestial.use-cases-and-patterns.md"}'),t={name:"doc/9-plugins/celestial.use-cases-and-patterns.md"};function h(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[l(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Civil clock time is an artificial human construct based on standardized 15° meridian bands. Physical systems on Earth—such as photovoltaic solar generators, agricultural crop lighting, maritime coastal navigation, and astronomical observations—are governed strictly by planetary physics:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Solar Position: True apparent solar noon, solar azimuth, elevation angles, and twilight boundaries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Lunar Mechanics: Illumination fractions, moonrise/moonset events, topocentric distance, and supermoons.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Gravitational Tides: Semi-diurnal high/low water, spring/neap tide cycles, and perigean king tides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-celestial plugin provides 100% offline, zero-network mathematical ephemeris calculations directly integrated with Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Photovoltaic (PV) Solar Inverter & Battery Storage Orchestration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In industrial microgrids and commercial battery energy storage systems (BESS), fixed-angle and single-axis solar arrays produce power as a function of the sun's altitude angle above the physical horizon.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than relying on static clock intervals (e.g. 12:00 PM), control systems query true solar elevation and apparent solar noon to dynamically switch inverter modes between grid-export, self-consumption, and battery absorption:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+export function evaluateInverterMode(
+  currentTime: string,
+  facilityCoordinates: { latitude: number; longitude: number }
+): { mode: 'PEAK_EXPORT' | 'CHARGING' | 'STANDBY'; solarElevationDeg: number } {
+  const t = new Tempo(currentTime, { geo: facilityCoordinates });
+  const solar = t.term.solar;
+  const altitude = solar.altitude ?? 0;
+
+  // Peak irradiance window: solar altitude > 45°
+  if (altitude > 45) {
+    return { mode: 'PEAK_EXPORT', solarElevationDeg: Math.round(altitude) };
+  }
+
+  // Active generating daylight: solar altitude > 10°
+  if (altitude > 10) {
+    return { mode: 'CHARGING', solarElevationDeg: Math.round(altitude) };
+  }
+
+  // Low sun or night: standby mode
+  return { mode: 'STANDBY', solarElevationDeg: Math.round(altitude) };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Smart Agriculture & Greenhouse Supplemental Lighting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Commercial greenhouse automation systems target a precise Daily Light Integral (DLI)—the total volume of photosynthetically active radiation (PAR) received by crops each day. Supplemental LED grow lights should only illuminate when natural daylight dips below target thresholds or during specific twilight windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using t.term.solar, environmental control engines automatically schedule lighting around exact civil twilight and golden hour boundaries:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+export function getGreenhouseLightingPlan(
+  farmLat: number,
+  farmLng: number,
+  targetDate: string
+) {
+  const noon = new Tempo(\`\${targetDate} 12:00:00\`, {
+    geo: { latitude: farmLat, longitude: farmLng }
+  });
+
+  const solar = noon.term.solar;
+
+  return {
+    date: targetDate,
+    totalDaylightHours: ((solar.daylightDurationMs ?? 0) / 3_600_000).toFixed(1),
+    morningLightsOff: solar.civil.sunrise?.format('{hh}:{mi}'),
+    eveningLightsOn: solar.goldenHour?.start?.format('{hh}:{mi}') ?? solar.sunset?.format('{hh}:{mi}'),
+    nightModeAt: solar.civil.sunset?.format('{hh}:{mi}')
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Maritime Shipping & Coastal Keel Clearance Windows ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deep-draft container ships and bulk cargo vessels entering shallow ports, river estuaries, or tidal locks must plan arrival times around High Water (HW) to ensure safe Under-Keel Clearance (UKC).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.term.tides resolves tidal states, spring/neap alignment, and predicted high-tide windows from observer coordinates and port lunitidal intervals:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+export function checkPortKeelClearance(
+  estimatedArrival: string,
+  port: { latitude: number; longitude: number; lunitidalIntervalMin: number; name: string }
+) {
+  const arrival = new Tempo(estimatedArrival, { geo: port });
+  const tides = arrival.term.tides;
+
+  return {
+    port: port.name,
+    arrivalIso: arrival.format('{yyyy}-{mm}-{dd} {hh}:{mi}'),
+    tideState: tides.state,              // 'high' | 'low' | 'flood' | 'ebb' | 'normal'
+    isSpringTide: tides.isSpringTide,    // Maximum tidal amplitude
+    isKingTide: tides.isKingTide,        // Perigean syzygy high water
+    nextHighTide: tides.nextHighTide?.format('{yyyy}-{mm}-{dd} {hh}:{mi}')
+  };
+}
+
+// Example: Vessel arriving near Hamburg Port (Elbe estuary)
+const transit = checkPortKeelClearance('2026-09-15 14:00:00', {
+  name: 'Port of Hamburg',
+  latitude: 53.5511,
+  longitude: 9.9937,
+  lunitidalIntervalMin: 320
+});
+
+console.log(transit.nextHighTide); // '2026-09-15 17:26'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Drone Surveying & Architectural Golden Hour Scheduling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Aerial drone photogrammetry and architectural cinematography require planning flights during either the Golden Hour (soft, warm shadows when solar altitude is between -4° and 6°) or the Blue Hour (deep diffused blue hues during nautical twilight).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than querying external weather websites, video production applications can calculate these windows for any GPS coordinate across the globe:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+export function isOptimalShootingCondition(
+  timestamp: string,
+  latitude: number,
+  longitude: number
+): { isGoldenHour: boolean; isBlueHour: boolean; sunAltitude: number } {
+  const flightTime = new Tempo(timestamp, { geo: { latitude, longitude } });
+  const solar = flightTime.term.solar;
+
+  return {
+    isGoldenHour: solar.isGoldenHour ?? false,
+    isBlueHour: solar.isBlueHour ?? false,
+    sunAltitude: Math.round(solar.altitude ?? 0)
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Wildlife Tracking & Nocturnal Ecological Monitoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Marine biologists and ecological field teams studying nocturnal wildlife behavior (such as sea turtle nesting, coral spawning, or bat emergence) schedule observation shifts based on the lunar cycle and moonlight illumination levels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using t.term.lunar, research software calculates illumination fractions, lunar phases, and moonrise/moonset without needing an internet connection:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.use(CelestialPlugin);
+
+export function getNightSurveyContext(dateIso: string, lat: number, lng: number) {
+  const surveyTime = new Tempo(\`\${dateIso} 22:00:00\`, {
+    geo: { latitude: lat, longitude: lng }
+  });
+
+  const lunar = surveyTime.term.lunar;
+
+  return {
+    date: dateIso,
+    moonPhase: lunar.phase,                             // e.g. 'First Quarter'
+    illuminationPct: Math.round(lunar.illumination * 100), // e.g. 34%
+    isWaxing: lunar.isWaxing,
+    isSupermoon: lunar.isSupermoon ?? false,
+    moonrise: lunar.moonrise?.format('{hh}:{mi}') ?? 'None'
+  };
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,31)])])}const o=i(t,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.lean.js new file mode 100644 index 00000000..18cd8380 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_celestial.use-cases-and-patterns.md.Bt45gZQ8.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/celestial.use-cases-and-patterns.md","filePath":"doc/9-plugins/celestial.use-cases-and-patterns.md"}'),t={name:"doc/9-plugins/celestial.use-cases-and-patterns.md"};function h(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[l("",31)])])}const o=i(t,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.js new file mode 100644 index 00000000..4307c66a --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.js @@ -0,0 +1 @@ +import{_ as n,o as d,c as l,a2 as a,j as e,a as o}from"./chunks/framework.DNL3hc5c.js";const w=JSON.parse('{"title":"Design Strategy & Deliberate Omissions","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.design-philosophy-and-omissions.md","filePath":"doc/9-plugins/dialects.design-philosophy-and-omissions.md"}'),i={name:"doc/9-plugins/dialects.design-philosophy-and-omissions.md"},s={tabindex:"0"},r={style:{"text-align":"left"}},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.206ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1859 522","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.206ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1859 522","aria-hidden":"true"};function u(p,t,h,f,x,b){return d(),l("div",null,[t[26]||(t[26]=a('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Design Strategy & Deliberate Omissions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why Tempo Chose {token:modifier} Over Historical Dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-dialects plugin exists to provide complete interoperability and zero-downtime migration paths for codebases written in Moment.js, Day.js, Luxon, date-fns, POSIX strftime, PHP, and SQL TO_CHAR.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    However, when engineering Tempo's native formatting engine, we deliberately chose not to adopt any single historical token system. Decades of formatting history have accumulated conflicting token semantics, capitalization traps, and combinatorial token explosions that frequently cause catastrophic production bugs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document outlines the architectural principles behind Tempo's {token:modifier} syntax and explains the specific dialect features we deliberately chose to omit.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏛️ Part A: The Token:Modifier Design Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's format syntax is founded on four core principles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The All-Lowercase Principle: Eliminating the Capitalization Trap ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In historical dialects, a single shift-key difference changes the entire semantic target of a format string. This is the single largest source of date-formatting bugs in modern software:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Month vs. Minute (MM vs mm): In Moment, LDML, and SQL, MM is month and mm is minute. An accidental typo like HH:MM:ss silently formats the month where minutes should appear.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The New Year Billing Catastrophe (YYYY vs yyyy): In Unicode LDML specifications, yyyy represents the standard calendar year, while YYYY represents a week-numbering year. Implementations diverge significantly: Luxon uses kkkk for the ISO week-numbering year, while date-fns throws an error on YYYY by default unless its useAdditionalWeekYearTokens option is explicitly enabled. Under ISO week rules, an erroneous format mask using a week-numbering year like YYYY-MM-dd outputs 2026-12-31 on December 31, 2025 because that day belongs to Week 1 of 2026. This subtle discrepancy has repeatedly broken payment gateways, reporting systems, and billing pipelines across the tech industry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Day of Month vs. Day of Week (D vs d): In Moment, D is day of month (1-31) and d is day of week (0-6). In LDML, d is day of month (1-31) and e / c is day of week.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo Solution:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All primary Tempo format tokens are strictly lowercase and uniquely named:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {yyyy}: 4-digit calendar year (2026)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {yy}: 2-digit calendar year (26)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {yow}: 4-digit ISO week-numbering year (2026)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mm}: Zero-padded month (01-12)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mi}: Zero-padded minute (00-59)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dd}: Zero-padded day of month (01-31)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {hh}: 24-hour clock (00-23)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {h12}: 12-hour clock (01-12)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {ss}: Zero-padded second (00-59)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You never need to remember whether a token was uppercase or lowercase. Capitalization in Tempo is reserved strictly for modifier transformations (e.g. :upper, :lower, :title).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Getter-to-Token Symmetry: Zero Context Switching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In legacy libraries, there is a total disconnect between how you read a property in code and how you format it in a template:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConceptNative JS / Moment MethodLegacy Format TokenTempo Getter PropertyNative Tempo Format Token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Yeard.getFullYear()YYYY / yyyy / %Yt.yy{yyyy} ({yy} for 2-digit)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Monthd.getMonth() + 1MM / %m / mt.mm{mm}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dayd.getDate()DD / dd / %dt.dd{dd}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hour (24h)d.getHours()HH / %H / Ht.hh{hh}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Minuted.getMinutes()mm / %M / it.mi{mi}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Secondd.getSeconds()ss / %S / st.ss{ss}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Millisecondd.getMilliseconds()SSS / %f / vt.ms{ms}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO Week Yeard.isoWeekYear()GGGG / YYYY / %Gt.yow{yow}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO Weekd.isoWeek()WW / ww / %Vt.woy{woy}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekdayd.isoWeekday()E / %u / Nt.dow{dow}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you learn Tempo's instance properties, you have already learned the format tokens. There is zero mental translation required between writing business logic (if (t.hh >= 12)) and writing format strings ("{hh}:{mi}"). Note that while t.yy yields the full year number in code, {yyyy} formats the 4-digit year and {yy} formats the 2-digit year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Composable Modifiers vs. Combinatorial Token Explosion ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical dialects solve formatting variations by inventing hundreds of arbitrary, single-purpose tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • LDML: M, MM, MMM, MMMM, MMMMM, L, LL, LLL, LLLL, LLLLL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • POSIX strftime: %b, %B, %h, %m, %-m, %_m, %d, %-d, %e, %j
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Moment: D, DD, Do, DDD, DDDD, DDDo, d, dd, ddd, dddd, do

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Developers cannot realistically memorize all these tokens, leading to constant documentation lookups.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo Solution:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo decouples the semantic data token from its presentation modifier. Modifiers are composable and chainable using a colon (:):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modifiers AppliedExpressionOutput (for 2026-10-24 15:05:09)Description
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None (default){mon}OctoberBase token (capitalized name)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :upper{mon:upper}OCTOBERForced uppercase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :lower{mon:lower}octoberForced lowercase
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :short{mon:short}OctAbbreviated name (alias: {mmm})
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :locale{mon:locale}octobre (in French)Full localized name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :locale:title{mon:locale:title}OctobreLocalized name with title-casing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :ord{dd:ord}24thOrdinal suffix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :raw{mi:raw}5Unpadded number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :space{dd:space} 4 (for day 4)Space-padded instead of zero-padded
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :<width>{yyyy:-2}26Sliced to last 2 digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :roman{mm:roman}XRoman numeral representation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :roman:lower{mm:roman:lower}xLowercase Roman numeral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of memorizing dozens of distinct tokens, developers learn a small set of orthogonal modifiers (:ord, :raw, :upper, :locale, :space) that can be applied consistently across any token.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Braced Architecture vs. Literal Escaping Nightmares ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In historical libraries, arbitrary literal text embedded in format strings is notoriously fragile:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Moment / Day.js: Requires square brackets ([Recorded on] YYYY-MM-DD). Forgetting brackets results in Recorded on converting characters like d, e, and o into date parts. Escaping an actual bracket requires [\\[nested\\]].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unicode LDML: Requires single quotes ('Recorded on' yyyy-MM-dd). Literal single quotes are doubled ('It''s time').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Go time.Format: Has no escape mechanism whatsoever. Literal text containing Go reference tokens (Jan, Mon, 1, 2, 02, 2006) cannot be escaped and will unpredictably mutate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • POSIX strftime: A literal percent sign is written as %%.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo Solution:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Tempo, all text outside curly braces is literal by default:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.format("Recorded on {yyyy}-{mm}-{dd} at {hh}:{mi}!");\n// "Recorded on 2026-10-24 at 15:30!"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To print literal braces, simply double them: {{ produces { and }} produces }. No quotes, brackets, or backslash escapes needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚫 Part B: Deliberate Omissions & Architectural Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building the @magmacomputing/tempo-plugin-dialects compatibility engine, we identified several legacy dialect behaviors that we deliberately chose not to adopt into native Tempo or promote as best practices:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Non-ISO Locale Week-Numbering Years (Moment gggg / gg) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Legacy Behavior: Moment's gggg and gg compute week-numbering years based on the locale's first day of the week (e.g. Sunday in the US, Monday in ISO, Saturday in the Middle East). In contrast, PHP o and POSIX %G strictly compute the ISO 8601 week-numbering year, which Tempo directly supports via {yow}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Why We Omitted It: Locale-dependent week-year calculations lack an unambiguous international standard. In the US, week 1 is often defined simply as the week containing January 1st, whereas ISO 8601 requires week 1 to contain the first Thursday (or 4 days in January). This divergence creates non-deterministic calendar drift across client machines depending on their browser locale. Tempo anchors strictly to the international ISO 8601 standard ({yow}, {woy}, {dow}) by default, guaranteeing consistent results across all runtime environments, while allowing explicit opt-in to locale-based week numbering via {yow:locale} and {woy:locale}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Confusing 1–24 and 0–11 Hour Systems (LDML k / K) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Legacy Behavior: LDML defines k (hours 1–24, where midnight is 24) and K (hours 0–11 for 12-hour clocks, where midnight is 0 AM and noon is 0 PM).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Why We Omitted It: Representing midnight as 24:00:00 or noon as 0:00 PM is widely recognized as a source of confusion that causes parsing edge cases and serialization bugs. Tempo provides standard 24-hour ({hh}) and standard 12-hour ({h12}). When localized display conventions are required, applying :locale (e.g. {hh:locale}) queries the underlying ECMAScript Intl engine to seamlessly adopt the target locale's preferred hourCycle (h11, h12, h23, or h24).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Duplicate Standalone vs. Format Inflections (LDML LLLL vs MMMM, cccc vs EEEE) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Legacy Behavior: In inflected languages (such as Russian, Polish, or Finnish), month and weekday names change form depending on whether they appear alone (nominative case: LLLL, cccc) or alongside a day number (genitive case: MMMM, EEEE).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Why We Omitted It: Doubling the format token surface (two parallel token hierarchies for every month and weekday) burdens developers with linguistic trivia. Tempo delegates localized inflection directly to ECMAScript Intl.DateTimeFormat. Using {mon:locale} or {wkd:locale} allows the runtime engine to automatically select the grammatically correct inflection based on the surrounding date context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Mnemonic Reference Date Formatting (Go time.Format) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Legacy Behavior: Go formats dates using a magic reference timestamp: Mon Jan 2 15:04:05 MST 2006 (1 2 3 4 5 6 -0700).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Why We Omitted It: While memorable in isolation, reference timestamps break down as soon as format masks include arbitrary words containing reference numbers (e.g. ref1, page2, step3) because Go lacks an escape syntax. In Tempo, braced tokens eliminate any possibility of token-literal collision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Hardcoded Business / Fiscal Quarter Assumptions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Legacy Behavior: Many SQL engines and reporting dialects hardcode assumptions that quarters strictly align to Gregorian three-month boundaries (Q1 = Jan–Mar, Q2 = Apr–Jun, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Why We Omitted It: In real-world enterprise applications, fiscal years, tax cycles, and academic quarters frequently start on arbitrary months (e.g. July 1st in Australia, April 1st in the UK/India, October 1st for the US federal government). Rather than baking inflexible Gregorian quarter tables into core tokens, Tempo encapsulates specialized domain concepts into modular Terms (#quarter, #fiscalYear). This allows developers to configure custom fiscal calendars without breaking standard date formatting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Summary Comparison ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',51)),e("table",s,[t[25]||(t[25]=e("thead",null,[e("tr",null,[e("th",{style:{"text-align":"left"}},"Feature / Trait"),e("th",{style:{"text-align":"left"}},"Legacy Dialects (LDML, Moment, strftime)"),e("th",{style:{"text-align":"left"}},"Native Tempo Approach")])],-1)),e("tbody",null,[t[19]||(t[19]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Case Sensitivity")]),e("td",{style:{"text-align":"left"}},"Critical (typos silently alter data targets)"),e("td",{style:{"text-align":"left"}},[o("All lowercase primary tokens ("),e("code",null,"{yyyy}"),o(", "),e("code",null,"{mm}"),o(", "),e("code",null,"{dd}"),o(", "),e("code",null,"{hh}"),o(")")])],-1)),e("tr",null,[t[17]||(t[17]=e("td",{style:{"text-align":"left"}},[e("strong",null,"API Alignment")],-1)),t[18]||(t[18]=e("td",{style:{"text-align":"left"}},"Methods and tokens use completely different vocabularies",-1)),e("td",r,[t[4]||(t[4]=o("Direct mirror (",-1)),t[5]||(t[5]=e("code",null,"t.yy",-1)),t[6]||(t[6]=o()),e("mjx-container",c,[(d(),l("svg",g,[...t[0]||(t[0]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"27F7",d:"M165 270H1694Q1578 357 1551 493Q1551 494 1551 496T1550 499Q1550 511 1567 511H1570Q1579 511 1582 510T1588 506T1591 497T1594 481T1602 456Q1624 389 1675 336T1794 261Q1803 258 1803 250Q1803 244 1798 241T1774 231T1736 212Q1695 186 1665 152T1620 85T1599 35T1591 4Q1589 -6 1586 -8T1570 -11Q1550 -11 1550 0Q1550 7 1555 25Q1587 151 1694 230H165Q167 228 182 216T211 189T244 152T277 96T303 25Q308 7 308 0Q308 -11 288 -11Q281 -11 278 -11T272 -7T267 2T263 21Q245 94 195 151T73 236Q58 242 55 247Q55 254 59 257T73 264Q121 283 158 314T215 375T247 434T264 480L267 497Q269 503 270 505T275 509T288 511Q308 511 308 500Q308 493 303 475Q293 438 278 406T246 352T215 315T185 287T165 270Z",style:{"stroke-width":"3"}})])])],-1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"⟷")])],-1))]),t[7]||(t[7]=o()),t[8]||(t[8]=e("code",null,"{yyyy}",-1)),t[9]||(t[9]=o(" / ",-1)),t[10]||(t[10]=e("code",null,"{yy}",-1)),t[11]||(t[11]=o(", ",-1)),t[12]||(t[12]=e("code",null,"t.mm",-1)),t[13]||(t[13]=o()),e("mjx-container",m,[(d(),l("svg",y,[...t[2]||(t[2]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"27F7",d:"M165 270H1694Q1578 357 1551 493Q1551 494 1551 496T1550 499Q1550 511 1567 511H1570Q1579 511 1582 510T1588 506T1591 497T1594 481T1602 456Q1624 389 1675 336T1794 261Q1803 258 1803 250Q1803 244 1798 241T1774 231T1736 212Q1695 186 1665 152T1620 85T1599 35T1591 4Q1589 -6 1586 -8T1570 -11Q1550 -11 1550 0Q1550 7 1555 25Q1587 151 1694 230H165Q167 228 182 216T211 189T244 152T277 96T303 25Q308 7 308 0Q308 -11 288 -11Q281 -11 278 -11T272 -7T267 2T263 21Q245 94 195 151T73 236Q58 242 55 247Q55 254 59 257T73 264Q121 283 158 314T215 375T247 434T264 480L267 497Q269 503 270 505T275 509T288 511Q308 511 308 500Q308 493 303 475Q293 438 278 406T246 352T215 315T185 287T165 270Z",style:{"stroke-width":"3"}})])])],-1)])])),t[3]||(t[3]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"⟷")])],-1))]),t[14]||(t[14]=o()),t[15]||(t[15]=e("code",null,"{mm}",-1)),t[16]||(t[16]=o(")",-1))])]),t[20]||(t[20]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Variations & Styling")]),e("td",{style:{"text-align":"left"}},"Hundreds of arbitrary single-character tokens"),e("td",{style:{"text-align":"left"}},[o("Orthogonal, chainable modifiers ("),e("code",null,":upper"),o(", "),e("code",null,":lower"),o(", "),e("code",null,":ord"),o(", "),e("code",null,":roman"),o(", "),e("code",null,":locale"),o(")")])],-1)),t[21]||(t[21]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Literal Text")]),e("td",{style:{"text-align":"left"}},[o("Requires quotes ("),e("code",null,"'...'"),o("), brackets ("),e("code",null,"[...]"),o("), or is unescapable (Go)")]),e("td",{style:{"text-align":"left"}},[o("Literal by default; doubled braces ("),e("span",null,[e("code",null,"{{")]),o(", "),e("span",null,[e("code",null,"}}")]),o(") for escape")])],-1)),t[22]||(t[22]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Week-Year Standard")]),e("td",{style:{"text-align":"left"}},"Mixes ISO and divergent locale-based week years"),e("td",{style:{"text-align":"left"}},[o("Anchored strictly to deterministic ISO 8601 by default ("),e("code",null,"{yow}"),o(", "),e("code",null,"{woy}"),o("), with explicit "),e("code",null,":locale"),o(" opt-in ("),e("code",null,"{yow:locale}"),o(", "),e("code",null,"{woy:locale}"),o(")")])],-1)),t[23]||(t[23]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Grammatical Inflection")]),e("td",{style:{"text-align":"left"}},[o("Duplicate token families ("),e("code",null,"LLLL"),o(" vs "),e("code",null,"MMMM"),o(", "),e("code",null,"cccc"),o(" vs "),e("code",null,"EEEE"),o(")")]),e("td",{style:{"text-align":"left"}},[o("Automatic via standard "),e("code",null,"Intl"),o(" integration ("),e("code",null,"{mon:locale}"),o(")")])],-1)),t[24]||(t[24]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Domain Terms")]),e("td",{style:{"text-align":"left"}},"Rigid, static token sets"),e("td",{style:{"text-align":"left"}},[o("Extensible Terms ("),e("code",null,"#quarter"),o(", "),e("code",null,"#isoWeek"),o(", "),e("code",null,"#dayOfYear"),o(")")])],-1))])]),t[27]||(t[27]=e("hr",null,null,-1)),t[28]||(t[28]=e("div",{class:"tip custom-block github-alert"},[e("p",{class:"custom-block-title"},"TIP"),e("p",null,[e("strong",null,"Use Dialects for Migration, Native Tempo for Greenfield"),e("br"),o(" While "),e("code",null,"@magmacomputing/tempo-plugin-dialects"),o(" provides extensive, high-fidelity compatibility for standard legacy masks, we recommend standardizing on native Tempo "),e("code",null,"{token}"),o(" syntax for new development to maximize clarity, performance, and maintainability.")])],-1))])}const T=n(i,[["render",u]]);export{w as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.lean.js new file mode 100644 index 00000000..9dc56c39 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.design-philosophy-and-omissions.md.9FbR7tUo.lean.js @@ -0,0 +1 @@ +import{_ as n,o as d,c as l,a2 as a,j as e,a as o}from"./chunks/framework.DNL3hc5c.js";const w=JSON.parse('{"title":"Design Strategy & Deliberate Omissions","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.design-philosophy-and-omissions.md","filePath":"doc/9-plugins/dialects.design-philosophy-and-omissions.md"}'),i={name:"doc/9-plugins/dialects.design-philosophy-and-omissions.md"},s={tabindex:"0"},r={style:{"text-align":"left"}},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.206ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1859 522","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.206ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1859 522","aria-hidden":"true"};function u(p,t,h,f,x,b){return d(),l("div",null,[t[26]||(t[26]=a("",51)),e("table",s,[t[25]||(t[25]=e("thead",null,[e("tr",null,[e("th",{style:{"text-align":"left"}},"Feature / Trait"),e("th",{style:{"text-align":"left"}},"Legacy Dialects (LDML, Moment, strftime)"),e("th",{style:{"text-align":"left"}},"Native Tempo Approach")])],-1)),e("tbody",null,[t[19]||(t[19]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Case Sensitivity")]),e("td",{style:{"text-align":"left"}},"Critical (typos silently alter data targets)"),e("td",{style:{"text-align":"left"}},[o("All lowercase primary tokens ("),e("code",null,"{yyyy}"),o(", "),e("code",null,"{mm}"),o(", "),e("code",null,"{dd}"),o(", "),e("code",null,"{hh}"),o(")")])],-1)),e("tr",null,[t[17]||(t[17]=e("td",{style:{"text-align":"left"}},[e("strong",null,"API Alignment")],-1)),t[18]||(t[18]=e("td",{style:{"text-align":"left"}},"Methods and tokens use completely different vocabularies",-1)),e("td",r,[t[4]||(t[4]=o("Direct mirror (",-1)),t[5]||(t[5]=e("code",null,"t.yy",-1)),t[6]||(t[6]=o()),e("mjx-container",c,[(d(),l("svg",g,[...t[0]||(t[0]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"27F7",d:"M165 270H1694Q1578 357 1551 493Q1551 494 1551 496T1550 499Q1550 511 1567 511H1570Q1579 511 1582 510T1588 506T1591 497T1594 481T1602 456Q1624 389 1675 336T1794 261Q1803 258 1803 250Q1803 244 1798 241T1774 231T1736 212Q1695 186 1665 152T1620 85T1599 35T1591 4Q1589 -6 1586 -8T1570 -11Q1550 -11 1550 0Q1550 7 1555 25Q1587 151 1694 230H165Q167 228 182 216T211 189T244 152T277 96T303 25Q308 7 308 0Q308 -11 288 -11Q281 -11 278 -11T272 -7T267 2T263 21Q245 94 195 151T73 236Q58 242 55 247Q55 254 59 257T73 264Q121 283 158 314T215 375T247 434T264 480L267 497Q269 503 270 505T275 509T288 511Q308 511 308 500Q308 493 303 475Q293 438 278 406T246 352T215 315T185 287T165 270Z",style:{"stroke-width":"3"}})])])],-1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"⟷")])],-1))]),t[7]||(t[7]=o()),t[8]||(t[8]=e("code",null,"{yyyy}",-1)),t[9]||(t[9]=o(" / ",-1)),t[10]||(t[10]=e("code",null,"{yy}",-1)),t[11]||(t[11]=o(", ",-1)),t[12]||(t[12]=e("code",null,"t.mm",-1)),t[13]||(t[13]=o()),e("mjx-container",m,[(d(),l("svg",y,[...t[2]||(t[2]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"27F7",d:"M165 270H1694Q1578 357 1551 493Q1551 494 1551 496T1550 499Q1550 511 1567 511H1570Q1579 511 1582 510T1588 506T1591 497T1594 481T1602 456Q1624 389 1675 336T1794 261Q1803 258 1803 250Q1803 244 1798 241T1774 231T1736 212Q1695 186 1665 152T1620 85T1599 35T1591 4Q1589 -6 1586 -8T1570 -11Q1550 -11 1550 0Q1550 7 1555 25Q1587 151 1694 230H165Q167 228 182 216T211 189T244 152T277 96T303 25Q308 7 308 0Q308 -11 288 -11Q281 -11 278 -11T272 -7T267 2T263 21Q245 94 195 151T73 236Q58 242 55 247Q55 254 59 257T73 264Q121 283 158 314T215 375T247 434T264 480L267 497Q269 503 270 505T275 509T288 511Q308 511 308 500Q308 493 303 475Q293 438 278 406T246 352T215 315T185 287T165 270Z",style:{"stroke-width":"3"}})])])],-1)])])),t[3]||(t[3]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"⟷")])],-1))]),t[14]||(t[14]=o()),t[15]||(t[15]=e("code",null,"{mm}",-1)),t[16]||(t[16]=o(")",-1))])]),t[20]||(t[20]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Variations & Styling")]),e("td",{style:{"text-align":"left"}},"Hundreds of arbitrary single-character tokens"),e("td",{style:{"text-align":"left"}},[o("Orthogonal, chainable modifiers ("),e("code",null,":upper"),o(", "),e("code",null,":lower"),o(", "),e("code",null,":ord"),o(", "),e("code",null,":roman"),o(", "),e("code",null,":locale"),o(")")])],-1)),t[21]||(t[21]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Literal Text")]),e("td",{style:{"text-align":"left"}},[o("Requires quotes ("),e("code",null,"'...'"),o("), brackets ("),e("code",null,"[...]"),o("), or is unescapable (Go)")]),e("td",{style:{"text-align":"left"}},[o("Literal by default; doubled braces ("),e("span",null,[e("code",null,"{{")]),o(", "),e("span",null,[e("code",null,"}}")]),o(") for escape")])],-1)),t[22]||(t[22]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Week-Year Standard")]),e("td",{style:{"text-align":"left"}},"Mixes ISO and divergent locale-based week years"),e("td",{style:{"text-align":"left"}},[o("Anchored strictly to deterministic ISO 8601 by default ("),e("code",null,"{yow}"),o(", "),e("code",null,"{woy}"),o("), with explicit "),e("code",null,":locale"),o(" opt-in ("),e("code",null,"{yow:locale}"),o(", "),e("code",null,"{woy:locale}"),o(")")])],-1)),t[23]||(t[23]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Grammatical Inflection")]),e("td",{style:{"text-align":"left"}},[o("Duplicate token families ("),e("code",null,"LLLL"),o(" vs "),e("code",null,"MMMM"),o(", "),e("code",null,"cccc"),o(" vs "),e("code",null,"EEEE"),o(")")]),e("td",{style:{"text-align":"left"}},[o("Automatic via standard "),e("code",null,"Intl"),o(" integration ("),e("code",null,"{mon:locale}"),o(")")])],-1)),t[24]||(t[24]=e("tr",null,[e("td",{style:{"text-align":"left"}},[e("strong",null,"Domain Terms")]),e("td",{style:{"text-align":"left"}},"Rigid, static token sets"),e("td",{style:{"text-align":"left"}},[o("Extensible Terms ("),e("code",null,"#quarter"),o(", "),e("code",null,"#isoWeek"),o(", "),e("code",null,"#dayOfYear"),o(")")])],-1))])]),t[27]||(t[27]=e("hr",null,null,-1)),t[28]||(t[28]=e("div",{class:"tip custom-block github-alert"},[e("p",{class:"custom-block-title"},"TIP"),e("p",null,[e("strong",null,"Use Dialects for Migration, Native Tempo for Greenfield"),e("br"),o(" While "),e("code",null,"@magmacomputing/tempo-plugin-dialects"),o(" provides extensive, high-fidelity compatibility for standard legacy masks, we recommend standardizing on native Tempo "),e("code",null,"{token}"),o(" syntax for new development to maximize clarity, performance, and maintainability.")])],-1))])}const T=n(i,[["render",u]]);export{w as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.js new file mode 100644 index 00000000..cfd974b8 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.js @@ -0,0 +1,15 @@ +import{_ as a}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as i,C as l,o as d,c as o,a2 as e,E as n}from"./chunks/framework.DNL3hc5c.js";const x=JSON.parse('{"title":"@magmacomputing/tempo-plugin-dialects","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.index.md","filePath":"doc/9-plugins/dialects.index.md"}'),c={name:"doc/9-plugins/dialects.index.md"};function r(p,t,g,h,m,y){const s=l("PluginRepl");return d(),o("div",null,[t[0]||(t[0]=e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-dialects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Dialects Plugin enables Tempo to seamlessly format and parse dates using established external formatting standards, including Unicode LDML / UTS #35 (Luxon, date-fns), POSIX strftime (C, Python, Linux), Moment.js / Day.js, and Oracle / SQL TO_CHAR (PostgreSQL, Snowflake, Redshift).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It provides transparent drop-in compatibility shims, multi-candidate fallback parsing, an automated .explain() ingestion engine, .export() for emitting dialect models from Tempo tokens, and .convert() for direct bidirectional transpilation between external ecosystems.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Installation & Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-dialects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),n(s,{plugin:"dialects"}),t[1]||(t[1]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+const t = new Tempo('2026-10-24T15:30:45');
+
+// Format using external dialect masks
+console.log(t.format('yyyy-MM-dd HH:mm:ss', { dialect: DIALECT.Ldml })); // "2026-10-24 15:30:45"
+console.log(t.format('%Y-%m-%d %H:%M:%S', { dialect: DIALECT.Strftime })); // "2026-10-24 15:30:45"
+console.log(t.format('[Recorded on] MMMM Do YYYY', { dialect: DIALECT.Moment })); // "Recorded on October 24th 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Boilerplate Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-dialects/install';
+
+const t = new Tempo('2026-10-24T15:30:45');
+console.log(t.toFormat('dd LLL yyyy')); // "24 Oct 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔤 Supported Dialects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dialect IdentifierCanonical ConstantCommon AliasesFormat ExamplePrimary Ecosystems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ldml'DIALECT.Ldml'luxon', 'datefns', 'cldr'yyyy-MM-dd HH:mm:ss.SSSLuxon, date-fns, CLDR, Unicode UTS #35
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'strftime'DIALECT.Strftime'posix', 'c', 'python'%Y-%m-%d %H:%M:%SPOSIX C, Python datetime, Linux Syslog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'moment'DIALECT.Moment'dayjs'YYYY-MM-DD HH:mm:ssMoment.js, Day.js
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'oracle'DIALECT.Oracle'sql', 'postgres', 'postgresql', 'snowflake', 'redshift', 'to_char'YYYY-MM-DD HH24:MI:SSOracle, PostgreSQL, Snowflake, AWS Redshift
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'php'DIALECT.Php'laravel', 'wordpress'Y-m-d H:i:sPHP, Laravel, WordPress, Symfony
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'go'DIALECT.Go'golang'2006-01-02 15:04:05Go (time.Format, time.Parse)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'mysql'DIALECT.Mysql'mariadb'%Y-%m-%d %H:%i:%sMySQL, MariaDB (DATE_FORMAT)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'dotnet'DIALECT.DotNet'csharp', '.net', 'c#'yyyy-MM-dd HH:mm:ss.fff.NET, C#, PowerShell (DateTime.ToString)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sheet'DIALECT.Sheet'spreadsheet', 'excel', 'sheets'yyyy-mm-dd hh:mm:ss AM/PMMicrosoft Excel, Google Sheets, LibreOffice Calc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Tempo Syntax is Optimal While the Dialects plugin provides seamless interoperability with legacy format masks, native Tempo braced syntax ({token}) remains the most performant, lightweight, and expressive choice. Native Tempo syntax runs in Core with zero plugin dependencies, and provides rich capabilities unavailable in external token systems—including custom Terms, dynamic dot namespaces ({geo.city}), localized modifiers ({dow:locale}, {hh:locale:raw}), and regional {intl.*} property interpolation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 API Surface Catalog ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Dialects plugin mounts cohesive static tools onto Tempo.dialects, instance utilities onto t.dialects, and attaches convenience shims directly onto Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    API / MethodTargetInputReturnsDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.toFormat(mask, options?)InstanceFormat mask string, optionsstringLuxon Drop-In Formatter. Formats the instance using LDML (or explicit dialect).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.ldml(mask)InstanceUnicode LDML maskstringFast-path formatter for Unicode LDML / Luxon / date-fns masks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.strftime(mask)InstancePOSIX strftime maskstringFast-path formatter for POSIX strftime specifiers (%Y, %m, %d, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.oracle(mask)InstanceOracle / SQL maskstringFast-path formatter for Oracle / PostgreSQL / Snowflake format models (YYYY, HH24, MI, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.sql(mask)InstanceSQL / Oracle maskstringConvenience alias for t.dialects.oracle(mask).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.php(mask)InstancePHP date maskstringFast-path formatter for PHP date() specifiers (Y, m, d, H, i, s, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.go(mask)InstanceGo reference maskstringFast-path formatter for Go reference time layout (2006, 01, 02, 15, 04, 05).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.mysql(mask)InstanceMySQL format maskstringFast-path formatter for MySQL / MariaDB DATE_FORMAT specifiers (%Y, %m, %d, %H, %i, %s, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.dotnet(mask)Instance.NET format maskstringFast-path formatter for .NET / C# DateTime.ToString custom format strings (yyyy, MM, dd, HH, mm, ss, fff, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.sheet(mask)InstanceSpreadsheet maskstringFast-path formatter for Excel / Google Sheets custom format strings (yyyy, mm, dd, hh, ss, AM/PM, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.format(mask, dialect?)InstanceMask, dialect identifierstringGeneric dialect instance formatter with auto-detection for %, Go, SQL, MySQL, .NET, and Sheet specifiers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.explain(mask, dialectOrOptions?)InstanceExternal format mask, dialect name or { dialect }ExplainResultAnalyzes mask and returns equivalent native Tempo {token} pattern and metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.export(pattern, dialectOrOptions?)InstanceNative Tempo pattern, target dialect name or { dialect }ExportResultExports a native Tempo {token} pattern into an external dialect format model.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.dialects.convert(mask, toOrOptions) / convert(mask, from, to)InstanceMask, target dialect, or { from, to } optionsConvertResultConverts a format mask directly from one dialect to another (source dialect auto-inferred if omitted).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.fromFormat(input, mask, options?)StaticDate string, mask, optionsTempoLuxon Drop-In Parser. Parses an input string using an LDML mask (or auto-detected dialect).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.fromFormats(input, masks[], options?)StaticDate string, candidate masksTempoMulti-candidate fallback parser with auto-dialect detection (first matching mask succeeds).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.dialects.parse(input, mask, dialect?)StaticDate string, mask, dialectTempoExplicit dialect parser.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.dialects.fromFormats(input, masks[], ...)StaticDate string, candidate masksTempoExplicit multi-candidate fallback parser.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.dialects.explain(mask, dialectOrOptions?)StaticExternal format mask, dialect name or { dialect }ExplainResultAST analyzer translating legacy masks into native Tempo {token} syntax.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.dialects.export(pattern, dialectOrOptions?)StaticNative Tempo pattern, target dialect name or { dialect }ExportResultExports a native Tempo {token} pattern into an external dialect format model.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.dialects.convert(mask, toOrOptions) / convert(mask, from, to)StaticMask, target dialect, or { from, to } optionsConvertResultTranspiles a format mask directly between dialects (source dialect auto-inferred if omitted).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Architecture & Specialized Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To explore technical deep-dives, token compatibility matrices, and production patterns, consult the dedicated guides below:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Performance & Lazy Evaluation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Pre-Compiled Formatters: Formatting masks are tokenized and compiled into high-speed closure interpolators on first run and cached in memory. Subsequent executions bypass tokenization and compilation overhead, evaluating directly through cached closures.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Lazy-Evaluated Namespace: Accessing t.dialects utilizes Tempo's zero-overhead proxy pattern, consuming zero CPU cycles until explicitly invoked on an instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Immutable Static Namespace: Tempo.dialects is recursively frozen via deepFreeze() to protect the host class against runtime tampering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,22))])}const u=i(c,[["render",r]]);export{x as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.lean.js new file mode 100644 index 00000000..e6a96f12 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.index.md.vhrHfiBB.lean.js @@ -0,0 +1 @@ +import{_ as a}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as i,C as l,o as d,c as o,a2 as e,E as n}from"./chunks/framework.DNL3hc5c.js";const x=JSON.parse('{"title":"@magmacomputing/tempo-plugin-dialects","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.index.md","filePath":"doc/9-plugins/dialects.index.md"}'),c={name:"doc/9-plugins/dialects.index.md"};function r(p,t,g,h,m,y){const s=l("PluginRepl");return d(),o("div",null,[t[0]||(t[0]=e("",8)),n(s,{plugin:"dialects"}),t[1]||(t[1]=e("",22))])}const u=i(c,[["render",r]]);export{x as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.js new file mode 100644 index 00000000..0efc6a83 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.js @@ -0,0 +1,78 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Migration & Legacy Compatibility","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.migration-and-compatibility.md","filePath":"doc/9-plugins/dialects.migration-and-compatibility.md"}'),n={name:"doc/9-plugins/dialects.migration-and-compatibility.md"};function l(p,s,h,o,r,d){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Migration & Legacy Compatibility ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-dialects plugin is engineered to provide frictionless, zero-downtime migration paths for codebases transitioning to Tempo from Moment.js, Day.js, Luxon, or date-fns, as well as legacy backend systems that emit standard POSIX strftime specifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Migration Challenge: Token Traps & Gotchas ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Directly porting format strings between date libraries without validation often introduces subtle production regressions due to conflicting token semantics across ecosystems:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Year Trap: YYYY vs yyyy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the most dangerous formatting bugs in modern web applications occurs during late December and early January:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In Moment.js & Day.js: YYYY represents the standard calendar year (e.g. 2026).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In Unicode LDML (Luxon, date-fns): yyyy represents the calendar year, while YYYY represents the ISO week-numbering year.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Pitfall: Formatting 2025-12-31 with YYYY under LDML outputs 2026 because December 31st belongs to the first week of 2026. This has historically caused catastrophic financial and billing errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Tempo Solution: Tempo Core uses {yyyy} for the 4-digit calendar year and {yow} for the ISO week-numbering year. The Dialects plugin automatically normalizes these semantics when evaluating legacy masks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Month vs Minute: MM vs mm vs mi ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In legacy libraries, uppercase MM designates months, while lowercase mm designates minutes. Accidental capitalization (e.g., HH:MM:ss) prints the month instead of the minute.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo solves this ambiguity at the foundational syntax level:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mm}: Zero-padded month (01-12)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mi}: Zero-padded minute (00-59)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mon}: Full month name (October)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {mmm}: Short month name (Oct)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Escaping Literals: Quotes vs Brackets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Different ecosystems handle arbitrary literal text within format strings inconsistently:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EcosystemLiteral Escaping SyntaxExampleEscaping Quotes / Brackets
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo CoreBraced tokens; all outer text is literalRecorded on {yyyy}-{mm}-{dd}{{ → {, }} → }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Moment.js / Day.jsSquare brackets [...][Recorded on] YYYY-MM-DD[\\[literal\\]]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unicode LDMLSingle quotes '...''Recorded on' yyyy-MM-dd'' (two single quotes)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    POSIX strftimeDirect text; % prefixes tokensRecorded on %Y-%m-%d%% produces %

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automated Migration Engine: Tempo.dialects.explain() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To eliminate guesswork and avoid manual regex translation, the Dialects plugin includes a built-in static AST analyzer: Tempo.dialects.explain().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It inspects any legacy format mask, auto-detects or confirms the originating dialect, and translates it into the equivalent native Tempo {token} pattern alongside a token-by-token metadata breakdown:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+// 1. Analyze a legacy Moment.js mask with bracketed literals and ordinals
+const analysis = Tempo.dialects.explain('[Report for] MMMM Do, YYYY [at] hh:mm A', DIALECT.Moment);
+
+console.log(analysis.pattern);
+// Output: "Report for {mon} {dd:ord}, {yyyy} at {h12}:{mi} {mer:upper}"
+
+console.log(analysis.dialect);
+// Output: "moment"
+
+// Inspect the mapped token array
+console.log(analysis.tokens);
+// [
+//   { source: 'MMMM', tempo: '{mon}', desc: 'Full month name (e.g. October)' },
+//   { source: 'Do',   tempo: '{dd:ord}', desc: 'Day of month with ordinal suffix (1st-31st)' },
+//   { source: 'YYYY', tempo: '{yyyy}', desc: '4-digit year' },
+//   { source: 'hh',   tempo: '{h12}', desc: '12-hour clock (01-12)' },
+//   { source: 'mm',   tempo: '{mi}', desc: 'Zero-padded minute (00-59)' },
+//   { source: 'A',    tempo: '{mer:upper}', desc: 'AM/PM marker (uppercase)' }
+// ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Programmatic Mask Upgrades in Build Pipelines ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can use explain() in a code-mod or lint rule to audit and rewrite legacy format strings across your codebase:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function migrateLegacyMask(legacyMask: string, dialect?: string): string {
+  const result = Tempo.dialects.explain(legacyMask, dialect);
+  return result.pattern;
+}
+
+// Convert Luxon masks to native Tempo
+const modernPattern = migrateLegacyMask("yyyy-MM-dd 'T' HH:mm:ss.SSS zzzz", 'ldml');
+console.log(modernPattern);
+// Output: "{yyyy}-{mm}-{dd} T {hh}:{mi}:{ss}.{ms} {tz:long}"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exporting Dialect Models: Tempo.dialects.export() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To emit external dialect masks from canonical Tempo patterns (for example, generating SQL/Oracle TO_CHAR format models or POSIX strftime masks from shared application templates), use Tempo.dialects.export():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Export canonical Tempo pattern to Oracle / SQL TO_CHAR model
+const oracleExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', 'oracle');
+console.log(oracleExport.pattern);
+// Output: "YYYY-MM-DD HH24:MI:SS"
+
+// Export to POSIX strftime
+const posixExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', 'strftime');
+console.log(posixExport.pattern);
+// Output: "%Y-%m-%d %H:%M:%S"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any tokens that cannot be directly mapped to the target ecosystem are tracked in unsupported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Universal Cross-Dialect Conversion: Tempo.dialects.convert() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With Tempo serving as an Intermediate Representation (IR), you can convert format masks directly between any supported external ecosystems in a single call:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Convert POSIX strftime directly to Oracle / SQL TO_CHAR
+const sqlMask = Tempo.dialects.convert('%Y-%m-%d %H:%M:%S', 'strftime', 'oracle');
+console.log(sqlMask.pattern);
+// Output: "YYYY-MM-DD HH24:MI:SS"
+
+// Convert Moment.js directly to POSIX strftime
+const posixMask = Tempo.dialects.convert('YYYY-MM-DD HH:mm:ss', 'moment', 'strftime');
+console.log(posixMask.pattern);
+// Output: "%Y-%m-%d %H:%M:%S"
+
+// Auto-detect source dialect
+const toLdml = Tempo.dialects.convert('%Y-%m-%d', 'ldml');
+console.log(toLdml.pattern);
+// Output: "yyyy-MM-dd"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Drop-In API Compatibility Shims ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For large codebases where updating thousands of call sites simultaneously is impractical, installing DialectsPlugin attaches drop-in convenience methods directly onto Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Luxon Drop-In: t.toFormat() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Existing Luxon format invocations can be ported by replacing the instance with Tempo without changing the formatting calls:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24T15:30:45');
+
+// Luxon drop-in instance method
+console.log(t.toFormat('dd LLL yyyy'));
+// Output: "24 Oct 2026"
+
+console.log(t.toFormat("'Time:' HH:mm:ss"));
+// Output: "Time: 15:30:45"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Static Parsers: Tempo.fromFormat() & Tempo.fromFormats() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Parse a single known format
+const t1 = Tempo.fromFormat('24/10/2026', 'dd/MM/yyyy');
+console.log(t1.iso); // "2026-10-24T00:00:00+..."
+
+// Multi-candidate fallback parsing (evaluates candidates until a match succeeds)
+const t2 = Tempo.fromFormats('10/24/2026 15:30', [
+  'yyyy-MM-dd HH:mm',
+  'dd/MM/yyyy HH:mm',
+  'MM/dd/yyyy HH:mm'
+]);
+console.log(t2.dd); // 24
+console.log(t2.mm); // 10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Performance Comparison: Native Tempo vs Dialects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While @magmacomputing/tempo-plugin-dialects is highly optimized with an internal compiled closure cache, native Tempo {token} syntax remains significantly faster:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ┌────────────────────────────────────────────────────────────────────────┐
+│ Formatting Performance Comparison (100,000 Iterations)                │
+├────────────────────────────────────────────────────────────────────────┤
+│ Native Tempo Core ({yyyy}-{mm}-{dd})   ████████████████████ 1.8x - 2.5x│
+│ Dialects LDML (yyyy-MM-dd)             ██████████           Cached     │
+│ Dialects strftime (%Y-%m-%d)           █████████            Cached     │
+│ Moment.js Library (Legacy Reference)   ████                 Baseline   │
+└────────────────────────────────────────────────────────────────────────┘

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why Native Syntax is Faster ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Zero Intermediate Token Mapping: Native Tempo tokens map directly to Temporal ZonedDateTime getters (zdt.year, zdt.month, zdt.day) inside Core.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Zero Regex Dialect Routing: External masks require regex tokenization and token AST resolution before execution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. No Plugin Overhead: Native formatting requires zero plugins loaded into memory, keeping bundle size minimal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Phase 1 (Immediate): Install @magmacomputing/tempo-plugin-dialects. Keep existing format strings untouched using t.format(mask, { dialect }), t.toFormat(), and Tempo.fromFormat().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Phase 2 (Automated Audit): Run Tempo.dialects.explain() across your format strings to generate native {token} equivalents.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Phase 3 (Optimization): Transition critical hot-paths and high-throughput logging routines to native Tempo format patterns for peak throughput.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,50)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.lean.js new file mode 100644 index 00000000..5facaacb --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.migration-and-compatibility.md.BhzaGPKq.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Migration & Legacy Compatibility","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.migration-and-compatibility.md","filePath":"doc/9-plugins/dialects.migration-and-compatibility.md"}'),n={name:"doc/9-plugins/dialects.migration-and-compatibility.md"};function l(p,s,h,o,r,d){return a(),t("div",null,[...s[0]||(s[0]=[e("",50)])])}const g=i(n,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.js new file mode 100644 index 00000000..6a02663d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.js @@ -0,0 +1 @@ +import{_ as a,C as n,o as i,c as l,a2 as s,E as c,j as e,a as d}from"./chunks/framework.DNL3hc5c.js";const T=JSON.parse('{"title":"Token Specification & Cross-Ecosystem Matrix","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.token-specification.md","filePath":"doc/9-plugins/dialects.token-specification.md"}'),r={name:"doc/9-plugins/dialects.token-specification.md"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"};function k(f,t,m,x,u,E){const o=n("DialectTabs");return i(),l("div",null,[t[22]||(t[22]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Token Specification & Cross-Ecosystem Matrix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document provides a comprehensive cross-reference matrix comparing date formatting and parsing tokens across Native Tempo Core and nine major ecosystem dialects:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unicode LDML / UTS #35 (ldml – date-fns, Luxon, CLDR)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Moment.js / Day.js (moment – Day.js, Moment)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • POSIX strftime (strftime – C, Python datetime, Ruby, Linux)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .NET / C# (dotnet – C#, PowerShell, ASP.NET)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Excel / Google Sheets (sheet – Spreadsheets, Calc)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • MySQL / MariaDB (mysql – DATE_FORMAT, STR_TO_DATE)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Oracle / PostgreSQL (oracle – TO_CHAR, TO_DATE, Snowflake)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • PHP date() (php – Laravel, WordPress, Symfony)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Go time.Format (go – Golang reference layouts)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Interactive Dialect Token Navigator ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Select a dialect tab below to view all supported specifiers, their Native Tempo equivalents, copyable tags, and live code examples. Use the filter bar to quickly locate tokens by keyword (e.g., year, hour, ord, fractional, timezone).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),c(o),t[23]||(t[23]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Core Standards Comparison Matrix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For a high-level overview across the most common date-formatting paradigms, the table below highlights primary date and time components compared to Native Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ComponentDescriptionLDML / date-fnsMoment / Day.jsPOSIX strftime.NET / C#Native Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Year (4-digit)4-digit calendar year (2026)yyyyYYYY%Yyyyy{yyyy}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Year (2-digit)2-digit calendar year (26)yyYY%yyy{yy}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Week-Numbering YearWeek-numbering year (ISO via %G / GGGG; locale-dependent in LDML YYYY)YYYY*GGGG%GN/A{yow}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month (padded)Zero-padded month (01–12)MMMM%mMM{mm}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month (raw)Unpadded month (1–12)MM%-m*M{mm:raw}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month Name (short)Abbreviated month (Oct)MMM / LLLMMM%bMMM{mmm}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month Name (full)Full month name (October)MMMM / LLLLMMMM%BMMMM{mon}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day (padded)Zero-padded day (01–31)ddDD%ddd{dd}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day (raw)Unpadded day (1–31)dD%-d*d{dd:raw}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day (ordinal)Ordinal suffix (24th)N/ADoN/AN/A{dd:ord}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day of YearDay of year (001–366)DDDDDDD%jN/A{doy}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Week of YearWeek number (01–53; ISO via %V / WW; locale-dependent in LDML ww)ww*WW%VN/A{woy}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday (full)Full weekday (Saturday)EEEEdddd%Adddd{wkd}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday (short)Abbreviated weekday (Sat)EEEddd%addd{www}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday (numeric)Numeric weekday (ISO 1=Mon..7=Sun via %u/E; locale-dependent 1-7 in LDML e/c)e / c*E%uN/A{dow}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hour (24h padded)24-hour clock (00–23)HHHH%HHH{hh}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hour (24h raw)24-hour clock unpadded (0–23)HH%-H*H{hh:raw}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hour (12h padded)12-hour clock (01–12)hhhh%Ihh{h12}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hour (12h raw)12-hour clock unpadded (1–12)hh%-I*h{h12:raw}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Meridiem (upper)Uppercase indicator (AM / PM)aaA%ptt{mer:upper}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Minute (padded)Zero-padded minute (00–59)mmmm%Mmm{mi}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Second (padded)Zero-padded second (00–59)ssss%Sss{ss}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Milliseconds3-digit fractional seconds (123)SSSSSS%3f*fff{ms}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Microseconds6-digit fractional seconds (123456)SSSSSSSSSSSS*%f*ffffff{ff:6}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezone OffsetFixed offset with colon (+08:00)ZZZZZ / XXXZN/Azzz{tz:offset}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezone (Kind-based)Dynamic offset or Z based on DateTime.KindN/AN/AN/AK*{tz:offset:utc}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Compact OffsetPortable offset without colon (+0800)ZZZZ%zN/A{tz:offsetcompact}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezone AbbreviationLocalized abbreviation (CET)zz%ZN/A{tz:short}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unix EpochSeconds since Unix epochN/AX%s*N/A{ts}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Standard Variations & Extensions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • LDML (YYYY, ww, e, c): In Unicode UTS #35, week-numbering year, week of year, and numeric day of week reflect territory/locale calendar conventions; deterministic ISO 8601 behavior requires explicit ISO settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Moment / Day.js (SSSSSS): Moment formats up to 3 fractional digits (milliseconds) and zero-pads additional digits; standard Day.js only formats up to SSS without plugins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • POSIX strftime (%-m, %-H, %-I, %f, %s): Modifiers omitting padding (%-) and %s (seconds since Unix epoch) are GNU/BSD extensions not specified in the standard POSIX strftime specification; %z is the POSIX portable standard for compact offsets. POSIX does not specify subseconds; %f is Python's 6-digit microsecond specifier, while %3f, %6f, and %9f are Tempo extensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .NET K: Unlike fixed-offset zzz (+08:00), K produces an offset for DateTimeKind.Local, Z for DateTimeKind.Utc, and an empty string for DateTimeKind.Unspecified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Literal Text Escaping Rules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When embedding plain text inside masks, each dialect implements distinct escaping conventions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Unicode LDML & Luxon (ldml) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',9)),e("ul",null,[t[10]||(t[10]=e("li",null,[d("Enclose text in "),e("strong",null,"single quotes"),d(": "),e("code",null,"'Date: ' yyyy-MM-dd"),d(".")],-1)),e("li",null,[t[2]||(t[2]=d("To emit a literal single quote, use ",-1)),t[3]||(t[3]=e("strong",null,"two consecutive single quotes",-1)),t[4]||(t[4]=d(": ",-1)),t[5]||(t[5]=e("code",null,"''yyyy''",-1)),t[6]||(t[6]=d()),e("mjx-container",g,[(i(),l("svg",h,[...t[0]||(t[0]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"→")])],-1))]),t[7]||(t[7]=d()),t[8]||(t[8]=e("code",null,"'2026'",-1)),t[9]||(t[9]=d(".",-1))])]),t[24]||(t[24]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format("'Report generated on' yyyy-MM-dd 'at' HH:mm", { dialect: 'ldml' });\n// => "Report generated on 2026-10-24 at 15:30"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Moment.js & Day.js (moment) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enclose text in square brackets: [Report generated on] YYYY-MM-DD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bare characters outside tokens remain literal text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format('[Invoice #] YYYY-MM-DD [due by] HH:mm', { dialect: 'moment' });\n// => "Invoice # 2026-10-24 due by 15:30"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C. POSIX strftime & MySQL (strftime, mysql) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',5)),e("ul",null,[t[21]||(t[21]=e("li",null,[d("Characters not prefixed by "),e("code",null,"%"),d(" are treated as literal text.")],-1)),e("li",null,[t[13]||(t[13]=d("To emit a literal percent symbol, use ",-1)),t[14]||(t[14]=e("code",null,"%%",-1)),t[15]||(t[15]=d(": ",-1)),t[16]||(t[16]=e("code",null,"%% %Y-%m-%d",-1)),t[17]||(t[17]=d()),e("mjx-container",p,[(i(),l("svg",y,[...t[11]||(t[11]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),t[12]||(t[12]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"→")])],-1))]),t[18]||(t[18]=d()),t[19]||(t[19]=e("code",null,"% 2026-10-24",-1)),t[20]||(t[20]=d(".",-1))])]),t[25]||(t[25]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format('%% Processed at %Y-%m-%d %H:%M:%S %%', { dialect: 'strftime' });\n// => "% Processed at 2026-10-24 15:30:45 %"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    D. .NET / C# (dotnet) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enclose text in single quotes 'text' or double quotes "text".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Escape individual characters using a backslash \\.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", { dialect: 'dotnet' });\n// => "2026-10-24T15:30:45.123"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    E. Excel / Google Sheets (sheet) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enclose arbitrary strings in double quotes: "Order Date: " yyyy-mm-dd.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Escape individual characters using backslash \\.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formatting decorators like _ (space reservation) and * (fill character) are ignored in standard parsing/formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format('"Total: $0.00 as of " mmmm d, yyyy', { dialect: 'sheet' });\n// => "Total: $0.00 as of October 24, 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    F. Native Tempo Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In Native Tempo syntax, tokens are enclosed in curly braces {token}. Everything outside braces is literal text by default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • To emit a literal { or }, use {{ or }}:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const str = t.format('Total balance: ${0} as of {yyyy}-{mm}-{dd}', { dialect: null });\n// => "Total balance: $0 as of 2026-10-24"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Ecosystem-Specific Nuances ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Context-Sensitive mm in Spreadsheets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In spreadsheet software (Excel, Google Sheets, Calc), the mask m or mm represents:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Minutes when immediately preceded by an hour (h or hh) or immediately followed by a second (s or ss), such as hh:mm:ss.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Months everywhere else, such as yyyy-mm-dd or mm/dd/yyyy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's sheet dialect automatically inspects token neighbors during tokenization to guarantee accurate resolution without manual intervention.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Standard .NET Single-Character Specifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In .NET, single-letter format strings expand into standard system patterns:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • O or o: Round-trip ISO-8601 (yyyy-MM-ddTHH:mm:ss.fffffffK)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • s: Sortable date/time (yyyy-MM-ddTHH:mm:ss)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • u: Universal sortable (yyyy-MM-dd HH:mm:ssZ)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • r or R: RFC 1123 (ddd, dd MMM yyyy HH:mm:ss GMT)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • d / D: Short / Long date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t / T: Short / Long time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo compiles these specifiers directly into optimal matching pipelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C. Hour Normalization (24:00 Midnight) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When parsing 24-hour clocks, differing standards support 00-23 (HH, H) and 01-24 (kk, k):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In Unicode LDML and Moment, kk indicates hours from 01 to 24. Hour 24:00 represents midnight at the close of day, which Temporal engines normalize to 00:00.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Dialects parser safely normalizes 24:00 to hour 0, while strictly rejecting out-of-range hours like 25:00 or 00:00 for kk tokens:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const validMidnight = Tempo.fromFormat('2026-10-24 24:00', 'yyyy-MM-dd kk:mm');\nconsole.log(validMidnight.hh); // 0 (normalized)\n\nconst invalidHour = Tempo.fromFormat('2026-10-24 25:00', 'yyyy-MM-dd kk:mm', { error: 'catch' });\nconsole.log(invalidHour.isValid); // false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',24))])}const v=a(r,[["render",k]]);export{T as __pageData,v as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.lean.js new file mode 100644 index 00000000..91db3d36 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.token-specification.md.BaBJmFN6.lean.js @@ -0,0 +1 @@ +import{_ as a,C as n,o as i,c as l,a2 as s,E as c,j as e,a as d}from"./chunks/framework.DNL3hc5c.js";const T=JSON.parse('{"title":"Token Specification & Cross-Ecosystem Matrix","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.token-specification.md","filePath":"doc/9-plugins/dialects.token-specification.md"}'),r={name:"doc/9-plugins/dialects.token-specification.md"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},y={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"};function k(f,t,m,x,u,E){const o=n("DialectTabs");return i(),l("div",null,[t[22]||(t[22]=s("",8)),c(o),t[23]||(t[23]=s("",9)),e("ul",null,[t[10]||(t[10]=e("li",null,[d("Enclose text in "),e("strong",null,"single quotes"),d(": "),e("code",null,"'Date: ' yyyy-MM-dd"),d(".")],-1)),e("li",null,[t[2]||(t[2]=d("To emit a literal single quote, use ",-1)),t[3]||(t[3]=e("strong",null,"two consecutive single quotes",-1)),t[4]||(t[4]=d(": ",-1)),t[5]||(t[5]=e("code",null,"''yyyy''",-1)),t[6]||(t[6]=d()),e("mjx-container",g,[(i(),l("svg",h,[...t[0]||(t[0]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),t[1]||(t[1]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"→")])],-1))]),t[7]||(t[7]=d()),t[8]||(t[8]=e("code",null,"'2026'",-1)),t[9]||(t[9]=d(".",-1))])]),t[24]||(t[24]=s("",5)),e("ul",null,[t[21]||(t[21]=e("li",null,[d("Characters not prefixed by "),e("code",null,"%"),d(" are treated as literal text.")],-1)),e("li",null,[t[13]||(t[13]=d("To emit a literal percent symbol, use ",-1)),t[14]||(t[14]=e("code",null,"%%",-1)),t[15]||(t[15]=d(": ",-1)),t[16]||(t[16]=e("code",null,"%% %Y-%m-%d",-1)),t[17]||(t[17]=d()),e("mjx-container",p,[(i(),l("svg",y,[...t[11]||(t[11]=[e("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[e("g",{"data-mml-node":"math"},[e("g",{"data-mml-node":"mo"},[e("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),t[12]||(t[12]=e("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[e("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[e("mo",{stretchy:"false"},"→")])],-1))]),t[18]||(t[18]=d()),t[19]||(t[19]=e("code",null,"% 2026-10-24",-1)),t[20]||(t[20]=d(".",-1))])]),t[25]||(t[25]=s("",24))])}const v=a(r,[["render",k]]);export{T as __pageData,v as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.js new file mode 100644 index 00000000..4d0e1964 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.js @@ -0,0 +1,131 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.use-cases-and-patterns.md","filePath":"doc/9-plugins/dialects.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/dialects.use-cases-and-patterns.md"};function l(p,s,h,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide showcases concrete, real-world architectural patterns where @magmacomputing/tempo-plugin-dialects solves non-trivial integration and migration challenges in production environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Heterogeneous Third-Party Webhook Ingestion ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In multi-tenant SaaS platforms or marketplace integrations (e.g. Shopify, Stripe, FedEx, Salesforce), inbound webhooks and partner API payloads arrive with wildly inconsistent date formats. Some send standard ISO 8601 strings, others omit seconds, some use European dd/MM/yyyy, and others emit legacy 12-hour AM/PM formats (MM/dd/yyyy hh:mm a). Hand-coding nested try/catch blocks for each vendor is fragile and expensive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Tempo.dialects.fromFormats() with an ordered list of candidate masks. The parser executes a high-speed layout matcher across candidate formats, returning a validated Tempo instance on the first matching signature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Incoming Webhook Payload
+         │
+         ▼
+┌────────────────────────────────────────────────────────┐
+│ Candidate Mask Fallback Array                          │
+│ 1. "yyyy-MM-dd HH:mm:ss"                               │
+│ 2. "yyyy-MM-ddTHH:mm:ssZ"                              │
+│ 3. "dd/MM/yyyy HH:mm"                                  │
+│ 4. "MM/dd/yyyy hh:mm a"                                │
+│ 5. "yyyy-MM-dd"                                        │
+└────────────────────────────────────────────────────────┘
+         │
+         ▼
+Validated Immutable Tempo Instance (Normalized to UTC)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Implementation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+// Define candidate formats ordered by descending specificity
+const WEBHOOK_CANDIDATE_MASKS = [
+  'yyyy-MM-dd HH:mm:ss',
+  'yyyy-MM-ddTHH:mm:ssZ',
+  'dd/MM/yyyy HH:mm',
+  'MM/dd/yyyy hh:mm a',
+  'yyyy-MM-dd'
+];
+
+/**
+ * Ingests external webhook timestamps into normalized UTC Tempo instances.
+ */
+export function normalizeExternalTimestamp(rawTimestamp: string): Tempo {
+  const parsed = Tempo.dialects.fromFormats(rawTimestamp, WEBHOOK_CANDIDATE_MASKS, {
+    dialect: DIALECT.Ldml,
+    timeZone: 'UTC'
+  });
+
+  if (!parsed.isValid) {
+    throw new Error(\`[Webhook Ingestion] Unrecognized timestamp signature: "\${rawTimestamp}"\`);
+  }
+
+  return parsed;
+}
+
+// 1. Standard ISO with space
+const t1 = normalizeExternalTimestamp('2026-10-24 15:30:45');
+console.log(t1.iso); // "2026-10-24T15:30:45Z"
+
+// 2. European format without seconds
+const t2 = normalizeExternalTimestamp('24/10/2026 15:30');
+console.log(t2.iso); // "2026-10-24T15:30:00Z"
+
+// 3. US 12-hour format with AM/PM
+const t3 = normalizeExternalTimestamp('10/24/2026 03:30 pm');
+console.log(t3.iso); // "2026-10-24T15:30:00Z"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Enterprise Syslog & Audit Trail Compliance (POSIX strftime) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enterprise security architectures and cloud logging daemons (Fluentd, Logstash, AWS CloudWatch, Datadog) require timestamps that strictly adhere to legacy POSIX standards—such as RFC 3164 BSD Syslog (Oct 24 15:30:45) or RFC 5424 High-Precision Structured Syslog (2026-10-24T15:30:45.123456Z). Writing manual string concatenation for padding, localized month abbreviations, and microsecond extraction is error-prone and hard to maintain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use t.format(mask, { dialect: DIALECT.Strftime }) to emit exact POSIX-compliant specifiers (%b, %e, %H, %M, %S, %f). The pre-compiled format cache evaluates these specs directly against the underlying high-resolution timestamp.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+export class SecurityAuditLogger {
+  /**
+   * Formats a legacy RFC 3164 BSD Syslog header: "Mmm dd hh:mm:ss"
+   * e.g. "Oct 24 15:30:45"
+   */
+  static formatRFC3164(tempo: Tempo): string {
+    return tempo.format('%b %e %H:%M:%S', { dialect: DIALECT.Strftime });
+  }
+
+  /**
+   * Formats an RFC 5424 High-Precision Audit Timestamp with microsecond precision:
+   * e.g. "2026-10-24T15:30:45.123456Z"
+   */
+  static formatRFC5424(tempo: Tempo): string {
+    return tempo.format('%Y-%m-%dT%H:%M:%S.%fZ', { dialect: DIALECT.Strftime });
+  }
+}
+
+// Example Execution
+const eventTime = new Tempo('2026-10-24T15:30:45.123456Z', { timeZone: 'UTC' });
+
+console.log(SecurityAuditLogger.formatRFC3164(eventTime));
+// Output: "Oct 24 15:30:45"
+
+console.log(SecurityAuditLogger.formatRFC5424(eventTime));
+// Output: "2026-10-24T15:30:45.123456Z"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Zero-Downtime Gradual Modernization Pipeline ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A large enterprise frontend and backend codebase has thousands of legacy call sites using Moment.js (moment(d).format('YYYY-MM-DD')) or Luxon (DateTime.fromISO(d).toFormat('dd LLL yyyy')). Migrating every call site at once is too risky and creates massive merge conflicts across engineering teams.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deploy a three-stage migration pipeline:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Stage 1 (Shim Layer): Replace Moment / Luxon imports with Tempo. The plugin's attached shims (t.toFormat(), Tempo.fromFormat()) fulfill all existing method calls transparently without requiring changes to format masks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Stage 2 (Automated Code-Mod via explain): Use Tempo.dialects.explain() in an automated CI lint rule or codemod script to inspect each format string and automatically rewrite it to native Tempo {token} syntax.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Stage 3 (Native Runtime): Once all masks are converted to native syntax, remove the dialect layer for zero-dependency peak throughput.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+// Stage 1: Legacy call sites continue working unchanged via shims
+const now = new Tempo('2026-10-24T15:30:45');
+console.log(now.toFormat('dd LLL yyyy')); // "24 Oct 2026"
+
+// Stage 2: Automated inspection and translation tool
+export function auditAndMigrateFormatMask(legacyMask: string, dialect: string) {
+  const explained = Tempo.dialects.explain(legacyMask, dialect);
+  
+  return {
+    sourceMask: legacyMask,
+    nativeTempoPattern: explained.pattern,
+    tokenCount: explained.tokens.length,
+    readyForCore: true
+  };
+}
+
+const migrationResult = auditAndMigrateFormatMask('YYYY-MM-DD [at] hh:mm:ss A', DIALECT.Moment);
+console.log(migrationResult.nativeTempoPattern);
+// Output: "{yyyy}-{mm}-{dd} at {h12}:{mi}:{ss} {mer:upper}"
+
+// Stage 3: Direct native format execution (Core only, zero plugin overhead)
+console.log(now.format(migrationResult.nativeTempoPattern, { dialect: null }));
+// Output: "2026-10-24 at 03:30:45 PM"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Cross-Ecosystem Format Transpilation (.convert() & .export()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In distributed architectures, different subsystems require different date token conventions. For example, a React frontend may define display masks in Moment or Luxon format, an Oracle or PostgreSQL database query requires TO_CHAR(..., 'YYYY-MM-DD HH24:MI:SS'), and a Linux syslog forwarder uses POSIX strftime (%Y-%m-%d %H:%M:%S). Maintaining synchronized format strings across these boundaries manually leads to subtle drift and formatting bugs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Tempo as a format Intermediate Representation (IR). You can either convert legacy masks directly between ecosystems via .convert(), or define application templates in canonical Tempo syntax and export target masks dynamically with .export().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin, DIALECT } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+
+// 1. Cross-compile frontend Moment mask directly to database TO_CHAR model
+const clientMask = 'YYYY-MM-DD HH:mm:ss';
+const sqlModel = Tempo.dialects.convert(clientMask, DIALECT.Moment, DIALECT.Oracle);
+console.log(sqlModel.pattern);
+// Output: "YYYY-MM-DD HH24:MI:SS"
+
+// 2. Export canonical backend template to POSIX syslog and SQL models
+const canonicalMask = '{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}';
+
+const syslogFormat = Tempo.dialects.export(canonicalMask, DIALECT.Strftime);
+console.log(syslogFormat.pattern);
+// Output: "%Y-%m-%d %H:%M:%S"
+
+const dbFormat = Tempo.dialects.export(canonicalMask, DIALECT.Oracle);
+console.log(dbFormat.pattern);
+// Output: "YYYY-MM-DD HH24:MI:SS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,35)])])}const c=i(e,[["render",l]]);export{E as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.lean.js new file mode 100644 index 00000000..072dbe69 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_dialects.use-cases-and-patterns.md.BKd6k2jk.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/dialects.use-cases-and-patterns.md","filePath":"doc/9-plugins/dialects.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/dialects.use-cases-and-patterns.md"};function l(p,s,h,k,r,o){return a(),n("div",null,[...s[0]||(s[0]=[t("",35)])])}const c=i(e,[["render",l]]);export{E as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.js b/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.js new file mode 100644 index 00000000..e0c18acc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.js @@ -0,0 +1,18 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as t,C as e,o as p,c as l,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-finance","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/finance.index.md","filePath":"doc/9-plugins/finance.index.md"}'),k={name:"doc/9-plugins/finance.index.md"};function o(r,s,g,c,d,m){const a=e("PluginRepl");return p(),l("div",null,[s[0]||(s[0]=i('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-finance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A specialized namespace plugin for Tempo that provides fiscal year and financial date utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-finance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',7)),h(a,{plugin:"finance"}),s[1]||(s[1]=i(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { FinanceNamespace } from '@magmacomputing/tempo-plugin-finance';
+
+// Register the namespace
+Tempo.use(FinanceNamespace);
+
+const t = new Tempo('2024-07-01');
+
+// Evaluate static properties
+console.log(t.finance.fiscalQuarter); // 3
+console.log(t.finance.taxYear); // 2024
+
+// Evaluate functional closures
+console.log(t.finance.isFiscalYearStart()); // false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For zero-boilerplate global registration, import the /install subpath:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-finance/install';
+
+const t = new Tempo('2024-07-01');
+console.log(t.finance.fiscalQuarter); // 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,6))])}const f=t(k,[["render",o]]);export{u as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.lean.js new file mode 100644 index 00000000..44c278c0 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_finance.index.md.CughzpD9.lean.js @@ -0,0 +1 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as t,C as e,o as p,c as l,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-finance","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/finance.index.md","filePath":"doc/9-plugins/finance.index.md"}'),k={name:"doc/9-plugins/finance.index.md"};function o(r,s,g,c,d,m){const a=e("PluginRepl");return p(),l("div",null,[s[0]||(s[0]=i("",7)),h(a,{plugin:"finance"}),s[1]||(s[1]=i("",6))])}const f=t(k,[["render",o]]);export{u as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.js new file mode 100644 index 00000000..05c4ab74 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.js @@ -0,0 +1,33 @@ +import{_ as i,o as a,c as l,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Cultural Locale Synchronization","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.cultural-sync.md","filePath":"doc/9-plugins/geo.cultural-sync.md"}'),e={name:"doc/9-plugins/geo.cultural-sync.md"};function t(h,s,p,k,r,o){return a(),l("div",null,[...s[0]||(s[0]=[n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-geo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cultural Locale Synchronization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explores the cultural synchronization engine in @magmacomputing/tempo-plugin-geo, linking physical geography with localized language, date formatting, and regional calendar conventions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Challenge of Geographic Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a user travels or logs in from another country (e.g. from London to Tokyo or Cairo), updating their timeZone alone is often insufficient:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Updating timezone shifts the clock time, but date formatting and day names might still remain in the home language (en-US).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Setting a cultural locale (ar-EG, ja-JP, de-DE, fr-FR) ensures month names, day names, relative periods ("yesterday", "tomorrow"), and calendar numbering conventions match the observer's physical territory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Automatic Cultural Sync (t.geoLocate({ setLocale })) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When calling t.geoLocate(), the setLocale option controls how the BCP 47 locale is synchronized with physical geography:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 'native': Converts to the primary native language and culture of the territory (e.g. ar-EG in Egypt, ja-JP in Japan).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • true / 'regional' (default): Preserves the caller's source language while adapting regional calendar rules (e.g. en-US + EG → en-EG).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom BCP 47 string: Explicit override (e.g. 'fr-EG').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • false / 'none': Opts out of locale synchronization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);
+
+const t = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: 30.0444, lng: 31.2357, country: 'EG' } // Cairo, Egypt
+});
+
+// 1. Native Cultural Sync: adopts Egypt's primary native language (Arabic)
+const localizedNative = await t.geoLocate({ setLocale: 'native' });
+
+console.log(localizedNative.tz);                            // 'Africa/Cairo'
+console.log(localizedNative.locale);                        // 'ar-EG'
+console.log(localizedNative.format({ dateStyle: 'full' })); // 'الأحد، ٢١ يونيو ٢٠٢٦'
+
+// 2. Regional Adaptation (default): keeps English language, adapts Egyptian calendar/weekend
+const localizedRegional = await t.geoLocate({ setLocale: true });
+
+console.log(localizedRegional.locale);                        // 'en-EG'
+console.log(localizedRegional.format({ dateStyle: 'full' })); // 'Sunday, 21 June 2026'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Call-Site Preference Priority ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explicit caller preferences always take absolute precedence:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Explicit custom BCP 47 tag
+const custom = await t.geoLocate({ setLocale: 'fr-EG' });
+console.log(custom.locale); // 'fr-EG'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Pure Cultural Locale Inference (resolveCulturalLocale) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolveCulturalLocale maps geographic coordinates, ISO country codes, or bounding territories to a standard BCP 47 locale tag:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { resolveCulturalLocale } from '@magmacomputing/tempo-plugin-geo';
+
+// From geographic coordinate objects
+console.log(resolveCulturalLocale({ lat: 35.6762, lng: 139.6503 })); // 'ja-JP' (Tokyo)
+console.log(resolveCulturalLocale({ lat: 52.5200, lng: 13.4050 }));  // 'de-DE' (Berlin)
+console.log(resolveCulturalLocale({ lat: 48.8566, lng: 2.3522 }));   // 'fr-FR' (Paris)
+console.log(resolveCulturalLocale({ lat: -33.8688, lng: 151.2093 })); // 'en-AU' (Sydney)
+
+// From country code directly
+console.log(resolveCulturalLocale({ countryCode: 'BR' })); // 'pt-BR'
+console.log(resolveCulturalLocale({ countryCode: 'IT' })); // 'it-IT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Internationalization Synergy with @magmacomputing/library ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolveCulturalLocale leverages getLC() from #library/international.library.js. It validates and memoizes Intl.Locale instances, applying defensive normalization to avoid runtime locale tag errors across different JavaScript runtimes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,23)])])}const g=i(e,[["render",t]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.lean.js new file mode 100644 index 00000000..7fbcdbe8 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.cultural-sync.md.CPpBygZ9.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as l,a2 as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Cultural Locale Synchronization","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.cultural-sync.md","filePath":"doc/9-plugins/geo.cultural-sync.md"}'),e={name:"doc/9-plugins/geo.cultural-sync.md"};function t(h,s,p,k,r,o){return a(),l("div",null,[...s[0]||(s[0]=[n("",23)])])}const g=i(e,[["render",t]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.js new file mode 100644 index 00000000..501e8d9c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.js @@ -0,0 +1,33 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as a,C as n,o as l,c as o,a2 as e,E as p}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-geo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.index.md","filePath":"doc/9-plugins/geo.index.md"}'),r={name:"doc/9-plugins/geo.index.md"};function h(d,t,g,c,k,y){const i=n("PluginRepl");return l(),o("div",null,[t[0]||(t[0]=e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-geo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A dedicated Community plugin for the Tempo ecosystem providing universal geolocation lookup, forward and reverse geocoding gateway, pluggable provider architecture, cultural locale synchronization, and multi-tenant bounded coordinate caching.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For geometric GIS math, Great-Circle navigation, and impossible travel anomaly detection, see @magmacomputing/tempo-plugin-spatial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-geo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture & Namespacing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installing GeoPlugin mounts an immutable, locked-down Tempo.geo static namespace onto the Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-geo/install';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore detailed guides on specific capabilities:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Provider Gateway & Geocoding: Forward geocoding, reverse geocoding, custom geocoding providers (OpenStreetMapProvider, IpApiProvider, MockGeoProvider), and call-site overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cultural Synchronization: Automatic cultural locale inference (setLocale: true / 'native'), territorial language resolution, and internationalization synergy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Storage & Multi-Tenant Caching: Ambient coordinate caching, 24h TTL BoundedCache, tenant isolation, and server vs. client operational warnings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Use Cases & Architectural Patterns: Multi-tenant SaaS localization, pluggable geocoding gateways, isolated tenant storage caching, and server edge middleware.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Which Method Should I Choose? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GoalMethod to UseInputOutput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Where is this machine / user right now?"await Tempo.geo.lookup({ refresh: true })None / { refresh: true }Fresh { latitude, longitude, city, ... }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Convert place name / address to coordinates"await Tempo.geo.forward("Paris")Address query string{ latitude, longitude, ... }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Convert GPS coordinates to street / city / country"await Tempo.geo.reverse({ lat, lng })Coordinate object{ city, country, ... }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Extract or safely normalize coordinates from any input"await Tempo.geo.resolve(input)Instance, config, or objectCanonical { latitude, longitude, ... }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Localize a Tempo instance with timezone & cultural calendar"await t.geoLocate()Existing Tempo instanceNew enriched Tempo instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive Tempo.geo API Surface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Method / PropertyCategoryDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.lookup(opts?)LookupUniversal geolocation lookup (browser hardware GPS or server IP lookup) cached for 24h. Supports { refresh: true }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.reverse(coords, opts?)GeocodingReverse geocodes coordinates to locality/address metadata (city, country, displayName, etc.) using active provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.forward(query, opts?)GeocodingForward geocodes place query string to coordinates using active provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.setProvider(provider)Provider GatewaySets custom geolocation/geocoding provider gateway (e.g. OpenStreetMap, Mapbox, internal IP proxy).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.getProvider()Provider GatewayRetrieves the active custom geolocation provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.resolve(input, opts?)UtilityAsynchronously resolves coordinates from an instance, configuration, or ambient storage cache.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.coerce(input)GeometryPure function normalizing various coordinate formats (lat/lng, latitude/longitude, tuples, etc.) into a canonical GeoConfig.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolveCulturalLocale(locale?, country?, mode?)Cultural SyncStandalone function resolving synchronized BCP 47 locale from current locale and ISO country code/name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.stash(coords, ttl?, keyOrOpts?)StorageStashes coordinates in storage with an optional custom TTL (default: 24h) and multi-tenant partitioning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.clear(keyOrOpts?)StoragePurges stashed coordinates from storage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.get(keyOrOpts?)StorageReads stashed coordinates for the specified tenant/IP or ambient default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.currentStorageRead-only getter returning the active global/ambient coordinates snapshot (getStashedGeo() ?? Tempo.config.geo).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.server(opts?)Low-LevelLow-level server-side IP geolocation handler.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.geo.browser(opts?)Low-LevelLow-level browser Geolocation API handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fluent Instance Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance MethodDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.geoLocate(opts?)Asynchronously resolves physical location (with optional reverse geocoding { reverse: true } and cultural locale synchronization { setLocale: true }) and returns a new enriched Tempo instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.geoLookup(opts?)Resolves coordinates for this instance via explicit coordinates or automatic IP/hardware lookup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,28)),p(i,{plugin:"geo"}),t[1]||(t[1]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Fluent OOP with Tempo.geo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);
+
+// Universal Geolocation Lookup (cached for 24h)
+const lookup = await Tempo.geo.lookup();
+console.log(lookup.lat, lookup.lng, lookup.city);
+
+// Enrich a Tempo instance with physical reality and native cultural locale
+const t = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: 30.0444, lng: 31.2357, country: 'EG' } // Cairo, Egypt
+});
+const localTime = await t.geoLocate({ setLocale: 'native' });
+console.log(localTime.geo?.latitude, localTime.geo?.longitude);
+console.log(localTime.locale); // 'ar-EG'
+console.log(localTime.format({ dateStyle: 'full' })); // 'الأحد، ٢١ يونيو ٢٠٢٦' (Arabic Egyptian culture)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Reverse Geocoding and Instance Enrichment ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);
+
+// Reverse geocode coordinates to place details (using built-in lookup or custom GeoProvider)
+const place = await Tempo.geo.reverse({ lat: -33.8688, lng: 151.2093 });
+console.log(place?.city, place?.country); // Sydney, AU
+
+// Or enrich an existing instance via t.geoLocate({ reverse: true })
+const t = new Tempo({ geo: { lat: -33.8688, lng: 151.2093 } });
+const enriched = await t.geoLocate({ reverse: true });
+console.log(enriched.geo?.city, enriched.geo?.country); // Sydney, AU

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Security & Immutability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In keeping with Tempo's strict immutability principles, the Tempo.geo namespace is fully locked down:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deeply Frozen: The entire Tempo.geo namespace and attached utilities are recursively frozen via deepFreeze.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tamper-Proof: Protected against reassignment or monkey-patching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pure Instance Operations: Instance methods like t.geoLocate() return new, enriched Tempo instances, preserving the immutability of the original instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,11))])}const f=a(r,[["render",h]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.lean.js new file mode 100644 index 00000000..3513e039 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.index.md.DxETixJP.lean.js @@ -0,0 +1 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as a,C as n,o as l,c as o,a2 as e,E as p}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-geo","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.index.md","filePath":"doc/9-plugins/geo.index.md"}'),r={name:"doc/9-plugins/geo.index.md"};function h(d,t,g,c,k,y){const i=n("PluginRepl");return l(),o("div",null,[t[0]||(t[0]=e("",28)),p(i,{plugin:"geo"}),t[1]||(t[1]=e("",11))])}const f=a(r,[["render",h]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.js new file mode 100644 index 00000000..c3cce626 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.js @@ -0,0 +1,89 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Pluggable Geocoding Provider Gateway","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.provider-gateway.md","filePath":"doc/9-plugins/geo.provider-gateway.md"}'),h={name:"doc/9-plugins/geo.provider-gateway.md"};function l(k,s,p,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-geo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pluggable Geocoding Provider Gateway ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains how to connect custom geocoding and geolocation providers (such as OpenStreetMap Nominatim, Mapbox, Google Maps, or internal corporate IP proxies) to @magmacomputing/tempo-plugin-geo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Overview & GeoProvider Interface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, @magmacomputing/tempo-plugin-geo uses browser hardware geolocation in browser environments and public IP geolocation on servers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Pluggable Geocoding Provider Gateway allows developers to register custom providers to customize coordinate resolution, forward geocoding (place query → coordinates), and reverse geocoding (coordinates → address/city/country metadata):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface GeoProvider {
+  /** Unique provider identifier */
+  readonly name: string;
+  /** Primary coordinate and location resolution */
+  lookup(opts?: Record<string, any>): Promise<GeoLookupResult | null>;
+  /** Optional reverse geocoding from coordinates to location metadata */
+  reverseGeocode?(coords: CoordinateInput, opts?: Record<string, any>): Promise<GeoConfig | null>;
+  /** Optional forward geocoding from place query string to coordinates */
+  forwardGeocode?(query: string, opts?: Record<string, any>): Promise<ResolvedCoordinates | null>;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Registering a Provider ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Global Static Registration (Tempo.geo.setProvider) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can register an active provider globally on the Tempo.geo namespace:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin, type GeoProvider } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);
+
+// Simple 1 req/sec throttle for public OSM Nominatim usage policy
+let nextOsmSlot = 0;
+async function throttleOsm() {
+  const now = Date.now();
+  const scheduledTime = Math.max(now, nextOsmSlot);
+  nextOsmSlot = scheduledTime + 1000;
+  const wait = scheduledTime - now;
+  if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+}
+
+// Example: OpenStreetMap Nominatim Provider (or commercial Mapbox/LocationIQ)
+const openStreetMapProvider: GeoProvider = {
+  name: 'openstreetmap',
+
+  // 1. Primary Lookup (fall back to default GPS / IP)
+  async lookup() {
+    return null;
+  },
+
+  // 2. Forward Geocoding: Place Query -> Coordinates
+  async forwardGeocode(query: string) {
+    await throttleOsm();
+    const url = \`https://nominatim.openstreetmap.org/search?q=\${encodeURIComponent(query)}&format=json&limit=1&addressdetails=1\`;
+    const res = await fetch(url, {
+      headers: { 'User-Agent': 'YourApp-TempoGateway/1.0 (contact@example.com)' }
+    });
+    const list = await res.json();
+    if (!Array.isArray(list) || list.length === 0) return null;
+
+    const first = list[0];
+    const lat = parseFloat(first.lat);
+    const lng = parseFloat(first.lon);
+    return {
+      lat,
+      lng,
+      latitude: lat,
+      longitude: lng,
+      city: first.address?.city ?? first.address?.town ?? first.address?.suburb,
+      country: first.address?.country_code ? first.address.country_code.toUpperCase() : undefined,
+      sphere: lat >= 0 ? 'north' : 'south',
+    };
+  },
+
+  // 3. Reverse Geocoding: Coordinates -> Address Details
+  async reverseGeocode(coords) {
+    await throttleOsm();
+    const lat = (coords as any).latitude ?? (coords as any).lat;
+    const lng = (coords as any).longitude ?? (coords as any).lng;
+    const url = \`https://nominatim.openstreetmap.org/reverse?lat=\${lat}&lon=\${lng}&format=json\`;
+    const res = await fetch(url, {
+      headers: { 'User-Agent': 'YourApp-TempoGateway/1.0 (contact@example.com)' }
+    });
+    const data = await res.json();
+    return {
+      city: data.address?.city ?? data.address?.town ?? data.address?.suburb,
+      country: data.address?.country_code ? data.address.country_code.toUpperCase() : undefined,
+    };
+  }
+};
+
+Tempo.geo.setProvider(openStreetMapProvider);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throttleOsm operates within a single JavaScript runtime and does not limit combined traffic across concurrent users or browser tabs. Because public OpenStreetMap Nominatim enforces a strict global rate limit of 1 request per second with a contact User-Agent header, multi-user applications should route requests through a shared backend gateway with centralized rate-limiting and caching, or use a dedicated commercial service (e.g. Mapbox, LocationIQ) or self-hosted Nominatim container.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Plugin Installation Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also pass the provider when loading the plugin:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.use(GeoPlugin, {
+  provider: openStreetMapProvider,
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C. Call-Site Override ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Providers can also be overridden per call:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-06-21T12:00:00Z');
+const located = await t.geoLocate({ provider: openStreetMapProvider });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Forward & Reverse Geocoding Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If a provider implements forwardGeocode and reverseGeocode, you can invoke them via Tempo.geo.forward() and Tempo.geo.reverse():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Forward Geocoding: Search query -> Coordinates
+const coords = await Tempo.geo.forward('Sydney Opera House');
+console.log('Coordinates:', coords?.latitude, coords?.longitude);
+console.log('City:', coords?.city, 'Country:', coords?.country);
+
+// Attach resolved coordinates to a Tempo instance:
+const sydneyTime = new Tempo('now', { geo: coords });
+console.log('Season in Sydney:', sydneyTime.term.szn);
+
+// 2. Reverse Geocoding: Coordinates -> Locality Metadata
+const details = await Tempo.geo.reverse({ lat: 48.8566, lng: 2.3522 });
+console.log('Reverse Geocoded:', details?.city, details?.country); // 'Paris', 'FR'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Built-in Caching & Automatic Failover ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 24-Hour Bounded Cache: Successful coordinate resolutions through custom providers are automatically stashed in the 24-hour cache layer with multi-tenant partitioning (Tempo.geo.lookup()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Graceful Failover: If a custom provider encounters a network error or rate limit, geoLookup automatically falls back to the default environment lookup unless { fallback: false } is specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,28)])])}const g=i(h,[["render",l]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.lean.js new file mode 100644 index 00000000..3e80d086 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.provider-gateway.md.Djynjt20.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Pluggable Geocoding Provider Gateway","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.provider-gateway.md","filePath":"doc/9-plugins/geo.provider-gateway.md"}'),h={name:"doc/9-plugins/geo.provider-gateway.md"};function l(k,s,p,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t("",28)])])}const g=i(h,[["render",l]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.js new file mode 100644 index 00000000..1e46e786 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.js @@ -0,0 +1,24 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Storage & Multi-Tenant Caching","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.storage-and-caching.md","filePath":"doc/9-plugins/geo.storage-and-caching.md"}'),t={name:"doc/9-plugins/geo.storage-and-caching.md"};function l(p,s,h,o,r,k){return a(),n("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-geo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Storage & Multi-Tenant Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide covers coordinate persistence, 24-hour TTL caching, multi-tenant partitioning, and critical operational warnings when using @magmacomputing/tempo-plugin-geo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ambient Stashing & 24-Hour Bounded Cache ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To prevent redundant network requests, Tempo.geo.lookup() automatically caches coordinates for 24 hours using BoundedCache from @magmacomputing/tempo/library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+Tempo.use(GeoPlugin);
+
+// First call performs network lookup & caches result
+const coords = await Tempo.geo.lookup();
+
+// Subsequent calls return the cached snapshot instantaneously
+const cached = await Tempo.geo.lookup();
+
+// Force fresh network lookup by bypassing cache
+const fresh = await Tempo.geo.lookup({ refresh: true });
+
+// Read ambient active snapshot synchronously
+console.log(Tempo.geo.current);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-Tenant Partitioning (keyOrOpts) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Tenant Isolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unpartitioned ambient storage is shared. In multi-tenant environments, always use unique tenant keys or instance-level options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In a shared backend process handling concurrent requests for different tenants, storing coordinates under the global ambient key will cause tenants to overwrite each other.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Solution A: Keyed Partitioning ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pass a tenant identifier or user ID:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Stash coordinates for Tenant Alpha
+Tempo.geo.stash(tenantACoords, undefined, 'tenant-alpha');
+
+// Read coordinates for Tenant Alpha
+const alphaCoords = Tempo.geo.get('tenant-alpha');
+
+// Clear coordinates for Tenant Alpha
+Tempo.geo.clear('tenant-alpha');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Under the hood, storage keys are partitioned under _magma_geo_:<tenant-id>, ensuring strict multi-tenant isolation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Attach coordinates directly to Tempo instances:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const tenantTime = new Tempo(date, { geo: tenantCoords });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance-level coordinates are local, immutable, and never touch shared memory or global caches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Server IP vs. Client Location Operational Warnings ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Server IP vs. User Location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ambient IP lookup on a server resolves the SERVER's location, NOT the user's location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • In a server environment (Node.js, Deno, Bun, Edge runtimes), calling Tempo.geo.lookup() without an explicit IP queries the server datacenter's public outbound IP address.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If your server runs in AWS us-east-1 (Virginia) and an Australian user hits your API, calling ambient Tempo.geo.lookup() will resolve to Virginia!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Best Practice for Backends:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Always extract the client IP from trusted reverse proxy headers (e.g., X-Forwarded-For, CF-Connecting-IP) and pass it explicitly:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const userCoords = await Tempo.geo.lookup({ ip: clientIp });
+const userTime = new Tempo(date, { geo: userCoords });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Or receive explicit GPS/browser coordinates from the frontend client request payload.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,24)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.lean.js new file mode 100644 index 00000000..2a3bb15d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.storage-and-caching.md.CjgH3ITl.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as e}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Storage & Multi-Tenant Caching","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.storage-and-caching.md","filePath":"doc/9-plugins/geo.storage-and-caching.md"}'),t={name:"doc/9-plugins/geo.storage-and-caching.md"};function l(p,s,h,o,r,k){return a(),n("div",null,[...s[0]||(s[0]=[e("",24)])])}const g=i(t,[["render",l]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.js new file mode 100644 index 00000000..3ae84694 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.js @@ -0,0 +1,103 @@ +import{_ as e,o as n,c as t,a2 as l,j as i,a}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.use-cases-and-patterns.md","filePath":"doc/9-plugins/geo.use-cases-and-patterns.md"}'),p={name:"doc/9-plugins/geo.use-cases-and-patterns.md"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"};function E(y,s,c,F,u,m){return n(),t("div",null,[s[31]||(s[31]=l('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-geo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modern cloud applications serve global users across varying jurisdictions, languages, and timezones. Handling geographic context in production requires solving three architectural challenges:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Vendor Independence: Decoupling your application code from specific proprietary geocoding APIs (Google Maps, Mapbox, OpenCage, or self-hosted Nominatim).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-Tenant Context Partitioning: Caching geographic metadata without leaking coordinates across enterprise tenants or making expensive repeated HTTP lookups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Cultural Localization: Automatically adapting dates, time formats, first day of the week, and number formats based on visitor location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-geo plugin provides an extensible provider gateway, multi-tenant partitioned caching, and cultural locale synchronization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Multi-Tenant SaaS Cultural Locale Synchronization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When an international customer visits an e-commerce or booking platform, their browser locale might be generic (en-US), but their physical IP or GPS location is Australia, Japan, or Egypt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using resolveCulturalLocale, apps dynamically align formatting conventions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',10)),i("ul",null,[i("li",null,[s[2]||(s[2]=i("strong",null,[i("code",null,"'regional'"),a(" mode")],-1)),s[3]||(s[3]=a(": Preserves user language while adjusting regional formatting (e.g. ",-1)),s[4]||(s[4]=i("code",null,"en-US",-1)),s[5]||(s[5]=a(" in ",-1)),s[6]||(s[6]=i("code",null,"AU",-1)),s[7]||(s[7]=a()),i("mjx-container",h,[(n(),t("svg",k,[...s[0]||(s[0]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[8]||(s[8]=a()),s[9]||(s[9]=i("code",null,"en-AU",-1)),s[10]||(s[10]=a(" for ",-1)),s[11]||(s[11]=i("code",null,"DD/MM/YYYY",-1)),s[12]||(s[12]=a(" dates).",-1))]),i("li",null,[s[17]||(s[17]=i("strong",null,[i("code",null,"'native'"),a(" mode")],-1)),s[18]||(s[18]=a(": Fully translates to the country's primary official language (e.g. ",-1)),s[19]||(s[19]=i("code",null,"en-US",-1)),s[20]||(s[20]=a(" in ",-1)),s[21]||(s[21]=i("code",null,"JP",-1)),s[22]||(s[22]=a()),i("mjx-container",r,[(n(),t("svg",o,[...s[13]||(s[13]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[14]||(s[14]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[23]||(s[23]=a()),s[24]||(s[24]=i("code",null,"ja-JP",-1)),s[25]||(s[25]=a(", or ",-1)),s[26]||(s[26]=i("code",null,"EG",-1)),s[27]||(s[27]=a()),i("mjx-container",d,[(n(),t("svg",g,[...s[15]||(s[15]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[16]||(s[16]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[28]||(s[28]=a()),s[29]||(s[29]=i("code",null,"ar-EG",-1)),s[30]||(s[30]=a(").",-1))])]),s[32]||(s[32]=l(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { resolveCulturalLocale } from '@magmacomputing/tempo-plugin-geo';
+
+export function formatInvoiceDateForVisitor(
+  dateIso: string,
+  userAcceptLanguage: string,
+  visitorCountry: string
+): string {
+  // Synchronize locale to visitor's geographic region
+  const targetLocale = resolveCulturalLocale(userAcceptLanguage, visitorCountry, 'regional') ?? userAcceptLanguage;
+
+  const invoiceDate = new Tempo(dateIso, {
+    locale: targetLocale,
+    geo: { country: visitorCountry }
+  });
+
+  return invoiceDate.format('{shortDate}');
+}
+
+// Example 1: American tourist booking in Sydney, Australia
+// Output switches to DD/MM/YYYY convention
+const sydneyBooking = formatInvoiceDateForVisitor('2026-03-05', 'en-US', 'AU');
+console.log(sydneyBooking); // '05/03/2026'
+
+// Example 2: Native mode conversion for local language
+const tokyoNative = resolveCulturalLocale('en-US', 'JP', 'native');
+console.log(tokyoNative); // 'ja-JP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Pluggable Resilient Geocoding Gateway (Custom Provider) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hard-coding proprietary geocoding SDKs creates vendor lock-in and high recurring API bills. Tempo.geo.setProvider lets you plug in any custom provider (Mapbox, OpenStreetMap Nominatim, or an internal microservice) through a uniform interface:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-geo/install';
+import { Tempo } from '@magmacomputing/tempo';
+import type { GeoProvider } from '@magmacomputing/tempo-plugin-geo';
+
+// Implement enterprise proxy with fallback
+const enterpriseGeoGateway: GeoProvider = {
+  name: 'enterprise-geocoder',
+
+  async lookup(opts) {
+    const res = await fetch('/api/internal/geo/lookup');
+    return res.json();
+  },
+
+  async forwardGeocode(query, opts) {
+    const res = await fetch(\`/api/internal/geo/forward?q=\${encodeURIComponent(query)}\`);
+    return res.json();
+  },
+
+  async reverseGeocode(coords, opts) {
+    const lat = typeof coords === 'object' && 'lat' in coords ? coords.lat : coords[0];
+    const lng = typeof coords === 'object' && 'lng' in coords ? coords.lng : coords[1];
+
+    const res = await fetch(\`/api/internal/geo/reverse?lat=\${lat}&lng=\${lng}\`);
+    return res.json();
+  }
+};
+
+// Register gateway globally
+Tempo.geo.setProvider(enterpriseGeoGateway);
+
+// All Tempo.geo calls now route through the enterprise gateway
+const location = await Tempo.geo.forward('100 Queen St, Melbourne');
+console.log(location.country, location.lat, location.lng);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Multi-Tenant Partitioned Geo Storage & 24h Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calling external geocoding APIs on every incoming HTTP request degrades latency and exhausts rate limits. Tempo.geo.stash and Tempo.geo.get provide built-in partitioned storage with TTL support:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-geo/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export async function resolveTenantLocation(
+  tenantId: string,
+  rawAddress: string
+) {
+  const partitionKey = \`tenant_\${tenantId}\`;
+
+  // 1. Check partitioned cache first
+  const cached = Tempo.geo.get({ partition: partitionKey });
+  if (cached) {
+    return cached;
+  }
+
+  // 2. Perform external geocoding lookup
+  const resolved = await Tempo.geo.forward(rawAddress);
+
+  // 3. Stash coordinates in tenant's isolated partition for 24 hours
+  Tempo.geo.stash(resolved, {
+    partition: partitionKey,
+    ttl: 86_400_000 // 24 hours in ms
+  });
+
+  return resolved;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Server-Side Edge Middleware Request Localization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Next.js, Remix, Fastify, or Cloudflare Workers, incoming requests include CDN geographic headers (e.g. cf-ipcountry or x-vercel-ip-country). Edge middleware can extract these headers, hydrate a Tempo instance, and pass it downstream via request context:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-geo/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export function createRequestContext(req: Request) {
+  // Extract edge CDN geolocation headers
+  const country = req.headers.get('cf-ipcountry') ?? 'US';
+  const timeZone = req.headers.get('cf-timezone') ?? 'UTC';
+
+  // Instantiate request-scoped Tempo context
+  const requestTime = new Tempo('now', {
+    geo: { country },
+    timeZone
+  });
+
+  return {
+    requestTime,
+    visitorCountry: country,
+    visitorTimeZone: timeZone
+  };
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,13))])}const D=e(p,[["render",E]]);export{A as __pageData,D as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.lean.js new file mode 100644 index 00000000..4dbc5cb9 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_geo.use-cases-and-patterns.md.lWL9YkMu.lean.js @@ -0,0 +1 @@ +import{_ as e,o as n,c as t,a2 as l,j as i,a}from"./chunks/framework.DNL3hc5c.js";const A=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/geo.use-cases-and-patterns.md","filePath":"doc/9-plugins/geo.use-cases-and-patterns.md"}'),p={name:"doc/9-plugins/geo.use-cases-and-patterns.md"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.025ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.262ex",height:"1.181ex",role:"img",focusable:"false",viewBox:"0 -511 1000 522","aria-hidden":"true"};function E(y,s,c,F,u,m){return n(),t("div",null,[s[31]||(s[31]=l("",10)),i("ul",null,[i("li",null,[s[2]||(s[2]=i("strong",null,[i("code",null,"'regional'"),a(" mode")],-1)),s[3]||(s[3]=a(": Preserves user language while adjusting regional formatting (e.g. ",-1)),s[4]||(s[4]=i("code",null,"en-US",-1)),s[5]||(s[5]=a(" in ",-1)),s[6]||(s[6]=i("code",null,"AU",-1)),s[7]||(s[7]=a()),i("mjx-container",h,[(n(),t("svg",k,[...s[0]||(s[0]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[8]||(s[8]=a()),s[9]||(s[9]=i("code",null,"en-AU",-1)),s[10]||(s[10]=a(" for ",-1)),s[11]||(s[11]=i("code",null,"DD/MM/YYYY",-1)),s[12]||(s[12]=a(" dates).",-1))]),i("li",null,[s[17]||(s[17]=i("strong",null,[i("code",null,"'native'"),a(" mode")],-1)),s[18]||(s[18]=a(": Fully translates to the country's primary official language (e.g. ",-1)),s[19]||(s[19]=i("code",null,"en-US",-1)),s[20]||(s[20]=a(" in ",-1)),s[21]||(s[21]=i("code",null,"JP",-1)),s[22]||(s[22]=a()),i("mjx-container",r,[(n(),t("svg",o,[...s[13]||(s[13]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[14]||(s[14]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[23]||(s[23]=a()),s[24]||(s[24]=i("code",null,"ja-JP",-1)),s[25]||(s[25]=a(", or ",-1)),s[26]||(s[26]=i("code",null,"EG",-1)),s[27]||(s[27]=a()),i("mjx-container",d,[(n(),t("svg",g,[...s[15]||(s[15]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mo"},[i("path",{"data-c":"2192",d:"M56 237T56 250T70 270H835Q719 357 692 493Q692 494 692 496T691 499Q691 511 708 511H711Q720 511 723 510T729 506T732 497T735 481T743 456Q765 389 816 336T935 261Q944 258 944 250Q944 244 939 241T915 231T877 212Q836 186 806 152T761 85T740 35T732 4Q730 -6 727 -8T711 -11Q691 -11 691 0Q691 7 696 25Q728 151 835 230H70Q56 237 56 250Z",style:{"stroke-width":"3"}})])])],-1)])])),s[16]||(s[16]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mo",{stretchy:"false"},"→")])],-1))]),s[28]||(s[28]=a()),s[29]||(s[29]=i("code",null,"ar-EG",-1)),s[30]||(s[30]=a(").",-1))])]),s[32]||(s[32]=l("",13))])}const D=e(p,[["render",E]]);export{A as __pageData,D as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.js new file mode 100644 index 00000000..615563b6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.js @@ -0,0 +1,58 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Business Days & SLA Arithmetic","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.business-days.md","filePath":"doc/9-plugins/holidays.business-days.md"}'),h={name:"doc/9-plugins/holidays.business-days.md"};function l(e,s,k,p,d,r){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-holidays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business Days & SLA Arithmetic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Regional Holidays Plugin extends Tempo with robust business day operations and SLA (Service Level Agreement) working hours arithmetic under the t.holidays namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determining Working Business Days ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A date is considered a business day if:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. It does not fall on a weekend day (according to the cultural locale weekend definition in tempo.intl.weekend, defaulting to Saturday/Sunday).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. It does not fall on a recognized public holiday in the active country/region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. It does not match any date in options.customHolidays.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// US Independence Day (Observed Friday July 3, 2026)
+const t1 = new Tempo('2026-07-03', { geo: { country: 'US' } });
+console.log(t1.holidays.isBusinessDay()); // false (Holiday)
+
+// Regular Monday
+const t2 = new Tempo('2026-07-06', { geo: { country: 'US' } });
+console.log(t2.holidays.isBusinessDay()); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.holidays.nextBusinessDay() and t.holidays.prevBusinessDay() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Skips over weekends and intervening public holidays to find the nearest valid working business day:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Thursday July 2, 2026 (US)
+const start = new Tempo('2026-07-02', { geo: { country: 'US' } });
+
+// Friday July 3 is Independence Day (Observed), July 4-5 is the weekend
+const next = start.holidays.nextBusinessDay();
+console.log(next.format('{yyyy}-{mm}-{dd}')); // '2026-07-06' (Monday)
+
+// Stepping backwards from Monday July 6
+const prev = next.holidays.prevBusinessDay();
+console.log(prev.format('{yyyy}-{mm}-{dd}')); // '2026-07-02' (Thursday)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adding Business Days ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.holidays.addBusinessDays(amount, options?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds or subtracts a specific number of working business days:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const orderDate = new Tempo('2026-07-02', { geo: { country: 'US' } });
+
+// Add 3 business days:
+// Day 1: Mon July 6
+// Day 2: Tue July 7
+// Day 3: Wed July 8
+const deliveryDate = orderDate.holidays.addBusinessDays(3);
+console.log(deliveryDate.format('{yyyy}-{mm}-{dd}')); // '2026-07-08'
+
+// Subtract 3 business days back
+const original = deliveryDate.holidays.addBusinessDays(-3);
+console.log(original.format('{yyyy}-{mm}-{dd}')); // '2026-07-02'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Counting Business Days Between Dates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.holidays.businessDaysUntil(target, options?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the exact number of full business days between two dates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const start = new Tempo('2026-07-02', { geo: { country: 'US' } });
+const end = new Tempo('2026-07-08', { geo: { country: 'US' } });
+
+console.log(start.holidays.businessDaysUntil(end)); // 3
+console.log(end.holidays.businessDaysUntil(start)); // -3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SLA Working Hours Calculation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.holidays.workingHoursUntil(deadline, options?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the exact number of SLA-eligible working hours between two timestamps, taking into account:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configurable working day hours (defaults to 9:00 AM to 5:00 PM).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Exclusion of non-working weekend days.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Exclusion of regional public holidays and custom non-working days.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Ticket opened on Friday Jan 23, 2026 at 3:00 PM in Australia
+const opened = new Tempo('2026-01-23 15:00:00', { geo: { country: 'AU' } });
+
+// Ticket resolved on Tuesday Jan 27, 2026 at 11:00 AM
+// (Monday Jan 26 is Australia Day public holiday)
+const resolved = new Tempo('2026-01-27 11:00:00', { geo: { country: 'AU' } });
+
+const slaHours = opened.holidays.workingHoursUntil(resolved);
+console.log(slaHours); // 4.0 hours
+// Breakdown:
+// - Friday Jan 23: 15:00 to 17:00 = 2.0 hours
+// - Saturday Jan 24: Weekend = 0 hours
+// - Sunday Jan 25: Weekend = 0 hours
+// - Monday Jan 26: Australia Day = 0 hours
+// - Tuesday Jan 27: 09:00 to 11:00 = 2.0 hours
+// Total: 4.0 working hours

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Work Hour Windows ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Custom 8:00 AM to 4:00 PM working day
+const hours = opened.holidays.workingHoursUntil(resolved, {
+  startHour: 8,
+  endHour: 16,
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cultural Locale Weekend Awareness ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Different countries have different working weeks. For example, in Saudi Arabia (ar-SA) and other Middle Eastern jurisdictions, the weekend is Friday and Saturday, and Sunday is a working business day.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo automatically respects the active locale's weekend definition via tempo.intl.weekend:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Saudi Arabia (ar-SA)
+const friday = new Tempo('2026-05-15', { locale: 'ar-SA', geo: { country: 'SA' } });
+const sunday = new Tempo('2026-05-17', { locale: 'ar-SA', geo: { country: 'SA' } });
+
+console.log(friday.holidays.isBusinessDay()); // false (Friday is non-working weekend in SA)
+console.log(sunday.holidays.isBusinessDay()); // true  (Sunday is a standard working day in SA)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,37)])])}const g=i(h,[["render",l]]);export{y as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.lean.js new file mode 100644 index 00000000..af72c9c3 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.business-days.md.BYOLhXcr.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Business Days & SLA Arithmetic","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.business-days.md","filePath":"doc/9-plugins/holidays.business-days.md"}'),h={name:"doc/9-plugins/holidays.business-days.md"};function l(e,s,k,p,d,r){return a(),n("div",null,[...s[0]||(s[0]=[t("",37)])])}const g=i(h,[["render",l]]);export{y as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.js new file mode 100644 index 00000000..86ed12ca --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.js @@ -0,0 +1,18 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as t,o as l,c as p,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-holidays","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.index.md","filePath":"doc/9-plugins/holidays.index.md"}'),o={name:"doc/9-plugins/holidays.index.md"};function r(k,s,d,g,c,y){const a=t("PluginRepl");return l(),p("div",null,[s[0]||(s[0]=i('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-holidays ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Regional Holidays Plugin provides bank holiday resolution, weekend observation shifts, SLA working hours calculations, and business day arithmetic for Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero-Latency Built-in Calendars: Instant synchronous holiday calculation for US, Australia, United Kingdom, Canada, Germany, France, Japan, and New Zealand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.geo.country Resolution Cascade: Automatically resolves national calendars via explicit option, tempo.geo.country, tempo.intl.region, or BCP-47 tempo.locale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Long-Tail Coverage (100+ Countries): Dynamic async preloading via @magmacomputing/tempo-fns with automatic 24-hour TTL caching in runtime storage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SLA Working Hours Calculation: t.holidays.workingHoursUntil(deadline) calculates business hours between dates, taking into account working hour windows, weekends, and regional holidays.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cultural Weekend Awareness: Automatically respects cultural workweeks (e.g. Friday/Saturday weekend in Middle Eastern locales like ar-SA).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-holidays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',12)),h(a,{plugin:"holidays"}),s[1]||(s[1]=i(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// Australia Day (Jan 26)
+const t = new Tempo('2026-01-26', { geo: { country: 'AU' } });
+
+console.log(t.holidays.isHoliday());          // true
+console.log(t.holidays.name);                 // 'Australia Day'
+console.log(t.holidays.isBusinessDay());      // false
+
+// Advance to next valid business day past holidays & weekends
+const nextWorkDay = t.holidays.nextBusinessDay();
+console.log(nextWorkDay.format('{yyyy}-{mm}-{dd}')); // '2026-01-27'
+
+// Calculate SLA working hours between dates
+const start = new Tempo('2026-01-23 15:00:00', { geo: { country: 'AU' } }); // Friday 3pm
+const deadline = new Tempo('2026-01-27 11:00:00', { geo: { country: 'AU' } }); // Tuesday 11am
+console.log(start.holidays.workingHoursUntil(deadline)); // 4.0 hours (2h Fri + 0h Sat/Sun/Mon-Holiday + 2h Tue)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Topic Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    License ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,7))])}const F=e(o,[["render",r]]);export{E as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.lean.js new file mode 100644 index 00000000..b20e7954 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.index.md.jPHTM0ST.lean.js @@ -0,0 +1 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as t,o as l,c as p,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-holidays","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.index.md","filePath":"doc/9-plugins/holidays.index.md"}'),o={name:"doc/9-plugins/holidays.index.md"};function r(k,s,d,g,c,y){const a=t("PluginRepl");return l(),p("div",null,[s[0]||(s[0]=i("",12)),h(a,{plugin:"holidays"}),s[1]||(s[1]=i("",7))])}const F=e(o,[["render",r]]);export{E as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.js new file mode 100644 index 00000000..850eb22c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.js @@ -0,0 +1,27 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Regional Calendars & Dynamic Preloading","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.regional-calendars.md","filePath":"doc/9-plugins/holidays.regional-calendars.md"}'),n={name:"doc/9-plugins/holidays.regional-calendars.md"};function l(o,s,h,d,r,p){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-holidays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regional Calendars & Dynamic Preloading ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Regional Holidays Plugin features high-precision offline algorithmic calendars for major world economies and dynamic asynchronous preloading for over 100+ countries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Offline Built-in Calendars ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The following countries are evaluated locally in memory in sub-millisecond execution time with zero network requests:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CountryCodeKey Holidays & Statutory Rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    United StatesUSNew Year's Day, MLK Day (3rd Mon Jan), Washington's Birthday (3rd Mon Feb), Memorial Day (Last Mon May), Juneteenth, Independence Day, Labor Day (1st Mon Sep), Columbus Day (2nd Mon Oct), Veterans Day, Thanksgiving (4th Thu Nov), Christmas Day. State overlays (e.g. Day After Thanksgiving in CA).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AustraliaAUNew Year's Day, Australia Day, Good Friday, Easter Monday, ANZAC Day, King's Birthday, Christmas Day, Boxing Day. State overlays for NSW, VIC, QLD, WA, SA, TAS, ACT, and NT. Melbourne Cup (VIC), King's Birthday October rule (QLD), dual Christmas/Boxing Day weekend shift rules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    United KingdomGBNew Year's Day, Good Friday, Easter Monday, Early May Bank Holiday, Spring Bank Holiday, Summer Bank Holiday, Christmas Day, Boxing Day. Regional overlays for Scotland (SCT - 2nd Jan, August Summer Bank, St Andrew's) and Northern Ireland (NIR - St Patrick's Day, Battle of the Boyne).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CanadaCANew Year's Day, Good Friday, Victoria Day, Canada Day, Civic Holiday, Labour Day, National Day for Truth and Reconciliation, Thanksgiving, Remembrance Day, Christmas Day, Boxing Day. Provincial Family Day overlays.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GermanyDENeujahr, Karfreitag, Ostermontag, Tag der Arbeit, Christi Himmelfahrt, Pfingstmontag, Fronleichnam, Tag der Deutschen Einheit, Reformationstag, Allerheiligen, Weihnachtstag, Zweiter Weihnachtstag. State holiday overlays across all 16 Bundesländer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FranceFRJour de l'An, Lundi de Pâques, Fête du Travail, Victoire 1945, Ascension, Lundi de Pentecôte, Fête Nationale (Bastille Day), Assomption, Toussaint, Armistice 1918, Noël. Alsace-Moselle overlays (Vendredi Saint, Saint-Étienne).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    JapanJP元日 (New Year's), 成人の日 (Coming of Age), 建国記念の日 (National Foundation), 天皇誕生日 (Emperor's Birthday), 春分の日 (Vernal Equinox), 昭和の日 (Shōwa Day), 憲法記念日 (Constitution), みどりの日 (Greenery), こどもの日 (Children's), 海の日 (Marine Day), 山の日 (Mountain Day), 敬老の日 (Respect for the Aged), 秋分の日 (Autumnal Equinox), スポーツの日 (Sports Day), 文化の日 (Culture Day), 勤労感謝の日 (Labor Thanksgiving), 振替休日 (Furikae Kyūjitsu substitute holidays).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New ZealandNZNew Year's Day, Day after New Year's Day, Waitangi Day, Good Friday, Easter Monday, ANZAC Day, King's Birthday, Matariki (statutory dates), Labour Day, Christmas Day, Boxing Day. Mondayisation shift rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolution Hierarchy & Geo Cohesion ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When evaluating a holiday or business day, Tempo resolves the effective country and region using the following priority cascade:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Explicit Option: t.holidays.isHoliday({ country: 'GB', region: 'SCT' })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Instance Geolocation: t.geo.country (and t.geo.region / t.geo.state)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Instance Internationalization: tempo.intl.region
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Instance Locale: BCP-47 tag (e.g. en-AU → 'AU', fr-CA → 'CA', ja-JP → 'JP')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Default Fallback: 'US'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// Geo-aware instance automatically evaluates Australian national and state holidays
+const melb = new Tempo('2026-11-03', {
+  geo: { country: 'AU', region: 'VIC' }
+});
+
+console.log(melb.holidays.isHoliday());       // true
+console.log(melb.holidays.name);              // 'Melbourne Cup Day'
+console.log(melb.holidays.country);           // 'AU'
+console.log(melb.holidays.region);            // 'VIC'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Long-Tail Preloading & Storage Caching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For global applications requiring holiday coverage beyond the 8 built-in economies, the plugin integrates with @magmacomputing/tempo-fns to fetch statutory public holidays for over 100+ countries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fetched calendars are stored in runtime storage with a 24-hour TTL under the _magma_holidays_ namespace and registered into the in-memory engine, allowing subsequent queries to execute synchronously with zero latency.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Static / Async Tempo.holidays.preload() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// Preload Italy (IT) for 2026
+await Tempo.holidays.preload(2026, 'IT');
+
+// All subsequent synchronous calls now recognize Italian public holidays!
+const capodanno = new Tempo('2026-01-01', { geo: { country: 'IT' } });
+console.log(capodanno.holidays.isHoliday());          // true
+console.log(capodanno.holidays.name);                 // 'Capodanno'
+console.log(capodanno.holidays.isBusinessDay());       // false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Instance Method t.holidays.preload() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const brazil = new Tempo('2026-09-07', { geo: { country: 'BR' } });
+
+// Preloads holidays for Brazil for the instance's year
+await brazil.holidays.preload();
+
+console.log(brazil.holidays.isHoliday()); // true (Dia da Independência)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,21)])])}const y=i(n,[["render",l]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.lean.js new file mode 100644 index 00000000..5201d2fc --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.regional-calendars.md.DW1vfRjd.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Regional Calendars & Dynamic Preloading","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.regional-calendars.md","filePath":"doc/9-plugins/holidays.regional-calendars.md"}'),n={name:"doc/9-plugins/holidays.regional-calendars.md"};function l(o,s,h,d,r,p){return a(),t("div",null,[...s[0]||(s[0]=[e("",21)])])}const y=i(n,[["render",l]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.js new file mode 100644 index 00000000..1a81a8da --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.js @@ -0,0 +1,173 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.use-cases-and-patterns.md","filePath":"doc/9-plugins/holidays.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/holidays.use-cases-and-patterns.md"};function t(k,s,p,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[l(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-holidays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Real-world business systems do not run on simple 24/7 timelines. Banking networks close, financial markets freeze trading on statutory holidays, payroll must disburse before long weekends, and SaaS support contracts enforce strict business-hours response SLAs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Naive date math—such as adding 48 hours or multiplying days by 86,400,000 milliseconds—causes immediate production bugs: premature SLA breach alerts, miscalculated trade settlement dates, and payroll disputes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-holidays plugin gives Tempo instances native awareness of public holidays, weekend observation shifts, and business-day arithmetic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Multi-Tenant SaaS SLA Resolution Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In B2B SaaS platforms (such as Zendesk, Jira, or ServiceNow architectures), customer support contracts specify service level agreements (SLAs) based on working business hours in the client's jurisdiction:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "Tier-1 critical incidents acknowledged within 4 business hours."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • "Standard tickets resolved within 2 business days."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If a customer in the UK logs a ticket at 4:30 PM on the Friday before a Bank Holiday, a naive + 48h timer will flag an SLA breach on Sunday afternoon. With tempo-plugin-holidays, the SLA engine respects the client's local country and statutory holidays automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+interface CustomerOrganization {
+  id: string;
+  name: string;
+  country: string; // e.g. 'US', 'GB', 'AU', 'DE'
+  region?: string;  // e.g. 'NSW', 'VIC', 'CA'
+  slaBusinessDays: number;
+}
+
+export function computeSlaDeadline(
+  ticketCreatedAt: string,
+  customer: CustomerOrganization
+): { deadline: Tempo; isRiskOfBreach: boolean; remainingWorkingHours: number } {
+  // 1. Initialize ticket Tempo with the customer's geographic context
+  const ticketTime = new Tempo(ticketCreatedAt, {
+    geo: { country: customer.country, region: customer.region }
+  });
+
+  // 2. Add customer's contracted business days (skips holidays + weekends)
+  const deadline = ticketTime.holidays.addBusinessDays(customer.slaBusinessDays);
+
+  // 3. Compute remaining working hours (standard 9am - 5pm business day)
+  const now = new Tempo('now', {
+    geo: { country: customer.country, region: customer.region }
+  });
+
+  const remainingWorkingHours = now.holidays.workingHoursUntil(deadline, {
+    startHour: 9,
+    endHour: 17
+  });
+
+  return {
+    deadline,
+    isRiskOfBreach: remainingWorkingHours < 4,
+    remainingWorkingHours
+  };
+}
+
+// Example: UK Customer creates ticket on Friday before Summer Bank Holiday
+const ticket = computeSlaDeadline('2026-08-28 16:30:00', {
+  id: 'org_enterprise_uk',
+  name: 'Acme UK Ltd',
+  country: 'GB',
+  slaBusinessDays: 2
+});
+
+// Friday + 2 business days (skipping Sat, Sun, and Bank Holiday Monday Aug 31):
+// Resolves accurately to Wednesday, Sep 2, 2026
+console.log(ticket.deadline.format('{yyyy}-{mm}-{dd}')); // '2026-09-02'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Financial T+2 Settlement & Trade Value Dates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In securities trading, currency exchange (FX), and treasury management, trades settle on T+2 (Trade Date + 2 Business Days). If a trade occurs on Thursday before Good Friday, financial clearing houses (Fedwire, TARGET2, CHAPS) are closed on both Good Friday and Easter Monday.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settlement cannot occur until the second valid banking day following the trade.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { addBusinessDays, isBusinessDay } from '@magmacomputing/tempo-plugin-holidays';
+
+export function calculateTradeSettlement(tradeDateIso: string, marketCountry: string): {
+  tradeDate: string;
+  settlementDate: string;
+  interveningHolidaysSkipped: number;
+} {
+  const trade = new Tempo(tradeDateIso, { geo: { country: marketCountry } });
+
+  // Ensure trade was executed on a valid market day
+  if (!trade.holidays.isBusinessDay()) {
+    throw new Error(\`Trade executed on non-clearing day: \${trade.format('{yyyy}-{mm}-{dd}')}\`);
+  }
+
+  // T+2 Settlement Date (skips exchange holidays & weekends)
+  const settlement = trade.holidays.addBusinessDays(2);
+
+  return {
+    tradeDate: trade.format('{yyyy}-{mm}-{dd}'),
+    settlementDate: settlement.format('{yyyy}-{mm}-{dd}'),
+    interveningHolidaysSkipped: trade.holidays.businessDaysUntil(settlement)
+  };
+}
+
+// Thursday April 2, 2026 (day before Good Friday on the London Stock Exchange)
+const trade = calculateTradeSettlement('2026-04-02', 'GB');
+
+// In the UK, April 3 (Good Friday) and April 6 (Easter Monday) are bank holidays.
+// April 4-5 is the weekend:
+// T+1 = Tuesday April 7, T+2 = Wednesday April 8
+console.log(trade.settlementDate); // '2026-04-08'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Payroll & Automated Invoicing (Preceding vs. Following Conventions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When automated billing or employee salary disbursement is scheduled for a fixed calendar date (e.g. the 1st or 15th of the month), banking regulations require applying a business day rolling convention if that date lands on a weekend or public holiday:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Preceding Business Day (Standard Payroll): Employees must be paid before the holiday weekend (e.g. Wednesday Dec 31 if Jan 1 is New Year's Day).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Following Business Day (Invoicing & Direct Debits): Payments are drawn on the next banking day after the holiday.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+type RollConvention = 'PRECEDING' | 'FOLLOWING';
+
+export function resolvePaymentRunDate(
+  scheduledDateIso: string,
+  country: string,
+  convention: RollConvention
+): Tempo {
+  const target = new Tempo(scheduledDateIso, { geo: { country } });
+
+  // If already a valid working day, process on scheduled date
+  if (target.holidays.isBusinessDay()) {
+    return target;
+  }
+
+  // Apply banking adjustment convention
+  return convention === 'PRECEDING'
+    ? target.holidays.prevBusinessDay()
+    : target.holidays.nextBusinessDay();
+}
+
+// 1. Payroll Run: Jan 1, 2026 (New Year's Day - US Bank Holiday)
+const payrollRun = resolvePaymentRunDate('2026-01-01', 'US', 'PRECEDING');
+console.log(payrollRun.format('{yyyy}-{mm}-{dd}')); // '2025-12-31' (Wednesday)
+
+// 2. Direct Debit Draw: July 4, 2026 (US Independence Day - Saturday)
+// Observed holiday is Friday July 3; next banking business day is Monday July 6
+const debitRun = resolvePaymentRunDate('2026-07-04', 'US', 'FOLLOWING');
+console.log(debitRun.format('{yyyy}-{mm}-{dd}')); // '2026-07-06' (Monday)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. HR Leave Balance & Vacation Day Accounting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When employees submit annual leave requests, naive calendar day subtraction calculates endDate - startDate + 1. This incorrectly charges employees vacation balance for weekends and statutory bank holidays occurring during their time off.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using businessDaysUntil or isBusinessDay() ensures fair, legally compliant leave deductions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-holidays/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export function calculateLeaveDeduction(
+  startDateIso: string,
+  endDateIso: string,
+  country: string
+): { totalCalendarDays: number; chargeableLeaveDays: number; holidaysIncluded: string[] } {
+  const start = new Tempo(startDateIso, { geo: { country } });
+  const end = new Tempo(endDateIso, { geo: { country } });
+
+  const holidaysIncluded: string[] = [];
+  let chargeableDays = 0;
+  let current = start;
+
+  while (current.epoch.ms <= end.epoch.ms) {
+    if (current.holidays.isHoliday()) {
+      holidaysIncluded.push(\`\${current.format('{yyyy}-{mm}-{dd}')}: \${current.holidays.name}\`);
+    } else if (current.holidays.isBusinessDay()) {
+      chargeableDays++;
+    }
+    current = current.add({ day: 1 });
+  }
+
+  return {
+    totalCalendarDays: Math.round((end.epoch.ms - start.epoch.ms) / 86_400_000) + 1,
+    chargeableLeaveDays: chargeableDays,
+    holidaysIncluded
+  };
+}
+
+// Employee books Christmas break in Australia (Dec 24, 2026 to Jan 4, 2027)
+const leave = calculateLeaveDeduction('2026-12-24', '2027-01-04', 'AU');
+
+console.log(leave.totalCalendarDays);   // 12 days
+console.log(leave.chargeableLeaveDays);  // 5 working days deducted
+console.log(leave.holidaysIncluded);
+// [
+//   '2026-12-25: Christmas Day',
+//   '2026-12-28: Boxing Day (Observed)',
+//   '2027-01-01: New Year\\'s Day'
+// ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Corporate Calendar Overlays & Floating Shutdowns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enterprises frequently observe non-statutory company closures in addition to national holidays:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Year-end corporate shutdowns (e.g. December 24 through January 2).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Annual company hackathons or global mental health recharge days.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Regional warehouse maintenance downtime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo-plugin-holidays supports customHolidays, seamlessly blending proprietary enterprise closure dates into the national holiday calendar without modifying runtime source files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { isBusinessDay, addBusinessDays } from '@magmacomputing/tempo-plugin-holidays';
+
+const corporateCalendar = {
+  country: 'US',
+  customHolidays: [
+    '2026-11-27', // Company Day after Thanksgiving
+    '2026-12-24', // Christmas Eve Corporate Closure
+    '2026-12-31'  // New Year's Eve Corporate Closure
+  ]
+};
+
+const thanksgivingThursday = new Tempo('2026-11-26');
+
+// Friday Nov 27 is a normal federal business day in the US,
+// but our custom enterprise overlay treats it as non-working:
+console.log(isBusinessDay(thanksgivingThursday.add({ day: 1 }), corporateCalendar)); // false
+
+// Advances past Thanksgiving (Thu), Company Day (Fri), and the Weekend to Monday:
+const nextActiveWorkDay = addBusinessDays(thanksgivingThursday, 1, corporateCalendar);
+console.log(nextActiveWorkDay.format('{yyyy}-{mm}-{dd}')); // '2026-11-30' (Monday)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Zero-Latency Synchronous Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All standard country calculations (including Easter Computus and observed floating holiday algorithms) execute 100% synchronously in pure memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    There are no network round-trips to third-party government APIs, no rate limits, and zero asynchronous latency—making tempo-plugin-holidays suitable for high-throughput batch transaction pipelines, bulk database ETL jobs, and millisecond-sensitive order routing engines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,38)])])}const g=i(h,[["render",t]]);export{y as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.lean.js new file mode 100644 index 00000000..fd95ed3d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_holidays.use-cases-and-patterns.md.CHmR90E9.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/holidays.use-cases-and-patterns.md","filePath":"doc/9-plugins/holidays.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/holidays.use-cases-and-patterns.md"};function t(k,s,p,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[l("",38)])])}const g=i(h,[["render",t]]);export{y as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.js new file mode 100644 index 00000000..efc62664 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.js @@ -0,0 +1,9 @@ +import{_ as l,o as e,c as a,a2 as s,j as t,a as T}from"./chunks/framework.DNL3hc5c.js";const l3=JSON.parse(`{"title":"Cristian's Algorithm & Precision Engineering","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.algorithms-and-precision.md","filePath":"doc/9-plugins/ntp.algorithms-and-precision.md"}`),n={name:"doc/9-plugins/ntp.algorithms-and-precision.md"},o={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},r={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.375ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.906ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 842.6","aria-hidden":"true"},i={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.357ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.659ex",height:"1.889ex",role:"img",focusable:"false",viewBox:"0 -677 2501.2 834.8","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.339ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.871ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 827","aria-hidden":"true"},h={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},H={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.375ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.333ex",height:"1.92ex",role:"img",focusable:"false",viewBox:"0 -683 6777.1 848.6","aria-hidden":"true"},V={id:"estimated-server-timestamp-at-reception",tabindex:"-1"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},x={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.339ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.871ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 827","aria-hidden":"true"},w={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0.124ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.76ex",height:"0.968ex",role:"img",focusable:"false",viewBox:"0 -483 778 428","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"9.583ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 4235.8 1000","aria-hidden":"true"},L={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},f={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"25.641ex",height:"4.627ex",role:"img",focusable:"false",viewBox:"0 -1359 11333.2 2045","aria-hidden":"true"},y={id:"clock-drift-offset",tabindex:"-1"},M={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},b={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.023ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.061ex",height:"1.618ex",role:"img",focusable:"false",viewBox:"0 -705 469 715","aria-hidden":"true"},v={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},Z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"37.245ex",height:"4.613ex",role:"img",focusable:"false",viewBox:"0 -1353 16462.3 2039","aria-hidden":"true"},_={id:"uncertainty-window",tabindex:"-1"},C={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},S={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"3.489ex",height:"1.538ex",role:"img",focusable:"false",viewBox:"0 -680 1542 680","aria-hidden":"true"},D={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},A={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"12.433ex",height:"4.627ex",role:"img",focusable:"false",viewBox:"0 -1359 5495.6 2045","aria-hidden":"true"},j={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},P={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.05ex"},xmlns:"http://www.w3.org/2000/svg",width:"7.93ex",height:"1.557ex",role:"img",focusable:"false",viewBox:"0 -666 3505 688","aria-hidden":"true"},R={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},E={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"7.195ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3180 1000","aria-hidden":"true"},I={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},B={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.65ex"},xmlns:"http://www.w3.org/2000/svg",width:"29.358ex",height:"2.347ex",role:"img",focusable:"false",viewBox:"0 -750 12976.4 1037.2","aria-hidden":"true"},O={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},F={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"8.991ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3974.2 1000","aria-hidden":"true"},z={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},N={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.965ex",height:"1.692ex",role:"img",focusable:"false",viewBox:"0 -666 2194.6 748","aria-hidden":"true"},J={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},G={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.65ex"},xmlns:"http://www.w3.org/2000/svg",width:"11.122ex",height:"2.245ex",role:"img",focusable:"false",viewBox:"0 -705 4916 992.2","aria-hidden":"true"},q={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},X={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},$={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},W={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"38.326ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 16940 1000","aria-hidden":"true"},U={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},K={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.023ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.061ex",height:"1.618ex",role:"img",focusable:"false",viewBox:"0 -705 469 715","aria-hidden":"true"};function Y(t3,Q,Q3,T3,e3,a3){return e(),a("div",null,[Q[81]||(Q[81]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ntp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cristian's Algorithm & Precision Engineering ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ntp implements Flaviu Cristian's probabilistic clock synchronization algorithm over HTTP(S) with modern performance enhancements: high-resolution monotonic baselines, sub-millisecond Server-Timing headers, statistical jitter rejection, and Exponential Moving Average (EMA) smoothing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cristian's Algorithm Over HTTP ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a client queries a time endpoint over HTTP:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',7)),t("ol",null,[t("li",null,[t("strong",null,[t("mjx-container",o,[(e(),a("svg",r,[...Q[0]||(Q[0]=[s('',1)])])),Q[1]||(Q[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"0")])])],-1))])]),Q[2]||(Q[2]=T(": Client records its local timestamp immediately before sending the HTTP request.",-1))]),t("li",null,[t("strong",null,[t("mjx-container",i,[(e(),a("svg",d,[...Q[3]||(Q[3]=[s('',1)])])),Q[4]||(Q[4]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])])])],-1))])]),Q[5]||(Q[5]=T(": Server records the current atomic timestamp when handling the request.",-1))]),t("li",null,[t("strong",null,[t("mjx-container",m,[(e(),a("svg",p,[...Q[6]||(Q[6]=[s('',1)])])),Q[7]||(Q[7]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])])],-1))])]),Q[8]||(Q[8]=T(": Client records its local timestamp immediately upon receiving the response.",-1))])]),Q[82]||(Q[82]=s(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Client                             Server
+  |                                  |
+  |--- HTTP Request (T0) ----------->|
+  |                                  | (T_server)
+  |<-- HTTP Response (T1) -----------|
+  |                                  |

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Round-Trip Time (RTT) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,2)),t("mjx-container",h,[(e(),a("svg",H,[...Q[9]||(Q[9]=[s('',1)])])),Q[10]||(Q[10]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mtext",null,"RTT"),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")]),t("mo",null,"−"),t("msub",null,[t("mi",null,"T"),t("mn",null,"0")])])],-1))]),t("h3",V,[Q[13]||(Q[13]=T("Estimated Server Timestamp at Reception (",-1)),t("mjx-container",g,[(e(),a("svg",x,[...Q[11]||(Q[11]=[s('',1)])])),Q[12]||(Q[12]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])])],-1))]),Q[14]||(Q[14]=T(") ",-1)),Q[15]||(Q[15]=t("a",{class:"header-anchor",href:"#estimated-server-timestamp-at-reception","aria-label":'Permalink to "Estimated Server Timestamp at Reception ($T_1$)"'},"​",-1))]),t("p",null,[Q[20]||(Q[20]=T("Assuming symmetrical network latency (outbound delay ",-1)),t("mjx-container",w,[(e(),a("svg",c,[...Q[16]||(Q[16]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mo"},[t("path",{"data-c":"2248",d:"M55 319Q55 360 72 393T114 444T163 472T205 482Q207 482 213 482T223 483Q262 483 296 468T393 413L443 381Q502 346 553 346Q609 346 649 375T694 454Q694 465 698 474T708 483Q722 483 722 452Q722 386 675 338T555 289Q514 289 468 310T388 357T308 404T224 426Q164 426 125 393T83 318Q81 289 69 289Q55 289 55 319ZM55 85Q55 126 72 159T114 210T163 238T205 248Q207 248 213 248T223 249Q262 249 296 234T393 179L443 147Q502 112 553 112Q609 112 649 141T694 220Q694 249 708 249T722 217Q722 153 675 104T555 55Q514 55 468 76T388 123T308 170T224 192Q164 192 125 159T83 84Q80 55 69 55Q55 55 55 85Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[17]||(Q[17]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈")])],-1))]),Q[21]||(Q[21]=T(" inbound delay ",-1)),t("mjx-container",u,[(e(),a("svg",k,[...Q[18]||(Q[18]=[s('',1)])])),Q[19]||(Q[19]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈"),t("mtext",null,"RTT"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mo",null,"/")]),t("mn",null,"2")])],-1))]),Q[22]||(Q[22]=T("):",-1))]),t("mjx-container",L,[(e(),a("svg",f,[...Q[23]||(Q[23]=[s('',1)])])),Q[24]||(Q[24]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"estimated")])]),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])]),t("mo",null,"+"),t("mfrac",null,[t("mtext",null,"RTT"),t("mn",null,"2")])])],-1))]),t("h3",y,[Q[27]||(Q[27]=T("Clock Drift Offset (",-1)),t("mjx-container",M,[(e(),a("svg",b,[...Q[25]||(Q[25]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mi"},[t("path",{"data-c":"1D703",d:"M35 200Q35 302 74 415T180 610T319 704Q320 704 327 704T339 705Q393 701 423 656Q462 596 462 495Q462 380 417 261T302 66T168 -10H161Q125 -10 99 10T60 63T41 130T35 200ZM383 566Q383 668 330 668Q294 668 260 623T204 521T170 421T157 371Q206 370 254 370L351 371Q352 372 359 404T375 484T383 566ZM113 132Q113 26 166 26Q181 26 198 36T239 74T287 161T335 307L340 324H145Q145 321 136 286T120 208T113 132Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[26]||(Q[26]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"θ")])],-1))]),Q[28]||(Q[28]=T(") ",-1)),Q[29]||(Q[29]=t("a",{class:"header-anchor",href:"#clock-drift-offset","aria-label":'Permalink to "Clock Drift Offset ($\\theta$)"'},"​",-1))]),t("mjx-container",v,[(e(),a("svg",Z,[...Q[30]||(Q[30]=[s('',1)])])),Q[31]||(Q[31]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mi",null,"θ"),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"estimated")])]),t("mo",null,"−"),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")]),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])]),t("mo",null,"−"),t("mfrac",null,[t("mrow",null,[t("msub",null,[t("mi",null,"T"),t("mn",null,"0")]),t("mo",null,"+"),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])]),t("mn",null,"2")])])],-1))]),t("h3",_,[Q[34]||(Q[34]=T("Uncertainty Window (",-1)),t("mjx-container",C,[(e(),a("svg",S,[...Q[32]||(Q[32]=[s('',1)])])),Q[33]||(Q[33]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"±"),t("mi",null,"E")])],-1))]),Q[35]||(Q[35]=T(") ",-1)),Q[36]||(Q[36]=t("a",{class:"header-anchor",href:"#uncertainty-window","aria-label":'Permalink to "Uncertainty Window ($\\pm E$)"'},"​",-1))]),Q[83]||(Q[83]=t("p",null,"The maximum theoretical clock error bounds are:",-1)),t("mjx-container",D,[(e(),a("svg",A,[...Q[37]||(Q[37]=[s('',1)])])),Q[38]||(Q[38]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mi",null,"E"),t("mo",null,"="),t("mo",null,"±"),t("mfrac",null,[t("mtext",null,"RTT"),t("mn",null,"2")])])],-1))]),Q[84]||(Q[84]=t("hr",null,null,-1)),Q[85]||(Q[85]=t("h2",{id:"_2-sub-millisecond-precision-via-server-timing",tabindex:"-1"},[T("2. Sub-Millisecond Precision via "),t("code",null,"Server-Timing"),T(),t("a",{class:"header-anchor",href:"#_2-sub-millisecond-precision-via-server-timing","aria-label":'Permalink to "2. Sub-Millisecond Precision via `Server-Timing`"'},"​")],-1)),t("p",null,[Q[41]||(Q[41]=T("Standard HTTP ",-1)),Q[42]||(Q[42]=t("code",null,"Date",-1)),Q[43]||(Q[43]=T(" headers have a coarse ",-1)),Q[44]||(Q[44]=t("strong",null,"1-second resolution",-1)),Q[45]||(Q[45]=T(" (",-1)),Q[46]||(Q[46]=t("code",null,"Date: Fri, 02 Oct 2026 06:15:00 GMT",-1)),Q[47]||(Q[47]=T("), which introduces up to ",-1)),t("mjx-container",j,[(e(),a("svg",P,[...Q[39]||(Q[39]=[s('',1)])])),Q[40]||(Q[40]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"±"),t("mn",null,"500"),t("mtext",null,"ms")])],-1))]),Q[48]||(Q[48]=T(" of quantization jitter.",-1))]),Q[86]||(Q[86]=s(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo-plugin-ntp automatically prioritizes sub-millisecond timestamps delivered via the standard HTTP Server-Timing header:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HTTP/1.1 200 OK
+Date: Fri, 02 Oct 2026 06:15:00 GMT
+Server-Timing: clock=1727856900123.45
+Content-Type: application/json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If Server-Timing contains a clock=..., server_time=..., or epoch=... metric, the plugin parses the high-precision floating-point epoch timestamp, achieving sub-millisecond synchronization accuracy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Statistical Jitter Rejection & Filtering ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,5)),t("p",null,[Q[51]||(Q[51]=T("Transient network spikes (e.g., cell tower handoffs, packet retries) can cause anomalous RTT measurements. If an asynchronous network delay is heavily skewed in one direction, the symmetrical assumption (",-1)),t("mjx-container",R,[(e(),a("svg",E,[...Q[49]||(Q[49]=[s('',1)])])),Q[50]||(Q[50]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mtext",null,"RTT"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mo",null,"/")]),t("mn",null,"2")])],-1))]),Q[52]||(Q[52]=T(") breaks down.",-1))]),Q[87]||(Q[87]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin protects against skew distortion using RTT Threshold Filtering:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Samples exceeding the configurable maxAcceptableRttMs threshold (default: 1000ms) are immediately discarded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • High-latency or asymmetrical network spikes are rejected without updating the active drift calibration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Exponential Moving Average (EMA) Smoothing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than jumping the clock offset instantaneously upon every sync sample (which could cause time to appear to skip or stutter), new samples are smoothed into the running offset using an Exponential Moving Average:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',5)),t("mjx-container",I,[(e(),a("svg",B,[...Q[53]||(Q[53]=[s('',1)])])),Q[54]||(Q[54]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mi",null,"t")])]),t("mo",null,"="),t("mi",null,"α"),t("mo",null,"⋅"),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"sample")])]),t("mo",null,"+"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",null,"−"),t("mi",null,"α"),t("mo",{stretchy:"false"},")"),t("mo",null,"⋅"),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mi",null,"t"),t("mo",null,"−"),t("mn",null,"1")])])])],-1))]),Q[88]||(Q[88]=t("p",null,"Where:",-1)),t("ul",null,[t("li",null,[t("mjx-container",O,[(e(),a("svg",F,[...Q[55]||(Q[55]=[s('',1)])])),Q[56]||(Q[56]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"α"),t("mo",null,"∈"),t("mo",{stretchy:"false"},"("),t("mn",null,"0"),t("mo",null,","),t("mn",null,"1"),t("mo",{stretchy:"false"},"]")])],-1))]),Q[57]||(Q[57]=T(" is the smoothing factor (default: ",-1)),Q[58]||(Q[58]=t("code",null,"0.3",-1)),Q[59]||(Q[59]=T(").",-1))]),t("li",null,[Q[64]||(Q[64]=T("On the very first sample (",-1)),t("mjx-container",z,[(e(),a("svg",N,[...Q[60]||(Q[60]=[s('',1)])])),Q[61]||(Q[61]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"t"),t("mo",null,"="),t("mn",null,"0")])],-1))]),Q[65]||(Q[65]=T("), ",-1)),t("mjx-container",J,[(e(),a("svg",G,[...Q[62]||(Q[62]=[s('',1)])])),Q[63]||(Q[63]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"θ"),t("mn",null,"0")]),t("mo",null,"="),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"sample")])])])],-1))]),Q[66]||(Q[66]=T(" to establish immediate baseline calibration.",-1))])]),Q[89]||(Q[89]=t("hr",null,null,-1)),Q[90]||(Q[90]=t("h2",{id:"_5-monotonic-time-progression-with-zero-o-n-overhead",tabindex:"-1"},[T("5. Monotonic Time Progression with Zero O(N) Overhead "),t("a",{class:"header-anchor",href:"#_5-monotonic-time-progression-with-zero-o-n-overhead","aria-label":'Permalink to "5. Monotonic Time Progression with Zero O(N) Overhead"'},"​")],-1)),t("p",null,[Q[69]||(Q[69]=T("Once calibrated, calling ",-1)),Q[70]||(Q[70]=t("code",null,"Tempo.ntp.now()",-1)),Q[71]||(Q[71]=T(" is a purely synchronous, ",-1)),t("mjx-container",q,[(e(),a("svg",X,[...Q[67]||(Q[67]=[s('',1)])])),Q[68]||(Q[68]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),Q[72]||(Q[72]=T(" calculation:",-1))]),t("mjx-container",$,[(e(),a("svg",W,[...Q[73]||(Q[73]=[s('',1)])])),Q[74]||(Q[74]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mtext",null,"Current Server Time"),t("mo",null,"="),t("mtext",null,"Date.now()"),t("mo",null,"+"),t("mi",null,"θ")])],-1))]),t("p",null,[Q[77]||(Q[77]=T("Because the offset ",-1)),t("mjx-container",U,[(e(),a("svg",K,[...Q[75]||(Q[75]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mi"},[t("path",{"data-c":"1D703",d:"M35 200Q35 302 74 415T180 610T319 704Q320 704 327 704T339 705Q393 701 423 656Q462 596 462 495Q462 380 417 261T302 66T168 -10H161Q125 -10 99 10T60 63T41 130T35 200ZM383 566Q383 668 330 668Q294 668 260 623T204 521T170 421T157 371Q206 370 254 370L351 371Q352 372 359 404T375 484T383 566ZM113 132Q113 26 166 26Q181 26 198 36T239 74T287 161T335 307L340 324H145Q145 321 136 286T120 208T113 132Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[76]||(Q[76]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"θ")])],-1))]),Q[78]||(Q[78]=T(" is continuously maintained in memory, your application can invoke ",-1)),Q[79]||(Q[79]=t("code",null,"Tempo.ntp.now()",-1)),Q[80]||(Q[80]=T(" millions of times per second inside render loops or high-frequency calculation pipelines with zero performance penalty.",-1))])])}const n3=l(n,[["render",Y]]);export{l3 as __pageData,n3 as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.lean.js new file mode 100644 index 00000000..7e87a208 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.algorithms-and-precision.md.3JO-q5xY.lean.js @@ -0,0 +1 @@ +import{_ as l,o as e,c as a,a2 as s,j as t,a as T}from"./chunks/framework.DNL3hc5c.js";const l3=JSON.parse(`{"title":"Cristian's Algorithm & Precision Engineering","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.algorithms-and-precision.md","filePath":"doc/9-plugins/ntp.algorithms-and-precision.md"}`),n={name:"doc/9-plugins/ntp.algorithms-and-precision.md"},o={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},r={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.375ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.906ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 842.6","aria-hidden":"true"},i={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.357ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.659ex",height:"1.889ex",role:"img",focusable:"false",viewBox:"0 -677 2501.2 834.8","aria-hidden":"true"},m={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},p={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.339ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.871ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 827","aria-hidden":"true"},h={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},H={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.375ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.333ex",height:"1.92ex",role:"img",focusable:"false",viewBox:"0 -683 6777.1 848.6","aria-hidden":"true"},V={id:"estimated-server-timestamp-at-reception",tabindex:"-1"},g={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},x={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.339ex"},xmlns:"http://www.w3.org/2000/svg",width:"2.309ex",height:"1.871ex",role:"img",focusable:"false",viewBox:"0 -677 1020.6 827","aria-hidden":"true"},w={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0.124ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.76ex",height:"0.968ex",role:"img",focusable:"false",viewBox:"0 -483 778 428","aria-hidden":"true"},u={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"9.583ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 4235.8 1000","aria-hidden":"true"},L={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},f={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"25.641ex",height:"4.627ex",role:"img",focusable:"false",viewBox:"0 -1359 11333.2 2045","aria-hidden":"true"},y={id:"clock-drift-offset",tabindex:"-1"},M={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},b={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.023ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.061ex",height:"1.618ex",role:"img",focusable:"false",viewBox:"0 -705 469 715","aria-hidden":"true"},v={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},Z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"37.245ex",height:"4.613ex",role:"img",focusable:"false",viewBox:"0 -1353 16462.3 2039","aria-hidden":"true"},_={id:"uncertainty-window",tabindex:"-1"},C={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},S={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"3.489ex",height:"1.538ex",role:"img",focusable:"false",viewBox:"0 -680 1542 680","aria-hidden":"true"},D={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},A={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-1.552ex"},xmlns:"http://www.w3.org/2000/svg",width:"12.433ex",height:"4.627ex",role:"img",focusable:"false",viewBox:"0 -1359 5495.6 2045","aria-hidden":"true"},j={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},P={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.05ex"},xmlns:"http://www.w3.org/2000/svg",width:"7.93ex",height:"1.557ex",role:"img",focusable:"false",viewBox:"0 -666 3505 688","aria-hidden":"true"},R={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},E={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"7.195ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3180 1000","aria-hidden":"true"},I={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},B={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.65ex"},xmlns:"http://www.w3.org/2000/svg",width:"29.358ex",height:"2.347ex",role:"img",focusable:"false",viewBox:"0 -750 12976.4 1037.2","aria-hidden":"true"},O={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},F={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"8.991ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 3974.2 1000","aria-hidden":"true"},z={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},N={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.965ex",height:"1.692ex",role:"img",focusable:"false",viewBox:"0 -666 2194.6 748","aria-hidden":"true"},J={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},G={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.65ex"},xmlns:"http://www.w3.org/2000/svg",width:"11.122ex",height:"2.245ex",role:"img",focusable:"false",viewBox:"0 -705 4916 992.2","aria-hidden":"true"},q={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},X={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},$={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},W={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"38.326ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 16940 1000","aria-hidden":"true"},U={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},K={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.023ex"},xmlns:"http://www.w3.org/2000/svg",width:"1.061ex",height:"1.618ex",role:"img",focusable:"false",viewBox:"0 -705 469 715","aria-hidden":"true"};function Y(t3,Q,Q3,T3,e3,a3){return e(),a("div",null,[Q[81]||(Q[81]=s("",7)),t("ol",null,[t("li",null,[t("strong",null,[t("mjx-container",o,[(e(),a("svg",r,[...Q[0]||(Q[0]=[s("",1)])])),Q[1]||(Q[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"0")])])],-1))])]),Q[2]||(Q[2]=T(": Client records its local timestamp immediately before sending the HTTP request.",-1))]),t("li",null,[t("strong",null,[t("mjx-container",i,[(e(),a("svg",d,[...Q[3]||(Q[3]=[s("",1)])])),Q[4]||(Q[4]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])])])],-1))])]),Q[5]||(Q[5]=T(": Server records the current atomic timestamp when handling the request.",-1))]),t("li",null,[t("strong",null,[t("mjx-container",m,[(e(),a("svg",p,[...Q[6]||(Q[6]=[s("",1)])])),Q[7]||(Q[7]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])])],-1))])]),Q[8]||(Q[8]=T(": Client records its local timestamp immediately upon receiving the response.",-1))])]),Q[82]||(Q[82]=s("",2)),t("mjx-container",h,[(e(),a("svg",H,[...Q[9]||(Q[9]=[s("",1)])])),Q[10]||(Q[10]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mtext",null,"RTT"),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")]),t("mo",null,"−"),t("msub",null,[t("mi",null,"T"),t("mn",null,"0")])])],-1))]),t("h3",V,[Q[13]||(Q[13]=T("Estimated Server Timestamp at Reception (",-1)),t("mjx-container",g,[(e(),a("svg",x,[...Q[11]||(Q[11]=[s("",1)])])),Q[12]||(Q[12]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])])],-1))]),Q[14]||(Q[14]=T(") ",-1)),Q[15]||(Q[15]=t("a",{class:"header-anchor",href:"#estimated-server-timestamp-at-reception","aria-label":'Permalink to "Estimated Server Timestamp at Reception ($T_1$)"'},"​",-1))]),t("p",null,[Q[20]||(Q[20]=T("Assuming symmetrical network latency (outbound delay ",-1)),t("mjx-container",w,[(e(),a("svg",c,[...Q[16]||(Q[16]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mo"},[t("path",{"data-c":"2248",d:"M55 319Q55 360 72 393T114 444T163 472T205 482Q207 482 213 482T223 483Q262 483 296 468T393 413L443 381Q502 346 553 346Q609 346 649 375T694 454Q694 465 698 474T708 483Q722 483 722 452Q722 386 675 338T555 289Q514 289 468 310T388 357T308 404T224 426Q164 426 125 393T83 318Q81 289 69 289Q55 289 55 319ZM55 85Q55 126 72 159T114 210T163 238T205 248Q207 248 213 248T223 249Q262 249 296 234T393 179L443 147Q502 112 553 112Q609 112 649 141T694 220Q694 249 708 249T722 217Q722 153 675 104T555 55Q514 55 468 76T388 123T308 170T224 192Q164 192 125 159T83 84Q80 55 69 55Q55 55 55 85Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[17]||(Q[17]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈")])],-1))]),Q[21]||(Q[21]=T(" inbound delay ",-1)),t("mjx-container",u,[(e(),a("svg",k,[...Q[18]||(Q[18]=[s("",1)])])),Q[19]||(Q[19]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈"),t("mtext",null,"RTT"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mo",null,"/")]),t("mn",null,"2")])],-1))]),Q[22]||(Q[22]=T("):",-1))]),t("mjx-container",L,[(e(),a("svg",f,[...Q[23]||(Q[23]=[s("",1)])])),Q[24]||(Q[24]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"estimated")])]),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])]),t("mo",null,"+"),t("mfrac",null,[t("mtext",null,"RTT"),t("mn",null,"2")])])],-1))]),t("h3",y,[Q[27]||(Q[27]=T("Clock Drift Offset (",-1)),t("mjx-container",M,[(e(),a("svg",b,[...Q[25]||(Q[25]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mi"},[t("path",{"data-c":"1D703",d:"M35 200Q35 302 74 415T180 610T319 704Q320 704 327 704T339 705Q393 701 423 656Q462 596 462 495Q462 380 417 261T302 66T168 -10H161Q125 -10 99 10T60 63T41 130T35 200ZM383 566Q383 668 330 668Q294 668 260 623T204 521T170 421T157 371Q206 370 254 370L351 371Q352 372 359 404T375 484T383 566ZM113 132Q113 26 166 26Q181 26 198 36T239 74T287 161T335 307L340 324H145Q145 321 136 286T120 208T113 132Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[26]||(Q[26]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"θ")])],-1))]),Q[28]||(Q[28]=T(") ",-1)),Q[29]||(Q[29]=t("a",{class:"header-anchor",href:"#clock-drift-offset","aria-label":'Permalink to "Clock Drift Offset ($\\theta$)"'},"​",-1))]),t("mjx-container",v,[(e(),a("svg",Z,[...Q[30]||(Q[30]=[s("",1)])])),Q[31]||(Q[31]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mi",null,"θ"),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"estimated")])]),t("mo",null,"−"),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")]),t("mo",null,"="),t("msub",null,[t("mi",null,"T"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"server")])]),t("mo",null,"−"),t("mfrac",null,[t("mrow",null,[t("msub",null,[t("mi",null,"T"),t("mn",null,"0")]),t("mo",null,"+"),t("msub",null,[t("mi",null,"T"),t("mn",null,"1")])]),t("mn",null,"2")])])],-1))]),t("h3",_,[Q[34]||(Q[34]=T("Uncertainty Window (",-1)),t("mjx-container",C,[(e(),a("svg",S,[...Q[32]||(Q[32]=[s("",1)])])),Q[33]||(Q[33]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"±"),t("mi",null,"E")])],-1))]),Q[35]||(Q[35]=T(") ",-1)),Q[36]||(Q[36]=t("a",{class:"header-anchor",href:"#uncertainty-window","aria-label":'Permalink to "Uncertainty Window ($\\pm E$)"'},"​",-1))]),Q[83]||(Q[83]=t("p",null,"The maximum theoretical clock error bounds are:",-1)),t("mjx-container",D,[(e(),a("svg",A,[...Q[37]||(Q[37]=[s("",1)])])),Q[38]||(Q[38]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mi",null,"E"),t("mo",null,"="),t("mo",null,"±"),t("mfrac",null,[t("mtext",null,"RTT"),t("mn",null,"2")])])],-1))]),Q[84]||(Q[84]=t("hr",null,null,-1)),Q[85]||(Q[85]=t("h2",{id:"_2-sub-millisecond-precision-via-server-timing",tabindex:"-1"},[T("2. Sub-Millisecond Precision via "),t("code",null,"Server-Timing"),T(),t("a",{class:"header-anchor",href:"#_2-sub-millisecond-precision-via-server-timing","aria-label":'Permalink to "2. Sub-Millisecond Precision via `Server-Timing`"'},"​")],-1)),t("p",null,[Q[41]||(Q[41]=T("Standard HTTP ",-1)),Q[42]||(Q[42]=t("code",null,"Date",-1)),Q[43]||(Q[43]=T(" headers have a coarse ",-1)),Q[44]||(Q[44]=t("strong",null,"1-second resolution",-1)),Q[45]||(Q[45]=T(" (",-1)),Q[46]||(Q[46]=t("code",null,"Date: Fri, 02 Oct 2026 06:15:00 GMT",-1)),Q[47]||(Q[47]=T("), which introduces up to ",-1)),t("mjx-container",j,[(e(),a("svg",P,[...Q[39]||(Q[39]=[s("",1)])])),Q[40]||(Q[40]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"±"),t("mn",null,"500"),t("mtext",null,"ms")])],-1))]),Q[48]||(Q[48]=T(" of quantization jitter.",-1))]),Q[86]||(Q[86]=s("",5)),t("p",null,[Q[51]||(Q[51]=T("Transient network spikes (e.g., cell tower handoffs, packet retries) can cause anomalous RTT measurements. If an asynchronous network delay is heavily skewed in one direction, the symmetrical assumption (",-1)),t("mjx-container",R,[(e(),a("svg",E,[...Q[49]||(Q[49]=[s("",1)])])),Q[50]||(Q[50]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mtext",null,"RTT"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mo",null,"/")]),t("mn",null,"2")])],-1))]),Q[52]||(Q[52]=T(") breaks down.",-1))]),Q[87]||(Q[87]=s("",5)),t("mjx-container",I,[(e(),a("svg",B,[...Q[53]||(Q[53]=[s("",1)])])),Q[54]||(Q[54]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mi",null,"t")])]),t("mo",null,"="),t("mi",null,"α"),t("mo",null,"⋅"),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"sample")])]),t("mo",null,"+"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",null,"−"),t("mi",null,"α"),t("mo",{stretchy:"false"},")"),t("mo",null,"⋅"),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mi",null,"t"),t("mo",null,"−"),t("mn",null,"1")])])])],-1))]),Q[88]||(Q[88]=t("p",null,"Where:",-1)),t("ul",null,[t("li",null,[t("mjx-container",O,[(e(),a("svg",F,[...Q[55]||(Q[55]=[s("",1)])])),Q[56]||(Q[56]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"α"),t("mo",null,"∈"),t("mo",{stretchy:"false"},"("),t("mn",null,"0"),t("mo",null,","),t("mn",null,"1"),t("mo",{stretchy:"false"},"]")])],-1))]),Q[57]||(Q[57]=T(" is the smoothing factor (default: ",-1)),Q[58]||(Q[58]=t("code",null,"0.3",-1)),Q[59]||(Q[59]=T(").",-1))]),t("li",null,[Q[64]||(Q[64]=T("On the very first sample (",-1)),t("mjx-container",z,[(e(),a("svg",N,[...Q[60]||(Q[60]=[s("",1)])])),Q[61]||(Q[61]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"t"),t("mo",null,"="),t("mn",null,"0")])],-1))]),Q[65]||(Q[65]=T("), ",-1)),t("mjx-container",J,[(e(),a("svg",G,[...Q[62]||(Q[62]=[s("",1)])])),Q[63]||(Q[63]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("msub",null,[t("mi",null,"θ"),t("mn",null,"0")]),t("mo",null,"="),t("msub",null,[t("mi",null,"θ"),t("mrow",{"data-mjx-texclass":"ORD"},[t("mtext",null,"sample")])])])],-1))]),Q[66]||(Q[66]=T(" to establish immediate baseline calibration.",-1))])]),Q[89]||(Q[89]=t("hr",null,null,-1)),Q[90]||(Q[90]=t("h2",{id:"_5-monotonic-time-progression-with-zero-o-n-overhead",tabindex:"-1"},[T("5. Monotonic Time Progression with Zero O(N) Overhead "),t("a",{class:"header-anchor",href:"#_5-monotonic-time-progression-with-zero-o-n-overhead","aria-label":'Permalink to "5. Monotonic Time Progression with Zero O(N) Overhead"'},"​")],-1)),t("p",null,[Q[69]||(Q[69]=T("Once calibrated, calling ",-1)),Q[70]||(Q[70]=t("code",null,"Tempo.ntp.now()",-1)),Q[71]||(Q[71]=T(" is a purely synchronous, ",-1)),t("mjx-container",q,[(e(),a("svg",X,[...Q[67]||(Q[67]=[s("",1)])])),Q[68]||(Q[68]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),Q[72]||(Q[72]=T(" calculation:",-1))]),t("mjx-container",$,[(e(),a("svg",W,[...Q[73]||(Q[73]=[s("",1)])])),Q[74]||(Q[74]=t("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[t("mtext",null,"Current Server Time"),t("mo",null,"="),t("mtext",null,"Date.now()"),t("mo",null,"+"),t("mi",null,"θ")])],-1))]),t("p",null,[Q[77]||(Q[77]=T("Because the offset ",-1)),t("mjx-container",U,[(e(),a("svg",K,[...Q[75]||(Q[75]=[t("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[t("g",{"data-mml-node":"math"},[t("g",{"data-mml-node":"mi"},[t("path",{"data-c":"1D703",d:"M35 200Q35 302 74 415T180 610T319 704Q320 704 327 704T339 705Q393 701 423 656Q462 596 462 495Q462 380 417 261T302 66T168 -10H161Q125 -10 99 10T60 63T41 130T35 200ZM383 566Q383 668 330 668Q294 668 260 623T204 521T170 421T157 371Q206 370 254 370L351 371Q352 372 359 404T375 484T383 566ZM113 132Q113 26 166 26Q181 26 198 36T239 74T287 161T335 307L340 324H145Q145 321 136 286T120 208T113 132Z",style:{"stroke-width":"3"}})])])],-1)])])),Q[76]||(Q[76]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"θ")])],-1))]),Q[78]||(Q[78]=T(" is continuously maintained in memory, your application can invoke ",-1)),Q[79]||(Q[79]=t("code",null,"Tempo.ntp.now()",-1)),Q[80]||(Q[80]=T(" millions of times per second inside render loops or high-frequency calculation pipelines with zero performance penalty.",-1))])])}const n3=l(n,[["render",Y]]);export{l3 as __pageData,n3 as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.js new file mode 100644 index 00000000..8a26d8fa --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.js @@ -0,0 +1,17 @@ +import{_ as t}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as p,c as l,a2 as s,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ntp","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.index.md","filePath":"doc/9-plugins/ntp.index.md"}'),o={name:"doc/9-plugins/ntp.index.md"};function r(d,i,k,c,g,m){const a=n("PluginRepl");return p(),l("div",null,[i[0]||(i[0]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ntp ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A lightweight, high-precision Community plugin for the Tempo ecosystem that provides client-server network time synchronization and monotonic clock drift compensation using Cristian's algorithm, HTTP Server-Timing headers, jitter rejection, and Exponential Moving Average (EMA) smoothing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-ntp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture & Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';
+
+Tempo.use(NtpPlugin, {
+  server: '/api/time',                        // Default time synchronization endpoint
+  syncInterval: '15m',                        // Automatic periodic re-sync
+  interceptFetch: ['https://api.mycorp.com', '/api/'] // Passively calibrate only on trusted endpoints
+});
+
+// Explicitly calibrate against the server before querying calibrated time
+await Tempo.ntp.sync();
+const now = Tempo.ntp.now();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Options (NtpSyncOptions) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serverstringundefinedDedicated HTTP time endpoint returning Date or Server-Timing: clock=<epochMs>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    syncIntervalstring | numberundefinedPeriodic re-sync interval (e.g. '15m', '1h', or ms).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interceptFetchboolean | string | string[] | RegExp | FunctionfalsePassively sniff headers from application fetch calls. Can be true (sniff all), a path prefix, origin array, regex, or predicate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    trustedOriginsstring | string[] | RegExp | FunctionundefinedWhitelist of allowed origins or URL prefixes to sample when interceptFetch: true is enabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxAcceptableRttMsnumber1000Maximum round-trip time threshold in milliseconds. Jittery or delayed requests are discarded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alphanumber0.3Exponential Moving Average (EMA) smoothing factor between 0.0 and 1.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ntp/install';
+
+// Synchronize and query true calibrated server time
+await Tempo.ntp.sync();
+const now = Tempo.ntp.now();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore detailed guides on architecture, production use-cases, and algorithms:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use Cases & Production Patterns: Real-world architectures for financial countdowns, live auctions, zero-overhead passive calibration (interceptFetch), distributed logging synchronization, and TOTP authentication.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ticker Integration & Atomic Clocks: Integrating with @magmacomputing/tempo-plugin-ticker to build true-time, drift-compensated continuous execution loops and scheduled intervals (ntp: true).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cristian Algorithm & Precision Specs: Mathematical models for round-trip time (RTT) offset calculations, sub-millisecond Server-Timing headers, statistical jitter filtering, and EMA smoothing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interactive REPL ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,21)),h(a,{plugin:"ntp"}),i[1]||(i[1]=s('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';\nimport { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';\n\n// 1. Install the plugin (points to same-origin or CORS-enabled time endpoint)\nTempo.use(NtpPlugin, { server: '/api/time' });\n\n// 2. Perform an initial sync\nawait Tempo.ntp.sync();\n\n// 3. Query true calibrated atomic time (100% synchronous!)\nconst atomicNow = Tempo.ntp.now();\nconsole.log(`True UTC Time: ${atomicNow.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{ms}')}`);\nconsole.log(`Measured Drift Offset: ${Tempo.ntp.offset}ms`);\nconsole.log(`Uncertainty Window: ±${Tempo.ntp.drift.uncertaintyMs}ms`);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive API Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.now(timeZone?: string): Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Synchronously returns a new Tempo instance anchored to the calibrated atomic server timestamp.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.sync(endpoint?: string): Promise<ClockDriftState> ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Asynchronously sends a lightweight HTTP request to measure Round-Trip Time (RTT) and updates the Exponential Moving Average (EMA) drift offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.offset: number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Getter returning the current clock drift offset in milliseconds (serverTime = localTime + offset).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.drift: ClockDriftState ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Getter returning the full telemetry state snapshot:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClockDriftState {\n  readonly offsetMs: number;\n  readonly uncertaintyMs: number;\n  readonly lastSyncedAt: number;\n  readonly sampleCount: number;\n}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.isCalibrated: boolean ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Getter indicating whether at least one valid synchronization sample has been successfully processed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.reset(): void ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resets the calibration state and sample count back to zero.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.toNtpTime(): Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance method that returns a new Tempo instance offset by the current NTP clock drift.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',21))])}const F=e(o,[["render",r]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.lean.js new file mode 100644 index 00000000..79b6d045 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.index.md.BS3pht0N.lean.js @@ -0,0 +1 @@ +import{_ as t}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as p,c as l,a2 as s,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ntp","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.index.md","filePath":"doc/9-plugins/ntp.index.md"}'),o={name:"doc/9-plugins/ntp.index.md"};function r(d,i,k,c,g,m){const a=n("PluginRepl");return p(),l("div",null,[i[0]||(i[0]=s("",21)),h(a,{plugin:"ntp"}),i[1]||(i[1]=s("",21))])}const F=e(o,[["render",r]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.js new file mode 100644 index 00000000..c3fed89d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.js @@ -0,0 +1,38 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Ticker Integration & Atomic Clocks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.ticker-integration.md","filePath":"doc/9-plugins/ntp.ticker-integration.md"}'),e={name:"doc/9-plugins/ntp.ticker-integration.md"};function p(l,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ntp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker Integration & Atomic Clocks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When combined with @magmacomputing/tempo-plugin-ticker, @magmacomputing/tempo-plugin-ntp enables continuous execution loops and scheduled intervals compensated for client-server network clock drift.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. NTP-Compensated Cadence (ntp: true) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Ticker plugin supports the ntp: true option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When ntp: true is configured, Ticker seeds unanchored start times from Tempo.ntp.now() and dynamically adjusts internal countdown delays to compensate for measured remote clock drift (Tempo.ntp.offset):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+// 1. Install both plugins
+Tempo.use(NtpPlugin, { server: '/api/time' });
+Tempo.use(TickerPlugin);
+
+// 2. Initial sync
+await Tempo.ntp.sync();
+
+// 3. Create an NTP-compensated 1-second continuous ticker
+const ticker = Tempo.ticker({
+  ntp: true,
+  seconds: 1,
+  timeZone: 'America/New_York'
+}, (atomicTempo) => {
+  console.log(\`Atomic Wall Clock: \${atomicTempo.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}')}\`);
+  console.log(\`Calibrated Drift: \${Tempo.ntp.offset}ms\`);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Distributed Wall-Clock Aligned Schedules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In collaborative web applications, multiplayer games, and distributed IoT fleets, multiple independent nodes often need to trigger a synchronized action on true atomic minute or hour boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By passing ntp: true alongside cron schedules or duration steps, all participating nodes align to true atomic epoch boundaries:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// Trigger on every 5-minute atomic boundary
+const synchronizedJob = Tempo.ticker({
+  ntp: true,
+  cron: '*/5 * * * *'
+}, (atomicTempo) => {
+  console.log(\`[SYNCHRONIZED PULSE] Distributed task at \${atomicTempo.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}')}\`);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Explicit Resource Management & Lifecycle ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NTP-enabled tickers implement ECMAScript explicit resource management ([Symbol.dispose] / [Symbol.asyncDispose]):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  await using activeTicker = Tempo.ticker({
+    ntp: true,
+    seconds: 5,
+    limit: 10
+  }, (now, stop) => {
+    updateDashboard(now);
+  });
+  
+  // Do work...
+} // 🧹 Automatically stopped and unmounted upon exiting scope!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Fallback Behavior ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If Tempo.ticker({ ntp: true, ... }) is invoked before an NTP sync has occurred, or if NtpPlugin has not yet been registered, the Ticker plugin gracefully falls back to local system time and calculates delays from instant().epochMilliseconds without throwing runtime errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,21)])])}const c=i(e,[["render",p]]);export{o as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.lean.js new file mode 100644 index 00000000..a31d64e7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.ticker-integration.md.BysX5Afz.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Ticker Integration & Atomic Clocks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.ticker-integration.md","filePath":"doc/9-plugins/ntp.ticker-integration.md"}'),e={name:"doc/9-plugins/ntp.ticker-integration.md"};function p(l,s,h,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t("",21)])])}const c=i(e,[["render",p]]);export{o as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.js new file mode 100644 index 00000000..1396aaab --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.js @@ -0,0 +1,67 @@ +import{_ as l,o as t,c as n,a2 as a,j as s,a as e}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.use-cases-and-patterns.md","filePath":"doc/9-plugins/ntp.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/ntp.use-cases-and-patterns.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},r={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"22.745ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 10053.1 1000","aria-hidden":"true"};function k(d,i,o,E,c,g){return t(),n("div",null,[i[4]||(i[4]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ntp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Client devices in modern web and mobile environments suffer from unpredictable clock skew. Users frequently travel across time zones, adjust system clocks manually, run outdated CMOS batteries, or experience clock throttling during laptop sleep cycles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ntp plugin provides industrial-grade time consistency by locking Tempo instances to true atomic server time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Anti-Cheat Live Countdowns & Flash Sales ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In live auctions, ticket drops, e-commerce flash sales, and sports betting, user interfaces rely on countdown timers. If a client manipulates their system clock backwards or forwards, standard new Date() or Date.now() timers will display false deadlines or prematurely disable bidding buttons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem with Uncalibrated Timers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ⚠️ VULNERABLE: If user sets their OS clock forward 10 minutes,
+// the countdown immediately hits 00:00:00 and locks them out.
+const timeLeftMs = saleEnd.getTime() - Date.now();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Calibrated Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ntp.now() evaluates the true atomic timeline with zero asynchronous overhead:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';
+
+Tempo.use(NtpPlugin, { server: '/api/v1/time' });
+
+// Ensure calibration is established
+await Tempo.ntp.sync();
+
+function getAuctionRemainingTime(auctionEnd: Tempo) {
+  // Synchronous, true server time calculation
+  const trueNow = Tempo.ntp.now();
+  
+  if (trueNow.epoch.ms >= auctionEnd.epoch.ms) {
+    return { isExpired: true, remainingMs: 0 };
+  }
+  
+  return {
+    isExpired: false,
+    remainingMs: auctionEnd.epoch.ms - trueNow.epoch.ms
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Zero-Overhead Passive Calibration (interceptFetch) & Origin Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Running dedicated background ping loops to sync time can waste mobile battery and add server load. tempo-plugin-ntp solves this via Passive Fetch Interception.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When passive fetch interception is enabled, the plugin inspects the HTTP response's Server-Timing or standard Date headers and recalculates drift alongside normal application data fetching, without issuing a single extra HTTP call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Trust Boundaries & Origin Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your application makes network calls to external third parties (e.g., payment gateways, external webhooks, analytics, or user-supplied URLs), you should never allow third-party servers to alter your application's shared clock offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To enforce strict boundary security, interceptFetch supports origin filtering via URL prefixes, origin whitelists, regex patterns, or custom predicates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';
+
+// Option A: Pass trusted origins/prefixes directly to interceptFetch
+Tempo.use(NtpPlugin, {
+  interceptFetch: ['https://api.mycompany.com', '/api/'],
+  alpha: 0.2
+});
+
+// Option B: Enable interceptFetch with an explicit trustedOrigins whitelist
+Tempo.use(NtpPlugin, {
+  interceptFetch: true,
+  trustedOrigins: ['https://api.mycompany.com', '/api/']
+});
+
+// Option C: Pattern matching via regular expression or predicate function
+Tempo.use(NtpPlugin, {
+  interceptFetch: (url) => url.startsWith('/api/') || url.includes('trusted-internal.com')
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Ingestion Flow ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Trusted first-party call: passively recalibrates Tempo.ntp clock offset
+const user = await fetch('/api/user/profile').then(r => r.json());
+console.log(\`Calibrated drift: \${Tempo.ntp.offset}ms (Sample #\${Tempo.ntp.drift.sampleCount})\`);
+
+// 2. Untrusted third-party call: response headers are safely ignored
+await fetch('https://untrusted-analytics.com/event', { method: 'POST' });
+// Clock offset remains calibrated exclusively by trusted first-party responses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Distributed Telemetry & Client Log Correlation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When debugging production issues across thousands of distributed clients, correlating frontend crash events with backend API logs is notoriously difficult because client timestamps are untrustworthy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using NTP-anchored logging guarantees that client log records share the backend's exact UTC epoch timeline:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+export function sendTelemetryLog(eventType: string, payload: Record<string, unknown>) {
+  const payloadWithTrueTimestamp = {
+    event: eventType,
+    data: payload,
+    // True UTC timestamp matching server logs
+    serverTimeUtc: Tempo.ntp.now().format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{ms}'),
+    localTimeUtc: new Tempo().format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{ms}'),
+    measuredDriftMs: Tempo.ntp.offset,
+    uncertaintyMs: Tempo.ntp.drift.uncertaintyMs
+  };
+
+  navigator.sendBeacon('/api/telemetry', JSON.stringify(payloadWithTrueTimestamp));
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Time-Based One-Time Passwords (TOTP / 2FA) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,30)),s("p",null,[i[2]||(i[2]=e("TOTP algorithms (RFC 6238) compute authentication codes using 30-second epoch time slices (",-1)),s("mjx-container",p,[(t(),n("svg",r,[...i[0]||(i[0]=[a('',1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("msub",null,[s("mi",null,"T"),s("mn",null,"0")]),s("mo",null,"="),s("mo",{fence:"false",stretchy:"false"},"⌊"),s("mtext",null,"epochMs"),s("mrow",{"data-mjx-texclass":"ORD"},[s("mo",null,"/")]),s("mn",null,"30000"),s("mo",{fence:"false",stretchy:"false"},"⌋")])],-1))]),i[3]||(i[3]=e("). If a client device's clock drifts by more than 30–60 seconds, generated 2FA tokens will be rejected by the server as invalid.",-1))]),i[5]||(i[5]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+function getTotpTimeStep(): number {
+  // Always derive 30s bucket from calibrated atomic time
+  const calibratedEpoch = Tempo.ntp.now().epoch.ms;
+  return Math.floor(calibratedEpoch / 30000);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Drift Convergence & High-Frequency Queries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once calibrated, Tempo.ntp.now() synchronously calculates Date.now() + offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because drift is continuously smoothed via Exponential Moving Average (EMA) and maintained in-memory, high-frequency renders, animation frames, and interval loops can query true server time millions of times per second with zero network or asynchronous overhead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,5))])}const T=l(h,[["render",k]]);export{m as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.lean.js new file mode 100644 index 00000000..0248bc10 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ntp.use-cases-and-patterns.md.BGQwe7LQ.lean.js @@ -0,0 +1 @@ +import{_ as l,o as t,c as n,a2 as a,j as s,a as e}from"./chunks/framework.DNL3hc5c.js";const m=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ntp.use-cases-and-patterns.md","filePath":"doc/9-plugins/ntp.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/ntp.use-cases-and-patterns.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},r={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"22.745ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 10053.1 1000","aria-hidden":"true"};function k(d,i,o,E,c,g){return t(),n("div",null,[i[4]||(i[4]=a("",30)),s("p",null,[i[2]||(i[2]=e("TOTP algorithms (RFC 6238) compute authentication codes using 30-second epoch time slices (",-1)),s("mjx-container",p,[(t(),n("svg",r,[...i[0]||(i[0]=[a("",1)])])),i[1]||(i[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("msub",null,[s("mi",null,"T"),s("mn",null,"0")]),s("mo",null,"="),s("mo",{fence:"false",stretchy:"false"},"⌊"),s("mtext",null,"epochMs"),s("mrow",{"data-mjx-texclass":"ORD"},[s("mo",null,"/")]),s("mn",null,"30000"),s("mo",{fence:"false",stretchy:"false"},"⌋")])],-1))]),i[3]||(i[3]=e("). If a client device's clock drifts by more than 30–60 seconds, generated 2FA tokens will be rejected by the server as invalid.",-1))]),i[5]||(i[5]=a("",5))])}const T=l(h,[["render",k]]);export{m as __pageData,T as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.js new file mode 100644 index 00000000..574fd96c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.js @@ -0,0 +1,18 @@ +import{_ as l,o as e,c as s,a2 as a,j as Q,a as T}from"./chunks/framework.DNL3hc5c.js";const a1=JSON.parse('{"title":"Classical Fasti & Lunar Anchors","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.calendar-mechanics.md","filePath":"doc/9-plugins/roman.calendar-mechanics.md"}'),n={name:"doc/9-plugins/roman.calendar-mechanics.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},i={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},m={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},H={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},V={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.462ex"},xmlns:"http://www.w3.org/2000/svg",width:"31.184ex",height:"2.081ex",role:"img",focusable:"false",viewBox:"0 -716 13783.4 920","aria-hidden":"true"},g={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},w={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"47.172ex",height:"1.756ex",role:"img",focusable:"false",viewBox:"0 -694 20850 776","aria-hidden":"true"},L={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},u={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.462ex"},xmlns:"http://www.w3.org/2000/svg",width:"33.517ex",height:"2.057ex",role:"img",focusable:"false",viewBox:"0 -705 14814.4 909","aria-hidden":"true"},y={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"58.776ex",height:"1.756ex",role:"img",focusable:"false",viewBox:"0 -694 25979 776","aria-hidden":"true"},x={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},f={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.312ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.875ex",height:"1.857ex",role:"img",focusable:"false",viewBox:"0 -683 2596.6 821","aria-hidden":"true"},M={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},Z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.93ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 7041 798","aria-hidden":"true"},b={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},v={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"20.078ex",height:"1.674ex",role:"img",focusable:"false",viewBox:"0 -716 8874.6 740","aria-hidden":"true"},_={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},C={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"24.603ex",height:"1.674ex",role:"img",focusable:"false",viewBox:"0 -716 10874.6 740","aria-hidden":"true"},A={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},E={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.373ex"},xmlns:"http://www.w3.org/2000/svg",width:"9.028ex",height:"1.918ex",role:"img",focusable:"false",viewBox:"0 -683 3990.3 847.8","aria-hidden":"true"},S={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},D={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.373ex"},xmlns:"http://www.w3.org/2000/svg",width:"19.083ex",height:"1.993ex",role:"img",focusable:"false",viewBox:"0 -716 8434.7 880.8","aria-hidden":"true"},I={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},F={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"34.25ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 15138.6 798","aria-hidden":"true"},j={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},P={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"34.25ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 15138.6 798","aria-hidden":"true"},B={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},R={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.312ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.875ex",height:"1.857ex",role:"img",focusable:"false",viewBox:"0 -683 2596.6 821","aria-hidden":"true"},N={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},J={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"10.621ex",height:"1.781ex",role:"img",focusable:"false",viewBox:"0 -705 4694.6 787","aria-hidden":"true"},q={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},K={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"14.644ex",height:"1.781ex",role:"img",focusable:"false",viewBox:"0 -705 6472.6 787","aria-hidden":"true"},O={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.93ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 7041 798","aria-hidden":"true"},G={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},U={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"64.686ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 28591 1000","aria-hidden":"true"};function Y($,t,X,W,Q1,t1){return e(),s("div",null,[t[83]||(t[83]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-roman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Classical Fasti & Lunar Anchors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Roman calendar system (Fasti) operated on astronomical and liturgical principles distinct from modern sequential month numbering. Rather than numbering days sequentially from 1 to 31, Roman dates were computed by counting backwards from three fixed lunar anchor points.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Three Lunar Anchor Points ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Roman month contains three primary anchor points rooted in the lunar calendar of the early Roman Republic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Kalends (Kalendae):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Always occurs on the 1st day of every month.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Originally marked the new crescent moon (calare, to call out or announce).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • In Latin syntax, dates on the Kalends use the feminine plural Ablative: Kalendis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Nones (Nonae):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Originally coincided with the First Quarter moon (nine days before the Ides, counting inclusively).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Occurs on the 7th day in the four long "MOM-J" months: March, October, May, and July.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Occurs on the 5th day in all remaining eight months.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • In Latin syntax: Nonis (Ablative).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Ides (Idus):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Originally coincided with the Full Moon.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Occurs on the 15th day in "MOM-J" months (March, October, May, July).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Occurs on the 13th day in all other months.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • In Latin syntax: Idibus (Ablative).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MOM-J Months (March, October, May, July):
+  Day 1:  Kalends (Kalendis)
+  Day 7:  Nones   (Nonis)
+  Day 15: Ides    (Idibus)
+
+All Other Months (Jan, Feb, Apr, Jun, Aug, Sep, Nov, Dec):
+  Day 1:  Kalends (Kalendis)
+  Day 5:  Nones   (Nonis)
+  Day 13: Ides    (Idibus)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inclusive Backward Counting (Ante Diem) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Romans did not count forward from the beginning of the month; they counted backwards towards the next upcoming anchor point:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,12)),Q("ol",null,[Q("li",null,[t[16]||(t[16]=Q("p",null,[Q("strong",null,[T("Exact Anchor Days ("),Q("code",null,"relation: 'on'"),T(")")]),T(": Expressed in the Ablative case without prefixes:")],-1)),Q("ul",null,[Q("li",null,[t[2]||(t[2]=T("March 15 ",-1)),Q("mjx-container",r,[(e(),s("svg",o,[...t[0]||(t[0]=[a('',1)])])),t[1]||(t[1]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[3]||(t[3]=T()),t[4]||(t[4]=Q("em",null,"Idibus Martiis",-1)),t[5]||(t[5]=T(" (",-1)),t[6]||(t[6]=Q("code",null,"Id. Mart.",-1)),t[7]||(t[7]=T(")",-1))]),Q("li",null,[t[10]||(t[10]=T("January 1 ",-1)),Q("mjx-container",d,[(e(),s("svg",i,[...t[8]||(t[8]=[a('',1)])])),t[9]||(t[9]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[11]||(t[11]=T()),t[12]||(t[12]=Q("em",null,"Kalendis Januariis",-1)),t[13]||(t[13]=T(" (",-1)),t[14]||(t[14]=Q("code",null,"Kal. Jan.",-1)),t[15]||(t[15]=T(")",-1))])])]),Q("li",null,[t[33]||(t[33]=Q("p",null,[Q("strong",null,[T("The Preceding Day ("),Q("code",null,"relation: 'pridie'"),T(")")]),T(": The day immediately preceding an anchor uses the adverb "),Q("em",null,"Pridie"),T(" followed by the anchor and month in the Accusative:")],-1)),Q("ul",null,[Q("li",null,[t[19]||(t[19]=T("March 14 ",-1)),Q("mjx-container",h,[(e(),s("svg",m,[...t[17]||(t[17]=[a('',1)])])),t[18]||(t[18]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[20]||(t[20]=T()),t[21]||(t[21]=Q("em",null,"Pridie Idus Martias",-1)),t[22]||(t[22]=T(" (",-1)),t[23]||(t[23]=Q("code",null,"Prid. Id. Mart.",-1)),t[24]||(t[24]=T(")",-1))]),Q("li",null,[t[27]||(t[27]=T("October 31 ",-1)),Q("mjx-container",p,[(e(),s("svg",H,[...t[25]||(t[25]=[a('',1)])])),t[26]||(t[26]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[28]||(t[28]=T()),t[29]||(t[29]=Q("em",null,"Pridie Kalendas Novembres",-1)),t[30]||(t[30]=T(" (",-1)),t[31]||(t[31]=Q("code",null,"Prid. Kal. Nov.",-1)),t[32]||(t[32]=T(")",-1))])])]),Q("li",null,[t[38]||(t[38]=Q("p",null,[Q("strong",null,[T("Inclusive Counting ("),Q("code",null,"relation: 'ante_diem'"),T(")")]),T(": All other days count inclusively, meaning both the starting date and the anchor date itself are counted. The formula for days prior to the Nones or Ides is:")],-1)),Q("mjx-container",V,[(e(),s("svg",c,[...t[34]||(t[34]=[a('',1)])])),t[35]||(t[35]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"Count"),Q("mo",null,"="),Q("mtext",null,"AnchorDay"),Q("mo",null,"−"),Q("mtext",null,"Day"),Q("mo",null,"+"),Q("mn",null,"1")])],-1))]),t[39]||(t[39]=Q("p",null,"For example, March 12 before the March 15 Ides:",-1)),Q("mjx-container",g,[(e(),s("svg",w,[...t[36]||(t[36]=[a('',1)])])),t[37]||(t[37]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mn",null,"15"),Q("mo",null,"−"),Q("mn",null,"12"),Q("mo",null,"+"),Q("mn",null,"1"),Q("mo",null,"="),Q("mn",null,"4"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"ante diem IV Idus Martias")])],-1))])]),Q("li",null,[t[44]||(t[44]=Q("p",null,[Q("strong",null,"Dates Past the Ides"),T(": Once the Ides of a month passes, dates are calculated backwards from the "),Q("strong",null,"Kalends of the following month"),T(":")],-1)),Q("mjx-container",L,[(e(),s("svg",u,[...t[40]||(t[40]=[a('',1)])])),t[41]||(t[41]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"Count"),Q("mo",null,"="),Q("mtext",null,"DaysInMonth"),Q("mo",null,"−"),Q("mtext",null,"Day"),Q("mo",null,"+"),Q("mn",null,"2")])],-1))]),t[45]||(t[45]=Q("p",null,"For example, October 16 (in a 31-day month) before the November 1 Kalends:",-1)),Q("mjx-container",y,[(e(),s("svg",k,[...t[42]||(t[42]=[a('',1)])])),t[43]||(t[43]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mn",null,"31"),Q("mo",null,"−"),Q("mn",null,"16"),Q("mo",null,"+"),Q("mn",null,"2"),Q("mo",null,"="),Q("mn",null,"17"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"ante diem XVII Kalendas Novembres")])],-1))])])]),t[84]||(t[84]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Leap Year Intercalation: The Bissextile Day ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Under the Julian calendar reform (45 BCE), an intercalary day was added every four years in February. Rather than appending an extra day at the end of the month (which would have disturbed the religious festivals aligned to the end of February, such as the Terminalia on February 23), the Romans doubled the sixth day before the March Kalends (ante diem sextum Kalendas Martias):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • February 24: ante diem bis sextum Kalendas Martias (the doubled "second sixth day")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • February 25: ante diem sextum Kalendas Martias (the sixth day)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • February 29: Pridie Kalendas Martias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This practice gave rise to the term Bissextile Year (annus bissextilis). @magmacomputing/tempo-plugin-roman faithfully reproduces this classical intercalation by default ({ bissextile: true }):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const leapDay = new Tempo('2024-02-24');
+const res = leapDay.toRomanClassical();
+
+console.log(res.isBissextile); // true
+console.log(res.latin);        // "ante diem bis sextum Kalendas Martias"
+console.log(res.shortLatin);   // "a.d. bis VI Kal. Mart."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ab Urbe Condita (AUC) Calculations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Years were traditionally recorded by naming the presiding Roman Consuls. Historians also reckoned time Ab Urbe Condita ("from the founding of the City"), traditionally fixed to 753 BCE by the scholar Marcus Terentius Varro.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin provides exact mathematical conversions between astronomical years, Common Era years, and AUC:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,10)),Q("ol",null,[Q("li",null,[Q("p",null,[Q("strong",null,[t[48]||(t[48]=T("Common Era (",-1)),Q("mjx-container",x,[(e(),s("svg",f,[...t[46]||(t[46]=[a('',1)])])),t[47]||(t[47]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mi",null,"Y"),Q("mo",null,"≥"),Q("mn",null,"1")])],-1))]),t[49]||(t[49]=T(")",-1))]),t[50]||(t[50]=T(":",-1))]),Q("mjx-container",M,[(e(),s("svg",Z,[...t[51]||(t[51]=[a('',1)])])),t[52]||(t[52]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mi",null,"Y"),Q("mo",null,"+"),Q("mn",null,"753")])],-1))]),Q("ul",null,[Q("li",null,[Q("mjx-container",b,[(e(),s("svg",v,[...t[53]||(t[53]=[a('',1)])])),t[54]||(t[54]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"1"),Q("mtext",null," CE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mtext",null," AUC")])],-1))])]),Q("li",null,[Q("mjx-container",_,[(e(),s("svg",C,[...t[55]||(t[55]=[a('',1)])])),t[56]||(t[56]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"2026"),Q("mtext",null," CE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"2779"),Q("mtext",null," AUC")])],-1))])])])]),Q("li",null,[Q("p",null,[Q("strong",null,[t[59]||(t[59]=T("Before Common Era (",-1)),Q("mjx-container",A,[(e(),s("svg",E,[...t[57]||(t[57]=[a('',1)])])),t[58]||(t[58]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("msub",null,[Q("mi",null,"Y"),Q("mrow",{"data-mjx-texclass":"ORD"},[Q("mtext",null,"BCE")])]),Q("mo",null,"≥"),Q("mn",null,"1")])],-1))]),t[60]||(t[60]=T(")",-1))]),t[61]||(t[61]=T(":",-1))]),Q("mjx-container",S,[(e(),s("svg",D,[...t[62]||(t[62]=[a('',1)])])),t[63]||(t[63]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mn",null,"754"),Q("mo",null,"−"),Q("msub",null,[Q("mi",null,"Y"),Q("mrow",{"data-mjx-texclass":"ORD"},[Q("mtext",null,"BCE")])])])],-1))]),Q("ul",null,[Q("li",null,[Q("mjx-container",I,[(e(),s("svg",F,[...t[64]||(t[64]=[a('',1)])])),t[65]||(t[65]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"44"),Q("mtext",null," BCE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mo",null,"−"),Q("mn",null,"44"),Q("mo",null,"="),Q("mn",null,"710"),Q("mtext",null," AUC")])],-1))])]),Q("li",null,[Q("mjx-container",j,[(e(),s("svg",P,[...t[66]||(t[66]=[a('',1)])])),t[67]||(t[67]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"753"),Q("mtext",null," BCE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mo",null,"−"),Q("mn",null,"753"),Q("mo",null,"="),Q("mn",null,"1"),Q("mtext",null," AUC")])],-1))])])])]),Q("li",null,[Q("p",null,[Q("strong",null,[t[70]||(t[70]=T("Astronomical Years (",-1)),Q("mjx-container",B,[(e(),s("svg",R,[...t[68]||(t[68]=[a('',1)])])),t[69]||(t[69]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mi",null,"Y"),Q("mo",null,"≤"),Q("mn",null,"0")])],-1))]),t[71]||(t[71]=T(")",-1))]),t[76]||(t[76]=T(": Continuous astronomical year numbering (",-1)),Q("mjx-container",N,[(e(),s("svg",J,[...t[72]||(t[72]=[a('',1)])])),t[73]||(t[73]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"0"),Q("mo",null,"="),Q("mn",null,"1"),Q("mtext",null," BCE")])],-1))]),t[77]||(t[77]=T(", ",-1)),Q("mjx-container",q,[(e(),s("svg",K,[...t[74]||(t[74]=[a('',1)])])),t[75]||(t[75]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mo",null,"−"),Q("mn",null,"43"),Q("mo",null,"="),Q("mn",null,"44"),Q("mtext",null," BCE")])],-1))]),t[78]||(t[78]=T(") follows a single continuous linear relation:",-1))]),Q("mjx-container",O,[(e(),s("svg",z,[...t[79]||(t[79]=[a('',1)])])),t[80]||(t[80]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mi",null,"Y"),Q("mo",null,"+"),Q("mn",null,"753")])],-1))])])]),t[85]||(t[85]=Q("hr",null,null,-1)),t[86]||(t[86]=Q("h2",{id:"consular-chronology-fasti-consulares",tabindex:"-1"},[T("Consular Chronology ("),Q("em",null,"Fasti Consulares"),T(") "),Q("a",{class:"header-anchor",href:"#consular-chronology-fasti-consulares","aria-label":'Permalink to "Consular Chronology (*Fasti Consulares*)"'},"​")],-1)),t[87]||(t[87]=Q("p",null,[T("In everyday Roman civic and legal life, years were designated by naming the two ordinary consuls ("),Q("em",null,"consules ordinarii"),T(") who entered office on the Kalends of January:")],-1)),Q("mjx-container",G,[(e(),s("svg",U,[...t[81]||(t[81]=[a('',1)])])),t[82]||(t[82]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"Cicerone et Antonio consulibus"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"63"),Q("mtext",null," BCE"),Q("mtext",null," (astronomical "),Q("mo",null,"−"),Q("mn",null,"62"),Q("mo",{stretchy:"false"},")")])],-1))]),t[88]||(t[88]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The plugin includes historical consular dating. By default, the core bundle provides a curated seed catalog of landmark years (e.g. 509 BCE founding, 63 BCE Cicero, 44 BCE Caesar, 541 CE Basilius).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To access the complete historical catalog spanning all 1,050 years from the founding of the Roman Republic in 509 BCE (-508) through the final recorded consul in the West in 541 CE (541), import the ./consuls subpath:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-roman/consuls';
+
+const idesMarch44 = new Tempo('-000043-03-15');
+console.log(idesMarch44.consuls);
+// "C. Julio Caesare V, M. Antonio coss."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,6))])}const e1=l(n,[["render",Y]]);export{a1 as __pageData,e1 as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.lean.js new file mode 100644 index 00000000..4312985c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.calendar-mechanics.md.Dxfr-GWH.lean.js @@ -0,0 +1 @@ +import{_ as l,o as e,c as s,a2 as a,j as Q,a as T}from"./chunks/framework.DNL3hc5c.js";const a1=JSON.parse('{"title":"Classical Fasti & Lunar Anchors","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.calendar-mechanics.md","filePath":"doc/9-plugins/roman.calendar-mechanics.md"}'),n={name:"doc/9-plugins/roman.calendar-mechanics.md"},r={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},o={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},d={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},i={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},m={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},H={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.964ex",height:"1.242ex",role:"img",focusable:"false",viewBox:"0 -525 2194 549","aria-hidden":"true"},V={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},c={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.462ex"},xmlns:"http://www.w3.org/2000/svg",width:"31.184ex",height:"2.081ex",role:"img",focusable:"false",viewBox:"0 -716 13783.4 920","aria-hidden":"true"},g={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},w={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"47.172ex",height:"1.756ex",role:"img",focusable:"false",viewBox:"0 -694 20850 776","aria-hidden":"true"},L={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},u={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.462ex"},xmlns:"http://www.w3.org/2000/svg",width:"33.517ex",height:"2.057ex",role:"img",focusable:"false",viewBox:"0 -705 14814.4 909","aria-hidden":"true"},y={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"58.776ex",height:"1.756ex",role:"img",focusable:"false",viewBox:"0 -694 25979 776","aria-hidden":"true"},x={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},f={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.312ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.875ex",height:"1.857ex",role:"img",focusable:"false",viewBox:"0 -683 2596.6 821","aria-hidden":"true"},M={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},Z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.93ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 7041 798","aria-hidden":"true"},b={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},v={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"20.078ex",height:"1.674ex",role:"img",focusable:"false",viewBox:"0 -716 8874.6 740","aria-hidden":"true"},_={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},C={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.054ex"},xmlns:"http://www.w3.org/2000/svg",width:"24.603ex",height:"1.674ex",role:"img",focusable:"false",viewBox:"0 -716 10874.6 740","aria-hidden":"true"},A={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},E={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.373ex"},xmlns:"http://www.w3.org/2000/svg",width:"9.028ex",height:"1.918ex",role:"img",focusable:"false",viewBox:"0 -683 3990.3 847.8","aria-hidden":"true"},S={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},D={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.373ex"},xmlns:"http://www.w3.org/2000/svg",width:"19.083ex",height:"1.993ex",role:"img",focusable:"false",viewBox:"0 -716 8434.7 880.8","aria-hidden":"true"},I={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},F={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"34.25ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 15138.6 798","aria-hidden":"true"},j={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},P={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"34.25ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 15138.6 798","aria-hidden":"true"},B={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},R={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.312ex"},xmlns:"http://www.w3.org/2000/svg",width:"5.875ex",height:"1.857ex",role:"img",focusable:"false",viewBox:"0 -683 2596.6 821","aria-hidden":"true"},N={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},J={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"10.621ex",height:"1.781ex",role:"img",focusable:"false",viewBox:"0 -705 4694.6 787","aria-hidden":"true"},q={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},K={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"14.644ex",height:"1.781ex",role:"img",focusable:"false",viewBox:"0 -705 6472.6 787","aria-hidden":"true"},O={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},z={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.186ex"},xmlns:"http://www.w3.org/2000/svg",width:"15.93ex",height:"1.805ex",role:"img",focusable:"false",viewBox:"0 -716 7041 798","aria-hidden":"true"},G={tabindex:"0",class:"MathJax",jax:"SVG",display:"true",style:{direction:"ltr",display:"block","text-align":"center",margin:"1em 0",position:"relative"}},U={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"64.686ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 28591 1000","aria-hidden":"true"};function Y($,t,X,W,Q1,t1){return e(),s("div",null,[t[83]||(t[83]=a("",12)),Q("ol",null,[Q("li",null,[t[16]||(t[16]=Q("p",null,[Q("strong",null,[T("Exact Anchor Days ("),Q("code",null,"relation: 'on'"),T(")")]),T(": Expressed in the Ablative case without prefixes:")],-1)),Q("ul",null,[Q("li",null,[t[2]||(t[2]=T("March 15 ",-1)),Q("mjx-container",r,[(e(),s("svg",o,[...t[0]||(t[0]=[a("",1)])])),t[1]||(t[1]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[3]||(t[3]=T()),t[4]||(t[4]=Q("em",null,"Idibus Martiis",-1)),t[5]||(t[5]=T(" (",-1)),t[6]||(t[6]=Q("code",null,"Id. Mart.",-1)),t[7]||(t[7]=T(")",-1))]),Q("li",null,[t[10]||(t[10]=T("January 1 ",-1)),Q("mjx-container",d,[(e(),s("svg",i,[...t[8]||(t[8]=[a("",1)])])),t[9]||(t[9]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[11]||(t[11]=T()),t[12]||(t[12]=Q("em",null,"Kalendis Januariis",-1)),t[13]||(t[13]=T(" (",-1)),t[14]||(t[14]=Q("code",null,"Kal. Jan.",-1)),t[15]||(t[15]=T(")",-1))])])]),Q("li",null,[t[33]||(t[33]=Q("p",null,[Q("strong",null,[T("The Preceding Day ("),Q("code",null,"relation: 'pridie'"),T(")")]),T(": The day immediately preceding an anchor uses the adverb "),Q("em",null,"Pridie"),T(" followed by the anchor and month in the Accusative:")],-1)),Q("ul",null,[Q("li",null,[t[19]||(t[19]=T("March 14 ",-1)),Q("mjx-container",h,[(e(),s("svg",m,[...t[17]||(t[17]=[a("",1)])])),t[18]||(t[18]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[20]||(t[20]=T()),t[21]||(t[21]=Q("em",null,"Pridie Idus Martias",-1)),t[22]||(t[22]=T(" (",-1)),t[23]||(t[23]=Q("code",null,"Prid. Id. Mart.",-1)),t[24]||(t[24]=T(")",-1))]),Q("li",null,[t[27]||(t[27]=T("October 31 ",-1)),Q("mjx-container",p,[(e(),s("svg",H,[...t[25]||(t[25]=[a("",1)])])),t[26]||(t[26]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})])])],-1))]),t[28]||(t[28]=T()),t[29]||(t[29]=Q("em",null,"Pridie Kalendas Novembres",-1)),t[30]||(t[30]=T(" (",-1)),t[31]||(t[31]=Q("code",null,"Prid. Kal. Nov.",-1)),t[32]||(t[32]=T(")",-1))])])]),Q("li",null,[t[38]||(t[38]=Q("p",null,[Q("strong",null,[T("Inclusive Counting ("),Q("code",null,"relation: 'ante_diem'"),T(")")]),T(": All other days count inclusively, meaning both the starting date and the anchor date itself are counted. The formula for days prior to the Nones or Ides is:")],-1)),Q("mjx-container",V,[(e(),s("svg",c,[...t[34]||(t[34]=[a("",1)])])),t[35]||(t[35]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"Count"),Q("mo",null,"="),Q("mtext",null,"AnchorDay"),Q("mo",null,"−"),Q("mtext",null,"Day"),Q("mo",null,"+"),Q("mn",null,"1")])],-1))]),t[39]||(t[39]=Q("p",null,"For example, March 12 before the March 15 Ides:",-1)),Q("mjx-container",g,[(e(),s("svg",w,[...t[36]||(t[36]=[a("",1)])])),t[37]||(t[37]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mn",null,"15"),Q("mo",null,"−"),Q("mn",null,"12"),Q("mo",null,"+"),Q("mn",null,"1"),Q("mo",null,"="),Q("mn",null,"4"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"ante diem IV Idus Martias")])],-1))])]),Q("li",null,[t[44]||(t[44]=Q("p",null,[Q("strong",null,"Dates Past the Ides"),T(": Once the Ides of a month passes, dates are calculated backwards from the "),Q("strong",null,"Kalends of the following month"),T(":")],-1)),Q("mjx-container",L,[(e(),s("svg",u,[...t[40]||(t[40]=[a("",1)])])),t[41]||(t[41]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"Count"),Q("mo",null,"="),Q("mtext",null,"DaysInMonth"),Q("mo",null,"−"),Q("mtext",null,"Day"),Q("mo",null,"+"),Q("mn",null,"2")])],-1))]),t[45]||(t[45]=Q("p",null,"For example, October 16 (in a 31-day month) before the November 1 Kalends:",-1)),Q("mjx-container",y,[(e(),s("svg",k,[...t[42]||(t[42]=[a("",1)])])),t[43]||(t[43]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mn",null,"31"),Q("mo",null,"−"),Q("mn",null,"16"),Q("mo",null,"+"),Q("mn",null,"2"),Q("mo",null,"="),Q("mn",null,"17"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"ante diem XVII Kalendas Novembres")])],-1))])])]),t[84]||(t[84]=a("",10)),Q("ol",null,[Q("li",null,[Q("p",null,[Q("strong",null,[t[48]||(t[48]=T("Common Era (",-1)),Q("mjx-container",x,[(e(),s("svg",f,[...t[46]||(t[46]=[a("",1)])])),t[47]||(t[47]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mi",null,"Y"),Q("mo",null,"≥"),Q("mn",null,"1")])],-1))]),t[49]||(t[49]=T(")",-1))]),t[50]||(t[50]=T(":",-1))]),Q("mjx-container",M,[(e(),s("svg",Z,[...t[51]||(t[51]=[a("",1)])])),t[52]||(t[52]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mi",null,"Y"),Q("mo",null,"+"),Q("mn",null,"753")])],-1))]),Q("ul",null,[Q("li",null,[Q("mjx-container",b,[(e(),s("svg",v,[...t[53]||(t[53]=[a("",1)])])),t[54]||(t[54]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"1"),Q("mtext",null," CE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mtext",null," AUC")])],-1))])]),Q("li",null,[Q("mjx-container",_,[(e(),s("svg",C,[...t[55]||(t[55]=[a("",1)])])),t[56]||(t[56]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"2026"),Q("mtext",null," CE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"2779"),Q("mtext",null," AUC")])],-1))])])])]),Q("li",null,[Q("p",null,[Q("strong",null,[t[59]||(t[59]=T("Before Common Era (",-1)),Q("mjx-container",A,[(e(),s("svg",E,[...t[57]||(t[57]=[a("",1)])])),t[58]||(t[58]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("msub",null,[Q("mi",null,"Y"),Q("mrow",{"data-mjx-texclass":"ORD"},[Q("mtext",null,"BCE")])]),Q("mo",null,"≥"),Q("mn",null,"1")])],-1))]),t[60]||(t[60]=T(")",-1))]),t[61]||(t[61]=T(":",-1))]),Q("mjx-container",S,[(e(),s("svg",D,[...t[62]||(t[62]=[a("",1)])])),t[63]||(t[63]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mn",null,"754"),Q("mo",null,"−"),Q("msub",null,[Q("mi",null,"Y"),Q("mrow",{"data-mjx-texclass":"ORD"},[Q("mtext",null,"BCE")])])])],-1))]),Q("ul",null,[Q("li",null,[Q("mjx-container",I,[(e(),s("svg",F,[...t[64]||(t[64]=[a("",1)])])),t[65]||(t[65]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"44"),Q("mtext",null," BCE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mo",null,"−"),Q("mn",null,"44"),Q("mo",null,"="),Q("mn",null,"710"),Q("mtext",null," AUC")])],-1))])]),Q("li",null,[Q("mjx-container",j,[(e(),s("svg",P,[...t[66]||(t[66]=[a("",1)])])),t[67]||(t[67]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"753"),Q("mtext",null," BCE"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"754"),Q("mo",null,"−"),Q("mn",null,"753"),Q("mo",null,"="),Q("mn",null,"1"),Q("mtext",null," AUC")])],-1))])])])]),Q("li",null,[Q("p",null,[Q("strong",null,[t[70]||(t[70]=T("Astronomical Years (",-1)),Q("mjx-container",B,[(e(),s("svg",R,[...t[68]||(t[68]=[a("",1)])])),t[69]||(t[69]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mi",null,"Y"),Q("mo",null,"≤"),Q("mn",null,"0")])],-1))]),t[71]||(t[71]=T(")",-1))]),t[76]||(t[76]=T(": Continuous astronomical year numbering (",-1)),Q("mjx-container",N,[(e(),s("svg",J,[...t[72]||(t[72]=[a("",1)])])),t[73]||(t[73]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mn",null,"0"),Q("mo",null,"="),Q("mn",null,"1"),Q("mtext",null," BCE")])],-1))]),t[77]||(t[77]=T(", ",-1)),Q("mjx-container",q,[(e(),s("svg",K,[...t[74]||(t[74]=[a("",1)])])),t[75]||(t[75]=Q("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[Q("mo",null,"−"),Q("mn",null,"43"),Q("mo",null,"="),Q("mn",null,"44"),Q("mtext",null," BCE")])],-1))]),t[78]||(t[78]=T(") follows a single continuous linear relation:",-1))]),Q("mjx-container",O,[(e(),s("svg",z,[...t[79]||(t[79]=[a("",1)])])),t[80]||(t[80]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",null,"AUC"),Q("mo",null,"="),Q("mi",null,"Y"),Q("mo",null,"+"),Q("mn",null,"753")])],-1))])])]),t[85]||(t[85]=Q("hr",null,null,-1)),t[86]||(t[86]=Q("h2",{id:"consular-chronology-fasti-consulares",tabindex:"-1"},[T("Consular Chronology ("),Q("em",null,"Fasti Consulares"),T(") "),Q("a",{class:"header-anchor",href:"#consular-chronology-fasti-consulares","aria-label":'Permalink to "Consular Chronology (*Fasti Consulares*)"'},"​")],-1)),t[87]||(t[87]=Q("p",null,[T("In everyday Roman civic and legal life, years were designated by naming the two ordinary consuls ("),Q("em",null,"consules ordinarii"),T(") who entered office on the Kalends of January:")],-1)),Q("mjx-container",G,[(e(),s("svg",U,[...t[81]||(t[81]=[a("",1)])])),t[82]||(t[82]=Q("mjx-assistive-mml",{unselectable:"on",display:"block",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",overflow:"hidden",width:"100%"}},[Q("math",{xmlns:"http://www.w3.org/1998/Math/MathML",display:"block"},[Q("mtext",{"data-mjx-variant":"-tex-mathit",mathvariant:"italic"},"Cicerone et Antonio consulibus"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mo",{stretchy:"false"},"⟹"),Q("mstyle",{scriptlevel:"0"},[Q("mspace",{width:"0.278em"})]),Q("mn",null,"63"),Q("mtext",null," BCE"),Q("mtext",null," (astronomical "),Q("mo",null,"−"),Q("mn",null,"62"),Q("mo",{stretchy:"false"},")")])],-1))]),t[88]||(t[88]=a("",6))])}const e1=l(n,[["render",Y]]);export{a1 as __pageData,e1 as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.js new file mode 100644 index 00000000..37ed0673 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.js @@ -0,0 +1 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as t,o as l,c as o,a2 as s,E as r}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-roman","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.index.md","filePath":"doc/9-plugins/roman.index.md"}'),p={name:"doc/9-plugins/roman.index.md"};function h(d,a,c,m,k,g){const i=t("PluginRepl");return l(),o("div",null,[a[0]||(a[0]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-roman ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A lightweight, zero-dependency Community plugin for the Tempo ecosystem that provides classical Roman calendar arithmetic (Kalends, Nones, Ides, Ante Diem), leap year bissextile handling, and AUC (Ab Urbe Condita) year conversions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Classical Anchors: Resolves any date to its Roman Kalends, Nones, or Ides anchor, including Pridie and inclusive ante diem counts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Latin Phrasing: Emits full (ante diem XVII Kalendas Novembres) and abbreviated (a.d. XVII Kal. Nov.) forms with correct Ablative/Accusative declensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bissextile Day: Reproduces the classical leap-year doubling of the sixth day before the March Kalends (a.d. bis VI Kal. Mart.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • AUC Year Reckoning: Bidirectional Ab Urbe Condita conversion for CE, BCE, and astronomical years.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Classical Latin Parser: Robust parser recognizing arbitrary Latin expressions (e.g. a.d. IV Id. Mart. 710 AUC, Idibus Martiis Cicerone coss.) with calendar validation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fasti Consulares (509 BCE–541 CE): Historical catalog of Roman Consuls with Latin ablative absolute (coss.) formatting and searching (full catalog via ./consuls, with landmark years in core).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lossless Round-Trips: Tempo.roman.fromClassical() maps any classical date back to its exact calendar day.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Results: Every structured result is frozen; zero runtime dependencies beyond Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation & Import Paths ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-roman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Choose Your Import Path ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Import PathMinified SizeWhat's Included
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-roman/install'~15 KBFull Roman calendar arithmetic, Latin phrasing/parsing, AUC conversions, and ~20 landmark consul years (Cicero, Caesar, Brutus, Basilius). Auto-installs plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-roman/consuls'~70 KBBatteries-included: full Roman calendar plugin + complete 1,050-year Fasti consulares catalog (509 BCE–541 CE). Auto-installs plugin in one import.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { RomanPlugin } from '@magmacomputing/tempo-plugin-roman'~15 KBCore plugin definition for explicit installation via Tempo.use(RomanPlugin).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',14)),r(i,{plugin:"roman"}),a[1]||(a[1]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Option A: Lean Core Plugin (Zero-Boilerplate) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-roman/install';\nimport { Tempo } from '@magmacomputing/tempo';\n\n// 1. Compute classical Roman date and Latin phrasing\nconst today = new Tempo('2026-10-16');\nconst classical = today.toRomanClassical();\n\nconsole.log(`Roman Date: ${classical.latin}`);      // "ante diem XVII Kalendas Novembres"\nconsole.log(`Abbreviated: ${classical.shortLatin}`);// "a.d. XVII Kal. Nov."\nconsole.log(`Anchor: ${classical.anchor}`);         // "Kalends"\nconsole.log(`Year AUC: ${today.auc} AUC`);          // 2779 AUC\n\n// 2. Ides of March (44 BCE = astronomical year -43)\nconst idesOfMarch = new Tempo('-000043-03-15');\nconsole.log(idesOfMarch.toRomanClassical().latin);  // "Idibus Martiis"\nconsole.log(idesOfMarch.toAUC());                   // 710 (AUC)\nconsole.log(idesOfMarch.consuls);                  // "C. Julio Caesare V, M. Antonio coss."\n\n// 3. Leap year bissextile day (February 24 in a leap year)\nconst leapDay = new Tempo('2024-02-24');\nconsole.log(leapDay.toRomanClassical().latin);      // "ante diem bis sextum Kalendas Martias"\nconsole.log(leapDay.toRomanClassical().shortLatin); // "a.d. bis VI Kal. Mart."\n\n// 4. Classical Latin Date Parsing\nconst parsed = Tempo.roman.parse('a.d. IV Id. Mart. 710 AUC');\nconsole.log(parsed.format('{yyyy}-{mm}-{dd}'));     // "-000043-03-12" (March 12, 44 BCE)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Option B: Full Consular Fasti (Single Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To access the complete historical Fasti consulares spanning all 1,050 years from 509 BCE through 541 CE:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-roman/consuls';\nimport { Tempo } from '@magmacomputing/tempo';\n\n// Auto-installs RomanPlugin AND populates all 1,050 consular years\nconst trajanYear = new Tempo('0100-01-01');\nconsole.log(trajanYear.consuls);\n// "Imp. Caesare Nerva Trajano Augusto III, Sex. Julio Frontino III coss."\n\nconsole.log(trajanYear.format('{roman:consul}'));\n// "Imp. Caesare Nerva Trajano Augusto III, Sex. Julio Frontino III coss."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Option C: Explicit Plugin Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';\nimport { RomanPlugin } from '@magmacomputing/tempo-plugin-roman';\n\nTempo.use(RomanPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    API Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.toRomanClassical(options?: RomanCalculationOptions): ClassicalRomanDate ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance method calculating the complete classical Roman calendar descriptor for the instance date. Returns an immutable, frozen ClassicalRomanDate object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.toAUC(): number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance method returning the year reckoned Ab Urbe Condita (AUC).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.auc: number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Getter returning the year in AUC.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.toClassical(date, options?): ClassicalRomanDate ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static calculation function resolving Tempo, native JavaScript Date, or plain { year, month, day } objects into a frozen ClassicalRomanDate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.fromClassical(anchor, anchorMonth, anchorYear, relation, count?, isBissextile?, isJulian?): { year, month, day } ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolves classical Roman calendar anchor parameters back to modern calendar coordinates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.parse(input: string, options?: RomanParseOptions): Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parses a natural classical Latin date string (e.g. 'a.d. IV Id. Mart. 710 AUC' or 'Idibus Martiis Cicerone coss.') directly into a Tempo instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.parseDate(input: string, options?: RomanParseOptions): ParsedRomanDate ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parses a Latin date string into calendar coordinates ({ year, month, day, auc, classical }) without constructing an instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.getConsuls(year: number): readonly string[] | undefined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Retrieves the eponymous Roman consuls for an astronomical year from the Fasti consulares (509 BCE–541 CE).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.formatConsuls(year: number, style?: 'ablative' | 'nominative'): string | undefined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Renders the eponymous consuls into a classical Latin dating formula (e.g. "M. Tullio Cicerone, C. Antonio Hybrida coss.").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.findConsuls(query: string): ConsularPair[] ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Performs a substring search against the Fasti consulares and returns matching years and names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.yearToAuc(year: number, era?: 'CE' | 'BCE'): number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an astronomical year (or positive BCE year with explicit era) into AUC.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.aucToYear(auc: number, format?: 'astronomical' | 'historical') ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converts an AUC year into an astronomical integer or { year, era: 'CE' | 'BCE' }.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.getNonesDay(month: number): number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns 7 for MOM-J months (March, October, May, July) and 5 for all other months.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.getIdesDay(month: number): number ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns 15 for MOM-J months (March, October, May, July) and 13 for all other months.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.roman.isLeapYear(year: number, isJulian?: boolean): boolean ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Evaluates leap year status under Gregorian or Julian calendar rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Topic Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    License ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',45))])}const b=e(p,[["render",h]]);export{E as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.lean.js new file mode 100644 index 00000000..f52aeeb4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.index.md.D6RGBtx3.lean.js @@ -0,0 +1 @@ +import{_ as n}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as t,o as l,c as o,a2 as s,E as r}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-roman","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.index.md","filePath":"doc/9-plugins/roman.index.md"}'),p={name:"doc/9-plugins/roman.index.md"};function h(d,a,c,m,k,g){const i=t("PluginRepl");return l(),o("div",null,[a[0]||(a[0]=s("",14)),r(i,{plugin:"roman"}),a[1]||(a[1]=s("",45))])}const b=e(p,[["render",h]]);export{E as __pageData,b as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.js new file mode 100644 index 00000000..40b0d37f --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.js @@ -0,0 +1,135 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Use Cases & Production Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.use-cases-and-patterns.md","filePath":"doc/9-plugins/roman.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/roman.use-cases-and-patterns.md"};function t(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[l(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-roman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Cases & Production Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-roman provides deterministic, high-performance classical calendar calculations for applications in classical archaeology, numismatics, epigraphy, academic digital humanities, and legal manuscript processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Digital Epigraphy & Classical Inscription Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Challenge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Museum catalogs, archaeological excavation databases, and epigraphic registries (such as the Corpus Inscriptionum Latinarum) frequently record dates in Latin abbreviations (e.g. a.d. IV Id. Mart. or a.d. XVII Kal. Nov.). Systems need to compute the exact modern Gregorian/Julian calendar coordinate for temporal indexing and GIS timelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { RomanPlugin } from '@magmacomputing/tempo-plugin-roman';
+
+Tempo.use(RomanPlugin);
+
+interface InscriptionRecord {
+  id: string;
+  catalogNumber: string;
+  latinDate: string;
+  anchor: 'Kalends' | 'Nones' | 'Ides';
+  anchorMonth: number;
+  relation: 'on' | 'pridie' | 'ante_diem';
+  count: number;
+  yearAuc: number;
+}
+
+function resolveInscriptionDate(record: InscriptionRecord): Tempo {
+  // 1. Convert AUC year to astronomical calendar year
+  const astronomicalYear = Tempo.roman.aucToYear(record.yearAuc);
+
+  // 2. Resolve classical Roman anchor to calendar date
+  const resolved = Tempo.roman.fromClassical(
+    record.anchor,
+    record.anchorMonth,
+    astronomicalYear,
+    record.relation,
+    record.count,
+    false, // isBissextile
+    true   // isJulian
+  );
+
+  return new Tempo({
+    year: resolved.year,
+    month: resolved.month,
+    day: resolved.day
+  });
+}
+
+// Example: Inscription recording "a.d. XVII Kal. Nov. 2779 AUC"
+const tempoDate = resolveInscriptionDate({
+  id: 'c-104',
+  catalogNumber: 'CIL VI 2065',
+  latinDate: 'a.d. XVII Kal. Nov.',
+  anchor: 'Kalends',
+  anchorMonth: 11,
+  relation: 'ante_diem',
+  count: 17,
+  yearAuc: 2779
+});
+
+console.log(tempoDate.format('{yyyy}-{mm}-{dd}')); // "2026-10-16"
+
+// Or resolve the inscription text directly using the Phase 3 Classical Parser:
+const parsedFromText = Tempo.roman.parse('a.d. XVII Kal. Nov. 2779 AUC');
+console.log(parsedFromText.format('{yyyy}-{mm}-{dd}')); // "2026-10-16"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Numismatics & Ancient Coin Provenance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Challenge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Numismatic databases record Roman imperial coinage dated by AUC foundation years or major commemorative Roman dates. Coin metadata must be indexed synchronously alongside both modern CE/BCE dates and historical AUC timestamps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-roman/install';
+
+interface RomanCoin {
+  mintId: string;
+  emperor: string;
+  issueDate: Tempo;
+}
+
+const coinCollection: RomanCoin[] = [
+  {
+    mintId: 'RIC-I-42',
+    emperor: 'Augustus',
+    issueDate: new Tempo('-000026-01-16') // January 16, 27 BCE (Title of Augustus conferred)
+  },
+  {
+    mintId: 'RRC-415-1',
+    emperor: 'Julius Caesar',
+    issueDate: new Tempo('-000043-03-15') // March 15, 44 BCE (Ides of March)
+  }
+];
+
+// Enrich numismatic metadata with classical Roman and AUC representations
+const enrichedCatalog = coinCollection.map(coin => {
+  const roman = coin.issueDate.toRomanClassical();
+  return {
+    mintId: coin.mintId,
+    emperor: coin.emperor,
+    gregorian: coin.issueDate.format('{yyyy}-{mm}-{dd}'),
+    latinDate: roman.latin,
+    shortDate: roman.shortLatin,
+    yearAuc: \`\${coin.issueDate.toAUC()} AUC\`
+  };
+});
+
+console.table(enrichedCatalog);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Academic Manuscript Dating & Legal Charters ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Challenge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Medieval papal bulls, monastic annals, and European royal charters frequently dated official decrees using the Roman ecclesiastical calendar. Archival tools need to verify whether transcribed dates match internal document text and compute verified civil calendar dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-roman/install';
+
+function verifyCharterDating(year: number, month: number, day: number) {
+  const tempo = new Tempo({ year, month, day });
+  const classical = tempo.toRomanClassical();
+
+  return {
+    isoDate: tempo.format('{yyyy}-{mm}-{dd}'),
+    formalLatin: classical.latin,
+    abbreviated: classical.shortLatin,
+    aucYear: classical.auc,
+    isLeapIntercalation: classical.isBissextile
+  };
+}
+
+// Verify a decree signed on February 24 in a leap year
+const leapCharter = verifyCharterDating(2024, 2, 24);
+console.log(leapCharter.formalLatin);
+// "ante diem bis sextum Kalendas Martias"
+
+// Verify an autumn charter signed on October 14
+const idesEveCharter = verifyCharterDating(2026, 10, 14);
+console.log(idesEveCharter.formalLatin);
+// "Pridie Idus Octobres"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Consular Dating & Fasti Chronology ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Challenge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical sources and decrees from the Roman Republic and early Empire were rarely dated by year numbers; they were dated by the eponymous Roman consuls holding office. Historians need to match consular dating formulas (e.g., "C. Julio Caesare V, M. Antonio coss.") with exact astronomical and civil calendar coordinates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+// Full 1,050-year Fasti consulares (also auto-installs RomanPlugin):
+import '@magmacomputing/tempo-plugin-roman/consuls';
+// (For lean core without full Fasti, use: import '@magmacomputing/tempo-plugin-roman/install')
+
+// 1. Resolve an astronomical date and format its presiding consuls
+const ides44BCE = new Tempo('-000043-03-15');
+console.log(ides44BCE.consuls);
+// "C. Julio Caesare V, M. Antonio coss."
+
+// 2. Format with standard Tempo tokens
+console.log(ides44BCE.format('{roman:classical}, {roman:consul}'));
+// "Idibus Martiis, C. Julio Caesare V, M. Antonio coss."
+
+// 3. Search the Fasti consulares (509 BCE–541 CE) by consul name
+const ciceroEntries = Tempo.roman.findConsuls('Cicero');
+console.log(ciceroEntries[0]);
+// { year: -62, consuls: ['M. Tullius Cicero', 'C. Antonius Hybrida'], formatted: 'M. Tullio Cicerone, C. Antonio Hybrida coss.' }
+
+// 4. Parse classical text with a consular dating formula directly
+const dateFromConsuls = Tempo.roman.parse('Idibus Martiis Cicerone coss.');
+console.log(dateFromConsuls.format('{yyyy}-{mm}-{dd}')); // "-000062-03-15" (March 15, 63 BCE)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,31)])])}const g=i(h,[["render",t]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.lean.js new file mode 100644 index 00000000..213b469d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_roman.use-cases-and-patterns.md.BRabEtkW.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as l}from"./chunks/framework.DNL3hc5c.js";const o=JSON.parse('{"title":"Use Cases & Production Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/roman.use-cases-and-patterns.md","filePath":"doc/9-plugins/roman.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/roman.use-cases-and-patterns.md"};function t(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[l("",31)])])}const g=i(h,[["render",t]]);export{o as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.js b/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.js new file mode 100644 index 00000000..2c56f58e --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.js @@ -0,0 +1,23 @@ +import{_ as a}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-snap","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/snap.index.md","filePath":"doc/9-plugins/snap.index.md"}'),d={name:"doc/9-plugins/snap.index.md"};function o(r,s,k,c,g,m){const t=n("PluginRepl");return l(),p("div",null,[s[0]||(s[0]=i('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-snap ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Community plugin for the Tempo library that provides robust time rounding and interval snapping functionality across standard time components (hours, minutes, seconds, milliseconds, microseconds, and nanoseconds).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, the plugin effortlessly snaps dates to a configurable minute-interval. This is invaluable when building UI components like time-pickers and calendar grids, downsampling telemetry streams, or aligning timestamps to multimedia frame boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Installation & Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-snap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',8)),h(t,{plugin:"snap"}),s[1]||(s[1]=i(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SnapPlugin } from '@magmacomputing/tempo-plugin-snap';
+
+Tempo.use(SnapPlugin);
+
+const t = new Tempo('2026-06-01T14:08:00Z');
+
+// Snaps to the nearest 15 minutes by default
+const snapped = t.snap();
+console.log(snapped.format('{hh}:{mi}')); // "14:15"
+
+// Or explicitly provide units and intervals
+const snapHour   = t.snap({ hh: 1 });
+const snapSecond = t.snap({ ss: 30 });
+const snapMs     = t.snap({ ms: 100 });
+
+// Directional snapping (floor vs ceiling)
+const snapUp   = t.snap({ mi: 15, direction: 'up' });   // 14:15
+const snapDown = t.snap({ mi: 15, direction: 'down' }); // 14:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Boilerplate Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-snap/install';
+
+const t = new Tempo('2026-06-01T14:08:00Z');
+console.log(t.snap().format('{hh}:{mi}')); // "14:15"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 API Surface Catalog ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Snap plugin extends Tempo.prototype with a fluent, immutable snap() method:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MethodTargetOptions ArgumentReturnsDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.snap(options?)InstanceSnapOptions?: OneKey<SnapKey, number> & { direction?: 'up' | 'down' }TempoReturns a new Tempo instance rounded to the nearest interval of the specified time unit. Sub-units are cleared to zero.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Units (SnapKey) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The options object accepts exactly one time component mapped to a numeric step:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unit KeyLong AliasesDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'hh''hour', 'hours'Snaps to hour interval (e.g. nearest 1, 2, or 4 hours)t.snap({ hh: 1 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'mi''minute', 'minutes'Snaps to minute interval (default: 15)t.snap({ mi: 15 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ss''second', 'seconds'Snaps to second interval (e.g. 10s, 30s)t.snap({ ss: 30 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ms''millisecond', 'milliseconds'Snaps to millisecond intervalt.snap({ ms: 50 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'us''microsecond', 'microseconds'Snaps to microsecond intervalt.snap({ us: 500 })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ns''nanosecond', 'nanoseconds'Snaps to nanosecond intervalt.snap({ ns: 1000 })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time Components Only: Date units (days, months, years) are strictly disallowed in snap(). For calendar date manipulation, use Tempo core's native .startOf('month'), .startOf('week'), or .add({ days: 1 }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Architecture & Specialized Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,17))])}const F=e(d,[["render",o]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.lean.js new file mode 100644 index 00000000..7212a839 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_snap.index.md.CCS6zQLh.lean.js @@ -0,0 +1 @@ +import{_ as a}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as i,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-snap","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/snap.index.md","filePath":"doc/9-plugins/snap.index.md"}'),d={name:"doc/9-plugins/snap.index.md"};function o(r,s,k,c,g,m){const t=n("PluginRepl");return l(),p("div",null,[s[0]||(s[0]=i("",8)),h(t,{plugin:"snap"}),s[1]||(s[1]=i("",17))])}const F=e(d,[["render",o]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.js b/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.js new file mode 100644 index 00000000..48408571 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.js @@ -0,0 +1,110 @@ +import{_ as l,o as t,c as h,a2 as a,j as i,a as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/snap.use-cases-and-patterns.md","filePath":"doc/9-plugins/snap.use-cases-and-patterns.md"}'),p={name:"doc/9-plugins/snap.use-cases-and-patterns.md"},e={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function r(d,s,E,g,o,y){return t(),h("div",null,[s[6]||(s[6]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-snap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide demonstrates how @magmacomputing/tempo-plugin-snap provides deterministic time boundary alignment across calendar user interfaces, high-frequency telemetry downsampling, and multimedia synchronization pipelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Interactive Calendar Drag-and-Drop Grid Snapping ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In scheduling platforms (e.g. Google Calendar, Calendly, Acuity), user mouse drag events and touch gestures emit unrounded timestamp coordinates (e.g. 14:08:22). Appointment booking systems require appointments to snap to clean 15-minute or 30-minute block boundaries without creating awkward overlapping gaps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use t.snap({ mi: 15, direction: 'down' }) to establish the slot start boundary and calculate slot duration intervals. The deterministic floor/ceil behavior guarantees grid alignment regardless of mouse position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pointer Coordinate: 14:08:22
+         │
+         ├─── direction: 'down' ───► Slot Start: 14:00:00
+         │
+         └─── + 30m Duration    ───► Slot End:   14:30:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Implementation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SnapPlugin } from '@magmacomputing/tempo-plugin-snap';
+
+Tempo.use(SnapPlugin);
+
+export interface AppointmentSlot {
+  start: Tempo;
+  end: Tempo;
+  label: string;
+}
+
+/**
+ * Resolves raw mouse-drop timestamp into an aligned calendar slot.
+ */
+export function resolveCalendarSlot(rawDropTime: Tempo, durationMinutes = 30): AppointmentSlot {
+  // 1. Floor to current 15-minute grid slot
+  const start = rawDropTime.snap({ mi: 15, direction: 'down' });
+
+  // 2. Add requested meeting duration
+  const end = start.add({ minutes: durationMinutes });
+
+  return {
+    start,
+    end,
+    label: \`\${start.format('{hh}:{mi}')} - \${end.format('{hh}:{mi}')}\`
+  };
+}
+
+// User clicks/drags at 14:08:22
+const rawClick = new Tempo('2026-06-01T14:08:22Z');
+const slot = resolveCalendarSlot(rawClick, 30);
+
+console.log(slot.start.format('{hh}:{mi}')); // "14:00"
+console.log(slot.end.format('{hh}:{mi}'));   // "14:30"
+console.log(slot.label);                     // "14:00 - 14:30"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. High-Frequency Metric Telemetry Downsampling (InfluxDB / Prometheus) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distributed microservices, IoT sensors, and load balancers emit millions of high-frequency events with microsecond jitter (e.g. 14:08:22.450123Z). Storing or graphing raw individual points overwhelms dashboard databases. Aggregating metrics into fixed time-series buckets (e.g. 10-second or 1-minute tumbling windows) requires normalizing event timestamps before insertion into time-series tables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18)),i("p",null,[s[2]||(s[2]=n("Downsample raw event timestamps to fixed second or minute boundaries using ",-1)),s[3]||(s[3]=i("code",null,"t.snap({ ss: 10, direction: 'down' })",-1)),s[4]||(s[4]=n(". This assigns every sample within the interval to the identical bucket key in constant ",-1)),i("mjx-container",e,[(t(),h("svg",k,[...s[0]||(s[0]=[a('',1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[5]||(s[5]=n(" time without database grouping overhead.",-1))]),s[7]||(s[7]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SnapPlugin } from '@magmacomputing/tempo-plugin-snap';
+
+Tempo.use(SnapPlugin);
+
+interface TelemetryPoint {
+  sensorId: string;
+  temperature: number;
+  timestamp: string; // ISO string
+}
+
+export class MetricBucketAggregator {
+  private buckets = new Map<string, number[]>();
+
+  /**
+   * Ingests a raw sample and groups it into a 10-second tumbling bucket.
+   */
+  ingest(point: TelemetryPoint) {
+    const rawTime = new Tempo(point.timestamp);
+
+    // Floor to nearest 10-second bucket
+    const bucketKey = rawTime.snap({ ss: 10, direction: 'down' }).format('{yyyy}-{mm}-{dd}T{hh}:{mi}:{ss}Z');
+
+    const list = this.buckets.get(bucketKey) ?? [];
+    list.push(point.temperature);
+    this.buckets.set(bucketKey, list);
+  }
+
+  getAverages(): Record<string, number> {
+    const result: Record<string, number> = {};
+    for (const [bucket, values] of this.buckets.entries()) {
+      const avg = values.reduce((sum, v) => sum + v, 0) / values.length;
+      result[bucket] = Number(avg.toFixed(2));
+    }
+    return result;
+  }
+}
+
+// Execution with jittery timestamps
+const aggregator = new MetricBucketAggregator();
+
+aggregator.ingest({ sensorId: 'temp-1', temperature: 21.4, timestamp: '2026-06-01T14:08:22.450Z' });
+aggregator.ingest({ sensorId: 'temp-1', temperature: 21.8, timestamp: '2026-06-01T14:08:27.890Z' });
+aggregator.ingest({ sensorId: 'temp-1', temperature: 22.1, timestamp: '2026-06-01T14:08:31.100Z' });
+
+console.log(aggregator.getAverages());
+// Output:
+// {
+//   "2026-06-01T14:08:20Z": 21.60,  // (21.4 + 21.8) / 2
+//   "2026-06-01T14:08:30Z": 22.10
+// }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Multimedia Frame Boundary Alignment (60fps / 25fps) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In video editing pipelines, subtitle synchronization engines, and WebAudio processors, cues and animation keys must align with physical display refresh boundaries. At 60 frames per second, each frame lasts approximately 16.67ms (approx 17ms), while PAL video runs at 40ms per frame (25fps). Subtitles or cue points that fall between frame transitions cause screen tearing or missed render intervals.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use sub-second millisecond snapping (t.snap({ ms: 17 }) or t.snap({ ms: 40 })) to snap arbitrary event times to the nearest physical render frame boundary.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SnapPlugin } from '@magmacomputing/tempo-plugin-snap';
+
+Tempo.use(SnapPlugin);
+
+/**
+ * Aligns video subtitle cue timestamps to 60fps frame boundaries (~17ms per frame).
+ */
+export function alignToVideoFrame(rawTimestampMs: number, fps: 60 | 25 = 60): Tempo {
+  const stepMs = fps === 60 ? 17 : 40;
+  const t = new Tempo(rawTimestampMs);
+
+  // Snap to nearest frame boundary
+  return t.snap({ ms: stepMs });
+}
+
+// Subtitle cue recorded with system clock jitter at 42ms
+const rawCue = 42;
+const aligned = alignToVideoFrame(rawCue, 60);
+
+console.log('Original ms:', rawCue);      // 42
+console.log('Aligned frame ms:', aligned.ms); // 34 (17 * 2 = 34ms frame boundary)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,8))])}const m=l(p,[["render",r]]);export{c as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.lean.js new file mode 100644 index 00000000..8841f079 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_snap.use-cases-and-patterns.md.B9Ns7Nr6.lean.js @@ -0,0 +1 @@ +import{_ as l,o as t,c as h,a2 as a,j as i,a as n}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/snap.use-cases-and-patterns.md","filePath":"doc/9-plugins/snap.use-cases-and-patterns.md"}'),p={name:"doc/9-plugins/snap.use-cases-and-patterns.md"},e={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function r(d,s,E,g,o,y){return t(),h("div",null,[s[6]||(s[6]=a("",18)),i("p",null,[s[2]||(s[2]=n("Downsample raw event timestamps to fixed second or minute boundaries using ",-1)),s[3]||(s[3]=i("code",null,"t.snap({ ss: 10, direction: 'down' })",-1)),s[4]||(s[4]=n(". This assigns every sample within the interval to the identical bucket key in constant ",-1)),i("mjx-container",e,[(t(),h("svg",k,[...s[0]||(s[0]=[a("",1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[5]||(s[5]=n(" time without database grouping overhead.",-1))]),s[7]||(s[7]=a("",8))])}const m=l(p,[["render",r]]);export{c as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.js new file mode 100644 index 00000000..b968bd6d --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.js @@ -0,0 +1,56 @@ +import{_ as i,o as a,c as n,a2 as h}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Spatial Geofencing & Bounding Boxes","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.geofencing.md","filePath":"doc/9-plugins/spatial.geofencing.md"}'),t={name:"doc/9-plugins/spatial.geofencing.md"};function l(p,s,k,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[h(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-spatial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Spatial Geofencing & Bounding Boxes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide details spatial boundary containment, circular radius proximity checks, and rectangular bounding box geofencing in @magmacomputing/tempo-plugin-spatial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Circular Proximity (Tempo.spatial.isWithin / isWithin / t.isWithin) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines whether the Great-Circle distance between two coordinates is within a given radius threshold:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    haversineDistance(from, to) <= maxDistance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Code Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin, isWithin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const userPos = { lat: 37.7749, lng: -122.4194 }; // San Francisco
+const storePos = { lat: 37.7833, lng: -122.4167 }; // SF Downtown Store (~1 km away)
+const sanJosePos = { lat: 37.3382, lng: -121.8863 }; // San Jose (~67 km away)
+
+// Check if user is within 5 km of SF store
+const isNearby = Tempo.spatial.isWithin(userPos, storePos, 5, 'km');
+console.log(isNearby); // true
+
+// Check if user is within 10 miles of San Jose
+const isSanJoseNearby = Tempo.spatial.isWithin(userPos, sanJosePos, 10, 'miles');
+console.log(isSanJoseNearby); // false
+
+// Fluent instance method
+const tUser = new Tempo({ geo: userPos });
+console.log(tUser.isWithin(storePos, 5, 'km')); // true
+
+// Pure function usage
+const isClose = isWithin(userPos, storePos, 2000, 'm'); // within 2000 meters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Rectangular Bounding Box (Tempo.spatial.inBoundingBox / inBoundingBox / t.inBoundingBox) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks whether a coordinate point falls inside a geographic bounding box defined by latitude and longitude bounds:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BoundingBox {
+  minLat: number; // Southern latitude boundary (-90..90)
+  maxLat: number; // Northern latitude boundary (-90..90)
+  minLng: number; // Western longitude boundary (-180..180)
+  maxLng: number; // Eastern longitude boundary (-180..180)
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard Geographic Bounding Box ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const californiaBBox = {
+  minLat: 32.5,
+  maxLat: 42.0,
+  minLng: -124.5,
+  maxLng: -114.1,
+};
+
+const sf = { lat: 37.7749, lng: -122.4194 };
+const ny = { lat: 40.7128, lng: -74.0060 };
+
+console.log(Tempo.spatial.inBoundingBox(sf, californiaBBox)); // true
+console.log(Tempo.spatial.inBoundingBox(ny, californiaBBox)); // false
+
+// Fluent instance method
+const tSF = new Tempo({ geo: sf });
+console.log(tSF.inBoundingBox(californiaBBox)); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Antimeridian Crossing Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bounding boxes that cross the 180° Antimeridian (e.g. spanning from eastern Russia across the Pacific to Alaska, where minLng > maxLng) are automatically handled correctly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const pacificBBox = {
+  minLat: -20,
+  maxLat: 20,
+  minLng: 170, // 170° East
+  maxLng: -170, // 170° West (crosses 180° meridian)
+};
+
+const fiji = { lat: -17.7134, lng: 178.0650 }; // In bounding box
+console.log(Tempo.spatial.inBoundingBox(fiji, pacificBBox)); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,19)])])}const o=i(t,[["render",l]]);export{E as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.lean.js new file mode 100644 index 00000000..64a5e91c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.geofencing.md.COTSxksf.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as h}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"Spatial Geofencing & Bounding Boxes","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.geofencing.md","filePath":"doc/9-plugins/spatial.geofencing.md"}'),t={name:"doc/9-plugins/spatial.geofencing.md"};function l(p,s,k,e,r,d){return a(),n("div",null,[...s[0]||(s[0]=[h("",19)])])}const o=i(t,[["render",l]]);export{E as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.js new file mode 100644 index 00000000..d1aa80d7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.js @@ -0,0 +1,32 @@ +import{_ as t}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as s,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-spatial","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.index.md","filePath":"doc/9-plugins/spatial.index.md"}'),o={name:"doc/9-plugins/spatial.index.md"};function r(k,i,d,g,c,m){const a=n("PluginRepl");return l(),p("div",null,[i[0]||(i[0]=s('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-spatial ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A comprehensive Community plugin for the Tempo ecosystem providing GIS spatial geometry, Great-Circle navigation, transit velocity and impossible travel anomaly detection, spatial geofencing, and natural solar time offset calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By decoupling geographic mathematics from network lookup into a dedicated plugin, @magmacomputing/tempo core remains zero-network, lightweight, and purely deterministic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-spatial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture & Namespacing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installing SpatialPlugin mounts an immutable, locked-down Tempo.spatial static namespace onto the Tempo class and adds fluent instance helpers to Tempo.prototype:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-spatial/install';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore detailed guides on specific capabilities:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Transit & Navigation: Great-Circle distance, compass bearing, geographic midpoint, transit velocity, and impossible travel anomaly detection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Spatial Geofencing: Proximity checking (isWithin), rectangular bounding boxes (inBoundingBox), and antimeridian crossing resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Natural Solar Time Offset: Longitude delta calculations (solarOffset), meridian drift, and circadian rhythm alignment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Use Cases & Architectural Patterns: Zero-trust impossible travel detection, depot geofencing, flight sector planning, and physical solar noon alignment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive Tempo.spatial API Surface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Method / PropertyCategoryDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.distance(from, to, unit?)NavigationGreat-Circle Haversine distance between two coordinates ('km', 'miles', or 'm').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.bearing(from, to, opts?)NavigationInitial forward compass azimuth bearing (0°..360°) from origin to destination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.midpoint(from, to)NavigationExact geographic midpoint along the Great-Circle path between two coordinates with hemisphere inference.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.velocity(from, to, opts?)Security / TransitSpeed of travel between two timestamped instances ('km', 'miles', or 'm'; time unit 'hh', 'ss', 'mi').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.isImpossibleTravel(from, to, opts?)Security / TransitEvaluates whether travel between timestamped instances exceeds physical commercial aviation feasibility (default: > 900 km/h).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.isWithin(from, to, maxDist, unit?)GeofencingChecks whether two points fall within a maximum radial distance threshold.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.inBoundingBox(coords, bbox)GeofencingChecks whether a coordinate point falls inside a geographic bounding box with antimeridian crossing support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.solarOffset(coords, opts?)Solar TimingComputes natural solar time offset (in minutes, seconds, or hours) derived from meridian offset (4 min/deg).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fluent Instance Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance MethodDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.spatialDistance(to, unit?)Calculates Great-Circle distance from this instance's coordinates to target coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.spatialBearing(to, opts?)Computes initial forward compass bearing from this instance to target coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.spatialVelocity(to, opts?)Calculates travel velocity between this instance and target timestamped instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.spatialSolarOffset(opts?)Computes natural solar time offset for this instance's coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.isWithin(to, maxDist, unit?)Checks if this instance is within a specified proximity radius of target coordinates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.inBoundingBox(bbox)Checks if this instance falls inside a rectangular bounding box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,25)),h(a,{plugin:"spatial"}),i[1]||(i[1]=s(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Great-Circle Distance & Bearing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const sydney = { lat: -33.8688, lng: 151.2093 };
+const london = { lat: 51.5074, lng: -0.1278 };
+
+const distKm = Tempo.spatial.distance(sydney, london, 'km');
+console.log('Distance:', distKm.toFixed(1), 'km'); // ~16988.0 km
+
+const heading = Tempo.spatial.bearing(sydney, london);
+console.log('Compass Bearing:', heading.toFixed(1) + '°'); // ~302.2° (WNW)
+
+const mid = Tempo.spatial.midpoint(sydney, london);
+console.log('Midpoint:', mid.latitude, mid.longitude);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Impossible Travel Anomaly Detection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const login1 = new Tempo('2026-06-21T10:00:00Z', {
+  geo: { lat: 51.5074, lng: -0.1278 }, // London
+});
+
+const login2 = new Tempo('2026-06-21T11:00:00Z', {
+  geo: { lat: 40.7128, lng: -74.0060 }, // New York (1 hour later)
+});
+
+const speed = Tempo.spatial.velocity(login1, login2);
+console.log('Velocity:', speed.toFixed(1), 'km/h'); // ~5570.2 km/h
+
+const alert = Tempo.spatial.isImpossibleTravel(login1, login2);
+console.log('Impossible Travel Alert?', alert); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    License ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,7))])}const F=e(o,[["render",r]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.lean.js new file mode 100644 index 00000000..eb6e2f91 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.index.md.DgkWwXEr.lean.js @@ -0,0 +1 @@ +import{_ as t}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as e,C as n,o as l,c as p,a2 as s,E as h}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"@magmacomputing/tempo-plugin-spatial","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.index.md","filePath":"doc/9-plugins/spatial.index.md"}'),o={name:"doc/9-plugins/spatial.index.md"};function r(k,i,d,g,c,m){const a=n("PluginRepl");return l(),p("div",null,[i[0]||(i[0]=s("",25)),h(a,{plugin:"spatial"}),i[1]||(i[1]=s("",7))])}const F=e(o,[["render",r]]);export{u as __pageData,F as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.js new file mode 100644 index 00000000..9916cc69 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.js @@ -0,0 +1,21 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Natural Solar Time Offset","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.solar-offset.md","filePath":"doc/9-plugins/spatial.solar-offset.md"}'),l={name:"doc/9-plugins/spatial.solar-offset.md"};function n(p,s,h,r,k,o){return a(),t("div",null,[...s[0]||(s[0]=[e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-spatial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural Solar Time Offset ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains natural solar time offset calculations and meridian longitudinal delta modeling in @magmacomputing/tempo-plugin-spatial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Natural Solar Time vs. Clock Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard civil time zones group wide longitudinal bands (typically ≈ 15° wide) into uniform standard offsets (e.g. UTC+1, UTC-5). However, Earth rotates continuously at:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1° longitude = 4 minutes of time = 240 seconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Natural Solar Time Offset measures the exact physical time difference between an observer's physical longitude (lng) and their standard reference timezone meridian (or the nearest 15° meridian: round(lng / 15) * 15°).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. API Usage (Tempo.spatial.solarOffset / t.spatialSolarOffset / solarOffset) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The solarOffset method computes this delta in minutes (default), seconds, or hours:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin, solarOffset } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+// Sydney: Longitude 151.2093° East vs Reference Meridian 150° East (UTC+10)
+// Delta: (151.2093° - 150°) * 4 min/deg ≈ +4.84 minutes
+const sydneyOffsetMin = Tempo.spatial.solarOffset({ lat: -33.8688, lng: 151.2093 });
+console.log(sydneyOffsetMin); // ~4.84 minutes
+
+// Offset in seconds
+const sydneyOffsetSec = Tempo.spatial.solarOffset({ lat: -33.8688, lng: 151.2093 }, { unit: 'ss' });
+console.log(sydneyOffsetSec); // ~290.23 seconds
+
+// Offset in hours
+const sydneyOffsetHours = Tempo.spatial.solarOffset({ lat: -33.8688, lng: 151.2093 }, { unit: 'hh' });
+console.log(sydneyOffsetHours); // ~0.08 hours
+
+// Via Tempo instance
+const tSydney = new Tempo({ geo: { lat: -33.8688, lng: 151.2093 } });
+console.log(tSydney.spatialSolarOffset()); // ~4.84 minutes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Dual-Tier Architecture: spatial vs celestial ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DimensionTempo.spatial.solarOffset (tempo-plugin-spatial)SolarTerm (tempo-plugin-celestial)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConceptNatural Solar Time Offset (Longitudinal Delta)Apparent Solar Trajectory & Ephemeris
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PhysicsLongitudinal delta (Δλ × 4 min/deg) from reference meridianExact orbital solar altitude, Equation of Time (EoT), and transit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runtime CostO(1) analytical geometry, zero external dependenciesKeplerian orbital ephemeris & trigonometric modeling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use CasesCircadian light tracking, timezone meridian driftTwilight tracking, golden hour photography, apparent solar noon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    API TargetTempo.spatial.solarOffset(coords)t.term.solar.noon & t.term.solar.solarTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,16)])])}const c=i(l,[["render",n]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.lean.js new file mode 100644 index 00000000..7d8fda85 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.solar-offset.md.BmjcYvEl.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as t,a2 as e}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Natural Solar Time Offset","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.solar-offset.md","filePath":"doc/9-plugins/spatial.solar-offset.md"}'),l={name:"doc/9-plugins/spatial.solar-offset.md"};function n(p,s,h,r,k,o){return a(),t("div",null,[...s[0]||(s[0]=[e("",16)])])}const c=i(l,[["render",n]]);export{g as __pageData,c as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.js new file mode 100644 index 00000000..06850c9c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.js @@ -0,0 +1,82 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Transit Velocity, Impossible Travel & Navigation","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.transit-and-navigation.md","filePath":"doc/9-plugins/spatial.transit-and-navigation.md"}'),l={name:"doc/9-plugins/spatial.transit-and-navigation.md"};function p(h,s,e,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-spatial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transit Velocity, Impossible Travel & Navigation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide covers Great-Circle spatial calculations, forward compass bearings, geographic midpoints, transit velocity modeling, and impossible travel anomaly detection in @magmacomputing/tempo-plugin-spatial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Great-Circle Distance (haversineDistance / Tempo.spatial.distance) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the shortest surface distance approximation on a spherical Earth between two geographic coordinates using the Great-Circle Haversine formula (with spherical radius R = 6,371 km / 3,959 miles / 6,371,000 meters).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Distance Units ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 'km' (default): Kilometers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 'miles': Statute Miles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 'm': Meters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Code Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin, haversineDistance } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const sydney = { lat: -33.8688, lng: 151.2093 };
+const melbourne = { lat: -37.8136, lng: 144.9631 };
+
+// Static namespace call
+const distKm = Tempo.spatial.distance(sydney, melbourne, 'km'); // ~713.4 km
+const distMiles = Tempo.spatial.distance(sydney, melbourne, 'miles'); // ~443.3 miles
+
+// Fluent instance method
+const tSydney = new Tempo({ geo: sydney });
+console.log(tSydney.spatialDistance(melbourne)); // ~713.4 km
+
+// Tree-shakeable pure function
+const distM = haversineDistance(sydney, melbourne, 'm'); // ~713,400 m

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Compass Bearing (Tempo.spatial.bearing / calculateBearing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the initial forward azimuth bearing along the Great-Circle path from an origin point to a destination point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Range: Normalized to 0° <= heading < 360° (0° = North, 90° = East, 180° = South, 270° = West).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const london = { lat: 51.5074, lng: -0.1278 };
+const paris = { lat: 48.8566, lng: 2.3522 };
+
+// Initial compass bearing from London to Paris
+const heading = Tempo.spatial.bearing(london, paris); // ~148.5° (South-Southeast)
+
+// Fluent instance method
+const tLondon = new Tempo({ geo: london });
+console.log(tLondon.spatialBearing(paris)); // ~148.5°

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Geographic Midpoint (Tempo.spatial.midpoint / calculateMidpoint) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the exact spherical midpoint along the Great-Circle path connecting two coordinate points:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const tokyo = { lat: 35.6762, lng: 139.6503 };
+const sanFrancisco = { lat: 37.7749, lng: -122.4194 };
+
+const mid = Tempo.spatial.midpoint(tokyo, sanFrancisco);
+console.log(mid);
+// { latitude: 44.47..., longitude: -170.83..., sphere: 'north' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Transit Velocity & Speed Modeling (Tempo.spatial.velocity) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Computes the average physical speed of travel required to transition between two timestamped geographic instances:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Velocity = Haversine Distance(A, B) / Δ Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const dep = new Tempo('2026-06-21T08:00:00Z', {
+  geo: { lat: 51.5074, lng: -0.1278 } // London (Depart 08:00 UTC)
+});
+
+const arr = new Tempo('2026-06-21T10:15:00Z', {
+  geo: { lat: 48.8566, lng: 2.3522 } // Paris (Arrive 10:15 UTC = 2.25 hours)
+});
+
+// Speed in km/h (default)
+const speedKmH = Tempo.spatial.velocity(dep, arr); // ~152.8 km/h (Eurostar train speed)
+
+// Speed in mph
+const speedMph = Tempo.spatial.velocity(dep, arr, { unit: 'miles' }); // ~95.0 mph
+
+// Fluent instance method
+console.log(dep.spatialVelocity(arr)); // ~152.8 km/h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Impossible Travel Anomaly Detection (Tempo.spatial.isImpossibleTravel) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A vital security primitive for detecting anomalous authentication events (e.g. impossible concurrent logins from geographically distant locations):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SpatialPlugin } from '@magmacomputing/tempo-plugin-spatial';
+
+Tempo.use(SpatialPlugin);
+
+const userAuth1 = new Tempo('2026-06-21T12:00:00Z', {
+  geo: { lat: 40.7128, lng: -74.0060 } // New York
+});
+
+const userAuth2 = new Tempo('2026-06-21T12:45:00Z', {
+  geo: { lat: 37.7749, lng: -122.4194 } // San Francisco (45 mins later)
+});
+
+// Checks if travel exceeds physical feasibility (default: 900 km/h commercial jet speed)
+const isFraud = Tempo.spatial.isImpossibleTravel(userAuth1, userAuth2);
+console.log(isFraud); // true (NY to SF in 45m requires ~5500 km/h)
+
+// Custom threshold (e.g., ground vehicle threshold: 130 km/h)
+const isCarTravelImpossible = Tempo.spatial.isImpossibleTravel(userAuth1, userAuth2, {
+  maxSpeed: 130
+});
+console.log(isCarTravelImpossible); // true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,29)])])}const o=i(l,[["render",p]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.lean.js new file mode 100644 index 00000000..300efbc5 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.transit-and-navigation.md.Dh_dl4dL.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Transit Velocity, Impossible Travel & Navigation","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.transit-and-navigation.md","filePath":"doc/9-plugins/spatial.transit-and-navigation.md"}'),l={name:"doc/9-plugins/spatial.transit-and-navigation.md"};function p(h,s,e,k,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t("",29)])])}const o=i(l,[["render",p]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.js new file mode 100644 index 00000000..18205aa7 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.js @@ -0,0 +1,107 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.use-cases-and-patterns.md","filePath":"doc/9-plugins/spatial.use-cases-and-patterns.md"}'),l={name:"doc/9-plugins/spatial.use-cases-and-patterns.md"};function h(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-spatial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Real-world applications frequently handle events anchored in both time and space:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Security & Zero-Trust: Detecting impossible travel across concurrent user sessions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Fleet Logistics: Triggering automated depot dispatch when vehicles enter circular geofences or service bounding boxes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Route Planning & Aviation: Computing Great-Circle nautical distances, initial forward azimuth bearings, and route midpoints.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Natural Solar Alignment: Reconciling civil timezone offsets with true physical solar time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-spatial plugin provides GIS geometry, spherical trigonometry, and velocity analysis directly on Tempo.spatial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Zero-Trust Security: Impossible Travel Anomaly Detection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In identity providers, IAM systems, and banking portals, detecting stolen session tokens or credential stuffing is critical. If a user authenticates in New York and makes an API call from London 30 minutes later, physical travel between those coordinates is impossible without exceeding commercial aviation speeds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.isImpossibleTravel calculates Great-Circle distance over elapsed time, flagging speed anomalies exceeding commercial flight thresholds (default: 900 km/h):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-spatial/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+interface UserLoginEvent {
+  userId: string;
+  timestampIso: string;
+  ipLatitude: number;
+  ipLongitude: number;
+}
+
+export function evaluateLoginRisk(
+  lastLogin: UserLoginEvent,
+  currentLogin: UserLoginEvent
+): { isAnomalous: boolean; calculatedSpeedKmH: number } {
+  // 1. Initialize Tempo instances with geographic metadata
+  const origin = new Tempo(lastLogin.timestampIso, {
+    geo: { latitude: lastLogin.ipLatitude, longitude: lastLogin.ipLongitude }
+  });
+
+  const destination = new Tempo(currentLogin.timestampIso, {
+    geo: { latitude: currentLogin.ipLatitude, longitude: currentLogin.ipLongitude }
+  });
+
+  // 2. Compute effective travel velocity
+  const speed = Tempo.spatial.velocity(origin, destination, { unit: 'km', timeUnit: 'hh' });
+
+  // 3. Evaluate commercial flight feasibility threshold (900 km/h)
+  const isAnomalous = Tempo.spatial.isImpossibleTravel(origin, destination, {
+    maxCommercialSpeedKmH: 900
+  });
+
+  return {
+    isAnomalous,
+    calculatedSpeedKmH: Math.round(speed)
+  };
+}
+
+// Example: User signs in from NYC, then 30 mins later from London
+const check = evaluateLoginRisk(
+  { userId: 'usr_123', timestampIso: '2026-06-01 10:00:00', ipLatitude: 40.7128, ipLongitude: -74.006 },
+  { userId: 'usr_123', timestampIso: '2026-06-01 10:30:00', ipLatitude: 51.5074, ipLongitude: -0.1278 }
+);
+
+console.log(check.isAnomalous);        // true (Requires step-up MFA or token revocation)
+console.log(check.calculatedSpeedKmH); // 11140 km/h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Fleet Geofencing: Depot Arrival & Service Zone Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Delivery platforms and transport dispatchers trigger real-time workflow events when couriers enter delivery zones or arrive at a loading dock:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Circular Proximity (isWithin): Detects arrival within a specific radius (e.g. 500 meters of a warehouse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rectangular Bounding Box (inBoundingBox): Enforces regional operational boundaries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-spatial/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+const depot = { lat: -33.8688, lng: 151.2093 }; // Sydney Central Depot
+
+// Regional delivery service boundary
+const metroBoundingBox = {
+  minLat: -33.95,
+  maxLat: -33.75,
+  minLng: 151.10,
+  maxLng: 151.30
+};
+
+export function processCourierTelemetry(courierLocation: { lat: number; lng: number }) {
+  // Check if courier is within 500m of depot loading bay
+  const isAtDepot = Tempo.spatial.isWithin(courierLocation, depot, 500, 'm');
+
+  // Verify courier is operating within licensed metropolitan zone
+  const isInsideZone = Tempo.spatial.inBoundingBox(courierLocation, metroBoundingBox);
+
+  return {
+    isAtDepot,
+    isInsideZone
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Flight Route Planning: Great-Circle Distance & Forward Azimuth ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Air navigation uses Great-Circle geodesic routes to minimize fuel consumption. Tempo.spatial.distance, bearing, and midpoint calculate the shortest curvature path, the initial compass heading, and the midpoint coordinates:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-spatial/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+const jfkAirport = { lat: 40.6413, lng: -73.7781 };
+const lhrAirport = { lat: 51.4700, lng: -0.4543 };
+
+export function planFlightSector(origin: typeof jfkAirport, destination: typeof lhrAirport) {
+  const distanceKm = Tempo.spatial.distance(origin, destination, 'km');
+  const initialBearingDeg = Tempo.spatial.bearing(origin, destination);
+  const midpoint = Tempo.spatial.midpoint(origin, destination);
+
+  return {
+    distanceKm: Math.round(distanceKm),
+    initialBearingDeg: Math.round(initialBearingDeg),
+    midpointCoord: {
+      latitude: Number(midpoint.latitude.toFixed(3)),
+      longitude: Number(midpoint.longitude.toFixed(3)),
+      hemisphere: midpoint.sphere
+    }
+  };
+}
+
+const flightPlan = planFlightSector(jfkAirport, lhrAirport);
+console.log(flightPlan.distanceKm);        // 5540 km
+console.log(flightPlan.initialBearingDeg); // 51°
+console.log(flightPlan.midpointCoord);     // { latitude: 52.217, longitude: -41.303, hemisphere: 'north' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Physical Solar Noon vs. Civil Timezone Offset ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard civil timezones group large geographic expanses into unified offsets. In regions on the western edge of wide time zones (such as Spain, which operates on Central European Time UTC+1 / UTC+2 despite geographically aligning with UTC+0), civil clock noon occurs nearly two hours before the sun reaches its zenith.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.spatial.solarOffset calculates this delta for energy modeling and circadian scheduling:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-spatial/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// Paris, France on the Summer Solstice
+const t = new Tempo('2026-06-21 12:00:00', {
+  geo: { latitude: 48.8584, longitude: 2.2945 },
+  timeZone: 'Europe/Paris'
+});
+
+// Calculate solar delta in minutes
+const deltaMinutes = Tempo.spatial.solarOffset(t, { unit: 'minutes' });
+
+// In CEST (UTC+2), civil noon is ~110 minutes ahead of true solar noon
+console.log(deltaMinutes); // -110.82 minutes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,25)])])}const o=i(l,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.lean.js new file mode 100644 index 00000000..3abc8fad --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_spatial.use-cases-and-patterns.md.C630dCxp.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/spatial.use-cases-and-patterns.md","filePath":"doc/9-plugins/spatial.use-cases-and-patterns.md"}'),l={name:"doc/9-plugins/spatial.use-cases-and-patterns.md"};function h(p,s,e,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t("",25)])])}const o=i(l,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.js new file mode 100644 index 00000000..d75f89e6 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.js @@ -0,0 +1,17 @@ +import{_ as r,o as i,c as n,a2 as a,j as t,a as s}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Lock-Free Atomics & Memory Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.atomic-architecture.md","filePath":"doc/9-plugins/sync.atomic-architecture.md"}'),o={name:"doc/9-plugins/sync.atomic-architecture.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.05ex"},xmlns:"http://www.w3.org/2000/svg",width:"20.828ex",height:"1.62ex",role:"img",focusable:"false",viewBox:"0 -694 9205.8 716","aria-hidden":"true"};function p(T,e,Q,m,g,u){return i(),n("div",null,[e[9]||(e[9]=a(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lock-Free Atomics & Memory Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-sync plugin provides hardware-level, nanosecond-accurate cross-thread time synchronization using standard JavaScript SharedArrayBuffer and Atomics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is specifically engineered for multi-threaded architectures—such as high-frequency trading (HFT) risk checkers, real-time physics engines, and audio digital signal processing (DSP)—where inter-process communication (IPC) latency or event-loop microtasks cannot be tolerated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Shared Memory Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Traditional multi-worker architectures broadcast timestamp updates via postMessage(). In Node.js or high-throughput browser Web Workers, postMessage() suffers from structural cloning serialization costs, thread-context switching, and event loop queue delays ranging from 0.5ms to 15ms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Sync plugin bypasses the event loop entirely by allocating a dedicated 8-byte shared buffer in virtual memory:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ┌────────────────────────────────────────────────────────┐
+│ Virtual Memory: SharedArrayBuffer (8 Bytes)           │
+├────────────────────────────────────────────────────────┤
+│ [ 0x00 | 0x01 | 0x02 | 0x03 | 0x04 | 0x05 | 0x06 | 0x07 ] │
+│ ◄──────────────── 64-Bit Integer (BigInt64Array) ────► │
+│ Represents: Epoch Time in Nanoseconds (nowNano)        │
+└────────────────────────────────────────────────────────┘
+          ▲                                    │
+          │                                    │
+     Atomics.store                        Atomics.load
+   (Master Thread)                     (Worker Threads)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Master Clock Writer (AtomicClock) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The master process instantiates AtomicClock, allocating new SharedArrayBuffer(8) with a BigInt64Array typed view.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An internal monotonic ticker writes the current timestamp in nanoseconds into index 0 using Atomics.store(this.#view, 0, nowNano).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Because Atomics.store is an atomic store instruction, it guarantees sequential consistency across all CPU cores and hardware memory caches without requiring thread locking or mutex semaphores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Lock-Free Worker Reader (AtomicReader) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,13)),t("ul",null,[e[8]||(e[8]=a("
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Worker threads receive the SharedArrayBuffer reference upon initialization (e.g. via workerData in Node.js or postMessage transfer in the browser).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The worker binds an AtomicReader directly to the buffer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Invoking reader.nowNano() or reader.now() executes a single CPU instruction: Atomics.load(this.#view, 0).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ",3)),t("li",null,[e[5]||(e[5]=s("This read executes synchronously in ",-1)),t("strong",null,[t("mjx-container",l,[(i(),n("svg",d,[...e[0]||(e[0]=[a('',1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[2]||(e[2]=s(" constant time",-1))]),e[6]||(e[6]=s(" (",-1)),t("mjx-container",c,[(i(),n("svg",h,[...e[3]||(e[3]=[a('',1)])])),e[4]||(e[4]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈"),t("mn",null,"10"),t("mtext",null,"–"),t("mn",null,"25"),t("mtext",null," nanoseconds")])],-1))]),e[7]||(e[7]=s(" on modern x86/ARM hardware), with zero IPC overhead and zero garbage collection pressure.",-1))])]),e[10]||(e[10]=a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dual-Layer Lifecycle Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Long-running timer loops in Node.js can inadvertently keep processes alive or cause memory leaks during hot-reloads and test teardowns. The Sync plugin implements Tempo's Dual-Layer Lifecycle Model:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Native Timer Unreferencing (unref()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When the master clock starts its periodic synchronization loop, it automatically calls .unref() on the underlying timer:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (typeof timer.unref === 'function') {
+  timer.unref();
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This ensures that the presence of the background sync clock will not prevent Node.js from exiting gracefully when all primary application tasks complete.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit Deterministic Resource Management (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AtomicClock implements [Symbol.dispose]() for deterministic cleanup via TypeScript 5.2+ explicit resource management:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using clock = Tempo.sync.startClock({ interval: 5 });
+  // Buffer is actively shared with worker threads...
+} // <-- Automatically invokes clock.stop() upon leaving block scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. GC Finalization Registry Safety Net ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As an asynchronous fallback, the clock registers with Tempo's Finalizer registry. If a developer forgets to call clock.stop() or dispose the instance, the timer is safely halted when the clock instance is reclaimed by the garbage collector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser Security Constraints: Cross-Origin Isolation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Due to Spectre and Meltdown side-channel mitigation policies, web browsers disable SharedArrayBuffer by default unless the host website serves strict Cross-Origin Isolation HTTP headers:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Environment Compatibility Matrix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runtime EnvironmentSharedArrayBuffer SupportConfiguration Requirements
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js (v18+)✅ Native (Unrestricted)None. Enabled by default across all worker threads.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser (Isolated)✅ Native (High Precision)Web server must emit COOP: same-origin and COEP: require-corp.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser (Non-Isolated)❌ Blocked by BrowserStatic hosts (e.g. GitHub Pages) cannot enable SAB without proxy headers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Electron / Tauri✅ Native (Configurable)Set webPreferences: { nodeIntegration: true } or configure isolation headers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If SharedArrayBuffer is not supported in the host environment, AtomicClock immediately throws a descriptive initialization error directing developers to verify their server headers or run in Node.js.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,19))])}const f=r(o,[["render",p]]);export{y as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.lean.js new file mode 100644 index 00000000..ee2afd7c --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.atomic-architecture.md.TRzGWYv8.lean.js @@ -0,0 +1 @@ +import{_ as r,o as i,c as n,a2 as a,j as t,a as s}from"./chunks/framework.DNL3hc5c.js";const y=JSON.parse('{"title":"Lock-Free Atomics & Memory Architecture","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.atomic-architecture.md","filePath":"doc/9-plugins/sync.atomic-architecture.md"}'),o={name:"doc/9-plugins/sync.atomic-architecture.md"},l={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},d={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.05ex"},xmlns:"http://www.w3.org/2000/svg",width:"20.828ex",height:"1.62ex",role:"img",focusable:"false",viewBox:"0 -694 9205.8 716","aria-hidden":"true"};function p(T,e,Q,m,g,u){return i(),n("div",null,[e[9]||(e[9]=a("",13)),t("ul",null,[e[8]||(e[8]=a("",3)),t("li",null,[e[5]||(e[5]=s("This read executes synchronously in ",-1)),t("strong",null,[t("mjx-container",l,[(i(),n("svg",d,[...e[0]||(e[0]=[a("",1)])])),e[1]||(e[1]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mi",null,"O"),t("mo",{stretchy:"false"},"("),t("mn",null,"1"),t("mo",{stretchy:"false"},")")])],-1))]),e[2]||(e[2]=s(" constant time",-1))]),e[6]||(e[6]=s(" (",-1)),t("mjx-container",c,[(i(),n("svg",h,[...e[3]||(e[3]=[a("",1)])])),e[4]||(e[4]=t("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[t("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[t("mo",null,"≈"),t("mn",null,"10"),t("mtext",null,"–"),t("mn",null,"25"),t("mtext",null," nanoseconds")])],-1))]),e[7]||(e[7]=s(" on modern x86/ARM hardware), with zero IPC overhead and zero garbage collection pressure.",-1))])]),e[10]||(e[10]=a("",19))])}const f=r(o,[["render",p]]);export{y as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.js new file mode 100644 index 00000000..d1e8fa74 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.js @@ -0,0 +1,26 @@ +import{_ as l}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as r,o as a,c as n,a2 as e,j as s,a as i}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"@magmacomputing/tempo-plugin-sync","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.index.md","filePath":"doc/9-plugins/sync.index.md"}'),o={name:"doc/9-plugins/sync.index.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},d={tabindex:"0"},k={style:{"text-align":"left"}},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function m(y,t,u,f,T,E){return a(),n("div",null,[t[19]||(t[19]=e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-sync ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin for the Tempo library that provides lock-free, nanosecond-accurate cross-thread time synchronization using SharedArrayBuffer and Atomics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',4)),s("p",null,[t[2]||(t[2]=i("It eliminates inter-process message passing (IPC) latency, allowing worker threads and Web Workers to read current timestamps synchronously in constant ",-1)),s("mjx-container",p,[(a(),n("svg",h,[...t[0]||(t[0]=[e('',1)])])),t[1]||(t[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),t[3]||(t[3]=i(" time.",-1))]),t[20]||(t[20]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perfect For

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    High-frequency trading platforms, real-time multiplayer authoritative game servers, distributed microservice tracing, and extreme-precision scientific telemetry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Installation & Quickstart ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Live Interactive Sandbox Note

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This plugin leverages SharedArrayBuffer and Atomics for hardware-level cross-thread synchronization. Modern browsers require Cross-Origin Isolation (Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp) to enable SharedArrayBuffer. Because GitHub Pages static hosting cannot emit custom HTTP response headers, the live browser sandbox widget is disabled on this documentation page. To test the Sync plugin, run it in Node.js (supported natively) or in a local development environment with custom server headers configured.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Master Process: Initializing the Atomic Clock ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SyncPlugin } from '@magmacomputing/tempo-plugin-sync';
+
+Tempo.use(SyncPlugin);
+
+// Start master clock loop (interval in ms, default is 10)
+const clock = Tempo.sync.startClock({ interval: 5 });
+const buffer = clock.getBuffer(); // Pass this SharedArrayBuffer to your workers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Boilerplate Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-sync/install';
+
+const clock = Tempo.sync.startClock({ interval: 10 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Worker Process: Lock-Free Reading ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // worker.ts
+import { workerData } from 'node:worker_threads';
+import { AtomicReader } from '@magmacomputing/tempo-plugin-sync';
+
+// Hydrate reader directly from shared memory
+const reader = new AtomicReader(workerData.buffer);
+
+// 1. Get raw epoch milliseconds (O(1) Atomic Read)
+const ms = reader.now(); 
+
+// 2. Get high-precision BigInt nanoseconds
+const ns = reader.nowNano();
+
+// 3. Hydrate a brand new Tempo instance with exact precision
+const t = reader.getTempo();
+console.log(t.iso);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 API Surface Catalog ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Sync plugin exposes two primary abstractions: AtomicClock for the master thread, and AtomicReader for worker threads:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,14)),s("table",d,[t[18]||(t[18]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Class / Method"),s("th",{style:{"text-align":"left"}},"Context"),s("th",{style:{"text-align":"left"}},"Parameters"),s("th",{style:{"text-align":"left"}},"Returns"),s("th",{style:{"text-align":"left"}},"Description")])],-1)),s("tbody",null,[t[12]||(t[12]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.startClock(opts?)")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},[s("code",null,"ClockOptions?: { interval?: number }")]),s("td",{style:{"text-align":"left"}},[s("code",null,"AtomicClock")]),s("td",{style:{"text-align":"left"}},"Initializes and starts the master clock loop, continuously writing time to shared memory.")],-1)),t[13]||(t[13]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.stopClock()")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"void")]),s("td",{style:{"text-align":"left"}},"Halts the master clock synchronization loop.")],-1)),t[14]||(t[14]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.getBuffer()")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"SharedArrayBuffer")]),s("td",{style:{"text-align":"left"}},"Returns the underlying 8-byte shared buffer for worker transfer.")],-1)),t[15]||(t[15]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"new AtomicReader(buffer)")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},[s("code",null,"buffer: SharedArrayBuffer")]),s("td",{style:{"text-align":"left"}},[s("code",null,"AtomicReader")]),s("td",{style:{"text-align":"left"}},"Instantiates a high-speed reader bound to the shared clock buffer.")],-1)),s("tr",null,[t[8]||(t[8]=s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.now()")])],-1)),t[9]||(t[9]=s("td",{style:{"text-align":"left"}},"Worker",-1)),t[10]||(t[10]=s("td",{style:{"text-align":"left"}},"None",-1)),t[11]||(t[11]=s("td",{style:{"text-align":"left"}},[s("code",null,"number")],-1)),s("td",k,[t[6]||(t[6]=i("Returns synchronized epoch timestamp in milliseconds in ",-1)),s("mjx-container",c,[(a(),n("svg",g,[...t[4]||(t[4]=[e('',1)])])),t[5]||(t[5]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),t[7]||(t[7]=i(" time.",-1))])]),t[16]||(t[16]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.nowNano()")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"bigint")]),s("td",{style:{"text-align":"left"}},"Returns synchronized epoch timestamp in BigInt nanoseconds.")],-1)),t[17]||(t[17]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.getTempo()")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"Tempo")]),s("td",{style:{"text-align":"left"}},[i("Hydrates a new immutable "),s("code",null,"Tempo"),i(" instance representing current synchronized time.")])],-1))])]),t[21]||(t[21]=e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Architecture & Specialized Guides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Licensing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',6))])}const w=r(o,[["render",m]]);export{F as __pageData,w as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.lean.js new file mode 100644 index 00000000..875e33d5 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.index.md.D7OIe-8G.lean.js @@ -0,0 +1 @@ +import{_ as l}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as r,o as a,c as n,a2 as e,j as s,a as i}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"@magmacomputing/tempo-plugin-sync","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.index.md","filePath":"doc/9-plugins/sync.index.md"}'),o={name:"doc/9-plugins/sync.index.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},h={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"},d={tabindex:"0"},k={style:{"text-align":"left"}},c={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},g={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function m(y,t,u,f,T,E){return a(),n("div",null,[t[19]||(t[19]=e("",4)),s("p",null,[t[2]||(t[2]=i("It eliminates inter-process message passing (IPC) latency, allowing worker threads and Web Workers to read current timestamps synchronously in constant ",-1)),s("mjx-container",p,[(a(),n("svg",h,[...t[0]||(t[0]=[e("",1)])])),t[1]||(t[1]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),t[3]||(t[3]=i(" time.",-1))]),t[20]||(t[20]=e("",14)),s("table",d,[t[18]||(t[18]=s("thead",null,[s("tr",null,[s("th",{style:{"text-align":"left"}},"Class / Method"),s("th",{style:{"text-align":"left"}},"Context"),s("th",{style:{"text-align":"left"}},"Parameters"),s("th",{style:{"text-align":"left"}},"Returns"),s("th",{style:{"text-align":"left"}},"Description")])],-1)),s("tbody",null,[t[12]||(t[12]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.startClock(opts?)")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},[s("code",null,"ClockOptions?: { interval?: number }")]),s("td",{style:{"text-align":"left"}},[s("code",null,"AtomicClock")]),s("td",{style:{"text-align":"left"}},"Initializes and starts the master clock loop, continuously writing time to shared memory.")],-1)),t[13]||(t[13]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.stopClock()")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"void")]),s("td",{style:{"text-align":"left"}},"Halts the master clock synchronization loop.")],-1)),t[14]||(t[14]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"Tempo.sync.getBuffer()")])]),s("td",{style:{"text-align":"left"}},"Master"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"SharedArrayBuffer")]),s("td",{style:{"text-align":"left"}},"Returns the underlying 8-byte shared buffer for worker transfer.")],-1)),t[15]||(t[15]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"new AtomicReader(buffer)")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},[s("code",null,"buffer: SharedArrayBuffer")]),s("td",{style:{"text-align":"left"}},[s("code",null,"AtomicReader")]),s("td",{style:{"text-align":"left"}},"Instantiates a high-speed reader bound to the shared clock buffer.")],-1)),s("tr",null,[t[8]||(t[8]=s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.now()")])],-1)),t[9]||(t[9]=s("td",{style:{"text-align":"left"}},"Worker",-1)),t[10]||(t[10]=s("td",{style:{"text-align":"left"}},"None",-1)),t[11]||(t[11]=s("td",{style:{"text-align":"left"}},[s("code",null,"number")],-1)),s("td",k,[t[6]||(t[6]=i("Returns synchronized epoch timestamp in milliseconds in ",-1)),s("mjx-container",c,[(a(),n("svg",g,[...t[4]||(t[4]=[e("",1)])])),t[5]||(t[5]=s("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[s("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[s("mi",null,"O"),s("mo",{stretchy:"false"},"("),s("mn",null,"1"),s("mo",{stretchy:"false"},")")])],-1))]),t[7]||(t[7]=i(" time.",-1))])]),t[16]||(t[16]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.nowNano()")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"bigint")]),s("td",{style:{"text-align":"left"}},"Returns synchronized epoch timestamp in BigInt nanoseconds.")],-1)),t[17]||(t[17]=s("tr",null,[s("td",{style:{"text-align":"left"}},[s("strong",null,[s("code",null,"reader.getTempo()")])]),s("td",{style:{"text-align":"left"}},"Worker"),s("td",{style:{"text-align":"left"}},"None"),s("td",{style:{"text-align":"left"}},[s("code",null,"Tempo")]),s("td",{style:{"text-align":"left"}},[i("Hydrates a new immutable "),s("code",null,"Tempo"),i(" instance representing current synchronized time.")])],-1))])]),t[21]||(t[21]=e("",6))])}const w=r(o,[["render",m]]);export{F as __pageData,w as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.js new file mode 100644 index 00000000..0cc21e39 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.js @@ -0,0 +1,100 @@ +import{_ as l,o as t,c as e,a2 as n,j as i,a}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.use-cases-and-patterns.md","filePath":"doc/9-plugins/sync.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/sync.use-cases-and-patterns.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function r(d,s,o,E,c,g){return t(),e("div",null,[s[8]||(s[8]=n('
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explores architectural patterns where @magmacomputing/tempo-plugin-sync provides lock-free, zero-latency time synchronization across multi-threaded systems.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. High-Frequency Trading (HFT) Worker Thread Risk Cluster ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In automated algorithmic trading and risk evaluation engines, 16–32 worker threads concurrently evaluate order books, order cancellations, and margin limits. In asynchronous microsecond trading environments, inter-thread message passing (worker.postMessage) introduces 500µs to 2ms of jitter. Workers evaluating risk thresholds with staggered clock skews make inconsistent margin calls or execute out-of-order market orders.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',9)),i("p",null,[s[2]||(s[2]=a("The main thread runs a master ",-1)),s[3]||(s[3]=i("code",null,"AtomicClock",-1)),s[4]||(s[4]=a(" updating every 1ms. The shared buffer is passed to worker threads at startup. Worker risk evaluators read the exact current timestamp in ",-1)),i("mjx-container",p,[(t(),e("svg",k,[...s[0]||(s[0]=[n('',1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[5]||(s[5]=a(" lock-free time via ",-1)),s[6]||(s[6]=i("code",null,"reader.nowNano()",-1)),s[7]||(s[7]=a(", guaranteeing absolute ordering and eliminating IPC delays.",-1))]),s[9]||(s[9]=n(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Master Process (WebSocket Ingestion)
+                     │
+         [AtomicClock: 1ms loop]
+                     │
+           SharedArrayBuffer(8)
+      ┌──────────────┼──────────────┐
+      ▼              ▼              ▼
+ Worker #1       Worker #2      Worker #3
+(Risk Engine)   (Order Book)   (Compliance)
+      │              │              │
+ reader.now()   reader.now()   reader.now()
+ (Sub-microsecond Lock-Free Atomic Read)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Implementation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // master.ts (Main Process)
+import { Worker } from 'node:worker_threads';
+import { Tempo } from '@magmacomputing/tempo';
+import { SyncPlugin } from '@magmacomputing/tempo-plugin-sync';
+
+Tempo.use(SyncPlugin);
+
+export class TradingEngineCluster {
+  private clock = Tempo.sync.startClock({ interval: 1 }); // 1ms tick
+  private workers: Worker[] = [];
+
+  spawnWorkers(workerScriptPath: string, count = 4) {
+    const buffer = this.clock.getBuffer();
+
+    for (let i = 0; i < count; i++) {
+      const worker = new Worker(workerScriptPath, {
+        workerData: { buffer, workerId: i + 1 }
+      });
+      this.workers.push(worker);
+    }
+  }
+
+  shutdown() {
+    this.clock.stop();
+    for (const w of this.workers) w.terminate();
+  }
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // worker.ts (Executed inside worker thread)
+import { workerData } from 'node:worker_threads';
+import { AtomicReader } from '@magmacomputing/tempo-plugin-sync';
+
+// Hydrate atomic reader directly from shared memory
+const reader = new AtomicReader(workerData.buffer);
+
+export function evaluateTradeRisk(orderId: string, limitPrice: number) {
+  // Ultra-fast lock-free read (approx 15ns)
+  const currentNano = reader.nowNano();
+  const currentMs = reader.now();
+
+  // Hydrate full Tempo instance for audit logging when violations occur
+  if (limitPrice > 10_000) {
+    const auditTime = reader.getTempo();
+    console.warn(\`[Risk Violation] Order \${orderId} at \${auditTime.iso}\`);
+  }
+
+  return { orderId, evaluatedAtNano: currentNano, evaluatedAtMs: currentMs };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Authoritative Multiplayer Game Simulation Ticks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In real-time multiplayer dedicated game servers (spatial combat, FPS, sports), physics simulations (Havok, Rapier, PhysX) run across multiple dedicated background workers. If physics workers derive their simulation deltaTime from independent Date.now() or performance.now() calls, thread scheduling jitter creates simulation desyncs, "rubber-banding", and inconsistent projectile trajectories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The master server loop drives simulation time using AtomicClock. Physics worker threads query reader.now() at the beginning of each simulation step to access drift-free master time. When workers require a strictly common simulation timestamp across all isolates, the master captures one tick value and passes it to all workers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { SyncPlugin, AtomicReader } from '@magmacomputing/tempo-plugin-sync';
+
+Tempo.use(SyncPlugin);
+
+export class PhysicsSimulationWorker {
+  private reader: AtomicReader;
+  private lastTickMs: number;
+
+  constructor(sharedBuffer: SharedArrayBuffer) {
+    this.reader = new AtomicReader(sharedBuffer);
+    this.lastTickMs = this.reader.now();
+  }
+
+  /**
+   * Evaluates a single physics tick synchronized with the master server clock.
+   */
+  stepSimulation() {
+    const currentMs = this.reader.now();
+    const deltaTime = (currentMs - this.lastTickMs) / 1000; // in seconds
+    this.lastTickMs = currentMs;
+
+    // Run physics integration with zero inter-worker time drift
+    return { currentMs, deltaTime };
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Real-Time Audio DSP Buffer Synchronization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Problem Statement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In WebAudio and professional audio workstations, digital signal processing (DSP) threads process audio frames in strict 128-sample buffers (approx 2.9ms at 44.1kHz). If the UI thread or network synchronization thread communicates with the audio thread via asynchronous messages, audio buffer under-runs (clicks and pops) occur whenever the main thread is busy rendering or parsing JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By sharing an AtomicClock buffer between the main thread and audio workers, the audio processor can stamp incoming MIDI notes and parameter automations synchronously without touching the event loop:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { AtomicReader } from '@magmacomputing/tempo-plugin-sync';
+
+export class AudioWorkletTimeSync {
+  private reader: AtomicReader;
+
+  constructor(sharedBuffer: SharedArrayBuffer) {
+    this.reader = new AtomicReader(sharedBuffer);
+  }
+
+  /**
+   * Called within audio rendering callback (zero allocations permitted).
+   */
+  processAudioFrame(frameNumber: number) {
+    // Lock-free read executes in O(1) time without garbage collection
+    const sampleTimestampNs = this.reader.nowNano();
+
+    return { frameNumber, timestampNs: sampleTimestampNs };
+  }
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,18))])}const u=l(h,[["render",r]]);export{F as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.lean.js new file mode 100644 index 00000000..45963e78 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_sync.use-cases-and-patterns.md.Dewhm-VI.lean.js @@ -0,0 +1 @@ +import{_ as l,o as t,c as e,a2 as n,j as i,a}from"./chunks/framework.DNL3hc5c.js";const F=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/sync.use-cases-and-patterns.md","filePath":"doc/9-plugins/sync.use-cases-and-patterns.md"}'),h={name:"doc/9-plugins/sync.use-cases-and-patterns.md"},p={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"-0.566ex"},xmlns:"http://www.w3.org/2000/svg",width:"4.618ex",height:"2.262ex",role:"img",focusable:"false",viewBox:"0 -750 2041 1000","aria-hidden":"true"};function r(d,s,o,E,c,g){return t(),e("div",null,[s[8]||(s[8]=n("",9)),i("p",null,[s[2]||(s[2]=a("The main thread runs a master ",-1)),s[3]||(s[3]=i("code",null,"AtomicClock",-1)),s[4]||(s[4]=a(" updating every 1ms. The shared buffer is passed to worker threads at startup. Worker risk evaluators read the exact current timestamp in ",-1)),i("mjx-container",p,[(t(),e("svg",k,[...s[0]||(s[0]=[n("",1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"O"),i("mo",{stretchy:"false"},"("),i("mn",null,"1"),i("mo",{stretchy:"false"},")")])],-1))]),s[5]||(s[5]=a(" lock-free time via ",-1)),s[6]||(s[6]=i("code",null,"reader.nowNano()",-1)),s[7]||(s[7]=a(", guaranteeing absolute ordering and eliminating IPC delays.",-1))]),s[9]||(s[9]=n("",18))])}const u=l(h,[["render",r]]);export{F as __pageData,u as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.js new file mode 100644 index 00000000..2616e928 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.js @@ -0,0 +1,19 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as a,C as n,o as l,c as r,a2 as e,E as o}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ticker","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.index.md","filePath":"doc/9-plugins/ticker.index.md"}'),d={name:"doc/9-plugins/ticker.index.md"};function p(c,t,h,k,g,y){const i=n("PluginRepl");return l(),r("div",null,[t[0]||(t[0]=e('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @magmacomputing/tempo-plugin-ticker ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm version npm peer dependency version License TypeScript Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A high-performance Community plugin for the Tempo ecosystem providing temporal continuous execution loops, best-effort scheduling with millisecond resolution, explicit resource management disposers (using / await using), async generator streams, and multi-clock synchronization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unlike raw setInterval, Tempo Ticker handles calendar arithmetic, month-length adjustments, daylight saving shifts, recurrence rules, and cron schedules with zero timer drift.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo-plugin-ticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architecture & Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Installation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';\nimport { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';\n\nTempo.use(TickerPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Auto-Installation (Side-Effect Import) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';\nimport '@magmacomputing/tempo-plugin-ticker/install';\n\nconst ticker = Tempo.ticker({ seconds: 1 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore detailed guides on specific capabilities:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intervals & Scheduling Engines: Semantic durations ({ months: 1 }), calendar terms (#timeOfDay), 5-field Cron expressions (0 9 * * 1-5), RFC 5545 RRULE, countdowns, and one-shot meeting alerts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resource Management & Lifecycle: Explicit resource management (using / await using), async generators (for await), programmatic controls (stop, info, pulse), limits, and zombie process prevention.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Event Streams & Reactive Clocks: Event listeners (.on('pulse'), .on('stop'), .on('catch')), registry diagnostics (Ticker.active), and zero-drift multi-timezone dashboards with UI signals.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Use Cases & Architectural Patterns: Zero-drift telemetry heartbeats, leak prevention via using, streaming market tick generators, multi-timezone cron schedules, and laptop sleep recovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive Ticker API Surface ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creation: Tempo.ticker(intervalOrOptions?, callback?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ParameterTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intervalOrOptionsTicker.Interval | Ticker.OptionsNumber of seconds, cron expression, RRULE string, calendar term, or comprehensive options object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback(t: Tempo, stop: () => void) => voidOptional pulse callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker.Options Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    seconds / ssnumber1Seconds interval step. Negative values count backwards.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minutes / minumber—Minutes interval step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hours / hhnumber—Hours interval step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    days / ddnumber—Days interval step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    months / mmnumber—Calendar months interval step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    years / yynumber—Years interval step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cronstring—Standard 5-field cron expression (e.g. '*/15 * * * *').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rrulestring—Standard RFC 5545 iCalendar recurrence rule string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    seedstring | Date | TempoCurrent timeInitial timestamp or starting point for virtual clocks and countdowns.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    untilstring | Date | Tempo—Inclusive termination boundary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limitnumber—Maximum pulse count before automatic shutdown (limit: 0 stops immediately).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    labelstring—Descriptive label visible in Ticker.active telemetry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TickerInstance Object ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Method / PropertyReturn TypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ticker.stop()voidStops the ticker, clears active timers, and finalizes pending async iterators.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ticker.pulse()TempoManually triggers a pulse, advances state, and notifies listeners.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ticker.infoobjectTelemetry snapshot: { next, ticks, limit, interval, stopped }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ticker.on(event, cb)thisRegisters listeners for 'pulse', 'stop', or 'catch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.dispose]voidSynchronous disposer hook for using blocks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.asyncDispose]Promise<void>Asynchronous disposer hook for await using blocks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [Symbol.asyncIterator]AsyncGenerator<Tempo>Streaming generator support for for await (const t of ticker) loops.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static Ticker Namespace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyReturn TypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker.activeSnapshot[]Returns an array of snapshots for all currently running (non-stopped) Tickers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Quickstart Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',30)),o(i,{plugin:"ticker"}),t[1]||(t[1]=e(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Disposer Pattern (Zero Leakage) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+{
+  await using ticker = Tempo.ticker({ seconds: 1 }, (t) => {
+    console.log('Tick:', t.format('{hh}:{mi}:{ss}'));
+  });
+
+  // Keep scope alive to observe repeated ticks
+  await new Promise((resolve) => setTimeout(resolve, 2500));
+} // ⚡ Cleaned up automatically upon leaving scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Async Generator Stream ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    async function streamClock() {
+  await using ticker = Tempo.ticker({ seconds: 1 });
+  let count = 0;
+
+  for await (const t of ticker) {
+    console.log('Stream tick:', t.iso);
+    if (++count >= 5) break;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    License ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is a Community plugin. It is completely free and open-source for personal and commercial use under the MIT license. No license token is required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,7))])}const f=a(d,[["render",p]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.lean.js new file mode 100644 index 00000000..20d47666 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.index.md.BdxzIC1U.lean.js @@ -0,0 +1 @@ +import{_ as s}from"./chunks/plugin-logo.C-aHx2mi.js";import{_ as a,C as n,o as l,c as r,a2 as e,E as o}from"./chunks/framework.DNL3hc5c.js";const E=JSON.parse('{"title":"@magmacomputing/tempo-plugin-ticker","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.index.md","filePath":"doc/9-plugins/ticker.index.md"}'),d={name:"doc/9-plugins/ticker.index.md"};function p(c,t,h,k,g,y){const i=n("PluginRepl");return l(),r("div",null,[t[0]||(t[0]=e("",30)),o(i,{plugin:"ticker"}),t[1]||(t[1]=e("",7))])}const f=a(d,[["render",p]]);export{E as __pageData,f as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.js new file mode 100644 index 00000000..ffc370ee --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.js @@ -0,0 +1,94 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Intervals & Scheduling Engines","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.intervals-and-scheduling.md","filePath":"doc/9-plugins/ticker.intervals-and-scheduling.md"}'),h={name:"doc/9-plugins/ticker.intervals-and-scheduling.md"};function l(e,s,k,p,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Intervals & Scheduling Engines ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ticker plugin supports a unified scheduling interface capable of driving continuous loops via semantic durations, calendar terms, standard 5-field cron syntax, RFC 5545 recurrence rules, and virtual clock countdowns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Semantic Duration Intervals ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of raw milliseconds or seconds, you can configure intervals using semantic DurationLike objects or shorthand units. This is critical for variable-length units like months and years, where fixed millisecond counts drift across leap years and differing month lengths:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+// Pulse exactly once every calendar month
+await using monthly = Tempo.ticker({ months: 1 }, (t) => {
+  console.log('Monthly pulse:', t.format('{yyyy}-{mm}-{dd}'));
+});
+
+// Multi-unit duration intervals
+await using meetingInterval = Tempo.ticker({ hours: 1, minutes: 30 }, (t) => {
+  console.log('Meeting interval pulse:', t.format('{hh}:{mi}'));
+});
+
+// Ultra-compact shorthand notation (consumed via async iteration)
+await using concise = Tempo.ticker({ hh: 1, mi: 30 }); // every 1h 30m
+for await (const t of concise) {
+  console.log('Concise interval pulse:', t.format('{hh}:{mi}'));
+  break;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Shorthand Units ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ShorthandFull Duration UnitExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ss / secondsSeconds{ ss: 5 } (Every 5 seconds)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mi / minutesMinutes{ mi: 15 } (Every 15 minutes)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hh / hoursHours{ hh: 2 } (Every 2 hours)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dd / daysDays{ dd: 1 } (Daily at current wall-clock offset)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ww / weeksWeeks{ ww: 2 } (Fortnightly)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mm / monthsCalendar Months{ mm: 1 } (1st of each month / monthly)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yy / yearsYears{ yy: 1 } (Annually)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Calendar Term-Driven Intervals ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker can be driven directly by any registered Term in the Tempo ecosystem (e.g., #timeOfDay, #quarter, #season).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Boundary Snapping (>) vs. Relative Shifting (1) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Boundary Snapping (> / <): Snaps each pulse directly to the exact boundary of the period (e.g. exactly at 06:00 for morning, 12:00 for afternoon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relative Shifting (1, 2, ...): Preserves your current time offset into the next period (e.g. being 15 minutes into a quarter will pulse 15 minutes into the next quarter).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Snap and pulse exactly at the start of each daily cycle ('morning', 'afternoon', 'evening', 'night')
+using shiftTicker = Tempo.ticker({ '#timeOfDay': '>' }, (t) => {
+  console.log(\`New period started: \${t.term.tod} at \${t.format('{hh}:{mi}')}\`);
+});
+
+// Pulse as each fiscal or calendar quarter begins
+using quarterlyTicker = Tempo.ticker({ '#quarter': '>' }, (t) => {
+  console.log(\`New quarter entered: Q\${t.quarter}\`);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Cron Expressions (Standard 5-Field Syntax) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker natively accepts standard 5-part cron expressions (minute hour day-of-month month day-of-week) powered by @magmacomputing/tempo-fns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing Cron Strings ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Pattern A: Positional 5-field cron string (9am Monday through Friday)
+// Note: The callback runs immediately when the ticker is created, even outside the 9am window,
+// before subsequent calls follow the scheduled cron interval.
+await using weekdaySync = Tempo.ticker('0 9 * * 1-5', (t) => {
+  console.log(\`Workday morning pulse: \${t.format('{hh}:{mi}:{ss}')}\`);
+});
+
+// Pattern B: Options object with cron schedule and boundary limits
+await using healthCheck = Tempo.ticker({
+  cron: '*/15 * * * *', // Every 15 minutes
+  label: '15-Minute Healthcheck',
+  limit: 10
+}, (t) => {
+  console.log(\`Healthcheck pulse: \${t.format('{yyyy}-{mm}-{dd} {hh}:{mi}')}\`);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. RFC 5545 Recurrence Rules (RRULE) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker natively supports RFC 5545 iCalendar recurrence rule strings:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Daily recurrence at current time
+await using dailySync = Tempo.ticker('FREQ=DAILY;INTERVAL=1');
+
+// Complex recurrence via options object
+await using weeklyTeamSync = Tempo.ticker({
+  rrule: 'FREQ=WEEKLY;BYDAY=MO,WE,FR;INTERVAL=1',
+  label: 'MWF Sync'
+}, (t) => {
+  console.log('Standup meeting tick:', t.format('{www}, {dd} {mon} {hh}:{mi}'));
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Virtual Clocks & Seeding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tickers emit real-time wall-clock timestamps. Providing a seed transforms the Ticker into a Virtual Clock that steps forward deterministically through simulated time:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Starts at '2026-01-01T00:00:00Z', advancing 1 day per real-time pulse
+await using simulation = Tempo.ticker({
+  days: 1,
+  seed: '2026-01-01T00:00:00Z',
+  limit: 30
+}, (t) => {
+  console.log(\`Simulated Day: \${t.format('{yyyy}-{mm}-{dd}')}\`);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Backwards Tickers (Countdowns) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supplying a negative duration creates a reverse Ticker that counts backwards in time:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Count down from 10 seconds, stepping back 1s per tick
+using countdown = Tempo.ticker(
+  { seconds: -1, seed: '00:00:10' },
+  (t, stop) => {
+    console.log(\`T-Minus: \${t.format('{ss}')}s\`);
+    if (t.ss === 0) {
+      console.log('🚀 Liftoff!');
+      stop();
+    }
+  }
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. One-Shot Timers & Meeting Alerts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specifying a seed without any recurring interval duration automatically configures a one-shot alert (limit: 1):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Pattern A: Quick string seed (e.g., target meeting alert)
+Tempo.ticker('Friday 10am', (t) => {
+  console.log(\`Meeting alert triggered: \${t.format('{hh}:{mi}')}\`);
+});
+
+// Pattern B: Explicit one-shot options
+Tempo.ticker({
+  seed: '2026-12-25T09:00:00Z'
+}, (t) => {
+  console.log('Christmas morning reminder!');
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Future Seeds: If the seed time is in the future, the Ticker remains dormant until that scheduled time is reached, fires its single pulse, and terminates automatically. For delays exceeding 32-bit integer timeout limits (~24.8 days), timeout capping re-arms the timer until the target epoch is reached.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8. Network Time & Clock Drift Compensation (ntp: true) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When orchestrating mission-critical workflows across distributed nodes, virtual machines, or IoT edge devices whose local hardware clocks may drift, you can pair Ticker with @magmacomputing/tempo-plugin-ntp:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+import { NtpPlugin } from '@magmacomputing/tempo-plugin-ntp';
+
+Tempo.use(TickerPlugin);
+Tempo.use(NtpPlugin);
+
+// Calibrate once with reliable reference server (same-origin or CORS-enabled)
+await Tempo.ntp.sync('/api/time');
+
+// Start ticker with NTP compensation enabled
+await using driftCompensated = Tempo.ticker({
+  ntp: true,
+  seconds: 10,
+  limit: 5
+}, (t) => {
+  console.log('True NTP-synchronized pulse:', t.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{fff}'));
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When ntp: true is enabled:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Baseline Initialization: Defaults to Tempo.ntp.now() instead of system clock when unseeded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Delay Compensation: Automatically shifts loop countdown delays against measured remote offset (Tempo.ntp.offset).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Graceful Fallback: If @magmacomputing/tempo-plugin-ntp is not loaded or uncalibrated, Ticker safely falls back to standard local system time without throwing errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,44)])])}const o=i(h,[["render",l]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.lean.js new file mode 100644 index 00000000..738829d4 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.intervals-and-scheduling.md.JNF-XJuK.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Intervals & Scheduling Engines","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.intervals-and-scheduling.md","filePath":"doc/9-plugins/ticker.intervals-and-scheduling.md"}'),h={name:"doc/9-plugins/ticker.intervals-and-scheduling.md"};function l(e,s,k,p,r,d){return a(),n("div",null,[...s[0]||(s[0]=[t("",44)])])}const o=i(h,[["render",l]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.js new file mode 100644 index 00000000..a5818d27 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.js @@ -0,0 +1,74 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Event Streams & Reactive Clocks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.reactive-clocks-and-events.md","filePath":"doc/9-plugins/ticker.reactive-clocks-and-events.md"}'),h={name:"doc/9-plugins/ticker.reactive-clocks-and-events.md"};function e(k,s,l,p,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Event Streams & Reactive Clocks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide covers event-driven integrations with the @magmacomputing/tempo-plugin-ticker plugin, including event listeners, active timer diagnostics, and zero-drift multi-timezone dashboards using reactive signals.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Event Listeners (.on) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Ticker instance acts as an event emitter supporting 'pulse', 'stop', and 'catch' events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+const ticker = Tempo.ticker({ seconds: 1 });
+
+// Register multiple listeners
+ticker.on('pulse', (t) => {
+  console.log('Pulse A:', t.format('{hh}:{mi}:{ss}'));
+});
+
+ticker.on('pulse', (t) => {
+  console.log('Pulse B (ISO):', t.iso);
+});
+
+ticker.on('stop', (t) => {
+  console.log('Ticker stopped at:', t.format('{hh}:{mi}:{ss}'));
+});
+
+ticker.on('catch', (t, stop) => {
+  console.warn('Recovered schedule tick at:', t.iso);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Event Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EventCallback SignatureTriggered When
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'pulse'(t: Tempo, stop: () => void) => voidEmitted on every recurring tick.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'stop'(t: Tempo) => voidEmitted when the ticker stops (limit reached or stop() called).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'catch'(t: Tempo, stop: () => void) => voidEmitted when schedule resolution fails or boundary conditions require recovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Active Ticker Registry & Telemetry (Ticker.active) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Ticker class maintains a global static registry of all currently running (non-stopped) Tickers. This is invaluable for monitoring, observability, and verifying clean test teardown:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Ticker } from '@magmacomputing/tempo-plugin-ticker';
+
+// Retrieve live snapshots of all active tickers
+const running = Ticker.active;
+
+console.log(\`Active running timers: \${running.length}\`);
+
+for (const { ticker, next, ticks, limit, interval } of running) {
+  console.log(\`Ticker pulse #\${ticks}, Next: \${next.iso}, Interval:\`, interval);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snapshot Structure (Ticker.Snapshot) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export interface Snapshot {
+  readonly ticker: Ticker.Instance;       // Reference to the active Ticker instance
+  readonly label?: string;                // Configured telemetry label
+  readonly next: Tempo;                   // The next scheduled Tempo value
+  readonly ticks: number;                 // Total number of pulses emitted so far
+  readonly limit?: number;                // Configured limit (if any)
+  readonly interval: Record<string, any>; // The duration-based interval configuration
+  readonly rrule?: string;                // Configured RFC 5545 recurrence rule
+  readonly cron?: string;                 // Configured 5-field cron expression
+  readonly stopped: boolean;              // Current stopped status
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Master Clock Synchronization (Zero-Drift Architecture) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building multi-timezone clocks or financial dashboards, never instantiate multiple independent 1-second timers. Independent timers will drift out of sync due to event loop scheduling differences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead, use a single Master Ticker to drive all derivative clocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Reactive UI Signals (Preact, Solid, Vue) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { signal, computed } from '@preact/signals-core';
+import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+// 1. Single Master Source of Truth
+const masterTime = signal(new Tempo());
+
+// 2. Drive the master clock from a master ticker instance (persisted in app scope)
+const masterTicker = Tempo.ticker(1, (t) => {
+  masterTime.value = t;
+});
+
+// 3. Derived multi-timezone views update simultaneously with zero drift
+const sydneyTime = computed(() => masterTime.value.set({ timeZone: 'Australia/Sydney' }));
+const londonTime = computed(() => masterTime.value.set({ timeZone: 'Europe/London' }));
+const nyTime     = computed(() => masterTime.value.set({ timeZone: 'America/New_York' }));
+const tokyoTime  = computed(() => masterTime.value.set({ timeZone: 'Asia/Tokyo' }));
+
+// Sydney, London, New York, and Tokyo will tick on the exact same millisecond

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Async Generator Multi-Clock Stream (Framework-Agnostic) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+async function runTradingDashboard() {
+  await using master = Tempo.ticker({ seconds: 1 });
+
+  for await (const t of master) {
+    const marketClocks = {
+      asx: t.set({ timeZone: 'Australia/Sydney' }),
+      lse: t.set({ timeZone: 'Europe/London' }),
+      nyse: t.set({ timeZone: 'America/New_York' }),
+      tse: t.set({ timeZone: 'Asia/Tokyo' }),
+    };
+
+    renderDashboard(marketClocks);
+  }
+}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,24)])])}const y=i(h,[["render",e]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.lean.js new file mode 100644 index 00000000..283980ef --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.reactive-clocks-and-events.md.oh5ZPvW6.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Event Streams & Reactive Clocks","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.reactive-clocks-and-events.md","filePath":"doc/9-plugins/ticker.reactive-clocks-and-events.md"}'),h={name:"doc/9-plugins/ticker.reactive-clocks-and-events.md"};function e(k,s,l,p,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t("",24)])])}const y=i(h,[["render",e]]);export{g as __pageData,y as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.js new file mode 100644 index 00000000..256ed1c8 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.js @@ -0,0 +1,65 @@ +import{_ as l,o as a,c as n,a2 as e,j as i,a as t}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Resource Management & Lifecycle","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.resource-management.md","filePath":"doc/9-plugins/ticker.resource-management.md"}'),p={name:"doc/9-plugins/ticker.resource-management.md"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"2.009ex",height:"1.545ex",role:"img",focusable:"false",viewBox:"0 -683 888 683","aria-hidden":"true"};function r(o,s,d,c,E,g){return a(),n("div",null,[s[4]||(s[4]=e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resource Management & Lifecycle ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Ticker execution loops are driven by asynchronous background timers (setTimeout / setImmediate), proper resource management is essential for preventing memory leaks, test suite hangs, and unhandled timer handles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Explicit Resource Management (using & await using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Ticker implements the standard TypeScript 5.2+ / ECMAScript Explicit Resource Management protocol (Symbol.dispose and Symbol.asyncDispose).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Synchronous Disposer (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ideal for callback-driven Tickers. The timer is automatically cleared the moment execution exits the block:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-ticker/install';
+
+{
+  using ticker = Tempo.ticker(1, (t) => {
+    updateUI(t);
+  });
+
+  // Perform operations within block...
+} // ⚡ Ticker is automatically stopped and timers cleared here

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Asynchronous Disposer (await using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ideal for for await streaming loops:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  await using stream = Tempo.ticker({ seconds: 1 });
+
+  for await (const t of stream) {
+    console.log('Pulse:', t.format('{hh}:{mi}:{ss}'));
+    if (shouldStop) break; // Exiting loop automatically disposes the ticker
+  }
+} // ⚡ Generator finalized and timer unreferenced

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Async Generator Streaming (for await ... of) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Ticker instance implements Symbol.asyncIterator, allowing you to consume pulses as a first-class async stream:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const ticker = Tempo.ticker({ seconds: 2 });
+
+async function processStream() {
+  for await (const t of ticker) {
+    console.log(\`Stream tick: \${t.iso}\`);
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you break from a for await loop or call ticker.stop(), pending promises are immediately resolved, allowing the loop to exit cleanly without dangling promises.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Programmatic Lifecycle Controls ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are managing long-lived tickers across components, you can use the object's control methods:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const ticker = Tempo.ticker({ seconds: 1 });
+
+// 1. Check live status and telemetry
+console.log(ticker.info);
+// { next: Tempo, ticks: 0, limit: undefined, interval: { seconds: 1 }, stopped: false }
+
+// 2. Manually advance or trigger a pulse (e.g., from a user UI event)
+ticker.pulse();
+
+// 3. Stop execution and tear down timers
+ticker.stop();
+console.log(ticker.info.stopped); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Bounded Termination Conditions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prevent runaway processes by defining built-in stopping criteria:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Pulse Count Limit (limit) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,26)),i("p",null,[s[2]||(s[2]=t("Stops automatically after emitting ",-1)),i("mjx-container",h,[(a(),n("svg",k,[...s[0]||(s[0]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mi"},[i("path",{"data-c":"1D441",d:"M234 637Q231 637 226 637Q201 637 196 638T191 649Q191 676 202 682Q204 683 299 683Q376 683 387 683T401 677Q612 181 616 168L670 381Q723 592 723 606Q723 633 659 637Q635 637 635 648Q635 650 637 660Q641 676 643 679T653 683Q656 683 684 682T767 680Q817 680 843 681T873 682Q888 682 888 672Q888 650 880 642Q878 637 858 637Q787 633 769 597L620 7Q618 0 599 0Q585 0 582 2Q579 5 453 305L326 604L261 344Q196 88 196 79Q201 46 268 46H278Q284 41 284 38T282 19Q278 6 272 0H259Q228 2 151 2Q123 2 100 2T63 2T46 1Q31 1 31 10Q31 14 34 26T39 40Q41 46 62 46Q130 49 150 85Q154 91 221 362L289 634Q287 635 234 637Z",style:{"stroke-width":"3"}})])])],-1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"N")])],-1))]),s[3]||(s[3]=t(" pulses:",-1))]),s[5]||(s[5]=e(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Stops after exactly 5 pulses
+using ticker = Tempo.ticker({ seconds: 1, limit: 5 }, (t) => {
+  console.log(\`Pulse #\${t.info?.ticks}\`);
+});
+
+// Immediate zero-execution limit (strictly honored without pulsing)
+using zeroTicker = Tempo.ticker({ limit: 0 }, (t) => console.log(t));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Stop Boundary (until) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Stops when simulated or wall-clock time reaches an upper boundary (inclusive):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    using boundedTicker = Tempo.ticker({
+  seconds: 10,
+  seed: '2026-12-25T10:00:00Z',
+  until: '2026-12-25T12:00:00Z' // Ceases when reaching 12:00:00
+}, (t) => {
+  console.log(t.format('{hh}:{mi}'));
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Dual-Layer Lifecycle Architecture & GC Safety-Net ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Ticker features an advanced Dual-Layer Lifecycle Model ensuring both deterministic resource teardown and automatic background cleanup:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ┌────────────────────────────────────────────────────────────────────────┐
+│                        Tempo Ticker Lifecycle                          │
+├───────────────────────────────────┬────────────────────────────────────┤
+│ 1. Deterministic Layer (Explicit) │ 2. Safety-Net Layer (Automatic)    │
+│   • \`using\` / \`await using\`       │   • \`FinalizationRegistry\` hooks   │
+│   • \`ticker.stop()\`               │   • \`WeakRef\` Active Registry      │
+│   • Immediate microsecond cleanup │   • GC-driven background reclaim   │
+└───────────────────────────────────┴────────────────────────────────────┘

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layer 1: Deterministic Cleanup (using & .stop()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In unit tests and latency-sensitive code paths, explicit disposal guarantees immediate teardown before subsequent assertions run:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ✅ RECOMMENDED: Immediate, deterministic cleanup
+{
+  using ticker = Tempo.ticker(1, (t) => { ... });
+}
+
+// ✅ EXPLICIT: Try...finally for cross-scope handles
+let ticker;
+try {
+  ticker = Tempo.ticker(1, (t) => { ... });
+  // assertions...
+} finally {
+  ticker?.stop();
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layer 2: Best-Effort GC Finalization (FinalizationRegistry) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While explicit teardown with .stop() or using is the required approach for deterministic resource management, Tempo provides a best-effort GC finalizer as a background safety net:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Safety-Net Teardown: Active setTimeout / setInterval timer loops are scheduled for cleanup if and when the JavaScript engine reclaims an unreferenced Ticker handle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Weak Registry: Tempo.tickers queries active handles via WeakRef—unreferenced tickers are not kept alive in memory solely by the registry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Leak Mitigation: Provides defense-in-depth against orphaned timer handles in long-running processes when handles are dropped inadvertently.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Garbage Collection timing is non-deterministic and never guaranteed by ECMAScript runtimes. Always call .stop(), using, or await using to ensure prompt, deterministic release of timers and event listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,15))])}const m=l(p,[["render",r]]);export{u as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.lean.js new file mode 100644 index 00000000..af5fc929 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.resource-management.md.D--mENjq.lean.js @@ -0,0 +1 @@ +import{_ as l,o as a,c as n,a2 as e,j as i,a as t}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Resource Management & Lifecycle","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.resource-management.md","filePath":"doc/9-plugins/ticker.resource-management.md"}'),p={name:"doc/9-plugins/ticker.resource-management.md"},h={class:"MathJax",jax:"SVG",style:{direction:"ltr",position:"relative"}},k={style:{overflow:"visible","min-height":"1px","min-width":"1px","vertical-align":"0"},xmlns:"http://www.w3.org/2000/svg",width:"2.009ex",height:"1.545ex",role:"img",focusable:"false",viewBox:"0 -683 888 683","aria-hidden":"true"};function r(o,s,d,c,E,g){return a(),n("div",null,[s[4]||(s[4]=e("",26)),i("p",null,[s[2]||(s[2]=t("Stops automatically after emitting ",-1)),i("mjx-container",h,[(a(),n("svg",k,[...s[0]||(s[0]=[i("g",{stroke:"currentColor",fill:"currentColor","stroke-width":"0",transform:"scale(1,-1)"},[i("g",{"data-mml-node":"math"},[i("g",{"data-mml-node":"mi"},[i("path",{"data-c":"1D441",d:"M234 637Q231 637 226 637Q201 637 196 638T191 649Q191 676 202 682Q204 683 299 683Q376 683 387 683T401 677Q612 181 616 168L670 381Q723 592 723 606Q723 633 659 637Q635 637 635 648Q635 650 637 660Q641 676 643 679T653 683Q656 683 684 682T767 680Q817 680 843 681T873 682Q888 682 888 672Q888 650 880 642Q878 637 858 637Q787 633 769 597L620 7Q618 0 599 0Q585 0 582 2Q579 5 453 305L326 604L261 344Q196 88 196 79Q201 46 268 46H278Q284 41 284 38T282 19Q278 6 272 0H259Q228 2 151 2Q123 2 100 2T63 2T46 1Q31 1 31 10Q31 14 34 26T39 40Q41 46 62 46Q130 49 150 85Q154 91 221 362L289 634Q287 635 234 637Z",style:{"stroke-width":"3"}})])])],-1)])])),s[1]||(s[1]=i("mjx-assistive-mml",{unselectable:"on",display:"inline",style:{top:"0px",left:"0px",clip:"rect(1px, 1px, 1px, 1px)","-webkit-touch-callout":"none","-webkit-user-select":"none","-khtml-user-select":"none","-moz-user-select":"none","-ms-user-select":"none","user-select":"none",position:"absolute",padding:"1px 0px 0px 0px",border:"0px",display:"block",width:"auto",overflow:"hidden"}},[i("math",{xmlns:"http://www.w3.org/1998/Math/MathML"},[i("mi",null,"N")])],-1))]),s[3]||(s[3]=t(" pulses:",-1))]),s[5]||(s[5]=e("",15))])}const m=l(p,[["render",r]]);export{u as __pageData,m as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.js new file mode 100644 index 00000000..d89262e8 --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.js @@ -0,0 +1,95 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.use-cases-and-patterns.md","filePath":"doc/9-plugins/ticker.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/ticker.use-cases-and-patterns.md"};function h(l,s,p,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t(`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ← @magmacomputing/tempo-plugin-ticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Production Use Cases & Architectural Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard JavaScript scheduling primitives (setInterval and setTimeout) are notorious for silent failures in long-running production systems:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cumulative Clock Drift: Timers drift by dozens of milliseconds per cycle due to main-thread execution lag and event loop starvation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Zombie Timers & Memory Leaks: Orphaned intervals remain running after UI components unmount or HTTP request handlers finish, slowly leaking memory.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Desktop & Mobile Sleep Distortion: When an operating system enters low-power sleep mode, standard intervals freeze, skipping scheduled database jobs or failing to drain background work queues.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ticker plugin solves these challenges with calendar-aware scheduling, Explicit Resource Management (using / await using), async generators, and self-healing sleep recovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Zero-Drift Telemetry & Heartbeat Loops ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In backend services and IoT edge gateways, healthcheck heartbeats and metric aggregations must pulse on exact intervals (e.g. precisely every 15 seconds) regardless of how long the async payload takes to send.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With setInterval, network latency or slow database queries delay subsequent ticks. With Tempo.ticker, each pulse is pinned to an absolute epoch target, completely eliminating cumulative drift:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ticker/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+export function startTelemetryEmitter(endpointUrl: string) {
+  // Pulses every 15 seconds with automatic catch-up on system wake
+  const heartbeat = Tempo.ticker({
+    seconds: 15,
+    catch: true,
+    label: 'telemetry-emitter'
+  });
+
+  heartbeat.on('pulse', async (t: Tempo) => {
+    const payload = {
+      timestamp: t.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}'),
+      epochMs: t.epoch.ms,
+      tickCount: heartbeat.info.ticks
+    };
+
+    try {
+      await fetch(endpointUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload)
+      });
+    } catch (err) {
+      console.error('Failed to dispatch heartbeat:', err);
+    }
+  });
+
+  return heartbeat;
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Preventing Zombie Leaks with Explicit Resource Management (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the most common memory leaks in modern TypeScript applications is forgotten timer handles in async operations, unit tests, or component lifecycles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ticker implements JavaScript's Explicit Resource Management (Disposable and AsyncDisposable). When defined with using or await using, the ticker automatically cleans up its internal timers, event listeners, and weak references the exact moment code leaves scope:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ticker/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+async function monitorJobQueue(jobId: string): Promise<void> {
+  // Automatically disposed when monitorJobQueue exits (even if an error throws)
+  using clock = Tempo.ticker({ seconds: 2 });
+
+  while (!isJobComplete(jobId)) {
+    // Pull the next scheduled tick promise
+    await clock.pull();
+    console.log(\`Polling status for \${jobId} at \${new Tempo().format('{hh}:{mi}:{ss}')}\`);
+  }
+} // <-- clock is automatically stopped and deregistered here!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Streaming Financial Market Feeds (for await...of) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of managing imperative callbacks and event listener state, Tempo.ticker can be consumed directly as an Async Generator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This pattern provides natural backpressure handling in data pipelines: if downstream processing slows down, the consumer controls the flow without dropped events:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ticker/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+interface MarketSummary {
+  symbol: string;
+  price: number;
+  sampledAt: string;
+}
+
+export async function* streamMarketTicks(
+  symbol: string,
+  sampleRateSeconds: number
+): AsyncGenerator<MarketSummary> {
+  // Streams ticks at precise interval intervals
+  for await (const tick of Tempo.ticker({ seconds: sampleRateSeconds })) {
+    const latestPrice = await fetchLatestQuote(symbol);
+
+    yield {
+      symbol,
+      price: latestPrice,
+      sampledAt: tick.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}')
+    };
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Multi-Timezone Market Opening & Closing Schedules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scheduling financial batch jobs across global exchanges (e.g. NYSE at 9:30 AM EST, Tokyo Stock Exchange at 9:00 AM JST) is prone to bugs when countries change between Daylight Saving Time (DST) on different weeks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ticker supports standard 5-field Cron syntax with explicit timeZone anchoring:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ticker/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+// 9:30 AM Monday-Friday in New York time (respects US DST transitions automatically)
+const nyseBell = Tempo.ticker({
+  cron: '30 9 * * 1-5',
+  timeZone: 'America/New_York',
+  label: 'nyse-opening-bell'
+});
+
+nyseBell.on('pulse', (t: Tempo) => {
+  console.log(\`NYSE Open at: \${t.format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}')}\`);
+  triggerDailyOpeningAuction();
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Mobile & Laptop Sleep Recovery (catch: true) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a mobile app or laptop enters sleep mode, background execution freezes. When the user opens their laptop 2 hours later, a standard setInterval only fires once for the latest tick, losing all context of the missed window.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With { catch: true }, Tempo.ticker detects the elapsed time gap and fires the catch event with the missed pulse sequence, allowing applications to drain queues or synchronize state:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo-plugin-ticker/install';
+import { Tempo } from '@magmacomputing/tempo';
+
+const syncLoop = Tempo.ticker({
+  minutes: 5,
+  catch: true,
+  label: 'offline-cache-sync'
+});
+
+syncLoop.on('catch', (missedTick: Tempo) => {
+  console.warn(\`Recovering missed sync point from: \${missedTick.format('{hh}:{mi}:{ss}')}\`);
+  reconcileDatabaseChanges(missedTick);
+});
+
+syncLoop.on('pulse', (currentTick: Tempo) => {
+  runScheduledSync(currentTick);
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,31)])])}const o=i(e,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.lean.js b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.lean.js new file mode 100644 index 00000000..d871a1ba --- /dev/null +++ b/packages/tempo/public/v4/assets/doc_9-plugins_ticker.use-cases-and-patterns.md.D3y-b9SZ.lean.js @@ -0,0 +1 @@ +import{_ as i,o as a,c as n,a2 as t}from"./chunks/framework.DNL3hc5c.js";const g=JSON.parse('{"title":"Production Use Cases & Architectural Patterns","description":"","frontmatter":{},"headers":[],"relativePath":"doc/9-plugins/ticker.use-cases-and-patterns.md","filePath":"doc/9-plugins/ticker.use-cases-and-patterns.md"}'),e={name:"doc/9-plugins/ticker.use-cases-and-patterns.md"};function h(l,s,p,k,r,E){return a(),n("div",null,[...s[0]||(s[0]=[t("",31)])])}const o=i(e,[["render",h]]);export{g as __pageData,o as default}; diff --git a/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.js b/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.js new file mode 100644 index 00000000..8d46bfd1 --- /dev/null +++ b/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.js @@ -0,0 +1 @@ +import{_ as Te,g as ae,p as i,V as oe,v as we,x as be,q as ke,o as c,c as m,j as t,k as ie,F as X,B as $,n as F,t as T,a3 as Se,a6 as Ie,e as Pe,N as xe,h as B}from"./chunks/framework.DNL3hc5c.js";const Ae={class:"tempo-hero"},De={class:"tempo-hero-content"},Ee={class:"tempo-hero-left"},Le={class:"tempo-title-row"},Ce=["src"],Me={class:"tempo-tagline-row"},Ne={class:"tempo-hero-actions"},ze=["href"],Oe={class:"tempo-hero-right"},Re={class:"tempo-clock-mini"},Xe={class:"tempo-clock-svg",viewBox:"0 0 200 200"},$e=["y1","transform"],Fe=["transform"],Be=["transform"],He=["transform"],Ve={class:"tempo-time-display"},Ze={class:"tempo-status-row"},Ge={class:"tempo-iso-time"},Ue=["aria-label"],qe=["value"],je={class:"tempo-carousel-controls"},Ke=["aria-label"],Je={key:0},We={key:1},Ye={key:0,class:"tempo-swipe-hint","aria-live":"polite"},Qe=["aria-live"],et={class:"tempo-feature-content"},tt={class:"tempo-feature-icon"},at={class:"tempo-feature-title"},ot={class:"tempo-feature-details"},rt=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home"},"headers":[],"relativePath":"index.md","filePath":"index.md"}'),it={name:"index.md"},nt=Object.assign(it,{setup(lt){const ne=ae("/tempo-logo.svg"),le=ae("/README"),H=i(0),V=i(0),Z=i(0),D=i("Loading..."),G=i(""),f=i(!0),d=i(!1),p=i(!1),S=i(Intl.DateTimeFormat().resolvedOptions().timeZone),se=i([Intl.DateTimeFormat().resolvedOptions().timeZone,"UTC","Europe/London","Europe/Paris","America/New_York","America/Los_Angeles","Asia/Tokyo","Australia/Sydney"]),re=B(()=>[...new Set(se.value)]),w=1,ue=3,g=i(w),I=i(!1),C=i(!1),l=i(!1),U=B(()=>I.value||C.value||l.value),b=i(!0),M=i(null),h=i(0),ce=B(()=>l.value?h.value<-8?"Swipe left":h.value>8?"Swipe right":"Swipe":"Swipe"),P=[{title:"Zero-Cost",details:"Lazy evaluation and smart matching ensure instantiation overhead is near-zero.",icon:"⚡"},{title:"Natural Language",details:"Semantic parsing for events and periods. Resolve human-readable strings with zero configuration.",icon:"🎯"},{title:"Tempo AI Engine",details:"Natural language date parsing, multi-provider dispatch (OpenAI, Gemini, Groq, Mistral), and slot resolution.",icon:"🤖"},{title:"Tempo.ticker()",details:"Community Plugin: State-of-the-art timing engine with AsyncGenerator support and native Daylight Saving Time resolution.",icon:"⏱️"},{title:"Modular Plugins",details:"Extend Tempo with specialized plugins for Snapping, High-Throughput Batching, and AI dispatch.",icon:"🔌"},{title:"Humanizing Temporal",details:"Transforming low-level Temporal complexity into intuitive, expressive APIs—anchored in a rock-solid ISO 8601 baseline with native regional calendar awareness.",icon:"🧭"},{title:"Cycle Persistence",details:"Shift by semantic terms while preserving your relative day-of-period offset.",icon:"🔄"},{title:"Business & Financial",details:"Native support for fiscal quarters, zodiac cycles, and meteorological seasons for finance and analytics.",icon:"📈"}],N=[...P.slice(-w),...P,...P.slice(0,ue)];let _=!1,x=null,k=null,s=null,r=null,n=null,q=!1,u=null,z=0,E=0,A=null;const me=40;function j(e,o,a){const v=e%12;H.value=v/12*360+o/60*30,V.value=o/60*360+a/60*6,Z.value=a/60*360}let O=(async()=>{try{let e,o;const{Tempo:a}=await oe(async()=>{const{Tempo:y}=await import("./chunks/tempo.index.Cp7zs7az.js");return{Tempo:y}},[]),{TickerPlugin:v}=await oe(async()=>{const{TickerPlugin:y}=await import("./chunks/index.phNTaoDP.js");return{TickerPlugin:y}},[]);return a.init({extends:[v]}),a}catch(e){throw console.error("Tempo failed to initialize:",e),q=!0,O=void 0,e}})();async function L(){if(!q)try{if(!O)return;const e=await O;if(!_)return;x?.stop(),n&&clearInterval(n);const o=a=>{const{hour:v,minute:y,second:ye}=a.toDateTime();j(v,y,ye),D.value=a.format("{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}"),G.value=a.tz};if(o(new e({timeZone:S.value})),d.value)return;x=e.ticker({seconds:1,timeZone:S.value},o)}catch(e){D.value=`Error: ${e.message||"Unknown"}`;const o=()=>{const a=new Date;j(a.getHours(),a.getMinutes(),a.getSeconds()),D.value=`Fallback: ${a.toLocaleTimeString()} (${e.message})`,G.value=Intl.DateTimeFormat().resolvedOptions().timeZone};o(),n&&clearInterval(n),n=setInterval(o,1e3)}}function de(){d.value=!d.value,d.value?(f.value=!1,x?.stop(),n&&clearInterval(n)):(f.value=!0,L())}function K(){k&&clearInterval(k),k=setInterval(()=>{U.value||R()},4e3)}function J(){s&&(clearTimeout(s),s=null),r&&(clearTimeout(r),r=null)}function W(e){J(),s=setTimeout(()=>{if(!_){s=null;return}s=null,b.value=!1,g.value=e,r=setTimeout(()=>{if(!_){r=null;return}b.value=!0,r=null},50)},850)}function R(){g.value++,g.value>=w+P.length&&W(w)}function Y(){g.value--,g.value{if(!_||document.visibilityState!=="visible"||d.value){u=null,p.value=!1;return}u=null,p.value=!1,f.value=!0,console.info("%c[Tempo]%c ⚡ Resuming Ticker","color: #2563eb; font-weight: bold","color: inherit"),L()},1200)}else p.value=!1,f.value=!1,console.info("%c[Tempo]%c 💤 Pausing Ticker (Standby)","color: #71717a; font-weight: bold","color: inherit"),x?.stop(),n&&clearInterval(n),s&&(clearTimeout(s),s=null),r&&(clearTimeout(r),r=null),clearInterval(k),k=null}we(()=>{_=!0,L(),K(),document.addEventListener("visibilitychange",Q)}),be(()=>{_=!1,J(),u&&(clearTimeout(u),u=null),x?.stop(),n&&clearInterval(n),clearInterval(k),document.removeEventListener("visibilitychange",Q)}),ke(S,()=>{_&&L()});const ee=i([]);function _e(e){e.key==="ArrowLeft"?(e.preventDefault(),Y(),te()):e.key==="ArrowRight"&&(e.preventDefault(),R(),te())}function te(){setTimeout(()=>{const e=ee.value[g.value];e&&e.focus()},100)}return(e,o)=>(c(),m("div",null,[t("div",Ae,[t("div",De,[t("div",Ee,[t("div",Le,[t("img",{src:ie(ne),class:"tempo-hero-logo",alt:"Tempo Logo"},null,8,Ce),o[3]||(o[3]=t("h1",{class:"tempo-hero-name"},"Tempo",-1))]),t("div",Me,[o[5]||(o[5]=t("p",{class:"tempo-hero-tagline"},"The Professional Date-Time Library for the Temporal API",-1)),t("div",Ne,[t("a",{href:ie(le),class:"tempo-btn tempo-btn-brand"},"Get Started",8,ze),o[4]||(o[4]=t("a",{href:"https://github.com/magmacomputing/magma/tree/main/packages/tempo",class:"tempo-btn tempo-btn-alt"},"View on GitHub",-1))])])]),t("div",Oe,[t("div",Re,[(c(),m("svg",Xe,[o[6]||(o[6]=t("circle",{cx:"100",cy:"100",r:"94",class:"tempo-clock-face"},null,-1)),(c(),m(X,null,$(60,a=>t("g",{key:a},[t("line",{x1:"100",y1:(a-1)%5===0?8:13,x2:"100",y2:"22",transform:`rotate(${(a-1)*6}, 100, 100)`,class:F((a-1)%5===0?"tempo-tick-major":"tempo-tick-minor")},null,10,$e)])),64)),t("line",{x1:"100",y1:"100",x2:"100",y2:"50",transform:`rotate(${H.value}, 100, 100)`,class:"tempo-hand-hour"},null,8,Fe),t("line",{x1:"100",y1:"100",x2:"100",y2:"32",transform:`rotate(${V.value}, 100, 100)`,class:"tempo-hand-minute"},null,8,Be),t("line",{x1:"100",y1:"114",x2:"100",y2:"24",transform:`rotate(${Z.value}, 100, 100)`,class:"tempo-hand-second"},null,8,He),o[7]||(o[7]=t("circle",{cx:"100",cy:"100",r:"6",class:"tempo-hub"},null,-1)),o[8]||(o[8]=t("circle",{cx:"100",cy:"100",r:"2.5",class:"tempo-hub-inner"},null,-1))])),t("div",Ve,[t("div",Ze,[t("p",Ge,T(D.value),1),t("button",{onClick:de,class:F(["tempo-ticker-status",f.value?"is-active":d.value?"is-paused":"is-standby",p.value?"is-resuming":""]),"aria-label":f.value?"Pause Ticker":"Start Ticker"},T(f.value?"Live":p.value?"Syncing...":d.value?"Start":"Standby"),11,Ue)]),Se(t("select",{"onUpdate:modelValue":o[0]||(o[0]=a=>S.value=a),class:"tempo-tz-select","aria-label":"Select Timezone"},[(c(!0),m(X,null,$(re.value,a=>(c(),m("option",{key:a,value:a},T(a),9,qe))),128))],512),[[Ie,S.value]])])])])])]),t("div",{class:"tempo-carousel-container",role:"region","aria-label":"Tempo features",onMouseenter:o[1]||(o[1]=a=>C.value=!0),onMouseleave:o[2]||(o[2]=a=>C.value=!1),onKeydown:_e},[t("div",je,[t("button",{class:"tempo-carousel-toggle",onClick:ve,"aria-label":I.value?"Play carousel":"Pause carousel"},[I.value?(c(),m("span",Je,"▶️")):(c(),m("span",We,"⏸️"))],8,Ke)]),l.value?(c(),m("div",Ye,T(ce.value),1)):Pe("",!0),t("div",{class:F(["tempo-carousel-track",{"is-dragging":l.value}]),ref_key:"carouselTrackRef",ref:M,role:"list","aria-live":U.value?"off":"polite",onPointerdown:fe,onPointermove:pe,onPointerup:ge,onPointercancel:he,style:xe({"--carousel-count":N.length,transform:`translateX(calc(-${g.value*(100/N.length)}% + ${h.value}px))`,transition:b.value?"transform 0.8s cubic-bezier(0.4, 0, 0.2, 1)":"none"})},[(c(),m(X,null,$(N,(a,v)=>t("div",{key:v,ref_for:!0,ref:y=>ee.value[v]=y,class:"tempo-feature-card",role:"listitem",tabindex:"0"},[t("div",et,[t("div",tt,T(a.icon),1),t("h3",at,T(a.title),1),t("p",ot,T(a.details),1)])],512)),64))],46,Qe)],32)]))}}),ut=Te(nt,[["__scopeId","data-v-8fadbdcc"]]);export{rt as __pageData,ut as default}; diff --git a/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.lean.js b/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.lean.js new file mode 100644 index 00000000..8d46bfd1 --- /dev/null +++ b/packages/tempo/public/v4/assets/index.md.BXrX0Bcg.lean.js @@ -0,0 +1 @@ +import{_ as Te,g as ae,p as i,V as oe,v as we,x as be,q as ke,o as c,c as m,j as t,k as ie,F as X,B as $,n as F,t as T,a3 as Se,a6 as Ie,e as Pe,N as xe,h as B}from"./chunks/framework.DNL3hc5c.js";const Ae={class:"tempo-hero"},De={class:"tempo-hero-content"},Ee={class:"tempo-hero-left"},Le={class:"tempo-title-row"},Ce=["src"],Me={class:"tempo-tagline-row"},Ne={class:"tempo-hero-actions"},ze=["href"],Oe={class:"tempo-hero-right"},Re={class:"tempo-clock-mini"},Xe={class:"tempo-clock-svg",viewBox:"0 0 200 200"},$e=["y1","transform"],Fe=["transform"],Be=["transform"],He=["transform"],Ve={class:"tempo-time-display"},Ze={class:"tempo-status-row"},Ge={class:"tempo-iso-time"},Ue=["aria-label"],qe=["value"],je={class:"tempo-carousel-controls"},Ke=["aria-label"],Je={key:0},We={key:1},Ye={key:0,class:"tempo-swipe-hint","aria-live":"polite"},Qe=["aria-live"],et={class:"tempo-feature-content"},tt={class:"tempo-feature-icon"},at={class:"tempo-feature-title"},ot={class:"tempo-feature-details"},rt=JSON.parse('{"title":"","description":"","frontmatter":{"layout":"home"},"headers":[],"relativePath":"index.md","filePath":"index.md"}'),it={name:"index.md"},nt=Object.assign(it,{setup(lt){const ne=ae("/tempo-logo.svg"),le=ae("/README"),H=i(0),V=i(0),Z=i(0),D=i("Loading..."),G=i(""),f=i(!0),d=i(!1),p=i(!1),S=i(Intl.DateTimeFormat().resolvedOptions().timeZone),se=i([Intl.DateTimeFormat().resolvedOptions().timeZone,"UTC","Europe/London","Europe/Paris","America/New_York","America/Los_Angeles","Asia/Tokyo","Australia/Sydney"]),re=B(()=>[...new Set(se.value)]),w=1,ue=3,g=i(w),I=i(!1),C=i(!1),l=i(!1),U=B(()=>I.value||C.value||l.value),b=i(!0),M=i(null),h=i(0),ce=B(()=>l.value?h.value<-8?"Swipe left":h.value>8?"Swipe right":"Swipe":"Swipe"),P=[{title:"Zero-Cost",details:"Lazy evaluation and smart matching ensure instantiation overhead is near-zero.",icon:"⚡"},{title:"Natural Language",details:"Semantic parsing for events and periods. Resolve human-readable strings with zero configuration.",icon:"🎯"},{title:"Tempo AI Engine",details:"Natural language date parsing, multi-provider dispatch (OpenAI, Gemini, Groq, Mistral), and slot resolution.",icon:"🤖"},{title:"Tempo.ticker()",details:"Community Plugin: State-of-the-art timing engine with AsyncGenerator support and native Daylight Saving Time resolution.",icon:"⏱️"},{title:"Modular Plugins",details:"Extend Tempo with specialized plugins for Snapping, High-Throughput Batching, and AI dispatch.",icon:"🔌"},{title:"Humanizing Temporal",details:"Transforming low-level Temporal complexity into intuitive, expressive APIs—anchored in a rock-solid ISO 8601 baseline with native regional calendar awareness.",icon:"🧭"},{title:"Cycle Persistence",details:"Shift by semantic terms while preserving your relative day-of-period offset.",icon:"🔄"},{title:"Business & Financial",details:"Native support for fiscal quarters, zodiac cycles, and meteorological seasons for finance and analytics.",icon:"📈"}],N=[...P.slice(-w),...P,...P.slice(0,ue)];let _=!1,x=null,k=null,s=null,r=null,n=null,q=!1,u=null,z=0,E=0,A=null;const me=40;function j(e,o,a){const v=e%12;H.value=v/12*360+o/60*30,V.value=o/60*360+a/60*6,Z.value=a/60*360}let O=(async()=>{try{let e,o;const{Tempo:a}=await oe(async()=>{const{Tempo:y}=await import("./chunks/tempo.index.Cp7zs7az.js");return{Tempo:y}},[]),{TickerPlugin:v}=await oe(async()=>{const{TickerPlugin:y}=await import("./chunks/index.phNTaoDP.js");return{TickerPlugin:y}},[]);return a.init({extends:[v]}),a}catch(e){throw console.error("Tempo failed to initialize:",e),q=!0,O=void 0,e}})();async function L(){if(!q)try{if(!O)return;const e=await O;if(!_)return;x?.stop(),n&&clearInterval(n);const o=a=>{const{hour:v,minute:y,second:ye}=a.toDateTime();j(v,y,ye),D.value=a.format("{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}"),G.value=a.tz};if(o(new e({timeZone:S.value})),d.value)return;x=e.ticker({seconds:1,timeZone:S.value},o)}catch(e){D.value=`Error: ${e.message||"Unknown"}`;const o=()=>{const a=new Date;j(a.getHours(),a.getMinutes(),a.getSeconds()),D.value=`Fallback: ${a.toLocaleTimeString()} (${e.message})`,G.value=Intl.DateTimeFormat().resolvedOptions().timeZone};o(),n&&clearInterval(n),n=setInterval(o,1e3)}}function de(){d.value=!d.value,d.value?(f.value=!1,x?.stop(),n&&clearInterval(n)):(f.value=!0,L())}function K(){k&&clearInterval(k),k=setInterval(()=>{U.value||R()},4e3)}function J(){s&&(clearTimeout(s),s=null),r&&(clearTimeout(r),r=null)}function W(e){J(),s=setTimeout(()=>{if(!_){s=null;return}s=null,b.value=!1,g.value=e,r=setTimeout(()=>{if(!_){r=null;return}b.value=!0,r=null},50)},850)}function R(){g.value++,g.value>=w+P.length&&W(w)}function Y(){g.value--,g.value{if(!_||document.visibilityState!=="visible"||d.value){u=null,p.value=!1;return}u=null,p.value=!1,f.value=!0,console.info("%c[Tempo]%c ⚡ Resuming Ticker","color: #2563eb; font-weight: bold","color: inherit"),L()},1200)}else p.value=!1,f.value=!1,console.info("%c[Tempo]%c 💤 Pausing Ticker (Standby)","color: #71717a; font-weight: bold","color: inherit"),x?.stop(),n&&clearInterval(n),s&&(clearTimeout(s),s=null),r&&(clearTimeout(r),r=null),clearInterval(k),k=null}we(()=>{_=!0,L(),K(),document.addEventListener("visibilitychange",Q)}),be(()=>{_=!1,J(),u&&(clearTimeout(u),u=null),x?.stop(),n&&clearInterval(n),clearInterval(k),document.removeEventListener("visibilitychange",Q)}),ke(S,()=>{_&&L()});const ee=i([]);function _e(e){e.key==="ArrowLeft"?(e.preventDefault(),Y(),te()):e.key==="ArrowRight"&&(e.preventDefault(),R(),te())}function te(){setTimeout(()=>{const e=ee.value[g.value];e&&e.focus()},100)}return(e,o)=>(c(),m("div",null,[t("div",Ae,[t("div",De,[t("div",Ee,[t("div",Le,[t("img",{src:ie(ne),class:"tempo-hero-logo",alt:"Tempo Logo"},null,8,Ce),o[3]||(o[3]=t("h1",{class:"tempo-hero-name"},"Tempo",-1))]),t("div",Me,[o[5]||(o[5]=t("p",{class:"tempo-hero-tagline"},"The Professional Date-Time Library for the Temporal API",-1)),t("div",Ne,[t("a",{href:ie(le),class:"tempo-btn tempo-btn-brand"},"Get Started",8,ze),o[4]||(o[4]=t("a",{href:"https://github.com/magmacomputing/magma/tree/main/packages/tempo",class:"tempo-btn tempo-btn-alt"},"View on GitHub",-1))])])]),t("div",Oe,[t("div",Re,[(c(),m("svg",Xe,[o[6]||(o[6]=t("circle",{cx:"100",cy:"100",r:"94",class:"tempo-clock-face"},null,-1)),(c(),m(X,null,$(60,a=>t("g",{key:a},[t("line",{x1:"100",y1:(a-1)%5===0?8:13,x2:"100",y2:"22",transform:`rotate(${(a-1)*6}, 100, 100)`,class:F((a-1)%5===0?"tempo-tick-major":"tempo-tick-minor")},null,10,$e)])),64)),t("line",{x1:"100",y1:"100",x2:"100",y2:"50",transform:`rotate(${H.value}, 100, 100)`,class:"tempo-hand-hour"},null,8,Fe),t("line",{x1:"100",y1:"100",x2:"100",y2:"32",transform:`rotate(${V.value}, 100, 100)`,class:"tempo-hand-minute"},null,8,Be),t("line",{x1:"100",y1:"114",x2:"100",y2:"24",transform:`rotate(${Z.value}, 100, 100)`,class:"tempo-hand-second"},null,8,He),o[7]||(o[7]=t("circle",{cx:"100",cy:"100",r:"6",class:"tempo-hub"},null,-1)),o[8]||(o[8]=t("circle",{cx:"100",cy:"100",r:"2.5",class:"tempo-hub-inner"},null,-1))])),t("div",Ve,[t("div",Ze,[t("p",Ge,T(D.value),1),t("button",{onClick:de,class:F(["tempo-ticker-status",f.value?"is-active":d.value?"is-paused":"is-standby",p.value?"is-resuming":""]),"aria-label":f.value?"Pause Ticker":"Start Ticker"},T(f.value?"Live":p.value?"Syncing...":d.value?"Start":"Standby"),11,Ue)]),Se(t("select",{"onUpdate:modelValue":o[0]||(o[0]=a=>S.value=a),class:"tempo-tz-select","aria-label":"Select Timezone"},[(c(!0),m(X,null,$(re.value,a=>(c(),m("option",{key:a,value:a},T(a),9,qe))),128))],512),[[Ie,S.value]])])])])])]),t("div",{class:"tempo-carousel-container",role:"region","aria-label":"Tempo features",onMouseenter:o[1]||(o[1]=a=>C.value=!0),onMouseleave:o[2]||(o[2]=a=>C.value=!1),onKeydown:_e},[t("div",je,[t("button",{class:"tempo-carousel-toggle",onClick:ve,"aria-label":I.value?"Play carousel":"Pause carousel"},[I.value?(c(),m("span",Je,"▶️")):(c(),m("span",We,"⏸️"))],8,Ke)]),l.value?(c(),m("div",Ye,T(ce.value),1)):Pe("",!0),t("div",{class:F(["tempo-carousel-track",{"is-dragging":l.value}]),ref_key:"carouselTrackRef",ref:M,role:"list","aria-live":U.value?"off":"polite",onPointerdown:fe,onPointermove:pe,onPointerup:ge,onPointercancel:he,style:xe({"--carousel-count":N.length,transform:`translateX(calc(-${g.value*(100/N.length)}% + ${h.value}px))`,transition:b.value?"transform 0.8s cubic-bezier(0.4, 0, 0.2, 1)":"none"})},[(c(),m(X,null,$(N,(a,v)=>t("div",{key:v,ref_for:!0,ref:y=>ee.value[v]=y,class:"tempo-feature-card",role:"listitem",tabindex:"0"},[t("div",et,[t("div",tt,T(a.icon),1),t("h3",at,T(a.title),1),t("p",ot,T(a.details),1)])],512)),64))],46,Qe)],32)]))}}),ut=Te(nt,[["__scopeId","data-v-8fadbdcc"]]);export{rt as __pageData,ut as default}; diff --git a/packages/tempo/public/v4/assets/inter-italic-cyrillic-ext.r48I6akx.woff2 b/packages/tempo/public/v4/assets/inter-italic-cyrillic-ext.r48I6akx.woff2 new file mode 100644 index 00000000..b6b603d5 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-cyrillic-ext.r48I6akx.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-cyrillic.By2_1cv3.woff2 b/packages/tempo/public/v4/assets/inter-italic-cyrillic.By2_1cv3.woff2 new file mode 100644 index 00000000..def40a4f Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-cyrillic.By2_1cv3.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-greek-ext.1u6EdAuj.woff2 b/packages/tempo/public/v4/assets/inter-italic-greek-ext.1u6EdAuj.woff2 new file mode 100644 index 00000000..e070c3d3 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-greek-ext.1u6EdAuj.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-greek.DJ8dCoTZ.woff2 b/packages/tempo/public/v4/assets/inter-italic-greek.DJ8dCoTZ.woff2 new file mode 100644 index 00000000..a3c16ca4 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-greek.DJ8dCoTZ.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-latin-ext.CN1xVJS-.woff2 b/packages/tempo/public/v4/assets/inter-italic-latin-ext.CN1xVJS-.woff2 new file mode 100644 index 00000000..2210a899 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-latin-ext.CN1xVJS-.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-latin.C2AdPX0b.woff2 b/packages/tempo/public/v4/assets/inter-italic-latin.C2AdPX0b.woff2 new file mode 100644 index 00000000..790d62dc Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-latin.C2AdPX0b.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-italic-vietnamese.BSbpV94h.woff2 b/packages/tempo/public/v4/assets/inter-italic-vietnamese.BSbpV94h.woff2 new file mode 100644 index 00000000..1eec0775 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-italic-vietnamese.BSbpV94h.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-cyrillic-ext.BBPuwvHQ.woff2 b/packages/tempo/public/v4/assets/inter-roman-cyrillic-ext.BBPuwvHQ.woff2 new file mode 100644 index 00000000..2cfe6153 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-cyrillic-ext.BBPuwvHQ.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-cyrillic.C5lxZ8CY.woff2 b/packages/tempo/public/v4/assets/inter-roman-cyrillic.C5lxZ8CY.woff2 new file mode 100644 index 00000000..e3886dd1 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-cyrillic.C5lxZ8CY.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-greek-ext.CqjqNYQ-.woff2 b/packages/tempo/public/v4/assets/inter-roman-greek-ext.CqjqNYQ-.woff2 new file mode 100644 index 00000000..36d67487 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-greek-ext.CqjqNYQ-.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-greek.BBVDIX6e.woff2 b/packages/tempo/public/v4/assets/inter-roman-greek.BBVDIX6e.woff2 new file mode 100644 index 00000000..2bed1e85 Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-greek.BBVDIX6e.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-latin-ext.4ZJIpNVo.woff2 b/packages/tempo/public/v4/assets/inter-roman-latin-ext.4ZJIpNVo.woff2 new file mode 100644 index 00000000..9a8d1e2b Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-latin-ext.4ZJIpNVo.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-latin.Di8DUHzh.woff2 b/packages/tempo/public/v4/assets/inter-roman-latin.Di8DUHzh.woff2 new file mode 100644 index 00000000..07d3c53a Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-latin.Di8DUHzh.woff2 differ diff --git a/packages/tempo/public/v4/assets/inter-roman-vietnamese.BjW4sHH5.woff2 b/packages/tempo/public/v4/assets/inter-roman-vietnamese.BjW4sHH5.woff2 new file mode 100644 index 00000000..57bdc22a Binary files /dev/null and b/packages/tempo/public/v4/assets/inter-roman-vietnamese.BjW4sHH5.woff2 differ diff --git a/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.js b/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.js new file mode 100644 index 00000000..f2d4884d --- /dev/null +++ b/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.js @@ -0,0 +1,12 @@ +import{_ as s,o as t,c as e,a2 as a}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)","description":"","frontmatter":{},"headers":[],"relativePath":"src/plugin/extend/README.md","filePath":"src/plugin/extend/README.md"}'),n={name:"src/plugin/extend/README.md"};function p(l,i,h,r,o,k){return t(),e("div",null,[...i[0]||(i[0]=[a(`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This directory contains opt-in prototype extension mixins that augment Tempo.prototype and TypeScript's interface Tempo declaration merging.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚫 Why Barrel (index.ts) Files are Omitted ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mixins in this directory perform module-level side effects when loaded (e.g. assigning methods to Tempo.prototype).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To preserve strict tree-shaking and prevent accidental side-effect execution across the codebase, barrel index files (index.ts) are intentionally omitted from this directory. Importing a barrel file would eagerly load all mixins and mutate the prototype for consumers who did not request those extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 How to Import Mixins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Always import mixins via explicit subpath imports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Explicitly opt into the recurrence mixin (patches Tempo.prototype.nextOccurrence)
+import '#tempo/plugin/extend/extend.recurrence.js';
+
+// Or in external consumption:
+import '@magmacomputing/tempo/extend/recurrence';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✍️ How to Author a Prototype Mixin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When creating a new mixin in this directory:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Augment the TypeScript Tempo interface:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      declare module '../../tempo.class.js' {
+  interface Tempo {
+    myCustomMethod(arg: string): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Assign the implementation to Tempo.prototype:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo.prototype.myCustomMethod = function (this: Tempo, arg: string): Tempo {
+  // Implementation...
+  return this;
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Avoid top-level barrel exports so the mixin remains strictly opt-in via subpath import.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `,14)])])}const g=s(n,[["render",p]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.lean.js b/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.lean.js new file mode 100644 index 00000000..f7faf1e6 --- /dev/null +++ b/packages/tempo/public/v4/assets/src_plugin_extend_README.md.kJGNE0p7.lean.js @@ -0,0 +1 @@ +import{_ as s,o as t,c as e,a2 as a}from"./chunks/framework.DNL3hc5c.js";const c=JSON.parse('{"title":"🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/)","description":"","frontmatter":{},"headers":[],"relativePath":"src/plugin/extend/README.md","filePath":"src/plugin/extend/README.md"}'),n={name:"src/plugin/extend/README.md"};function p(l,i,h,r,o,k){return t(),e("div",null,[...i[0]||(i[0]=[a("",14)])])}const g=s(n,[["render",p]]);export{c as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/style.BRULFQUK.css b/packages/tempo/public/v4/assets/style.BRULFQUK.css new file mode 100644 index 00000000..a97e7502 --- /dev/null +++ b/packages/tempo/public/v4/assets/style.BRULFQUK.css @@ -0,0 +1 @@ +.tempo-hero[data-v-8fadbdcc]{padding:80px 24px 64px;max-width:1152px;margin:0 auto}.tempo-hero-content[data-v-8fadbdcc]{display:flex;flex-direction:row;align-items:center;justify-content:space-between;gap:64px}@media(max-width:960px){.tempo-hero-content[data-v-8fadbdcc]{flex-direction:column;text-align:center}}.tempo-hero-left[data-v-8fadbdcc]{flex:1;display:flex;flex-direction:column;gap:32px}.tempo-title-row[data-v-8fadbdcc]{display:flex;align-items:center;gap:24px}@media(max-width:960px){.tempo-title-row[data-v-8fadbdcc]{flex-direction:column;gap:16px}}.tempo-hero-logo[data-v-8fadbdcc]{width:140px;height:140px}.tempo-hero-name[data-v-8fadbdcc]{font-size:5rem;font-weight:800;color:#3498db;margin:0;line-height:1}.tempo-hero-tagline[data-v-8fadbdcc]{font-size:1.6rem;font-weight:700;color:#2c3e50;margin:0;line-height:1.3}.tempo-hero-actions[data-v-8fadbdcc]{display:flex;gap:16px;margin-top:24px}@media(max-width:960px){.tempo-hero-actions[data-v-8fadbdcc]{justify-content:center}}.tempo-btn[data-v-8fadbdcc]{padding:0 24px;line-height:44px;border-radius:22px;font-size:15px;font-weight:600;text-decoration:none;transition:all .2s}.tempo-btn-brand[data-v-8fadbdcc]{background-color:var(--vp-c-brand-1);color:var(--vp-c-white)}.tempo-btn-brand[data-v-8fadbdcc]:hover{background-color:var(--vp-c-brand-2, #2980b9);color:var(--vp-c-white)}.tempo-btn-alt[data-v-8fadbdcc]{background-color:var(--vp-c-bg-mute);color:var(--vp-c-text-1)}.tempo-btn-alt[data-v-8fadbdcc]:hover{background-color:var(--vp-c-bg-soft)}.tempo-hero-right[data-v-8fadbdcc]{display:flex;justify-content:center;align-items:center;min-width:320px}.tempo-clock-mini[data-v-8fadbdcc]{display:flex;flex-direction:column;align-items:center;gap:24px}.tempo-clock-svg[data-v-8fadbdcc]{width:200px;height:200px;filter:drop-shadow(0 8px 30px rgba(0,0,0,.12))}.tempo-clock-face[data-v-8fadbdcc]{fill:var(--vp-c-bg-soft);stroke:var(--vp-c-border);stroke-width:2}.tempo-tick-major[data-v-8fadbdcc]{stroke:var(--vp-c-text-1);stroke-width:2.5;stroke-linecap:round}.tempo-tick-minor[data-v-8fadbdcc]{stroke:var(--vp-c-text-2);stroke-width:1;stroke-linecap:round}.tempo-hand-hour[data-v-8fadbdcc]{stroke:var(--vp-c-text-1);stroke-width:6;stroke-linecap:round}.tempo-hand-minute[data-v-8fadbdcc]{stroke:var(--vp-c-text-1);stroke-width:3.5;stroke-linecap:round}.tempo-hand-second[data-v-8fadbdcc]{stroke:var(--vp-c-brand-1);stroke-width:1.5;stroke-linecap:round}.tempo-hub[data-v-8fadbdcc]{fill:var(--vp-c-text-1)}.tempo-hub-inner[data-v-8fadbdcc]{fill:var(--vp-c-brand-1)}.tempo-time-display[data-v-8fadbdcc]{text-align:center}.tempo-iso-time[data-v-8fadbdcc]{font-family:ui-monospace,SFMono-Regular,SF Mono,Menlo,monospace;font-size:1rem;font-weight:600;color:var(--vp-c-text-1);margin:0;white-space:nowrap}.tempo-tz-select[data-v-8fadbdcc]{background:var(--vp-c-bg-soft);color:var(--vp-c-text-2);border:1px solid var(--vp-c-border);border-radius:4px;padding:4px 12px;font-family:ui-monospace,SFMono-Regular,SF Mono,Menlo,monospace;font-size:.8rem;margin-top:8px;cursor:pointer;outline:none;transition:all .2s;appearance:none;-webkit-appearance:none}.tempo-tz-select[data-v-8fadbdcc]:hover{border-color:var(--vp-c-brand-1);color:var(--vp-c-text-1);background:var(--vp-c-bg-mute)}.tempo-tz-select[data-v-8fadbdcc]:focus{border-color:var(--vp-c-brand-1);box-shadow:0 0 0 2px #3498db33}.tempo-carousel-container[data-v-8fadbdcc]{overflow:hidden;padding:60px 24px;max-width:1152px;margin:0 auto;position:relative}.tempo-carousel-controls[data-v-8fadbdcc]{position:absolute;top:24px;right:24px;z-index:10}.tempo-swipe-hint[data-v-8fadbdcc]{position:absolute;top:24px;left:24px;z-index:10;font-size:.75rem;font-weight:700;letter-spacing:.04em;text-transform:uppercase;color:var(--vp-c-brand-1);background:color-mix(in srgb,var(--vp-c-bg-soft) 88%,transparent);border:1px solid var(--vp-c-border);border-radius:999px;padding:6px 10px;backdrop-filter:blur(4px)}.tempo-carousel-toggle[data-v-8fadbdcc]{background:var(--vp-c-bg-soft);border:1px solid var(--vp-c-border);border-radius:50%;width:40px;height:40px;display:flex;align-items:center;justify-content:center;cursor:pointer;font-size:1.2rem;transition:all .2s}.tempo-carousel-toggle[data-v-8fadbdcc]:hover{border-color:var(--vp-c-brand-1);background:var(--vp-c-bg-mute)}.tempo-carousel-track[data-v-8fadbdcc]{display:flex;width:calc((var(--carousel-count) / 3) * 100%);touch-action:pan-y;user-select:none;cursor:grab}.tempo-carousel-track.is-dragging[data-v-8fadbdcc]{cursor:grabbing}.tempo-carousel-track.is-dragging .tempo-feature-content[data-v-8fadbdcc]{border-color:color-mix(in srgb,var(--vp-c-brand-1) 40%,var(--vp-c-border))}.tempo-feature-card[data-v-8fadbdcc]{flex:0 0 calc(100% / var(--carousel-count));padding:12px;box-sizing:border-box}.tempo-feature-content[data-v-8fadbdcc]{padding:24px;height:100%;background-color:var(--vp-c-bg-soft);border-radius:12px;border:1px solid var(--vp-c-border);transition:all .3s ease;cursor:default;position:relative}.tempo-feature-content[data-v-8fadbdcc]:hover{border-color:var(--vp-c-brand-1);transform:translateY(-4px);background-color:var(--vp-c-bg-mute)}.tempo-feature-icon[data-v-8fadbdcc]{font-size:2rem;margin-bottom:12px}.tempo-feature-title[data-v-8fadbdcc]{font-size:1.1rem;font-weight:700;margin-bottom:8px;color:var(--vp-c-brand-1);font-family:ui-monospace,monospace}.tempo-feature-details[data-v-8fadbdcc]{font-size:.9rem;line-height:1.5;color:var(--vp-c-text-2)}@media(max-width:768px){.tempo-carousel-track[data-v-8fadbdcc]{width:calc(var(--carousel-count) * 100%)}.tempo-feature-card[data-v-8fadbdcc]{flex:0 0 calc(100% / var(--carousel-count))}}.tempo-status-row[data-v-8fadbdcc]{display:flex;align-items:center;gap:.75rem;justify-content:center}.tempo-ticker-status[data-v-8fadbdcc]{font-size:.65rem;text-transform:uppercase;letter-spacing:.05em;padding:.15rem .4rem;border-radius:4px;font-weight:700;transition:all .3s ease;cursor:pointer;border:1px solid transparent;background:none;line-height:1}.tempo-ticker-status[data-v-8fadbdcc]:hover{filter:brightness(1.1)}.tempo-ticker-status.is-active[data-v-8fadbdcc]{background:#2563eb1a;color:#3b82f6;border:1px solid rgba(59,130,246,.2);animation:tempo-pulse-8fadbdcc 2s infinite}.tempo-ticker-status.is-resuming[data-v-8fadbdcc]{background:#f59e0b1a;color:#f59e0b;border:1px solid rgba(245,158,11,.2)}.tempo-ticker-status.is-standby[data-v-8fadbdcc]{background:#71717a1a;color:#71717a;border:1px solid rgba(113,113,122,.2)}.tempo-ticker-status.is-paused[data-v-8fadbdcc]{background:#3498db26;color:#3498db;border:1px solid rgba(52,152,219,.3);animation:tempo-pulse-8fadbdcc 3s infinite ease-in-out}.tempo-ticker-status.is-paused[data-v-8fadbdcc]:hover{background:#3498db40;color:var(--vp-c-brand-1)}@keyframes tempo-pulse-8fadbdcc{0%{opacity:1}50%{opacity:.7}to{opacity:1}}.tempo-clock-mini[data-v-8fadbdcc]{transition:all .5s cubic-bezier(.4,0,.2,1)}.tempo-clock-mini:has(.is-standby) .tempo-clock-svg[data-v-8fadbdcc],.tempo-clock-mini:has(.is-paused) .tempo-clock-svg[data-v-8fadbdcc]{filter:grayscale(.2) opacity(.4)}.tempo-clock-mini:has(.is-standby) .tempo-iso-time[data-v-8fadbdcc],.tempo-clock-mini:has(.is-paused) .tempo-iso-time[data-v-8fadbdcc]{opacity:.5}.tempo-clock-mini:has(.is-paused) .tempo-tz-select[data-v-8fadbdcc]{opacity:.8;cursor:pointer}.tempo-clock-mini:has(.is-standby) .tempo-tz-select[data-v-8fadbdcc]{opacity:.5;pointer-events:none}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-cyrillic-ext.BBPuwvHQ.woff2) format("woff2");unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-cyrillic.C5lxZ8CY.woff2) format("woff2");unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-greek-ext.CqjqNYQ-.woff2) format("woff2");unicode-range:U+1F00-1FFF}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-greek.BBVDIX6e.woff2) format("woff2");unicode-range:U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-vietnamese.BjW4sHH5.woff2) format("woff2");unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-latin-ext.4ZJIpNVo.woff2) format("woff2");unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:Inter;font-style:normal;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-roman-latin.Di8DUHzh.woff2) format("woff2");unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-cyrillic-ext.r48I6akx.woff2) format("woff2");unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-cyrillic.By2_1cv3.woff2) format("woff2");unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-greek-ext.1u6EdAuj.woff2) format("woff2");unicode-range:U+1F00-1FFF}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-greek.DJ8dCoTZ.woff2) format("woff2");unicode-range:U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-vietnamese.BSbpV94h.woff2) format("woff2");unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-latin-ext.CN1xVJS-.woff2) format("woff2");unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:Inter;font-style:italic;font-weight:100 900;font-display:swap;src:url(/magma/v4/assets/inter-italic-latin.C2AdPX0b.woff2) format("woff2");unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:Punctuation SC;font-weight:400;src:local("PingFang SC Regular"),local("Noto Sans CJK SC"),local("Microsoft YaHei");unicode-range:U+201C,U+201D,U+2018,U+2019,U+2E3A,U+2014,U+2013,U+2026,U+00B7,U+007E,U+002F}@font-face{font-family:Punctuation SC;font-weight:500;src:local("PingFang SC Medium"),local("Noto Sans CJK SC"),local("Microsoft YaHei");unicode-range:U+201C,U+201D,U+2018,U+2019,U+2E3A,U+2014,U+2013,U+2026,U+00B7,U+007E,U+002F}@font-face{font-family:Punctuation SC;font-weight:600;src:local("PingFang SC Semibold"),local("Noto Sans CJK SC Bold"),local("Microsoft YaHei Bold");unicode-range:U+201C,U+201D,U+2018,U+2019,U+2E3A,U+2014,U+2013,U+2026,U+00B7,U+007E,U+002F}@font-face{font-family:Punctuation SC;font-weight:700;src:local("PingFang SC Semibold"),local("Noto Sans CJK SC Bold"),local("Microsoft YaHei Bold");unicode-range:U+201C,U+201D,U+2018,U+2019,U+2E3A,U+2014,U+2013,U+2026,U+00B7,U+007E,U+002F}:root{--vp-c-white: #ffffff;--vp-c-black: #000000;--vp-c-neutral: var(--vp-c-black);--vp-c-neutral-inverse: var(--vp-c-white)}.dark{--vp-c-neutral: var(--vp-c-white);--vp-c-neutral-inverse: var(--vp-c-black)}:root{--vp-c-gray-1: #dddde3;--vp-c-gray-2: #e4e4e9;--vp-c-gray-3: #ebebef;--vp-c-gray-soft: rgba(142, 150, 170, .14);--vp-c-indigo-1: #3451b2;--vp-c-indigo-2: #3a5ccc;--vp-c-indigo-3: #5672cd;--vp-c-indigo-soft: rgba(100, 108, 255, .14);--vp-c-purple-1: #6f42c1;--vp-c-purple-2: #7e4cc9;--vp-c-purple-3: #8e5cd9;--vp-c-purple-soft: rgba(159, 122, 234, .14);--vp-c-green-1: #18794e;--vp-c-green-2: #299764;--vp-c-green-3: #30a46c;--vp-c-green-soft: rgba(16, 185, 129, .14);--vp-c-yellow-1: #915930;--vp-c-yellow-2: #946300;--vp-c-yellow-3: #9f6a00;--vp-c-yellow-soft: rgba(234, 179, 8, .14);--vp-c-red-1: #b8272c;--vp-c-red-2: #d5393e;--vp-c-red-3: #e0575b;--vp-c-red-soft: rgba(244, 63, 94, .14);--vp-c-sponsor: #db2777}.dark{--vp-c-gray-1: #515c67;--vp-c-gray-2: #414853;--vp-c-gray-3: #32363f;--vp-c-gray-soft: rgba(101, 117, 133, .16);--vp-c-indigo-1: #a8b1ff;--vp-c-indigo-2: #5c73e7;--vp-c-indigo-3: #3e63dd;--vp-c-indigo-soft: rgba(100, 108, 255, .16);--vp-c-purple-1: #c8abfa;--vp-c-purple-2: #a879e6;--vp-c-purple-3: #8e5cd9;--vp-c-purple-soft: rgba(159, 122, 234, .16);--vp-c-green-1: #3dd68c;--vp-c-green-2: #30a46c;--vp-c-green-3: #298459;--vp-c-green-soft: rgba(16, 185, 129, .16);--vp-c-yellow-1: #f9b44e;--vp-c-yellow-2: #da8b17;--vp-c-yellow-3: #a46a0a;--vp-c-yellow-soft: rgba(234, 179, 8, .16);--vp-c-red-1: #f66f81;--vp-c-red-2: #f14158;--vp-c-red-3: #b62a3c;--vp-c-red-soft: rgba(244, 63, 94, .16)}:root{--vp-c-bg: #ffffff;--vp-c-bg-alt: #f6f6f7;--vp-c-bg-elv: #ffffff;--vp-c-bg-soft: #f6f6f7}.dark{--vp-c-bg: #1b1b1f;--vp-c-bg-alt: #161618;--vp-c-bg-elv: #202127;--vp-c-bg-soft: #202127}:root{--vp-c-border: #c2c2c4;--vp-c-divider: #e2e2e3;--vp-c-gutter: #e2e2e3}.dark{--vp-c-border: #3c3f44;--vp-c-divider: #2e2e32;--vp-c-gutter: #000000}:root{--vp-c-text-1: #3c3c43;--vp-c-text-2: #67676c;--vp-c-text-3: #929295}.dark{--vp-c-text-1: #dfdfd6;--vp-c-text-2: #98989f;--vp-c-text-3: #6a6a71}:root{--vp-c-default-1: var(--vp-c-gray-1);--vp-c-default-2: var(--vp-c-gray-2);--vp-c-default-3: var(--vp-c-gray-3);--vp-c-default-soft: var(--vp-c-gray-soft);--vp-c-brand-1: var(--vp-c-indigo-1);--vp-c-brand-2: var(--vp-c-indigo-2);--vp-c-brand-3: var(--vp-c-indigo-3);--vp-c-brand-soft: var(--vp-c-indigo-soft);--vp-c-brand: var(--vp-c-brand-1);--vp-c-tip-1: var(--vp-c-brand-1);--vp-c-tip-2: var(--vp-c-brand-2);--vp-c-tip-3: var(--vp-c-brand-3);--vp-c-tip-soft: var(--vp-c-brand-soft);--vp-c-note-1: var(--vp-c-brand-1);--vp-c-note-2: var(--vp-c-brand-2);--vp-c-note-3: var(--vp-c-brand-3);--vp-c-note-soft: var(--vp-c-brand-soft);--vp-c-success-1: var(--vp-c-green-1);--vp-c-success-2: var(--vp-c-green-2);--vp-c-success-3: var(--vp-c-green-3);--vp-c-success-soft: var(--vp-c-green-soft);--vp-c-important-1: var(--vp-c-purple-1);--vp-c-important-2: var(--vp-c-purple-2);--vp-c-important-3: var(--vp-c-purple-3);--vp-c-important-soft: var(--vp-c-purple-soft);--vp-c-warning-1: var(--vp-c-yellow-1);--vp-c-warning-2: var(--vp-c-yellow-2);--vp-c-warning-3: var(--vp-c-yellow-3);--vp-c-warning-soft: var(--vp-c-yellow-soft);--vp-c-danger-1: var(--vp-c-red-1);--vp-c-danger-2: var(--vp-c-red-2);--vp-c-danger-3: var(--vp-c-red-3);--vp-c-danger-soft: var(--vp-c-red-soft);--vp-c-caution-1: var(--vp-c-red-1);--vp-c-caution-2: var(--vp-c-red-2);--vp-c-caution-3: var(--vp-c-red-3);--vp-c-caution-soft: var(--vp-c-red-soft)}:root{--vp-font-family-base: "Inter", ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--vp-font-family-mono: ui-monospace, "Menlo", "Monaco", "Consolas", "Liberation Mono", "Courier New", monospace;font-optical-sizing:auto}:root:where(:lang(zh)){--vp-font-family-base: "Punctuation SC", "Inter", ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"}:root{--vp-shadow-1: 0 1px 2px rgba(0, 0, 0, .04), 0 1px 2px rgba(0, 0, 0, .06);--vp-shadow-2: 0 3px 12px rgba(0, 0, 0, .07), 0 1px 4px rgba(0, 0, 0, .07);--vp-shadow-3: 0 12px 32px rgba(0, 0, 0, .1), 0 2px 6px rgba(0, 0, 0, .08);--vp-shadow-4: 0 14px 44px rgba(0, 0, 0, .12), 0 3px 9px rgba(0, 0, 0, .12);--vp-shadow-5: 0 18px 56px rgba(0, 0, 0, .16), 0 4px 12px rgba(0, 0, 0, .16)}:root{--vp-z-index-footer: 10;--vp-z-index-local-nav: 20;--vp-z-index-nav: 30;--vp-z-index-layout-top: 40;--vp-z-index-backdrop: 50;--vp-z-index-sidebar: 60}@media(min-width:960px){:root{--vp-z-index-sidebar: 25}}:root{--vp-layout-max-width: 1440px}:root{--vp-header-anchor-symbol: "#"}:root{--vp-code-line-height: 1.7;--vp-code-font-size: .875em;--vp-code-color: var(--vp-c-brand-1);--vp-code-link-color: var(--vp-c-brand-1);--vp-code-link-hover-color: var(--vp-c-brand-2);--vp-code-bg: var(--vp-c-default-soft);--vp-code-block-color: var(--vp-c-text-2);--vp-code-block-bg: var(--vp-c-bg-alt);--vp-code-block-divider-color: var(--vp-c-gutter);--vp-code-lang-color: var(--vp-c-text-3);--vp-code-line-highlight-color: var(--vp-c-default-soft);--vp-code-line-number-color: var(--vp-c-text-3);--vp-code-line-diff-add-color: var(--vp-c-success-soft);--vp-code-line-diff-add-symbol-color: var(--vp-c-success-1);--vp-code-line-diff-remove-color: var(--vp-c-danger-soft);--vp-code-line-diff-remove-symbol-color: var(--vp-c-danger-1);--vp-code-line-warning-color: var(--vp-c-warning-soft);--vp-code-line-error-color: var(--vp-c-danger-soft);--vp-code-copy-code-border-color: var(--vp-c-divider);--vp-code-copy-code-bg: var(--vp-c-bg-soft);--vp-code-copy-code-hover-border-color: var(--vp-c-divider);--vp-code-copy-code-hover-bg: var(--vp-c-bg);--vp-code-copy-code-active-text: var(--vp-c-text-2);--vp-code-copy-copied-text-content: "Copied";--vp-code-tab-divider: var(--vp-code-block-divider-color);--vp-code-tab-text-color: var(--vp-c-text-2);--vp-code-tab-bg: var(--vp-code-block-bg);--vp-code-tab-hover-text-color: var(--vp-c-text-1);--vp-code-tab-active-text-color: var(--vp-c-text-1);--vp-code-tab-active-bar-color: var(--vp-c-brand-1)}:lang(es),:lang(pt){--vp-code-copy-copied-text-content: "Copiado"}:lang(fa){--vp-code-copy-copied-text-content: "کپی شد"}:lang(ko){--vp-code-copy-copied-text-content: "복사됨"}:lang(ru){--vp-code-copy-copied-text-content: "Скопировано"}:lang(zh){--vp-code-copy-copied-text-content: "已复制"}:root{--vp-button-brand-border: transparent;--vp-button-brand-text: var(--vp-c-white);--vp-button-brand-bg: var(--vp-c-brand-3);--vp-button-brand-hover-border: transparent;--vp-button-brand-hover-text: var(--vp-c-white);--vp-button-brand-hover-bg: var(--vp-c-brand-2);--vp-button-brand-active-border: transparent;--vp-button-brand-active-text: var(--vp-c-white);--vp-button-brand-active-bg: var(--vp-c-brand-1);--vp-button-alt-border: transparent;--vp-button-alt-text: var(--vp-c-text-1);--vp-button-alt-bg: var(--vp-c-default-3);--vp-button-alt-hover-border: transparent;--vp-button-alt-hover-text: var(--vp-c-text-1);--vp-button-alt-hover-bg: var(--vp-c-default-2);--vp-button-alt-active-border: transparent;--vp-button-alt-active-text: var(--vp-c-text-1);--vp-button-alt-active-bg: var(--vp-c-default-1);--vp-button-sponsor-border: var(--vp-c-text-2);--vp-button-sponsor-text: var(--vp-c-text-2);--vp-button-sponsor-bg: transparent;--vp-button-sponsor-hover-border: var(--vp-c-sponsor);--vp-button-sponsor-hover-text: var(--vp-c-sponsor);--vp-button-sponsor-hover-bg: transparent;--vp-button-sponsor-active-border: var(--vp-c-sponsor);--vp-button-sponsor-active-text: var(--vp-c-sponsor);--vp-button-sponsor-active-bg: transparent}:root{--vp-custom-block-font-size: 14px;--vp-custom-block-code-font-size: 13px;--vp-custom-block-info-border: transparent;--vp-custom-block-info-text: var(--vp-c-text-1);--vp-custom-block-info-bg: var(--vp-c-default-soft);--vp-custom-block-info-code-bg: var(--vp-c-default-soft);--vp-custom-block-note-border: transparent;--vp-custom-block-note-text: var(--vp-c-text-1);--vp-custom-block-note-bg: var(--vp-c-default-soft);--vp-custom-block-note-code-bg: var(--vp-c-default-soft);--vp-custom-block-tip-border: transparent;--vp-custom-block-tip-text: var(--vp-c-text-1);--vp-custom-block-tip-bg: var(--vp-c-tip-soft);--vp-custom-block-tip-code-bg: var(--vp-c-tip-soft);--vp-custom-block-important-border: transparent;--vp-custom-block-important-text: var(--vp-c-text-1);--vp-custom-block-important-bg: var(--vp-c-important-soft);--vp-custom-block-important-code-bg: var(--vp-c-important-soft);--vp-custom-block-warning-border: transparent;--vp-custom-block-warning-text: var(--vp-c-text-1);--vp-custom-block-warning-bg: var(--vp-c-warning-soft);--vp-custom-block-warning-code-bg: var(--vp-c-warning-soft);--vp-custom-block-danger-border: transparent;--vp-custom-block-danger-text: var(--vp-c-text-1);--vp-custom-block-danger-bg: var(--vp-c-danger-soft);--vp-custom-block-danger-code-bg: var(--vp-c-danger-soft);--vp-custom-block-caution-border: transparent;--vp-custom-block-caution-text: var(--vp-c-text-1);--vp-custom-block-caution-bg: var(--vp-c-caution-soft);--vp-custom-block-caution-code-bg: var(--vp-c-caution-soft);--vp-custom-block-details-border: var(--vp-custom-block-info-border);--vp-custom-block-details-text: var(--vp-custom-block-info-text);--vp-custom-block-details-bg: var(--vp-custom-block-info-bg);--vp-custom-block-details-code-bg: var(--vp-custom-block-info-code-bg)}:root{--vp-input-border-color: var(--vp-c-border);--vp-input-bg-color: var(--vp-c-bg-alt);--vp-input-switch-bg-color: var(--vp-c-default-soft)}:root{--vp-nav-height: 64px;--vp-nav-bg-color: var(--vp-c-bg);--vp-nav-screen-bg-color: var(--vp-c-bg);--vp-nav-logo-height: 24px}.hide-nav{--vp-nav-height: 0px}.hide-nav .VPSidebar{--vp-nav-height: 22px}:root{--vp-local-nav-bg-color: var(--vp-c-bg)}:root{--vp-sidebar-width: 272px;--vp-sidebar-bg-color: var(--vp-c-bg-alt)}:root{--vp-backdrop-bg-color: rgba(0, 0, 0, .6)}:root{--vp-home-hero-name-color: var(--vp-c-brand-1);--vp-home-hero-name-background: transparent;--vp-home-hero-image-background-image: none;--vp-home-hero-image-filter: none}:root{--vp-badge-info-border: transparent;--vp-badge-info-text: var(--vp-c-text-2);--vp-badge-info-bg: var(--vp-c-default-soft);--vp-badge-tip-border: transparent;--vp-badge-tip-text: var(--vp-c-tip-1);--vp-badge-tip-bg: var(--vp-c-tip-soft);--vp-badge-warning-border: transparent;--vp-badge-warning-text: var(--vp-c-warning-1);--vp-badge-warning-bg: var(--vp-c-warning-soft);--vp-badge-danger-border: transparent;--vp-badge-danger-text: var(--vp-c-danger-1);--vp-badge-danger-bg: var(--vp-c-danger-soft)}:root{--vp-carbon-ads-text-color: var(--vp-c-text-1);--vp-carbon-ads-poweredby-color: var(--vp-c-text-2);--vp-carbon-ads-bg-color: var(--vp-c-bg-soft);--vp-carbon-ads-hover-text-color: var(--vp-c-brand-1);--vp-carbon-ads-hover-poweredby-color: var(--vp-c-text-1)}:root{--vp-local-search-bg: var(--vp-c-bg);--vp-local-search-result-bg: var(--vp-c-bg);--vp-local-search-result-border: var(--vp-c-divider);--vp-local-search-result-selected-bg: var(--vp-c-bg);--vp-local-search-result-selected-border: var(--vp-c-brand-1);--vp-local-search-highlight-bg: var(--vp-c-brand-1);--vp-local-search-highlight-text: var(--vp-c-neutral-inverse)}@media(prefers-reduced-motion:reduce){*,:before,:after{animation-delay:-1ms!important;animation-duration:1ms!important;animation-iteration-count:1!important;background-attachment:initial!important;scroll-behavior:auto!important;transition-duration:0s!important;transition-delay:0s!important}}*,:before,:after{box-sizing:border-box}html{line-height:1.4;font-size:16px;-webkit-text-size-adjust:100%}html.dark{color-scheme:dark}body{margin:0;width:100%;min-width:320px;min-height:100vh;line-height:24px;font-family:var(--vp-font-family-base);font-size:16px;font-weight:400;color:var(--vp-c-text-1);background-color:var(--vp-c-bg);font-synthesis:style;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}main{display:block}h1,h2,h3,h4,h5,h6{margin:0;line-height:24px;font-size:16px;font-weight:400}p{margin:0}strong,b{font-weight:600}a,area,button,[role=button],input,label,select,summary,textarea{touch-action:manipulation}a{color:inherit;text-decoration:inherit}ol,ul{list-style:none;margin:0;padding:0}blockquote{margin:0}pre,code,kbd,samp{font-family:var(--vp-font-family-mono)}img,svg,video,canvas,audio,iframe,embed,object{display:block}figure{margin:0}img,video{max-width:100%;height:auto}button,input,optgroup,select,textarea{border:0;padding:0;line-height:inherit;color:inherit}button{padding:0;font-family:inherit;background-color:transparent;background-image:none}button:enabled,[role=button]:enabled{cursor:pointer}button:focus,button:focus-visible{outline:1px dotted;outline:4px auto -webkit-focus-ring-color}button:focus:not(:focus-visible){outline:none!important}input:focus,textarea:focus,select:focus{outline:none}table{border-collapse:collapse}input{background-color:transparent}input:-ms-input-placeholder,textarea:-ms-input-placeholder{color:var(--vp-c-text-3)}input::-ms-input-placeholder,textarea::-ms-input-placeholder{color:var(--vp-c-text-3)}input::placeholder,textarea::placeholder{color:var(--vp-c-text-3)}input::-webkit-outer-spin-button,input::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}input[type=number]{-moz-appearance:textfield}textarea{resize:vertical}select{-webkit-appearance:none}fieldset{margin:0;padding:0}h1,h2,h3,h4,h5,h6,li,p{overflow-wrap:break-word}vite-error-overlay{z-index:9999}mjx-container{overflow-x:auto}mjx-container>svg{display:inline-block;margin:auto}[class^=vpi-],[class*=" vpi-"],.vp-icon{width:1em;height:1em}[class^=vpi-].bg,[class*=" vpi-"].bg,.vp-icon.bg{background-size:100% 100%;background-color:transparent}[class^=vpi-]:not(.bg),[class*=" vpi-"]:not(.bg),.vp-icon:not(.bg){-webkit-mask:var(--icon) no-repeat;mask:var(--icon) no-repeat;-webkit-mask-size:100% 100%;mask-size:100% 100%;background-color:currentColor;color:inherit}.vpi-align-left{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M21 6H3M15 12H3M17 18H3'/%3E%3C/svg%3E")}.vpi-arrow-right,.vpi-arrow-down,.vpi-arrow-left,.vpi-arrow-up{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M5 12h14M12 5l7 7-7 7'/%3E%3C/svg%3E")}.vpi-chevron-right,.vpi-chevron-down,.vpi-chevron-left,.vpi-chevron-up{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='m9 18 6-6-6-6'/%3E%3C/svg%3E")}.vpi-chevron-down,.vpi-arrow-down{transform:rotate(90deg)}.vpi-chevron-left,.vpi-arrow-left{transform:rotate(180deg)}.vpi-chevron-up,.vpi-arrow-up{transform:rotate(-90deg)}.vpi-square-pen{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7'/%3E%3Cpath d='M18.375 2.625a2.121 2.121 0 1 1 3 3L12 15l-4 1 1-4Z'/%3E%3C/svg%3E")}.vpi-plus{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M5 12h14M12 5v14'/%3E%3C/svg%3E")}.vpi-sun{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Ccircle cx='12' cy='12' r='4'/%3E%3Cpath d='M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M6.34 17.66l-1.41 1.41M19.07 4.93l-1.41 1.41'/%3E%3C/svg%3E")}.vpi-moon{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z'/%3E%3C/svg%3E")}.vpi-more-horizontal{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Ccircle cx='12' cy='12' r='1'/%3E%3Ccircle cx='19' cy='12' r='1'/%3E%3Ccircle cx='5' cy='12' r='1'/%3E%3C/svg%3E")}.vpi-languages{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='m5 8 6 6M4 14l6-6 2-3M2 5h12M7 2h1M22 22l-5-10-5 10M14 18h6'/%3E%3C/svg%3E")}.vpi-heart{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z'/%3E%3C/svg%3E")}.vpi-search{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Ccircle cx='11' cy='11' r='8'/%3E%3Cpath d='m21 21-4.3-4.3'/%3E%3C/svg%3E")}.vpi-layout-list{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Crect width='7' height='7' x='3' y='3' rx='1'/%3E%3Crect width='7' height='7' x='3' y='14' rx='1'/%3E%3Cpath d='M14 4h7M14 9h7M14 15h7M14 20h7'/%3E%3C/svg%3E")}.vpi-delete{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='M20 5H9l-7 7 7 7h11a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2ZM18 9l-6 6M12 9l6 6'/%3E%3C/svg%3E")}.vpi-corner-down-left{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Cpath d='m9 10-5 5 5 5'/%3E%3Cpath d='M20 4v7a4 4 0 0 1-4 4H4'/%3E%3C/svg%3E")}:root{--vp-icon-copy: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='rgba(128,128,128,1)' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Crect width='8' height='4' x='8' y='2' rx='1' ry='1'/%3E%3Cpath d='M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2'/%3E%3C/svg%3E");--vp-icon-copied: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='rgba(128,128,128,1)' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 24 24'%3E%3Crect width='8' height='4' x='8' y='2' rx='1' ry='1'/%3E%3Cpath d='M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2'/%3E%3Cpath d='m9 14 2 2 4-4'/%3E%3C/svg%3E")}.visually-hidden{position:absolute;width:1px;height:1px;white-space:nowrap;clip:rect(0 0 0 0);clip-path:inset(50%);overflow:hidden}.custom-block{border:1px solid transparent;border-radius:8px;padding:16px 16px 8px;line-height:24px;font-size:var(--vp-custom-block-font-size);color:var(--vp-c-text-2)}.custom-block.info{border-color:var(--vp-custom-block-info-border);color:var(--vp-custom-block-info-text);background-color:var(--vp-custom-block-info-bg)}.custom-block.info a,.custom-block.info code{color:var(--vp-c-brand-1)}.custom-block.info a:hover,.custom-block.info a:hover>code{color:var(--vp-c-brand-2)}.custom-block.info code{background-color:var(--vp-custom-block-info-code-bg)}.custom-block.note{border-color:var(--vp-custom-block-note-border);color:var(--vp-custom-block-note-text);background-color:var(--vp-custom-block-note-bg)}.custom-block.note a,.custom-block.note code{color:var(--vp-c-brand-1)}.custom-block.note a:hover,.custom-block.note a:hover>code{color:var(--vp-c-brand-2)}.custom-block.note code{background-color:var(--vp-custom-block-note-code-bg)}.custom-block.tip{border-color:var(--vp-custom-block-tip-border);color:var(--vp-custom-block-tip-text);background-color:var(--vp-custom-block-tip-bg)}.custom-block.tip a,.custom-block.tip code{color:var(--vp-c-tip-1)}.custom-block.tip a:hover,.custom-block.tip a:hover>code{color:var(--vp-c-tip-2)}.custom-block.tip code{background-color:var(--vp-custom-block-tip-code-bg)}.custom-block.important{border-color:var(--vp-custom-block-important-border);color:var(--vp-custom-block-important-text);background-color:var(--vp-custom-block-important-bg)}.custom-block.important a,.custom-block.important code{color:var(--vp-c-important-1)}.custom-block.important a:hover,.custom-block.important a:hover>code{color:var(--vp-c-important-2)}.custom-block.important code{background-color:var(--vp-custom-block-important-code-bg)}.custom-block.warning{border-color:var(--vp-custom-block-warning-border);color:var(--vp-custom-block-warning-text);background-color:var(--vp-custom-block-warning-bg)}.custom-block.warning a,.custom-block.warning code{color:var(--vp-c-warning-1)}.custom-block.warning a:hover,.custom-block.warning a:hover>code{color:var(--vp-c-warning-2)}.custom-block.warning code{background-color:var(--vp-custom-block-warning-code-bg)}.custom-block.danger{border-color:var(--vp-custom-block-danger-border);color:var(--vp-custom-block-danger-text);background-color:var(--vp-custom-block-danger-bg)}.custom-block.danger a,.custom-block.danger code{color:var(--vp-c-danger-1)}.custom-block.danger a:hover,.custom-block.danger a:hover>code{color:var(--vp-c-danger-2)}.custom-block.danger code{background-color:var(--vp-custom-block-danger-code-bg)}.custom-block.caution{border-color:var(--vp-custom-block-caution-border);color:var(--vp-custom-block-caution-text);background-color:var(--vp-custom-block-caution-bg)}.custom-block.caution a,.custom-block.caution code{color:var(--vp-c-caution-1)}.custom-block.caution a:hover,.custom-block.caution a:hover>code{color:var(--vp-c-caution-2)}.custom-block.caution code{background-color:var(--vp-custom-block-caution-code-bg)}.custom-block.details{border-color:var(--vp-custom-block-details-border);color:var(--vp-custom-block-details-text);background-color:var(--vp-custom-block-details-bg)}.custom-block.details a{color:var(--vp-c-brand-1)}.custom-block.details a:hover,.custom-block.details a:hover>code{color:var(--vp-c-brand-2)}.custom-block.details code{background-color:var(--vp-custom-block-details-code-bg)}.custom-block-title{font-weight:600}.custom-block p+p{margin:8px 0}.custom-block.details summary{margin:0 0 8px;font-weight:700;cursor:pointer;user-select:none}.custom-block.details summary+p{margin:8px 0}.custom-block a{color:inherit;font-weight:600;text-decoration:underline;text-underline-offset:2px;transition:opacity .25s}.custom-block a:hover{opacity:.75}.custom-block code{font-size:var(--vp-custom-block-code-font-size)}.custom-block.custom-block th,.custom-block.custom-block blockquote>p{font-size:var(--vp-custom-block-font-size);color:inherit}.dark .vp-code span{color:var(--shiki-dark, inherit)}html:not(.dark) .vp-code span{color:var(--shiki-light, inherit)}.vp-code-group{margin-top:16px}.vp-code-group .tabs{position:relative;display:flex;margin-right:-24px;margin-left:-24px;padding:0 12px;background-color:var(--vp-code-tab-bg);overflow-x:auto;overflow-y:hidden;box-shadow:inset 0 -1px var(--vp-code-tab-divider)}@media(min-width:640px){.vp-code-group .tabs{margin-right:0;margin-left:0;border-radius:8px 8px 0 0}}.vp-code-group .tabs input{position:fixed;opacity:0;pointer-events:none}.vp-code-group .tabs label{position:relative;display:inline-block;border-bottom:1px solid transparent;padding:0 12px;line-height:48px;font-size:14px;font-weight:500;color:var(--vp-code-tab-text-color);white-space:nowrap;cursor:pointer;transition:color .25s}.vp-code-group .tabs label:after{position:absolute;right:8px;bottom:-1px;left:8px;z-index:1;height:2px;border-radius:2px;content:"";background-color:transparent;transition:background-color .25s}.vp-code-group label:hover{color:var(--vp-code-tab-hover-text-color)}.vp-code-group input:checked+label{color:var(--vp-code-tab-active-text-color)}.vp-code-group input:checked+label:after{background-color:var(--vp-code-tab-active-bar-color)}.vp-code-group div[class*=language-],.vp-block{display:none;margin-top:0!important;border-top-left-radius:0!important;border-top-right-radius:0!important}.vp-code-group div[class*=language-].active,.vp-block.active{display:block}.vp-block{padding:20px 24px}.vp-doc h1,.vp-doc h2,.vp-doc h3,.vp-doc h4,.vp-doc h5,.vp-doc h6{position:relative;font-weight:600;outline:none}.vp-doc h1{letter-spacing:-.02em;line-height:40px;font-size:28px}.vp-doc h2{margin:48px 0 16px;border-top:1px solid var(--vp-c-divider);padding-top:24px;letter-spacing:-.02em;line-height:32px;font-size:24px}.vp-doc h3{margin:32px 0 0;letter-spacing:-.01em;line-height:28px;font-size:20px}.vp-doc h4{margin:24px 0 0;letter-spacing:-.01em;line-height:24px;font-size:18px}.vp-doc .header-anchor{position:absolute;top:0;left:0;margin-left:-.87em;font-weight:500;user-select:none;opacity:0;text-decoration:none;transition:color .25s,opacity .25s}.vp-doc .header-anchor:before{content:var(--vp-header-anchor-symbol)}.vp-doc h1:hover .header-anchor,.vp-doc h1 .header-anchor:focus,.vp-doc h2:hover .header-anchor,.vp-doc h2 .header-anchor:focus,.vp-doc h3:hover .header-anchor,.vp-doc h3 .header-anchor:focus,.vp-doc h4:hover .header-anchor,.vp-doc h4 .header-anchor:focus,.vp-doc h5:hover .header-anchor,.vp-doc h5 .header-anchor:focus,.vp-doc h6:hover .header-anchor,.vp-doc h6 .header-anchor:focus{opacity:1}@media(min-width:768px){.vp-doc h1{letter-spacing:-.02em;line-height:40px;font-size:32px}}.vp-doc h2 .header-anchor{top:24px}.vp-doc p,.vp-doc summary{margin:16px 0}.vp-doc p{line-height:28px}.vp-doc blockquote{margin:16px 0;border-left:2px solid var(--vp-c-divider);padding-left:16px;transition:border-color .5s;color:var(--vp-c-text-2)}.vp-doc blockquote>p{margin:0;font-size:16px;transition:color .5s}.vp-doc a{font-weight:500;color:var(--vp-c-brand-1);text-decoration:underline;text-underline-offset:2px;transition:color .25s,opacity .25s}.vp-doc a:hover{color:var(--vp-c-brand-2)}.vp-doc strong{font-weight:600}.vp-doc ul,.vp-doc ol{padding-left:1.25rem;margin:16px 0}.vp-doc ul{list-style:disc}.vp-doc ol{list-style:decimal}.vp-doc li+li{margin-top:8px}.vp-doc li>ol,.vp-doc li>ul{margin:8px 0 0}.vp-doc table{display:block;border-collapse:collapse;margin:20px 0;overflow-x:auto}.vp-doc tr{background-color:var(--vp-c-bg);border-top:1px solid var(--vp-c-divider);transition:background-color .5s}.vp-doc tr:nth-child(2n){background-color:var(--vp-c-bg-soft)}.vp-doc th,.vp-doc td{border:1px solid var(--vp-c-divider);padding:8px 16px}.vp-doc th{text-align:left;font-size:14px;font-weight:600;color:var(--vp-c-text-2);background-color:var(--vp-c-bg-soft)}.vp-doc td{font-size:14px}.vp-doc hr{margin:16px 0;border:none;border-top:1px solid var(--vp-c-divider)}.vp-doc .custom-block{margin:16px 0}.vp-doc .custom-block p{margin:8px 0;line-height:24px}.vp-doc .custom-block p:first-child{margin:0}.vp-doc .custom-block div[class*=language-]{margin:8px 0;border-radius:8px}.vp-doc .custom-block div[class*=language-] code{font-weight:400;background-color:transparent}.vp-doc .custom-block .vp-code-group .tabs{margin:0;border-radius:8px 8px 0 0}.vp-doc :not(pre,h1,h2,h3,h4,h5,h6)>code{font-size:var(--vp-code-font-size);color:var(--vp-code-color)}.vp-doc :not(pre)>code{border-radius:4px;padding:3px 6px;background-color:var(--vp-code-bg);transition:color .25s,background-color .5s}.vp-doc a>code{color:var(--vp-code-link-color)}.vp-doc a:hover>code{color:var(--vp-code-link-hover-color)}.vp-doc h1>code,.vp-doc h2>code,.vp-doc h3>code,.vp-doc h4>code{font-size:.9em}.vp-doc div[class*=language-],.vp-block{position:relative;margin:16px -24px;background-color:var(--vp-code-block-bg);overflow-x:auto;transition:background-color .5s}@media(min-width:640px){.vp-doc div[class*=language-],.vp-block{border-radius:8px;margin:16px 0}}@media(max-width:639px){.vp-doc li div[class*=language-]{border-radius:8px 0 0 8px}}.vp-doc div[class*=language-]+div[class*=language-],.vp-doc div[class$=-api]+div[class*=language-],.vp-doc div[class*=language-]+div[class$=-api]>div[class*=language-]{margin-top:-8px}.vp-doc [class*=language-] pre,.vp-doc [class*=language-] code{direction:ltr;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}.vp-doc [class*=language-] pre{position:relative;z-index:1;margin:0;padding:20px 0;background:transparent;overflow-x:auto}.vp-doc [class*=language-] code{display:block;padding:0 24px;width:fit-content;min-width:100%;line-height:var(--vp-code-line-height);font-size:var(--vp-code-font-size);color:var(--vp-code-block-color);transition:color .5s}.vp-doc [class*=language-] code .highlighted{background-color:var(--vp-code-line-highlight-color);transition:background-color .5s;margin:0 -24px;padding:0 24px;width:calc(100% + 48px);display:inline-block}.vp-doc [class*=language-] code .highlighted.error{background-color:var(--vp-code-line-error-color)}.vp-doc [class*=language-] code .highlighted.warning{background-color:var(--vp-code-line-warning-color)}.vp-doc [class*=language-] code .diff{transition:background-color .5s;margin:0 -24px;padding:0 24px;width:calc(100% + 48px);display:inline-block}.vp-doc [class*=language-] code .diff:before{position:absolute;left:10px}.vp-doc [class*=language-] .has-focused-lines .line:not(.has-focus){filter:blur(.095rem);opacity:.4;transition:filter .35s,opacity .35s}.vp-doc [class*=language-] .has-focused-lines .line:not(.has-focus){opacity:.7;transition:filter .35s,opacity .35s}.vp-doc [class*=language-]:hover .has-focused-lines .line:not(.has-focus){filter:blur(0);opacity:1}.vp-doc [class*=language-] code .diff.remove{background-color:var(--vp-code-line-diff-remove-color);opacity:.7}.vp-doc [class*=language-] code .diff.remove:before{content:"-";color:var(--vp-code-line-diff-remove-symbol-color)}.vp-doc [class*=language-] code .diff.add{background-color:var(--vp-code-line-diff-add-color)}.vp-doc [class*=language-] code .diff.add:before{content:"+";color:var(--vp-code-line-diff-add-symbol-color)}.vp-doc div[class*=language-].line-numbers-mode{padding-left:32px}.vp-doc .line-numbers-wrapper{position:absolute;top:0;bottom:0;left:0;z-index:3;border-right:1px solid var(--vp-code-block-divider-color);padding-top:20px;width:32px;text-align:center;font-family:var(--vp-font-family-mono);line-height:var(--vp-code-line-height);font-size:var(--vp-code-font-size);color:var(--vp-code-line-number-color);transition:border-color .5s,color .5s}.vp-doc [class*=language-]>button.copy{direction:ltr;position:absolute;top:12px;right:12px;z-index:3;border:1px solid var(--vp-code-copy-code-border-color);border-radius:4px;width:40px;height:40px;background-color:var(--vp-code-copy-code-bg);opacity:0;cursor:pointer;background-image:var(--vp-icon-copy);background-position:50%;background-size:20px;background-repeat:no-repeat;transition:border-color .25s,background-color .25s,opacity .25s}.vp-doc [class*=language-]:hover>button.copy,.vp-doc [class*=language-]>button.copy:focus{opacity:1}.vp-doc [class*=language-]>button.copy:hover,.vp-doc [class*=language-]>button.copy.copied{border-color:var(--vp-code-copy-code-hover-border-color);background-color:var(--vp-code-copy-code-hover-bg)}.vp-doc [class*=language-]>button.copy.copied,.vp-doc [class*=language-]>button.copy:hover.copied{border-radius:0 4px 4px 0;background-color:var(--vp-code-copy-code-hover-bg);background-image:var(--vp-icon-copied)}.vp-doc [class*=language-]>button.copy.copied:before,.vp-doc [class*=language-]>button.copy:hover.copied:before{position:relative;top:-1px;transform:translate(calc(-100% - 1px));display:flex;justify-content:center;align-items:center;border:1px solid var(--vp-code-copy-code-hover-border-color);border-right:0;border-radius:4px 0 0 4px;padding:0 10px;width:fit-content;height:40px;text-align:center;font-size:12px;font-weight:500;color:var(--vp-code-copy-code-active-text);background-color:var(--vp-code-copy-code-hover-bg);white-space:nowrap;content:var(--vp-code-copy-copied-text-content)}.vp-doc [class*=language-]>span.lang{position:absolute;top:2px;right:8px;z-index:2;font-size:12px;font-weight:500;user-select:none;color:var(--vp-code-lang-color);transition:color .4s,opacity .4s}.vp-doc [class*=language-]:hover>button.copy+span.lang,.vp-doc [class*=language-]>button.copy:focus+span.lang{opacity:0}.vp-doc .VPTeamMembers{margin-top:24px}.vp-doc .VPTeamMembers.small.count-1 .container{margin:0!important;max-width:calc((100% - 24px)/2)!important}.vp-doc .VPTeamMembers.small.count-2 .container,.vp-doc .VPTeamMembers.small.count-3 .container{max-width:100%!important}.vp-doc .VPTeamMembers.medium.count-1 .container{margin:0!important;max-width:calc((100% - 24px)/2)!important}:is(.vp-external-link-icon,.vp-doc a[href*="://"],.vp-doc a[target=_blank]):not(:is(.no-icon,svg a,:has(img,svg))):after{display:inline-block;margin-top:-1px;margin-left:4px;width:11px;height:11px;background:currentColor;color:var(--vp-c-text-3);flex-shrink:0;--icon: url("data:image/svg+xml, %3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' %3E%3Cpath d='M0 0h24v24H0V0z' fill='none' /%3E%3Cpath d='M9 5v2h6.59L4 18.59 5.41 20 17 8.41V15h2V5H9z' /%3E%3C/svg%3E");-webkit-mask-image:var(--icon);mask-image:var(--icon)}.vp-external-link-icon:after{content:""}.external-link-icon-enabled :is(.vp-doc a[href*="://"],.vp-doc a[target=_blank]):not(:is(.no-icon,svg a,:has(img,svg))):after{content:"";color:currentColor}.vp-sponsor{border-radius:16px;overflow:hidden}.vp-sponsor.aside{border-radius:12px}.vp-sponsor-section+.vp-sponsor-section{margin-top:4px}.vp-sponsor-tier{margin:0 0 4px!important;text-align:center;letter-spacing:1px!important;line-height:24px;width:100%;font-weight:600;color:var(--vp-c-text-2);background-color:var(--vp-c-bg-soft)}.vp-sponsor.normal .vp-sponsor-tier{padding:13px 0 11px;font-size:14px}.vp-sponsor.aside .vp-sponsor-tier{padding:9px 0 7px;font-size:12px}.vp-sponsor-grid+.vp-sponsor-tier{margin-top:4px}.vp-sponsor-grid{display:flex;flex-wrap:wrap;gap:4px}.vp-sponsor-grid.xmini .vp-sponsor-grid-link{height:64px}.vp-sponsor-grid.xmini .vp-sponsor-grid-image{max-width:64px;max-height:22px}.vp-sponsor-grid.mini .vp-sponsor-grid-link{height:72px}.vp-sponsor-grid.mini .vp-sponsor-grid-image{max-width:96px;max-height:24px}.vp-sponsor-grid.small .vp-sponsor-grid-link{height:96px}.vp-sponsor-grid.small .vp-sponsor-grid-image{max-width:96px;max-height:24px}.vp-sponsor-grid.medium .vp-sponsor-grid-link{height:112px}.vp-sponsor-grid.medium .vp-sponsor-grid-image{max-width:120px;max-height:36px}.vp-sponsor-grid.big .vp-sponsor-grid-link{height:184px}.vp-sponsor-grid.big .vp-sponsor-grid-image{max-width:192px;max-height:56px}.vp-sponsor-grid[data-vp-grid="2"] .vp-sponsor-grid-item{width:calc((100% - 4px)/2)}.vp-sponsor-grid[data-vp-grid="3"] .vp-sponsor-grid-item{width:calc((100% - 4px * 2) / 3)}.vp-sponsor-grid[data-vp-grid="4"] .vp-sponsor-grid-item{width:calc((100% - 12px)/4)}.vp-sponsor-grid[data-vp-grid="5"] .vp-sponsor-grid-item{width:calc((100% - 16px)/5)}.vp-sponsor-grid[data-vp-grid="6"] .vp-sponsor-grid-item{width:calc((100% - 4px * 5) / 6)}.vp-sponsor-grid-item{flex-shrink:0;width:100%;background-color:var(--vp-c-bg-soft);transition:background-color .25s}.vp-sponsor-grid-item:hover{background-color:var(--vp-c-default-soft)}.vp-sponsor-grid-item:hover .vp-sponsor-grid-image{filter:grayscale(0) invert(0)}.vp-sponsor-grid-item.empty:hover{background-color:var(--vp-c-bg-soft)}.dark .vp-sponsor-grid-item:hover{background-color:var(--vp-c-white)}.dark .vp-sponsor-grid-item.empty:hover{background-color:var(--vp-c-bg-soft)}.vp-sponsor-grid-link{display:flex}.vp-sponsor-grid-box{display:flex;justify-content:center;align-items:center;width:100%}.vp-sponsor-grid-image{max-width:100%;filter:grayscale(1);transition:filter .25s}.dark .vp-sponsor-grid-image{filter:grayscale(1) invert(1)}.VPBadge{display:inline-block;margin-left:2px;border:1px solid transparent;border-radius:12px;padding:0 10px;line-height:22px;font-size:12px;font-weight:500;transform:translateY(-2px)}.VPBadge.small{padding:0 6px;line-height:18px;font-size:10px;transform:translateY(-8px)}.VPDocFooter .VPBadge{display:none}.vp-doc h1>.VPBadge{margin-top:4px;vertical-align:top}.vp-doc h2>.VPBadge{margin-top:3px;padding:0 8px;vertical-align:top}.vp-doc h3>.VPBadge{vertical-align:middle}.vp-doc h4>.VPBadge,.vp-doc h5>.VPBadge,.vp-doc h6>.VPBadge{vertical-align:middle;line-height:18px}.VPBadge.info{border-color:var(--vp-badge-info-border);color:var(--vp-badge-info-text);background-color:var(--vp-badge-info-bg)}.VPBadge.tip{border-color:var(--vp-badge-tip-border);color:var(--vp-badge-tip-text);background-color:var(--vp-badge-tip-bg)}.VPBadge.warning{border-color:var(--vp-badge-warning-border);color:var(--vp-badge-warning-text);background-color:var(--vp-badge-warning-bg)}.VPBadge.danger{border-color:var(--vp-badge-danger-border);color:var(--vp-badge-danger-text);background-color:var(--vp-badge-danger-bg)}.VPBackdrop[data-v-32d0349a]{position:fixed;inset:0;z-index:var(--vp-z-index-backdrop);background:var(--vp-backdrop-bg-color);transition:opacity .5s}.VPBackdrop.fade-enter-from[data-v-32d0349a],.VPBackdrop.fade-leave-to[data-v-32d0349a]{opacity:0}.VPBackdrop.fade-leave-active[data-v-32d0349a]{transition-duration:.25s}@media(min-width:1280px){.VPBackdrop[data-v-32d0349a]{display:none}}.NotFound[data-v-9e9fbb1e]{padding:64px 24px 96px;text-align:center}@media(min-width:768px){.NotFound[data-v-9e9fbb1e]{padding:96px 32px 168px}}.code[data-v-9e9fbb1e]{line-height:64px;font-size:64px;font-weight:600}.title[data-v-9e9fbb1e]{padding-top:12px;letter-spacing:2px;line-height:20px;font-size:20px;font-weight:700}.divider[data-v-9e9fbb1e]{margin:24px auto 18px;width:64px;height:1px;background-color:var(--vp-c-divider)}.quote[data-v-9e9fbb1e]{margin:0 auto;max-width:256px;font-size:14px;font-weight:500;color:var(--vp-c-text-2)}.action[data-v-9e9fbb1e]{padding-top:20px}.link[data-v-9e9fbb1e]{display:inline-block;border:1px solid var(--vp-c-brand-1);border-radius:16px;padding:3px 16px;font-size:14px;font-weight:500;color:var(--vp-c-brand-1);transition:border-color .25s,color .25s}.link[data-v-9e9fbb1e]:hover{border-color:var(--vp-c-brand-2);color:var(--vp-c-brand-2)}.root[data-v-872013a5]{position:relative;z-index:1}.nested[data-v-872013a5]{padding-right:16px;padding-left:16px}.outline-link[data-v-872013a5]{display:block;line-height:32px;font-size:14px;font-weight:400;color:var(--vp-c-text-2);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:color .5s}.outline-link[data-v-872013a5]:hover,.outline-link.active[data-v-872013a5]{color:var(--vp-c-text-1);transition:color .25s}.outline-link.nested[data-v-872013a5]{padding-left:13px}.VPDocAsideOutline[data-v-72c9ae02]{display:none}.VPDocAsideOutline.has-outline[data-v-72c9ae02]{display:block}.content[data-v-72c9ae02]{position:relative;border-left:1px solid var(--vp-c-divider);padding-left:16px;font-size:13px;font-weight:500}.outline-marker[data-v-72c9ae02]{position:absolute;top:32px;left:-1px;z-index:0;opacity:0;width:2px;border-radius:2px;height:18px;background-color:var(--vp-c-brand-1);transition:top .25s cubic-bezier(0,1,.5,1),background-color .5s,opacity .25s}.outline-title[data-v-72c9ae02]{line-height:32px;font-size:14px;font-weight:600}.VPDocAside[data-v-1ad0daab]{display:flex;flex-direction:column;flex-grow:1}.spacer[data-v-1ad0daab]{flex-grow:1}.VPDocAside[data-v-1ad0daab] .spacer+.VPDocAsideSponsors,.VPDocAside[data-v-1ad0daab] .spacer+.VPDocAsideCarbonAds{margin-top:24px}.VPDocAside[data-v-1ad0daab] .VPDocAsideSponsors+.VPDocAsideCarbonAds{margin-top:16px}.VPLastUpdated[data-v-4e5f2de1]{line-height:24px;font-size:14px;font-weight:500;color:var(--vp-c-text-2)}@media(min-width:640px){.VPLastUpdated[data-v-4e5f2de1]{line-height:32px;font-size:14px;font-weight:500}}.VPDocFooter[data-v-4a375655]{margin-top:64px}.edit-info[data-v-4a375655]{padding-bottom:18px}@media(min-width:640px){.edit-info[data-v-4a375655]{display:flex;justify-content:space-between;align-items:center;padding-bottom:14px}}.edit-link-button[data-v-4a375655]{display:flex;align-items:center;border:0;line-height:32px;font-size:14px;font-weight:500;color:var(--vp-c-brand-1);transition:color .25s}.edit-link-button[data-v-4a375655]:hover{color:var(--vp-c-brand-2)}.edit-link-icon[data-v-4a375655]{margin-right:8px}.prev-next[data-v-4a375655]{border-top:1px solid var(--vp-c-divider);padding-top:24px;display:grid;grid-row-gap:8px}@media(min-width:640px){.prev-next[data-v-4a375655]{grid-template-columns:repeat(2,1fr);grid-column-gap:16px}}.pager-link[data-v-4a375655]{display:block;border:1px solid var(--vp-c-divider);border-radius:8px;padding:11px 16px 13px;width:100%;height:100%;transition:border-color .25s}.pager-link[data-v-4a375655]:hover{border-color:var(--vp-c-brand-1)}.pager-link.next[data-v-4a375655]{margin-left:auto;text-align:right}.desc[data-v-4a375655]{display:block;line-height:20px;font-size:12px;font-weight:500;color:var(--vp-c-text-2)}.title[data-v-4a375655]{display:block;line-height:20px;font-size:14px;font-weight:500;color:var(--vp-c-brand-1);transition:color .25s}.VPDoc[data-v-47e63f70]{padding:32px 24px 96px;width:100%}@media(min-width:768px){.VPDoc[data-v-47e63f70]{padding:48px 32px 128px}}@media(min-width:960px){.VPDoc[data-v-47e63f70]{padding:48px 32px 0}.VPDoc:not(.has-sidebar) .container[data-v-47e63f70]{display:flex;justify-content:center;max-width:992px}.VPDoc:not(.has-sidebar) .content[data-v-47e63f70]{max-width:752px}}@media(min-width:1280px){.VPDoc .container[data-v-47e63f70]{display:flex;justify-content:center}.VPDoc .aside[data-v-47e63f70]{display:block}}@media(min-width:1440px){.VPDoc:not(.has-sidebar) .content[data-v-47e63f70]{max-width:784px}.VPDoc:not(.has-sidebar) .container[data-v-47e63f70]{max-width:1104px}}.container[data-v-47e63f70]{margin:0 auto;width:100%}.aside[data-v-47e63f70]{position:relative;display:none;order:2;flex-grow:1;padding-left:32px;width:100%;max-width:256px}.left-aside[data-v-47e63f70]{order:1;padding-left:unset;padding-right:32px}.aside-container[data-v-47e63f70]{position:fixed;top:0;padding-top:calc(var(--vp-nav-height) + var(--vp-layout-top-height, 0px) + var(--vp-doc-top-height, 0px) + 48px);width:224px;height:100vh;overflow-x:hidden;overflow-y:auto;scrollbar-width:none}.aside-container[data-v-47e63f70]::-webkit-scrollbar{display:none}.aside-curtain[data-v-47e63f70]{position:fixed;bottom:0;z-index:10;width:224px;height:32px;background:linear-gradient(transparent,var(--vp-c-bg) 70%)}.aside-content[data-v-47e63f70]{display:flex;flex-direction:column;min-height:calc(100vh - (var(--vp-nav-height) + var(--vp-layout-top-height, 0px) + 48px));padding-bottom:32px}.content[data-v-47e63f70]{position:relative;margin:0 auto;width:100%}@media(min-width:960px){.content[data-v-47e63f70]{padding:0 32px 128px}}@media(min-width:1280px){.content[data-v-47e63f70]{order:1;margin:0;min-width:640px}}.content-container[data-v-47e63f70]{margin:0 auto}.VPDoc.has-aside .content-container[data-v-47e63f70]{max-width:688px}.VPButton[data-v-cbd0f1a8]{display:inline-block;border:1px solid transparent;text-align:center;font-weight:600;white-space:nowrap;transition:color .25s,border-color .25s,background-color .25s}.VPButton[data-v-cbd0f1a8]:active{transition:color .1s,border-color .1s,background-color .1s}.VPButton.medium[data-v-cbd0f1a8]{border-radius:20px;padding:0 20px;line-height:38px;font-size:14px}.VPButton.big[data-v-cbd0f1a8]{border-radius:24px;padding:0 24px;line-height:46px;font-size:16px}.VPButton.brand[data-v-cbd0f1a8]{border-color:var(--vp-button-brand-border);color:var(--vp-button-brand-text);background-color:var(--vp-button-brand-bg)}.VPButton.brand[data-v-cbd0f1a8]:hover{border-color:var(--vp-button-brand-hover-border);color:var(--vp-button-brand-hover-text);background-color:var(--vp-button-brand-hover-bg)}.VPButton.brand[data-v-cbd0f1a8]:active{border-color:var(--vp-button-brand-active-border);color:var(--vp-button-brand-active-text);background-color:var(--vp-button-brand-active-bg)}.VPButton.alt[data-v-cbd0f1a8]{border-color:var(--vp-button-alt-border);color:var(--vp-button-alt-text);background-color:var(--vp-button-alt-bg)}.VPButton.alt[data-v-cbd0f1a8]:hover{border-color:var(--vp-button-alt-hover-border);color:var(--vp-button-alt-hover-text);background-color:var(--vp-button-alt-hover-bg)}.VPButton.alt[data-v-cbd0f1a8]:active{border-color:var(--vp-button-alt-active-border);color:var(--vp-button-alt-active-text);background-color:var(--vp-button-alt-active-bg)}.VPButton.sponsor[data-v-cbd0f1a8]{border-color:var(--vp-button-sponsor-border);color:var(--vp-button-sponsor-text);background-color:var(--vp-button-sponsor-bg)}.VPButton.sponsor[data-v-cbd0f1a8]:hover{border-color:var(--vp-button-sponsor-hover-border);color:var(--vp-button-sponsor-hover-text);background-color:var(--vp-button-sponsor-hover-bg)}.VPButton.sponsor[data-v-cbd0f1a8]:active{border-color:var(--vp-button-sponsor-active-border);color:var(--vp-button-sponsor-active-text);background-color:var(--vp-button-sponsor-active-bg)}html:not(.dark) .VPImage.dark[data-v-713f3478]{display:none}.dark .VPImage.light[data-v-713f3478]{display:none}.VPHero[data-v-bb92d360]{margin-top:calc((var(--vp-nav-height) + var(--vp-layout-top-height, 0px)) * -1);padding:calc(var(--vp-nav-height) + var(--vp-layout-top-height, 0px) + 48px) 24px 48px}@media(min-width:640px){.VPHero[data-v-bb92d360]{padding:calc(var(--vp-nav-height) + var(--vp-layout-top-height, 0px) + 80px) 48px 64px}}@media(min-width:960px){.VPHero[data-v-bb92d360]{padding:calc(var(--vp-nav-height) + var(--vp-layout-top-height, 0px) + 80px) 64px 64px}}.container[data-v-bb92d360]{display:flex;flex-direction:column;margin:0 auto;max-width:1152px}@media(min-width:960px){.container[data-v-bb92d360]{flex-direction:row}}.main[data-v-bb92d360]{position:relative;z-index:10;order:2;flex-grow:1;flex-shrink:0}.VPHero.has-image .container[data-v-bb92d360]{text-align:center}@media(min-width:960px){.VPHero.has-image .container[data-v-bb92d360]{text-align:left}}@media(min-width:960px){.main[data-v-bb92d360]{order:1;width:calc((100% / 3) * 2)}.VPHero.has-image .main[data-v-bb92d360]{max-width:592px}}.heading[data-v-bb92d360]{display:flex;flex-direction:column}.name[data-v-bb92d360],.text[data-v-bb92d360]{width:fit-content;max-width:392px;letter-spacing:-.4px;line-height:40px;font-size:32px;font-weight:700;white-space:pre-wrap}.VPHero.has-image .name[data-v-bb92d360],.VPHero.has-image .text[data-v-bb92d360]{margin:0 auto}.name[data-v-bb92d360]{color:var(--vp-home-hero-name-color)}.clip[data-v-bb92d360]{background:var(--vp-home-hero-name-background);-webkit-background-clip:text;background-clip:text;-webkit-text-fill-color:var(--vp-home-hero-name-color)}@media(min-width:640px){.name[data-v-bb92d360],.text[data-v-bb92d360]{max-width:576px;line-height:56px;font-size:48px}}@media(min-width:960px){.name[data-v-bb92d360],.text[data-v-bb92d360]{line-height:64px;font-size:56px}.VPHero.has-image .name[data-v-bb92d360],.VPHero.has-image .text[data-v-bb92d360]{margin:0}}.tagline[data-v-bb92d360]{padding-top:8px;max-width:392px;line-height:28px;font-size:18px;font-weight:500;white-space:pre-wrap;color:var(--vp-c-text-2)}.VPHero.has-image .tagline[data-v-bb92d360]{margin:0 auto}@media(min-width:640px){.tagline[data-v-bb92d360]{padding-top:12px;max-width:576px;line-height:32px;font-size:20px}}@media(min-width:960px){.tagline[data-v-bb92d360]{line-height:36px;font-size:24px}.VPHero.has-image .tagline[data-v-bb92d360]{margin:0}}.actions[data-v-bb92d360]{display:flex;flex-wrap:wrap;margin:-6px;padding-top:24px}.VPHero.has-image .actions[data-v-bb92d360]{justify-content:center}@media(min-width:640px){.actions[data-v-bb92d360]{padding-top:32px}}@media(min-width:960px){.VPHero.has-image .actions[data-v-bb92d360]{justify-content:flex-start}}.action[data-v-bb92d360]{flex-shrink:0;padding:6px}.image[data-v-bb92d360]{order:1;margin:-76px -24px -48px}@media(min-width:640px){.image[data-v-bb92d360]{margin:-108px -24px -48px}}@media(min-width:960px){.image[data-v-bb92d360]{flex-grow:1;order:2;margin:0;min-height:100%}}.image-container[data-v-bb92d360]{position:relative;margin:0 auto;width:320px;height:320px}@media(min-width:640px){.image-container[data-v-bb92d360]{width:392px;height:392px}}@media(min-width:960px){.image-container[data-v-bb92d360]{display:flex;justify-content:center;align-items:center;width:100%;height:100%;transform:translate(-32px,-32px)}}.image-bg[data-v-bb92d360]{position:absolute;top:50%;left:50%;border-radius:50%;width:192px;height:192px;background-image:var(--vp-home-hero-image-background-image);filter:var(--vp-home-hero-image-filter);transform:translate(-50%,-50%)}@media(min-width:640px){.image-bg[data-v-bb92d360]{width:256px;height:256px}}@media(min-width:960px){.image-bg[data-v-bb92d360]{width:320px;height:320px}}[data-v-bb92d360] .image-src{position:absolute;top:50%;left:50%;max-width:192px;max-height:192px;transform:translate(-50%,-50%)}@media(min-width:640px){[data-v-bb92d360] .image-src{max-width:256px;max-height:256px}}@media(min-width:960px){[data-v-bb92d360] .image-src{max-width:320px;max-height:320px}}.VPFeature[data-v-dc805d92]{display:block;border:1px solid var(--vp-c-bg-soft);border-radius:12px;height:100%;background-color:var(--vp-c-bg-soft);transition:border-color .25s,background-color .25s}.VPFeature.link[data-v-dc805d92]:hover{border-color:var(--vp-c-brand-1)}.box[data-v-dc805d92]{display:flex;flex-direction:column;padding:24px;height:100%}.box[data-v-dc805d92]>.VPImage{margin-bottom:20px}.icon[data-v-dc805d92]{display:flex;justify-content:center;align-items:center;margin-bottom:20px;border-radius:6px;background-color:var(--vp-c-default-soft);width:48px;height:48px;font-size:24px;transition:background-color .25s}.title[data-v-dc805d92]{line-height:24px;font-size:16px;font-weight:600}.details[data-v-dc805d92]{flex-grow:1;padding-top:8px;line-height:24px;font-size:14px;font-weight:500;color:var(--vp-c-text-2)}.link-text[data-v-dc805d92]{padding-top:8px}.link-text-value[data-v-dc805d92]{display:flex;align-items:center;font-size:14px;font-weight:500;color:var(--vp-c-brand-1)}.link-text-icon[data-v-dc805d92]{margin-left:6px}.VPFeatures[data-v-4491a3bd]{position:relative;padding:0 24px}@media(min-width:640px){.VPFeatures[data-v-4491a3bd]{padding:0 48px}}@media(min-width:960px){.VPFeatures[data-v-4491a3bd]{padding:0 64px}}.container[data-v-4491a3bd]{margin:0 auto;max-width:1152px}.items[data-v-4491a3bd]{display:flex;flex-wrap:wrap;margin:-8px}.item[data-v-4491a3bd]{padding:8px;width:100%}@media(min-width:640px){.item.grid-2[data-v-4491a3bd],.item.grid-4[data-v-4491a3bd],.item.grid-6[data-v-4491a3bd]{width:50%}}@media(min-width:768px){.item.grid-2[data-v-4491a3bd],.item.grid-4[data-v-4491a3bd]{width:50%}.item.grid-3[data-v-4491a3bd],.item.grid-6[data-v-4491a3bd]{width:calc(100% / 3)}}@media(min-width:960px){.item.grid-4[data-v-4491a3bd]{width:25%}}.container[data-v-a6e74fd2]{margin:auto;width:100%;max-width:1280px;padding:0 24px}@media(min-width:640px){.container[data-v-a6e74fd2]{padding:0 48px}}@media(min-width:960px){.container[data-v-a6e74fd2]{width:100%;padding:0 64px}}.vp-doc[data-v-a6e74fd2] .VPHomeSponsors,.vp-doc[data-v-a6e74fd2] .VPTeamPage{margin-left:var(--vp-offset, calc(50% - 50vw) );margin-right:var(--vp-offset, calc(50% - 50vw) )}.vp-doc[data-v-a6e74fd2] .VPHomeSponsors h2{border-top:none;letter-spacing:normal}.vp-doc[data-v-a6e74fd2] .VPHomeSponsors a,.vp-doc[data-v-a6e74fd2] .VPTeamPage a{text-decoration:none}.VPHome[data-v-28935afa]{margin-bottom:96px}@media(min-width:768px){.VPHome[data-v-28935afa]{margin-bottom:128px}}.VPContent[data-v-422da788]{flex-grow:1;flex-shrink:0;margin:var(--vp-layout-top-height, 0px) auto 0;width:100%}.VPContent.is-home[data-v-422da788]{width:100%;max-width:100%}.VPContent.has-sidebar[data-v-422da788]{margin:0}@media(min-width:960px){.VPContent[data-v-422da788]{padding-top:var(--vp-nav-height)}.VPContent.has-sidebar[data-v-422da788]{margin:var(--vp-layout-top-height, 0px) 0 0;padding-left:var(--vp-sidebar-width)}}@media(min-width:1440px){.VPContent.has-sidebar[data-v-422da788]{padding-right:calc((100vw - var(--vp-layout-max-width)) / 2);padding-left:calc((100vw - var(--vp-layout-max-width)) / 2 + var(--vp-sidebar-width))}}.VPFooter[data-v-b3ad5ce0]{position:relative;z-index:var(--vp-z-index-footer);border-top:1px solid var(--vp-c-gutter);padding:32px 24px;background-color:var(--vp-c-bg)}.VPFooter.has-sidebar[data-v-b3ad5ce0]{display:none}.VPFooter[data-v-b3ad5ce0] a{text-decoration-line:underline;text-underline-offset:2px;transition:color .25s}.VPFooter[data-v-b3ad5ce0] a:hover{color:var(--vp-c-text-1)}@media(min-width:768px){.VPFooter[data-v-b3ad5ce0]{padding:32px}}.container[data-v-b3ad5ce0]{margin:0 auto;max-width:var(--vp-layout-max-width);text-align:center}.message[data-v-b3ad5ce0],.copyright[data-v-b3ad5ce0]{line-height:24px;font-size:14px;font-weight:500;color:var(--vp-c-text-2)}.VPLocalNavOutlineDropdown[data-v-0e38a025]{padding:12px 20px 11px}@media(min-width:960px){.VPLocalNavOutlineDropdown[data-v-0e38a025]{padding:12px 36px 11px}}.VPLocalNavOutlineDropdown button[data-v-0e38a025]{display:block;font-size:12px;font-weight:500;line-height:24px;color:var(--vp-c-text-2);transition:color .5s;position:relative}.VPLocalNavOutlineDropdown button[data-v-0e38a025]:hover{color:var(--vp-c-text-1);transition:color .25s}.VPLocalNavOutlineDropdown button.open[data-v-0e38a025]{color:var(--vp-c-text-1)}.icon[data-v-0e38a025]{display:inline-block;vertical-align:middle;margin-left:2px;font-size:14px;transform:rotate(0);transition:transform .25s}@media(min-width:960px){.VPLocalNavOutlineDropdown button[data-v-0e38a025]{font-size:14px}.icon[data-v-0e38a025]{font-size:16px}}.open>.icon[data-v-0e38a025]{transform:rotate(90deg)}.items[data-v-0e38a025]{position:absolute;top:40px;right:16px;left:16px;display:grid;gap:1px;border:1px solid var(--vp-c-border);border-radius:8px;background-color:var(--vp-c-gutter);max-height:calc(var(--vp-vh, 100vh) - 86px);overflow:hidden auto;box-shadow:var(--vp-shadow-3)}@media(min-width:960px){.items[data-v-0e38a025]{right:auto;left:calc(var(--vp-sidebar-width) + 32px);width:320px}}.header[data-v-0e38a025]{background-color:var(--vp-c-bg-soft)}.top-link[data-v-0e38a025]{display:block;padding:0 16px;line-height:48px;font-size:14px;font-weight:500;color:var(--vp-c-brand-1)}.outline[data-v-0e38a025]{padding:8px 0;background-color:var(--vp-c-bg-soft)}.flyout-enter-active[data-v-0e38a025]{transition:all .2s ease-out}.flyout-leave-active[data-v-0e38a025]{transition:all .15s ease-in}.flyout-enter-from[data-v-0e38a025],.flyout-leave-to[data-v-0e38a025]{opacity:0;transform:translateY(-16px)}.VPLocalNav[data-v-d06d210a]{position:sticky;top:0;left:0;z-index:var(--vp-z-index-local-nav);border-bottom:1px solid var(--vp-c-gutter);padding-top:var(--vp-layout-top-height, 0px);width:100%;background-color:var(--vp-local-nav-bg-color)}.VPLocalNav.fixed[data-v-d06d210a]{position:fixed}@media(min-width:960px){.VPLocalNav[data-v-d06d210a]{top:var(--vp-nav-height)}.VPLocalNav.has-sidebar[data-v-d06d210a]{padding-left:var(--vp-sidebar-width)}.VPLocalNav.empty[data-v-d06d210a]{display:none}}@media(min-width:1280px){.VPLocalNav[data-v-d06d210a]{display:none}}@media(min-width:1440px){.VPLocalNav.has-sidebar[data-v-d06d210a]{padding-left:calc((100vw - var(--vp-layout-max-width)) / 2 + var(--vp-sidebar-width))}}.container[data-v-d06d210a]{display:flex;justify-content:space-between;align-items:center}.menu[data-v-d06d210a]{display:flex;align-items:center;padding:12px 24px 11px;line-height:24px;font-size:12px;font-weight:500;color:var(--vp-c-text-2);transition:color .5s}.menu[data-v-d06d210a]:hover{color:var(--vp-c-text-1);transition:color .25s}@media(min-width:768px){.menu[data-v-d06d210a]{padding:0 32px}}@media(min-width:960px){.menu[data-v-d06d210a]{display:none}}.menu-icon[data-v-d06d210a]{margin-right:8px;font-size:14px}.VPOutlineDropdown[data-v-d06d210a]{padding:12px 24px 11px}@media(min-width:768px){.VPOutlineDropdown[data-v-d06d210a]{padding:12px 32px 11px}}.VPSwitch[data-v-2ba9eb1e]{position:relative;border-radius:11px;display:block;width:40px;height:22px;flex-shrink:0;border:1px solid var(--vp-input-border-color);background-color:var(--vp-input-switch-bg-color);transition:border-color .25s!important}.VPSwitch[data-v-2ba9eb1e]:hover{border-color:var(--vp-c-brand-1)}.check[data-v-2ba9eb1e]{position:absolute;top:1px;left:1px;width:18px;height:18px;border-radius:50%;background-color:var(--vp-c-neutral-inverse);box-shadow:var(--vp-shadow-1);transition:transform .25s!important}.icon[data-v-2ba9eb1e]{position:relative;display:block;width:18px;height:18px;border-radius:50%;overflow:hidden}.icon[data-v-2ba9eb1e] [class^=vpi-]{position:absolute;top:3px;left:3px;width:12px;height:12px;color:var(--vp-c-text-2)}.dark .icon[data-v-2ba9eb1e] [class^=vpi-]{color:var(--vp-c-text-1);transition:opacity .25s!important}.sun[data-v-0a38c41c]{opacity:1}.moon[data-v-0a38c41c],.dark .sun[data-v-0a38c41c]{opacity:0}.dark .moon[data-v-0a38c41c]{opacity:1}.dark .VPSwitchAppearance[data-v-0a38c41c] .check{transform:translate(18px)}.VPNavBarAppearance[data-v-0715029b]{display:none}@media(min-width:1280px){.VPNavBarAppearance[data-v-0715029b]{display:flex;align-items:center}}.VPMenuGroup+.VPMenuLink[data-v-fc99a6ef]{margin:12px -12px 0;border-top:1px solid var(--vp-c-divider);padding:12px 12px 0}.link[data-v-fc99a6ef]{display:block;border-radius:6px;padding:0 12px;line-height:32px;font-size:14px;font-weight:500;color:var(--vp-c-text-1);white-space:nowrap;transition:background-color .25s,color .25s}.link[data-v-fc99a6ef]:hover{color:var(--vp-c-brand-1);background-color:var(--vp-c-default-soft)}.link.active[data-v-fc99a6ef]{color:var(--vp-c-brand-1)}.VPMenuGroup[data-v-9fd5816a]{margin:12px -12px 0;border-top:1px solid var(--vp-c-divider);padding:12px 12px 0}.VPMenuGroup[data-v-9fd5816a]:first-child{margin-top:0;border-top:0;padding-top:0}.VPMenuGroup+.VPMenuGroup[data-v-9fd5816a]{margin-top:12px;border-top:1px solid var(--vp-c-divider)}.title[data-v-9fd5816a]{padding:0 12px;line-height:32px;font-size:14px;font-weight:600;color:var(--vp-c-text-2);white-space:nowrap;transition:color .25s}.VPMenu[data-v-2ecede1c]{border-radius:12px;padding:12px;min-width:128px;border:1px solid var(--vp-c-divider);background-color:var(--vp-c-bg-elv);box-shadow:var(--vp-shadow-3);transition:background-color .5s;max-height:calc(100vh - var(--vp-nav-height));overflow-y:auto}.VPMenu[data-v-2ecede1c] .group{margin:0 -12px;padding:0 12px 12px}.VPMenu[data-v-2ecede1c] .group+.group{border-top:1px solid var(--vp-c-divider);padding:11px 12px 12px}.VPMenu[data-v-2ecede1c] .group:last-child{padding-bottom:0}.VPMenu[data-v-2ecede1c] .group+.item{border-top:1px solid var(--vp-c-divider);padding:11px 16px 0}.VPMenu[data-v-2ecede1c] .item{padding:0 16px;white-space:nowrap}.VPMenu[data-v-2ecede1c] .label{flex-grow:1;line-height:28px;font-size:12px;font-weight:500;color:var(--vp-c-text-2);transition:color .5s}.VPMenu[data-v-2ecede1c] .action{padding-left:24px}.VPFlyout[data-v-a4cb0e19]{position:relative}.VPFlyout[data-v-a4cb0e19]:hover{color:var(--vp-c-brand-1);transition:color .25s}.VPFlyout:hover .text[data-v-a4cb0e19]{color:var(--vp-c-text-2)}.VPFlyout:hover .icon[data-v-a4cb0e19]{fill:var(--vp-c-text-2)}.VPFlyout.active .text[data-v-a4cb0e19]{color:var(--vp-c-brand-1)}.VPFlyout.active:hover .text[data-v-a4cb0e19]{color:var(--vp-c-brand-2)}.button[aria-expanded=false]+.menu[data-v-a4cb0e19]{opacity:0;visibility:hidden;transform:translateY(0)}.VPFlyout:hover .menu[data-v-a4cb0e19],.button[aria-expanded=true]+.menu[data-v-a4cb0e19]{opacity:1;visibility:visible;transform:translateY(0)}.button[data-v-a4cb0e19]{display:flex;align-items:center;padding:0 12px;height:var(--vp-nav-height);color:var(--vp-c-text-1);transition:color .5s}.text[data-v-a4cb0e19]{display:flex;align-items:center;line-height:var(--vp-nav-height);font-size:14px;font-weight:500;color:var(--vp-c-text-1);transition:color .25s}.option-icon[data-v-a4cb0e19]{margin-right:0;font-size:16px}.text-icon[data-v-a4cb0e19]{margin-left:4px;font-size:14px}.icon[data-v-a4cb0e19]{font-size:20px;transition:fill .25s}.menu[data-v-a4cb0e19]{position:absolute;top:calc(var(--vp-nav-height) / 2 + 20px);right:0;opacity:0;visibility:hidden;transition:opacity .25s,visibility .25s,transform .25s}.VPSocialLink[data-v-c300d4f5]{display:flex;justify-content:center;align-items:center;width:36px;height:36px;color:var(--vp-c-text-2);transition:color .5s}.VPSocialLink[data-v-c300d4f5]:hover{color:var(--vp-c-text-1);transition:color .25s}.VPSocialLink[data-v-c300d4f5]>svg,.VPSocialLink[data-v-c300d4f5]>[class^=vpi-social-]{width:20px;height:20px;fill:currentColor}.VPSocialLinks[data-v-5ace9ec0]{display:flex;justify-content:center}.VPNavBarExtra[data-v-ce206fa3]{display:none;margin-right:-12px}@media(min-width:768px){.VPNavBarExtra[data-v-ce206fa3]{display:block}}@media(min-width:1280px){.VPNavBarExtra[data-v-ce206fa3]{display:none}}.trans-title[data-v-ce206fa3]{padding:0 24px 0 12px;line-height:32px;font-size:14px;font-weight:700;color:var(--vp-c-text-1)}.item.appearance[data-v-ce206fa3],.item.social-links[data-v-ce206fa3]{display:flex;align-items:center;padding:0 12px}.item.appearance[data-v-ce206fa3]{min-width:176px}.appearance-action[data-v-ce206fa3]{margin-right:-2px}.social-links-list[data-v-ce206fa3]{margin:-4px -8px}.VPNavBarHamburger[data-v-87280792]{display:flex;justify-content:center;align-items:center;width:48px;height:var(--vp-nav-height)}@media(min-width:768px){.VPNavBarHamburger[data-v-87280792]{display:none}}.container[data-v-87280792]{position:relative;width:16px;height:14px;overflow:hidden}.VPNavBarHamburger:hover .top[data-v-87280792]{top:0;left:0;transform:translate(4px)}.VPNavBarHamburger:hover .middle[data-v-87280792]{top:6px;left:0;transform:translate(0)}.VPNavBarHamburger:hover .bottom[data-v-87280792]{top:12px;left:0;transform:translate(8px)}.VPNavBarHamburger.active .top[data-v-87280792]{top:6px;transform:translate(0) rotate(225deg)}.VPNavBarHamburger.active .middle[data-v-87280792]{top:6px;transform:translate(16px)}.VPNavBarHamburger.active .bottom[data-v-87280792]{top:6px;transform:translate(0) rotate(135deg)}.VPNavBarHamburger.active:hover .top[data-v-87280792],.VPNavBarHamburger.active:hover .middle[data-v-87280792],.VPNavBarHamburger.active:hover .bottom[data-v-87280792]{background-color:var(--vp-c-text-2);transition:top .25s,background-color .25s,transform .25s}.top[data-v-87280792],.middle[data-v-87280792],.bottom[data-v-87280792]{position:absolute;width:16px;height:2px;background-color:var(--vp-c-text-1);transition:top .25s,background-color .5s,transform .25s}.top[data-v-87280792]{top:0;left:0;transform:translate(0)}.middle[data-v-87280792]{top:6px;left:0;transform:translate(8px)}.bottom[data-v-87280792]{top:12px;left:0;transform:translate(4px)}.VPNavBarMenuLink[data-v-735ee087]{display:flex;align-items:center;padding:0 12px;line-height:var(--vp-nav-height);font-size:14px;font-weight:500;color:var(--vp-c-text-1);transition:color .25s}.VPNavBarMenuLink.active[data-v-735ee087],.VPNavBarMenuLink[data-v-735ee087]:hover{color:var(--vp-c-brand-1)}.VPNavBarMenu[data-v-2f030098]{display:none}@media(min-width:768px){.VPNavBarMenu[data-v-2f030098]{display:flex}}/*! @docsearch/css 3.8.2 | MIT License | © Algolia, Inc. and contributors | https://docsearch.algolia.com */:root{--docsearch-primary-color:#5468ff;--docsearch-text-color:#1c1e21;--docsearch-spacing:12px;--docsearch-icon-stroke-width:1.4;--docsearch-highlight-color:var(--docsearch-primary-color);--docsearch-muted-color:#969faf;--docsearch-container-background:rgba(101,108,133,.8);--docsearch-logo-color:#5468ff;--docsearch-modal-width:560px;--docsearch-modal-height:600px;--docsearch-modal-background:#f5f6f7;--docsearch-modal-shadow:inset 1px 1px 0 0 hsla(0,0%,100%,.5),0 3px 8px 0 #555a64;--docsearch-searchbox-height:56px;--docsearch-searchbox-background:#ebedf0;--docsearch-searchbox-focus-background:#fff;--docsearch-searchbox-shadow:inset 0 0 0 2px var(--docsearch-primary-color);--docsearch-hit-height:56px;--docsearch-hit-color:#444950;--docsearch-hit-active-color:#fff;--docsearch-hit-background:#fff;--docsearch-hit-shadow:0 1px 3px 0 #d4d9e1;--docsearch-key-gradient:linear-gradient(-225deg,#d5dbe4,#f8f8f8);--docsearch-key-shadow:inset 0 -2px 0 0 #cdcde6,inset 0 0 1px 1px #fff,0 1px 2px 1px rgba(30,35,90,.4);--docsearch-key-pressed-shadow:inset 0 -2px 0 0 #cdcde6,inset 0 0 1px 1px #fff,0 1px 1px 0 rgba(30,35,90,.4);--docsearch-footer-height:44px;--docsearch-footer-background:#fff;--docsearch-footer-shadow:0 -1px 0 0 #e0e3e8,0 -3px 6px 0 rgba(69,98,155,.12)}html[data-theme=dark]{--docsearch-text-color:#f5f6f7;--docsearch-container-background:rgba(9,10,17,.8);--docsearch-modal-background:#15172a;--docsearch-modal-shadow:inset 1px 1px 0 0 #2c2e40,0 3px 8px 0 #000309;--docsearch-searchbox-background:#090a11;--docsearch-searchbox-focus-background:#000;--docsearch-hit-color:#bec3c9;--docsearch-hit-shadow:none;--docsearch-hit-background:#090a11;--docsearch-key-gradient:linear-gradient(-26.5deg,#565872,#31355b);--docsearch-key-shadow:inset 0 -2px 0 0 #282d55,inset 0 0 1px 1px #51577d,0 2px 2px 0 rgba(3,4,9,.3);--docsearch-key-pressed-shadow:inset 0 -2px 0 0 #282d55,inset 0 0 1px 1px #51577d,0 1px 1px 0 #0304094d;--docsearch-footer-background:#1e2136;--docsearch-footer-shadow:inset 0 1px 0 0 rgba(73,76,106,.5),0 -4px 8px 0 rgba(0,0,0,.2);--docsearch-logo-color:#fff;--docsearch-muted-color:#7f8497}.DocSearch-Button{align-items:center;background:var(--docsearch-searchbox-background);border:0;border-radius:40px;color:var(--docsearch-muted-color);cursor:pointer;display:flex;font-weight:500;height:36px;justify-content:space-between;margin:0 0 0 16px;padding:0 8px;user-select:none}.DocSearch-Button:active,.DocSearch-Button:focus,.DocSearch-Button:hover{background:var(--docsearch-searchbox-focus-background);box-shadow:var(--docsearch-searchbox-shadow);color:var(--docsearch-text-color);outline:none}.DocSearch-Button-Container{align-items:center;display:flex}.DocSearch-Search-Icon{stroke-width:1.6}.DocSearch-Button .DocSearch-Search-Icon{color:var(--docsearch-text-color)}.DocSearch-Button-Placeholder{font-size:1rem;padding:0 12px 0 6px}.DocSearch-Button-Keys{display:flex;min-width:calc(40px + .8em)}.DocSearch-Button-Key{align-items:center;background:var(--docsearch-key-gradient);border:0;border-radius:3px;box-shadow:var(--docsearch-key-shadow);color:var(--docsearch-muted-color);display:flex;height:18px;justify-content:center;margin-right:.4em;padding:0 0 2px;position:relative;top:-1px;width:20px}.DocSearch-Button-Key--pressed{box-shadow:var(--docsearch-key-pressed-shadow);transform:translate3d(0,1px,0)}@media(max-width:768px){.DocSearch-Button-Keys,.DocSearch-Button-Placeholder{display:none}}.DocSearch--active{overflow:hidden!important}.DocSearch-Container,.DocSearch-Container *{box-sizing:border-box}.DocSearch-Container{background-color:var(--docsearch-container-background);height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:200}.DocSearch-Container a{text-decoration:none}.DocSearch-Link{appearance:none;background:none;border:0;color:var(--docsearch-highlight-color);cursor:pointer;font:inherit;margin:0;padding:0}.DocSearch-Modal{background:var(--docsearch-modal-background);border-radius:6px;box-shadow:var(--docsearch-modal-shadow);flex-direction:column;margin:60px auto auto;max-width:var(--docsearch-modal-width);position:relative}.DocSearch-SearchBar{display:flex;padding:var(--docsearch-spacing) var(--docsearch-spacing) 0}.DocSearch-Form{align-items:center;background:var(--docsearch-searchbox-focus-background);border-radius:4px;box-shadow:var(--docsearch-searchbox-shadow);display:flex;height:var(--docsearch-searchbox-height);margin:0;padding:0 var(--docsearch-spacing);position:relative;width:100%}.DocSearch-Input{appearance:none;background:transparent;border:0;color:var(--docsearch-text-color);flex:1;font:inherit;font-size:1.2em;height:100%;outline:none;padding:0 0 0 8px;width:80%}.DocSearch-Input::placeholder{color:var(--docsearch-muted-color);opacity:1}.DocSearch-Input::-webkit-search-cancel-button,.DocSearch-Input::-webkit-search-decoration,.DocSearch-Input::-webkit-search-results-button,.DocSearch-Input::-webkit-search-results-decoration{display:none}.DocSearch-LoadingIndicator,.DocSearch-MagnifierLabel,.DocSearch-Reset{margin:0;padding:0}.DocSearch-MagnifierLabel,.DocSearch-Reset{align-items:center;color:var(--docsearch-highlight-color);display:flex;justify-content:center}.DocSearch-Container--Stalled .DocSearch-MagnifierLabel,.DocSearch-LoadingIndicator{display:none}.DocSearch-Container--Stalled .DocSearch-LoadingIndicator{align-items:center;color:var(--docsearch-highlight-color);display:flex;justify-content:center}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Reset{animation:none;appearance:none;background:none;border:0;border-radius:50%;color:var(--docsearch-icon-color);cursor:pointer;right:0;stroke-width:var(--docsearch-icon-stroke-width)}}.DocSearch-Reset{animation:fade-in .1s ease-in forwards;appearance:none;background:none;border:0;border-radius:50%;color:var(--docsearch-icon-color);cursor:pointer;padding:2px;right:0;stroke-width:var(--docsearch-icon-stroke-width)}.DocSearch-Reset[hidden]{display:none}.DocSearch-Reset:hover{color:var(--docsearch-highlight-color)}.DocSearch-LoadingIndicator svg,.DocSearch-MagnifierLabel svg{height:24px;width:24px}.DocSearch-Cancel{display:none}.DocSearch-Dropdown{max-height:calc(var(--docsearch-modal-height) - var(--docsearch-searchbox-height) - var(--docsearch-spacing) - var(--docsearch-footer-height));min-height:var(--docsearch-spacing);overflow-y:auto;overflow-y:overlay;padding:0 var(--docsearch-spacing);scrollbar-color:var(--docsearch-muted-color) var(--docsearch-modal-background);scrollbar-width:thin}.DocSearch-Dropdown::-webkit-scrollbar{width:12px}.DocSearch-Dropdown::-webkit-scrollbar-track{background:transparent}.DocSearch-Dropdown::-webkit-scrollbar-thumb{background-color:var(--docsearch-muted-color);border:3px solid var(--docsearch-modal-background);border-radius:20px}.DocSearch-Dropdown ul{list-style:none;margin:0;padding:0}.DocSearch-Label{font-size:.75em;line-height:1.6em}.DocSearch-Help,.DocSearch-Label{color:var(--docsearch-muted-color)}.DocSearch-Help{font-size:.9em;margin:0;user-select:none}.DocSearch-Title{font-size:1.2em}.DocSearch-Logo a{display:flex}.DocSearch-Logo svg{color:var(--docsearch-logo-color);margin-left:8px}.DocSearch-Hits:last-of-type{margin-bottom:24px}.DocSearch-Hits mark{background:none;color:var(--docsearch-highlight-color)}.DocSearch-HitsFooter{color:var(--docsearch-muted-color);display:flex;font-size:.85em;justify-content:center;margin-bottom:var(--docsearch-spacing);padding:var(--docsearch-spacing)}.DocSearch-HitsFooter a{border-bottom:1px solid;color:inherit}.DocSearch-Hit{border-radius:4px;display:flex;padding-bottom:4px;position:relative}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Hit--deleting{transition:none}}.DocSearch-Hit--deleting{opacity:0;transition:all .25s linear}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Hit--favoriting{transition:none}}.DocSearch-Hit--favoriting{transform:scale(0);transform-origin:top center;transition:all .25s linear;transition-delay:.25s}.DocSearch-Hit a{background:var(--docsearch-hit-background);border-radius:4px;box-shadow:var(--docsearch-hit-shadow);display:block;padding-left:var(--docsearch-spacing);width:100%}.DocSearch-Hit-source{background:var(--docsearch-modal-background);color:var(--docsearch-highlight-color);font-size:.85em;font-weight:600;line-height:32px;margin:0 -4px;padding:8px 4px 0;position:sticky;top:0;z-index:10}.DocSearch-Hit-Tree{color:var(--docsearch-muted-color);height:var(--docsearch-hit-height);opacity:.5;stroke-width:var(--docsearch-icon-stroke-width);width:24px}.DocSearch-Hit[aria-selected=true] a{background-color:var(--docsearch-highlight-color)}.DocSearch-Hit[aria-selected=true] mark{text-decoration:underline}.DocSearch-Hit-Container{align-items:center;color:var(--docsearch-hit-color);display:flex;flex-direction:row;height:var(--docsearch-hit-height);padding:0 var(--docsearch-spacing) 0 0}.DocSearch-Hit-icon{height:20px;width:20px}.DocSearch-Hit-action,.DocSearch-Hit-icon{color:var(--docsearch-muted-color);stroke-width:var(--docsearch-icon-stroke-width)}.DocSearch-Hit-action{align-items:center;display:flex;height:22px;width:22px}.DocSearch-Hit-action svg{display:block;height:18px;width:18px}.DocSearch-Hit-action+.DocSearch-Hit-action{margin-left:6px}.DocSearch-Hit-action-button{appearance:none;background:none;border:0;border-radius:50%;color:inherit;cursor:pointer;padding:2px}svg.DocSearch-Hit-Select-Icon{display:none}.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-Select-Icon{display:block}.DocSearch-Hit-action-button:focus,.DocSearch-Hit-action-button:hover{background:#0003;transition:background-color .1s ease-in}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Hit-action-button:focus,.DocSearch-Hit-action-button:hover{transition:none}}.DocSearch-Hit-action-button:focus path,.DocSearch-Hit-action-button:hover path{fill:#fff}.DocSearch-Hit-content-wrapper{display:flex;flex:1 1 auto;flex-direction:column;font-weight:500;justify-content:center;line-height:1.2em;margin:0 8px;overflow-x:hidden;position:relative;text-overflow:ellipsis;white-space:nowrap;width:80%}.DocSearch-Hit-title{font-size:.9em}.DocSearch-Hit-path{color:var(--docsearch-muted-color);font-size:.75em}.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-Tree,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-action,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-icon,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-path,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-text,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-title,.DocSearch-Hit[aria-selected=true] mark{color:var(--docsearch-hit-active-color)!important}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Hit-action-button:focus,.DocSearch-Hit-action-button:hover{background:#0003;transition:none}}.DocSearch-ErrorScreen,.DocSearch-NoResults,.DocSearch-StartScreen{font-size:.9em;margin:0 auto;padding:36px 0;text-align:center;width:80%}.DocSearch-Screen-Icon{color:var(--docsearch-muted-color);padding-bottom:12px}.DocSearch-NoResults-Prefill-List{display:inline-block;padding-bottom:24px;text-align:left}.DocSearch-NoResults-Prefill-List ul{display:inline-block;padding:8px 0 0}.DocSearch-NoResults-Prefill-List li{list-style-position:inside;list-style-type:"» "}.DocSearch-Prefill{appearance:none;background:none;border:0;border-radius:1em;color:var(--docsearch-highlight-color);cursor:pointer;display:inline-block;font-size:1em;font-weight:700;padding:0}.DocSearch-Prefill:focus,.DocSearch-Prefill:hover{outline:none;text-decoration:underline}.DocSearch-Footer{align-items:center;background:var(--docsearch-footer-background);border-radius:0 0 8px 8px;box-shadow:var(--docsearch-footer-shadow);display:flex;flex-direction:row-reverse;flex-shrink:0;height:var(--docsearch-footer-height);justify-content:space-between;padding:0 var(--docsearch-spacing);position:relative;user-select:none;width:100%;z-index:300}.DocSearch-Commands{color:var(--docsearch-muted-color);display:flex;list-style:none;margin:0;padding:0}.DocSearch-Commands li{align-items:center;display:flex}.DocSearch-Commands li:not(:last-of-type){margin-right:.8em}.DocSearch-Commands-Key{align-items:center;background:var(--docsearch-key-gradient);border:0;border-radius:2px;box-shadow:var(--docsearch-key-shadow);color:var(--docsearch-muted-color);display:flex;height:18px;justify-content:center;margin-right:.4em;padding:0 0 1px;width:20px}.DocSearch-VisuallyHiddenForAccessibility{clip:rect(0 0 0 0);clip-path:inset(50%);height:1px;overflow:hidden;position:absolute;white-space:nowrap;width:1px}@media(max-width:768px){:root{--docsearch-spacing:10px;--docsearch-footer-height:40px}.DocSearch-Dropdown{height:100%}.DocSearch-Container{height:100vh;height:-webkit-fill-available;height:calc(var(--docsearch-vh, 1vh)*100);position:absolute}.DocSearch-Footer{border-radius:0;bottom:0;position:absolute}.DocSearch-Hit-content-wrapper{display:flex;position:relative;width:80%}.DocSearch-Modal{border-radius:0;box-shadow:none;height:100vh;height:-webkit-fill-available;height:calc(var(--docsearch-vh, 1vh)*100);margin:0;max-width:100%;width:100%}.DocSearch-Dropdown{max-height:calc(var(--docsearch-vh, 1vh)*100 - var(--docsearch-searchbox-height) - var(--docsearch-spacing) - var(--docsearch-footer-height))}.DocSearch-Cancel{appearance:none;background:none;border:0;color:var(--docsearch-highlight-color);cursor:pointer;display:inline-block;flex:none;font:inherit;font-size:1em;font-weight:500;margin-left:var(--docsearch-spacing);outline:none;overflow:hidden;padding:0;user-select:none;white-space:nowrap}.DocSearch-Commands,.DocSearch-Hit-Tree{display:none}}@keyframes fade-in{0%{opacity:0}to{opacity:1}}[class*=DocSearch]{--docsearch-primary-color: var(--vp-c-brand-1);--docsearch-highlight-color: var(--docsearch-primary-color);--docsearch-text-color: var(--vp-c-text-1);--docsearch-muted-color: var(--vp-c-text-2);--docsearch-searchbox-shadow: none;--docsearch-searchbox-background: transparent;--docsearch-searchbox-focus-background: transparent;--docsearch-key-gradient: transparent;--docsearch-key-shadow: none;--docsearch-modal-background: var(--vp-c-bg-soft);--docsearch-footer-background: var(--vp-c-bg)}.dark [class*=DocSearch]{--docsearch-modal-shadow: none;--docsearch-footer-shadow: none;--docsearch-logo-color: var(--vp-c-text-2);--docsearch-hit-background: var(--vp-c-default-soft);--docsearch-hit-color: var(--vp-c-text-2);--docsearch-hit-shadow: none}.DocSearch-Button{display:flex;justify-content:center;align-items:center;margin:0;padding:0;width:48px;height:55px;background:transparent;transition:border-color .25s}.DocSearch-Button:hover{background:transparent}.DocSearch-Button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}.DocSearch-Button-Key--pressed{transform:none;box-shadow:none}.DocSearch-Button:focus:not(:focus-visible){outline:none!important}@media(min-width:768px){.DocSearch-Button{justify-content:flex-start;border:1px solid transparent;border-radius:8px;padding:0 10px 0 12px;width:100%;height:40px;background-color:var(--vp-c-bg-alt)}.DocSearch-Button:hover{border-color:var(--vp-c-brand-1);background:var(--vp-c-bg-alt)}}.DocSearch-Button .DocSearch-Button-Container{display:flex;align-items:center}.DocSearch-Button .DocSearch-Search-Icon{position:relative;width:16px;height:16px;color:var(--vp-c-text-1);fill:currentColor;transition:color .5s}.DocSearch-Button:hover .DocSearch-Search-Icon{color:var(--vp-c-text-1)}@media(min-width:768px){.DocSearch-Button .DocSearch-Search-Icon{top:1px;margin-right:8px;width:14px;height:14px;color:var(--vp-c-text-2)}}.DocSearch-Button .DocSearch-Button-Placeholder{display:none;margin-top:2px;padding:0 16px 0 0;font-size:13px;font-weight:500;color:var(--vp-c-text-2);transition:color .5s}.DocSearch-Button:hover .DocSearch-Button-Placeholder{color:var(--vp-c-text-1)}@media(min-width:768px){.DocSearch-Button .DocSearch-Button-Placeholder{display:inline-block}}.DocSearch-Button .DocSearch-Button-Keys{direction:ltr;display:none;min-width:auto}@media(min-width:768px){.DocSearch-Button .DocSearch-Button-Keys{display:flex;align-items:center}}.DocSearch-Button .DocSearch-Button-Key{display:block;margin:2px 0 0;border:1px solid var(--vp-c-divider);border-right:none;border-radius:4px 0 0 4px;padding-left:6px;min-width:0;width:auto;height:22px;line-height:22px;font-family:var(--vp-font-family-base);font-size:12px;font-weight:500;transition:color .5s,border-color .5s}.DocSearch-Button .DocSearch-Button-Key+.DocSearch-Button-Key{border-right:1px solid var(--vp-c-divider);border-left:none;border-radius:0 4px 4px 0;padding-left:2px;padding-right:6px}.DocSearch-Button .DocSearch-Button-Key:first-child{font-size:0!important}.DocSearch-Button .DocSearch-Button-Key:first-child:after{content:"Ctrl";font-size:12px;letter-spacing:normal;color:var(--docsearch-muted-color)}.mac .DocSearch-Button .DocSearch-Button-Key:first-child:after{content:"⌘"}.DocSearch-Button .DocSearch-Button-Key:first-child>*{display:none}.DocSearch-Search-Icon{--icon: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' stroke-width='1.6' viewBox='0 0 20 20'%3E%3Cpath fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' d='m14.386 14.386 4.088 4.088-4.088-4.088A7.533 7.533 0 1 1 3.733 3.733a7.533 7.533 0 0 1 10.653 10.653z'/%3E%3C/svg%3E")}.VPNavBarSearch{display:flex;align-items:center}@media(min-width:768px){.VPNavBarSearch{flex-grow:1;padding-left:24px}}@media(min-width:960px){.VPNavBarSearch{padding-left:32px}}.dark .DocSearch-Footer{border-top:1px solid var(--vp-c-divider)}.DocSearch-Form{border:1px solid var(--vp-c-brand-1);background-color:var(--vp-c-white)}.dark .DocSearch-Form{background-color:var(--vp-c-default-soft)}.DocSearch-Screen-Icon>svg{margin:auto}.VPNavBarSocialLinks[data-v-02cad4ce]{display:none}@media(min-width:1280px){.VPNavBarSocialLinks[data-v-02cad4ce]{display:flex;align-items:center}}.title[data-v-a3e9f880]{display:flex;align-items:center;border-bottom:1px solid transparent;width:100%;height:var(--vp-nav-height);font-size:16px;font-weight:600;color:var(--vp-c-text-1);transition:opacity .25s}@media(min-width:960px){.title[data-v-a3e9f880]{flex-shrink:0}.VPNavBarTitle.has-sidebar .title[data-v-a3e9f880]{border-bottom-color:var(--vp-c-divider)}}[data-v-a3e9f880] .logo{margin-right:8px;height:var(--vp-nav-logo-height)}.VPNavBarTranslations[data-v-8e20710a]{display:none}@media(min-width:1280px){.VPNavBarTranslations[data-v-8e20710a]{display:flex;align-items:center}}.title[data-v-8e20710a]{padding:0 24px 0 12px;line-height:32px;font-size:14px;font-weight:700;color:var(--vp-c-text-1)}.VPNavBar[data-v-93e70900]{position:relative;height:var(--vp-nav-height);pointer-events:none;white-space:nowrap;transition:background-color .25s}.VPNavBar.screen-open[data-v-93e70900]{transition:none;background-color:var(--vp-nav-bg-color);border-bottom:1px solid var(--vp-c-divider)}.VPNavBar[data-v-93e70900]:not(.home){background-color:var(--vp-nav-bg-color)}@media(min-width:960px){.VPNavBar[data-v-93e70900]:not(.home){background-color:transparent}.VPNavBar[data-v-93e70900]:not(.has-sidebar):not(.home.top){background-color:var(--vp-nav-bg-color)}}.wrapper[data-v-93e70900]{padding:0 8px 0 24px}@media(min-width:768px){.wrapper[data-v-93e70900]{padding:0 32px}}@media(min-width:960px){.VPNavBar.has-sidebar .wrapper[data-v-93e70900]{padding:0}}.container[data-v-93e70900]{display:flex;justify-content:space-between;margin:0 auto;max-width:calc(var(--vp-layout-max-width) - 64px);height:var(--vp-nav-height);pointer-events:none}.container>.title[data-v-93e70900],.container>.content[data-v-93e70900]{pointer-events:none}.container[data-v-93e70900] *{pointer-events:auto}@media(min-width:960px){.VPNavBar.has-sidebar .container[data-v-93e70900]{max-width:100%}}.title[data-v-93e70900]{flex-shrink:0;height:calc(var(--vp-nav-height) - 1px);transition:background-color .5s}@media(min-width:960px){.VPNavBar.has-sidebar .title[data-v-93e70900]{position:absolute;top:0;left:0;z-index:2;padding:0 32px;width:var(--vp-sidebar-width);height:var(--vp-nav-height);background-color:transparent}}@media(min-width:1440px){.VPNavBar.has-sidebar .title[data-v-93e70900]{padding-left:max(32px,calc((100% - (var(--vp-layout-max-width) - 64px)) / 2));width:calc((100% - (var(--vp-layout-max-width) - 64px)) / 2 + var(--vp-sidebar-width) - 32px)}}.content[data-v-93e70900]{flex-grow:1}@media(min-width:960px){.VPNavBar.has-sidebar .content[data-v-93e70900]{position:relative;z-index:1;padding-right:32px;padding-left:var(--vp-sidebar-width)}}@media(min-width:1440px){.VPNavBar.has-sidebar .content[data-v-93e70900]{padding-right:calc((100vw - var(--vp-layout-max-width)) / 2 + 32px);padding-left:calc((100vw - var(--vp-layout-max-width)) / 2 + var(--vp-sidebar-width))}}.content-body[data-v-93e70900]{display:flex;justify-content:flex-end;align-items:center;height:var(--vp-nav-height);transition:background-color .5s}@media(min-width:960px){.VPNavBar:not(.home.top) .content-body[data-v-93e70900]{position:relative;background-color:var(--vp-nav-bg-color)}.VPNavBar:not(.has-sidebar):not(.home.top) .content-body[data-v-93e70900]{background-color:transparent}}@media(max-width:767px){.content-body[data-v-93e70900]{column-gap:.5rem}}.menu+.translations[data-v-93e70900]:before,.menu+.appearance[data-v-93e70900]:before,.menu+.social-links[data-v-93e70900]:before,.translations+.appearance[data-v-93e70900]:before,.appearance+.social-links[data-v-93e70900]:before{margin-right:8px;margin-left:8px;width:1px;height:24px;background-color:var(--vp-c-divider);content:""}.menu+.appearance[data-v-93e70900]:before,.translations+.appearance[data-v-93e70900]:before{margin-right:16px}.appearance+.social-links[data-v-93e70900]:before{margin-left:16px}.social-links[data-v-93e70900]{margin-right:-8px}.divider[data-v-93e70900]{width:100%;height:1px}@media(min-width:960px){.VPNavBar.has-sidebar .divider[data-v-93e70900]{padding-left:var(--vp-sidebar-width)}}@media(min-width:1440px){.VPNavBar.has-sidebar .divider[data-v-93e70900]{padding-left:calc((100vw - var(--vp-layout-max-width)) / 2 + var(--vp-sidebar-width))}}.divider-line[data-v-93e70900]{width:100%;height:1px;transition:background-color .5s}.VPNavBar:not(.home) .divider-line[data-v-93e70900]{background-color:var(--vp-c-gutter)}@media(min-width:960px){.VPNavBar:not(.home.top) .divider-line[data-v-93e70900]{background-color:var(--vp-c-gutter)}.VPNavBar:not(.has-sidebar):not(.home.top) .divider[data-v-93e70900]{background-color:var(--vp-c-gutter)}}.VPNavScreenAppearance[data-v-d4b75105]{display:flex;justify-content:space-between;align-items:center;border-radius:8px;padding:12px 14px 12px 16px;background-color:var(--vp-c-bg-soft)}.text[data-v-d4b75105]{line-height:24px;font-size:12px;font-weight:500;color:var(--vp-c-text-2)}.VPNavScreenMenuLink[data-v-7c8408f3]{display:block;border-bottom:1px solid var(--vp-c-divider);padding:12px 0 11px;line-height:24px;font-size:14px;font-weight:500;color:var(--vp-c-text-1);transition:border-color .25s,color .25s}.VPNavScreenMenuLink[data-v-7c8408f3]:hover{color:var(--vp-c-brand-1)}.VPNavScreenMenuGroupLink[data-v-89ef6f22]{display:block;margin-left:12px;line-height:32px;font-size:14px;font-weight:400;color:var(--vp-c-text-1);transition:color .25s}.VPNavScreenMenuGroupLink[data-v-89ef6f22]:hover{color:var(--vp-c-brand-1)}.VPNavScreenMenuGroupSection[data-v-98b82a0d]{display:block}.title[data-v-98b82a0d]{line-height:32px;font-size:13px;font-weight:700;color:var(--vp-c-text-2);transition:color .25s}.VPNavScreenMenuGroup[data-v-a2b53d44]{border-bottom:1px solid var(--vp-c-divider);height:48px;overflow:hidden;transition:border-color .5s}.VPNavScreenMenuGroup .items[data-v-a2b53d44]{visibility:hidden}.VPNavScreenMenuGroup.open .items[data-v-a2b53d44]{visibility:visible}.VPNavScreenMenuGroup.open[data-v-a2b53d44]{padding-bottom:10px;height:auto}.VPNavScreenMenuGroup.open .button[data-v-a2b53d44]{padding-bottom:6px;color:var(--vp-c-brand-1)}.VPNavScreenMenuGroup.open .button-icon[data-v-a2b53d44]{transform:rotate(45deg)}.button[data-v-a2b53d44]{display:flex;justify-content:space-between;align-items:center;padding:12px 4px 11px 0;width:100%;line-height:24px;font-size:14px;font-weight:500;color:var(--vp-c-text-1);transition:color .25s}.button[data-v-a2b53d44]:hover{color:var(--vp-c-brand-1)}.button-icon[data-v-a2b53d44]{transition:transform .25s}.group[data-v-a2b53d44]:first-child{padding-top:0}.group+.group[data-v-a2b53d44],.group+.item[data-v-a2b53d44]{padding-top:4px}.VPNavScreenTranslations[data-v-1cc5a949]{height:24px;overflow:hidden}.VPNavScreenTranslations.open[data-v-1cc5a949]{height:auto}.title[data-v-1cc5a949]{display:flex;align-items:center;font-size:14px;font-weight:500;color:var(--vp-c-text-1)}.icon[data-v-1cc5a949]{font-size:16px}.icon.lang[data-v-1cc5a949]{margin-right:8px}.icon.chevron[data-v-1cc5a949]{margin-left:4px}.list[data-v-1cc5a949]{padding:4px 0 0 24px}.link[data-v-1cc5a949]{line-height:32px;font-size:13px;color:var(--vp-c-text-1)}.VPNavScreen[data-v-0ad0c2e2]{position:fixed;top:calc(var(--vp-nav-height) + var(--vp-layout-top-height, 0px));right:0;bottom:0;left:0;padding:0 32px;width:100%;background-color:var(--vp-nav-screen-bg-color);overflow-y:auto;transition:background-color .25s;pointer-events:auto}.VPNavScreen.fade-enter-active[data-v-0ad0c2e2],.VPNavScreen.fade-leave-active[data-v-0ad0c2e2]{transition:opacity .25s}.VPNavScreen.fade-enter-active .container[data-v-0ad0c2e2],.VPNavScreen.fade-leave-active .container[data-v-0ad0c2e2]{transition:transform .25s ease}.VPNavScreen.fade-enter-from[data-v-0ad0c2e2],.VPNavScreen.fade-leave-to[data-v-0ad0c2e2]{opacity:0}.VPNavScreen.fade-enter-from .container[data-v-0ad0c2e2],.VPNavScreen.fade-leave-to .container[data-v-0ad0c2e2]{transform:translateY(-8px)}@media(min-width:768px){.VPNavScreen[data-v-0ad0c2e2]{display:none}}.container[data-v-0ad0c2e2]{margin:0 auto;padding:24px 0 96px;max-width:288px}.menu+.translations[data-v-0ad0c2e2],.menu+.appearance[data-v-0ad0c2e2],.translations+.appearance[data-v-0ad0c2e2]{margin-top:24px}.menu+.social-links[data-v-0ad0c2e2]{margin-top:16px}.appearance+.social-links[data-v-0ad0c2e2]{margin-top:16px}.VPNav[data-v-13b6eb60]{position:relative;top:var(--vp-layout-top-height, 0px);left:0;z-index:var(--vp-z-index-nav);width:100%;pointer-events:none;transition:background-color .5s}@media(min-width:960px){.VPNav[data-v-13b6eb60]{position:fixed}}.VPSidebarItem.level-0[data-v-7e70fccd]{padding-bottom:24px}.VPSidebarItem.collapsed.level-0[data-v-7e70fccd]{padding-bottom:10px}.item[data-v-7e70fccd]{position:relative;display:flex;width:100%}.VPSidebarItem.collapsible>.item[data-v-7e70fccd]{cursor:pointer}.indicator[data-v-7e70fccd]{position:absolute;top:6px;bottom:6px;left:-17px;width:2px;border-radius:2px;transition:background-color .25s}.VPSidebarItem.level-2.is-active>.item>.indicator[data-v-7e70fccd],.VPSidebarItem.level-3.is-active>.item>.indicator[data-v-7e70fccd],.VPSidebarItem.level-4.is-active>.item>.indicator[data-v-7e70fccd],.VPSidebarItem.level-5.is-active>.item>.indicator[data-v-7e70fccd]{background-color:var(--vp-c-brand-1)}.link[data-v-7e70fccd]{display:flex;align-items:center;flex-grow:1}.text[data-v-7e70fccd]{flex-grow:1;padding:4px 0;line-height:24px;font-size:14px;transition:color .25s}.VPSidebarItem.level-0 .text[data-v-7e70fccd]{font-weight:700;color:var(--vp-c-text-1)}.VPSidebarItem.level-1 .text[data-v-7e70fccd],.VPSidebarItem.level-2 .text[data-v-7e70fccd],.VPSidebarItem.level-3 .text[data-v-7e70fccd],.VPSidebarItem.level-4 .text[data-v-7e70fccd],.VPSidebarItem.level-5 .text[data-v-7e70fccd]{font-weight:500;color:var(--vp-c-text-2)}.VPSidebarItem.level-0.is-link>.item>.link:hover .text[data-v-7e70fccd],.VPSidebarItem.level-1.is-link>.item>.link:hover .text[data-v-7e70fccd],.VPSidebarItem.level-2.is-link>.item>.link:hover .text[data-v-7e70fccd],.VPSidebarItem.level-3.is-link>.item>.link:hover .text[data-v-7e70fccd],.VPSidebarItem.level-4.is-link>.item>.link:hover .text[data-v-7e70fccd],.VPSidebarItem.level-5.is-link>.item>.link:hover .text[data-v-7e70fccd]{color:var(--vp-c-brand-1)}.VPSidebarItem.level-0.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-1.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-2.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-3.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-4.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-5.has-active>.item>.text[data-v-7e70fccd],.VPSidebarItem.level-0.has-active>.item>.link>.text[data-v-7e70fccd],.VPSidebarItem.level-1.has-active>.item>.link>.text[data-v-7e70fccd],.VPSidebarItem.level-2.has-active>.item>.link>.text[data-v-7e70fccd],.VPSidebarItem.level-3.has-active>.item>.link>.text[data-v-7e70fccd],.VPSidebarItem.level-4.has-active>.item>.link>.text[data-v-7e70fccd],.VPSidebarItem.level-5.has-active>.item>.link>.text[data-v-7e70fccd]{color:var(--vp-c-text-1)}.VPSidebarItem.level-0.is-active>.item .link>.text[data-v-7e70fccd],.VPSidebarItem.level-1.is-active>.item .link>.text[data-v-7e70fccd],.VPSidebarItem.level-2.is-active>.item .link>.text[data-v-7e70fccd],.VPSidebarItem.level-3.is-active>.item .link>.text[data-v-7e70fccd],.VPSidebarItem.level-4.is-active>.item .link>.text[data-v-7e70fccd],.VPSidebarItem.level-5.is-active>.item .link>.text[data-v-7e70fccd]{color:var(--vp-c-brand-1)}.caret[data-v-7e70fccd]{display:flex;justify-content:center;align-items:center;margin-right:-7px;width:32px;height:32px;color:var(--vp-c-text-3);cursor:pointer;transition:color .25s;flex-shrink:0}.item:hover .caret[data-v-7e70fccd]{color:var(--vp-c-text-2)}.item:hover .caret[data-v-7e70fccd]:hover{color:var(--vp-c-text-1)}.caret-icon[data-v-7e70fccd]{font-size:18px;transform:rotate(90deg);transition:transform .25s}.VPSidebarItem.collapsed .caret-icon[data-v-7e70fccd]{transform:rotate(0)}.VPSidebarItem.level-1 .items[data-v-7e70fccd],.VPSidebarItem.level-2 .items[data-v-7e70fccd],.VPSidebarItem.level-3 .items[data-v-7e70fccd],.VPSidebarItem.level-4 .items[data-v-7e70fccd],.VPSidebarItem.level-5 .items[data-v-7e70fccd]{border-left:1px solid var(--vp-c-divider);padding-left:16px}.VPSidebarItem.collapsed .items[data-v-7e70fccd]{display:none}.no-transition[data-v-ecb5358a] .caret-icon{transition:none}.group+.group[data-v-ecb5358a]{border-top:1px solid var(--vp-c-divider);padding-top:10px}@media(min-width:960px){.group[data-v-ecb5358a]{padding-top:10px;width:calc(var(--vp-sidebar-width) - 64px)}}.VPSidebar[data-v-41586462]{position:fixed;top:var(--vp-layout-top-height, 0px);bottom:0;left:0;z-index:var(--vp-z-index-sidebar);padding:32px 32px 96px;width:calc(100vw - 64px);max-width:320px;background-color:var(--vp-sidebar-bg-color);opacity:0;box-shadow:var(--vp-c-shadow-3);overflow-x:hidden;overflow-y:auto;transform:translate(-100%);transition:opacity .5s,transform .25s ease;overscroll-behavior:contain}.VPSidebar.open[data-v-41586462]{opacity:1;visibility:visible;transform:translate(0);transition:opacity .25s,transform .5s cubic-bezier(.19,1,.22,1)}.dark .VPSidebar[data-v-41586462]{box-shadow:var(--vp-shadow-1)}@media(min-width:960px){.VPSidebar[data-v-41586462]{padding-top:var(--vp-nav-height);width:var(--vp-sidebar-width);max-width:100%;background-color:var(--vp-sidebar-bg-color);opacity:1;visibility:visible;box-shadow:none;transform:translate(0)}}@media(min-width:1440px){.VPSidebar[data-v-41586462]{padding-left:max(32px,calc((100% - (var(--vp-layout-max-width) - 64px)) / 2));width:calc((100% - (var(--vp-layout-max-width) - 64px)) / 2 + var(--vp-sidebar-width) - 32px)}}@media(min-width:960px){.curtain[data-v-41586462]{position:sticky;top:-64px;left:0;z-index:1;margin-top:calc(var(--vp-nav-height) * -1);margin-right:-32px;margin-left:-32px;height:var(--vp-nav-height);background-color:var(--vp-sidebar-bg-color)}}.nav[data-v-41586462]{outline:0}.VPSkipLink[data-v-654948f2]{top:8px;left:8px;padding:8px 16px;z-index:999;border-radius:8px;font-size:12px;font-weight:700;text-decoration:none;color:var(--vp-c-brand-1);box-shadow:var(--vp-shadow-3);background-color:var(--vp-c-bg)}.VPSkipLink[data-v-654948f2]:focus{height:auto;width:auto;clip:auto;clip-path:none}@media(min-width:1280px){.VPSkipLink[data-v-654948f2]{top:14px;left:16px}}.Layout[data-v-f81a5f2e]{display:flex;flex-direction:column;min-height:100vh}.VPHomeSponsors[data-v-f996d063]{border-top:1px solid var(--vp-c-gutter);padding-top:88px!important}.VPHomeSponsors[data-v-f996d063]{margin:96px 0}@media(min-width:768px){.VPHomeSponsors[data-v-f996d063]{margin:128px 0}}.VPHomeSponsors[data-v-f996d063]{padding:0 24px}@media(min-width:768px){.VPHomeSponsors[data-v-f996d063]{padding:0 48px}}@media(min-width:960px){.VPHomeSponsors[data-v-f996d063]{padding:0 64px}}.container[data-v-f996d063]{margin:0 auto;max-width:1152px}.love[data-v-f996d063]{margin:0 auto;width:fit-content;font-size:28px;color:var(--vp-c-text-3)}.icon[data-v-f996d063]{display:inline-block}.message[data-v-f996d063]{margin:0 auto;padding-top:10px;max-width:320px;text-align:center;line-height:24px;font-size:16px;font-weight:500;color:var(--vp-c-text-2)}.sponsors[data-v-f996d063]{padding-top:32px}.action[data-v-f996d063]{padding-top:40px;text-align:center}.VPTeamMembersItem[data-v-3d0dba6c]{display:flex;flex-direction:column;gap:2px;border-radius:12px;width:100%;height:100%;overflow:hidden}.VPTeamMembersItem.small .profile[data-v-3d0dba6c]{padding:32px}.VPTeamMembersItem.small .data[data-v-3d0dba6c]{padding-top:20px}.VPTeamMembersItem.small .avatar[data-v-3d0dba6c]{width:64px;height:64px}.VPTeamMembersItem.small .name[data-v-3d0dba6c]{line-height:24px;font-size:16px}.VPTeamMembersItem.small .affiliation[data-v-3d0dba6c]{padding-top:4px;line-height:20px;font-size:14px}.VPTeamMembersItem.small .desc[data-v-3d0dba6c]{padding-top:12px;line-height:20px;font-size:14px}.VPTeamMembersItem.small .links[data-v-3d0dba6c]{margin:0 -16px -20px;padding:10px 0 0}.VPTeamMembersItem.medium .profile[data-v-3d0dba6c]{padding:48px 32px}.VPTeamMembersItem.medium .data[data-v-3d0dba6c]{padding-top:24px;text-align:center}.VPTeamMembersItem.medium .avatar[data-v-3d0dba6c]{width:96px;height:96px}.VPTeamMembersItem.medium .name[data-v-3d0dba6c]{letter-spacing:.15px;line-height:28px;font-size:20px}.VPTeamMembersItem.medium .affiliation[data-v-3d0dba6c]{padding-top:4px;font-size:16px}.VPTeamMembersItem.medium .desc[data-v-3d0dba6c]{padding-top:16px;max-width:288px;font-size:16px}.VPTeamMembersItem.medium .links[data-v-3d0dba6c]{margin:0 -16px -12px;padding:16px 12px 0}.profile[data-v-3d0dba6c]{flex-grow:1;background-color:var(--vp-c-bg-soft)}.data[data-v-3d0dba6c]{text-align:center}.avatar[data-v-3d0dba6c]{position:relative;flex-shrink:0;margin:0 auto;border-radius:50%;box-shadow:var(--vp-shadow-3)}.avatar-img[data-v-3d0dba6c]{position:absolute;inset:0;border-radius:50%;object-fit:cover}.name[data-v-3d0dba6c]{margin:0;font-weight:600}.affiliation[data-v-3d0dba6c]{margin:0;font-weight:500;color:var(--vp-c-text-2)}.org.link[data-v-3d0dba6c]{color:var(--vp-c-text-2);transition:color .25s}.org.link[data-v-3d0dba6c]:hover{color:var(--vp-c-brand-1)}.desc[data-v-3d0dba6c]{margin:0 auto}.desc[data-v-3d0dba6c] a{font-weight:500;color:var(--vp-c-brand-1);text-decoration-style:dotted;transition:color .25s}.links[data-v-3d0dba6c]{display:flex;justify-content:center;height:56px}.sp-link[data-v-3d0dba6c]{display:flex;justify-content:center;align-items:center;text-align:center;padding:16px;font-size:14px;font-weight:500;color:var(--vp-c-sponsor);background-color:var(--vp-c-bg-soft);transition:color .25s,background-color .25s}.sp .sp-link.link[data-v-3d0dba6c]:hover,.sp .sp-link.link[data-v-3d0dba6c]:focus{outline:none;color:var(--vp-c-white);background-color:var(--vp-c-sponsor)}.sp-icon[data-v-3d0dba6c]{margin-right:8px;font-size:16px}.VPTeamMembers.small .container[data-v-c21e88e0]{grid-template-columns:repeat(auto-fit,minmax(224px,1fr))}.VPTeamMembers.small.count-1 .container[data-v-c21e88e0]{max-width:276px}.VPTeamMembers.small.count-2 .container[data-v-c21e88e0]{max-width:576px}.VPTeamMembers.small.count-3 .container[data-v-c21e88e0]{max-width:876px}.VPTeamMembers.medium .container[data-v-c21e88e0]{grid-template-columns:repeat(auto-fit,minmax(256px,1fr))}@media(min-width:375px){.VPTeamMembers.medium .container[data-v-c21e88e0]{grid-template-columns:repeat(auto-fit,minmax(288px,1fr))}}.VPTeamMembers.medium.count-1 .container[data-v-c21e88e0]{max-width:368px}.VPTeamMembers.medium.count-2 .container[data-v-c21e88e0]{max-width:760px}.container[data-v-c21e88e0]{display:grid;gap:24px;margin:0 auto;max-width:1152px}.VPTeamPage[data-v-f961e78b]{margin:96px 0}@media(min-width:768px){.VPTeamPage[data-v-f961e78b]{margin:128px 0}}.VPHome .VPTeamPageTitle[data-v-f961e78b-s]{border-top:1px solid var(--vp-c-gutter);padding-top:88px!important}.VPTeamPageSection+.VPTeamPageSection[data-v-f961e78b-s],.VPTeamMembers+.VPTeamPageSection[data-v-f961e78b-s]{margin-top:64px}.VPTeamMembers+.VPTeamMembers[data-v-f961e78b-s]{margin-top:24px}@media(min-width:768px){.VPTeamPageTitle+.VPTeamPageSection[data-v-f961e78b-s]{margin-top:16px}.VPTeamPageSection+.VPTeamPageSection[data-v-f961e78b-s],.VPTeamMembers+.VPTeamPageSection[data-v-f961e78b-s]{margin-top:96px}}.VPTeamMembers[data-v-f961e78b-s]{padding:0 24px}@media(min-width:768px){.VPTeamMembers[data-v-f961e78b-s]{padding:0 48px}}@media(min-width:960px){.VPTeamMembers[data-v-f961e78b-s]{padding:0 64px}}.VPTeamPageSection[data-v-61ecb2d4]{padding:0 32px}@media(min-width:768px){.VPTeamPageSection[data-v-61ecb2d4]{padding:0 48px}}@media(min-width:960px){.VPTeamPageSection[data-v-61ecb2d4]{padding:0 64px}}.title[data-v-61ecb2d4]{position:relative;margin:0 auto;max-width:1152px;text-align:center;color:var(--vp-c-text-2)}.title-line[data-v-61ecb2d4]{position:absolute;top:16px;left:0;width:100%;height:1px;background-color:var(--vp-c-divider)}.title-text[data-v-61ecb2d4]{position:relative;display:inline-block;padding:0 24px;letter-spacing:0;line-height:32px;font-size:20px;font-weight:500;background-color:var(--vp-c-bg)}.lead[data-v-61ecb2d4]{margin:0 auto;max-width:480px;padding-top:12px;text-align:center;line-height:24px;font-size:16px;font-weight:500;color:var(--vp-c-text-2)}.members[data-v-61ecb2d4]{padding-top:40px}.VPTeamPageTitle[data-v-811fa16d]{padding:48px 32px;text-align:center}@media(min-width:768px){.VPTeamPageTitle[data-v-811fa16d]{padding:64px 48px 48px}}@media(min-width:960px){.VPTeamPageTitle[data-v-811fa16d]{padding:80px 64px 48px}}.title[data-v-811fa16d]{letter-spacing:0;line-height:44px;font-size:36px;font-weight:500}@media(min-width:768px){.title[data-v-811fa16d]{letter-spacing:-.5px;line-height:56px;font-size:48px}}.lead[data-v-811fa16d]{margin:0 auto;max-width:512px;padding-top:12px;line-height:24px;font-size:16px;font-weight:500;color:var(--vp-c-text-2)}@media(min-width:768px){.lead[data-v-811fa16d]{max-width:592px;letter-spacing:.15px;line-height:28px;font-size:20px}}.catalog-container[data-v-1da38fb5]{margin-top:1.5rem}.section-title[data-v-1da38fb5]{margin-top:2rem;margin-bottom:.25rem}.section-subtitle[data-v-1da38fb5]{font-size:.95rem;color:var(--vp-c-text-2);margin-bottom:1.5rem}.domain-group[data-v-1da38fb5]{margin-bottom:2.25rem}.domain-header[data-v-1da38fb5]{margin-bottom:.75rem;padding-bottom:.4rem;border-bottom:1px solid var(--vp-c-divider)}.domain-title[data-v-1da38fb5]{margin:0;font-size:1.15rem;font-weight:600;color:var(--vp-c-text-1)}.domain-desc[data-v-1da38fb5]{margin:.2rem 0 0;font-size:.85rem;color:var(--vp-c-text-2)}.row-list[data-v-1da38fb5]{display:flex;flex-direction:column;gap:.6rem}.plugin-row[data-v-1da38fb5]{display:flex;align-items:center;justify-content:space-between;gap:1.5rem;padding:.85rem 1.15rem;background-color:var(--vp-c-bg-soft);border:1px solid var(--vp-c-divider);border-radius:8px;transition:border-color .2s ease,background-color .2s ease}.plugin-row[data-v-1da38fb5]:hover{border-color:var(--vp-c-brand);background-color:var(--vp-c-bg-mute)}.plugin-info[data-v-1da38fb5]{flex:1 1 auto;min-width:0}.title-line[data-v-1da38fb5]{display:flex;align-items:center;gap:.5rem;flex-wrap:wrap}.plugin-name[data-v-1da38fb5]{font-weight:600;font-size:1.05rem;color:var(--vp-c-text-1)}.version-tag[data-v-1da38fb5]{font-size:.75rem;font-weight:500;color:var(--vp-c-text-3);background-color:var(--vp-c-bg-mute);padding:1px 6px;border-radius:4px;border:1px solid var(--vp-c-divider)}.plugin-desc[data-v-1da38fb5]{margin:.25rem 0 0;font-size:.875rem;color:var(--vp-c-text-2);line-height:1.45}.plugin-actions[data-v-1da38fb5]{display:flex;align-items:center;gap:.4rem;flex-shrink:0}.copy-wrapper[data-v-1da38fb5]{position:relative;display:flex;align-items:center}.action-btn[data-v-1da38fb5]{display:inline-flex;align-items:center;justify-content:center;background-color:var(--vp-c-bg-alt, var(--vp-c-bg));border:1px solid var(--vp-c-divider);padding:.4rem .55rem;border-radius:6px;cursor:pointer;white-space:nowrap;transition:border-color .15s ease,background-color .15s ease,color .15s ease}.copy-icon-btn[data-v-1da38fb5]{color:var(--vp-c-brand)}.copy-icon-btn[data-v-1da38fb5]:hover{border-color:var(--vp-c-brand);color:var(--vp-c-brand);background-color:var(--vp-c-brand-soft, var(--vp-c-bg-mute))}.copy-icon-btn.copied[data-v-1da38fb5]{border-color:#10b981;color:#10b981;background-color:#10b98114}.docs-icon-btn[data-v-1da38fb5]{color:var(--vp-c-brand);text-decoration:none}.docs-icon-btn[data-v-1da38fb5]:hover{border-color:var(--vp-c-brand);background-color:var(--vp-c-brand-soft, var(--vp-c-bg-mute))}.badge[data-v-1da38fb5]{font-size:.7rem;font-weight:700;padding:1px 7px;border-radius:10px;color:#fff;text-transform:uppercase;letter-spacing:.3px}.experimental-badge[data-v-1da38fb5]{background-color:var(--vp-c-warning-1, #f59e0b)}.premium-badge[data-v-1da38fb5]{background-color:var(--vp-c-brand, #3b82f6)}.registry-banner[data-v-1da38fb5]{display:flex;align-items:center;gap:16px;margin:1rem 0 1.5rem;padding:1rem 1.25rem;background-color:var(--vp-c-bg-soft);border:1px solid var(--vp-c-brand);border-radius:8px;font-size:.9rem}.copy-tooltip[data-v-1da38fb5]{position:absolute;bottom:calc(100% + 6px);left:50%;transform:translate(-50%);background-color:var(--vp-c-text-1);color:var(--vp-c-bg);padding:3px 8px;border-radius:4px;font-size:.72rem;font-weight:700;white-space:nowrap;pointer-events:none;animation:tooltipFadeIn-1da38fb5 .15s ease-out;box-shadow:0 4px 6px #0000001a;z-index:10}.copy-tooltip[data-v-1da38fb5]:after{content:"";position:absolute;top:100%;left:50%;transform:translate(-50%);border-width:4px;border-style:solid;border-color:var(--vp-c-text-1) transparent transparent transparent}@keyframes tooltipFadeIn-1da38fb5{0%{opacity:0;transform:translate(-50%) translateY(4px)}to{opacity:1;transform:translate(-50%) translateY(0)}}.disabled[data-v-1da38fb5]{opacity:.55}@media(max-width:680px){.plugin-row[data-v-1da38fb5]{flex-direction:column;align-items:flex-start;gap:.85rem}.plugin-actions[data-v-1da38fb5]{width:100%;justify-content:flex-end}}.plugin-repl-container[data-v-f957e754]{margin:20px 0 28px;width:100%;border-radius:8px;overflow:hidden;border:1px solid var(--vp-c-divider);background-color:#0b0f19;box-shadow:0 4px 20px #00000026}.plugin-repl-active[data-v-f957e754]{width:100%;height:100%}.plugin-repl-facade[data-v-f957e754]{display:flex;flex-direction:column;position:relative;width:100%;background-color:#0b0f19;color:#f8fafc;font-family:Fira Code,monospace}.facade-header[data-v-f957e754]{display:flex;align-items:center;justify-content:space-between;padding:8px 14px;background:#111827d9;border-bottom:1px solid rgba(255,255,255,.08);font-size:.8rem;font-family:var(--vp-font-family-base)}.facade-title[data-v-f957e754]{display:flex;align-items:center;gap:8px;font-weight:600;color:#94a3b8}.facade-title .dot[data-v-f957e754]{width:8px;height:8px;border-radius:50%;background:#38bdf8;box-shadow:0 0 8px #38bdf899}.facade-link[data-v-f957e754]{display:inline-flex;align-items:center;gap:4px;color:#38bdf8;font-size:.78rem;font-weight:500;text-decoration:none;transition:color .15s ease}.facade-link[data-v-f957e754]:hover{color:#7dd3fc;text-decoration:underline}.facade-body[data-v-f957e754]{position:relative;flex:1;overflow:hidden}.facade-code[data-v-f957e754]{margin:0;padding:16px;font-size:.85rem;line-height:1.55;color:#cbd5e1;background:transparent;filter:blur(.3px);user-select:none}.facade-overlay[data-v-f957e754]{position:absolute;inset:0;background:#0b0f19a6;backdrop-filter:blur(2px);display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px}.btn-launch[data-v-f957e754]{display:inline-flex;align-items:center;gap:8px;padding:10px 22px;border-radius:8px;background:linear-gradient(135deg,#0284c7,#2563eb);color:#fff;font-family:var(--vp-font-family-base);font-size:.92rem;font-weight:600;border:none;cursor:pointer;box-shadow:0 4px 16px #38bdf859;transition:all .2s cubic-bezier(.16,1,.3,1)}.btn-launch[data-v-f957e754]:hover{transform:translateY(-1px);background:linear-gradient(135deg,#0369a1,#1d4ed8);box-shadow:0 6px 20px #38bdf880}.btn-launch .icon[data-v-f957e754]{font-size:.85rem}.facade-hint[data-v-f957e754]{font-size:.75rem;color:#94a3b8;font-family:var(--vp-font-family-base)}.dialect-tabs-wrapper[data-v-b974baac]{margin:1.5rem 0 2.5rem;border-radius:12px;background:var(--vp-c-bg-soft);border:1px solid var(--vp-c-divider);overflow:hidden;box-shadow:0 4px 16px #0000000a}.dialect-nav[data-v-b974baac]{display:flex;flex-wrap:wrap;gap:4px;padding:8px 12px;background:var(--vp-c-bg-alt);border-bottom:1px solid var(--vp-c-divider)}.dialect-tab-btn[data-v-b974baac]{display:inline-flex;align-items:center;gap:6px;padding:6px 14px;border-radius:8px;border:1px solid transparent;background:transparent;color:var(--vp-c-text-2);font-size:.88rem;font-weight:500;cursor:pointer;transition:all .18s ease;user-select:none}.dialect-tab-btn[data-v-b974baac]:hover{color:var(--vp-c-text-1);background:var(--vp-c-bg-soft)}.dialect-tab-btn.is-active[data-v-b974baac]{background:var(--vp-c-bg);color:var(--vp-c-brand-1);border-color:var(--vp-c-brand-1);font-weight:600;box-shadow:0 2px 8px #0000000f}.tab-icon[data-v-b974baac]{font-size:1rem}.dialect-banner[data-v-b974baac]{display:grid;grid-template-columns:1fr;gap:16px;padding:16px 20px;background:var(--vp-c-bg);border-bottom:1px solid var(--vp-c-divider)}@media(min-width:900px){.dialect-banner[data-v-b974baac]{grid-template-columns:1.2fr 1fr;align-items:center}}.dialect-title-row[data-v-b974baac]{display:flex;align-items:center;gap:10px;margin-bottom:6px}.banner-icon[data-v-b974baac]{font-size:1.5rem}.banner-title[data-v-b974baac]{margin:0!important;font-size:1.3rem!important;font-weight:700;color:var(--vp-c-text-1);border:none!important;padding:0!important}.banner-badge[data-v-b974baac]{font-family:var(--vp-font-family-mono);font-size:.78rem;padding:2px 8px;border-radius:6px;background:var(--vp-c-brand-soft);color:var(--vp-c-brand-1);font-weight:600}.banner-ecosystem[data-v-b974baac]{font-size:.88rem;color:var(--vp-c-text-2);margin:4px 0 8px}.banner-syntax[data-v-b974baac]{display:flex;align-items:flex-start;gap:8px;padding:8px 12px;border-radius:6px;background:var(--vp-c-bg-alt);font-size:.85rem;color:var(--vp-c-text-1);border-left:3px solid var(--vp-c-brand-1)}.syntax-icon[data-v-b974baac]{font-size:.95rem}.dialect-sample-card[data-v-b974baac]{border-radius:8px;background:var(--vp-c-bg-alt);border:1px solid var(--vp-c-divider);overflow:hidden}.sample-header[data-v-b974baac]{display:flex;justify-content:space-between;align-items:center;padding:6px 12px;background:var(--vp-c-bg-soft);border-bottom:1px solid var(--vp-c-divider);font-size:.78rem;font-weight:600;color:var(--vp-c-text-2)}.sample-copy-btn[data-v-b974baac]{background:transparent;border:1px solid var(--vp-c-divider);border-radius:4px;padding:2px 8px;font-size:.74rem;color:var(--vp-c-brand-1);cursor:pointer;transition:all .15s ease}.sample-copy-btn[data-v-b974baac]:hover{background:var(--vp-c-brand-soft);border-color:var(--vp-c-brand-1)}.sample-body[data-v-b974baac]{padding:10px 12px;display:flex;flex-direction:column;gap:4px}.sample-body code[data-v-b974baac]{font-family:var(--vp-font-family-mono);font-size:.78rem;background:transparent;padding:0;color:var(--vp-c-text-1);white-space:nowrap;overflow-x:auto}.sample-body code[data-v-b974baac]:first-child,.sample-body code[data-v-b974baac]:nth-child(3){color:var(--vp-c-text-3);font-weight:600}.dialect-toolbar[data-v-b974baac]{display:flex;flex-wrap:wrap;justify-content:space-between;align-items:center;gap:12px;padding:10px 20px;background:var(--vp-c-bg-soft);border-bottom:1px solid var(--vp-c-divider)}.search-box[data-v-b974baac]{position:relative;flex:1;min-width:280px;max-width:520px}.search-icon[data-v-b974baac]{position:absolute;left:10px;top:50%;transform:translateY(-50%);font-size:.85rem;color:var(--vp-c-text-3);pointer-events:none}.search-input[data-v-b974baac]{width:100%;padding:6px 32px;border-radius:6px;border:1px solid var(--vp-c-divider);background:var(--vp-c-bg);color:var(--vp-c-text-1);font-size:.85rem;outline:none;transition:border-color .2s ease}.search-input[data-v-b974baac]:focus{border-color:var(--vp-c-brand-1);box-shadow:0 0 0 2px var(--vp-c-brand-soft)}.clear-btn[data-v-b974baac]{position:absolute;right:8px;top:50%;transform:translateY(-50%);background:transparent;border:none;color:var(--vp-c-text-3);font-size:.75rem;cursor:pointer}.token-count[data-v-b974baac]{font-size:.82rem;color:var(--vp-c-text-2)}.dialect-table-container[data-v-b974baac]{overflow-x:auto;overflow-y:auto;max-height:520px;position:relative;scrollbar-width:thin;scrollbar-color:var(--vp-c-divider) transparent}.dialect-table-container[data-v-b974baac]::-webkit-scrollbar{width:6px;height:6px}.dialect-table-container[data-v-b974baac]::-webkit-scrollbar-thumb{background:var(--vp-c-divider);border-radius:3px}.dialect-token-table[data-v-b974baac]{width:100%;border-collapse:separate;border-spacing:0;font-size:.88rem;margin:0!important}.dialect-token-table th[data-v-b974baac]{position:sticky;top:0;z-index:5;background:var(--vp-c-bg-alt);color:var(--vp-c-text-1);font-weight:600;text-align:left;padding:10px 16px;border-bottom:1px solid var(--vp-c-divider);box-shadow:0 1px 0 var(--vp-c-divider)}.dialect-token-table td[data-v-b974baac]{padding:10px 16px;border-bottom:1px solid var(--vp-c-divider);vertical-align:middle}.dialect-token-table tr:last-child td[data-v-b974baac]{border-bottom:none}.dialect-token-table tr:hover td[data-v-b974baac]{background:var(--vp-c-bg-alt)}.col-ext[data-v-b974baac]{width:18%;min-width:130px}.col-tempo[data-v-b974baac]{width:22%;min-width:160px}.col-cat[data-v-b974baac]{width:14%;min-width:100px}.col-desc[data-v-b974baac]{width:46%}.token-pill[data-v-b974baac]{display:inline-block;padding:3px 8px;border-radius:5px;font-family:var(--vp-font-family-mono);font-size:.84rem;font-weight:600}.token-ext[data-v-b974baac]{background:var(--vp-c-bg);border:1px solid var(--vp-c-divider);color:var(--vp-c-brand-1)}.token-tempo-btn[data-v-b974baac]{display:inline-flex;align-items:center;justify-content:space-between;gap:8px;padding:4px 10px;border-radius:6px;background:var(--vp-c-bg);border:1px solid var(--vp-c-brand-soft);color:var(--vp-c-text-1);cursor:pointer;transition:all .15s ease;font-family:var(--vp-font-family-mono);font-size:.84rem;width:100%;max-width:180px}.token-tempo-btn[data-v-b974baac]:hover{border-color:var(--vp-c-brand-1);background:var(--vp-c-brand-soft)}.token-tempo-btn code[data-v-b974baac]{background:transparent!important;padding:0!important;color:var(--vp-c-brand-1)!important;font-weight:700}.copy-hint[data-v-b974baac]{font-size:.72rem;color:var(--vp-c-text-3);text-transform:uppercase}.token-tempo-btn:hover .copy-hint[data-v-b974baac]{color:var(--vp-c-brand-1)}.unsupported-tempo[data-v-b974baac]{display:inline-block;color:var(--vp-c-text-3);font-weight:600;padding:4px 10px}.cat-pill[data-v-b974baac]{display:inline-block;font-size:.74rem;font-weight:600;padding:2px 8px;border-radius:12px;background:var(--vp-c-bg);border:1px solid var(--vp-c-divider);color:var(--vp-c-text-2)}.desc-text[data-v-b974baac]{font-weight:500;color:var(--vp-c-text-1);margin-bottom:2px}.example-text[data-v-b974baac]{font-size:.8rem;color:var(--vp-c-text-2)}.example-text code[data-v-b974baac]{font-family:var(--vp-font-family-mono);font-size:.78rem;padding:1px 4px;background:var(--vp-c-bg);border:1px solid var(--vp-c-divider);border-radius:4px}.notes-text[data-v-b974baac]{font-size:.78rem;color:var(--vp-c-text-3);margin-top:2px;font-style:italic}.no-tokens-found[data-v-b974baac]{text-align:center;padding:2rem!important;color:var(--vp-c-text-2);font-style:italic}.custom-navbar-logo[data-v-8ddba353]{height:24px;margin-right:8px;vertical-align:middle;display:inline-block}:root{--vp-c-brand-1: #3498db;--vp-c-brand-2: #2980b9;--vp-c-brand-3: #1f618d;--vp-c-brand-soft: rgba(52, 152, 219, .14);--vp-c-brand: var(--vp-c-brand-1)}.dark{--vp-c-brand-1: #3498db;--vp-c-brand-2: #5dade2;--vp-c-brand-3: #2980b9;--vp-c-brand-soft: rgba(52, 152, 219, .16);--vp-c-brand: var(--vp-c-brand-1)}.btn{background-color:var(--vp-c-brand);color:#fff;border:none;border-radius:4px;padding:.4rem .8rem;cursor:pointer;font-weight:600;font-size:.85rem;text-decoration:none;text-align:center}.icon-btn{display:inline-flex;align-items:center;justify-content:center;padding:.4rem;line-height:1}.btn-secondary{background-color:var(--vp-c-bg-soft);color:var(--vp-c-text-1)!important;border:1px solid var(--vp-c-divider)}.btn-secondary:hover{background-color:var(--vp-c-bg-mute);text-decoration:none!important}mjx-container{font-size:90%!important;vertical-align:-.05em}.vp-doc img[src*=plugin-logo]{width:90px;height:auto}.plugin-eyebrow{margin-top:16px;margin-bottom:6px}.plugin-eyebrow a{display:inline-flex;align-items:center;gap:6px;padding:4px 14px;border-radius:16px;background-color:var(--vp-c-brand-soft);color:var(--vp-c-brand-1);font-size:.88rem;font-weight:600;text-decoration:none;border:1px solid transparent;transition:all .2s ease}.plugin-eyebrow a:hover{background-color:color-mix(in srgb,var(--vp-c-brand-1) 22%,transparent);border-color:var(--vp-c-brand-2);color:var(--vp-c-brand-2)}.vp-doc table{display:block;max-height:72vh;overflow:auto;position:relative;margin:1.5rem 0;border-radius:8px;border:1px solid var(--vp-c-divider);scrollbar-width:thin;scrollbar-color:var(--vp-c-divider) transparent}.vp-doc table thead tr th{position:sticky;top:0;z-index:10;background-color:var(--vp-c-bg-soft);box-shadow:0 1px 0 var(--vp-c-divider)}.VPLocalSearchBox[data-v-c9af88f0]{position:fixed;z-index:100;inset:0;display:flex}.backdrop[data-v-c9af88f0]{position:absolute;inset:0;background:var(--vp-backdrop-bg-color);transition:opacity .5s}.shell[data-v-c9af88f0]{position:relative;padding:12px;margin:64px auto;display:flex;flex-direction:column;gap:16px;background:var(--vp-local-search-bg);width:min(100vw - 60px,900px);height:min-content;max-height:min(100vh - 128px,900px);border-radius:6px}@media(max-width:767px){.shell[data-v-c9af88f0]{margin:0;width:100vw;height:100vh;max-height:none;border-radius:0}}.search-bar[data-v-c9af88f0]{border:1px solid var(--vp-c-divider);border-radius:4px;display:flex;align-items:center;padding:0 12px;cursor:text}@media(max-width:767px){.search-bar[data-v-c9af88f0]{padding:0 8px}}.search-bar[data-v-c9af88f0]:focus-within{border-color:var(--vp-c-brand-1)}.local-search-icon[data-v-c9af88f0]{display:block;font-size:18px}.navigate-icon[data-v-c9af88f0]{display:block;font-size:14px}.search-icon[data-v-c9af88f0]{margin:8px}@media(max-width:767px){.search-icon[data-v-c9af88f0]{display:none}}.search-input[data-v-c9af88f0]{padding:6px 12px;font-size:inherit;width:100%}@media(max-width:767px){.search-input[data-v-c9af88f0]{padding:6px 4px}}.search-actions[data-v-c9af88f0]{display:flex;gap:4px}@media(any-pointer:coarse){.search-actions[data-v-c9af88f0]{gap:8px}}@media(min-width:769px){.search-actions.before[data-v-c9af88f0]{display:none}}.search-actions button[data-v-c9af88f0]{padding:8px}.search-actions button[data-v-c9af88f0]:not([disabled]):hover,.toggle-layout-button.detailed-list[data-v-c9af88f0]{color:var(--vp-c-brand-1)}.search-actions button.clear-button[data-v-c9af88f0]:disabled{opacity:.37}.search-keyboard-shortcuts[data-v-c9af88f0]{font-size:.8rem;opacity:75%;display:flex;flex-wrap:wrap;gap:16px;line-height:14px}.search-keyboard-shortcuts span[data-v-c9af88f0]{display:flex;align-items:center;gap:4px}@media(max-width:767px){.search-keyboard-shortcuts[data-v-c9af88f0]{display:none}}.search-keyboard-shortcuts kbd[data-v-c9af88f0]{background:#8080801a;border-radius:4px;padding:3px 6px;min-width:24px;display:inline-block;text-align:center;vertical-align:middle;border:1px solid rgba(128,128,128,.15);box-shadow:0 2px 2px #0000001a}.results[data-v-c9af88f0]{display:flex;flex-direction:column;gap:6px;overflow-x:hidden;overflow-y:auto;overscroll-behavior:contain}.result[data-v-c9af88f0]{display:flex;align-items:center;gap:8px;border-radius:4px;transition:none;line-height:1rem;border:solid 2px var(--vp-local-search-result-border);outline:none}.result>div[data-v-c9af88f0]{margin:12px;width:100%;overflow:hidden}@media(max-width:767px){.result>div[data-v-c9af88f0]{margin:8px}}.titles[data-v-c9af88f0]{display:flex;flex-wrap:wrap;gap:4px;position:relative;z-index:1001;padding:2px 0}.title[data-v-c9af88f0]{display:flex;align-items:center;gap:4px}.title.main[data-v-c9af88f0]{font-weight:500}.title-icon[data-v-c9af88f0]{opacity:.5;font-weight:500;color:var(--vp-c-brand-1)}.title svg[data-v-c9af88f0]{opacity:.5}.result.selected[data-v-c9af88f0]{--vp-local-search-result-bg: var(--vp-local-search-result-selected-bg);border-color:var(--vp-local-search-result-selected-border)}.excerpt-wrapper[data-v-c9af88f0]{position:relative}.excerpt[data-v-c9af88f0]{opacity:50%;pointer-events:none;max-height:140px;overflow:hidden;position:relative;margin-top:4px}.result.selected .excerpt[data-v-c9af88f0]{opacity:1}.excerpt[data-v-c9af88f0] *{font-size:.8rem!important;line-height:130%!important}.titles[data-v-c9af88f0] mark,.excerpt[data-v-c9af88f0] mark{background-color:var(--vp-local-search-highlight-bg);color:var(--vp-local-search-highlight-text);border-radius:2px;padding:0 2px}.excerpt[data-v-c9af88f0] .vp-code-group .tabs{display:none}.excerpt[data-v-c9af88f0] .vp-code-group div[class*=language-]{border-radius:8px!important}.excerpt-gradient-bottom[data-v-c9af88f0]{position:absolute;bottom:-1px;left:0;width:100%;height:8px;background:linear-gradient(transparent,var(--vp-local-search-result-bg));z-index:1000}.excerpt-gradient-top[data-v-c9af88f0]{position:absolute;top:-1px;left:0;width:100%;height:8px;background:linear-gradient(var(--vp-local-search-result-bg),transparent);z-index:1000}.result.selected .titles[data-v-c9af88f0],.result.selected .title-icon[data-v-c9af88f0]{color:var(--vp-c-brand-1)!important}.no-results[data-v-c9af88f0]{font-size:.9rem;text-align:center;padding:12px}svg[data-v-c9af88f0]{flex:none} diff --git a/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.js b/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.js new file mode 100644 index 00000000..f221b98d --- /dev/null +++ b/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.js @@ -0,0 +1 @@ +import{_ as e,o as s,c as a,a2 as i}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Tempo Test Suite","description":"","frontmatter":{},"headers":[],"relativePath":"test/README.md","filePath":"test/README.md"}'),o={name:"test/README.md"};function n(r,t,l,d,c,h){return s(),a("div",null,[...t[0]||(t[0]=[i('

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Test Suite ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This directory contains the automated test suite for the @magmacomputing/tempo package, organized by functional domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Directory Structure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DirectoryResponsibility
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    core/Tests for class mechanics: constructor, configuration, discovery, and state management.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    engine/The internal parsing engine: lexer, planner, layout resolution, and pattern matching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    instance/Public methods on the Tempo instance (e.g., add(), since(), format(), set()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins/Extension modules and registries: Terms, Tickers, and Duration modules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module/Modules (Parse, Format, Duration, Mutate) that can operate on a Tempo instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    issues/Regression tests linked to specific bug reports or edge cases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    support/Infrastructure, Vitest setup files, and general test utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Running Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specific Domain ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To run only a specific category of tests (e.g., the engine):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npx vitest test/engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CI Simulation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To simulate the CI environment (Strict mode, specific timezones):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm run test:ci

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Conventions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolation Assertions: Files ending in .core.test.ts or .lazy.test.ts are designed to assert behavior before modules are fully loaded. These are executed in isolation under the Tempo: Core test project to avoid cross-suite side-effects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Console Suppression: By default, console output is suppressed in tests via test/support/setup.console-spy.ts. To debug, you can use (console.log as any).mockRestore() within your test or comment out the suppression in the setup file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anchoring: When testing relative dates, always provide a fixed anchor to ensure tests are deterministic.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ',15)])])}const g=e(o,[["render",n]]);export{u as __pageData,g as default}; diff --git a/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.lean.js b/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.lean.js new file mode 100644 index 00000000..aa30bbbf --- /dev/null +++ b/packages/tempo/public/v4/assets/test_README.md.DVuOleBg.lean.js @@ -0,0 +1 @@ +import{_ as e,o as s,c as a,a2 as i}from"./chunks/framework.DNL3hc5c.js";const u=JSON.parse('{"title":"Tempo Test Suite","description":"","frontmatter":{},"headers":[],"relativePath":"test/README.md","filePath":"test/README.md"}'),o={name:"test/README.md"};function n(r,t,l,d,c,h){return s(),a("div",null,[...t[0]||(t[0]=[i("",15)])])}const g=e(o,[["render",n]]);export{u as __pageData,g as default}; diff --git a/packages/tempo/public/v4/book-icon.svg b/packages/tempo/public/v4/book-icon.svg new file mode 100644 index 00000000..c8bf70a2 --- /dev/null +++ b/packages/tempo/public/v4/book-icon.svg @@ -0,0 +1,4 @@ + + + + diff --git a/packages/tempo/public/v4/bundle.index.html b/packages/tempo/public/v4/bundle.index.html new file mode 100644 index 00000000..14a726aa --- /dev/null +++ b/packages/tempo/public/v4/bundle.index.html @@ -0,0 +1,255 @@ + + + + + + Tempo Full Bundle Test + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Full Bundle Test
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + import { Tempo } from '@magmacomputing/tempo'; + +const t = new Tempo('next friday'); +t.format('{mon} {dd:raw}'); +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Result +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Temporal...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Output also available in the developer console. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/1-getting-started/ai-integration.html b/packages/tempo/public/v4/doc/1-getting-started/ai-integration.html new file mode 100644 index 00000000..74d5b9bc --- /dev/null +++ b/packages/tempo/public/v4/doc/1-getting-started/ai-integration.html @@ -0,0 +1,84 @@ + + + + + + 🤖 AI & IDE Integration (llms.txt) | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure modern AI coding assistants—such as Cursor, VS Code (GitHub Copilot), Antigravity, ChatGPT, and Claude—generate accurate, idiomatically aligned Tempo code and minimize hallucinations, Tempo publishes an official, standardized llms.txt rulebook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By providing these rules to your AI assistant, your IDE will respect Tempo's strict immutability, zero-cost getters, native Temporal runtime expectations, and layout token syntax out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Quick Setup by IDE / Tool ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Cursor IDE ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add Tempo to Cursor's native documentation index:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Open Cursor Settings (Cmd + , or Ctrl + ,).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Navigate to Features ➔ Docs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Click + Add new doc and enter:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Name: Tempo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • URL: https://tempo.magmacomputing.com.au/llms.txt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once added, type @Tempo in any Cursor chat or prompt window to inject exact API syntax rules into your conversation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. VS Code & GitHub Copilot ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In VS Code, configure GitHub Copilot Chat by adding a .github/copilot-instructions.md file to the root of your workspace:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # Tempo AI Rules
+- Always use `Tempo` from `@magmacomputing/tempo`.
+- Never instantiate legacy JavaScript `Date`. Tempo expects native `Temporal` or polyfill.
+- All mutating methods (`.add()`, `.subtract()`, `.set()`) return a brand-new, frozen `Tempo` instance.
+- Refer to https://tempo.magmacomputing.com.au/llms.txt for full layout token grammar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When prompting Copilot Chat in VS Code:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Using https://tempo.magmacomputing.com.au/llms.txt, write a custom layout parser..."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Antigravity AI Assistant ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Antigravity, you can reference the live endpoint directly in your chat prompt or store it as a localized Knowledge Item (KI):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reference @https://tempo.magmacomputing.com.au/llms.txt in your prompt for instant context ingestion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. ChatGPT & Claude Projects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For web-based LLM interfaces, reference or copy-paste the full, un-truncated documentation context file: 👉 Full RAG Documentation Bundle (llms-full.txt)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Prompting AI for Custom Layout Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When asking AI assistants to generate custom layout patterns for non-standard date-time formats, instruct the model to use Tempo's configuration syntax (Tempo.init({ registry: { layouts: { ... } } })) and layout tokens ({yy}, {mm}, {dd}, {hh}, {mi}, {ss}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sample Prompt: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Using the rules from https://tempo.magmacomputing.com.au/llms.txt, register a custom Tempo layout for star-delimited dates (e.g., '08042026') using Tempo.init({ registry: { layouts: { ... } } }) and parse the date string using new Tempo(...)."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generated Code (Actual Tempo Syntax): ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// 1. Register custom layout pattern using layout tokens
+Tempo.init({
+  registry: {
+    layouts: {
+      star_date: '{mm}\\*{dd}\\*{yy}'
+    }
+  }
+});
+
+// 2. Parse date string matching the custom layout
+const date = new Tempo('08*04*2026');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/1-getting-started/installation.html b/packages/tempo/public/v4/doc/1-getting-started/installation.html new file mode 100644 index 00000000..7b12befa --- /dev/null +++ b/packages/tempo/public/v4/doc/1-getting-started/installation.html @@ -0,0 +1,149 @@ + + + + + + Installation Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Installation Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed to be environment-agnostic. Whether you are building a server-side application, a modern browser project with ESM, or a performance-critical "Lite" bundle, Tempo provides a specific path for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal Polyfill Note ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo expects the host environment to provide Temporal, either through native runtime support or a user-supplied polyfill.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal has reached Stage 4 of the TC39 standards process (the committee that evolves JavaScript) and is shipping natively in modern environments (Deno 2.7+, Node.js 26+, Chrome 144+, Firefox 139+). Note that Safari/iOS currently do not support Temporal natively and require a polyfill. You can verify current browser support at caniuse.com/temporal. To avoid needlessly inflating package sizes for modern apps, Tempo does not bundle a Temporal polyfill by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js environments that ship Temporal behind a feature flag (--harmony-temporal) may have incomplete implementations. For stability, we strongly recommend using @js-temporal/polyfill instead of the native flag until you upgrade to an official unflagged release.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can check at runtime with a simple guard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    js
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (typeof globalThis.Temporal === 'undefined') {
+  // Load your Temporal polyfill for this environment
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: The examples below include a polyfill for demonstration purposes only, so the snippets work consistently across environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💻 Server & Bundlers (Node.js, Bun, Vite) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For most modern projects using a package manager, install Tempo via the npm registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @magmacomputing/tempo   # npm
+yarn add @magmacomputing/tempo      # yarn
+pnpm add @magmacomputing/tempo      # pnpm
+bun add @magmacomputing/tempo       # bun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+const t = new Tempo('next Friday');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js (with Native Temporal) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native unflagged Temporal support is available in Node.js 26+ and is enabled by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node my-app.js

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Node.js (with Polyfill) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The polyfill import shown here is conditional guidance, not required for all environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm install @js-temporal/polyfill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@js-temporal/polyfill';
+import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('next Friday');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🦕 Deno ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a native ESM package and works perfectly with Deno. You can add it via the deno add command which will resolve it from the npm registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of Deno 2.7, the Temporal API is fully stabilized and enabled by default. You no longer need to pass the --unstable-temporal flag to use it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deno add npm:@magmacomputing/tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from "@magmacomputing/tempo";
+const t = new Tempo();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Browser & Native Environments ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides multiple native browser distribution formats. Here is the quick breakdown of which approach to use:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standard Usage (No plugins): Use the Native ESM Bundle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugins without a bundler: Use Smart CDNs (Easiest setup) OR Static CDNs (Best production performance).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugins with a bundler (Vite/Webpack): Do nothing. Your bundler handles the resolution automatically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Non-ESM Environments: Use the UMD Global Variable approach.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Global Bundle (Standard Usage) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The easiest way to use Tempo natively in the browser is via the pre-optimized ESM bundle. It includes the entire core engine in a single file, eliminating network waterfall effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.esm.js"
+  }
+}
+</script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="module">
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  
+  const t = new Tempo('tomorrow');
+  console.log(t.format('{mon} {dd:ord}'));
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Smart CDNs (The "Best-of-Both-Worlds") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want the absolute easiest setup for Tempo Plugins natively in the browser, use an on-the-fly bundling CDN like esm.sh. Smart CDNs act like a Node environment—they read the package resolution rules and resolve nested dependencies automatically, meaning you don't have to map any internal subpaths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While you could import directly from the URL everywhere, the best practice is to use a tiny import map for your top-level packages to keep your application code clean:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <!-- 1. A tiny import map for your clean shortcuts -->
+<script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://esm.sh/@js-temporal/polyfill@0.5.1",
+    "@magmacomputing/tempo": "https://esm.sh/@magmacomputing/tempo@4",
+    "@magmacomputing/tempo-plugin-ticker": "https://esm.sh/@magmacomputing/tempo-plugin-ticker@2"
+  }
+}
+</script>
+
+<!-- 2. Your Application Code -->
+<script type="module">
+  // You can use standard bare specifiers thanks to the tiny import map above.
+  // esm.sh handles all the complex internal plugin routing behind the scenes!
+  import '@js-temporal/polyfill';
+  import { Tempo } from '@magmacomputing/tempo';
+  import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+  Tempo.init({ 
+    plugins: [TickerPlugin] 
+  });
+</script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Trade-offs of using Smart CDNs in Production

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While esm.sh is fantastic for prototyping and reducing import map complexity, there are architectural trade-offs to consider before using it in a mission-critical production environment:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Network Waterfalls: The browser must fetch the module, parse it, and then fetch its nested dependencies sequentially. This can slow down page load times compared to a fully bundled application.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Uptime Dependency: You are introducing a critical third-party dependency into your runtime. If the CDN experiences routing issues, your application could break for end-users.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Sub-dependency Version Floating: esm.sh automatically resolves sub-dependencies based on semver constraints. If a sub-dependency introduces an accidental breaking change, it could affect your app.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Suboptimal Tree Shaking: The browser will download the entire module graph for that package; you cannot easily tree-shake unused exports as you can with a dedicated bundler like Vite or Webpack.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Environment Parity: Handling development versus production environments (like process.env.NODE_ENV) requires query parameters (e.g., ?dev), which complicates deployment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Static CDNs (Production-Ready) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For production environments where uptime and load speeds are critical, you should use a static file CDN (like jsdelivr). Because static CDNs serve raw files without compiling them on the fly, they are significantly faster and more reliable than Smart CDNs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To use Tempo Plugins via a static CDN, you simply need to explicitly map the unified plugin/sdk subpath so the browser knows how to resolve the internal connections:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <script type="importmap">
+{
+  "imports": {
+    "@js-temporal/polyfill": "https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.esm.js",
+    "@magmacomputing/tempo": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.index.js",
+    "@magmacomputing/tempo/plugin/sdk": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/plugin/plugin.sdk.js",
+
+    "@magmacomputing/tempo-plugin-celestial": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-celestial@1/dist/index.js",
+    "@magmacomputing/tempo-plugin-ticker": "https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-ticker@2/dist/index.js"
+  }
+}
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Busting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The jsdelivr CDN aggressively caches major version tags (like @4). When relying on precise module resolution for plugins, it is highly recommended to use explicit patch versions (like @4.0.0) to avoid fetching mismatched or outdated sub-modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Browser (Global Variable / Plugins) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you aren't using ESM or just want a simple <script> tag for rapid prototyping, use our unified Magma global bundles. This clean approach ensures all plugins share a single, collision-free namespace on the window object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <!-- 1. Load the Temporal Polyfill first -->
+<script src="https://cdn.jsdelivr.net/npm/@js-temporal/polyfill@0.5.1/dist/index.umd.js"></script>
+
+<!-- 2. Load the Tempo Global Bundle (Creates window.Magma) -->
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/dist/tempo.bundle.min.js"></script>
+
+<!-- 3. Load any Community Plugins (Attaches to window.Magma.plugins) -->
+<script src="https://cdn.jsdelivr.net/npm/@magmacomputing/tempo-plugin-celestial@1/dist/index.global.min.js"></script>
+
+<script>
+  // 1. Extract what you need from the Magma namespace
+  const { Tempo, plugins } = Magma;
+  
+  // 2. Extend the core engine
+  Tempo.use(plugins.celestial);
+
+  // 3. Create your instance!
+  const t = new Tempo('next friday');
+  console.log(t.toString());
+</script>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Granular "Lite" Builds (Advanced) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are extremely concerned about bundle size, you can bypass the "Batteries Included" entry point and import only the core engine. You then manually opt-in to the modules you need.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { MutateModule } from '@magmacomputing/tempo/mutate';
+
+// Opt-in to specific functionality
+Tempo.use(MutateModule);
+
+const t = new Tempo().add({ days: 1 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Lite build, the Tempo class will have almost no methods (like .add(), .set(), or .format()) until you explicitly call Tempo.use() with the appropriate module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Versioning Policy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We recommend pinning your versions in production environments to ensure stability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • JSDelivr: https://cdn.jsdelivr.net/npm/@magmacomputing/tempo@4/... (Locks to major version 4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Latest: https://cdn.jsdelivr.net/npm/@magmacomputing/tempo/... (Omit the version string to always receive the latest release. Note that JSDelivr will resolve a missing version tag to the latest published release).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Cursor, VS Code (GitHub Copilot), Antigravity, ChatGPT, or Claude? Tempo publishes an official llms.txt index to give AI assistants documented project context and reduce hallucinations regarding Tempo's syntax, token grammar, and immutability rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the dedicated AI & IDE Integration Guide for step-by-step setup instructions for your IDE or tool.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/1-getting-started/tempo.cookbook.html b/packages/tempo/public/v4/doc/1-getting-started/tempo.cookbook.html new file mode 100644 index 00000000..f9b2c7bb --- /dev/null +++ b/packages/tempo/public/v4/doc/1-getting-started/tempo.cookbook.html @@ -0,0 +1,166 @@ + + + + + + Tempo Cookbook | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Cookbook ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A collection of recipes for solving common date and time challenges using Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Table of Contents ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Basics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Parsing Challenges
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Manipulation and Calculations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Timezones and Locales
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Business Logic and Terms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Formatting and Localization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Interoperability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Basics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I get the current date and time? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When invoked without arguments, the constructor initializes to the current date and time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const now = new Tempo();
+console.log(now.toString()); // e.g. "2026-07-31T14:42:11+10:00[Australia/Sydney]"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Get "Now" in UTC ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const utcNow = new Tempo({ timeZone: 'UTC' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I format a date for my UI? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use the placeholder syntax in the .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-12-25');
+t.format('{dd} {mon} {yyyy}');  // "25 December 2024"
+t.format('{h12}:{mi}');         // "12:00am"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How do I check if a date is valid? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('invalid-date');
+if (t.isValid) {
+  // ...
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can initialize global defaults that apply to all future Tempo instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  timeZone: 'UTC',
+  locale: 'en-GB',
+  silent: true
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: Configuration Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing Challenges ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing "Ambiguous" Digits (US vs UK) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo intelligently resolves ambiguous dates like 04012026 based on your timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('04012026', { timeZone: 'America/New_York' }); 
+console.log(us.format('{mon} {dd}')); // "April 01"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: Ambiguity Resolution Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Handling Relative Strings ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively understands human-readable offsets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('yesterday');
+new Tempo('next Friday');
+new Tempo('2 weeks ago');
+new Tempo('tomorrow afternoon');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: You can seamlessly localize relative phrases (e.g. next to prochain) by reading the Internationalized Parsing Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing Unix Timestamps ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo handles both milliseconds (Number) and nanoseconds (BigInt).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo(1716163200000);         // Milliseconds
+new Tempo(1716163200000000000n);  // Nanoseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manipulation and Calculations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add or Subtract Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo instances are immutable; add() returns a new instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const deadline = new Tempo().add({ days: 7, hours: 2 });
+const past = new Tempo().add({ months: -1 });
+
+// You can also step by semantic Terms using the `#` prefix!
+const t1 = new Tempo('2024-05-15'); // Middle of Q2
+const t2 = t1.add({ '#quarter': 1 }); // Middle of Q3: "2024-08-14" (approx)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Jumping to Boundaries (start, mid, end) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .set() method allows you to jump to the boundaries of native units (like months or years) or semantic Terms (using the # prefix). You can specify whether to land on the inclusive start, inclusive end, or the exact center.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Native Units
+const monthStart = new Tempo().set({ month: 'start' });
+
+// Semantic Terms (Lands on 30-Sep 23:59:59.999... Inclusive End)
+const qtrEnd = new Tempo('2024-07-15').set({ '#quarter': 'end' });
+
+// Lands on the arithmetic nanosecond midpoint of the period
+const qtrMid = new Tempo().set({ '#quarter': 'mid' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can navigate relative to your current date by using Slick Shorthand operators directly inside .set(). Use the snippet shorthand keys (yy, mm, ww, dd, wkd, etc.) and provide a string payload containing a directional modifier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+t.set({ mm: '>2' });               // July 20th
+t.set({ wkd: '>Fri' });            // May 24th

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: To read about advanced chaining, order-of-operations, and architectural limitations, see the Slick Object Mutations Deep Dive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How long until a deadline? (until) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+const daysLeft = t.until('2025-01-01', 'days');
+console.log(`${daysLeft} days remaining`);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative Time (since) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Generate human-readable relative time strings instantly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('yesterday');
+console.log(t.since()); // "1d ago"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezones and Locales ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Convert Time to Another Zone ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const nyc = new Tempo('2024-05-20 10:00', { timeZone: 'America/New_York' });
+const london = nyc.set({ timeZone: 'Europe/London' });
+
+console.log(nyc.format('{hh}:{mi}'));    // "10:00"
+console.log(london.format('{hh}:{mi}')); // "15:00"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic / Multi-Tenant Context (Functional Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Context options (timeZone, locale, calendar, sphere) accept supplier functions (() => string). Tempo resolves suppliers at instantiation time to construct an immutable, frozen instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { AsyncLocalStorage } from 'node:async_hooks';
+
+const requestContext = new AsyncLocalStorage<{ timeZone: string; locale: string }>();
+
+// Configure dynamic suppliers that evaluate against current request context
+const t = new Tempo('now', {
+  timeZone: () => requestContext.getStore()?.timeZone || 'UTC',
+  locale: () => requestContext.getStore()?.locale || 'en-US'
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Configuration Guide for details on functional options and immutability guarantees.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business Logic and Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Is it the weekend? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For simple ISO checks, Saturday is 6 and Sunday is 7:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+const isWeekend = t.dow >= 6; // Saturday = 6, Sunday = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For international applications, use the locale-aware t.intl.weekend array (backed by Intl.Locale.prototype.getWeekInfo() and its fallback resolver), which reflects regional weekend days (e.g. [5, 6] for Friday & Saturday in Middle Eastern locales like ar-SA):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Standard weekend ([6, 7] for Saturday and Sunday in en-US)
+const us = new Tempo({ locale: 'en-US' });
+const isUsWeekend = us.intl.weekend.includes(us.dow);
+
+// Regional weekend ([5, 6] for Friday and Saturday in ar-SA)
+const sa = new Tempo({ locale: 'ar-SA' });
+const isSaWeekend = sa.intl.weekend.includes(sa.dow);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What Fiscal Quarter are we in? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using the qtr Term plugin (term.qtr is a convenient alias for the full term.quarter property).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+console.log(`Current Quarter: ${t.term.qtr}`); // "Q1", "Q2", etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemispheric Seasons ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Terms are hemisphere-aware.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sydney = new Tempo('2024-07-01', { sphere: 'south' });
+console.log(sydney.term.szn); // "Winter"
+
+const london = new Tempo('2024-07-01', { sphere: 'north' });
+console.log(london.term.szn); // "Summer"
+
+// or even via the timeZone setting
+console.log(new Tempo({ timeZone: 'America/New_York' }).term.szn); // "Summer"
+console.log(new Tempo({ timeZone: 'Australia/Sydney' }).term.szn); // "Winter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting and Localization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Semantic Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use specific Term tokens like {#quarter} or {#season} to automatically embed a Term's label (or key) into a format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+console.log(t.format('We are currently in the {#quarter}')); // "We are currently in the First Quarter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Modifiers & Localization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format strings support chained colon-modifiers (e.g., :upper, :locale, :ord) to dynamically change the presentation casing or delegate to the native Intl API. You can stack them to get the exact presentation required!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-15 15:30', { locale: 'fr-FR' });
+
+t.format('{mon:upper}');             // "MAY" (English Default -> UpperCase)
+t.format('{mon:long}');              // "mai" (Native French Intl output via styling bridge)
+t.format('{mon:long:upper} {dd}');   // "MAI 15" (Native French Intl output)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Smart Formatting Guide for the complete list of available modifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tired of typing styling modifiers?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you find yourself repeatedly writing :long or :short for the same localized date structure, save it to the global FORMATS registry! This creates a clean, reusable shortcut:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+    locale: 'fr-FR',
+    registry: {
+        formats: {
+            'ui-date': '{wkd:long}, {dd:raw} {mon:long} {yyyy}'
+        }
+    }
+});
+
+t.format('ui-date'); // Resolved with all modifiers intact!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Format keys are resolved case-sensitively from the global registry.formats object. If the requested key is not found, Tempo will simply treat the provided string as a literal layout string rather than throwing an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: To build custom zero-overhead logic evaluators (like Fiscal Years or native Intl bridges), read the Custom Format Tokens Deep Dive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Ticker engine is a community plugin for precisely driving business logic (like recurring billing or reporting cycles) on specific date boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Drive internal reporting precisely when a new quarter begins
+await using quarterly = Tempo.ticker({ '#quarter': 1 });
+
+for await (const t of quarterly) {
+  generateReport(t.term.qtr);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Ticker Plugin Documentation for detailed configuration, term-driven intervals, and await using syntax requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format & Parse Dialects Plugin (Moment, Luxon, SQL, POSIX, PHP) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating existing code or layouts from Moment.js, Luxon, date-fns, POSIX strftime, PHP, or SQL, use the @magmacomputing/tempo-plugin-dialects community plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Zero-config drop-in import automatically mounts dialect shims:
+import '@magmacomputing/tempo-plugin-dialects/install';
+
+const t = new Tempo('2026-10-24T15:30:00');
+
+// Luxon convenience shim (.toFormat)
+t.toFormat('yyyy-MM-dd HH:mm:ss');          // "2026-10-24 15:30:00"
+
+// LDML & Moment parsing
+Tempo.fromFormat('2026-10-24', 'yyyy-MM-dd'); // LDML parsing via Luxon shim
+Tempo.dialects.parse('2026-10-24', 'YYYY-MM-DD', 'moment'); // Moment layout parsing
+
+// Direct dialect formatters
+t.dialects.sql('YYYY-MM-DD HH24:MI:SS');     // Oracle / PostgreSQL TO_CHAR
+t.dialects.php('Y-m-d H:i:s');               // PHP date()
+t.dialects.go('2006-01-02 15:04:05');        // Go reference layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: See the Dialects Plugin Documentation for full token specifications, multi-candidate parsing fallbacks, and cross-ecosystem translation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interoperability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converting to / from Native Date ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = new Tempo().toDate();
+const tempo = new Tempo(new Date());

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Converting to Temporal Objects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const zdt = new Tempo().zdt;             // Temporal.ZonedDateTime (or .toDateTime())
+const instant = new Tempo().toInstant(); // Temporal.Instant
+const pdt = new Tempo().toPlainDate();   // Temporal.PlainDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sorting an array of Tempos ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dates = [new Tempo('tomorrow'), new Tempo('yesterday'), new Tempo('today')];
+dates.sort(Tempo.compare); // Sorts chronologically

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/1-getting-started/tempo.repl.html b/packages/tempo/public/v4/doc/1-getting-started/tempo.repl.html new file mode 100644 index 00000000..163b864e --- /dev/null +++ b/packages/tempo/public/v4/doc/1-getting-started/tempo.repl.html @@ -0,0 +1,73 @@ + + + + + + Interactive REPL & Feature Showcase | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interactive REPL & Feature Showcase ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers two dedicated, zero-install in-browser environments running 100% client-side via native ECMAScript Modules (esm.sh):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 🎨 Feature Showcase & Workbench: A dynamic, visual sandbox to test format tokens, chained mutations, relative durations, world geolocation, and astronomical ephemeris in real time with auto-generated TypeScript code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. ⚡ Freeform Code REPL: A freeform JavaScript/TypeScript code editor with real-time evaluation, console streaming, official plugin preloading, and snippet URL sharing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎨 Interactive Feature Showcase ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore live formatting, chained mutations, hemisphere-aware astronomical seasons, and celestial mechanics without writing boilerplate:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Runs 100% in your browser. Generates ready-to-use TypeScript code.🚀 Open Full-Screen Showcase↗

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Freeform Code REPL ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An instant scratchpad for testing custom algorithms, experimental plugin imports, and sharing reproducible snippet links:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-configured with Tempo, Temporal, and official plugins.🚀 Open Full-Screen Code REPL↗

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Capabilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Preloaded Official Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both environments pre-register the core Tempo instance along with default official plugins:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo-plugin-geo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo-plugin-celestial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can immediately access Terms, seasons, and celestial data without import boilerplate:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('today', { geo: { lat: -33.86, lng: 151.2 } });
+console.log(t.term.szn);            // "Spring"
+console.log(t.term.lunar.phase);    // "First Quarter"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dynamic Plugin Loading & Presets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need an additional plugin like @magmacomputing/tempo-plugin-spatial, @magmacomputing/tempo-plugin-ticker, or custom third-party modules? Select their preset from the preset dropdown or use standard dynamic imports in the Code REPL:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const { SpatialPlugin } = await import('@magmacomputing/tempo-plugin-spatial');
+Tempo.use(SpatialPlugin);
+
+console.log('Spatial plugin active!');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. AI Semantic Parsing & Natural Language Scheduling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore generative date parsing, conversational recurrence, and multi-point event scheduling powered by @magmacomputing/tempo-plugin-ai:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Select the Preset: AI Semantic Parsing & Scheduling from the preset dropdown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supported Provider Configuration (BYOK): Provide an API key or local endpoint in Tempo.ai.init({ providers: [...] }) before calling Tempo.ai.parse or Tempo.ai.schedule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • External Resources & Free Keys:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Groq Console: Ultra-fast inference with a generous free tier (recommended for quick testing).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Google AI Studio (Gemini): Free API key for Gemini models.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • OpenAI Platform: Standard GPT-4o / GPT-4o-mini keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ollama: 100% free, private local LLMs. Note: When running locally for browser access, start Ollama with CORS enabled: OLLAMA_ORIGINS="*" ollama serve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    API Key Safety in Share Links: When you click 📋 Share, the editor content is encoded into the URL hash (#code=...). Never paste production or sensitive API keys into shared snippets. For live testing, use ephemeral personal sandbox keys or local Ollama.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Shareable Snippets & Presets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Share: Click the 📋 Share button in the REPL header to encode your code directly into a shareable URL hash (#code=...).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copy Code: Click 📋 Copy Code in the Showcase to grab production-ready TypeScript code for your current visual setup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Keyboard Shortcuts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ctrl + Enter (Windows/Linux) or Cmd + Enter (macOS): Immediately re-evaluate the current editor code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tab: Inserts 2-space indentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.cache.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.cache.html new file mode 100644 index 00000000..14a16b6a --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.cache.html @@ -0,0 +1,90 @@ + + + + + + Cache Management Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Management Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a centralized, high-performance BoundedCache singleton accessible via Tempo.cache. It provides dual-layer resolution for dynamic relative dates (with LRU eviction and TTL expiration) and static business glossaries (immortal keys).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏛️ Centralized Cache Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All date resolution caching—whether triggered by core Tempo parsing or the Tempo AI plugin (parseAI, formatAI, contextAI)—is managed centrally by Tempo.cache.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Behavior: Core Tempo vs. Tempo AI Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core Tempo: Caching is opt-in. Core date parsing executes at sub-microsecond speeds using standard regex matching. Tempo.cache is consulted when you seed a static glossary or enable caching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo AI Plugin: Caching is automatic. To eliminate network latency (~500ms+) and avoid redundant LLM API billing, AI functions (like parseAI) automatically check Tempo.cache before sending network requests and cache every successful LLM resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cache Topology & Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can configure global cache parameters using Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  cache: {
+    maxSize: 1000,             // Maximum number of entries before LRU eviction (default: 1000)
+    ttl: 24 * 60 * 60 * 1000   // Time-to-live in milliseconds (default: 24 hours)
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Capacity Management (LRU): When the cache reaches maxSize, the Least Recently Used dynamic entry is automatically evicted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TTL Expiration: Dynamic entries older than ttl are automatically purged upon lookup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Static Glossary Isolation: Static entries added to the glossary are exempt from both LRU eviction and TTL expiration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📖 Seeding & Appending Glossaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can seed static business terms into Tempo.cache using a native JavaScript Map or via Tempo.init({ cache: map }):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const businessGlossary = new Map([
+  ['fiscal year start 2026', '2026-07-01T00:00:00Z'],
+  ['q3 board review', '2026-09-15T09:00:00Z']
+]);
+
+// Appends entries to Tempo.cache as static, immortal terms
+Tempo.init({ cache: businessGlossary });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Non-Destructive Appending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing a Map or custom key-value pairs to Tempo.init({ cache }) or initAI({ cache }) appends to the existing cache without clearing previously cached terms or resetting cache capacity settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 When to Use What: Glossary vs. Alias vs. Snippet/Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides multiple mechanisms for augmenting parsing intelligence. Choosing the right pattern depends on whether your logic is static, dynamic, structural, or string replacement:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MechanismTier / LocationEvaluation ModelBest Used For...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Glossary (Tempo.cache)Core EngineZero-cost O(1) Map lookupPre-calculated static ISO date/time strings or exact business dates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Aliases / Events / Periods (registry.events / periods)Registry EngineDynamic function or target stringComputing dynamic business dates (e.g. 'deadline' => () => this.add({ days: 30 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snippet / Layouts (registry.snippets / layouts)Parser PlannerRegex pattern matcherStructural natural language formats (e.g. yyyy/mm/dd or custom date tokens).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Decision Tree ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Use a Glossary (Tempo.cache) when you have fixed, pre-resolved ISO dates for specific terms (e.g., 'eoy 2026' -> '2026-12-31T23:59:59Z'). It offers instant O(1) resolution without invoking the regex parser.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Use an Alias (registry.events / periods) when you need dynamic rules calculated relative to the current date/time (e.g., 'market-close' -> '16:00' or 'deadline' -> 30 days from now).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Use a Snippet or Layout (registry.snippets / layouts) when parsing custom input structures with variable numbers or tokens (e.g. "2026-W05" or "Quarter 3, 2026").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI Plugin Cache Integration (@magmacomputing/tempo-plugin-ai) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The @magmacomputing/tempo-plugin-ai plugin works hand-in-hand with Tempo.cache to reduce LLM API calls and costs across AI functions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { parseAI, initAI } from '@magmacomputing/tempo-plugin-ai';
+
+initAI({ providers: [...] });
+
+// First lookup: Triggers LLM call -> Stores ISO result in Tempo.cache
+const t1 = await parseAI("The penultimate Tuesday before Thanksgiving in 2026");
+
+// Second lookup: Instantly resolves from Tempo.cache (O(1) local hit, $0 cost)
+const t2 = new Tempo("The penultimate Tuesday before Thanksgiving in 2026");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Two-Tier Resolution Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Date-Salted Relative Cache: Relative queries (e.g. "next Tuesday") are salted with the anchor date so cached entries remain valid for the given day.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Static Glossary Fallback: Business glossary terms seeded via initAI({ cache }) or Tempo.init({ cache }) are checked first, providing zero-latency resolution without ever contacting the LLM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.config.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.config.html new file mode 100644 index 00000000..adefd0ed --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.config.html @@ -0,0 +1,220 @@ + + + + + + Configuration Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configuration Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a flexible, multi-tiered configuration system. Settings are applied in a specific order of precedence, allowing you to set broad defaults that can be refined at the application or instance level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Precedence Hierarchy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Settings are loaded in the following order (where later stages override earlier ones):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Library Defaults: Sensible out-of-the-box baseline.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Persistent Storage: Sticky user preferences (which merge into Defaults).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Global Discovery: Enterprise-level setup discovered via Symbol.for('$Tempo').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Library Extension: Dynamic feature registration via Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Explicit Initialization: Baseline configuration via Tempo.init().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Instance Constructor: Specific overrides for a single new Tempo() call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏆 Best Practice: The tempo.config.ts Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than scattering Tempo.init() or Tempo.use() calls throughout your application, the recommended best practice is to centralize your environment setup into a single tempo.config.ts (or .js) file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This mirrors modern ecosystem standards (like vite.config.ts or tailwind.config.js) and ensures that plugins, timezones, and custom aliases are consistently applied before any domain logic executes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Target Environment & Discovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automatic zero-config discovery relies on Node.js file system capabilities and is exclusive to Server and Node.js environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In bundled frontend environments (like Vite or Webpack), you can still maintain a central tempo.config.ts, but you must explicitly import and pass it to Tempo.init(config) at your application entry point (e.g. main.ts). If you are using Tempo via a <script> tag in a pure Browser environment, skip to Explicit Initialization to configure Tempo directly!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo.config.ts
+import { defineConfig } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+export default defineConfig({
+  timeZone: 'Australia/Sydney',        // Set your baseline timezone
+  extends: './tempo-base.config.jsonc',// Inherit local base config
+  plugins: [
+    CelestialPlugin,                   // 1. Executable plugin or term
+    TickerPlugin,                      // 2. Plugin singleton (or factory closure)
+  ],
+  pluginOptions: {
+    ai: { mode: 'fallback', timeout: 10000 }, // 3. Plugin configuration defaults
+    ticker: { interval: 1000 }
+  },
+  registry: {
+    periods: { 
+      'market-open': '09:30',
+      'market-close': '16:00' 
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Clean Separation: Feature Registration vs Plugin Configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo separates code registration from data configuration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • plugins: Strictly registers executable plugins, namespaces, terms, or factory closures ((Plugin | Term)[]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pluginOptions: Dedicated dictionary holding runtime options and configuration defaults for plugins (Record<string, any>), serializable in tempo.config.json and cascading across local extends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The 'plugins' key as a JSON of plugin-configuration settings has been migrated to 'pluginOptions' so as not to overload the 'plugins' key (which registers Plugin instances / Terms / Modules / Namespaces).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can then bootstrap this environment at the very top of your application's entry point (e.g., main.ts or index.js) to guarantee the configuration is locked in before any other files run:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Server / Node.js Entry Point (Zero-Config Discovery) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // main.ts (Server / Node.js)
+import { Tempo } from '@magmacomputing/tempo';
+
+// Automatically discovers and loads local 'tempo.config.ts' (or .js / .json / .jsonc)
+await Tempo.bootstrap(); 
+
+// OR: Bootstrap from an explicit local configuration file or path
+await Tempo.bootstrap({ configFile: './configs/tempo.production.jsonc' });
+
+// Dynamic import ensures domain logic loads ONLY AFTER configuration is complete
+const { App } = await import('./app.js');
+// ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bundled Frontend Entry Point (Vite / Webpack) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // main.ts (Bundled Frontend / Browser)
+import { Tempo } from '@magmacomputing/tempo';
+import tempoConfig from './tempo.config';
+
+// Explicitly pass central configuration into Tempo.init()
+Tempo.init(tempoConfig);
+
+// Application bootstrap proceeds with configured Tempo
+import './app';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cascading Configurations ("extends") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo configuration files can inherit settings from parent baseline configurations via local file paths or file:// URLs using the "extends" key. Local options automatically override parent baseline options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jsonc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo.config.jsonc
+{
+  "extends": "./tempo-base.config.jsonc",
+  "timeZone": "Australia/Sydney", // Local override
+  "registry": {
+    "periods": {
+      "standup": "09:15"
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits vs. Drawbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using tempo.config.ts or Tempo.bootstrap() is the modern standard, but it introduces specific architectural tradeoffs due to Node.js ES Module and asynchronous I/O boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TypeScript Autocomplete: Using defineConfig provides instant IDE intellisense and type-safety for all configuration options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Execution: You can import and instantiate plugins directly inside JS/TS configuration files, keeping your application logic clean.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Configuration Inheritance: Enables inheriting shared base configs via relative paths, absolute paths, or file:// URLs with recursive inheritance and cycle detection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dynamic Configuration: Enables runtime logic (e.g., debug: process.env.NODE_ENV !== 'production') in JS/TS configs that strict JSON cannot provide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Drawbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Asynchronous Requirement: Because dynamic config loading and file reading are asynchronous, you must use await Tempo.bootstrap() instead of synchronous calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛑 Security & Reliability Bounds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Data-Only Inheritance: The "extends" mechanism strictly supports static .json and .jsonc data files. Dynamic JavaScript execution (eval or dynamic import) from extended configurations is prohibited to prevent unintended code execution in inherited configs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Boundary Safety: Remote HTTP(S) URLs are rejected when specified as configFile (returning undefined), whereas remote "extends" targets are skipped with a warning while local configuration processing continues, protecting against external network dependencies and remote code injection. file:// URLs are validated to disallow remote hosts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Floating Promises: You must ensure you actually await the bootstrap call. If you forget the await keyword, your application will continue booting before Tempo finishes reading your config file, leading to race conditions where early instances use default settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Looking to configure Internationalization?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers deep integration with native Intl APIs for both parsing and formatting foreign languages out-of-the-box. See Internationalization & Locale for a general guide, and the Internationalized Parsing and Format Modifiers & Localization guides for configuration details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Persistent Configuration ($Tempo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The first layer Tempo checks after its own internal defaults is persistent storage. This is ideal for "sticky" settings like a user's preferred timezone or locale that should persist across sessions without a database.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Write a preference to localStorage under the default key ('$Tempo')
+Tempo.writeStore({ timeZone:'Australia/Sydney' });
+// Write a preference to localStorage under the key 'mySettings'
+Tempo.writeStore({ timeZone: 'America/New_York' }, 'mySettings');
+
+// Later, or in another file, initialize Tempo pointing to that key
+// It will automatically read 'America/New_York' and apply it
+Tempo.init({ store: 'mySettings' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Global Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To facilitate configuration in micro-frontend architectures or script-first bootstraps, Tempo can discover a Discovery object from globalThis during Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The intended flow is:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Write a Discovery object into globalThis under the configured discovery symbol key.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Import a module containing Tempo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Tempo class static initialization runs Tempo.init().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Tempo.init() reads the global discovery slot and merges it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, the key is Symbol.for('$Tempo').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-Bootstrap Discovery (globalThis) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Must run before the first Tempo module is evaluated
+globalThis[Symbol.for('$Tempo')] = Object.freeze({
+  options: { timeZone: 'Europe/Paris' },
+  timeZones: { MYTZ: 'Asia/Dubai' },
+  registry: { formats: { myFormat: '{dd}!!{mm}!!{yyyy}' } },
+  terms: [myCustomTermPlugin]
+});
+
+// Load Tempo after the discovery object is in place
+const { Tempo } = await import('@magmacomputing/tempo');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With static ESM imports, import evaluation happens before module body execution. If you need discovery to apply on first load, assign globalThis in an earlier script/module, or use dynamic import() as shown above.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explicit Runtime Registration (Not Global Discovery) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Tempo.use(...) is explicit registration after Tempo is loaded. It is ergonomic and strongly recommended for normal application code, but it is a different mechanism from pre-bootstrap global discovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.use({
+  options: { timeZone: 'Europe/Paris' },
+  timeZones: { MYTZ: 'Asia/Dubai' },
+  registry: { formats: { myFormat: '{dd}!!{mm}!!{yyyy}' } },
+  terms: [myCustomTermPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Security and Ergonomics Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tamper Prevention: When utilizing Global Discovery in a shared environment (like micro-frontends), it is highly recommended to Object.freeze() your configuration. Tempo only reads from this object, so freezing it prevents third-party scripts from injecting unauthorized plugins before Tempo boots up.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Discovery is convenient for host-controlled bootstraps and cross-bundle handoff.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use(...) is usually safer in app code because configuration is explicit, local, and easier to trace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use Global Discovery when you must configure Tempo before the first Tempo import executes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovery Contract ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo looks for the following structure:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optionsOptions | (() => Options)Configuration options merged into global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intlIntlOptionsInternationalization configuration grouping relativeTimeFormat, numberFormat, durationFormat, and dateTimeFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extendsstring | string[]Local file path(s) or file:// URL(s) to inherit base configuration from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins(Plugin | TermPlugin)[]Modular plugins/terms to register during configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptionsRecord<string, any>Plugin configuration defaults and dictionaries keyed by plugin name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZonesRecord<string, string>Custom timezone aliases to be merged.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registry{ formats?, locales?, numbers?, ordinals?, events?, periods?, snippets?, layouts?, ignores?, modifiers?, tokens? }Custom configuration for internal dictionary registries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Explicit Initialization (Tempo.init) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is the Standard Developer Tier. Most applications should call Tempo.init() during startup to establish a predictable baseline for all instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  timeZone: 'Australia/Sydney',
+  locale: 'en-AU',
+  pivot: 80,
+  debug: 0
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Single-App vs. Sandboxed Environments (Tempo.init() vs. Tempo.create())

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init(): Designed for single-app entry points (such as client-side SPAs or CLI tools) to establish baseline defaults globally across the runtime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.create(): Designed for multi-tenant SSR servers (e.g. Next.js, Fastify), reusable npm libraries, or isolated unit test suites. Tempo.create() branches off an isolated, sandboxed class constructor with its own independent state and registry, guaranteeing zero cross-tenant preference leakage or global state pollution when using the default discovery setting or a unique options.discovery key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OptionTypeDefaultDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeZoneEvaluable<string>System ZoneDefault IANA time zone, alias, or dynamic supplier (() => string).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localeEvaluable<string | string[]>System LocaleDefault BCP 47 language tag(s) or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    calendarEvaluable<string>'iso8601'Default calendar system or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pivotnumber75Cutoff for parsing two-digit years.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    monthDayMonthDay | booleanundefinedRegional date-parsing configuration (grouped). Includes active, locales, layouts, and timezones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeStamp'ss' | 'ms' | 'us' | 'ns''ms'Precision for numeric inputs and the .ts property.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sphereEvaluable<'north' | 'south' | 'equator'>Auto-inferredHemisphere for seasonal plugins or dynamic supplier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    geoGeoOptionsundefinedGeographic coordinates, city, country, elevation, and timezone metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intlIntlOptionsundefinedInternationalization configuration grouping relativeTimeFormat, numberFormat, and durationFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    localeInfobooleanfalseEnables locale-aware week-boundary mutation behavior (week: 'start' | 'mid' | 'end'). Formatting tokens ({dow:locale}, {hh:locale}) resolve locale info independently.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registry{ formats?, locales?, numbers?, ordinals?, events?, periods?, snippets?, layouts?, ignores?, modifiers? }Built-in registriesCustom data augmentation registries (e.g., format aliases, number-to-word mappings, parsing logic, localization).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extendsstring | string[]undefinedLocal file path(s) or file:// URL(s) to inherit base configuration from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins(Plugin | TermPlugin)[][]Plugins/terms to register during initialization (applied via Tempo.use(p)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptionsRecord<string, any>{}Plugin configuration defaults and dictionaries keyed by plugin name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    storestring'$Tempo'Persistent storage key used by readStore/writeStore.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    discoverystring | symbol'$Tempo' symbol keyDiscovery slot used to resolve global discovery config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debugnumber | string'info'Controls log verbosity via direct LOG levels (0=Off ... 5=Trace) or string labels ('trace', 'info', etc).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catchbooleanfalseIf true, invalid inputs return a Void instance instead of throwing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode'auto' | 'strict' | 'defer''auto'Controls the hydration strategy (e.g., defer for Zero-Cost creation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    silentbooleanfalseSuppresses console output. Combined with catch: true for silent failover.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plannerPlannerOptionsundefinedGrouped configuration for layoutOrder and preFilter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debug accepts numeric level values (0 through 5) or lowercase string labels ('off', 'error', 'warn', 'info', 'debug', 'trace').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Instance-Level Overrides ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The final layer of precedence is the constructor itself. You can override any global setting for a specific calculation without affecting the rest of your application.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // This instance uses UTC regardless of any global configuration
+const t = new Tempo('now', { timeZone: 'UTC' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4.1 Dynamic & Functional Context Evaluation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In modern multi-tenant, serverless, or micro-service architectures (such as Next.js, Express, or Fastify), user timezone and locale preferences frequently change on a per-request basis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To eliminate repetitive instance options and prevent global configuration mutation churn (Tempo.init()), Tempo supports Evaluable<T> (T | (() => T)) suppliers across all core context properties (timeZone, locale, calendar, sphere):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+interface UserSession {
+  tenantId: string;
+  timeZone: string;
+  locale: string;
+}
+
+export const sessionContext = new AsyncLocalStorage<UserSession>();
+
+// Initialize global baseline with dynamic supplier functions once:
+Tempo.init({
+  timeZone: () => sessionContext.getStore()?.timeZone || 'UTC',
+  locale: () => sessionContext.getStore()?.locale || 'en-US'
+});
+
+// In request handlers, instantiate Tempo without manual option boilerplate:
+app.get('/api/report', (req, res) => {
+  sessionContext.run({ tenantId: 'tenant-123', timeZone: 'America/Chicago', locale: 'en-US' }, () => {
+    const t = new Tempo(); // Automatically resolves to 'America/Chicago'
+    res.json({ formatted: t.format('{mon} {dd}, {yyyy}') });
+  });
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determinism and Immutability Guarantees ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a Tempo instance is constructed:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. All functional suppliers (timeZone, locale, calendar, sphere) are evaluated synchronously at the moment of instantiation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The resolved scalar values are locked into the instance's immutable Temporal.ZonedDateTime engine and #state record.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. The instance is strictly frozen (Object.freeze).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero Configuration Drift: Because suppliers are resolved at creation time into an immutable snapshot, an existing Tempo instance will never drift or become out-of-sync if external session state changes later in the request lifecycle. Subsequent new Tempo() or plugin calls will cleanly evaluate contemporary session state anew.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4.2 Geographic Coordinates & Location Configuration (geo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can configure geographic coordinates and location metadata globally or override them on individual instances:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Global baseline in tempo.config.ts or Tempo.init():
+Tempo.init({
+  geo: {
+    lat: -33.8688,
+    lng: 151.2093,
+    city: 'Sydney',
+    country: 'Australia'
+  }
+});
+
+// Or per-instance override:
+const t = new Tempo('now', {
+  geo: {
+    lat: 51.5074,
+    lng: -0.1278,
+    city: 'London',
+    country: 'United Kingdom'
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deterministic Validation: Latitudes outside [−90,90] and longitudes outside [−180,180] are rejected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3-Decimal Precision: Automatically rounded (Math.round(val * 1000) / 1000) to guarantee cache hit consistency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hemisphere Inference: Automatically sets t.sphere ('north', 'south', or 'equator').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Canonical Access: Read through t.geo (recursively frozen GeoConfig) and t.sphere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Advanced Parsing Rules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Beyond basic settings, Tempo's parsing engine can be extended with custom rules and behaviors to handle specialized natural language or high-volume processing requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 5.1 Custom Events and Periods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can extend Tempo's intelligence by supplying custom Events (date aliases) and Periods (time aliases) at any global configuration tier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    events: {
+      'launch date': '2026-05-20',
+      'deadline': function () { return this.add({ days: 30 }) }
+    },
+    periods: {
+      'tea time': '15:00',
+      'mid[ -]?after[ -]?noon': '16:00',  // regex-like key for 'mid after noon' or 'mid-after-noon' etc
+    }
+  }
+})
+
+const delivery = new Tempo('deadline'); // Parsed using your custom logic, adds 30-days to current-date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ 5.2 Deferring Initialization (mode: 'defer') ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default (mode: 'auto'), Tempo uses the Master Guard to determine if a string can be lazily evaluated. For exceptionally high-volume scenarios where you may be creating thousands of Tempo instances but only using them for calculations (not formats or Terms), you can force a standard lazy behavior using mode: 'defer'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When mode: 'defer' is set, the registry-discovery logic is deferred until the first time you access a property on t.fmt or t.term.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Optimized for mass-creation
+const t = new Tempo('now', { mode: 'defer' });
+
+console.log(t.format('{yyyy}')); // Discovery triggers NOW, only once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When initialized this way, no registries are built upfront. The constructor returns in O(1) time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Cost Constructor: Combining the Master Guard (automatic) and the defer mode allows Tempo to satisfy the "Zero-Cost Constructor" requirement for mass-processing applications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧹 5.3 Noise Word Filtering (ignore) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo allows you to specify "noise words" that should be ignored during natural language parsing. This is particularly useful for handling human-readable strings that contain connectors or filler words.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo ignores the word "at" (e.g., "Friday at 3pm" becomes "Friday 3pm" internally).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Extend globally via Tempo.init()
+// This adds 'the' and 'o-clock' to the existing default list (['at'])
+Tempo.init({ registry: { ignores: ['the', 'o-clock'] } });
+
+// Use in a specific instance via the Tempo constructor (new Tempo(...))
+// This instance will ignore 'at', 'the', and 'o-clock'
+const t = new Tempo('next Friday at 3 o-clock', { 
+  registry: { ignores: 'o-clock' }
+}); 
+
+console.log(t.toString()); // Resolved correctly (noise words stripped)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registry Structure: The ignore registry accepts a String or an Array of strings. These are converted to a high-performance internal format to support efficient prototype-based shadowing. Note that values provided via Tempo.init() or the new Tempo() constructor merge with the default ignore list rather than replacing it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 5.4 Parse Planner & Pre-filtering ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For high-performance applications, you can enable the Parse Planner to optimize the pattern-matching loop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    planner.preFilter (Boolean) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled, Tempo performs a fast upfront classification of the input string (detecting digits, letters, colons, etc.) and skips layouts that cannot possibly match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Purely numeric inputs: Skips event, period, wkd, and rel layouts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Alpha-only inputs: Skips time-heavy layouts like hms or off.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Colon detected: Prioritizes time-based layouts (tm, dtm) to find a match faster.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ 
+  planner: { preFilter: true } 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    planner.layoutOrder (Array) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can manually define the order in which layouts are attempted. This is useful if you know your data primarily uses a specific format (e.g., ISO dates) and want to avoid checking other layouts first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ 
+  planner: { layoutOrder: ['ymd', 'dt', 'tm', 'rel'] } 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Observability: Set debug: 'debug' along with planner.preFilter to see a detailed "Planner summary" in the console, showing how many layouts were skipped for a given input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Summary of Tiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TierPrecedenceBest For...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defaults🐚 BaselineOut-of-the-box reasonable settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Persistence🏅 Low (Default)Sticky user preferences (merges into baseline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovery🥉 MediumMicro-frontends and third-party integrations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Init🥈 HighStandard baseline for the whole application.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance🥇 HighestAd-hoc overrides for specific calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Observability: When debug: 'debug' is set, Tempo logs its discovery path to the console (e.g., "Global Discovery found via Symbol"), making it easy to trace exactly where a setting originated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hidden Keys: The tempo.config getter excludes internal properties like anchor and input-only properties like value to keep the public API clean. These properties are still used internally for relative date resolution and instance hydration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.duration.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.duration.html new file mode 100644 index 00000000..027abf34 --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.duration.html @@ -0,0 +1,130 @@ + + + + + + Duration Logic | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Duration Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a powerful DurationModule for calculating, balancing, and formatting the elapsed time between two dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo wraps the modern Temporal API, durations are highly accurate, seamlessly handling leap years, daylight saving time boundaries, and variable month lengths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculating Durations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo offers two primary methods for calculating time differences: .until() and .since(). While they may appear to be directional inverses of each other, they serve distinct architectural purposes and produce different output types:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .until() is built for numeric and mathematical calculations, returning primitive Number metrics (e.g. 420 minutes) or a Duration object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .since() is built for human-readable relative time formatting, returning localized String outputs (e.g. "36y ago" or "yesterday" via Intl.RelativeTimeFormat).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Coming from Moment.js or Day.js?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are looking for .diff(), you won't find it in Tempo—and for good reason!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In legacy libraries, a.diff(b) performed a - b, frequently causing off-by-sign confusion (e.g., today.diff(christmas) returning a negative number).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When architecting the modern ECMAScript Temporal API, the TC39 committee deliberately rejected .diff() in favor of directional, self-explanatory methods. Tempo follows this modern standard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use .until() for forward-looking math and durations ("How long until Christmas?" → today.until(christmas, 'days') is intuitively positive).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use .since() for elapsed time and human-readable relative strings ("How long since my birthday?" → today.since(birthday, 'years') → "36y ago").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .until() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the time remaining from the Tempo instance until a future date. The target can be a Tempo instance, a Temporal object, a JS Date, an ISO string, or a natural-language string expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const now = new Tempo('2026-05-10T08:00:00');
+const targetDate = new Tempo('2026-12-25'); // Tempo instance
+
+// 1. Target as a Tempo / Temporal instance (returns a Duration EDO)
+const duration = now.until(targetDate);
+
+// 2. Target as a Tempo instance with a specific unit (returns a primitive Number)
+now.until(targetDate, 'days');               // → 229    (using Tempo instance)
+now.until(targetDate, 'weeks');              // → ~32.71 (using Tempo instance)
+
+// 3. Target as a natural-language string expression or ISO string
+now.until('2026-12-25', 'days');             // → 229    (ISO date string)
+now.until('christmas', 'days');              // → 229    (natural-language string expression)
+now.until('afternoon', 'minutes');           // → 420    (natural-language string expression)
+
+// 4. Target as a chained Tempo mutation
+now.until(now.add({ days: 2 }), 'hours');    // → 48     (or 47/49 if crossing a DST transition)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Date-only targets inherit the current time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a target resolves to a date without a time component (e.g. 'christmas', 'tomorrow', 'next friday'), Tempo copies the current time-of-day from the anchor into the target. This means:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'days') → whole number — the time components cancel out exactly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'hours') → whole number — same reason.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • now.until('christmas', 'weeks') → fractional — 229 days does not divide evenly into weeks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This matches natural-language intuition: "How many days until Christmas?" expects 229, not 229.43. Targets with an explicit time (e.g. 'afternoon', '9am') produce fractional values if the target time differs from the anchor's current time-of-day.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .since() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculates the time elapsed since a past date. By default, it returns a human-readable localized string (powered by Intl.RelativeTimeFormat).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const anchor = new Tempo('2026-05-10', { locale: 'en-US' });
+const birthday = new Tempo('1990-05-10');
+
+// 1. Returns localized relative string based on the given unit
+// Note: Tempo uses a compact ('narrow') Intl style by default
+anchor.since(birthday, 'years');  // → "36y ago" (deterministic)
+anchor.since(birthday, 'days');   // → "13,149d ago" (deterministic)
+
+// 2. Pass a custom formatter for natural language output (e.g. "yesterday")
+const yesterday = anchor.add({ days: -1 });
+const autoFormat = new Intl.RelativeTimeFormat('en-US', { numeric: 'auto' });
+anchor.since(yesterday, { unit: 'days', intl: { relativeTimeFormat: autoFormat.format.bind(autoFormat) } }); // → "yesterday"
+
+// 3. Returns an ISO 8601 Duration String if no unit is provided
+anchor.since(birthday);     // → "-P36Y..."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Duration Object (EDO) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you call until() (or Tempo.duration()), Tempo returns an Extended Data Object (EDO) representing the exact duration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const dur = Tempo.duration('P1Y2M15D');
+console.log(dur.years);   // 1
+console.log(dur.months);  // 2
+console.log(dur.days);    // 15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Intelligent Balancing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Return Types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you call .until() without a unit, it returns a Tempo.Duration object, onto which you can chain .balance() and .format() (see below). If you provide a unit (like 'days'), it returns a primitive JavaScript Number. Calling .balance() on a Number will throw an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes you have a raw number of days (e.g. 365 days) and you want to mathematically "balance" it into larger units (like 1 year). Tempo provides the .balance() method directly on the Duration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When to use .balance()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo injects { largestUnit: 'years' } by default, .until() is usually perfectly balanced out of the box. However, you will still need to chain .balance() in three specific scenarios:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Raw Durations: When you manually construct an unbalanced duration (e.g., Tempo.duration({ days: 365 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Cross-Timezone Math: If you run .until() between two different timezones, Tempo restricts the result to hours to prevent calendar ambiguity. Chaining .balance() forces the rollup into Years/Months.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Nominal Math: When you want to force commercial math ({ nominal: true }) instead of strict calendar math.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strict Calendar Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, .balance() uses a relativeTo anchor to perform perfect calendar math.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // A manually created duration is unbalanced by default: { days: 365 }
+const rawDuration = Tempo.duration({ days: 365 });
+
+// Balance it using an anchor: safely converts it to { years: 1 } (or 11mo 30d if a leap year!)
+const balanced = rawDuration.balance({ relativeTo: '2026-01-01' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nominal (Commercial) Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building SaaS pricing tables or catalog displays, strict calendar math can be frustrating (you don't want a 365-day license to display as "11 months and 30 days" during a leap year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can pass { nominal: true } to mathematically force 365 days = 1 year, 30 days = 1 month, and 7 days = 1 week regardless of the calendar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const commercialDur = Tempo.duration({ days: 365 }).balance({ nominal: true });
+console.log(commercialDur.years); // 1
+console.log(commercialDur.days);  // 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Balancing Downwards (Un-balancing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also force a duration to roll downwards into smaller units by specifying a largestUnit. This is incredibly useful for UI countdown timers (e.g., displaying "48 Hours" instead of "2 Days") or per-diem billing calculations where you need to know exactly how many days are in a specific year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const yearlyLicense = Tempo.duration({ years: 1 });
+
+// Un-balance the year down into exact days (365 or 366 depending on the anchor)
+const exactDays = yearlyLicense.balance({ 
+  largestUnit: 'days', 
+  relativeTo: '2024-01-01' 
+});
+
+console.log(exactDays.days); // 366 (2024 is a leap year!)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting Absolute Durations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once you have a balanced duration, you can instantly render it as a highly localized, plural-aware string using the .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .format() natively uses Intl.DurationFormat (or a robust multi-unit polyfill) to render all non-zero units perfectly into the user's language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Perfect for detailed countdowns or SaaS dashboards!
+const formatted = Tempo.duration({ days: 395, hours: 4 })
+  // 'nominal: true' uses 365d/yr and 30d/mo math, so no relativeTo anchor is needed
+  .balance({ nominal: true })
+  .format();
+
+console.log(formatted); // "1 year, 1 month, and 4 hours" (or localized equivalent)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also define default formatting options globally by adding durationFormat into your Tempo.init configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  intl: {
+    durationFormat: { style: 'short' } // e.g. "1 yr, 1 mth, 4 hr" instead of long-form
+  }
+});
+
+// Now, all format calls will automatically use 'short' display
+const shortDur = Tempo.duration('P1Y1M').format(); // "1 yr, 1 mth"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.format.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.format.html new file mode 100644 index 00000000..13ad2d0f --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.format.html @@ -0,0 +1,208 @@ + + + + + + Smart Formatting Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Formatting Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a powerful token-based formatting engine that goes beyond the standard ISO strings of native Temporal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Standalone Formatting (Zero-Overhead) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you have a native Temporal.ZonedDateTime and want to format it using Tempo's readable tokens, you can use the standalone format function. This allows you to use Tempo's formatting logic without importing the full Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { format } from '@magmacomputing/tempo/format';
+
+const zdt = Temporal.Now.zonedDateTimeISO();
+const str = format(zdt, '{mon} {dd:ord}, {yyyy}'); 
+
+console.log(str); // e.g., "October 24th, 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms and Standalone Formatting: When using format() with native Temporal objects, Terms (tokens starting with #) are not resolved. To use Terms resolution in your format strings, you must either pass a Tempo instance to the format() utility or use the class-based .format() method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Input Types ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine can interpret:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Objects: ZonedDateTime, Instant (auto-projected to ZDT), PlainDate, PlainDateTime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo Instances: Any instance of the Tempo class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Strings: Valid Temporal ISO-8601 strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Defaults: If no object is provided, it defaults to Now in the configured timezone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Class-Based Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Tempo class, the .format() method is available on every instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('2026-10-24T15:30:00');
+console.log(t.format('display')); // Sat, 24 Oct 2026 (using a named format alias)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Named Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo comes with several pre-configured format aliases. You can also define your own globally during initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    formats: {
+      'fancy': '{mon} the {dd:ord} day of {yyyy}'
+    }
+  }
+});
+
+const t = new Tempo('2026-10-24');
+console.log(t.format('fancy')); // October the 24th day of 2026

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modularity: Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Like the parsing engine, the formatting engine is modular:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VersionFormatting Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo FullBuilt-in. Works out of the box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo CoreOpt-in. You must call Tempo.use(FormatModule) to enable .format().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabling Formatting in Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using @magmacomputing/tempo/core, you must explicitly register the formatting engine:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { FormatModule } from '@magmacomputing/tempo/format';
+
+Tempo.use(FormatModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔠 Supported Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is heavily opinionated. To provide maximum predictability and eliminate common timezone or regional bugs, Tempo strictly defaults to ISO-8601 standards. This means weeks always start on Monday (1), and mathematical bounds (like week-of-year and year-of-week calculations) adhere to the rigorous ISO specification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Dialects & Migration Tempo's formatting engine uses explicit curly braces and consistent lower-case tokens ({yyyy}, {mm}, {dd}) to prevent common cross-ecosystem pitfalls—such as token confusion between calendar year and ISO week-year (in Unicode LDML yyyy is calendar year while YYYY is ISO week-year, whereas in Moment and Day.js YYYY is calendar year while GGGG is ISO week-year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating an existing codebase from Moment, Day.js, or Luxon, the @magmacomputing/tempo-plugin-dialects community plugin provides drop-in support for familiar external masks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { DialectsPlugin } from '@magmacomputing/tempo-plugin-dialects';
+
+Tempo.use(DialectsPlugin);
+Tempo.init({ dialect: 'moment' });
+
+const t = new Tempo('2026-10-24');
+t.format('YYYY-MM-DD');        // "2026-10-24" (Moment mask)
+t.format('{yyyy}-{mm}-{dd}');  // "2026-10-24" (Native Tempo tokens always work)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For Unicode LDML, POSIX strftime, and dual-mode configuration details, see the Dialects Plugin Documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TokenDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yyyy}4-digit Year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yy}2-digit Year26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {eon}Absolute Year within Era200
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {era}Era Designator (e.g., AD/BC, CE/BCE)AD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yow}ISO Year of Week2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {woy}Zero-padded ISO Week of Year43
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mon}Full Month NameOctober
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mmm}Short Month NameOct
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mm}Zero-padded Month10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dd}Zero-padded Day24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wkd}Full Weekday NameSaturday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {www}Short Weekday NameSat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dow}ISO Day of Week (1=Mon, 7=Sun)6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {doy}Day of Year (1-366)297
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {intl.<prop>}Regional metadata via Intl.LocaleInfo ({intl.region}, {intl.script}, {intl.firstDay}, {intl.direction}, {intl.hourCycle})US, Latn, 7, ltr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hh}Zero-padded Hour (24h)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {h24}Zero-padded Hour synonym (24h)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {h12}Zero-padded Hour (12h) plus meridiem03pm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mer}am/pm meridiem markerpm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mi}Zero-padded Minutes30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ss}Zero-padded Seconds45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ms}Zero-padded Milliseconds (3-digit)123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {us}Zero-padded Microseconds (3-digit)456
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ns}Zero-padded Nanoseconds (3-digit)789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ff}Fractional Seconds (9-digit)123456789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ts}Unix Timestamp1792843200000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dmy}Compact Date (ddmmyyyy)24102026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mdy}Compact Date (mmddyyyy)10242026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ymd}Compact Date (yyyymmdd)20261024
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hms}Compact Time (24h)153045
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {time}Time (24h, or localized format via :locale)15:30:45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {nano}Nanosecond Timestamp1792843200000000000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dim}Total Days in Month (28-31)31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {cen}2-digit Century ({century})20
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {jj}Astronomical Julian Day Number ({julian})2461338
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wom}Week of Month (1-5, aliases {ww:month}, {woy:month})4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz}Time Zone IDAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {cal}Calendar Systemiso8601

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎛️ Token Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can append modifiers to any token using a colon (:) to transform its output. Multiple modifiers can be chained together (e.g., {mon:locale:title}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierTargetDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :<number>NumberPositive integer zero-fill pads numeric tokens (e.g. {ns:6} → 000005); negative integer tail-slices digits from the right (e.g. {yyyy:-3} → 026, {yow:-2} → 26); or slices fractional-second {ff} to precision length (e.g. {ff:1} → tenths, {ff:2} → hundredths){doy:3} → 045, {yyyy:-3} → 026, {ff:1} → 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :rawNumberUnpadded number with no meridiem{h12:raw} → 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :ordNumberUnpadded number with ordinal suffix{dd:ord} → 24th
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :romanNumberConverts integer into Roman numeral representation (supports chaining with :lower){yyyy:roman} → MMXXVI, {mm:roman:lower} → x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :upperStringConverts to uppercase{mer:upper} → PM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :lowerStringConverts to lowercase{mon:lower} → october
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :titleStringConverts to titlecase{mon:locale:title} → Octobre
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :dotsStringInjects periods (useful for abbreviations){mer:lower:dots} → a.m.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :spaceUniversalInjects leading space padding for numeric tokens (e.g. {dd:space} → 5, {doy:3:space} → 5), or a leading space before string/meridiem elements{dd:space} → 5, {h12}:{mi}{mer:space:dots} → 03:30 a.m.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :localeUniversalResolves localized term/month/weekday, adapts {dow:locale} to week start, adapts {woy:locale} / {yow:locale} to locale week rules, adapts {hh:locale} to hourCycle, or transliterates numeric tokens into locale numberingSystem{mon:locale} → octobre, {dow:locale} → 1, {dow:locale:0} → 0, {woy:locale} → 01, {hh:locale} → 03 (in en-US), {yyyy:locale} → ٢٠٢٦ (in ar-EG)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :shortUniversal / StringYields a short or abbreviated style (e.g. {mon:short} → Oct, {yow:short} → 26, {dmy:short} → 241026){mon:short} → Oct, {yow:short} → 26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :longStringYields a full-length style{mon:long} → October
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :compactStringYields a delimiter-free, compact representation{tz:offset:compact} → +1000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :offset{tz}Converts timezone identifier to numeric UTC offset. Supports granular sub-modifiers (:hh, :mi, :ss, :z){tz:offset} → +10:00, {tz:offset:hh} → +10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :zero / :0NumberShifts 1-based counters to zero-indexed ({doy:zero} → 000–365, {dow:zero} → 0–6 Sunday=0, {dow:locale:0} → 0–6 locale week start=0, {mm:zero} → 00–11, {woy:zero} → 00–52, {wom:zero} → 0–4){dow:0} → 6, {dow:locale:0} → 0, {mm:raw:0} → 9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :dayUnit ScopeExpresses time units cumulatively over the day ({ss:day} → 0–86399, {mi:day} → 0–1439, {ms:day}, {ns:day}){ss:day} → 55845
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :weekUnit ScopeExpresses time units cumulatively over the week ({hh:week} → 0–167, {mi:week}, {ss:week}) or day within the week ({dd:week} → 1–7){hh:week} → 135, {dd:week} → 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :monthUnit ScopeScopes counters to the month ({wom} / {woy:month} → 1–5, {dd:month} → 1–31){wom} → 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    :yearUnit ScopeScopes counters to the year ({dd:year} → 001–366, {mm:year} → 01–12){dd:year} → 297

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timezone Formatting & Extended Offset Variations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz} defaults to the IANA timezone identifier (e.g. Australia/Sydney). Modifiers can be composed seamlessly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Named Styles: {tz:short} → AEST, {tz:long} → Australian Eastern Standard Time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chained Offsets: {tz:offset} → +10:00, {tz:offset:short} → +10, {tz:offset:compact} → +1000.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Granular Offset Components:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:hh} / {tz:offset:hour} → Hour with sign (e.g. +10, -05, +00).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:mi} (and alias :min) → Minutes without sign (e.g. 00, 30).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:ss} (and alias :sec) → Offset including seconds (e.g. +10:00:00, compact {tz:offset:compact:ss} → +100000).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {tz:offset:utc} / {tz:offset:compact:utc} → UTC Z indicator: emits Z for UTC (+00:00), else ISO offset +10:00 (or compact +1000).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Canonical Naming: Sub-modifiers :hh, :mi, :ss, and :utc match Tempo's core time tokens. Modifiers :hour, :min, :sec, and :z are supported synonyms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shorthands & Aliases: LDML aliases ({tz:z}, {tz:zz}, {tz:zzz}) are supported as drop-in shorthands.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Numeric Zero-Fill Padding, Tail-Slicing & Fractional Precision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can pass any integer width directly as a modifier (e.g. {doy:3}, {yyyy:-3}, {yow:-2}, {ns:6}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Positive width (+N): Zero-pads integers to the specified width. Negative values maintain proper sign formatting (e.g. -5 with :3 yields "-05").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Negative width (-N): Slices the last N characters from the right (slice(-N)). Ideal for year variations such as 3-digit year ({yyyy:-3} → '026'), 1-digit year ({yyyy:-1} → '6'), or 2-digit ISO week-year ({yow:-2} / {yow:short} → '26').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fractional seconds ({ff}): Slices the 9-digit fractional second string to the specified precision length (e.g. {ff:1} for tenths, {ff:2} for hundredths, {ff:3} for milliseconds, {ff:6} for microseconds).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specialized Tokens, Calendrical Counters & Designed Composability
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rather than proliferating one-off tokens for every niche format requirement, Tempo promotes an orthogonal matrix of composable unit scopes (:day, :week, :month, :year) alongside specialized tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Astronomical Julian Day ({jj}, {julian}): Emits continuous 7-digit day count since 4713 BC (2461331 for 2026-10-17, matching Oracle J).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Julian Day vs. Day of Year: {jj} is the astronomical Julian Day number, whereas {dd:year} (or {doy}) is the day of the year (1–366, matching mainframe "Julian dates" like YYYYDDD).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Days in Month ({dim}): Total count of days in the current month (28–31, matching PHP t). (Convenience alias for .zdt.daysInMonth).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Century ({cen}, {century}): 2-digit century number (20 for 2026, matching POSIX %C).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Week of Month ({wom}): 1-based week counter within the month (1–5, matching Oracle W and Unicode LDML W). Semantic aliases: {ww:month}, {woy:month}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calendar Week ({woy:cal}) & v5 Roadmap: Week of year starting on January 1st (01–53, matching Oracle WW). Marked @deprecated Will be superseded by {ww} in v5.0.0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dimensional Time-Scope Modifiers: Compose time units over a specified duration scope:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {ss:day}: Seconds past midnight (0–86399, matching Oracle SSSSS).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mi:day}: Minute of the day (0–1439).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {ms:day}, {ns:day}: Milliseconds and nanoseconds of the day.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {dd:week}: Day of week (1–7, or 0–6 with :zero).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {hh:week}: Hour of the week (0–167).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mi:week}, {ss:week}: Minute and second of the week.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Generalized Zero-Indexing (:zero / :0): Shifts any 1-based numeric counter to 0-based without width collisions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • :zero is the canonical semantic modifier; :0 is its compact shorthand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {doy:zero} / {doy:0}: 000–365 (or {doy:raw:0} → 0–365, matching PHP z).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {dow:zero} / {dow:0}: 0–6 with Sunday = 0 (matching POSIX %w, JavaScript Date.prototype.getDay() parity).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {mm:zero} / {mm:0}: 00–11 (or {mm:raw:0} → 0–11, matching JavaScript Date.prototype.getMonth() parity).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {woy:zero} / {woy:0}: 00–52.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {wom:zero} / {wom:0}: 0–4.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implicit Localization Bridge The :short and :long styling modifiers act as an automatic bridge to the browser's native Intl API! By default, core tokens like {mon} or {wkd} run at zero-cost using Tempo's lightning-fast internal enums (yielding English results). If you want a localized string, you don't need to explicitly chain the :locale modifier. Simply using a styling modifier like {mon:long} will automatically translate the string using the instance's configured locale!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Automatic Meridiem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your format string contains {h12} (12-hour clock) but lacks a {mer} token, Tempo will automatically append a {mer} token with the same modifiers as the {h12} token after the last time component to ensure the time remains unambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (If you explicitly want a 12-hour digit without an auto-appended meridiem, use the :raw modifier: {h12:raw})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why {h12} and {h24}? In other date libraries, {hh} could mean 12-hour and {HH} could mean 24-hour time. This is confusing and error-prone. Tempo standardizes {hh} on the default 24-hour expectation, but provides explicit {h12} and {h24} tokens to completely eliminate ambiguity. This keeps all token definitions fully lowercase and semantic, without relying on uppercase variations like {HH}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.format('{h12}:{mi}');           // "03:30pm" (auto-append standard meridiem)
+t.format('{h12:upper}:{mi}');     // "03:30PM" (auto-append modified meridiem)
+t.format('{h12:dots}:{mi}');      // "03:30a.m." (auto-append meridiem with dots)
+t.format('{h12:space:dots}:{mi}');// "03:30 a.m." (auto-append meridiem with leading space)
+t.format('{h12:raw}:{mi}');       // "3:30"    (no meridiem added)
+t.format('{h12:raw}:{mi} {mer}'); // "3:30 am" (manual space + meridiem)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📝 Common Formatting Examples ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Here are a few real-world examples demonstrating how tokens and modifiers can be composed together to build readable sentences and structured strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-05T15:30:00');
+
+// Injecting tokens directly into sentences
+t.format('Today is the {dd:ord} of {mon:title}'); 
+// "Today is the 5th of October"
+
+// Building standard UI formats
+t.format('{wkd}, {mmm} {dd:raw}, {yyyy} @ {h12}:{mi}'); 
+// "Monday, Oct 5, 2026 @ 03:30pm"
+
+// Forcing fully lowercase strings
+t.format('{wkd:lower} afternoon'); 
+// "monday afternoon"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📍 Dynamic Namespace & Spatial Tokens ({namespace.key}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's format engine dynamically resolves bracketed dot-notated tokens ({namespace.key}) against any active plugin namespace or property container on the Tempo instance (such as t.geo, t.finance, t.astro, t.term, or custom attached metadata).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geographic Tokens ({geo.*}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When geographic coordinates or metadata are attached to a Tempo instance (via options.geo, new Tempo('...', { geo: { city: 'Sydney', country: 'AU', lat: -33.8688, lng: 151.2093 } }), or resolved via t.geoLocate()), you can format location fields directly using {geo.<property>} tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TokenDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.city}Locality or City nameSydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.country}ISO Country code or Country nameAU / Australia
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.sphere}Hemisphere (north, south, or equator)south
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.elevation}Altitude / Elevation in meters above sea level42
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.timezone}IANA Timezone resolved from coordinatesAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {geo.<custom>}Any custom metadata key attached to t.geoOpera House

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom & Plugin Namespace Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any namespace plugin mounted via defineNamespace or property object on the instance can be formatted directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Plugin namespace (e.g. tempo-plugin-finance):
+t.format('Fiscal Quarter: Q{finance.fiscalQuarter} ({finance.taxYear})');
+
+// Term plugin (e.g. season or solar terms):
+t.format('Current Season: {term.season} · {geo.city:title}');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modifiers & Graceful Fallback ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All standard formatting modifiers apply seamlessly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.country:upper} → AU
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.city:title} → Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {geo.sphere:upper} → SOUTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For known property namespaces (like geo), if the context is unpopulated or the requested property is missing, the token cleanly resolves to an empty string ('') rather than throwing an exception or printing undefined:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24T15:30:00', {
+  geo: { city: 'Sydney', country: 'AU', lat: -33.869, lng: 151.209 }
+});
+
+t.format('{geo.city}, {geo.country} · {h12}:{mi} {mer}');
+// "Sydney, AU · 03:30 pm"
+
+// Graceful fallback for instances without geo:
+const tNoGeo = new Tempo('2026-10-24T15:30:00');
+tNoGeo.format('Time: {hh}:{mi} [{geo.city}]');
+// "Time: 15:30 []"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Hierarchical Localization ({namespace.key:locale}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using :locale on namespace tokens (e.g. {geo.sphere:locale} or {custom.tag:locale}), Tempo resolves translations from the global registry.locales dictionary using an intuitive, cascading fallback:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Deep Hierarchical Path: locales[lang]?.geo?.sphere?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Leaf Property Scoped: locales[lang]?.sphere?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Flat Word Match: locales[lang]?.['south'] → "sud"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Canonical Fallback: If no dictionary match exists, gracefully returns the raw canonical value ("south").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',
+  registry: {
+    locales: {
+      fr: {
+        geo: {
+          sphere: {
+            north: 'nord',
+            south: 'sud',
+            equator: 'équateur',
+          },
+          city: {
+            sydney: 'Sydney (Australie)',
+          },
+        },
+      },
+    },
+  },
+});
+
+const t = new Tempo('2026-10-24', { geo: { city: 'sydney', sphere: 'south' } });
+
+t.format('{geo.sphere:locale}');        // "sud"
+t.format('{geo.sphere:locale:title}');  // "Sud" (modifiers chain seamlessly)
+t.format('{geo.sphere:locale:upper}');  // "SUD"
+t.format('{geo.city:locale}');          // "Sydney (Australie)"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Complex Native Intl Formatting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Tempo's template tokens ({dd}, {mon}, etc.) combined with the :locale modifier are incredibly powerful for structured formats, there are times when you want the full power of the native Intl.DateTimeFormat API for complete, culturally-specific sentence formatting (like Arabic numerals or full-length descriptive dates).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo's philosophy is to "humanize" the rigid Temporal API, you can pass an Intl.DateTimeFormatOptions object directly into the .format() method. While Intl.DateTimeFormat still strictly validates your locales and option values, Tempo catches Temporal mismatch failures for you. It automatically retries formatting using zdt.epochMilliseconds for Temporal/Intl mismatch cases, safely injects the necessary timeZone and calendar metadata, but will explicitly rethrow any withTimeZone or withCalendar failures (e.g. from invalid timezones).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo vs Temporal (Side-by-Side):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const arabicConfig = {
+  locale: 'ar-EG',
+  timeZone: 'Africa/Cairo',
+  weekday: 'long',
+  year: 'numeric',
+  month: 'long',
+  day: 'numeric',
+  numberingSystem: 'arab'
+}
+
+// 🔴 Native Temporal (Strict & Verbose)
+// 1. You must carefully parse the date using the correct Temporal factory.
+// 2. You must manually shift the timezone before formatting, or it throws an exception!
+const nativeStr = Temporal.PlainDateTime
+  .from('2024-12-25T14:30:00')
+  .toZonedDateTime('UTC')
+  .withTimeZone('Africa/Cairo')
+  .toLocaleString('ar-EG', arabicConfig);
+
+// 🟢 Tempo (Humanized)
+// Automatically handles the parsing, shifts constraints, and safely delegates to Intl!
+const tempoStr = new Tempo('2024-12-25 14:30')
+  .format(arabicConfig);
+
+console.log(tempoStr); // "الأربعاء، ٢٥ ديسمبر ٢٠٢٤"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example: Japanese Reiwa Era formatting
+const t = new Tempo('2024-12-25 14:30');
+
+const japaneseConfig = {
+  locale: 'ja-JP-u-ca-japanese',
+  timeZone: 'Asia/Tokyo',
+  calendar: 'japanese',
+  era: 'long',
+  year: 'numeric',
+  month: 'long',
+  day: 'numeric'
+}
+
+console.log(t.format(japaneseConfig));
+// Output: "令和6年12月25日"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Custom Format Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need a completely custom format behavior? You can define dynamic token evaluators in the global registry that receive the zdt (Temporal.ZonedDateTime) instance and a context object, giving you full native access to Intl formatting or custom logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why native ZonedDateTime instead of a Tempo instance? The formatting engine is highly modular and designed to be tree-shakable via the standalone format() utility. By injecting native Temporal objects, custom tokens remain extremely fast, portable, and zero-overhead. If you absolutely need access to Tempo's syntactic sugar inside your token evaluator, you can simply re-wrap the object on the fly: const t = new Tempo(zdt);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+    locale: 'fr-FR',
+    registry: {
+        tokens: {
+            // A simple math-based token
+            'myDay': (zdt) => String(zdt.day - 1),
+            
+            // A deeply localized custom token using native Intl
+            'wkd-fr': (zdt, { config }) => {
+                const dtOptions = config?.intl?.dateTimeFormat ?? {};
+                return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
+            }
+        }
+    }
+});
+
+const t = new Tempo('2024-05-20');
+t.format('{myDay}');  // "19"
+t.format('{wkd-fr}'); // "lundi"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.getters.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.getters.html new file mode 100644 index 00000000..0e9cbe78 --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.getters.html @@ -0,0 +1,74 @@ + + + + + + 🧲 Core Getters | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧲 Core Getters ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo class provides an extensive array of zero-cost getters that allow you to seamlessly read properties from the underlying Temporal instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Cost Lazy Evaluation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a sophisticated proxy-based lazy-evaluation pattern. Accessing a getter (like t.yy) resolves the property on demand, and then overwrites the getter with a static literal. This means the first access is O(1) and every subsequent access is raw property access (O(0) cost).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Native Temporal Gateway ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .zdtTemporal.ZonedDateTimeDirect zero-overhead access to the underlying native Temporal instancet.zdt.daysInMonth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .zdt getter provides direct, zero-overhead access to the underlying Temporal.ZonedDateTime instance, enabling native Temporal inspections and properties without method call ceremony:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24T15:30:00[Australia/Sydney]');
+
+console.log(t.zdt.daysInMonth);  // 31
+console.log(t.zdt.inLeapYear);   // false
+console.log(t.zdt.offset);       // '+11:00'
+console.log(t.zdt.hoursInDay);   // 24
+console.log(t.zdt.monthCode);    // 'M10'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 Date Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .yynumber4-digit Year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .mmnumberMonth number (1 = Jan, 12 = Dec)10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ddnumberDay of the month (1-31)24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .dimnumberTotal days in the month (28-31; convenience alias for .zdt.daysInMonth)31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .jjnumberAstronomical Julian Day number since 4713 BC2461331
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .erastringLocalized era string'ce', 'bce', 'ad', 'bc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .eonnumberPositive integer year within the current .era2026, 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Days in Month (.dim) vs. Native .zdt.daysInMonth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While .dim is provided as a zero-cost convenience property returning the number of days in the current month (28–31, matching format token {dim} and PHP t), t.zdt.daysInMonth is the native standard property directly available on the underlying Temporal.ZonedDateTime instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Astronomical Julian Day (.jj) vs. Day of Year (.doy)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .jj provides the true astronomical Julian Day Number (an integer day count elapsed since noon UT on January 1, 4713 BC in the proleptic Julian calendar, e.g. 2461331 for 2026-10-17), matching Oracle J and token {jj}. If you need the calendar day within the current year (1–366), use .doy (or format token {doy} / {dd:year}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Time Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .hhnumberHour of the day (0-23)15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .minumberMinutes of the hour (0-59)30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ssnumberSeconds of the minute (0-59)45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .msnumberMilliseconds of the second (0-999)123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .usnumberMicroseconds of the millisecond (0-999)456
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .nsnumberNanoseconds of the microsecond (0-999)789
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .ffnumberFractional seconds representation0.123456789

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ ISO Week & Day Alignments ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .yownumber4-digit ISO week-numbering year2026
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .woynumberISO week number of the year (1-53; canonical, supersedes legacy .ww)43
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .downumberISO weekday number (1 = Mon, 7 = Sun)6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .doynumberDay of the year (1-366)297

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Canonical Getters & v5 Deprecation Path
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To establish a clean, predictable, and collision-free API surface across getters and format tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .woy is canonical for ISO week of the year. The legacy .ww getter is marked @deprecated and will be removed in v5.0.0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .eon is canonical for the positive integer year within the era (supersedes @deprecated .eraYear).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .dd is canonical for the day of the month (supersedes @deprecated .day).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔤 Named String Representations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .monstringFull English month name'October'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .mmmstringShort English month name'Oct'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .wkdstringFull English weekday name'Saturday'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .wwwstringShort English weekday name'Sat'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Regional, Timezone & System Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescriptionExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .tzstringIANA Time Zone ID'Australia/Sydney'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .calstringTemporal Calendar ID'iso8601'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .localestring | string[]Resolved BCP 47 locale'en-AU', ['en-US', 'fr-FR']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .intlTempoIntlNamespaceStructured internationalization namespace (.info for cultural metadata, .locale for native Intl.Locale)t.intl.info.firstDay, t.intl.locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .geoobject | undefinedResolved geographic coordinates (latitude, longitude, elevation, sphere){ latitude: -33.8688, longitude: 151.2093 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .sphere'north' | 'south' | undefinedResolved hemisphere configuration'south'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .tsnumber | bigintUnix timestamp (number for ss/ms/us, bigint for ns)1792843200000
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .nanobigintNanoseconds since Unix epoch1792843200000000000n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .isostringStandard ISO 8601 string (RFC 3339) in UTC'2026-10-24T04:30:00Z'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .isValidbooleantrue if the underlying date-time is validtrue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎛️ Metadata Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Beyond date-time properties, the Tempo class also provides read-only getters into its active state and configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetterTypeDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .configobjectReturns a proxy to the active configuration, including all resolved inheritance and local overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .termsobjectReturns a dictionary of all registered TermPlugins and their available ranges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .rangesobjectReturns a dictionary of the currently active range key for every registered term (e.g., { 'season': 'summer' }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .parseobjectReturns a shadowed view of the internal parsing state (including anchor, mode, and the AST-like match output).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.interval.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.interval.html new file mode 100644 index 00000000..059e4173 --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.interval.html @@ -0,0 +1,105 @@ + + + + + + Interval | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interval ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In the realm of time mathematics, an Interval is a continuous segment of time bounded by two fixed points (a start and an end). While a Duration represents an amount of time (e.g., "5 hours"), an Interval is firmly anchored to the timeline (e.g., "9:00 AM to 2:00 PM").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The official ECMAScript Temporal proposal currently lacks a native Interval type. Tempo bridges this gap by providing a mathematically pure, highly optimized Interval primitive directly in the core package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instantiating an Interval ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access the Interval class either statically through the Tempo namespace (for developer convenience) or as a decoupled named export (for strict tree-shaking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Ergonomic Approach (Attached to Tempo) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The easiest way to use Interval is directly from the Tempo class. When instantiated this way, Tempo.Interval automatically intercepts its arguments and parses them through the Tempo constructor. This means you can pass standard strings, Temporal objects, or Date objects directly without wrapping them yourself!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const meeting = new Tempo.Interval(
+  '2026-07-15T14:00:00Z',
+  '2026-07-15T15:00:00Z'
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Purist Approach (Tree-Shakeable Export) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are strictly using native Temporal polyfill objects and want to avoid bundling the entire Tempo class, you can import Interval directly. The pure Interval class has stricter requirements: it relies on simple duck-typing and requires the arguments to be pre-instantiated objects that expose an epochNanoseconds or epoch.ns property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Interval } from '@magmacomputing/tempo';
+import { Temporal } from '@js-temporal/polyfill';
+
+const meeting = new Interval(
+  Temporal.Instant.from('2026-07-15T14:00:00Z'),
+  Temporal.Instant.from('2026-07-15T15:00:00Z')
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Because Interval uses duck-typing to read epochNanoseconds, it natively supports all Temporal point-in-time types (Instant, ZonedDateTime, etc.) and Tempo instances right out of the box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Open-Ended Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both Tempo.Interval and the pure Interval class fully support open-ended time spans! Just pass null for the start or end parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const fromNowOn = new Tempo.Interval(Tempo.now(), null);
+const untilThen = new Interval(null, Temporal.Instant.from('2026-07-15T14:00:00Z'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Interval provides four read-only properties to access its boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    start & end ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These properties return the exact original objects that were used to create the interval (e.g., the Tempo instances or Temporal.ZonedDateTime objects). If the boundary is open-ended, they return null. Use these when you need to format the date, extract calendar components (like month or year), or apply timezone logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startNs & endNs ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These properties return the raw BigInt epoch nanoseconds of the boundaries. If a boundary is open-ended (null), these properties will automatically return the absolute limits of the timeline (Year 1000 or Year 9999).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Performance: When writing custom logic, sorting algorithms, or mathematical overlap checks, always use startNs and endNs! Comparing raw BigInt nanoseconds is thousands of times faster than comparing or mutating Temporal objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set Operations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Interval class provides powerful, lightning-fast methods for evaluating time ranges.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    overlaps() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if two intervals share any common timeline segment. Perfect for finding meeting scheduling conflicts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const bookedSlot = new Tempo.Interval(
+  new Tempo('2026-07-15T14:30:00Z'), 
+  new Tempo('2026-07-15T16:00:00Z')
+);
+
+if (meeting.overlaps(bookedSlot)) {
+  throw new Error('This time slot is already taken!');
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contains() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if a specific point in time falls within the boundaries of the interval (inclusive of start, exclusive of end). Useful for business-hours or promotional-period evaluations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const businessHours = new Tempo.Interval(
+  new Tempo('09:00'), 
+  new Tempo('17:00')
+);
+
+if (businessHours.contains(Tempo.now())) {
+  console.log("We are open!");
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abuts() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checks if one interval ends exactly when another begins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const shift1 = new Tempo.Interval(new Tempo('09:00'), new Tempo('13:00'));
+const shift2 = new Tempo.Interval(new Tempo('13:00'), new Tempo('17:00'));
+
+shift1.abuts(shift2); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intersection() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a new Interval representing the shared, overlapping time between two intervals. Returns null if they do not overlap. Useful for finding mutual availability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const aliceFreeTime = new Tempo.Interval(new Tempo('09:00'), new Tempo('12:00'));
+const bobFreeTime = new Tempo.Interval(new Tempo('11:00'), new Tempo('14:00'));
+
+const mutualFreeTime = aliceFreeTime.intersection(bobFreeTime);
+// Interval: 11:00 to 12:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    union() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a new Interval that spans the entire duration of two overlapping or abutting intervals. Returns null if there is a gap between them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const shift1 = new Tempo.Interval(new Tempo('09:00'), new Tempo('13:00'));
+const shift2 = new Tempo.Interval(new Tempo('13:00'), new Tempo('17:00'));
+
+const fullDay = shift1.union(shift2);
+// Interval: 09:00 to 17:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.mutate.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.mutate.html new file mode 100644 index 00000000..892badca --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.mutate.html @@ -0,0 +1,104 @@ + + + + + + Mutation & Math | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mutation & Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's API for modifying instances is intentionally microscopic. Rather than bloating the prototype with dozens of distinct methods (.addDays(), .subMonths(), .startOf(), etc.), Tempo provides unified utilities that natively support intuitive shorthand strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability & Chainability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All mutation methods in Tempo (.add(), .subtract(), .set()) are strictly immutable. They never modify the original instance. Instead, they evaluate the change and return a new Tempo instance, ensuring absolute safety and allowing for predictable method chaining.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .add() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .add() method returns a new Tempo instance shifted by a specific amount.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = tempo();
+t.add({ days: 5 });           // Adds 5 days

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .subtract() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .subtract() method returns a new Tempo instance shifted backwards by a specific amount.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.subtract({ days: 5 });      // Subtracts 5 days

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also use negative values if you prefer:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.add({ days: -5 });          // Subtracts 5 days
+t.subtract({ days: -5 });     // Adds 5 days (double negative)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The .set() Method ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While .add() shifts a date, the .set() method replaces components.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ year: 2026, month: 1 }); // Sets to January 2026

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can snap to boundaries using intuitive property-based { Term: Value } assignment, or use Slick Structural Keys to navigate custom terminology cycles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ month: 'start' });    // Native: Start of the current month
+t.set({ '#qtr': 'end' });     // Slick: End of the current quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Week Boundaries & Dedicated ISO Invariance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, week boundaries follow ISO 8601 (Monday start, Thursday middle, Sunday end):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ week: 'start' });     // Snaps to Monday 00:00:00
+t.set({ week: 'mid' });       // Snaps to Thursday 00:00:00
+t.set({ week: 'end' });       // Snaps to Sunday 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When localeInfo: true is enabled, week boundary calculations adapt to the active locale's regional first day of the week (e.g., Sunday in en-US, Saturday in ar-EG):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('2026-09-16', { locale: 'en-US', localeInfo: true });
+us.set({ week: 'start' });    // Snaps to Sunday 2026-09-13 00:00:00
+us.set({ week: 'mid' });      // Snaps to Wednesday 2026-09-16 00:00:00
+us.set({ week: 'end' });      // Snaps to Saturday 2026-09-19 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To guarantee strict ISO 8601 Monday-to-Sunday boundaries regardless of active locale or localeInfo settings, use dedicated ISO tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    us.set({ isoWeek: 'start' }); // Always snaps to Monday 00:00:00
+us.set({ woy: 'start' });     // Equivalent dedicated ISO week boundary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ISO Week & ISO Year Mutation (woy, yow) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides full mathematical support for ISO 8601 week calendar coordinates (yow, woy, dow):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Numeric ISO Week Assignment (woy, isoWeek, isoweek) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Assign an ISO week number (1..53) while preserving day of week (dow), time, and ISO year of week (yow):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ isoWeek: 25 });       // Jump to week 25 in the same ISO year
+t.set({ woy: 10 });           // Token equivalent
+t.set({ isoweek: 5 });        // Case-insensitive alias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If an ISO year has 52 weeks and 53 is assigned, Tempo gracefully clamps to week 52 without leaking into the next year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Numeric ISO Year Assignment & Shifting (yow, isoYear, isoyear) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Assign or shift the ISO week-numbering year while preserving week-of-year (woy), day-of-week (dow), and wall-clock time:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ yow: 2028 });         // Move to ISO year 2028 (preserves woy, dow, and time)
+t.set({ isoYear: 2029 });     // Descriptive alias
+t.set({ isoyear: 2030 });     // Case-insensitive alias
+
+t.add({ yow: 1 });            // Shift forward 1 ISO year
+t.subtract({ yow: 1 });       // Shift backward 1 ISO year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When shifting from a 53-week ISO year (e.g., 2020) to a 52-week ISO year (e.g., 2021), Week 53 safely clamps to Week 52 while preserving weekday and time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. ISO Year Boundaries (start, mid, end) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snap directly to key ISO year checkpoints:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ yow: 'start' });      // Monday of Week 1 at 00:00:00
+t.set({ yow: 'mid' });        // Thursday of Week 26 at 00:00:00
+t.set({ yow: 'end' });        // Sunday of Week 52/53 at 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snippet shorthand keys (mm, yy, dd) are also supported for boundary snapping:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ mm: 'start' });       // Snaps to start of current month
+t.set({ yy: 'end' });         // Snaps to end of current year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also navigate relative to your current date by using Slick Shorthand operators directly inside the .set() object payload. Use the snippet shorthand keys (yy, mm, ww, dd, wkd, etc.) and provide a string payload containing a directional modifier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+
+// Jump forward two months
+t.set({ mm: '>2' }); // July 20th
+
+// Jump to the next Friday
+t.set({ wkd: '>Fri' }); // May 24th

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because .set() processes keys in insertion order, you can now effortlessly combine absolute assignments and Slick shifts in a single pass to build complex boundaries:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Jump 2 months forward, find the next Friday, and set the time to 10:30 AM
+const t2 = t.set({ 
+  mm: '>2', 
+  wkd: '>Fri', 
+  hour: 10, 
+  minute: 30 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ ESLint sort-keys Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because mixed object payloads execute strictly in the order they are defined, you must be careful if you use aggressive automated linters (like ESLint's sort-keys auto-fixer). If your linter alphabetically re-orders your properties, your math will execute in the wrong order! If your codebase forces alphabetical object keys, stick to chaining: t.set({ mm: '>2' }).set({ wkd: '>Fri' }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 Why can't I use Slick modifiers on timezones (tz)?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changing a timezone (tz or timeZone) does not traverse the timeline—it merely changes the local representation of the exact same absolute moment in time. Because no temporal displacement occurs, applying directional Slick modifiers (like >) to a timezone is logically invalid and unsupported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chainability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because all mutations return a new instance, you can safely chain .add() and .set() methods together to perform complex temporal logic in a single, readable line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const endOfQ1 = t
+  .set({ year: 'start' })     // Snap to January 1st
+  .add({ months: 3 })         // Shift forward 3 months (to April 1st)
+  .subtract({ days: 1 })      // Step back exactly one day (March 31st)
+  .set({ month: 'end' });     // Snap to March 31st at 23:59:59.999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relational vs. Navigation Shifting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using custom terminology plugins (like Fiscal Quarters or Seasons), Tempo provides two distinct shorthand styles for mutation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Navigation Mode (String) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use a string to jump to a specific boundary. This relies on chronological momentum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set('#qtr.>q1');              // Snaps to the start of the next Q1
+t.add('#timeOfDay.>afternoon'); // Jumps to the start of the next Afternoon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Relational Mode (Object) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use an object to shift by a specific semantic step while preserving your relative position in the cycle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.add({ '#qtr': 1 });           // Shift forward 1 quarter, preserving progress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are 20 days into Q1, relational shifting will put you exactly 20 days into Q2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Learn More: For deeper details on cycle preservation and directional operators, see the Shorthand Engine Reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/2-core-concepts/tempo.parse.html b/packages/tempo/public/v4/doc/2-core-concepts/tempo.parse.html new file mode 100644 index 00000000..34c0ba56 --- /dev/null +++ b/packages/tempo/public/v4/doc/2-core-concepts/tempo.parse.html @@ -0,0 +1,193 @@ + + + + + + Smart Parsing Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Parsing Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's strongest feature is its flexible, natural-language parsing engine. While native Temporal is strictly ISO-only, Tempo can interpret a vast range of human-friendly date and time expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Standalone Parsing (Zero-Overhead) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you only need Tempo's "Smart" parsing but want to keep your project lightweight, you can use the standalone parse function. This returns a native Temporal.ZonedDateTime without importing the full Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parse } from '@magmacomputing/tempo/parse';
+
+// Returns a native Temporal.ZonedDateTime
+const zdt = parse('May 20, 2026 at 3pm', { timeZone: 'Australia/Sydney' });
+
+console.log(zdt.toString()); // 2026-05-20T15:00:00+10:00[Australia/Sydney]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why use Standalone Parse? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tree-Shaking: Your bundler can skip the entire Tempo class and its associated methods, significantly reducing your bundle size.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Native: Perfect for projects that already use native Temporal objects but need a friendlier input layer for users.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict by Default: The standalone function defaults to mode: 'strict', ensuring that it won't "guess" if the input is ambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms and Standalone Parsing: Standalone parse() supports all standard natural language patterns but does not resolve Global Terms or aliases unless they are part of the core pattern registry. For full Term-dispatch and instance-aware resolution, use the Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Standalone vs. Class-Based ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is important to understand the trade-offs when using the lightweight parse() function:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureStandalone parse()new Tempo() Class
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Return TypeNative Temporal.ZonedDateTimeTempo Instance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fluent API❌ Native Temporal methods only✅ .add(), .set(), .format(), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Validation❌ No .isValid property✅ Track success via .isValid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    State❌ One-off (Stateless)✅ Persistent instance configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins❌ Bypasses class-level plugins✅ Full support for .ticker(), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Config❌ Configuration per call only✅ Configure once via Tempo.init()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use Standalone Parse for server-side processing or background tasks where bundle size is the priority. Use the Tempo Class for UI-heavy applications that need advanced formatting and mutation chains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Class-Based Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using the Tempo class, parsing is handled automatically by the constructor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('May 20, 2026');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine can interpret:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Strings: 2024-05-20T10:00:00Z
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Short Dates: 20-May, May 20 (locale-aware)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relative Strings: next Monday, last Friday, 2 days ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Numbers/BigInt: Unix timestamps in milliseconds or nanoseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Temporal Objects: ZonedDateTime, PlainDate, PlainDateTime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical Era Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively supports parsing historical and future dates with era designations such as BC, BCE, AD, and CE. It correctly resolves both trailing (200 BC) and leading (BC 200) formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Era Parsing Assumptions When parsing dates with eras, be aware of the following architectural rules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Implicit Defaults: If no era is explicitly provided in the string, Tempo safely assumes CE (Common Era).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Missing Months/Days: If a historical era string like "200 BC" is parsed without a month or day, Tempo anchors the missing components to January 1st of that astronomical year (i.e., -199-01-01).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calendar Systems: Era parsing and conversion to astronomical years is strictly restricted to the ISO/Gregorian calendar system. This mathematically means 1 BC becomes astronomical year 0, and 200 BC becomes year -199.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📆 Ordinals & Nth Parsing ("3rd Wednesday of October") ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively supports parsing structured ordinal weekday and ordinal date expressions—using both numeric (1st, 2nd, 3rd) and written word ordinals (first, second, tenth, last, current)—in deterministic O(1) time with zero network overhead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Numeric Ordinal Weekdays
+new Tempo('3rd Wednesday of October');        // 3rd Wed in Oct of anchor/current year
+new Tempo('1st Thursday of November 2026');   // 1st Thursday of November 2026
+
+// Written Ordinal Weekdays (backed by Tempo.enums.ORDINAL)
+new Tempo('first Wednesday of October');      // 1st Wed in Oct
+new Tempo('second Friday of November');       // 2nd Fri in Nov
+new Tempo('last Monday of May');              // Last Mon in May
+
+// Ordinal Dates
+new Tempo('15th day of May');                 // 15th day of May
+new Tempo('1st day of 2026');                 // 1st day of 2026
+new Tempo('last day of the month');           // Last day of anchor/current month

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Written ordinals are powered by the extensible Tempo.enums.ORDINAL enum (@magmacomputing/tempo/enums), providing built-in mappings for current (0), first (1) through tenth (10), and last (-1). Custom ordinals can be registered globally via Tempo.init({ registry: { ordinals: { eleventh: 11 } } }) (or Enum.extend(Tempo.enums.ORDINAL, ...)) or per-instance via new Tempo(date, { registry: { ordinals: { eleventh: 11 } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💡 When to use Native Ordinal Parsing vs. @magmacomputing/tempo-plugin-ai (parseAI) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Input Type & ScenarioRecommended ApproachKey Advantage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Structured Expressions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (e.g. "3rd Wednesday of Oct", "1st day of next month")                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		Native Tempo ParsingDeterministic O(1) Speed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero API latency, zero token costs, 100% offline processing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Free-Form / Conversational Text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (e.g. "Schedule a call on the third Wednesday after my trip ends")                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		tempo-plugin-ai (parseAI)LLM Natural Language Reasoning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extracts context and conversational intent before passing dates to Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Always prefer native Tempo parsing for form inputs, search inputs, and predictable UI date controls. Reserve @magmacomputing/tempo-plugin-ai for conversational chat interfaces or unstructured email/document text processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎭 Structured Mask & Wildcard Parsing ({format: '...'}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can parse strictly structured templates with braced tokens and {*} wildcards without crafting custom regexes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Braced structured format masks
+new Tempo('24-10-2026', { format: '{dd}-{mm}-{yyyy}' });
+
+// With non-capturing wildcard {*}
+new Tempo('Recorded on 15 Sep 2026 at server-01', { 
+  format: '{*} on {dd} {mmm} {yyyy} at {*}' 
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Dialects & Migration Tempo's formatting and parsing engine uses consistent lower-case tokens ({yyyy}, {mm}, {dd}) to prevent common pitfalls—such as the subtle year-end shift between calendar year (yyyy) and ISO week-year (YYYY).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are migrating an existing codebase or prefer familiar external formatting standards (such as Luxon, Moment, or POSIX strftime), the @magmacomputing/tempo-plugin-dialects community plugin provides drop-in support:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import '@magmacomputing/tempo-plugin-dialects/install';
+
+// Parse using external masks
+const t = new Tempo('2026-10-24', { format: 'YYYY-MM-DD', dialect: 'moment' });
+
+// Or via the Luxon convenience shim
+const t2 = Tempo.fromFormat('2026-10-24', 'yyyy-MM-dd');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For full token specifications and multi-candidate parsing fallbacks, see the Dialects Plugin Documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔢 Numeric & Epoch Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides robust support for parsing Unix timestamps (Epochs). Unlike standard Date.parse, Tempo can interpret epochs in multiple units and handles both Number and BigInt types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unit Selection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo treats numbers as milliseconds. You can configure this via the timeStamp option:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Default (milliseconds)
+new Tempo(1715900000000).format('{yyyy}-{mm}-{dd}'); // 2024-05-16
+
+// Seconds
+new Tempo(946684800, { timeStamp: 'ss' }).yy; // 2000
+
+// Microseconds / Nanoseconds
+new Tempo(1715900000000000n, { timeStamp: 'us' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Smart Epoch Detection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parsing engine automatically detects shorter numeric strings (9-10 digits) as valid Epoch candidates when a non-default unit (like 'ss') is configured. This ensures that second-based timestamps like 946684800 are correctly interpreted as timestamps rather than being passed to the layout engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fractional Precision ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo supports fractional numeric inputs across all units with nanosecond precision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 1.5 (seconds mode) resolves to 1.5 seconds (1500ms).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 100.25 (milliseconds mode) resolves to 100 milliseconds and 250 microseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modularity: Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parsing engine is modular. Depending on which version of Tempo you are using, you may need to explicitly enable it:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VersionSmart Parsing Status
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo FullBuilt-in. Works out of the box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo CoreOpt-in. You must call Tempo.use(ParseModule) to enable natural language support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabling Smart Parsing in Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using @magmacomputing/tempo/core, the constructor only supports basic ISO strings by default. To enable "next Tuesday" style parsing, you must extend it:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { ParseModule } from '@magmacomputing/tempo/parse';
+
+Tempo.use(ParseModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Internationalization, TimeZone & Locale ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses your configuration to intelligently parse ambiguous dates and foreign languages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TimeZone & Offset Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo natively supports human-readable timezone abbreviations (e.g. AEST, PST, EST, CET, JST) as well as explicit GMT / UTC offset designators (e.g. 'Aug 6, 16:16 GMT+10', 'August 6, 16:16 AEST', 'UTC-5').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Default Layout Positioning & Collisions By default, Tempo's built-in layouts expect timezone offsets and abbreviations to follow the date/time payload. This design prevents leading abbreviations from colliding with 3-letter month names (such as MAR for March vs. Marshall Islands Time).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registering a Custom Leading Timezone Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your application processes custom log files or legacy data streams that position timezone designators at the start (e.g. "PST 8 Aug 10:30"), you can register a custom layout using {tz} alongside {dt} and {tm}. The {tz} token accepts both timezone offset designators (+10:00, Z, GMT+10) and registered timezone abbreviations (such as AEST, PST, EST):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    layouts: {
+      leadingTz: '{tz}{sep}+{dt}{sep}+{tm}'
+    }
+  }
+});
+
+const t = new Tempo('PST 8 Aug 10:30');
+console.log(t.tz); // 'America/Los_Angeles'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    US-Style Dates (MM/DD/YYYY) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you parse a numeric string like 04012026, Tempo uses your timeZone to decide if it means April 1st (US) or 4th of January (UK/AU).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo achieves this by dynamically checking if your current timeZone is associated with a locale that prefers Month-Day ordering (like en-US). It uses the Intl.Locale.prototype.getTimeZones() API where available, and maintains a robust hardcoded fallback list for environments (like Node.js CI or non-ICU environments) where the full Intl API is not present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const us = new Tempo('04012026', { timeZone: 'America/New_York' }); // Apr 1
+const au = new Tempo('04012026', { timeZone: 'Australia/Sydney' }); // Jan 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parsing "Ambiguous" Digits (6 vs 8) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When processing numeric-only strings, the length determines the ambiguity rules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A 6-digit string is always validated as compact time first (hhmiss) regardless of timeZone. Only if time validation fails does Tempo try compact date layouts (ddmmyy or mmddyy).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An 8-digit string is checked as a compact date first, with month-day-year vs day-month-year decided by the active Region/timeZone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To avoid ambiguity completely, prefer separators whenever you control the input format (e.g., 2026-04-01, 04/01/2026, or 01/04/2026).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manual Resolution Override ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want to bypass the timezone detection, you can explicitly force the parser to use Month-Day logic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Force MDY parsing
+const t = new Tempo('04/01/2023', { monthDay: true }); 
+
+// Force DMY parsing
+const t3 = new Tempo('04/01/2023', { monthDay: { active: false } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Customizing the MONTH_DAY Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The global MONTH_DAY registry defines the default rules for detection. You can augment this to support additional custom regions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  monthDay: {
+    locales: ['en-CA'], // Add Canada to the MDY preference list
+    timezones: {
+      'en-CA': ['America/Toronto', 'America/Vancouver']
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalized Parsing (Locales) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo can be instructed to automatically generate language-specific parsing rules based on your locale. This enables parsing of translated months, weekdays, and relative events out-of-the-box!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can provide either a single locale string or an array of locales to parse multiple languages simultaneously:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ locale: ['fr-FR', 'es-ES'] });
+
+// Natively understand French, Spanish, AND English dates!
+new Tempo('15 fevrier 2026');   // parses as "15 February 2026" (French)
+new Tempo('15 febrero 2026');   // parses as "15 February 2026" (Spanish)
+new Tempo('vendredi');          // parses as the closest "Friday"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cross-Locale Collisions: In a multi-lingual lexer, if two languages share the exact same abbreviation/word for different dates (e.g. if "mai" meant May in French but March in another language), the parser will resolve a collision using "Last-One-Wins" logic based on your array order. The language that appears last in the locale array takes priority. Be deliberate in your array ordering to safely prioritize your primary language fallback!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works & Accent Normalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When non-English locales are provided, Tempo automatically uses the native Intl API to pre-generate lists of Months, Weekdays, and Relative terms ("yesterday", "today", "tomorrow").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It also automatically normalizes and strips accents from these generated rules. This means that if a user types fevrier (without the accent), it will still successfully fuzzy-match against the strictly translated février.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Current Limitations (What is NOT Available) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Intl provides a robust foundation for month and weekday translations, there are limits to auto-localization:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Units: Words representing duration units ("days", "weeks", "months", "hours") inside natural language strings are currently English-only.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Grammar Structure: The parser expects sequences matching standard English formats (e.g., [value] [unit] [affix]). Highly inflected languages or completely different phrase structures might fail to parse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To bridge these gaps, you can register Custom Aliases (see below) or define custom localized keywords in registry.modifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Localized Parsing Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo allows you to localize term modifiers (like next, last, this) by defining them in the registry.modifiers configuration. This lets you seamlessly mix localized terms into your relative string parsing and even use them in the # shorthand navigation engine!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',                // Natively translates months & weekdays
+  registry: {
+    modifiers: {
+      '>': ['prochain', 'suivant'],
+      '<': ['dernier', 'passé'],
+      '=': ['ce', 'cette']
+    }
+  }
+});
+
+new Tempo('next Friday');         // English always works natively
+new Tempo('vendredi prochain');   // Pure French localized string!
+new Tempo('#qtr.dernier');        // Localized shorthand navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Aliases (Events & Periods) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can teach the parser new words or entire foreign phrases to bridge translation gaps:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',
+  registry: {
+    events: {
+      // Map a full foreign phrase directly to an English-equivalent relative string
+      'le lendemain': 'tomorrow',
+      // Or standard static events
+      'launch': '2026-12-01',
+      'party': () => 'next Friday 8pm'
+    }
+  }
+});
+
+const t1 = new Tempo('le lendemain'); // Parses accurately to tomorrow
+const t2 = new Tempo('party');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧠 Functional Alias Context ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Functional Alias Context is a powerful API for creating dynamic, self-referential date definitions. Within an alias function, this provides access to the AliasContext instance:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.set(input): Reset the context to a specific date/time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.add(duration): Add a Temporal-style duration (e.g. 'P1D').
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.toNow(): Align context with current system time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.zdt (or this.toDateTime()): Resolve the context to a Temporal.ZonedDateTime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.yy / this.mm / this.dd: Access current date components.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.hh / this.mi / this.ss: Access current time components.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • this.tz / this.cal / this.locale / this.sphere / this.config: Access instance metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example: Dynamic 'meeting' alias
+'meeting': function() {
+    return this.set('2026-05-20').add({ hours: 1 }); // Resolves to 2026-05-20T01:00:00
+},
+'bedtime': function() {
+    return this.set('22:00').zdt; // or .toDateTime()
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: Complex Functional Alias ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    events: {
+      // Resolve "bedtime" to 10pm on the same day
+      'bedtime': function() {
+        return this.set({ hour: 22, minute: 0, second: 0 });
+      },
+      // Resolve "meeting" to 2 hours after whatever was just parsed
+      'meeting': function() {
+        return this.add({ hours: 2 });
+      }
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📍 Geographic Context & Coordinates (geo Option) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When constructing a Tempo instance or calling parse(), you can supply a geo object directly in the options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-24 15:30', {
+  geo: {
+    lat: -33.8688,
+    lng: 151.2093,
+    city: 'Sydney',
+    country: 'Australia'
+  }
+});
+
+console.log(t.geo?.latitude);  // -33.869 (rounded to 3 decimals)
+console.log(t.geo?.longitude); // 151.209
+console.log(t.sphere);         // 'south'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Normalization & Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo applies strict validation and standardization to all incoming coordinate payloads with zero external network dependencies:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Boundary Validation: Coordinates outside physical Earth limits (-90° ≤ lat ≤ 90°, -180° ≤ lng ≤ 180°) are strictly rejected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3-Decimal Precision: Coordinates are rounded deterministically to 3 decimal places (≈ 111 m resolution at the equator), eliminating sensor noise and storage cache fragmentation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic Hemisphere Inference: The hemisphere ('north', 'south', or 'equator') is automatically deduced from latitude, recognizing the ±0.001° equatorial band.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Access: Normalized geographic metadata is accessible on the instance via t.geo (recursively frozen GeoConfig) and t.sphere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Performance: The Master Guard ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a "Scan-and-Consume" engine called the Master Guard. This allows it to check your input string against dozens of patterns (weekdays, months, custom events) in a single pass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In version 2.9.0, the Master Guard has been optimized with a Versioned Registry. The engine now tracks a #version counter on the alias registry, ensuring that the guard's pattern list is only rebuilt when a mutation actually occurs. This provides near-instant validation for high-volume parsing tasks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/ecosystem.html b/packages/tempo/public/v4/doc/3-extending-tempo/ecosystem.html new file mode 100644 index 00000000..6a1564d8 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/ecosystem.html @@ -0,0 +1,69 @@ + + + + + + Plugin Ecosystem | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's functionality can be easily extended through community plugins. Because of Tempo's unique core architecture, plugins add exactly 0 bytes to the bundle size of developers who do not use them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browse the live catalog below to discover extensions for scheduling, calendar math, astronomical events, and more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Community Plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Free, open-source extensions under the MIT license organized by functional domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌍 Geolocation & Regional Calendars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hardware GPS / IP geolocation resolution, cultural calendars, bank holidays, and SLA business day arithmetic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Geo Pluginv1.4.2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin for IP geolocation lookup, browser hardware location services, and coordinate resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Holidays Pluginv1.0.2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regional bank holiday, public holiday, and business day SLA scheduling plugin for Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Spatial Pluginv1.0.1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin for GIS spatial geometry, Great-Circle navigation, transit velocity, and impossible travel anomaly detection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ☀️ Celestial & Astronomical Science

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemisphere-aware solar events, lunar phase tracking, solstices, and twilight boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Celestial Pluginv1.3.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo plugin to add Terms for location-aware solar twilight events, lunar phase tracking, and astronomical seasons / tidal mechanics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & Natural Language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LLM-powered natural language date parsing, narrative formatting, and recurrence rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AI Pluginv2.3.2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin for LLM-powered natural language parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💼 Business, Finance & UI Utilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fiscal calendars, financial namespaces, and precision block-snapping for UI controls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Finance Pluginv1.1.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Community Plugin: Finance namespace and fiscal year utilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snap Pluginv1.4.2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo plugin for rounding and snapping dates to custom minute, hour, or sub-second intervals — ideal for calendar UIs, time-pickers, and telemetry aggregation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ High Performance & System Execution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lock-free thread synchronization, continuous execution loops, and SAB multi-threading.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Batch Pluginv1.2.1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin bringing C-level parallelization to massive date arrays via SharedArrayBuffer and Worker Threads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sync Pluginv1.1.2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo community plugin providing lock-free, highly precise cross-thread synchronization via SharedArrayBuffer and Atomics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker Pluginv2.6.1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo plugin that provides a high-performance continuous execution loop (Ticker) based on temporal mathematics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ntp Pluginv1.0.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo plugin providing client-server network time synchronization and monotonic clock drift compensation using Cristian's algorithm and HTTP Server-Timing headers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗣️ Formats & Dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format dialects for Unicode LDML/Luxon, Moment.js, and POSIX strftime compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dialects Pluginv1.1.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Community Plugin: Format dialects for Unicode LDML/Luxon, Moment, POSIX strftime, and Oracle/SQL TO_CHAR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Submit Your Own Plugin!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Have you built something amazing for Tempo? We want to see it!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can have your own packages listed in this live catalog. Simply build your extension using definePlugin() or defineTerm() and publish it to NPM with the "tempo-plugin" keyword. Open an Issue on our GitHub repository with a link to your package, and we'll review it for inclusion in the global registry!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.extension.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.extension.html new file mode 100644 index 00000000..ecc1f887 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.extension.html @@ -0,0 +1,143 @@ + + + + + + Creating a Custom Plugin | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creating a Custom Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Term Plugins are excellent for providing static, memoized data (like astrological signs or fiscal quarters), a general Plugin allows you to fundamentally enhance the Tempo class with entirely new methods and behaviors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide will teach you the "Tempo-way" of authoring a custom plugin by building a classic, real-world example: The Business Days Plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adding a group of properties?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building a plugin that adds multiple related properties or methods (like .finance.taxYear and .finance.fiscalQuarter), you should use the defineNamespace factory instead! It automatically lazy-loads your methods and prevents prototype pollution. 👉 Read the Namespace Guide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Goal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We want to add an .addBusinessDays() method to the Tempo instance that adds or subtracts a specific number of working days (defaulting to 1), skipping weekends automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-05-22'); // Friday
+console.log(t.addBusinessDays(2).format('{www}')); // Output: 'Tue'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The definePlugin Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The safest and most efficient way to author a plugin is using the definePlugin factory. This handles the internal registration automatically.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // src/index.ts
+import { definePlugin, type TempoPlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+export const BusinessDaysPlugin: TempoPlugin = definePlugin({
+  name: 'BusinessDaysPlugin',
+  install(TempoClass) {
+    // Plugin implementation goes here!
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Extending the Prototype ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add an instance method, you extend the TempoClass.prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability is King

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is strictly immutable. When authoring an instance method that modifies the date, never mutate this. Instead, use the core methods (like this.add or this.set) which automatically generate and return a fresh, isolated clone for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's implement our .addBusinessDays() logic:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const BusinessDaysPlugin: TempoPlugin = definePlugin({
+  name: 'BusinessDaysPlugin',
+  install(TempoClass) {
+    TempoClass.prototype.addBusinessDays = function(days: number = 1) {
+      let next = this;
+      const direction = days >= 0 ? 1 : -1;
+      let remaining = Math.abs(days);
+      
+      // Loop using the underlying Temporal API data
+      // dayOfWeek: 1 = Monday ... 7 = Sunday
+      while (remaining > 0) {
+        next = next.add({ days: direction });
+        
+        // Only count Monday-Friday as a valid jump
+        if (next.dow <= TempoClass.WEEKDAY.Fri) {
+          remaining--;
+        }
+      }
+      
+      // Return the new clone! (Tempo's native .add() already guarantees a fresh instance)
+      return next;
+    };
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Notice how we used the next.dow getter to easily read the Day Of Week? Tempo instances have many lightweight getters (like .yy, .mm, .dd, .hh) built-in.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    However, if you ever need to calculate advanced calendar math (like dayOfYear, daysInMonth, or weeksInYear), you can drop into this.zdt (or this.toDateTime()) to access the raw, underlying Temporal.ZonedDateTime object with zero method call ceremony.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. TypeScript Module Augmentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using TypeScript (highly recommended), your IDE will not know about .addBusinessDays() until you augment the Tempo interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You must declare this augmentation in the same file that exports your plugin:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // src/index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+// ... (plugin implementation) ...
+
+// Inform TypeScript that the core Tempo class now has this method
+declare module '@magmacomputing/tempo/core' {
+  interface Tempo {
+    addBusinessDays(days?: number): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Packing it as a Configurable Module ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes, you want your plugin to accept options (e.g., passing in a custom array of public holidays to skip). To do this, wrap your definePlugin call in a standard factory function:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export type BusinessDayOptions = {
+  skipHolidays?: boolean;
+};
+
+export const BusinessDaysPlugin = (pluginOptions: BusinessDayOptions = {}): TempoPlugin => {
+  return definePlugin({
+    name: 'BusinessDaysPlugin',
+    install(TempoClass) {
+      TempoClass.prototype.addBusinessDays = function(days: number = 1) {
+        let next = this;
+        const direction = days >= 0 ? 1 : -1;
+        let remaining = Math.abs(days);
+        
+        while (remaining > 0) {
+          next = next.add({ days: direction });
+          if (next.dow <= TempoClass.WEEKDAY.Fri) {
+            // We can now use 'pluginOptions' in our logic!
+            if (!pluginOptions.skipHolidays /* || !isHoliday(next) */) {
+               remaining--;
+            }
+          }
+        }
+        
+        return next;
+      };
+    }
+  });
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consuming the Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Your users can now import and register your plugin elegantly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { BusinessDaysPlugin } from 'my-business-days-plugin';
+
+Tempo.use(BusinessDaysPlugin({ skipHolidays: true }));
+
+const t = new Tempo();
+const nextBiz = t.addBusinessDays(2);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need something more complex?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you need to build advanced scheduling engines, AsyncGenerators, or precision arithmetic tools that you plan to distribute commercially, check out our Plugin Ecosystem ↗ for inspiration, or contact Magma Computing Solutions for professional plugin development.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.layout.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.layout.html new file mode 100644 index 00000000..5362a454 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.layout.html @@ -0,0 +1,87 @@ + + + + + + Layout Patterns Guide | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layout Patterns Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's parsing engine is driven by regular expression patterns and named capture-groups. By understanding and extending these layouts, you can teach Tempo to understand entirely new terminology, formats, and relative units.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What is a Snippet? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Snippet is a pre-defined regex pattern that can be combined with other snippets to create a Layout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What is a Layout? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Layout is a string that combines pre-defined Snippets and strings. When you provide a layout to Tempo, it is translated into an anchored, case-insensitive Regular Expression used to match and extract date-time values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Snippets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Snippets represent specific date or time units. When arranged in a layout, they form the blueprint for the parser:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SnippetDescriptionRegex Match (approx)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {yy}Year (2 or 4 digits)([0-9]{2})?[0-9]{2}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mm}Month (01-12, Jan-Dec, etc.)01-12 or names
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {dd}Day (01-31)01-31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {hh}Hour (00-24)00-24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mi}Minute (prefixed by :):[0-5][0-9]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ss}Second (prefixed by :):[0-5][0-9]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {ff}Fraction (prefixed by .)\.[0-9]{1,9}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {wkd}Weekday (Mon-Sun)Name strings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {era}Historical era markerBC, a.d., c.e., etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {tz}Time zone designatorZ, ±hh:mm, GMT+10, or abbreviation (AEST, PST)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {sep}Separator character/, -, ., ,, or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {mod}Modifier and count+, -, next, prev
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {unt}Time unitsyear(s), day(s), etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {evt}Event aliasxmas, nye, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {per}Period aliasmidnight, noon, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {sfx}Time-pattern suffixT {tm} Z
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {brk}Zone/Calendar brackets[UTC][u-ca=iso8601]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {www}Short weekday nameMon, Tue, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {nbr}Numeric value or word1, two, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {afx}Relative affixago, hence, from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Composite Snippets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dt}: Matches a date (e.g., {dd}{sep}{mm}) OR an event alias {evt}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {tm}: Matches a time (e.g., {hh}{mi}) OR a period alias {per}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Built-in Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeyLayoutDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dtm({dt}){sfx}?{brk}?Calendar/event and clock/period
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dmy{www}?{dd}{sep}?{mm}({sep}{yy})?{sfx}?{brk}?Day-month(-year)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mdy{www}?{mm}{sep}?{dd}({sep}{yy})?{sfx}?{brk}?Month-day(-year)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ymd{www}?{yy}{sep}?{mm}({sep}{dd})?{sfx}?{brk}?Year-month(-day)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ye{mod}?{yy}{era}Explicit year and era (e.g., 200 BC)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ey{mod}?{era}{sep}?{yy}Explicit leading era and year (e.g., BC 200)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unt{nbr}{sep}?{unt}{sep}?{afx}Relative duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Customizing Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can supply your own parsing tokens to Tempo globally via Tempo.init() or locally per-instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  registry: {
+    layouts: {
+      'myCustomFormat': '{dd}{sep}?{mm}{sep}?{yy}'
+    }
+  }
+});
+
+const t = new Tempo('20-05-2024'); // Parsed using 'myCustomFormat'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Escaping Regex Meta-Characters in Custom Delimiters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Layout strings are compiled directly into regular expressions by the Tempo engine. If your custom layout uses non-standard separators that are regex meta-characters (such as *, |, +, ?, ., ^, $), you must escape them in layout strings (e.g., \\*, \\|) or pass a pre-compiled RegExp object with escaped delimiters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ Incorrect: '*' is interpreted as a regex quantifier
+Tempo.init({ registry: { layouts: { starDate: '{mm}*{dd}*{yy}' } } });
+
+// ✅ Correct: escape meta-characters in layout strings
+Tempo.init({ registry: { layouts: { starDate: '{mm}\\*{dd}\\*{yy}' } } });
+
+// ✅ Correct: using RegExp with escaped delimiters
+Tempo.init({ registry: { layouts: { starDate: /(?<mm>\d{2})\*(?<dd>\d{2})\*(?<yy>\d{4})/ } } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance-Specific Layout ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('20240520', { registry: { layouts: '{yy}{mm}{dd}' } });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced Capture Groups ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When crafting raw regex, the following capture groups are used by the engine:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • yy, mm, dd: Year, Month, Day digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hh, mi, ss, ff: Hour, Minute, Second, Fractional digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mer: Meridiem (am, pm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evt: Event string offset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • per: Period string offset
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • unt: Relative unit (e.g., days, weeks)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Prototyping with Tempo.regexp() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can use the static Tempo.regexp() method to "preview" how a layout string will be compiled by the engine. This is useful for testing custom regex logic before applying it to your configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Expands {dd}, {sep}, {mm}, etc. into a final anchored RegExp
+const regex = Tempo.regexp('{dd}{sep}{mm}{sep}{yy}');
+
+console.log(regex.source); 
+// Output (illustrative): ^((?<dd>...)(?<sep>...)(?<mm>...)(?<sep_1>...)(?<yy>...))$

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖 AI & LLM Layout Prompting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When prompting AI assistants (Cursor, GitHub Copilot, ChatGPT, Claude) to write custom Tempo regular expression snippets and layout extensions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ingest AI Rules: Provide the assistant with our official llms.txt rules by referencing @https://tempo.magmacomputing.com.au/llms.txt in Cursor or pasting llms.txt context into ChatGPT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit Token Request: Ask the LLM to use Tempo's standard snippet tokens ({yy}, {mm}, {dd}, {hh}, {mi}, {ss}, {tz}) rather than raw, un-anchored regular expressions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Example AI Prompt:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "Using https://tempo.magmacomputing.com.au/llms.txt, register a custom layout for strings like '20-05-2024' using Tempo.init({ registry: { layouts: { ... } } }) and snippet tokens."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Professional Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your project involves specialized terminology, complex financial calendars, or legacy application log formats, the Magma Computing Solutions team offers professional services to design and test custom Tempo Layouts optimized for your business needs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Contact us at Magma Computing Solutions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.modularity.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.modularity.html new file mode 100644 index 00000000..fb1aaada --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.modularity.html @@ -0,0 +1,104 @@ + + + + + + Tempo Modularity | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Modularity ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed as a modular library, allowing you to include only the features you need. This reduces the core bundle size and prevents your application from being polluted with unused functionality.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Module Activation Quick Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are using module entry points, use this rule of thumb:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. import '@magmacomputing/tempo/<module>' (side-effect import): auto-registers that module. You usually do not need Tempo.use(...) for the same module.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. import { SomeModule } from '@magmacomputing/tempo/<module>' (named import): requires explicit activation via Tempo.use(SomeModule).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Tempo.init() is primarily for baseline configuration and initial discovery. Call it at startup for config; if you load modules later at runtime, use Tempo.use(...) for deterministic activation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Import order is usually only relevant when modules are loaded dynamically/lazily. For deterministic activation in those cases, prefer explicit Tempo.use(...) immediately after import.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Core vs. Full ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo/core: The bare-bones Tempo engine. Includes parsing (standard ISO string or a native Temporal object), basic getters, and internal state management.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo: The "batteries included" version. Includes all standard modules (Duration, Format, Term Registry, Mutate, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { DurationModule } from '@magmacomputing/tempo/duration';
+import { FormatModule } from '@magmacomputing/tempo/format';
+import { MutateModule } from '@magmacomputing/tempo/mutate';
+import { ParseModule } from '@magmacomputing/tempo/parse';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+
+// Individual extension...
+Tempo.use(DurationModule);
+
+// ...or bulk extension!
+Tempo.use(DurationModule, FormatModule, TermsModule, MutateModule, ...);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available Modules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Duration Module (@magmacomputing/tempo/duration) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for .until() and .since() instance methods, as well as the static Tempo.duration() factory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Module (@magmacomputing/tempo/format) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for the .format() method and custom layout resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mutate Module (@magmacomputing/tempo/mutate) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for the .add(), .subtract(), and .set() instance methods, enabling time manipulation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parse Module (@magmacomputing/tempo/parse) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Handles string parsing and token extraction. This is included automatically in the full package, but must be explicitly opted-in when using core.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms Module (@magmacomputing/tempo/term) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Adds support for semantic Terms like quarter, season, zodiac, and period. There are three ways to enable Terms:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Side-Effect (Standard Activation) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fastest way to enable all standard Terms in a Core environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/term'; // One-line activation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Explicit Module (Uniform Sync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Recommended for consistency with other modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+Tempo.use(TermsModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. The Surgical Strike (Data-Only) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for maximum bundle-size optimization by picking only what you need. Note that specific standard terms have their own dedicated sub-paths natively bundled within the main package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { QuarterTerm } from '@magmacomputing/tempo/term/quarter';
+
+Tempo.use(QuarterTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Custom Modules ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can create your own modules to extend Tempo's internal engine or its public API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineModule } from '@magmacomputing/tempo/plugin';
+
+export const MyModule = defineModule((TempoClass, options) => {
+    // Add instance methods
+    TempoClass.prototype.sayHello = function() { return 'Hello!'; };
+    
+    // Add static methods
+    (TempoClass as any).greet = () => 'Greetings!';
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure TypeScript recognizes your new methods without throwing augmentation errors (such as TS2669), you must properly declare the module augmentation in a .d.ts file alongside an explicit import:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // my-module.d.ts
+import '@magmacomputing/tempo';
+
+declare module '@magmacomputing/tempo' {
+    interface Tempo {
+        sayHello(): string;
+    }
+    namespace Tempo {
+        export function greet(): string;
+    }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dual Module Hazard: If you are using @magmacomputing/tempo/core and @magmacomputing/tempo in the same project, ensure you use the development condition or consistent import paths to avoid registering the same classes twice.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ The Registration "Gotcha" ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    There is a subtle but important distinction between how features are activated in Core mode:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use(Module): This is Immediate and Explicit. It applies the module or plugin to the class exactly when the line is executed. This is the recommended pattern for modular applications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init(): Establishes global baseline configuration at application startup and registers plugins specified in the plugins array during initial startup discovery.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ::: note Startup Initialization Lifecycle: Tempo.init() establishes baseline configuration during application startup. Built-in plugins are registered automatically via static imports in full Tempo (@magmacomputing/tempo), while explicit plugin lists are registered during Tempo.init({ plugins: [...] }). Note that subsequent calls to Tempo.init() re-evaluate and merge configuration options rather than executing as an idempotent no-op. To register additional plugins dynamically after startup, use Tempo.use(...). :::

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.namespace.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.namespace.html new file mode 100644 index 00000000..11cc75de --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.namespace.html @@ -0,0 +1,166 @@ + + + + + + Creating a Namespace Plugin | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creating a Namespace Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building plugins that provide multiple related features, adding them directly to the Tempo prototype can clutter the root interface and increase the risk of naming collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To solve this, Tempo provides the defineNamespace factory. This allows you to mount an entire suite of related tools under a single property (e.g., Tempo().finance.taxYear).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Lazy-Evaluation Advantage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespaces in Tempo are Lazy-Evaluated Proxies. When a user extends Tempo with your namespace plugin, it adds exactly 0 CPU cycles of overhead to instantiation. Your methods and resolvers are only initialized and executed if the user actually accesses the namespace property on that specific date instance!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The defineNamespace Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's build a finance plugin. We want to add a .finance namespace that provides tools like fiscalQuarter and isFiscalYearStart().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // finance.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+import type { Tempo } from '@magmacomputing/tempo/core';
+
+export const FinanceNamespace = defineNamespace({
+  // 1. Define the property name where this namespace will live on the Tempo instance
+  name: 'finance',
+  
+  // 2. Define the lazy-resolvers
+  resolvers: {
+    // Static properties return values directly
+    fiscalQuarter: (tempo: Tempo): number => {
+      const month = tempo.mm;
+      return Math.floor((month - 1) / 3) + 1;
+    },
+    
+    taxYear: (tempo: Tempo): number => {
+      return tempo.yy;
+    },
+    
+    // Methods return callable functions
+    isFiscalYearStart: (tempo: Tempo): ((startMonth?: number) => boolean) => {
+      const currentMonth = tempo.mm;
+      const currentDay = tempo.dd;
+      return (startMonth: number = 1) => currentMonth === startMonth && currentDay === 1;
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Notice how every resolver receives the current Tempo instance as its first argument? This gives you full access to the date's underlying data (tempo.mm, tempo.add(), etc.) without ever needing to worry about this binding!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Memoized Closure Pattern (Methods with Parameters) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the most powerful features of the defineNamespace architecture is that your resolvers are memoized closures. Because a resolver is only evaluated the very first time the property is accessed on that specific Tempo instance, you can use the outer block to execute expensive setup logic or stash variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Let's zoom in on the isFiscalYearStart method we defined above:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFiscalYearStart: (tempo: Tempo) => {
+  // 1. SETUP BLOCK (Runs exactly once per Tempo instance)
+  // You can stash variables, run complex mathematical lookups, or build state here!
+  const currentMonth = tempo.mm;
+  const currentDay = tempo.dd;
+
+  // 2. INNER CLOSURE (Runs every time the consumer calls the method)
+  // The consumer can pass their company's fiscal start month (e.g., 7 for July). Defaults to 1.
+  return (startMonth: number = 1): boolean => {
+    return currentMonth === startMonth && currentDay === 1;
+  };
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a consumer types t.finance.isFiscalYearStart(7), they are executing that returned inner function to check if the date is July 1st. This pattern allows you to write incredibly performant plugins with zero repeated overhead!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. TypeScript Module Augmentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Just like standard plugins, you must inform TypeScript about your new namespace so developers get full IDE autocomplete:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // finance.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+
+// ... (FinanceNamespace implementation) ...
+
+declare module '@magmacomputing/tempo/core' {
+  interface Tempo {
+    finance: {
+      fiscalQuarter: number;
+      taxYear: number;
+      isFiscalYearStart: (startMonth?: number) => boolean;
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Consuming the Namespace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Developers can now import your plugin, register it once, and enjoy your clean, isolated API!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { FinanceNamespace } from './finance.js';
+
+// Extend the core Tempo engine
+Tempo.use(FinanceNamespace);
+
+const t = new Tempo('2024-07-01');
+
+// Access the static property (Evaluated instantly and memoized!)
+console.log(t.finance.fiscalQuarter); // 3
+
+// Access the callable method (Checking if it's the start of the Australian fiscal year)
+console.log(t.finance.isFiscalYearStart(7)); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Dual Architecture (OOP vs FP) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building a Namespace plugin, you'll naturally face a choice between Object-Oriented Programming (OOP) and Functional Programming (FP).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Namespace (OOP): t.finance.isFiscalYearStart()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pros: Incredible Developer Experience (DX). You get instant IDE autocomplete, and the Tempo object automatically carries your timezone and locale context.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Cons: Extending Tempo means the entire namespace is attached to the prototype. It is not fully tree-shakeable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Functional Approach (FP): isFiscalYearStart(t)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pros: 100% tree-shakeable. Developers only import exactly the functions they need. Zero prototype pollution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Cons: Less discoverable. Developers must pass the Tempo object as the first argument manually.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Best of Both Worlds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A world-class plugin doesn't force developers to choose—it provides both! You can write all your logic as pure functions first, and then use defineNamespace to wrap those functions for OOP users.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. The Pure Functions (The FP layer)
+export function isFiscalYearStart(t: Tempo, startMonth: number = 1): boolean {
+    return t.mm === startMonth && t.dd === 1; 
+}
+export function nextTaxYear(t: Tempo): Tempo { ... }
+
+// 2. The Namespace Wrapper (The OOP layer)
+export const FinanceNamespace = defineNamespace({
+    name: 'finance',
+    resolvers: {
+        // We simply wrap our pure functions and inject the 'tempo' context!
+        isFiscalYearStart: (tempo: Tempo) => (startMonth?: number) => isFiscalYearStart(tempo, startMonth),
+        nextTaxYear: (tempo: Tempo) => () => nextTaxYear(tempo)
+    }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because of this interleaving, developers can choose their preferred architecture based on their project needs (e.g. rapid prototyping with t.finance.x vs. strict bundle optimization with isFiscalYearStart(t)).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Advanced: Symbol Namespaces ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are building a highly-specialized internal plugin and want to mathematically guarantee zero naming collisions, you can use a Symbol as your namespace key!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // secret.ts
+import { defineNamespace } from '@magmacomputing/tempo/plugin/sdk';
+import type { Tempo } from '@magmacomputing/tempo/core';
+
+export const InternalTools = Symbol('internal');
+
+export const SecretPlugin = defineNamespace({
+  name: InternalTools,
+  resolvers: {
+    audit: (tempo: Tempo) => () => console.log(`Audited: ${tempo.format('{yyyy}-{mm}-{dd}')}`)
+  }
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Consumer's code
+import { Tempo } from '@magmacomputing/tempo/core';
+import { FormatModule } from '@magmacomputing/tempo/format';
+// The consumer must import BOTH the Plugin (to extend Tempo) and the Symbol (to access the namespace)
+import { SecretPlugin, InternalTools } from './secret.js';
+
+// Register both modules so tempo.format() is available for the audit method
+Tempo.use(FormatModule, SecretPlugin);
+
+const t = new Tempo();
+t[InternalTools].audit();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbol Tagging Requirement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo enforces a strict tagging policy for security and discovery. If you pass an undescribed Symbol (e.g., Symbol()) as a namespace, the factory will throw a TempoError. You must provide a description (e.g., Symbol('myPlugin')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbol Discovery in the Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a developer calls Tempo.versions to view the loaded plugins, Tempo intelligently translates your Symbol namespaces into standard representations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Local Symbols (e.g., Symbol('internal')) are reported as @internalNamespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Symbols (e.g., Symbol.for('system')) are reported as @@systemNamespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.plugin.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.plugin.html new file mode 100644 index 00000000..7a025163 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.plugin.html @@ -0,0 +1,185 @@ + + + + + + Extending Tempo with Plugins | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extending Tempo with Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed with a "lean core" philosophy. While it provides robust date-time manipulation and parsing out of the box, advanced functionality (like reactive Tickers or domain-specific business logic) is added through a flexible Plugin System.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In the Tempo ecosystem, a Plugin is the universal overarching term for any feature added to the core library. To make authoring plugins easy and consistent, Tempo provides two specialized factory functions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. definePlugin: The standard factory for general-purpose features (e.g., adding prototype instance methods, static tools, or altering configuration).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. defineTerm: A specialized factory exclusively for defining temporal vocabulary constraints (a "Term" is technically just a highly-opinionated "Plugin" focused on date ranges and schedules).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. defineNamespace: A factory for creating lazily-evaluated property landing pads (e.g., Tempo().finance.taxYear).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Naming Convention Standard ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To provide a consistent and intuitive developer experience, the exported symbol of your plugin should use a suffix that directly matches the factory used to construct it. This makes it instantly obvious to consumers how the extension will attach to the Tempo core:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with definePlugin ➡️ [Name]Plugin (e.g., TickerPlugin)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with defineTerm ➡️ [Name]Term (e.g., FiscalTerm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Built with defineNamespace ➡️ [Name]Namespace (e.g., FinanceNamespace)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (Note: The Module suffix and defineModule factory are strictly reserved for Tempo's core internal injection APIs like ParseModule and should not be used by external plugins.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To register a plugin, choose between explicit registration (Tempo.use) or zero-boilerplate side-effect imports (/install):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Explicit registration (Recommended for production apps & tree-shaking)
+import { Tempo } from '@magmacomputing/tempo/core';
+import { MyPlugin } from './my-plugin.js';
+import { HolidayPlugin } from './my-holiday-plugin.js';
+
+Tempo.use(MyPlugin);
+Tempo.use(HolidayPlugin({ region: 'US-NY' }));
+
+// 2. Zero-boilerplate side-effect registration (Recommended for scripts & REPLs)
+import '@magmacomputing/tempo-plugin-geo/install';
+import '@magmacomputing/tempo-plugin-ai/install';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Creating a Custom Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a dedicated step-by-step guide for developers wishing to author their own general-purpose plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the Custom Plugin Guide (tempo.extension.md) to learn how to:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use the definePlugin factory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Safely extend the TempoClass.prototype
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build a full BusinessDaysPlugin from scratch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Safety (TypeScript) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure your plugin is discoverable by the IDE, use Module Augmentation to extend the Tempo namespace and the Tempo class interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    declare module '@magmacomputing/tempo/core' {
+  namespace Tempo {
+    // 1. Define new types/interfaces here
+    interface HolidayOptions { ... }
+
+    // 2. Add static methods to the Tempo namespace
+    function myStaticMethod(): void;
+  }
+
+  interface Tempo {
+    // 3. Add instance methods to the Tempo class
+    toHoliday(): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Understanding Tempo Versions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo/core (Lite): A bare-bones engine with zero side-effects. This is the recommended choice for production builds and plugin authoring.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • @magmacomputing/tempo (Full): The "Batteries Included" version which automatically imports and registers all standard modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Avoid Circular Dependencies: When authoring a plugin, never import the Tempo class directly from the Full version (@magmacomputing/tempo). Doing so triggers the library's automatic registration sequence in a recursive loop, which will break your application's initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Use types: import type { Tempo } from '@magmacomputing/tempo/core'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Use the argument: Rely on the TempoClass argument passed into your plugin function for static method access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Use the engine: If you need a class reference (e.g., for instanceof checks), import only from the Lite engine (@magmacomputing/tempo/core).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modern Tempo plugins are designed to be "plug-and-play." By using the definePlugin factory, a plugin registers itself with the global Tempo registry as soon as it's imported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';   // 1. Load the `lite` engine
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker'; // 2. Import the plugin
+
+Tempo.init({ 
+  plugins: [TickerPlugin]                             // 3. Register and activate plugin during init
+});
+
+// Ticker is now available on the core Tempo class!
+const pulse = Tempo.ticker(1);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dynamic Extension vs Startup Registration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({ plugins: [...] }) establishes baseline configuration at startup and performs initial registration of plugins. In full Tempo (@magmacomputing/tempo), standard plugins are registered automatically upon import. To dynamically register custom plugins loaded later at runtime, use Tempo.use(Plugin) directly rather than re-running Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Selective Immobility ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core methods of Tempo (like add, set, format) are protected. The use() system will prevent you from accidentally overwriting these essential behaviors. By standardizing plugins through the Tempo module system, the entire library remains small and fast, while offering unbounded domain-specific customization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Immutability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When adding instance methods that "modify" the date, always follow the Tempo pattern of returning a new instance. Do not mutate this. Rely on the core methods (like this.add()) inside your plugin, as they automatically guarantee a fresh, cloned instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Namespace Respect ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin provides many related methods, consider grouping them under a single namespace property on the instance (e.g., tempo.holiday.isPublic() rather than tempo.isPublicHoliday()). This keeps the root Tempo interface clean and minimizes the risk of naming collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of manually building these namespaces on the prototype, Tempo provides the defineNamespace factory to automate lazy-evaluation. 👉 Read the Namespace Guide to learn more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Error Handling & The Diagnostic Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building plugins that perform complex parsing or logic, follow Tempo's "Fail-fast by Default" principle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Mode (Default): If your plugin encounters a terminal error (e.g., invalid input that cannot be recovered), you should throw a descriptive error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Catch Mode: Respect the user's catch configuration. If this.config.catch is true, instead of throwing, you should log a warning using this.warn() and return a sensible fallback (or the original input).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Dependencies: You are responsible for managing missing configuration keys that your plugin depends on. The core engine will not validate your plugin's specific requirements. If a required config key is missing (e.g., sphere for a Season plugin), either provide a reasonable default fallback value or warn the user explicitly using this.warn(). Do not make assumptions that lead to silent failures.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example within a plugin instance method
+if (errorCondition) {
+  const msg = `Custom Error: ${details}`;
+  if (this.config.catch === true) {
+    this.warn(msg);
+    return this; // or a fallback value
+  }
+  throw new Error(msg);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This pattern ensures that Tempo remains robust in production environments while providing strict validation during development.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Unified Logging Hooks (logWarn, logError, logDebug) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins should avoid invoking raw console.warn, console.error, or console.log directly. Instead, import and use the standard logging hooks exported by @magmacomputing/tempo/plugin/sdk:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { logWarn, logError, logDebug } from '@magmacomputing/tempo/plugin/sdk';
+
+// Log operational warnings or errors while passing instance config
+logWarn("MyPlugin: Missing optional coordinate parameters.", this?.config);
+logError(err, this?.config);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Passing the instance configuration allows Tempo's logging subsystem to automatically respect { silent: true }, custom logger delegates, and debug verbosity levels. Additionally, logError(err, this?.config) automatically throws the error when config.catch is false (the default) and swallows it gracefully when catch: true, eliminating the need for manual if (!config.catch) throw checks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alternative: Standalone Functions (tempo-fns) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The JavaScript ecosystem is divided between two architectural preferences: Chained Fluent APIs (like Tempo Plugins) and Pure Standalone Functions (for aggressive tree-shaking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To support teams that mandate strict 0kb bundle-impacts and functional programming paradigms, Magma Computing provides the @magmacomputing/tempo-fns library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // The Pure, Tree-shakeable approach:
+import { isFirstDayOfMonth } from '@magmacomputing/tempo-fns';
+import { Tempo } from '@magmacomputing/tempo/core';
+
+if (isFirstDayOfMonth(new Tempo('2024-01-01'))) { ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building complex logic, consider whether it belongs as a core Plugin extension, or as a standalone utility in tempo-fns (or a hybrid wrapper of both!).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Distributing Your Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To make your plugin available to the community, package it as a standard NPM module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Factories (with Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin requires its own configuration, use definePlugin directly and export the result as a callable PluginFactory. Consumers can then invoke it at registration time with their options, following the Vite / Rollup colocated plugin model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // tempo-plugin-holiday/index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+import type { TempoPlugin } from '@magmacomputing/tempo/plugin/sdk';
+
+export interface HolidayPluginOptions {
+  region?: string;
+  observeWeekendShifts?: boolean;
+}
+
+// Export the options type so consumers get IDE intellisense inside HolidayPlugin({ ... })
+export const HolidayPlugin = definePlugin({
+  name: 'holiday',
+  install(TempoClass, options?: any) {
+    const opts = options as HolidayPluginOptions | undefined;
+    const region = opts?.region ?? 'US-NY';
+    // ... register methods or terms using the resolved options ...
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consumers can then register it using any of the three patterns:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins: [
+  HolidayPlugin,                            // Pattern 0: bare (uses pluginOptions fallback)
+  HolidayPlugin({ region: 'AU-NSW' }),      // Pattern 1: factory closure
+  [HolidayPlugin, { region: 'AU-NSW' }],   // Pattern 2: tuple
+]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Module Aggregator Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If your plugin provides multiple related components, wrap them in an aggregator module to provide a uniform activation experience for the user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // index.ts
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';
+import { PluginA } from './plugin.a.js';
+import { PluginB } from './plugin.b.js';
+
+export const MyFeaturePlugin = definePlugin((TempoClass, options) => {
+  TempoClass.use([PluginA, PluginB]);
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Commercial & Enterprise Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you require custom commercial plugins, domain-specific extensions, or enterprise-grade features with dedicated support, see our Commercial & Professional Services guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Consuming a Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For developers using your plugin, registration can be handled imperatively via use() or declaratively via configuration. As of v4.3.0, Tempo supports three registration patterns:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PatternSyntaxDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0 — BareTickerPluginDefault options; reads from pluginOptions fallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1 — Factory ClosureTickerPlugin({ interval: 1000 })Colocated options injected at call site
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2 — Tuple[TickerPlugin, { interval: 1000 }]Works with any plugin, including third-party

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Imperative Registration (Tempo.use) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For standalone usage, pass the plugin directly to Tempo.use() using any pattern:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+import { HolidayPlugin } from '@magmacomputing/tempo-plugin-holidays';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+
+// Pattern 0: bare
+Tempo.use(TickerPlugin);
+
+// Pattern 1: factory closure — options colocated at the call site
+Tempo.use(TickerPlugin({ interval: 1000 }));
+
+// Pattern 2: tuple — pairs any plugin with its options
+Tempo.use([HolidayPlugin, { region: 'US-NY' }]);
+
+// Mix and match in a single call:
+Tempo.use(
+  CelestialPlugin,
+  TickerPlugin({ interval: 500 }),
+  [GeoPlugin, { timeout: 5000 }],
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Declarative Configuration (defineConfig / Tempo.init) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All three patterns are supported directly in the plugins array of tempo.config.ts or Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+Tempo.init({
+  plugins: [
+    CelestialPlugin,                       // Pattern 0: bare
+    TickerPlugin({ interval: 1000 }),      // Pattern 1: factory closure
+    [GeoPlugin, { timeout: 5000 }],        // Pattern 2: tuple
+  ],
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options Precedence (lowest → highest):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. pluginOptions[name] from config (base/shared fallback)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Trailing shared options passed to Tempo.use(PluginA, PluginB, sharedOpts)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Call-site colocated options (Pattern 1 or Pattern 2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. pluginOptions — Legacy / Shared Fallback ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluginOptions remains fully supported as a passive configuration registry. It is the right tool for:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bare-registered plugins that read their config from TempoClass.config.pluginOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lazy / dynamically imported plugins that aren't in the main bundle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enterprise base configs shared via extends across microservices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  plugins: [HolidayPlugin, TickerPlugin],  // bare (Pattern 0)
+  pluginOptions: {
+    holiday: { region: 'US-NY', observeWeekendShifts: true },
+    ticker: { interval: 500 },
+    ai: { mode: 'fallback', timeout: 10000 },  // safe even if 'ai' plugin not imported
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecation Notice: Configuration Dictionaries in `plugins`

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supplying plain configuration dictionaries directly inside the plugins array (e.g. plugins: [{ holiday: { ... } }]) remains supported for backwards compatibility, but is marked @deprecated in favor of pluginOptions or the new colocated option patterns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bulk Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.use() supports rest parameters and arrays, allowing you to register multiple plugins in a single call. If the last argument is a plain object (and not a plugin/term), it is treated as a shared configuration for all plugins in that batch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Mix and match arrays and individual arguments
+Tempo.use(
+  [PluginA, PluginB], 
+  PluginC, 
+  { debug: 5 } // applied to A, B, and C
+);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Need Help Writing a Plugin? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you have a complex business requirement or need a high-performance plugin built to professional standards, we can help. Our team can design, implement, and verify custom Tempo plugins tailored to your specific domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Contact Magma Computing Solutions to discuss your requirements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.registry.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.registry.html new file mode 100644 index 00000000..49cf59c2 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.registry.html @@ -0,0 +1,77 @@ + + + + + + Registries and Dictionaries | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registries and Dictionaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses internal dictionaries—called Registries—to map string keys to values, functions, or formats. This is how Tempo resolves timezone abbreviations like EST, parses custom month layouts, and translates numbers to words.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By standardizing these data stores under the registry namespace, you can deeply customize how Tempo parses, formats, and understands regional values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Accessing Registries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access active registries using the static Tempo.registry getter. These objects are Read-Only Proxies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+console.log(Tempo.registry.formats);
+// { '{iso}': '{yyyy}-{mm}-{dd}T{hh}:{mi}:{ss}', ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because these registries are frozen proxies, attempting to mutate them directly (e.g., Tempo.registry.formats.custom = '...') will throw an error. This guarantees that internal caches and parser guards remain synchronized.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add or override values, you must use Tempo.use() or Tempo.init():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.use({
+  registry: {
+    formats: {
+      custom: '{yyyy}!!{mm}!!{dd}'
+    }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📅 TIMEZONE Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a built-in registry of common timezone abbreviations. Most regional aliases map to DST-aware regional IANA zones, not fixed UTC offsets. For example, both est and edt map to America/New_York, which means dates parsed during summer months will automatically adjust to Eastern Daylight Time (-04:00), whereas gmt and utc map to fixed UTC (+00:00). If your application requires a constant, non-shifting offset year-round (e.g. strict UTC-5 without Daylight Saving adjustments), use an explicit fixed offset like "-05:00" or 'Etc/GMT+5' instead of a regional abbreviation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AliasIANA Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    utc/ gmtUTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    est / edtAmerica/New_York
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cst / cdtAmerica/Chicago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mst / mdtAmerica/Denver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pst / pdtAmerica/Los_Angeles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aest / aedtAustralia/Sydney
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    acst / acdtAustralia/Adelaide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    awstAustralia/Perth
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nzt / nzst / nzdtPacific/Auckland
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cet / cestEurope/Paris
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eet / eestEurope/Helsinki
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    istAsia/Kolkata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nptAsia/Kathmandu
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jstAsia/Tokyo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can extend this list or override existing aliases using Tempo.use({ registry: { timeZones: { ... } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other Internal Registries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo leverages several other internal data dictionaries to parse and format dates. The formats and locales dictionaries are organized under the registry configuration namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formats: Named format aliases used by the format() engine.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Locales: Translation dictionaries used by the :locale format modifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Events: Custom aliases mapped to specific dates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Periods: Custom aliases mapped to specific times.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Snippets: Reusable Regex patterns mapped to variables for parsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layouts: Composed string patterns mapped to Regex logic for parsing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Numbers: Word-to-number dictionaries (e.g., "one" -> 1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinals: Word-to-ordinal offset dictionaries (e.g., "first" -> 1, "last" -> -1, "current" -> 0).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (Note: All dictionaries are consolidated into the registry namespace to separate data from behavior.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registry Merge Contracts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core internal registryUpdate() utility applies an additive-only merge strategy. It deeply merges new keys into the registries but safely preserves existing root keys (preventing accidental overrides of built-in definitions).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you pass an options object to Tempo.use(), it acts differently depending on the data type:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enum/Proxy-Backed Registries: For explicitly wrapped structures (like formats and locales), Tempo.use() can be used to forcefully shadow existing entries, making it the proper tool to change standard behaviors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • General Registries: It does not provide a blanket, universal overwrite mechanism for the entire registry system.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/3-extending-tempo/tempo.term.html b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.term.html new file mode 100644 index 00000000..948d76c6 --- /dev/null +++ b/packages/tempo/public/v4/doc/3-extending-tempo/tempo.term.html @@ -0,0 +1,261 @@ + + + + + + Tempo Terms | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Overview ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Terms system is Tempo's extensible plugin mechanism for attaching business-logic to a date-time instance, without adding to the profile (memory footprint) of a Tempo object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because a Tempo instance is designed to be as lean as possible, term properties are lazy-loaded: their lookup function is not executed until the property is first accessed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once evaluated, the result is memoised — subsequent reads of the same property return the cached value directly, with no further computation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('25-Dec-2024').term.season     // ← computed on first access, cached thereafter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transparent Discovery: As of v2.0.1, all Term properties are enumerable. While modern console.log environments (like Node.js) will typically display these as [Getter] to preserve laziness, they are visible to property-scanning tools. This means a serializer (like JSON.stringify) or a deep-clone utility will trigger the eager evaluation of every registered Term at once. To prevent terminal noise during these events (e.g., for invalid dates), initialize Tempo with silent: true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What a Term Does ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Term plugin answers a single question:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "Where does this Tempo instance sit within a pre-defined date-time range?"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each plugin holds a static list of range boundaries (e.g. the start of each meteorological season) and a define function that is called — with the Tempo instance as its this context — to determine into which boundary the instance falls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin expose two views of that result via the Tempo.term object:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PropertyReturns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.term.<key>A short identifier string (e.g. 'qtr', 'szn', 'zdc')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tempo.term.<scope>The full matching range object, with all metadata fields (e.g. key, day, month, year, sphere, etc.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The <key> and <scope> are defined by the plugin author, where the intent of the <key> is to provide a short identifier value, and the intent of the <scope> is to provide the full matching range object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provided Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The examples given below for Fiscal Quarters and Meteorological Seasons assume a Northern Hemisphere configuration (sphere: 'north'), unless they explicitly state otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    qtr / quarter — Fiscal Quarters ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Divides the calendar year into four fiscal quarters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemisphere-aware: southern-hemisphere configs shift the quarter boundaries by six months.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('15-Feb-2025');
+
+t.term.qtr      // → 'Q1'
+t.term.quarter  // → { key: 'Q1', day: 1, month: 1, fiscal: 2025, sphere: 'north' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('15-Feb-2025', { sphere: 'south' });
+
+t.term.qtr      // → 'Q3'  (southern hemisphere)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    szn / season — Meteorological Seasons ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Maps the current date to the appropriate meteorological season.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hemisphere-aware (northern / southern boundaries differ).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('01-Jul-2025');
+
+t.term.szn      // → 'Summer'  (northern hemisphere)
+t.term.season
+// → { key: 'Summer', day: 1, month: 6, symbol: 'Sun', sphere: 'north' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('01-Jul-2025', { sphere: 'south' });
+
+t.term.szn      // → 'Winter'  (southern hemisphere, different boundary dates)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zdc / zodiac — Astrological Zodiac ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines the Western astrological sign for the date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full zodiac scope also includes the Chinese zodiac (animal, element, Yin/Yang) derived from the year.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('14-Mar-2025');
+
+t.term.zdc      // → 'Pisces'
+t.term.zodiac
+// → { key: 'Pisces', day: 19, month: 2, symbol: 'Fish', longitude: 330, planet: 'Neptune' }
+
+t.term.zodiac.CN
+// → { animal: 'Snake', traits: 'Wise, intuitive', element: 'Wood', yinYang: 'Yin' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tod / timeOfDay — Daily Time Periods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Classifies the time of day into a named period based on a pre-defined range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeyStarts at
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midnight00:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Early04:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Morning08:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midmorning10:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Midday12:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Afternoon15:30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Evening18:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Night20:00
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('1pm');
+
+t.term.tod      // → 'Midday'
+t.term.timeOfDay   // → { key: 'Midday', hour: 12, group: 'standard' }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspecting Registered Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The static Tempo.terms getter returns a read-only list of all registered plugins:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.terms
+// → [
+//     { key: 'qtr', scope: 'quarter',  description: 'Fiscal Quarter' },
+//     { key: 'szn', scope: 'season',   description: 'Meteorological season' },
+//     { key: 'zdc', scope: 'zodiac',   description: 'Astrological Zodiac sign' },
+//     { key: 'tod', scope: 'timeOfDay',   description: 'Daily time period' },
+//   ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Activating Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In Tempo Full, all standard Terms are enabled by default. In Tempo Core, you have three ways to opt-in:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Standard Activation (Recommended) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The fastest way to enable all built-in Terms (qtr, szn, zdc, tod).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/term'; // One-line side-effect activation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Explicit Module (Uniform Sync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for projects that prefer explicit dependencies and a uniform API across all features.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { TermsModule } from '@magmacomputing/tempo/term';
+
+Tempo.use(TermsModule);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Surgical Opt-in (Maximum Lite) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for maximum bundle-size optimization—you only load the specific Terms you use. Note that specific standard terms have their own dedicated sub-paths natively bundled within the main package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { QuarterTerm } from '@magmacomputing/tempo/term/quarter';
+
+Tempo.use(QuarterTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How to Define a Term Plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Term plugin is created using the defineTerm factory function provided by the library (@magmacomputing/tempo/plugin/sdk). This ensures correct type-inference and automatically handles registration during the discovery phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin Definition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineTerm, defineRange, getTermRange, resolveCycleWindow } from '@magmacomputing/tempo/plugin/sdk';
+import { enums, type Tempo } from '@magmacomputing/tempo/core';
+
+/** 1. The range boundaries (grouped by sphere) */
+const ranges = defineRange([
+  { key: 'Spring', month: 3,  sphere: enums.COMPASS.North },
+  { key: 'Summer', month: 6,  sphere: enums.COMPASS.North },
+  { key: 'Autumn', month: 9,  sphere: enums.COMPASS.North },
+  { key: 'Winter', month: 12, sphere: enums.COMPASS.North },
+  { key: 'Spring', month: 9,  sphere: enums.COMPASS.South },
+  { key: 'Summer', month: 12, sphere: enums.COMPASS.South },
+  { key: 'Autumn', month: 3,  sphere: enums.COMPASS.South },
+  { key: 'Winter', month: 6,  sphere: enums.COMPASS.South },
+], 'sphere');
+
+/** 2. Resolve the candidate list for the current anchor/context */
+function resolve(t: Tempo, anchor?: any): any[] {
+  const source = anchor ?? t;
+  const sphere = source.sphere ?? t.sphere;
+  const template = ranges[sphere] ?? [];
+  
+  // resolveCycleWindow handle the ±1 year shifting for boundaries
+  return resolveCycleWindow(t, template, anchor);
+}
+
+/** 3. The Plugin Object */
+export const MyRetailSeasonTerm = defineTerm({
+    key: 'rsn',
+    scope: 'retailSeason',
+    description: 'Custom retail seasonal range',
+    ranges,
+
+    /** Optional: Used for multi-cycle discovery & traversals */
+    resolve(this: Tempo, anchor?: any) {
+      return resolve(this, anchor);
+    },
+
+    /**
+     * Determine the current range.
+     * @param keyOnly - if true, return only the identifier string
+     * @param anchor - the specific date-time we are calculating for 
+     */
+    define(this: Tempo, keyOnly?: boolean, anchor?: any) {
+      const list = resolve(this, anchor);
+      return getTermRange(this, list, keyOnly, anchor);
+    }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Range fields ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Range object must include a key and any subset of the date-time fields below.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getTermRange sorts ranges in descending chronological order and returns the first range whose boundary the instance has reached or passed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Sync to Alias Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a Term plugin defines ranges with string-based key values, Tempo automatically synchronizes these keys with the internal Alias Engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Period Scopes: Ranges defined in a period scope (like midnight or morning) are registered as Period Aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Event Scopes: Ranges defined in an event scope are registered as Event Aliases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This synchronization happens during Tempo.use() and Tempo.init(), ensuring that any named range boundaries are immediately available for use in the natural-language parsing engine. For example, if you define a custom Term with a range key "bedtime", you can immediately create a new instance using new Tempo('bedtime').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Range = {
+  key: PropertyKey;                // identifier returned when keyOnly = true
+  year?:   number;
+  month?:  number;
+  day?:    number;
+  hour?:   number;
+  minute?: number;
+  second?: number;
+  group?:  string;                 // categorization marker (e.g. 'fiscal', 'western')
+  [extra: PropertyKey]: any;       // any additional term-dependent metadata (e.g. 'sphere')
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Registering the plugin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use the static Tempo.use() method. This allows you to add Terms dynamically without modifying the library source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';
+import { MyRetailSeasonTerm } from './term.myretailseason.js';
+
+// Register the term plugin
+Tempo.use(MyRetailSeasonTerm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Tempo instance created after that point will have the custom Term available.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using Custom Configuration in Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Since Tempo preserves non-standard configuration options in its internal config object, you can use Tempo.init() to provide values that your custom Term plugin can later reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Initialize with a custom 'business' config option
+Tempo.init({ 
+  fiscalYearStart: 7 // e.g., July
+});
+
+// 2. Define a term that uses this custom property
+Tempo.use({
+  key: 'cfy',
+  scope: 'fiscal',
+  description: 'Custom Fiscal Year',
+  define: function(this: Tempo, keyOnly?: boolean) {
+    const startMonth = this.config.fiscalYearStart ?? 1;
+    const isPastStart = this.mm >= startMonth;
+    const year = `FY${this.yy - Number(!isPastStart)}`;
+    
+    return keyOnly
+      ? year
+      : { key: year, year, startMonth };
+  }
+});
+
+const t = new Tempo('2025-02-15');
+console.log(t.term.cfy); // → "FY2024" (because it's before July 2025)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Writing Math-Aware Terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To unlock Tempo's advanced Term Traversal (e.g., t.add({ '#quarter': 1 })) and Ticker Syncing, a plugin must provide semantic boundaries (start and end).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The getTermRange Helper ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library provides a specialized helper that calculates these boundaries automatically based on your ranges array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { getTermRange } from '@magmacomputing/tempo/plugin/sdk';
+
+export function define(this: Tempo, keyOnly?: boolean) {
+  // Finds the current range, then injects 'start' and 'end' (as Tempo instances)
+  // into the result object before returning it to the user.
+  return getTermRange(this, ranges, keyOnly);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Manual Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you choose not to use getTermRange, you must manually include start and end (as Tempo instances) in your scope object:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return keyOnly ? 'MyTerm' : {
+  key: 'MyTerm',
+  start: this.set({ hour: 0 }),
+  end: this.set({ hour: 23, mi: 59 })
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Multi-Cycle Discovery & Traversals (The resolve method) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The define method only returns a single boundary (the one the instance currently falls into). But what happens if a user wants to traverse forward by three boundaries (t.add({ '#rsn': 3 }))? Or what if the Ticker engine needs to discover virtual deadlines across multiple years?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To enable this, your plugin can optionally provide a resolve(anchor) method. This method should return the complete array of boundaries for a given cycle (e.g., all the retail seasons in a given year).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When the core engine needs to mathematically "step" through boundaries across multiple years, it repeatedly calls your resolve method with different anchor dates (e.g., shifting the year forward) to discover future/past boundaries seamlessly!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪝 Term Lifecycle Hooks Protocol ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Starting in v4.6.0, Term plugins can participate directly in Tempo's core parsing, arithmetic, boundary snapping, difference calculation, and formatting pipelines via well-known symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instead of overriding core methods or monkey-patching regex tables, term plugins implement protocol hooks using well-known symbols (Symbol.for), exported under TermHook:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineTerm, TermHook, type TermParseContext, type Tempo } from '@magmacomputing/tempo';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The 6 Lifecycle Hooks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hook SymbolMethod SignatureEngine Trigger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.parse](input: string, context?: TermParseContext) => Tempo | Temporal.ZonedDateTime | undefinedExplicit #term natural string input (e.g. new Tempo('#fiscal.q1'))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.ordinal](groups: Record<string, any>, anchor: Tempo, context?: TermParseContext) => Tempo | Temporal.ZonedDateTime | undefinedAnchored ordinal expressions (e.g. Tempo.from('3rd day of #sprint.2', { anchor }))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.step](unit: string, count: number, tempo: Tempo) => Tempo | undefinedStepping arithmetic via dictionary syntax: t.add({ '#term': n }), t.sub({ '#term': n })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.diff](other: Tempo, unit: string, tempo: Tempo) => number | undefinedDifference calculation: t1.until(t2, '#term'), t1.since(t2, '#term')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.bound](boundary: 'start' | 'mid' | 'end', unit: string, tempo: Tempo) => Tempo | undefinedRange boundary snapping: t.set({ '#term': 'start' }), t.set('#term.mid')
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [TermHook.format](token: string, tempo: Tempo) => string | undefinedCustom token formatting: t.format('{#academic}'), t.format('{#academic:upper}')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Complete Hook Example ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo, defineTerm, TermHook } from '@magmacomputing/tempo';
+
+export const SprintTerm = defineTerm({
+  key: 'sprint',
+  scope: 'sprint',
+  description: 'Two-week development sprint cycle',
+  define() {
+    return {
+      key: 'sprint.1',
+      start: this.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }),
+      end: this.add({ days: 14 })
+    };
+  },
+
+  // 1. Parse: Resolve custom #sprint expressions
+  [TermHook.parse](input, ctx) {
+    if (input === '#sprint.current') {
+      return (ctx?.anchor ?? this).set({ day: 1 });
+    }
+    return undefined;
+  },
+
+  // 2. Ordinal: Handle ordinal offsets
+  [TermHook.ordinal](groups, anchor) {
+    // e.g. "3rd day of #sprint.current" or "penultimate day of #sprint.current"
+    const ord = groups.ord?.toLowerCase();
+    const val = groups.value ?? (ord === 'last' ? 14 : (parseInt(ord, 10) || Tempo.enums.ORDINAL[ord]));
+    if (!val) return undefined;
+    const dayOffset = val < 0 ? 14 + val + 1 : val;
+    if (dayOffset < 1 || dayOffset > 14) return undefined;
+    return anchor.add({ days: dayOffset - 1 });
+  },
+
+  // 3. Step: add/sub sprint blocks
+  [TermHook.step](unit, count, tempo) {
+    return tempo.add({ days: count * 14 });
+  },
+
+  // 4. Bound: Snap to sprint start/end
+  [TermHook.bound](boundary, unit, tempo) {
+    if (boundary === 'start') return tempo.set({ hour: 9, minute: 0, second: 0, millisecond: 0 });
+    if (boundary === 'end') return tempo.add({ days: 14 }).set({ hour: 17, minute: 0, second: 0, millisecond: 0 });
+    return undefined;
+  },
+
+  // 5. Diff: Sprints between two dates
+  [TermHook.diff](other, unit, tempo) {
+    const diffDays = tempo.until(other, 'days');
+    return Math.trunc(diffDays / 14);
+  },
+
+  // 6. Format: Custom sprint format token
+  [TermHook.format](token, tempo) {
+    if (token === '#sprint') {
+      return `Sprint-${Math.ceil(tempo.doy / 14)}`;
+    }
+    return undefined;
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Overhead Guarantee ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All lifecycle hooks are strictly isolated behind the # domain term sigil:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calls to standard ISO date parsing (e.g. new Tempo('2026-10-09')), core unit arithmetic (e.g. t.add({ months: 1 })), and standard formatting (t.format('{yyyy}-{mm}-{dd}')) bypass hook lookups entirely with 0ns overhead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Existing terms that do not implement lifecycle hooks continue to use default range-based dispatching without interruption.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Developer Guide: Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure a custom Term plugin integrates fully with Tempo, follow these guidelines:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Static ranges Export: Always include the ranges property in your defineTerm configuration. This enables programmatic discovery via Tempo.terms and allows the Ticker to automatically calculate next-pulse intervals.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Metadata-First Boundaries: If your plugin handles multiple sets (e.g. hemispheres or cultural calendars), avoid using array indices like ranges[0]. Instead, add marker fields like sphere or group to each range object and use .filter() inside your define function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Memoization Safety: Keep the define function pure. It will only be called once per instance access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Math Readiness: Always use getTermRange or provide boundaries. Without them, users cannot use your Term in add(), set(), or ticker().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Key consistency: It is valid to remap the returned scope key (for example, cfy -> FY2024) when that is the semantic value your Term represents. Be intentional and keep it consistent with your ranges lookup and consumer expectations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Unique Names & Collisions: Keep key and scope globally unique across all registered Terms. Avoid reusing an existing Term key (e.g., another plugin already uses qtr) or scope alias. Current behavior is not ideal for collisions: duplicate Term keys are ignored, while scope alias resolution is order-dependent and can shadow another Term. Treat collisions as unsupported and choose unique names to ensure deterministic behavior.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Semantic Casing: To provide a predictable developer experience, adhere to the following casing standards for your Term and Range fields:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Lower-case: Internal identifiers (Term key and scope) and marker fields (e.g., group, sphere, id).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • CapInit / TitleCase: Presentational identifiers (e.g., Range key or symbol, like 'Q1' or 'Spring'). This ensures t.term.season.key returns a properly capitalized string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Free-form text: Longer descriptive fields (e.g., label, description, trait).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8. IDE Autocomplete (Interface Augmentation): To provide a world-class developer experience, always augment the global TempoTermRegistry interface with your custom keys and payload types. This ensures IDEs can provide strict type-checking and autocomplete when users access t.term.myKey.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // IDE Autocomplete (Interface Augmentation)
+declare module '@magmacomputing/tempo' {
+  interface TempoTermRegistry {
+    rsn: 'Spring' | 'Summer' | 'Autumn' | 'Winter';
+    retailSeason: {
+      key: 'Spring' | 'Summer' | 'Autumn' | 'Winter';
+      symbol: string;
+      // ...
+    }
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Best Practices: Idempotency & Side-Effects ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Term lookups are memoized (cached) on the instance, the define function must be pure and idempotent. It should only depend on the current Tempo instance state and its configuration (this.config).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Never apply side-effects or modify external state within a Term definition. The function is only guaranteed to run once per instance access; subsequent reads will return the cached value directly without re-executing your logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/sandbox-factory.html b/packages/tempo/public/v4/doc/4-advanced-reference/sandbox-factory.html new file mode 100644 index 00000000..56ee45b9 --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/sandbox-factory.html @@ -0,0 +1,133 @@ + + + + + + Sandbox Factory Pattern | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandbox Factory Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.5.0 introduces the Sandbox Factory pattern, allowing for deep isolation of configurations and parsing rules. This is particularly useful in complex applications where different modules may require different date-time aliases or behaviors without polluting the global Tempo namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historically, Tempo.init() modified the global library state. This meant that:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Only one set of custom Event or Period aliases could exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Large applications or libraries using Tempo internally would step on each other's configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Testing multiple configurations required careful cleanup between tests.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Solution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.create() returns a derived sandboxed class with its own isolated configuration, registry, and plugin state. Each sandbox inherits from the caller, but runs with independent internal state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lifecycle Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To understand when to use Tempo.create(), it helps to contrast it with the other initialization methods:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.init({ options })Concept: Hard-reset to "out-of-the-box" factory defaults, then apply the provided configuration globally. All previous plugins, terms, and custom formats are purged.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use({ options })Concept: Additive mutation. Keep all existing global settings, plugins, and formats intact, but merge in new configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.create({ options }) / Tempo.create(fn) / Tempo.create(options, fn)Concept: Sandbox Factory. Clone the current global state (inheriting all currently loaded plugins and settings), but branch it off into a brand new, isolated class. Any future changes made to this Sandbox will not affect the global Tempo, and vice-versa. Supports both long-lived derived class creation and ephemeral scoped callback execution with deterministic resource disposal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Overloaded Signatures & Usage Modes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.create supports three distinct execution patterns tailored for different application lifecycles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Derived Class Factory (Long-lived sandbox)
+static create(options?: Options): typeof Tempo;
+
+// 2. Scoped Callback Mode (Ephemeral auto-disposed sandbox)
+static create<R>(fn: (sandbox: typeof Tempo) => R): R;
+
+// 3. Configured Scoped Callback Mode (Custom options + auto-disposed sandbox)
+static create<R>(options: Options, fn: (sandbox: typeof Tempo) => R): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 1: Derived Class Factory ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use this mode when building long-lived domain services, multi-tenant app routers, or dedicated modules requiring custom configurations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
+
+// Create a specialized Sandbox for a Financial app
+const FinTempo = Tempo.create({
+  plugins: [FinancePlugin],
+  pluginOptions: {
+    finance: { fiscalYearStart: 7 } // July fiscal year
+  },
+  registry: {
+    periods: {
+      'market-open': '09:30',
+      'market-close': '16:00'
+    }
+  }
+});
+
+// Standard Tempo remains untouched
+const t1 = new Tempo('market-open'); // Error: Unknown alias
+const t2 = new FinTempo('market-open'); // Success: 09:30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 2: Scoped Callback Execution (Tempo.create(fn)) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For unit tests, request-scoped operations, or short-lived calculations, pass an execution callback. Tempo.create invokes your callback with a freshly isolated sandbox and automatically disposes of it when the function completes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CelestialPlugin } from '@magmacomputing/tempo-plugin-celestial';
+
+// Synchronous callback: automatically disposed on return
+const season = Tempo.create((sb) => {
+  sb.use(CelestialPlugin);
+  return sb('2026-06-21').term.astronomy.season;
+});
+
+// Asynchronous callback: automatically disposed when the Promise settles
+const result = await Tempo.create({ timeZone: 'Pacific/Auckland' }, async (sb) => {
+  const data = await fetchFlightDeparture();
+  return sb(data.departureTime).format('{full}');
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mode 3: Explicit Resource Management (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandboxed classes created via Tempo.create() implement the TC39 Disposable protocol (Symbol.dispose). In TypeScript 5.2+ and modern JavaScript runtimes supporting the using keyword, sandboxes can be scoped deterministically to code blocks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { CustomPlugin } from './custom-plugin.js';
+
+{
+  using sb = Tempo.create({ discovery: 'ephemeral-batch' });
+  sb.use(CustomPlugin);
+
+  const formatted = sb('2026-05-10').format();
+  console.log(formatted);
+} // sb is automatically disposed here as execution leaves block scope!

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Disposal & Memory Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every sandbox class exposes lifecycle disposal mechanisms to prevent memory leaks in high-turnover server environments:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sb[Symbol.dispose](): Purges the sandbox from internal state registries (ClassStates) and deletes the registered discovery symbol slot from globalThis.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sb.isDisposed: Readonly boolean getter indicating whether the sandbox has been cleaned up.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const sb = Tempo.create();
+console.log(sb.isDisposed); // false
+
+// Explicitly clean up when finished
+sb[Symbol.dispose]();
+console.log(sb.isDisposed); // true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Traceability & Collision Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When using sandboxes, it's important to know which configuration resolved an input. Tempo now records the source of every match in the parse.result array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hierarchy of Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a conflict occurs (e.g., you redefine "noon"), Tempo resolves it by checking layers from highest priority to lowest priority:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Local (Instance): Options passed to new Tempo(val, options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Sandbox (Factory): Options passed to Tempo.create(options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Plugins: Aliases registered via Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Global Defaults: Built-in aliases like "xmas", "midnight", etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Checking the Trace ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can inspect the parse.result to see exactly which layer provided the definition:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new FinTempo('market-open');
+console.log(t.parse.result);
+/*
+[
+  {
+    type: "Period",
+    value: "market-open",
+    source: "sandbox", // Resolved from FinTempo (factory/sandbox layer)
+    match: "tm",
+    ...
+  }
+]
+*/

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Immutability & Security ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sandboxed classes created via Tempo.create() are protected by the same @Immutable and @Serializable decorators as the base class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Sandbox class itself is hardened against static member modification.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instances of the Sandbox are frozen upon construction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The internal state is stored in a WeakMap, inaccessible to external code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Create Once: Create your application-specific Sandbox once and export it as your primary entry point.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Prefer Sandboxes for Custom Aliases: Avoid modifying the base Tempo class if your app is intended to be used as a library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Use Debug Mode: When developing new aliases, set debug: 'debug' to receive console warnings about naming collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/tempo.debugging.html b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.debugging.html new file mode 100644 index 00000000..9f033e53 --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.debugging.html @@ -0,0 +1,72 @@ + + + + + + Tempo Debugging & Introspection | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Debugging & Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo encapsulates complex parsing logic and date-time permutations within an immutable class, understanding why a Tempo instance has arrived at its absolute Temporal.ZonedDateTime value can be critical.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document outlines the various debugging and introspection mechanisms available to help trace and understand Tempo's behavior.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before an instance is even created, you can inspect the static state of the Tempo class to understand the global configuration and available plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.config ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of current global configuration settings that act as the default for all new Tempo instances. This includes properties like the default locale, timeZone, and formatting layouts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.default ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of initial, out-of-the-box defaults that Tempo ships with, unaffected by any modifications made via Global Discovery or Tempo.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.terms ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an array of all currently registered Term plugins. This is useful to verify which plugins have been loaded via Tempo.use().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.properties ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns an array of the available static getters on the Tempo class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.parse ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of current global parsing rules. This includes the registries of regex patterns (pattern), snippets, and mapped {event} and {period} definitions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instance Introspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Once a Tempo instance is instantiated, you can inspect its internal state to understand how it was constructed and what logic was applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.config ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the collection of configuration settings applied to this instance. This is a composite of the global Tempo.config and any specific Tempo.Options passed during instantiation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.parse.result ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is arguably the most powerful debugging tool within Tempo. The parse.result property contains an array (a history lineage) of all the rule-matches that occurred to produce the current value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Tempo is chainable (e.g., new Tempo('xmas').set({ period: 'afternoon' })), the parse.result array will contain an entry for every step in that chain, detailing:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • type: The interpreted type of the input (e.g., String, Temporal.ZonedDateTimeLike).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value: The original argument passed to that step.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • match: The specific regex pattern or symbol that successfully matched the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • groups: The resolved components (yy, mm, dd, hh, etc.) extracted from the match.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • anchor: The active reference point used for this specific match. This provides a "breadcrumb" trail during complex parses where the anchor might shift as components are resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.parse.anchor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns the initial reference point used for the current parsing operation. This is the baseline "Now" against which relative Terms (like next Monday or ago) are calculated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.term ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a collection containing the evaluated results of all registered Term plugins for this specific instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    this.fmt ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns a collection containing the pre-calculated string outputs for all currently registered formatting codes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primitive Auditing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you simply need to see the value represented in different primitive formats, Tempo implements [Symbol.toPrimitive]:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ${tempo} (String coercion) outputs the ISO8601 string via this.toString().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +tempo (Number coercion) outputs the Unix epoch in milliseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tempo.nano outputs the Unix epoch in nanoseconds formatted as a BigInt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Debugging and Console Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo utilizes a central Diagnostic Engine (replacing the legacy Logify strategy) that respects configuration flags to provide structured output without polluting the console.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The debug Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When instantiating a Tempo, or globally via Tempo.init(), you can pass { debug: 'debug' } in the options object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('next Friday', { debug: 'debug' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When this flag is enabled, Tempo's Diagnostic Engine will output detailed console.debug logs during parsing. These logs provide a deep-dive look into the Parse Engine's resolution logic, including:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The prioritized layout regex patterns evaluated against the string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The raw regex groups extracted (e.g., specific day offsets, localized term mappings).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The intermediate steps in temporal normalization (e.g., resolving aliases, computing time and date).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The absolute temporal coordinates composed before final instantiation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: The Diagnostic Engine evaluates the debug setting before serializing any string interpolations, guaranteeing zero-cost execution overhead for standard users who do not request debug-level diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The catch Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo is designed to be resilient. If it encounters parsing errors or invalid inputs, it will gracefully fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    However, if you want Tempo to throw Error objects instead of swallowing them (useful during development or in strict environments), you can pass { catch: false } in the options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Throws an Error instead of returning a fallback date
+const t = new Tempo('invalid string', { catch: false });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Fast-Fail (Master Guard) Debugging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a Master Guard to avoid the expensive regex parsing phase for strings that are obviously not date-time inputs. If you find that a string is not being parsed as expected, it's possible that the guard is Rejecting it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Check characters: The guard only allows digits, common symbols (-, :, ., T, Z, /, +, #), space, and standard Latin characters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Use debug: 5: If a string passes the guard but fails the parser, you will see "conformed groups" logs. If you see nothing and the input is returned as-is (falling back to a timestamp interpretation), then the guard likely rejected the string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Invalid String fallback: If the guard rejects a string and it cannot be parsed as a numeric timestamp, it will result in an Invalid instance (see below).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Invalid Instances ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If a Tempo instance completely fails to instantiate (and { catch: false } is not set), it returns an empty object. You can check for this using the isValid property:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo();
+if (!t.isValid) {
+    console.error("Tempo failed to initialize properly");
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/tempo.intl.html b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.intl.html new file mode 100644 index 00000000..cce84041 --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.intl.html @@ -0,0 +1,118 @@ + + + + + + Internationalization (Intl) & Locale in Tempo | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalization (Intl) & Locale in Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The locale configuration setting (config.locale) and internationalization subsystem are foundational pillars of the Tempo engine. Because Tempo delegates heavily to native ECMAScript APIs (Intl and Temporal), the locale parameter is responsible for driving three distinct behavioral systems:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ambiguity Resolution (How ambiguous dates are ordered)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-lingual Parsing (How foreign text is lexed)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Auto-localization Formatting (How output strings are generated)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scope & Design Philosophy Tempo focuses strictly on high-performance date-time mathematics, localized calendar heuristics, and temporal token formatting. General-purpose string manipulation (such as Intl.DisplayNames, Intl.Segmenter, or Intl.Collator) is intentionally delegated directly to standard native ECMAScript engines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you initialize Tempo (or let it infer its environment), the locale dictates how it interprets and communicates dates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Ambiguity Resolution (Date Layout) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When parsing an ambiguous string like 04/05/2024, the engine must decide if it's April 5th (MDY order) or May 4th (DMY order).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses the active locale as a critical piece of metadata to resolve this:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It resolves your locale (e.g. 'en-US' or 'en-GB') to determine the active region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It cross-references the locale's region or language against the internal MONTH_DAY registry to check its preferred layout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If the locale inherently prefers MDY (as in the United States), Tempo dynamically swaps its parsing order to attempt Month-Day-Year patterns before it attempts Day-Month-Year patterns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper details on layout configurations and ambiguous digits, see the Ambiguity Resolution Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Multi-Lingual Parsing (Input) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo parses structural English abbreviations (e.g., Jan, Feb, Mon, Tue). However, Tempo is capable of natively parsing foreign languages by dynamically learning from the runtime environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you nominate a non-English locale (or an array of locales like ['fr-FR', 'es-ES']):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo asks the native ECMAScript Intl API how to spell months, weekdays, and relative events (like "tomorrow" or "yesterday") in the specified languages.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It dynamically compiles new, high-performance Regular Expressions containing these localized abbreviations (and automatically handles accent variations, matching both próximo and proximo).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • It injects these patterns into its lexer, allowing Tempo to instantly understand strings like '15 Janvier 2024' or '15 febrero 2024'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// Tempo learns French and Spanish months & weekdays at runtime!
+// Custom relative modifier keywords ('próximo') and noise articles ('el') can be registered in the registry.
+Tempo.init({ 
+  locale: ['fr-FR', 'es-ES'],
+  registry: {
+    modifiers: { '+': ['próximo', 'proximo', 'siguiente'] },
+    ignores: ['el', 'la', 'los', 'las']
+  }
+});
+
+const a = new Tempo('15 janvier 2024');  // Matches French
+const b = new Tempo('el próximo lunes');  // Matches Spanish ("next Monday")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more details on setting up and optimizing international parsing, see Internationalized Parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Formatting (Output) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When generating human-readable output, Tempo uses the locale to ensure the resulting text is culturally accurate. It delegates this heavily to native Intl APIs for extreme performance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • When calling .toLocaleString(), Tempo automatically passes your configured locale to Temporal so that dates and times are correctly formatted for that region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom format masks can leverage :locale modifiers (e.g. {hh:locale}, {time:locale}, {mon:locale}, {geo.sphere:locale}) to apply local hour-cycles, localized month names, spatial hemisphere translations, and numbering system transliteration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regional Calendar & Environment Fallbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo delegates regional calendar metadata (such as firstDay of the week, regional weekend days, and text direction) directly to the ECMAScript Intl.Locale Info API powered by the host runtime's Unicode CLDR/ICU database.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Host Environment & Default Baseline Fallbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modern Runtimes (Node 18.19+, Node 20+, Modern Browsers): Tempo pulls dynamic, fully authoritative CLDR data directly from the host engine for all 250+ world territories (e.g. Sunday start for en-US, Monday start for en-GB, Saturday/Sunday weekend for France, Friday/Saturday for Saudi Arabia).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy or Stripped Environments (Minimal Docker / Older Engines): If running in an environment lacking the native Intl.Locale Info API, Tempo applies a best-effort regional heuristic for major cohorts (like US, Canada, and Middle Eastern locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Default Baseline Settings: If a locale or territory is not covered by these heuristics, Tempo deliberately falls back to standard baseline settings:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • First day of week: Monday (1, matching ISO 8601)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Weekend days: Saturday & Sunday ([6, 7])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Text direction: Left-to-Right ('ltr')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tip for Docker Deployments: When packaging server applications in minimal Linux or Alpine containers, ensure your Node.js runtime has full ICU support (standard official node container images include full ICU by default) so your applications enjoy full native CLDR accuracy across all locales.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Intl.Locale Info & Regional Calendar Integration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo delegates regional calendar and cultural metadata directly to the ECMAScript Intl.Locale Info API (such as Intl.Locale.prototype.getWeekInfo() and getTextInfo()), bridging the mathematical rigor of the ISO 8601 engine with the practical cultural expectations of calendars around the world (e.g., Sunday-first weeks in North America and Japan, Friday–Saturday weekends in the Middle East).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspecting Cultural Metadata (t.intl.info) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Every Tempo instance provides a structured t.intl namespace:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.intl.info: Returns a frozen, memoized ResolvedLocaleInfo object. Guaranteed to be fully populated across all runtimes (providing standard ISO/CLDR fallbacks if running in minimal or stripped environments).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.intl.locale: Returns the memoized native ECMAScript Intl.Locale instance (typed as Intl.Locale | undefined to safely handle legacy or headless environments that lack Intl.Locale).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-09-16', { locale: 'en-US' });
+
+// Cultural calendar metadata via t.intl.info (always defined):
+console.log(t.intl.info.firstDay);        // 7 (Sunday)
+console.log(t.intl.info.weekend);         // [6, 7] (Saturday, Sunday)
+console.log(t.intl.info.region);          // 'US'
+console.log(t.intl.info.script);          // 'Latn'
+console.log(t.intl.info.direction);       // 'ltr'
+console.log(t.intl.info.hourCycle);       // 'h12'
+console.log(t.intl.info.numberingSystem); // 'latn'
+console.log(t.intl.info.baseName);        // 'en-US'
+
+// Native Intl.Locale instance via t.intl.locale (use optional chaining):
+console.log(t.intl.locale?.language);             // 'en'
+console.log(t.intl.locale?.maximize().baseName);  // 'en-Latn-US'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Safety & Environment Portability: While t.intl.info.* properties are guaranteed non-nullish across all platforms, t.intl.locale directly exposes the host engine's native Intl.Locale. TypeScript strict checking encourages optional chaining (t.intl.locale?....) when directly interacting with the native instance prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Backward Compatibility: Direct access via t.intl.firstDay, t.intl.weekend, etc., remains supported as a deprecated fallback during v4.x, but new code should target t.intl.info.*.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Opt-in Regional Calendar Math (localeInfo: true) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo protects your backend and machine logic with strict ISO 8601 invariants (t.set({ week: 'start' }) always snaps to Monday).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To adapt week mutations to human cultural conventions, enable localeInfo: true:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Enable globally or per-instance:
+Tempo.init({ locale: 'en-US', localeInfo: true });
+
+const t = new Tempo('2026-09-16'); // Wednesday
+t.set({ week: 'start' });          // Snaps to previous Sunday (2026-09-13 00:00:00)
+t.set({ week: 'mid' });            // Snaps to Wednesday (2026-09-16 00:00:00, 3 days after start)
+t.set({ week: 'end' });            // Snaps to Saturday (2026-09-19 23:59:59.999999999)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dedicated ISO Escape Hatches (isoWeek, wy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When localeInfo: true is active, you can always guarantee strict ISO 8601 Monday-start boundaries using dedicated ISO tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ isoWeek: 'start' });       // Always snaps to Monday 00:00:00
+t.set({ wy: 'start' });            // Equivalent dedicated ISO week boundary
+t.set({ isoWeek: 'mid' });         // Always snaps to Thursday 00:00:00
+t.set({ isoWeek: 'end' });         // Always snaps to Sunday 23:59:59.999999999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cultural Formatting Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dow:locale}: Formats a 1-based day-of-week index relative to the active locale's firstDay (e.g. Sunday = 1 in en-US, Saturday = 1 in ar-EG, Monday = 1 in en-GB). Because the developer explicitly requested :locale, this evaluates directly using t.intl.info.firstDay. Standard {dow} continues to evaluate to ISO Monday = 1 strictly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {dow:locale:0} / {dow:0:locale}: Formats a 0-based day-of-week index (0..6) relative to the active locale's firstDay (e.g. Sunday = 0 in en-US, Saturday = 0 in ar-EG, Monday = 0 in en-GB).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {woy:locale}: Formats the week-of-year according to the active locale's week rules (firstDay and minimalDays, e.g. US week numbering where Week 1 is the week containing January 1st). Compose with :raw ({woy:locale:raw}) for unpadded week numbers, or :0 ({woy:locale:0}) for zero-indexed weeks (00..52).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {yow:locale} / {yw:locale}: Formats the week-numbering year according to the active locale's week rules. Compose with :short ({yow:locale:short}) for a 2-digit week-year.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {hh:locale}: Adapts hour formatting to the region's hourCycle (12-hour format 00..11 in h11 regions, 01..12 in h12 regions like en-US, and 24-hour format 00..23 in h23/h24 regions like fr-FR). Compose with :raw ({hh:locale:raw}) for unpadded hours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {time:locale}: Formats a complete localized time string, automatically including localized meridiem markers in h12 locales ("03:30:45 pm") and 24-hour time in h23 locales ("15:30:45").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Localized Numerals (:locale): When applied to numeric tokens ({yyyy:locale}, {mm:locale}, {dd:locale}), transliterates digits into the region's native numbering system (e.g. ٢٠٢٦-١٠-٢٤ in ar-EG). Base tokens without :locale ({yyyy}-{mm}-{dd}) always maintain strict ASCII digits for machine safety.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • BiDi Isolation: When formatting localized text tokens ({mon:locale}, {wkd:locale}) in RTL regions (Arabic, Hebrew), Tempo wraps text in Unicode BiDi isolates to prevent bidirectional text disruption.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {intl.<property>}: Directly embeds resolved regional metadata into format templates (e.g. {intl.region}, {intl.script}, {intl.direction}, {intl.firstDay}, {intl.minimalDays}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. High-Performance Intl Utility Hub ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In addition to inspecting regional calendar metadata, the t.intl namespace is designed as a zero-overhead, pre-bound internationalization utility hub.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native ECMAScript Intl formatters (Intl.RelativeTimeFormat, Intl.ListFormat, Intl.DateTimeFormat) are powerful but can be slow to initialize in tight loops because they re-parse Unicode CLDR databases on each constructor call. Tempo.intl eliminates this overhead through an internal O(1) memoization cache pre-bound to the active instance's locale and timeZone:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pre-Bound Formatting Operations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-10-02', { locale: 'fr-FR' });
+
+// 1. Relative Time Formatting (Pre-bound to t.locale)
+t.intl.relativeTime(-2, 'day');              // "il y a 2 jours"
+t.intl.relativeTime(3, 'month');             // "dans 3 mois"
+
+// 2. Localized List Formatting (Pre-bound to t.locale)
+t.intl.list(['lundi', 'mardi', 'mercredi']);  // "lundi, mardi et mercredi"
+
+// 3. Pre-Memoized Native DateTimeFormat Instance
+const dtf = t.intl.dtf({ dateStyle: 'full' }); // Instant O(1) cached Intl.DateTimeFormat
+
+// 4. Plural Category Rules
+t.intl.plural(1);                            // 'one'
+t.intl.plural(5);                            // 'other'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Architectural Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureRaw Native IntlTempo.intl Utility Hub
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Instantiation CostRepeated CLDR/ICU initializationO(1) Globally memoized cache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Context WiringManual locale & timeZone passingAutomatically bound to instance context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Memory FootprintManual GC management required0 bytes added to Tempo instances
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative & List FormattingMulti-line constructor boilerplateClean, humanized one-liners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/tempo.planner.html b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.planner.html new file mode 100644 index 00000000..031c3867 --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.planner.html @@ -0,0 +1,80 @@ + + + + + + Parse Planner Configuration | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parse Planner Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Parse Planner allows you to configure exactly how Tempo's text-to-date parsing engine operates, prioritizing certain date layouts and optimizing the parsing phase using pre-filters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These options are nested under the planner property when configuring Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layoutOrder ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, Tempo searches through a variety of date layouts (like ISO 8601, European, American, etc.) to understand user input. The layoutOrder configuration allows you to explicitly list which layout patterns should be evaluated first, prioritizing formats that you expect most often.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This leads to performance gains and gives you deterministic control when overriding Ambiguity Resolution heuristics (e.g. forcing mdy over dmy).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+Tempo.init({
+  planner: {
+    layoutOrder: ['iso', 'dmy', 'mdy'] // Array of string layout names
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Layouts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Common layouts include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • iso (e.g., 2024-05-20)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mdy (e.g., 05/20/2024)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dmy (e.g., 20/05/2024)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ymd (e.g., 2024/05/20)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a layoutOrder is provided, those specific layouts are pushed to the top of the parsing queue.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preFilter ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The preFilter option is a performance-optimization flag for the engine. When set to true, the parsing engine will pre-scan incoming text and immediately skip complex regex evaluation if the input contains no discernible date or time characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is highly recommended for applications where non-date text is frequently evaluated by Tempo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('some random text', {
+  planner: {
+    preFilter: true
+  }
+});
+
+// `t` will quickly resolve to an errored state, saving CPU cycles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/tempo.shorthand.html b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.shorthand.html new file mode 100644 index 00000000..97744d6e --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.shorthand.html @@ -0,0 +1,76 @@ + + + + + + Tempo Shorthand Engine | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Shorthand Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo Shorthand Engine (the "Slick" engine) provides a powerful, namespace-based syntax for navigating and manipulating complex date/time cycles (Terms). It allows you to treat high-level concepts like Quarters, Seasons, and Daily Periods as first-class units of measure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Three Modes of Shorthand ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Shorthand behavior changes depending on whether you provide a String, an Object, or a Structural Key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A. Navigation Mode (String Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .set(), .add(), .subtract(), .until(), and .since().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: #[namespace].[modifier][repeat][range]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Jumping to specific boundaries (e.g., "the start of the next Q1").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set('#qtr.>q1'); // Snaps to the start of the next available Q1
+t.add('#timeOfDay.>afternoon'); // Jumps to the start of the next Afternoon period

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    B. Relational Mode (Object Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .add(), .subtract(), and .set().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: { '#namespace': value }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Shifting by semantic "steps" while preserving your relative position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Relational Add & Subtract: Preserves your offset within the cycle
+t.add({ '#qtr': 1 });      // If you are 20 days into Q1, you resolve to 20 days into Q2.
+t.subtract({ '#qtr': 1 }); // Resolves backwards to 20 days into the previous Quarter.
+
+// Relational Set: Absolute index alignment
+t.set({ '#qtr': 2 }); // Aligns to the start of the 2nd quarter of the current year

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C. Structural Mode (Boundary Shorthand) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used in: .set().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern: { '#namespace': 'start' | 'mid' | 'end' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Best for: Snapping a date to the precise boundaries or midpoint of its current Term.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.set({ '#qtr': 'start' }); // Snaps to the exact start of the current quarter
+t.set({ '#qtr': 'end' });   // Snaps to the final nanosecond of the current quarter
+t.set({ '#qtr': 'mid' });   // Snaps to the midpoint of the current quarter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Navigation Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modifiers control the direction and inclusivity of the search.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierMeaningBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >Forward (Exclusive)Finds the next boundary strictly after the current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <Backward (Exclusive)Finds the previous boundary strictly before the current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >=Forward (Inclusive)Returns the current Term if it contains the cursor; otherwise, the next.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <=Backward (Inclusive)Returns the current Term if it contains the cursor; otherwise, the previous.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +Relative FutureAlias for >.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -Relative PastAlias for <.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thisIdentityResolves the Term currently containing the cursor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Proximity vs. Momentum ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The "Slick" engine uses two different sorting strategies to ensure results feel "natural."

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Proximity Resolution (Identifiers) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a simple identifier like #zodiac.aries, Tempo uses Past-Leaning Resolution. It finds the most recent instance of Aries that has already started. If you are currently in Aries, it returns the start of the current one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Momentum Resolution (Shifters) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a shifter like >q1, Tempo uses Chronological Momentum. It ignores where you are now and looks exclusively into the future for the next occurrence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. The "Cycle Preservation" Guarantee ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of Tempo's premium features is its ability to maintain your relative offset when shifting across Terms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are 45% of the way through a Morning period and you call t.add({ '#timeOfDay': 1 }), Tempo doesn't just add a fixed number of hours. It:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Determines your relative percentage/offset within the current Morning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Finds the boundaries of the next registered period (e.g., Afternoon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calculates the same 45% point within that new period.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This ensures that "shifting by a quarter" or "shifting by a period" feels mathematically correct even when those Terms have different durations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Development Constraints ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building custom Terminology Plugins, you must follow the Golden Rules of Range-Keys to ensure the lexer can resolve them:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No Reserved Characters: Range-Keys (e.g., q1, aries) must not contain:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > < + = , . ! @ # $ % ^ & * ( ) [ ] { }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This rule does not reserve - even though the Relative Past shorthand uses - as an alias for <; that modifier is parsed in operator position, not as part of the range-key token itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WARNING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No Leading Numbers: Range-Keys must not start with a digit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1q is Invalid (Lexer thinks it's a repeat count). Use q1 instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Best Practices ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Explicit Spheres: Always set sphere: 'north' or 'south' in your config if using seasonal Terms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Method Intent: Use String shorthand for "Jumping" to boundaries and Object shorthand for "Shifting" relative to your current time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fail-Safe: Use catch: true in your global config to allow shorthand resolution to fail silently (returning a void instance) instead of throwing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/4-advanced-reference/tempo.weekday.html b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.weekday.html new file mode 100644 index 00000000..1edae2dd --- /dev/null +++ b/packages/tempo/public/v4/doc/4-advanced-reference/tempo.weekday.html @@ -0,0 +1,69 @@ + + + + + + Weekday Parsing | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a flexible way to parse Weekday inputs, allowing you to specify dates relative to the current day or a specific base date. This is particularly useful for phrases like "next Monday" or "3 Wednesdays ago".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Supported Formats ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weekday inputs typically consist of a modifier (optional), a count (optional), and the Weekday name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Simple Weekday Names ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can provide the short or full name of a Weekday.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mon, Monday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Wed, Wednesday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sun, Sunday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Symbolic Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Symbols can be used to indicate relative weeks or specific directions in time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When no modifier is provided, Tempo defaults to the Weekday in the current week.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ModifierMeaningExampleResults in...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +Next week+MonMonday of next week
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -Previous week-TueTuesday of last week
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <=Prior to<=WedThe Wednesday immediately preceding (or equal to) today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <Prior to (strict)<ThuThe Thursday strictly before today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >=Subsequent to>=FriThe Friday immediately following (or equal to) today
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >Subsequent to (strict)>SatThe Saturday strictly after today

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strict vs Inclusive Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The difference between < (strict) and <= (inclusive) is only relevant when you evaluate a string on the exact same weekday you are targeting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For example, if today is Wednesday:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('<Wed')  // → returns LAST Wednesday (strictly before today)
+new Tempo('<=Wed') // → returns TODAY (inclusive match)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Keyword Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Keywords can be used for more natural language-like inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KeywordMeaningExample
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thisCurrent weekthis Wed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextNext weeknext Monday
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prevPrevious weekprev Fri
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lastLast weeklast Sunday

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Count Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can specify a number of weeks to jump by adding a count after the modifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • -3 Wed: Three Wednesdays ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • +2 Mon: Two Mondays from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Relative Suffixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also specify the direction of time using a suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 3 Wed ago: Three Wednesdays ago
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 2 Mon hence: Two Mondays hence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 2 Mon from now: Two Mondays from now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time Suffixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can append time information to a Weekday string. Tempo will parse the Weekday first and then apply the time to that specific date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mon 10:00am
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • >Friday noon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • <3 Wed 15:30:00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Normalization: Weekday names are normalized to their 3-letter proper-case prefix (e.g., monday -> Mon).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Anchor: If no time-zone or base date is provided, Tempo uses "now" as the anchor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Calculation: The modifier and count determine the number of weeks to add or subtract from the anchor date to find the target Weekday.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Constraint: If time components are provided, they are set on the calculated date. Otherwise, the time defaults to 00:00:00 if it's the first parsing pass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/5-architecture-and-internals/architecture.html b/packages/tempo/public/v4/doc/5-architecture-and-internals/architecture.html new file mode 100644 index 00000000..0e3cc5c1 --- /dev/null +++ b/packages/tempo/public/v4/doc/5-architecture-and-internals/architecture.html @@ -0,0 +1,68 @@ + + + + + + 🏗️ Core Architecture | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Core Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo introduces several industry-leading architectural patterns designed for maximum resilience in complex Monorepo and Proxy-wrapped environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌐 Shared Global Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TempoRuntime — single hardened bridge ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historically, Tempo spread its inter-module state across many global symbol slots on globalThis ($terms, $extends, $modules, etc.). Each slot was a potential tamper target, making the global namespace difficult to audit securely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of modern builds, all bookkeeping is consolidated inside a single TempoRuntime object (internal core runtime). The runtime is stored on globalThis under a hardened private symbol property with descriptor enumerable: false, configurable: false, writable: false, ensuring external code can neither replace nor delete it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reduced Global Footprint — Consolidation from multiple scatter-slots down to a single root.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Centralized Hardening — Strict input validation (Tempo.use) and hook management operate securely from one nexus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Runtimes (Experimental) — TempoRuntime.createScoped() returns a fresh, isolated runtime for internal test harnesses without globalThis manipulation. Note: This is an internal testing utility. For user-facing configuration and plugin isolation, use the official Sandbox Factory API (Tempo.create()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-Bundle / HMR Safety — Guarantees that two bundle copies of Tempo always share the identical runtime object, resolving complex split-brain states in monorepos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    User-facing "Global Discovery" slots remain on globalThis. The Symbol.for('$Tempo') slot (and custom discovery symbols passed to Tempo.init) are intentionally exposed for user-readability, remaining ordinary writable properties. Only sensitive internal bookkeeping was moved into the hardened runtime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To solve the "Split-Brain" issue inherent in monorepo development, Tempo utilizes a Shared Global Registry. By leveraging a unified global type-identification symbol on globalThis, all versions of Tempo share a synchronized constructor registry. This ensures classes are accurately identified as constructors even when loaded across disparate module boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🕵️ Decoupled Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo utilizes a centralized, functional diagnostic engine (via logError / logWarn utilities) relying on private context to avoid polluting the public console or altering object state. This ensures parsing telemetry never clashes with standard application logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context-Aware: Logs rigorously track their discovery path (e.g., "Applied via Global Discovery").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero-Footprint: When debug: 0, the logging overhead is mathematically eliminated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol-Gated: Diagnostic metadata is attached via private symbol variable directly (e.g., config[sym.$LogConfig]), making it invisible to standard iteration (Object.keys) and serialization (JSON.stringify).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Hardened Functional Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine implements a "Fail-Safe" execution pattern for functional inputs, automatically recovering from misidentified types—such as ES6 classes wrapped in defensive Proxies or circular dependency deadlocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Defensive Execution: All plugin invocations are wrapped in recursive try/catch execution blocks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Silent Failover: When combined with catch: true, resolution failures safely return a Void Instance, preventing application crashes while surfacing clear diagnostic symbols for debugging.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Tempo Architecture: Internal Protection & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo employs two distinct methodologies for protecting its internal state. These strategies are highly complementary, each meticulously tailored to a specific scope (Instance vs. Global) and performance requirement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭 Methodology Comparison ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureLazy Evaluation (Shadowing)Soft Freeze (Proxy)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primary TargetTempo.#term, Tempo.#fmt (Instance State)NUMBER, FORMAT (Global Registries)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ScopeInstance-Specific: Unique to every separate new Tempo() call.Global-Shared: One single source of truth used by all instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Primary GoalPerformance: Avoid computing expensive Terms (e.g., qtr or szn) until explicitly requested.Extensibility: Allow plugins to safely append new data to registries at runtime.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MechanismObject.create(proto) + Prototype Shadowing.new Proxy(target) + Symbol-bypass.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why this one?Memory Efficiency: Thousands of instances share the same base prototype.Reference Stability: Shared registries must persist at the same object reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ The "Zero-Cost Constructor" Objective ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is built with a militant "Performance First" mindset, specifically targeting the computational overhead of the class constructor. In high-frequency applications (like Tickers or real-time Dashboards), creating thousands of objects must be nearly as computationally cheap as primitive assignments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Status: Achieved. We successfully meet the Zero-Cost objective under stable conditions. Benchmarks demonstrate an instantiation overhead of ~523µs, and a fast-fail rejection speed of ~359µs (steady-state results after warm-up on the documented hardware setup).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This objective is achieved through two primary architectural pillars:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy Evaluation (Section 1): Deferring the computationally expensive work of string parsing and Term calculation until the first strict property access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Master Guard (Section 3): Implementing a high-speed "fast-fail" gatekeeper to instantly reject invalid inputs before parsing logic is engaged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Together, these pillars help ensure that new Tempo() maintains an extremely fast constructor execution time by completely deferring standard parsing workloads. However, note that these costs can depend on input scanning length and registry-mutation-driven wordlist rebuilds, meaning performance is not universally input- or registry-independent.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Iteration & Enumerability (Delegator Proxies) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A delegator Proxy is a wrapper whose traps forward operations to an internal target/handler pair. Unlike a standard Proxy, delegation is explicit and tightly routed through an intermediate forwarding layer. In Tempo, the "Generic Lazy Delegator Proxy" handles the public delegation mechanism, while lazy shadowing initializes the private state. These mechanisms coexist: the instance.term / instance.fmt public API employs the delegator Proxy path, and Tempo.#term / Tempo.#fmt private fields are initialized exactly once via lazy shadowing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✅ Object.keys() Behavior ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object.keys(instance.fmt) and Object.keys(instance.term) return the enumerable own keys strictly registered on each delegator target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Proxy Discovery (Definition): This is the proxy-handler phase that enumerates available target keys and installs enumerable lazy getter properties on the proxy target without computing their values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Triggered by Enumeration APIs: Discovery executes when enumeration APIs execute, including Object.keys(instance.fmt), for...in, and Reflect.ownKeys(...).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Timing: Discovery happens at enumeration time (before any property get), establishing key visibility prior to value resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Relation to Section 1: Discovery only registers getters; actual value computation and memoization trigger purely on-demand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • After Access: Getter access memoizes values directly onto the target object; keys remain highly stable and do not "move" across prototype links.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Iteration Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Object.keys / for...in / Object Spread: Operate reliably on enumerable keys exposed by the delegator target after discovery.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • [Symbol.iterator]: Maintains explicit iterator semantics where fully implemented.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.registry.formats & Tempo.registry.terms: These static getters provide a registry-wide macroscopic view of available keys, entirely independent of per-instance memoization state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy Evaluation (Shadowing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: Tempo.#term, Tempo.#fmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Instance Shadowing pattern is engineered for massive scale. When a library handles dense operations, creating thousands of new Proxy() objects injects unacceptable memory overhead. Instead, Tempo exploits the native JavaScript prototype chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 0: All instances initially point to the identical base #term object containing un-evaluated getters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 1: When a Term (e.g., .qtr) is accessed, the value is computationally evaluated exactly once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stage 2: Tempo utilizes a Generic Lazy Delegator Proxy (via getLazyDelegator) which catches property access and evaluates it strictly on-demand.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Result: The V8 engine executes lookups via an aggressively optimized Proxy handler, making lookups mathematically comparable to raw property access while keeping the state strictly immutable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper implementation schematics, see the Lazy Evaluation Pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Soft Freeze Strategy (Proxy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: Tempo.NUMBER, Tempo.FORMAT, Tempo.TIMEZONE, Tempo.config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global registries must remain live yet highly secure. These are protected by a "Soft Freeze" layer to prevent state corruption or prototype poisoning by third-party code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The User: Interacts with a read-only Proxy that strictly behaves like a frozen object. Direct assignments are hard-blocked to prevent poisoning the global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Library: Utilizes a private symbol bypass to execute "Transactional Updates" natively via registryUpdate().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Result: The object reference remains constant while facilitating deeply controlled extensibility. This ensures that internal high-speed caches (like the Master Guard) can be synchronously rebuilt whenever a registry mutates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For deeper implementation schematics, see the Soft Freeze Strategy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ 3. Master Guard (Guarded-Lazy Strategy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Used for: new Tempo(string | number)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Guarded-Lazy strategy ensures that even under the weight of hundreds of custom plugins, the constructor entry point remains near-instantaneous. This logic is decoupled into a high-performance engine.guard.ts module.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Longest-Token Matching: To prevent fractional matching (e.g., matching qtr inside quarter), the guard executes a greedy "Scan-and-Consume" loop that strongly prioritizes the longest available token match.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Unified Wordlist: The guard systematically ingests all registered Terms, Timezones, Month names, and Custom Events into a single O(1) Set lookup (average token-lookup performance after cache construction).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. High-Speed Gatekeeper: By eliminating complex backtracking regular expressions, the gatekeeper provides deterministic O(1) average lookup performance regardless of the depth of registered plugins. Note that overall validation time is bounded by the string length during the scan-and-consume phase, plus occasional O(N) cache rebuild costs when the underlying registry mutates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Versioned Registry: To avoid catastrophic redundant wordlist rebuilding, the Guard strictly monitors a version counter on the alias registry. The wordlist is dynamically rebuilt only when a valid mutation occurs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Auto-Lazy: Valid inputs that successfully clear the guard automatically shift the instance to mode: 'defer', completely deferring the heavy O(N) parsing work until a property is strictly read.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Centralized Alias Management ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo consolidates all Event and Period alias logic into a deeply optimized AliasEngine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it works: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Registry: Aliases operate in a strict prototype-aware chain. A local Tempo instance can deploy its own private aliases that safely shadow global implementations, all while sharing the underlying resolution engines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich Metadata: Every resolution returns a strict AliasResult, providing the Parser with immediate categorical knowledge of the alias's origin (global vs local), structural type, and clock-snapping requirements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clock Snapping: Time-based aliases (e.g. 8:00) are mathematically "snapped" to absolute precision, clearing sub-second drift (ms, us, ns) directly during the resolution phase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decoupled Registration: By deprecating legacy raw objects, the modern registry is highly protected against accidental mutation and supports high-efficiency, version-aware monitoring.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈 Validation & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The algorithmic efficiency of the Master Guard and the success of the Zero-Cost objective remain strictly validated via core benchmarking:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instantiation Overhead: ~523µs on average (passing the Master Guard). (Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Validates the Zero-Cost O(1) objective on this hardware.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fast-Fail Rejection: ~359µs on average (failing the Master Guard). (Node.js v24.14.1, 12th Gen Intel i7-1255U, Linux x86_64; steady-state measured after 1k warm-up runs, n=10k. Demonstrates the Master Guard's low-latency rejection performance.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For detailed execution timings and methodology, see the Performance Benchmarks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄 Internal Lifecycle & Reactive Sync ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo commands system-wide synchronization through a deeply integrated, Symbol-based hook ecosystem.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When a plugin is imported via a side-effect (import '@magmacomputing/tempo/duration'), it triggers a strict sym.$Register hook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Sync: The Tempo core listens for these hooks and synchronously updates its internal registries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Guard Rebuild: Upon any new Term or layout registration, the Master Guard is automatically rebuilt to dynamically ingest the new tokens, ensuring the "Zero-Cost Constructor" remains entirely synchronized with the ecosystem.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disposable Engine (Symbol.dispose) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo class rigorously implements the explicit resource management pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Slate: Calling Tempo[Symbol.dispose]() (or utilizing the using keyword in a test suite) comprehensively resets all global registries and configuration parameters back to factory defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolation: This is mathematically critical for automated testing environments to prevent memory or state-leaks between discrete test cases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚖️ Summary ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Tempo architecture strictly follows the structural principle of "Right Tool for the Job":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shadowing provides the extreme performance and mathematical memory efficiency required for per-instance computed state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Proxies enforce the strict reference stability and highly controlled extensibility required for global system registries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Master Guard algorithmically ensures that even under massive extensibility, the entry point maintains a true "Zero-Cost Constructor".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html b/packages/tempo/public/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html new file mode 100644 index 00000000..4fb66933 --- /dev/null +++ b/packages/tempo/public/v4/doc/5-architecture-and-internals/lazy-evaluation-pattern.html @@ -0,0 +1,87 @@ + + + + + + The Immutable Proxy-Delegator Lazy Evaluation Pattern | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Immutable Proxy-Delegator Lazy Evaluation Pattern ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When building complex JavaScript libraries (like date-time utilities), exposing numerous computed properties as getters on an object is common. However, computing them all upfront is expensive, and re-computing them on every access is wasteful. The standard solution is "Lazy Evaluation": evaluate the getter on first access, and then overwrite the getter with the literal value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    But what if the base object is strictly immutable (via Object.freeze)?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This article details a highly optimized O(1) pattern for securely lazy-evaluating properties on immutable objects using a Proxy-based delegator and private fields.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem: Mutating Frozen State ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A traditional lazy evaluation approach destroys and recreates the properties on the parent object. If the parent object is Object.freeze()'d for security (preventing API consumers from tampering with state), you cannot simply Object.defineProperty to overwrite the getter with a literal value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To get around freezing, you might try taking all property descriptors, wiping the object, mapping the other getters to a new object, adding the evaluated value, and calling Object.freeze() on the new object. This operation runs in O(N) time every single time any getter is accessed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Solution: Proxy-Delegator with Memoization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo achieves lazy evaluation in O(1) time using a Delegator Proxy that memoizes results back onto the target object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    #setLazy(target, name, defineFunction) {
+    // Note: The `target` object must remain unfrozen so we can memoize properties onto it.
+    // It is kept secure by being stored in a private field (e.g., `#term`).
+    const get = () => {
+        const value = defineFunction.call(this); // Evaluate the value
+        
+        // Memoize the value by defining it as a static property on the mutable target
+        Object.defineProperty(target, name, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: false
+        });
+        
+        return value;
+    };
+
+    // Define the initial getter
+    Object.defineProperty(target, name, { get, enumerable: true, configurable: true });
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How it Works ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Proxy Entry Point: Tempo uses a single Proxy (the delegate helper) to catch the very first access to a property. This Proxy doesn't store state; it just routes the request to the lazy evaluator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Private Fields Keep the Mutable Target Secure: The internal containers (#term, #fmt) are private fields. Native JS Private Fields don't exist as public properties on the object. Thus, even if the public Tempo instance is frozen, we can safely keep the internal target objects unfrozen to allow for memoization without exposing them to tampering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Innate JS Engine Optimizations: Once a property (e.g., .quarter) is evaluated, it is "baked" into the target object as a standard value property. Subsequent lookups bypass the Proxy and the getter entirely. The JS engine treats it as a raw property access, which is the fastest possible operation in JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Zero Over-allocation: Unused getters remain as simple function pointers. They cost absolutely nothing in execution time or memory until they are needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By combining Private Fields, Proxies, and Property Memoization, Tempo builds securely immutable APIs that lazy-load computed getters with zero overhead after the initial call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌈 The Best of All Worlds ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As of v2.1.2, Tempo uses a Proxy-Delegator that combines the security of immutability with the speed of raw property access:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy by Default: Properties are only evaluated when accessed, keeping the constructor near-instant.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Memoized Evaluation: Once accessed (e.g., t.term.quarter), the result is "baked" into the instance using Object.defineProperty.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. O(1) Performance: Every access after the first is a direct property lookup—no Proxy traps, no prototype traversal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Transparent Discovery: Because properties are enumerable, console.log(t.term) or JSON.stringify will trigger the evaluation of all registered Terms at once, providing a perfect "snapshot" of the instance state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To prevent diagnostic noise during these full-evaluation events, initialize Tempo with silent: true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html b/packages/tempo/public/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html new file mode 100644 index 00000000..4215595f --- /dev/null +++ b/packages/tempo/public/v4/doc/5-architecture-and-internals/soft_freeze_strategy.html @@ -0,0 +1,90 @@ + + + + + + Soft Freeze Strategy | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Soft Freeze Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Soft Freeze is a design pattern used in the Tempo library to balance Public Immutability with Internal Extensibility. It ensures that shared registries (like NUMBER, FORMAT, or DURATION) are read-only for users while remaining mutable for internal library features like plugin and runtime updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Problem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Standard JavaScript Object.freeze() is a "Hard Freeze":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pros: Guaranteed immutability; prevents accidental state corruption.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cons: Impossible to extend. Once frozen, even the library itself cannot add new formats or number-words (e.g., during plugin registration or configuration via Tempo.use()).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    An unfrozen object is even riskier:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Risk: A user could accidentally write NUMBER['one'] = 'two', which would break the library globally for all instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Solution: Soft Freeze ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Soft Freeze uses a Read-Only Proxy wrapped around a Mutable Target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Proxy (Public Shield) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Proxy traps all mutation attempts (set, deleteProperty, defineProperty) and returns false. This makes the object look and feel like a frozen object to the public API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Target (Internal Source of Truth) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The underlying object remains mutable. It is NOT passed through Object.freeze(). This allows the library to perform controlled mutations when explicitly requested (e.g., during plugin registration).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Access Control ($Target Symbol) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library uses a private Symbol called $Target. Only code with access to this symbol can "unwrap" the proxy to access the mutable underlying object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Implementation Details ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    proxy.library.ts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The core logic resides in proxify, which now supports an optional lock parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hard Freeze (frozen=true, lock=true): Both the proxy and the target are immutable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Soft Freeze (frozen=true, lock=false): The proxy is read-only, but the target stays mutable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export function proxify<T extends object>(target: T, frozen = true, lock = frozen) {
+    const tgt = (target as any)[$Target] ?? target;         // unwrap proxy
+
+    // Hard Freeze: prevent all mutation to the target
+    if (lock) secure(tgt); 
+
+    return new Proxy(tgt, {
+        set: (_, key, val) => {
+            // Soft Freeze: Proxy blocks mutation, but target stays mutable
+            return frozen ? false : Reflect.set(tgt, key, val);
+        },
+        deleteProperty: (_, key) => {
+            return frozen ? false : Reflect.deleteProperty(tgt, key);
+        },
+        // ... other traps
+    });
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enumerate.library.ts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The enumify utility uses Soft Freeze by default for registries that are intended to be extensible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export function enumify(list, frozen = false) {
+    const target = Object.create(proto, descriptors);
+    
+    // By defaulting to frozen=false, we create a Soft Freeze (proxy is frozen, target is not locked).
+    // This allows extensible library registries to be safely updated via the private symbol.
+    return proxify(target, true, frozen); 
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Bulletproof Public API: Users cannot accidentally overwrite library constants.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Library Extensibility: A plugin can add new data to registries at runtime without bypasses or 'hacks'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Safe Global Discovery: External discovery objects (via Symbol.for('$Tempo')) can extend the library with new aliases but are prevented from overwriting core keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Internal State Integrity: Centralized STATE objects are protected from direct access while providing a single source of truth.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Transparent Experience: The object behaves like a POJO (Plain Old JavaScript Object) in the debugger and typical usage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The "Safe Merge" Rule ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To prevent a global discovery object from "trashing" the registry, the library implements a Safe Merge rule for all shared states.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When merging external data (discovery or plugin):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Additive Only: New keys are added.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Root Protection: Core building blocks (like NUMBER['one'] or FORMAT['iso']) are protected from being overwritten.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This ensures that while the library is extensible, its fundamental logic remains deterministic and secure across all environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.1.2 Update: The Soft Freeze is now tightly integrated with the Diagnostic Engine. Internal state updates bypass the Proxy using a private Symbol, allowing the engine to remain "Silent" while performing complex transactional updates during the discovery phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/5-architecture-and-internals/tempo.benchmarks.html b/packages/tempo/public/v4/doc/5-architecture-and-internals/tempo.benchmarks.html new file mode 100644 index 00000000..f5070258 --- /dev/null +++ b/packages/tempo/public/v4/doc/5-architecture-and-internals/tempo.benchmarks.html @@ -0,0 +1,82 @@ + + + + + + 🚀 Tempo Performance Benchmarks | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Tempo Performance Benchmarks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure high performance in mass-instantiation scenarios, Tempo implements a "Zero-Cost Constructor" architecture using prototype shadowing and lazy delegation. This document outlines the benchmark results for these optimizations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Summary of Timings ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timings were captured over 1,000 iterations to measure micro-overhead and compare different instantiation strategies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MethodTotal Timeµs / opNotes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Default (Lazy Proxy)523.14ms523.14µsCurrent O(1) constructor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Eager Simulation1394.51ms1394.51µs~2.7x slower (simulating pre-refactor impact).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fast-Fail @sync359.04ms359.04µsRejected instantly by the Master Guard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object.create Baseline0.22ms0.22µsRaw JS overhead for comparison.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Architectural Impact ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Proxy-Delegator Delegation (O(1)) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By using a Proxy-Delegator pattern, the constructor returns near-instantly without populating the formatting (fmt) or Term (term) objects. These registries are only discovered and memoized on the first property access.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gain: ~65% reduction in instantiation overhead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.1.2 Update: The Scan-and-Consume guard further stabilizes the "Zero-Cost Constructor" by ensuring that even with massive plugin lists, the entry-point remains O(1).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. The Master Guard (Fast-Fail) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The dynamic Master Guard acts as a rapid scan-and-consume gatekeeper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Efficiency: Invalid inputs are rapidly rejected via a fast greedy scan, bounding failure costs tightly to string length.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance: Validating a string against the guard is ~30% faster than a full parsing cycle, even for simple ISO strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Benchmark Methodology ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The benchmark script used performance.now() within a Vitest environment to ensure accurate module resolution and test environment isolation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Lazy Creation: Creates a new Tempo('2024-05-20') without accessing any properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Eager Simulation: Creates a new Tempo() and manually triggers discovery on 5 core properties to simulate O(N) initialization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Invalid Parse: Passes a string that fails the Master Guard (e.g., includes emojis or exotic symbols) to measure rejection speed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These benchmarks represent the library's performance under Node.js v22+. Results may vary based on the JS engine (V8, JavaScriptCore, etc.) but the O(1) complexity remains constant.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈 Self-Service Benchmark Module ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a built-in BenchmarkModule to allow developers to prove the performance ROI in their own exact environment (e.g. comparing Node.js memory metrics against Browser DOM performance).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This module is completely decoupled from the core to keep the bundle light, but accepts your specific configured Tempo instance to give accurate results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Usage ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+import { BenchmarkModule } from '@magmacomputing/tempo/module/benchmark';
+
+// 1. Configure your Tempo instance (e.g. plugins, timezone, etc)
+Tempo.init({ timeZone: 'America/New_York' });
+
+// 2. Run the benchmark against your datasets
+const results = BenchmarkModule.run(Tempo, {
+  data: ['2026-05-20', '2026-05-21', 'Invalid-Pizza-String'], // production datasets
+  iterations: 100, // stress-test count
+  baseline: true,  // compare against native `new Date()`
+  modes: ['auto', 'defer']
+});
+
+console.table(results);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Metrics Collected ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The BenchmarkModule is platform-aware. Using the internal getContext() utility, it tracks:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • totalTimeMs: Total elapsed time using high-resolution timers (performance.now()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • microSecPerOp: The average number of microseconds (µs) taken per operation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • successRate: The percentage of strings that successfully resolved to a valid date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • heapUsedDeltaMb: (Node.js Only) The change in memory allocation to measure Garbage Collection overhead and memory safety.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Indicative Benchmark Results ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When evaluated against a mixed dataset (Strict ISO, US Localized, Timestamps, and Garbage strings) over 3,500 operations in Node.js (Vitest), the BenchmarkModule yields the following performance profiles:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Strategyµs / OpSuccess RateMemory OverheadNotes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Date0.18 µs57.1%0.39 MBRaw C++ speed, but fails on localized strings (e.g., 10/31/2026 11:59 PM).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Auto)778.8 µs71.4%108.84 MB~0.77ms: Fully parses US localized strings and timestamps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Defer)704.7 µs71.4%-36.27 MB~0.70ms: Noticeably faster, reduced Garbage Collection pressure.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo (Strict)700.7 µs71.4%26.10 MB~0.70ms: Fastest mode; bypasses parsing fallback attempts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Key Takeaways ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Sub-Millisecond Rich Parsing: While native Date has raw native engine speed (0.18 µs), it sacrifices reliability and formatting, failing entirely on localized formats like 10/31/2026. Tempo achieves a robust 71% success rate while still maintaining blazing fast sub-millisecond (~0.7ms) parsing speeds! In real-world terms, processing 100 complex localized dates on a page will only take 70 milliseconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Defer Mode is Highly Optimized: Looking at the memory overhead (heapUsedDeltaMb), defer mode actually resulted in a negative memory delta (-36.27 MB). Note that this is simply an observed lower end-of-run heap measurement due to incidental GC timing, but demonstrates the inherently low memory pressure of deferred initialization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Adapt This Test: The runner script used to generate these results is available in the bench/runner.test.ts directory. You can use it as a scaffold to test Tempo against your own unique datasets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/6-utility-library/tempo.enumerators.html b/packages/tempo/public/v4/doc/6-utility-library/tempo.enumerators.html new file mode 100644 index 00000000..51aed855 --- /dev/null +++ b/packages/tempo/public/v4/doc/6-utility-library/tempo.enumerators.html @@ -0,0 +1,127 @@ + + + + + + Tempo Enumerators (enumify) | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Enumerators (enumify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a custom enumify utility to define enumerations rather than relying on native TypeScript enums. This gives consumers of the library access to a robust set of iteration and lookup methods out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains how they are defined, how you use them as a consumer of the Tempo library, and why this design pattern was chosen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. How Tempo Enums are Defined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's core enumerators (like Weekdays, Months, Seasons) are built using the exported enumify function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Under the hood, enumify returns a Proxy-wrapped, frozen object based on a null-prototype:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Null-Prototype Root (Object.create(null)): The base prototype is completely detached from Object.prototype. Standard prototype properties like toString, valueOf, constructor, or hasOwnProperty do not exist on the object, eliminating key collision and prototype pollution risks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Strict Runtime Immutability: The object is locked down with Object.freeze() and wrapped in a read-only Proxy that rejects writes, deletions, or runtime property additions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Prototypal Extensibility: Even though each enum is deeply frozen and immutable, enums remain extensible through JavaScript prototypal inheritance via .extend().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array-based Definitions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you pass an array to enumify, the strings become the keys, and the values are their zero-indexed positions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const WEEKDAY = enumify(['All', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']);
+// Result: { All: 0, Mon: 1, Tue: 2 ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object-based Definitions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you need specific string-to-string mappings, you pass an object literal directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export const SEASON = enumify({ Summer: 'summer', Autumn: 'autumn', Winter: 'winter', Spring: 'spring' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Inference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    After defining the enumify object, simple TypeScript helper aliases pull out the types so you can use them reliably in function signatures:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    export type SEASON = ValueOf<typeof SEASON>; // Type: 'summer' | 'autumn' | 'winter' | 'spring'
+export type Season = KeyOf<typeof SEASON>;   // Type: 'Summer' | 'Autumn' | 'Winter' | 'Spring'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The above types allow for the use of Season and SEASON as type arguments, providing type safety for both the keys and values of the enum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is generally recommended to use the values (lowercase) as type arguments, as they are used as the actual values in the enumify object. This allows for easier use of the enumify methods, which operate on the values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: TypeScript provides automatic typing for native enums, but it is not the case with enumify.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Using Enums Outside of Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For consumers of the library, these enumerations are exposed via public package exports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As static properties on Tempo (convenient in app code already using Tempo)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As the default export from @magmacomputing/tempo/enums
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • As individual named exports from @magmacomputing/tempo/enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Avoid referencing internal source files (such as tempo.index.ts) in application code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Static Properties on Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can access all enums via the unified Tempo.enums getter, or use top-level getters for core calendar and direction enums (WEEKDAY, WEEKDAYS, MONTH, MONTHS, DURATION, DURATIONS, SEASON, COMPASS):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+// Core domain enums directly on Tempo:
+const direction = Tempo.COMPASS.North; // 'north'
+const monthIndex = Tempo.MONTH.Feb;    // 2 (since 'All' was index 0)
+
+// All enums via the unified Tempo.enums accessor:
+const first = Tempo.enums.ORDINAL.first; // 1
+const dateFormat = Tempo.enums.FORMAT.date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Canonical Namespace Import ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Import the full enums object via the default export:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import enums from '@magmacomputing/tempo/enums';
+
+const { COMPASS, MONTH } = enums;
+const direction = COMPASS.North;
+const monthIndex = MONTH.Feb;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Direct Named Import ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Import individual enumerators directly:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { COMPASS, MONTH, WEEKDAY, ORDINAL, Enum } from '@magmacomputing/tempo/enums';
+
+console.log('compass keys: ', Enum.keys(COMPASS));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Static-First Reflection Suite (Enum.*) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In modern Tempo, enum reflection is performed using the Enum.* static helper suite, mirroring ECMAScript's standard Object.hasOwn and Object.keys:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Enum } from '@magmacomputing/tempo/enums';
+// or: import { Enum } from '@magmacomputing/tempo/library';
+
+// Iterating over properties (Type-safe & collision-proof)
+const days = Enum.keys(Tempo.WEEKDAY);                  // readonly ('All' | 'Mon' | 'Tue' | ...)[]
+const values = Enum.values(Tempo.WEEKDAY);              // readonly (0 | 1 | 2 | ...)[]
+const entries = Enum.entries(Tempo.WEEKDAY);            // readonly (readonly [key, value])[]
+const count = Enum.count(Tempo.WEEKDAY);                // 8
+
+// Validation
+if (Enum.has(Tempo.SEASON, 'Spring')) { ... }           // true if 'Spring' is a key
+if (Enum.hasOwn(Tempo.SEASON, 'Spring')) { ... }        // true if 'Spring' is a direct own key
+if (Enum.includes(Tempo.SEASON, 'spring')) { ... }      // true if 'spring' is a value
+
+// Reverse lookups! Get the Key Name from the Value
+const keyName = Enum.keyOf(Tempo.MONTH, 2);             // 'Feb'
+
+// Inversion & Aliasing support (last-key-wins)
+const byCode = Enum.invert(Tempo.SEASON);               // { summer: 'Summer', ... }
+
+// Native iteration
+for (const [key, val] of Tempo.WEEKDAY) {
+  console.log(key, val);
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Creating Custom Enums ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can utilize the same enumify engine for your own application logic by importing it from the library subpath. This is particularly useful for maintaining consistent data patterns and iteration capabilities throughout your project.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Basic Custom Enum ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { enumify, Enum } from '@magmacomputing/tempo/library';
+
+// 1. Define your Enum
+export const STATUS = enumify(['Pending', 'Active', 'Resolved', 'Archived']);
+
+// 2. Use the static reflection helpers
+const allKeys = Enum.keys(STATUS);           // ['Pending', 'Active', 'Resolved', 'Archived']
+const isActive = Enum.has(STATUS, 'Active'); // true
+const value = STATUS.Resolved;               // 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extending Enums via Prototypal Inheritance (Enum.extend()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A standout capability of enumify is that enums are immutable yet extendable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Developers typically assume that freezing an object (Object.freeze) prevents adding fields. However, enumify achieves non-destructive extensibility through JavaScript prototype delegation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { enumify, Enum } from '@magmacomputing/tempo/library';
+
+// Base enum (frozen and immutable)
+export const BASE_ROLE = enumify(['Viewer', 'Editor']);
+
+// Extend with additional roles
+export const ADMIN_ROLE = Enum.extend(BASE_ROLE, ['Admin', 'SuperAdmin']);
+
+console.log(Enum.keys(ADMIN_ROLE));             // ['Viewer', 'Editor', 'Admin', 'SuperAdmin']
+console.log(Enum.count(ADMIN_ROLE));            // 4
+console.log(Enum.has(ADMIN_ROLE, 'Viewer'));    // true (inherited from BASE_ROLE)
+console.log(Enum.hasOwn(ADMIN_ROLE, 'Viewer')); // false (inherited, not an own property)
+console.log(Enum.hasOwn(ADMIN_ROLE, 'Admin'));  // true (direct own property on ADMIN_ROLE)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    How Prototypal Inheritance Works Here: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero Mutation on Parent: BASE_ROLE remains untouched and completely immutable. Existing code relying on BASE_ROLE is guaranteed never to see unwanted keys.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Delegation (Object.create(this)): Calling extend() creates a new frozen child enum whose prototype is the parent enum. The child inherits all parent keys, values, and methods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stealth Traversal: Methods like .keys(), .values(), .entries(), .count(), and even JSON.stringify() seamlessly traverse the prototype chain to treat the extended enum as a unified collection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Key Shadowing: Child enums can cleanly shadow inherited keys with new values without polluting the ancestor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-tier Hierarchies: Enums can be extended multiple times (BASE -> TENANT -> USER) while keeping each level individually sealed and safe.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. How They Are Used Inside Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internally, the Tempo logic relies heavily on these enumerators. This gives the parsing and formatting engines guaranteed type-safety and robust lookup dictionaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For instance, the .format() logic can map tokens efficiently, and parser configuration (e.g., regex Snippet mapping) loops through them safely without manually declaring Object.keys() combinations everywhere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The overarching design ensures the library stays strongly typed, internally consistent, and protected against accidental runtime mutation via Object.freeze().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. enumify vs. TypeScript enum (The Trade-Offs) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TypeScript's native enum is one of the few TS features that generates structural runtime JavaScript, and it has known friction points in the JavaScript community.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using enumify is a deliberate choice for high-quality library design.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Wins for enumify ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich API (Methods): Native TS enums are plain JavaScript objects at runtime. To get the keys, you must write Object.keys(MyEnum). The enumify wrapper gives developers .keys(), .values(), .has(), .includes(), .map(), .filter(), and native iteration ([Symbol.iterator]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Namespace (Null-Prototype): Native enums and plain objects inherit from Object.prototype, creating potential collisions with keys like toString, valueOf, or constructor. enumify uses a null prototype, keeping the namespace completely unpolluted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototypal Extensibility (.extend()): TypeScript native enums cannot be extended, inherited, or composed. enumify allows enums to inherit from base enums cleanly without mutating the parent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Predictable Serialization: TypeScript numeric enums generate strange "reverse mappings" in compiled JS (e.g., { 0: "Up", "Up": 0 }). This makes iterating over them or stringifying them to JSON very messy. enumify objects serialize cleanly and safely.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutability: enumify freezes the object at runtime (Object.freeze) and seals it with a Proxy. Standard TS enums can technically be mutated at runtime by malicious or sloppy ES code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • NodeJS/ESM Compatibility: Standard TS enums can cause friction with isolated module compilers (like Vite or esbuild) or when importing into vanilla JS. enumify generates 100% standard ES2015 JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Losses (Trade-offs) for enumify ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Slightly More Boilerplate Definition: Defining an enumify dictionary takes 2-3 lines of code (exporting the const, then exporting the type alias). TS native enums do both (value and type) as part of the enum keyword.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Missing Nominal Typing: TypeScript native enums offer "nominal" typing (e.g., enum A { X } cannot be passed to a function expecting enum B { X } even if the keys/structures match). enumify relies on structural typing (union of literals), meaning TypeScript allows passing the raw string 'spring' into a function rather than forcing you to strictly use Tempo.SEASON.Spring.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Slight Runtime Overhead: Instantiating the proxy/prototype wrapper and freezing it adds a microscopic runtime cost compared to evaluating a plain object literal, though parsing the library is typically a one-time engine cost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • More Verbose Setup: TypeScript's enum can use auto-incrementing numeric values, but enumify requires explicit values for each key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/6-utility-library/tempo.library.html b/packages/tempo/public/v4/doc/6-utility-library/tempo.library.html new file mode 100644 index 00000000..fe8343a3 --- /dev/null +++ b/packages/tempo/public/v4/doc/6-utility-library/tempo.library.html @@ -0,0 +1,80 @@ + + + + + + Tempo Library Functionality | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Library

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Library Functionality ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While Tempo is primarily a Date-Time engine, it relies on several custom utilities under the hood to handle data structures, deep cloning, and serialization safely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These utilities are robust enough that they are exported as public API methods for use within your own application logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This document serves as an index summarizing these core library features.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Enumerators (enumify, Enum.*) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses a custom utility called enumify to create heavily-protected, iterable enum-like objects instead of relying on native TypeScript enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This allows for structural typing, easy type-safe iteration via static reflection helpers (Enum.keys(), Enum.values()), and runtime safety without the overhead or compilation quirks of standard TS Enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It is heavily used internally for concepts like Weekdays, Months, Compass cardinal points and Meteorological Seasons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Enumerators Guide for details on definition, methods, and a comparison with native enums.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Serialization (stringify, objectify, cloneify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native JSON methods (JSON.stringify and JSON.parse) often fail or destructively mutate rich JavaScript data types like BigInt, Map, Set, Symbol, and Date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To ensure safe data persistence across localStorage, IndexedDB, or network boundaries, Tempo implements its own serialization suite:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • stringify(): Safely serializes rich objects, protecting circular references and complex types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • objectify(): Safely reconstructs objects previously serialized by stringify().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cloneify(): Performs a deep-copy of an object, preserving all rich data types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Serializers Guide for detailed usage, benefits, and trade-offs compared to native JSON methods or structuredClone.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. High-Performance Push/Pull Streams (Reactive) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes Reactive<T>, a bidirectional asynchronous stream primitive that unifies push-based event listeners and pull-based async iterators (for await) with O(1) dispatch, backpressure buffering, and explicit resource management (using).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Push/Pull Duality: Seamlessly switch between event subscribers (stream.on('data', cb)) and async pull iteration (await stream.pull(), for await).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Disposable Subscriptions: stream.on() returns a Reactive.Subscription implementing TC39 Disposable (using sub = stream.on(...)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stream Truncation: Easily gate or bound streams via stream.until(signal | promise | otherStream).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Leak-Proof Finalization: Backed by Finalizer to ensure unclosed abandoned streams are safely reclaimed by the garbage collector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Reactive Streams Guide for detailed usage, patterns, and state inspection.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Deferred Promises (Pledge) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo provides a specialized wrapper around Promise.withResolvers() called Pledge. It is designed to simplify modern asynchronous patterns where you need to manage a promise's lifecycle externally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Key Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State Tracking: Transparent access to isPending, isResolved, and isRejected flags.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Lifecycle Hooks: Support for onResolve, onReject, and onSettle callbacks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Shell: Once created, the Pledge instance is frozen, ensuring the promise reference cannot be swapped.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resource Management: Implements Symbol.dispose to automatically reject pending promises when they go out of scope, preventing deadlocks or memory leaks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    👉 Read the full Pledge Guide for advanced usage with callbacks, debugging tags, and lifecycle management.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. GC Safety & Memory Management (WeakCache, Finalizer) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For performance-critical and memory-sensitive architectures, Tempo exports two key garbage-collection primitives:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • WeakCache<K, V>: High-performance, GC-cooperative memoization cache that allows unreferenced keys or values to be collected without memory retention.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Finalizer: Safe abstraction over FinalizationRegistry to register automatic teardown callbacks for timers, streams, or proxies without pinning object references.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Functional Evaluation (evaluate, dynamicProxy) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo exports functional evaluation utilities for resolving static values, lazy suppliers, and dynamic object proxies:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluate(...values): Synchronously resolves candidate values or zero-argument supplier functions (() => T) in order, returning the first defined result (lazy coalesce with short-circuiting).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluateAsync(...values): Asynchronously resolves static values, sync/async suppliers, or Promises (() => Promise<T> | T) in order with short-circuiting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • evaluateConfig(config) / evaluateConfigAsync(config): Resolves Evaluable property suppliers on the top-level properties of a configuration dictionary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • dynamicProxy(target): Wraps a target object with dynamic property traps that evaluate function-valued properties lazily on-access.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evaluable<T> / AsyncEvaluable<T>: TypeScript utility types representing values that can be provided directly or supplied lazily via functions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { evaluate, evaluateAsync, dynamicProxy } from '@magmacomputing/tempo/library';
+
+// Synchronous supplier evaluation with lazy cascading fallback (short-circuited)
+const tz = evaluate(options.timeZone, () => process.env.TZ, 'UTC');
+
+// Asynchronous supplier evaluation (e.g. secret vault / remote config)
+const apiKey = await evaluateAsync(provider.key, async () => await vault.getKey('openai'));
+
+// Dynamic proxy with lazy on-access getters
+const dynamicSettings = dynamicProxy({
+  timeout: 5000,
+  token: () => getActiveToken()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Class Decorators (@Immutable, @Serializable, @Static) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo uses lightweight TypeScript class decorators internally to enforce immutability (@Immutable), register custom serialization handlers (@Serializable), and prevent instantiation of static-only classes (@Static).


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8. Exhaustive API Reference ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These are isolated, standalone utility functions and classes developed internally to support our various applications. They are entirely free to use and are documented here as a convenience reference for our users.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While some of these utilities may be used internally by the Tempo library, many are completely independent (such as the browser and server-specific functions). They do not declare external dependencies, keeping them lightweight and portable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The library is split into domain-specific modules:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Browser: Functions and classes that rely on browser APIs (e.g., window, localStorage, Geolocation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Server: Node.js specific utilities (e.g., file system access, server-side JWT decoding).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Common: Runtime-agnostic utilities shared across all environments (evaluation, assertion, coercion, cipher, json, calendar, recurrence, proxy).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can browse the full API reference in the sidebar below this section.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/6-utility-library/tempo.pledge.html b/packages/tempo/public/v4/doc/6-utility-library/tempo.pledge.html new file mode 100644 index 00000000..5cf90142 --- /dev/null +++ b/packages/tempo/public/v4/doc/6-utility-library/tempo.pledge.html @@ -0,0 +1,102 @@ + + + + + + Pledge: Advanced Asynchronous Patterns | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge: Advanced Asynchronous Patterns ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Pledge utility is a specialized wrapper around Promise.withResolvers() designed for modern asynchronous workflows where promise management needs to be handled externally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Basic Lifecycle ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Pledge provides direct access to its state and resolution methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Pledge } from '@magmacomputing/tempo/library';
+
+// 1. Instantiate
+const p = new Pledge<string>('DataFetch');
+
+// 2. Resolve or Reject externally
+p.resolve('Success!'); 
+// or p.reject(new Error('Failed'));
+
+// 3. Await the promise anywhere
+const result = await p.promise;
+
+// Note: resolve/reject are idempotent. Calling them on an already-settled 
+// `Pledge` is safe; it will log a warning but won't change the state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Then-ability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Pledge is a first-class "Then-able". You don't need to access .promise to chain your logic; you can call .then() and .catch() directly on the Pledge instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const p = new Pledge('NaturalAction');
+
+p.then(val => console.log(val))
+ .catch(err => console.error(err));
+
+p.resolve('Victory!');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Advanced Callbacks ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can register lifecycle hooks during instantiation. These are useful for cross-cutting concerns like logging or resource cleanup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const p = new Pledge<string>({
+  tag: 'Task-123',
+  onResolve: (val) => console.log('Resolved with:', val),
+  onReject:  (err) => console.error('Rejected with:', err),
+  onSettle:  () =>    console.log('Pledge settled.')
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onResolve: Triggered when p.resolve() is called.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onReject: Triggered when p.reject() is called.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onSettle: Triggered regardless of outcome (analogous to finally).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Debugging with Tags ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each Pledge can be assigned a tag string. This tag is included in logs and error messages if the debug or catch flags are set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Enable debug logging for this instance
+const p = new Pledge({ tag: 'DatabaseQuery', debug: 5 });
+
+// If p is rejected, the tag will be included in the trace
+p.reject('Timeout');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Global Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can set global defaults for all future Pledge instances using Pledge.init().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge.init({
+  debug: 5,
+  onSettle: () => GlobalSpinner.stop()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To reset to library defaults:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge.init();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Automatic Cleanup (Symbol.dispose) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pledge implements the Disposable interface. You can automatically reject a pending pledge at the end of a scope by declaring it with the using keyword, or by explicitly invoking [Symbol.dispose](). Ordinary block exit (without using) or garbage collection will not trigger disposal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using p = new Pledge('ScopedOperation');
+  // if p is not resolved/rejected by the end of this block, 
+  // it is automatically rejected with "Pledge disposed".
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. State Accessors ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.state: Returns 'pending', 'resolved', or 'rejected'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isPending: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isResolved: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isRejected: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.isSettled: boolean (resolved or rejected)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • p.status: Returns a snapshot of the full status object (tag, state, settled value, error).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/6-utility-library/tempo.reactive.html b/packages/tempo/public/v4/doc/6-utility-library/tempo.reactive.html new file mode 100644 index 00000000..8512cf0e --- /dev/null +++ b/packages/tempo/public/v4/doc/6-utility-library/tempo.reactive.html @@ -0,0 +1,122 @@ + + + + + + Reactive: High-Performance Push/Pull Streams | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive: High-Performance Push/Pull Streams ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> is a modern, lightweight asynchronous stream primitive built into the Tempo Utility Library. It bridges the gap between push-based event listeners and pull-based async iterators without the overhead of heavy third-party reactive extensions.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Core Concepts: Push/Pull Duality ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unlike standard EventEmitter (push-only) or AsyncGenerator (pull-only), Reactive<T> operates seamlessly in both directions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Producer Push (stream.push(value)): Dispatches the next value to a single pending pull waiter or buffers for future consumers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Producer Cast (stream.cast(value)): Multicasts the value to all concurrent pull waiters and push listeners simultaneously (fan-out).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Pull (await stream.pull()): Pulls the next available value directly as Promise<T | undefined>, eliminating { value, done } unwrapping boilerplate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Push (stream.on('data', listener)): Subscribes callback listeners for event-driven workflows.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consumer Iteration (for await (const item of stream)): Native ES2018 iteration with backpressure buffering and zero lost items.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Reactive } from '@magmacomputing/tempo/library';
+
+// Create a typed reactive stream
+const stream = new Reactive<string>({ tag: 'TaskStream' });
+
+// Producer pushes data
+stream.push('First Event');
+stream.cast('Broadcast Event'); // Casts to all active pull waiters and listeners
+
+// Consumer pulls data directly
+const first = await stream.pull();  // 'First Event'
+const second = await stream.pull(); // 'Broadcast Event'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Push-Based Event Subscriptions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Register event listeners using familiar on(), once(), and off() methods.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Register data listener with early-stop capability
+stream.on('data', (item, stop) => {
+  console.log('Received:', item);
+  if (item === 'HALT') stop(); // Completes the stream
+});
+
+// Register error or completion listeners
+stream.on('error', (err) => console.error('Stream error:', err));
+stream.on('end', () => console.log('Stream completed'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deterministic Disposal with using ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stream.on() returns a disposable Reactive.Subscription object conforming to the TC39 Explicit Resource Management standard:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using sub = stream.on('data', (data) => {
+    console.log('Scoped data:', data);
+  });
+  
+  // When execution leaves this scope, sub[Symbol.dispose]() is called automatically
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can also unsubscribe manually at any time via sub.unsubscribe() or sub[Symbol.dispose]().


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Pull-Based Async Iteration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> implements AsyncIterable<T>, making it natively consumable with for await:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    async function processEvents(stream: Reactive<number>) {
+  for await (const value of stream) {
+    console.log('Processing:', value);
+  }
+  console.log('All events processed!');
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Stream Truncation with .until() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Easily terminate or gate a stream using an AbortSignal, a Promise, or another Reactive stream:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const controller = new AbortController();
+const boundedStream = stream.until(controller.signal);
+
+// Or bound by another reactive event:
+const stopper = new Reactive<void>();
+const gated = stream.until(stopper);
+
+// When stopper.push() or controller.abort() fires, gated stream cleanly completes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Resource Management & GC Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Reactive<T> implements both Disposable and AsyncDisposable:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+  using managedStream = new Reactive<number>();
+  // Producer and consumer operations...
+  // Stream is automatically completed upon block exit
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Automatic Finalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Backed by Finalizer, any unclosed reactive stream that is dropped and garbage-collected will automatically settle pending promise waiters and tear down internal buffers, preventing orphaned promises and memory leaks.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Static Factory Methods ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Convert existing collections, promises, or async iterables into reactive streams using Reactive.from():

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // From an array
+const streamFromArray = Reactive.from(['alpha', 'beta', 'gamma']);
+
+// From an async iterable or Promise
+const streamFromPromise = Reactive.from(fetchDataAsync());

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7. Stream State Inspection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Inspect stream statistics and runtime status via stream.state:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    console.log(stream.state);
+// {
+//   tag: 'TaskStream',
+//   active: true,
+//   completed: false,
+//   emitted: 42,
+//   subscribers: 2,
+//   queued: 0,
+//   buffered: 0
+// }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/6-utility-library/tempo.serializers.html b/packages/tempo/public/v4/doc/6-utility-library/tempo.serializers.html new file mode 100644 index 00000000..5b55df09 --- /dev/null +++ b/packages/tempo/public/v4/doc/6-utility-library/tempo.serializers.html @@ -0,0 +1,82 @@ + + + + + + Tempo Serializers (stringify, objectify, cloneify) | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Serializers (stringify, objectify, cloneify) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo includes a custom serialization suite designed to succeed where standard native JSON methods fail. Complex JavaScript types like Map, Set, BigInt, Symbol, and Date routinely break or mangle when passed through standard JSON.stringify().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This guide explains what the serialization tools do, their benefits over native methods, how they are used inside the library, and their trade-offs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The Core Functions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The serializers are heavily utilized under the hood but are also exposed for robust data handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stringify(obj) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Serializes variables, primitives, and rich objects into string-safe representations. Unlike standard JSON, it detects complex types and translates them into identifiable single key:value structures (e.g., {"$BigInt":"123"}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { stringify } from '@magmacomputing/tempo/library';
+
+const richData = new Map([
+  ['time', new Date()],
+  ['id', Symbol.for('session')],
+  ['count', 100n]
+]);
+
+const safeString = stringify(richData);
+// Safely serialized, preserving Map, Date, Symbol, and BigInt topologies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    objectify(str, sentinel?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The inverse of stringify. It rebuilds an object from its stringified representation, parsing the specialized { $Type: value } signatures back into their native JavaScript object instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { objectify } from '@magmacomputing/tempo/library';
+
+const restored = objectify(safeString);
+// restored instance is a true Map, containing true Date, Symbol, and BigInt primitives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cloneify(obj, sentinel?) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a deep-copy of an object by piping it through stringify and immediately back through objectify. This results in a detached, deeply cloned object that retains its rich types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { cloneify } from '@magmacomputing/tempo/library';
+
+const detachedCopy = cloneify(richData);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Both objectify and cloneify accept an optional sentinel function, which allows you to dynamically replace undefined values during the rebuild phase.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Selling the Benefits ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Why not just use JSON.parse(JSON.stringify(obj)) or structuredClone()?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Preservation of Rich Types: JSON.stringify() instantly throws a TypeError if it encounters a BigInt. It silently strips undefined, reduces Date to a dumb string, and mangles Set/Map into empty {} objects. Tempo's stringify preserves all of these.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fallback for structuredClone: While structuredClone is great, it is not universally available in older environments and throws an error if it encounters functions. cloneify gives you a guaranteed deep-clone that resurrects your precise types reliably.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Safe Encoding: Strings are natively URI-encoded for control characters, ensuring safe stashing in fragile WebStorage or cache environments without injection/corruption vulnerabilities.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Class Registration: User-defined classes can be resurrected after stringification if they are decorated with Tempo's @Serialize() registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. How They Are Used Inside Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internally, these robust guarantees allow Tempo to safely toss memory-heavy or complex objects around asynchronously:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Caching & Storage (storage.library.ts): Used to safely serialize and deserialize internal state and user settings to localStorage, sessionStorage, or NodeJS process.env.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cryptography (cipher.class.ts): Complex payloads are reliably stringified prior to hashing and encryption, guaranteeing that decrypting the payload yields the exact original JavaScript topology.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deep Cloning Templates (term.season.ts, etc): Core plugins define fixed objects or arrays (like meteorological season date boundaries). cloneify is used extensively to serve detached copies of those arrays to standard operations, ensuring that the original base configuration can never be accidentally mutated by reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Drawbacks (Over JSON Methods) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance / Execution Speed: Operations that map, inspect, and safely cast specialized strings are slower than the highly-optimized C++ engine driving the native JSON namespace. If you only have raw text and numbers, standard JSON.stringify will be faster.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Payload Size: Because unsupported types are wrapped in identifier signatures (e.g., Set -> {"$Set":"[1,2,3]"}), the resulting string weight can be slightly heavier than stripped-down raw JSON.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unsupported Memory Types: Just like JSON, stringify cannot safely serialize transient memory references. Standard JS Function, AsyncFunction, WeakMap, WeakSet, and WeakRef are ignored/bypassed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/7-ecosystem/comparison.html b/packages/tempo/public/v4/doc/7-ecosystem/comparison.html new file mode 100644 index 00000000..d3abcb39 --- /dev/null +++ b/packages/tempo/public/v4/doc/7-ecosystem/comparison.html @@ -0,0 +1,68 @@ + + + + + + 🥊 Tempo vs. The Competition | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🥊 Tempo vs. The Competition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are choosing a date library today, you are likely looking at Day.js, Luxon, or date-fns. While these are excellent tools, they were all built for the legacy Date era.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is the first premium wrapper built specifically for the Temporal API (Stage 4), giving it unique advantages that legacy libraries simply cannot match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    At a Glance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FeatureTempo 💎Raw Temporal APIDay.js / MomentLuxondate-fns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FoundationNative TemporalNative TemporalLegacy DateLegacy Intl + DateLegacy Date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PrecisionNanosecondsNanosecondsMillisecondsMillisecondsMilliseconds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ParsingHuman-CentricStrict ISO OnlyStrict / PluginStrictModular / Strict
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FormattingSmart Tokens & GettersVerbose Intl OnlyToken-Based (Moment style)Token-Based (Unicode)Token-Based (Unicode helper)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business LogicTerms SystemManual MathManual MathManual MathManual Math
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time ZonesFirst-ClassFirst-ClassPlugin-basedBuilt-inSeparate Lib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Future-Proof100% (Native)100% (Native)Maintenance ModePlanned SunsetTransitioning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    💎 Why Tempo Wins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. The "Terms" Engine (Business Intelligence) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Most libraries stop at "adding 2 days." Tempo introduces the Terms system, allowing you to encode domain-specific logic (Fiscal Quarters, Meteorological Seasons, Academic terms, Zodiac Signs) directly into the Tempo term object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: You have to write custom utility functions and import them everywhere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Human-Centric Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Day.js and Luxon are quite strict. If your string isn't in exactly the right format, they fail. Tempo’s Snippet & Layout engine is designed to be forgiving, extensible, and human-centric, handling relative dates like "next Friday" or "Christmas" out of the box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Often requires an external library like Chrono or complex regex boilerplate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Nanosecond Precision ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Date (and thus Day.js/Luxon/date-fns) is limited to milliseconds. For high-frequency trading, scientific data, or distributed systems, this isn't enough. Tempo inherits nanosecond precision from the Temporal API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Capped at 1/1000th of a second.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Zero "Leaky Abstractions" ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When you use a legacy library, you are often fighting the weirdness of the 1995 Date object (like months being 0-indexed). Tempo is built on Temporal, which was designed from the ground up to be mathematically sound and developer-friendly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Intelligent Formatting & Shorthands ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    While native Temporal is highly precise, formatting dates for a UI in native Temporal is extremely verbose. It relies entirely on the native Intl API, requiring you to construct complex option objects or use long .toLocaleString() boilerplate just to output simple strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo solves this by offering a Smart Token Engine (using {yyyy}-{mm}-{dd} placeholders) alongside built-in, highly optimized format getters like .fmt.date, .fmt.time, or .fmt.dateTime. In addition, Tempo automatically memoizes internal formatters under the hood, delivering top-tier performance without developer boilerplate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Competition: Raw Temporal requires verbose Intl configurations; legacy libraries require large plugins or separate helper imports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Temporal Transition Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As JavaScript transitions natively to the Temporal API, the existing ecosystem is taking different paths. This presents a unique opportunity for new, Temporal-first architectures like Tempo:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Luxon: The creators have explicitly stated they plan to sunset Luxon as Temporal adoption grows, eventually becoming "a distant memory."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Day.js: Architecturally bound to the legacy Date object to maintain its <2kB size and Moment.js compatibility. It cannot evolve to support native Temporal objects and will remain a tool for legacy codebases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • date-fns: Transforming into a companion utility kit tailored around native Temporal objects (evidenced by their bridging project, date-fns/interim), while maintaining dual support for legacy Date.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Because Luxon is bowing out and Day.js cannot evolve architecturally without losing its identity, Tempo steps in as the premier, dedicated premium wrapper built specifically for the Temporal era from day one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Which should you choose? ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Day.js if: You have a legacy codebase and need a tiny <2KB patch for simple tasks, and are comfortable using a library in maintenance mode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Luxon if: You need a stable bridge for environments that don't yet support Temporal, but keep in mind it is actively planning for sunset.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose date-fns if: You have an existing codebase heavily invested in date-fns pipelines and want to leverage their transitional bridge as you migrate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose @magmacomputing/tempo-fns if: You prefer pure, tree-shakeable functional utilities designed natively for Temporal objects (and Tempo terms) without the overhead of a class-based wrapper.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Choose Tempo if: You want a premium, Temporal-first architecture that provides fluent chaining, high precision, human-centric parsing, and the ability to model complex business-date logic directly into your application.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready to start? See the Quick Start Guide →

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/7-ecosystem/extending-temporal.html b/packages/tempo/public/v4/doc/7-ecosystem/extending-temporal.html new file mode 100644 index 00000000..ff32f062 --- /dev/null +++ b/packages/tempo/public/v4/doc/7-ecosystem/extending-temporal.html @@ -0,0 +1,113 @@ + + + + + + 🤝 Extending Native Temporal | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Extending Native Temporal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORTANT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is NOT a replacement for Native Temporal. Temporal provides an excellent, mathematically sound foundation for dates in JavaScript, and Tempo is built directly on top of it. Tempo acts as a developer-friendly wrapper that eliminates boilerplate and makes common tasks effortless, while retaining the rock-solid reliability of Temporal under the hood.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To complement Temporal's explicit strictness, Tempo adds:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Flexibility: Out-of-the-box natural language parsing and intelligent formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Convenience: Extensive getters, method chaining, and zero-configuration defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configurability: Dynamic semantic aliases for resolving events and periods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extensibility: A lazy-loaded plugin architecture for domain-specific calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Here is a side-by-side comparison demonstrating how Tempo drastically reduces boilerplate for standard operations, while unlocking capabilities that are difficult to achieve with native Temporal alone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Parsing: Strict vs. Intelligent ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal only accepts strict ISO 8601 strings. If you have user input, database dumps, or human-readable dates, you have to write your own parser first. Tempo handles it out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal ❌

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+Temporal.PlainDate.from('2026/01/24');    // Throws RangeError: invalid ISO 8601 string
+Temporal.PlainDate.from('next Friday');   // Throws RangeError: invalid ISO 8601 string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo ✅

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+new Tempo('2026/01/24');                  // Parses perfectly
+new Tempo('next Friday');                 // Parses relative natural language perfectly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information on handling natural language and complex strings, read the dedicated Parsing Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Formatting: Verbose vs. Expressive Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Temporal relies on the Intl.DateTimeFormat API for formatting. While powerful for localization, it is incredibly verbose for simple, specific string outputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = Temporal.Now.plainDateISO();
+date.toLocaleString('en-GB', { day: 'numeric', month: 'short', year: 'numeric' });  // Output: "24 Jan 2026"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-24T12:00:00');
+
+// Use the format method to create custom formats, or use the pre-built getters (on the 'fmt' property)
+t.format('{dd} {mmm} {yyyy}');            // Output: "24 Jan 2026"
+t.fmt.date;                               // Output: "2026-01-24"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For comprehensive examples of localized output and custom layouts, read the dedicated Formatting Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Extensibility: Domain-Specific Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal deals strictly with standard calendar units (days, months, years). If you need to map a date to domain-specific logic (like a fiscal quarter or a meteorological season), you have to write and maintain your own math utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const date = Temporal.Now.plainDateISO();
+
+// 1. Calculate the fiscal quarter
+const month = date.month;
+const fiscalQuarter = `Q${Math.ceil(month / 3)}`; // Manual math
+
+// 2. Calculate the meteorological season (Northern Hemisphere)
+let season;
+if (month === 12 || month <= 2) season = 'Winter';
+else if (month >= 3 && month <= 5) season = 'Spring';
+else if (month >= 6 && month <= 8) season = 'Summer';
+else season = 'Autumn';
+
+// And what if you need to support the Southern Hemisphere? 
+// You have to write and maintain even more utility functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀 Tempo solves this elegantly using the Terms plugin system. Terms are lazy-loaded plugins that evaluate the current date against semantic boundaries without adding memory bloat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-24T12:00:00', { sphere: 'north' });
+
+// Built-in complex Terms via the standard plugin
+t.term.qtr; // → 'Q1' (Calculates fiscal quarter)
+t.term.szn; // → 'Winter' (Calculates meteorological season, respecting hemisphere)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information on adding your own domain-specific logic, read the dedicated Terms Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Duration Logic: Strict Math vs. Human Readable ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Calculating the difference between two dates in native Temporal is mathematically sound, but it strictly returns a Temporal.Duration object. Tempo gives you the flexibility to return a Duration object, a precise floating-point number, or a human-readable string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native Temporal 🐢

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // 1. Calculate the raw duration
+const now = Temporal.Now.plainDateISO();
+const target = Temporal.PlainDate.from('2026-12-25');
+now.until(target); // → Returns a complex Duration object
+
+// 2. Format a past date into a human-readable string (relative to a fixed point)
+const refDate = Temporal.PlainDate.from('2026-07-09');
+const pastDate = Temporal.PlainDate.from('2026-07-06');
+const diff = pastDate.until(refDate, { largestUnit: 'days' });
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+rtf.format(-Math.abs(diff.days), 'day'); // → "3 days ago"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo 🚀 Tempo understands natural language targets and provides multiple ways to measure and format the resulting elapsed time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-05-20T08:00:00');
+
+// 1. .until() returns an EDO or a precise number
+t.until('2026-12-25').duration; // → The underlying Temporal.Duration object
+t.until('2026-12-25', 'days');  // → 219
+
+// 2. .since() instantly returns human-readable relative strings
+const t2 = new Tempo('2026-07-09');
+t2.since('2026-07-06', 'days'); // → "3 days ago"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.until() returns a highly functional Extended Data Object (EDO) or a precise decimal number depending on your arguments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • t.since() leverages Intl.RelativeTimeFormat to instantly return human-readable relative strings (like "3 days ago").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For comprehensive examples of duration mathematics, intelligent balancing, and localization formatting, read the dedicated Duration Logic Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/7-ecosystem/vision.html b/packages/tempo/public/v4/doc/7-ecosystem/vision.html new file mode 100644 index 00000000..ff459f58 --- /dev/null +++ b/packages/tempo/public/v4/doc/7-ecosystem/vision.html @@ -0,0 +1,68 @@ + + + + + + The Vision for Tempo | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Vision for Tempo ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduction: Humanizing Temporal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The ECMAScript Temporal specification represents a monumental leap forward for JavaScript dates, providing mathematical rigor, timezone correctness, and nanosecond precision. However, as an engine-level foundation, native Temporal is intentionally low-level, verbose, and rigid. Answering everyday human questions—such as "What time is it where our client is right now?", "Is it daylight or business hours at their location?", or "How many business days until the next fiscal quarter?"—can feel mechanically clunky, requiring developers to stitch together multiple disjoint types, offset normalizers, calendar converters, and external APIs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's primary mission is to humanize Temporal: transforming low-level precision into an intuitive, expressive, and effortless developer experience.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We believe that developer ergonomics should never compromise mathematical correctness. Tempo achieves this balance by providing a rock-solid ISO 8601 baseline—ensuring deterministic calendar arithmetic, guaranteed immutable safety, and explicit ISO escape hatches—paired with rich regional and cultural awareness (standardized Intl.Locale info) that understands human intent and local calendar conventions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Core Value Proposition ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Closing the Onboarding Gap ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modern developers expect a "warm" API for common tasks. Native Temporal requires explicit types and strict ISO formats for almost every operation. Tempo provides a familiar, intuitive entry point (similar to the ease of Day.js) while maintaining the rock-solid reliability of Temporal under the hood.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Human-Centric Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data in the real world is messy. Tempo's Layout and Snippet engine allows developers to interpret human-readable strings, aliases, and custom formats without writing complex custom utility functions. It turns "today", "next Friday 3pm", or "Christmas" into machine-exact time points effortlessly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Contextual & Business Intelligence via Plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time and physical reality are inseparable: civil time only has meaning relative to a location, a business calendar, or natural cycles. Through its modular plugin architecture, Tempo bridges time with real-world context—such as IP and GPS geolocation, fiscal quarters, meteorological seasons, and astronomical cycles—moving domain-specific complexity out of application code and into reusable, extensible plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Lean, Deterministic, and Hardened ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is designed to be a thin, highly capable layer. It prioritizes a lightweight, ergonomic API surface for the developer while maintaining robust internal logic to handle the complexities of timezones, calendars, and durations with zero mutable side effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Conclusion ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is not intended to replace Temporal, but to humanize it. It is the tool for developers who want the future of JavaScript dates today, without the overhead of building their own high-level utility library from scratch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/commercial.html b/packages/tempo/public/v4/doc/8-project-and-support/commercial.html new file mode 100644 index 00000000..f2b39d13 --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/commercial.html @@ -0,0 +1,68 @@ + + + + + + 🤝 Magma Computing Solutions: Professional Services | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤝 Magma Computing Solutions: Professional Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is a high-performance, precision date-time library maintained by Magma Computing Solutions. We offer a range of professional services and private extensions to help teams build robust, time-sensitive applications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Our Services ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Custom Plugin Development ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Need a specialized plugin for your industry? We design and implement high-performance Tempo extensions such as:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Financial Tickers: Real-time market-aware pulses with weekend/holiday suppression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Production Timelines: Complex shift-based scheduling and resource allocation generators.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Terms: Domain-specific date ranges (e.g., academic years, retail seasons, or medical billing cycles).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏛️ Architecture & Migration Consulting ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transitioning from legacy libraries like Moment.js or Luxon? Our team can:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Audit your existing date-time logic for Temporal compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Perform high-fidelity migrations of complex "relative time" calculations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optimize performance for large-scale data processing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Enterprise Support & Commercial Extensions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For mission-critical applications, we provide:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Priority commercial support and SLA guarantees.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Security auditing and bespoke feature engineering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom enterprise plugins tailored to private infrastructures.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📬 Contact Us ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready to discuss your project? Get in touch with our engineering team:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Core is 100% open source under the MIT license. Our professional services are designed to complement the open-source library with deep domain expertise, custom plugin engineering, and enterprise SLA support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/migration-guide.html b/packages/tempo/public/v4/doc/8-project-and-support/migration-guide.html new file mode 100644 index 00000000..4afb9610 --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/migration-guide.html @@ -0,0 +1,127 @@ + + + + + + ⚠️ Migrating to Tempo v4.x | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v4.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.x introduces a standardized plugin & registry architecture, strict configuration namespaces, cascading configuration inheritance, and deterministic resource disposal while excising legacy v3.x deprecated interfaces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Dynamic Functional Context (DFC) & Supplier Options ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.0.0, core configuration options (timeZone, locale, calendar, sphere) accept lazy Evaluable<T> supplier functions (() => T) as well as static scalars. This enables dynamic, per-request context resolution (e.g. multi-tenant session headers, request-scoped localizations) without recreating Tempo options or rebuilding configuration objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ✅ v4.0.0 - Dynamic per-request timezone resolution
+import { Tempo } from '@magmacomputing/tempo';
+import { getActiveTenantTimezone } from './session';
+
+Tempo.init({
+  timeZone: () => getActiveTenantTimezone(), // Re-evaluated dynamically when context getters execute
+  locale: () => getCurrentUserLocale()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Plugin SDK Subpath (@magmacomputing/tempo/plugin/sdk) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.0.0, all custom plugin, term, module, and namespace development is standardized on @magmacomputing/tempo/plugin/sdk.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy Imports: Deprecated plugin-api.index.ts and #tempo/license subpath imports have been removed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SDK Import: Import definePlugin, defineTerm, defineModule, defineNamespace, defineRange, and evaluation utilities directly from @magmacomputing/tempo/plugin/sdk.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ v3.x (Deprecated)
+import { definePlugin } from '@magmacomputing/tempo/plugin-api';
+
+// ✅ v4.0.0
+import { definePlugin } from '@magmacomputing/tempo/plugin/sdk';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📄 Zero-await Synchronous JSONC Config Discovery ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 introduces resolveConfigSync() for zero-await synchronous configuration discovery when using .json or .jsonc configuration files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .json / .jsonc files: Dynamically discovered and parsed synchronously during module initialization via parseJSONC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • .ts / .mts / .mjs / .js files: Asynchronously loaded via resolveConfig().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated .cjs config discovery files are no longer automatically scanned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔓 100% Open-Source Community Core ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 Community Core is 100% open-source without commercial license validation hooks or JWT scope checks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • License keys (licenseKey, TEMPO_LICENSE_KEY) are no longer required or checked in the Community Edition.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.ready() returns 'none' for community core compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Commercial plugin management and domain-locking hooks have been relocated into the @magmacomputing/tempo-pro enterprise package.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Tempo v4.1.0 Updates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.1.0 introduces cascading configuration inheritance (extends), a dedicated pluginOptions configuration slot, and overloaded Tempo.create() with deterministic resource cleanup (TC39 using).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Configuration Inheritance (extends), plugins, and pluginOptions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.1.0, configuration, plugin registration, and runtime options have been cleanly separated:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Inheritance (extends): The extends option in Tempo.init() or tempo.config.json is strictly reserved for cascading configuration inheritance via local file paths or file:// URLs (mirroring tsconfig.json and ESLint conventions): extends: './tempo-base.json'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Registration (plugins): Pass executable plugins, terms, and modules into plugins: [TickerPlugin, CelestialPlugin].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Configuration Slot (pluginOptions): Pass runtime configuration defaults for plugins into pluginOptions: { ticker: { interval: 500 } }. The 'plugins' key as a JSON of plugin-configuration settings has been migrated to pluginOptions so as not to overload the plugins key (which registers Plugin instances / Terms / Modules / Namespaces).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Imperative Registration (Tempo.use): Use the standard Tempo.use(Plugin) static method to register plugins, terms, or modules at runtime. Tempo.extend() is @deprecated Use Tempo.use(...) instead..

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ✅ v4.1.0: Clean Separation
+Tempo.init({
+  extends: './tempo-base.json',                                     // Configuration inheritance
+  plugins: [TickerPlugin, CelestialPlugin],                         // Feature & Term registration
+  pluginOptions: {                                                  // Plugin runtime options
+    ticker: { interval: 500 }
+  }
+});
+
+// ✅ Imperative registration
+Tempo.use(TickerPlugin);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔒 Overloaded Tempo.create() & Scoped Disposal (using) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v4.1.0, Tempo.create() introduces deterministic resource cleanup via TC39 Explicit Resource Management:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Callback Mode: Run isolated operations without leaking sandbox state to the global scope:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const season = Tempo.create((sb) => {
+  sb.use(CelestialPlugin);
+  return sb('2026-06-21').term.astronomy.season;
+}); // sandbox automatically disposed upon completion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TC39 Explicit Resource Management (using):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
+  using sb = Tempo.create({ discovery: 'ephemeral' });
+  sb.use(MyPlugin);
+} // sb[Symbol.dispose]() called automatically

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📂 Data Augmentation (registry: { ... }) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All custom format definitions, locale mappings, modifiers, tokens, snippets, layouts, events, periods, ignores, and number-word definitions are consolidated under the registry namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Number-Word Mappings: Top-level numbers: { ... } has been moved to registry: { numbers: { ... } }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Formats: Top-level formats: { ... } has been moved to registry: { formats: { ... } }.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Discovery: Discovery objects (Symbol.for('$Tempo')) use registry: { numbers: { ... }, formats: { ... } } instead of top-level discovery.numbers or discovery.formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example Migration: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // ❌ v3.x (Deprecated)
+Tempo.init({
+  numbers: { un: 1, deux: 2 },
+  formats: { customDate: '{yyyy}-{mm}-{dd}' }
+});
+
+// ✅ v4.0.0
+Tempo.init({
+  registry: {
+    numbers: { un: 1, deux: 2 },
+    formats: { customDate: '{yyyy}-{mm}-{dd}' }
+  }
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧹 Deprecated Type & API Cleanup ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use vs Tempo.uses: The legacy alias Tempo.uses has been excised. Use Tempo.use().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TempoInstance Type: TempoInstance interface alias has been removed in favor of standard Tempo class/instance types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mutable<T> to MutableObject<T>: The utility type Mutable<T> has been renamed to MutableObject<T> to prevent naming collisions with the @Mutable member decorator and clarify object-level readonly stripping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v3.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v3.x finalizes the plugin ecosystem by extracting advanced features into standalone, licensed packages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating to Tempo v3.x (Ticker Extraction) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The TickerPlugin has been extracted from the core engine into a standalone open-source Community plugin (@magmacomputing/tempo-plugin-ticker).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. If you use Tempo.ticker(), install @magmacomputing/tempo-plugin-ticker alongside @magmacomputing/tempo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Import and register the plugin in your application initialization:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+Tempo.init({
+  plugins: [TickerPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migrating to Tempo v2.x ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.x introduces architectural improvements and a more modular engine. While we strive for backward compatibility, there are some key changes to consider when upgrading from v1.x.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Modular Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is now split into a core engine and optional modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you use the full package: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you import from @magmacomputing/tempo, everything (except Plugin extensions, like .ticker()) is included and works exactly like v1.x. No changes are required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you want a lean bundle: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now import the core engine only:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo/core';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you do this, you must manually import the features you need. Built-in features now self-register on import via side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Feature Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Features like mutation, duration, format, and the ticker are now modular.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v1.x (Automatic) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In v1.x, all features were always present.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.x (Opt-in for Core) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If using the Core engine, simply import the module to activate the feature:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import '@magmacomputing/tempo/duration';
+import '@magmacomputing/tempo/ticker';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ Term Logic Refactor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The way Terms (Quarters, Seasons, Zodiacs, etc.) are handled has been unified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v1.x: Some Term properties were ad-hoc on the instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.x: All Term logic is centralized under the .term property or accessible via the # shorthand in .set() and .add().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example of new syntax:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Snap to start of quarter
+t.set({ '#quarter': 'start' });
+
+// Add two quarters while preserving day-of-quarter
+t.add({ '#quarter': 2 });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Tempo v2.4.0: Standalone Utilities & Path Deprecation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.4.0 introduces standalone utility entry points for parse and format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Standalone Imports ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now import lightweight, tree-shakable versions of our parsing and formatting engines without the Tempo class:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { parse } from '@magmacomputing/tempo/parse';
+import { format } from '@magmacomputing/tempo/format';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Reorganized Paths ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    We have reorganized the package structure to support these standalone entry points more cleanly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Use package subpath maps: Update your imports to use the official entry points:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ❌ @magmacomputing/tempo/module/parse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ❌ @magmacomputing/tempo/module/format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ✅ @magmacomputing/tempo/parse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ✅ @magmacomputing/tempo/format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Check your Import Maps: If you use browser-side import maps, ensure they point to package subpath locations rather than internal folder paths. A maintained importmap.json is included in the package root (packages/tempo/importmap.json) as the sanctioned reference for each release.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note: The shipped packages/tempo/importmap.json is the supported exception for version-locked internal mappings. Use it as-is for your installed Tempo version instead of hand-authoring dist/ paths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
+    "imports": {
+        "@magmacomputing/tempo/parse": "./node_modules/@magmacomputing/tempo/parse",
+        "@magmacomputing/tempo/format": "./node_modules/@magmacomputing/tempo/format"
+    }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.4 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    As Tempo grows, it has become much more efficient for our developers to logically re-group certain modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Review your browser importmap entries.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Replace any older internal paths with the current package subpath entries (for example, @magmacomputing/tempo/duration, @magmacomputing/tempo/mutate, @magmacomputing/tempo/parse, and @magmacomputing/tempo/format).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Do not pin imports in your code directly to internal folder layouts in dist/, since those paths may change as modules are reorganized. Instead rely wholly on your import maps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.6.0 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Season Term scope output has been simplified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. If you previously relied on the Chinese-specific object attached to term.season scope output, remove that dependency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Resolve Chinese season context by creating a dedicated Tempo instance with the appropriate Chinese timeZone for the interpretation you need.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating from version 2.7.0 (Grouped Options) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo has rationalized its configuration surface by grouping related options into nested objects. This improves discoverability and allows for easier additive merging across the prototype chain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Month-Day (Regional Parsing) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The individual mdyLocales and mdyLayouts options have been consolidated into a single monthDay object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.6.x: new Tempo({ mdyLocales: ['en-US'] })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.7.x: new Tempo({ monthDay: { locales: ['en-US'] } })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shortcut: new Tempo({ monthDay: true }) (enables forced MDY parsing using default locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Relative Time ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The individual rtfFormat and rtfStyle options have been consolidated into a single relativeTimeFormat object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.6.x: new Tempo({ rtfStyle: 'long' })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.7.x: new Tempo({ relativeTimeFormat: { style: 'long' } })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only the deprecated top-level keys rtfFormat and rtfStyle are still accepted as legacy fallbacks in the current release, handled specifically in the Tempo class constructor for backward compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    In contrast, the old mdyLocales and mdyLayouts keys are not treated as aliases and will be ignored; these must be migrated to the new nested monthDay structure. Update your configuration to ensure compatibility with future versions and the optimization engine. Refer to the Tempo constructor for implementation details on legacy alias handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Migrating to version 2.9.3 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📏 BigInt Precision Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A breaking change was introduced to harmonize BigInt handling with numeric inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-v2.9.3: BigInt inputs were always treated as raw nanoseconds, regardless of the timeStamp configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • v2.9.3+: BigInt inputs now respect the configured unit (default 'ms').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Before v2.9.3
+new Tempo(1000n).ts; // 1000 (nanoseconds)
+
+// After v2.9.3
+new Tempo(1000n).ts; // 1000 (milliseconds)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Action Required: ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you previously relied on BigInt being treated as nanoseconds, you must now explicitly set the timeStamp unit to 'ns':

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo(1000n, { timeStamp: 'ns' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔁 Removed Features (v3.0.0) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated Boolean Debug Flag ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The debug configuration property no longer accepts boolean values. It has been strictly typed to accept numeric verbosity levels matching the internal LOG enum, or lowercase string labels (e.g. 'trace', 'info').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed: new Tempo({ debug: true })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recommended: new Tempo({ debug: 4 }), new Tempo({ debug: 'debug' }), or new Tempo({ debug: LOG.Debug }) (for parsing verbosity).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internationalization Naming ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To better align with ECMAScript standards (specifically Intl.RelativeTimeFormat), the relativeTime configuration option inside intl is no longer supported in v3.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed: new Tempo({ intl: { relativeTime: { style: 'long' } } })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recommended: new Tempo({ intl: { relativeTimeFormat: { style: 'long' } } })

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Please migrate your configurations from relativeTime to relativeTimeFormat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧪 Testing and Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v2.x has been hardened with a 100% pass rate on our regression suite. If you were relying on undocumented "quirks" or bugs in v1.x parsing, you may find that v2.x is more strict and deterministic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/index.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/index.html new file mode 100644 index 00000000..7108f435 --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/index.html @@ -0,0 +1,68 @@ + + + + + + 🚀 Releases | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Releases ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Explore the evolution of Tempo through its version history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Release Strategy ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo follows Semantic Versioning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Major: Breaking changes and architectural shifts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Minor: New features and significant enhancements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Patch: Bug fixes and performance optimizations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/v0.x.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/v0.x.html new file mode 100644 index 00000000..38f70baa --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/v0.x.html @@ -0,0 +1,68 @@ + + + + + + 📜 Version 0.x History | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 0.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v0.3.0] - 2025-07-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced an immutable property decorator and a deep-freeze utility for objects and arrays. Added a secure, default configuration module for date/time parsing. Extended global browser support for the Temporal API via polyfill.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Corrected the enumerable decorator to ensure proper closure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Refactor ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Centralised and secured date/time parsing constants and layouts. Improved typing and immutability for enums and configuration objects. Updated logging and state management to use object-based constants instead of enums.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enhanced inline documentation and added detailed usage examples for enum utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated development dependencies to latest versions. Reformatted TypeScript configuration for clarity.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v0.2.0] - 2024-10-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated the version of the Tempo class to 0.2.0, ensuring users have access to the latest enhancements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Resolved versioning discrepancies in the Default configuration object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/v1.x.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/v1.x.html new file mode 100644 index 00000000..e2d3badf --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/v1.x.html @@ -0,0 +1,68 @@ + + + + + + 📜 Version 1.x History | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 1.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.3] - 2026-03-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Browser: persistent storage wrapper, multi‑tap gesture helper, geolocation + maps/address utilities, simple alert/prompt/confirm helpers. Server: sandboxed temp‑file API, HTTP helpers with timeouts, Base64 encode/decode, JWT payload decoder. Tempo v2.0.0: lazy initialization, unified Term math/format tokens (#{...}), anchor/term utilities and faster startup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Expanded API/type docs, architecture, benchmarks, migration and cookbook guidance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package scope renamed to @magmacomputing/*; new build/release scripts and updated TypeScript/test configs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.2] - 2026-03-23 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unified plugin system via Tempo.load() for plugins, Term plugins, and discovery configuration. Made Pledge thenable and awaitable via .then() method support. Enhanced makeTemplate() with safe placeholder substitution instead of code evaluation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Improved asCurrency() to properly coerce string inputs. Fixed constructor error handling to throw instead of returning empty objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added Target Audience section describing intended users and migration scenarios. Expanded Node.js documentation with native subpath import details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.1] - 2026-03-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugin-based extension architecture for extending Tempo functionality Automatic plugin discovery via static Tempo.discover() method New subpath exports for enums, serialisation, Pledge utility, and Ticker plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changed ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ticker functionality now available as optional plugin; requires explicit installation Selective immutability for decorated classes instead of full object freeze Core methods (format, add, set) are now protected from overwrites

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Comprehensive overhaul reflecting new plugin architecture Dedicated Pledge utility documentation added

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v1.1.0] - 2026-03-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced Tempo.ticker() — reactive clock streams via async-generator (for await...of) or callback subscription with stop control.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added a dedicated Ticker guide and updated Tempo docs with examples and API reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added unit tests covering callback mode, async-iterator mode and input validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bumped package version to 1.1.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/v2.x.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/v2.x.html new file mode 100644 index 00000000..39f90357 --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/v2.x.html @@ -0,0 +1,68 @@ + + + + + + 📜 Version 2.x History | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 2.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.11.0] - 2026-05-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Mathematics: Introduced the .balance() method to Tempo.Duration objects to allow intelligent mathematical roll-up of duration units (e.g., converting 365 days into 1 year), with support for both strict calendar math and nominal overrides ({ nominal: true }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Duration Formatting: Introduced the .format() method to Tempo.Duration objects. This uses a shared, memoized internal implementation of Intl.NumberFormat to generate highly localized, plural-aware duration strings with excellent performance and robust cross-environment execution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Configuration: Added numberFormat to the IntlOptions interface, allowing developers to set global formatting defaults (like unitDisplay: 'short') via Tempo.init() that seamlessly cascade down to all .format() calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fixed ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Open Core Build Fallback: Updated the build:resolve script to gracefully fallback to Open Core licensing types when the proprietary @core module is unavailable, resolving CI build failures in public GitHub Actions environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.10.1] - 2026-05-23 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added support for license key discovery via global browser context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced license object output with formatted timestamps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved terms registry with better key-based indexing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced Free Showcase Astronomical Seasons premium plugin option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded license application guidance for browser, Node.js, and micro-frontend environments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added network synchronization and offline behavior documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clarified logStamp format customization examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved relative time and duration string documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.10.0] - 2026-05-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added licensing system with JWT validation and revocation checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced Tempo.license public API for license state management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced Terms display with license metadata support
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term registration now enforces naming collision detection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed parsing side-effects and state leakage issues
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved epoch timestamp precision with nanosecond-level fractional resolution for 9–10 digit timestamps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Comprehensive licensing architecture and strategy documentation added.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added guidance for CI-safe licensing stubs and cross-repo dependency management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.3] - 2026-05-10 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Engine Stabilization & Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Timestamp Resolution Fix: Corrected configuration propagation for timeStamp settings, ensuring consistent persistence across nested Tempo instances.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Epoch Precedence Logic: Optimized parseLayout to prioritize epoch-style numeric inputs, preventing layout misidentification for large timestamps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Unit Enforcement: Consolidated numeric resolution to strictly respect configured unit preferences for both Number and BigInt types.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Normalizer Leak Protection: Hardened the alias normalizer with try/finally blocks to ensure proper cleanup of internal resolution keys, preventing memory leaks during high-frequency parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Type Safety & Environment Engine Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ZonedDateTime Mutation Ordering: Refined the internal mutation pipeline to ensure time zone and calendar application always precedes wall-clock updates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Interface Hardening: Resolved DOM interface collisions in internal types by correcting PluginContainer inheritance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Build Recovery: Patched dependency resolution between VitePress and MathJax to stabilize the documentation generation environment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Universal Type Guard Fix: Overhauled the internal assertion.library to eliminate "never poisoning" during complex union narrowing. Every type guard now explicitly specifies its target type, ensuring reliable Exclude and Extract behavior in downstream logic.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context Parity: Synchronized the functional alias "Resolution Context" (Host) with the public Tempo API. Methods like this.add() and this.set() in functional aliases now support the full range of Terms (#) and configuration overrides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Dependency Updates ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Synchronized Monorepo: Updated @magmacomputing/library to 2.9.3.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Infrastructure Refresh: Updated core toolchain including TypeScript, Vitest, and Rollup to their latest compatible versions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.2] - 2026-05-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced Temporal support with improved timezone and calendar handling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added documentation for prototyping with regexp patterns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded installation guidance for Node.js Temporal support

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved parsing robustness with better symbol mapping and prototype-shadowing fixes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced identity-based layout resolution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strengthened lifecycle handling for timezone and calendar operations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Optimized performance with dedicated guard and normalizer modules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Updated UI styling with theme-aware color variables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Refined error handling in engine components

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Expanded main branch protection guidance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced architecture documentation with modular design overview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.9.0] - 2026-05-06 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Alias Architecture Stabilization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Alias Engine: Completed the architectural migration to the AliasEngine, centralizing all registration and resolution logic for Events and Periods.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rich Metadata Results: Enhanced the resolution engine to return structured AliasResult objects, providing better traceability and granular control over alias-driven parses.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened Clock Snapping: Finalized the standardization of clock-like alias resolution, ensuring consistent sub-second precision clearing for all static and functional time aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance Optimized Monitoring: Introduced a lightweight version-tracking system to detect registry mutations, enabling O(1) change detection during the Tempo lifecycle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Parser & Registry Refinement ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Consolidated Host Context: Modularized the construction of the functional alias "pseudo-Tempo" context, improving separation of concerns in the parsing pipeline.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy Decoupling: Successfully decoupled Term-based alias registration from internal raw objects, moving toward a more encapsulated and secure registry design.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • VitePress 404 Patch: Corrected root directory resolution to fix "404 Not Found" errors on the landing page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build Resilience: Implemented targeted folder exclusion to prevent build-time dead-link errors in non-public directories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.8.0] - 2026-04-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Immutability System Refined ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The project evaluated mutation-throwing Proxies for all immutable objects, but reverted to using Object.freeze for stability and compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • All core objects remain protected with Object.freeze. No mutation-throwing Proxies are used for core objects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • See plan for architectural and migration details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Parse Planner Configuration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Parse Planner: Introduced planner.layoutOrder to explicitly control the parsing priority of date layouts (like mdy or iso).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-Filtering Optimization: Moved parsePrefilter to planner.preFilter. Legacy parsePrefilter configurations remain fully backward compatible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Resilience & Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • MonthDay Auto-Detection: Hardened the monthDay options resolver so that boolean shortcuts (e.g. monthDay: true) and manual overrides are properly tracked and never overwritten by auto-detection heuristics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Factory Stability: Fixed bugs in the Tempo.create() sandbox where period alias collisions were failing silently; console.warn is now properly emitted when aliases overlap in local sandboxes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol Discovery Isolation: Patched the $setConfig resolution flow to correctly merge custom formats provided via discovery symbols before evaluating global option extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.7.0] - 2026-04-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Configuration Rationalization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Grouped Options: Consolidated regional parsing and relative time options into nested objects for improved discoverability and additive merging support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mdyLocales and mdyLayouts → monthDay: { locales, layouts }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • rtfFormat and rtfStyle → relativeTime: { format, style }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Internal Hardening: Added isMonthDay internal detection to more accurately resolve parse-order layouts in regional contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Resilience & Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Event Registry Overrides: Fixed $setEvents logic to ensure user-defined event aliases correctly override or merge with built-in patterns without duplication or stale matches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • TimeZone Fallback Resilience: Enhanced the IANA TimeZone fallback mechanism with a cleaned-up, prioritized list of regional aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl.Locale Debugging: Improved diagnostic logging for Intl.Locale resolution to assist in cross-environment consistency issues.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ticker Stabilization: Further refined async generator pulse counts and termination logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ CI/CD & Infrastructure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Performance Benchmarking: Integrated a dedicated bench/ suite into the CI pipeline to monitor performance impact on core parsing and mutation logic.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Workflow Optimization: Refactored the GitHub Actions workflow for better test isolation and Node.js 24 compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.6.0] - 2026-04-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚠️ Migration Notes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New Features

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added normalizeUtcOffset utility for transforming informal UTC-offset strings to standard format. Added layoutOrder option to customize parsing element precedence.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Breaking Changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Season Scope Simplification: Removed the Chinese-specific object previously attached to all term.season scope's output. For Chinese season interpretation, create a dedicated Tempo instance with {timeZone: 'Asia/Shanghai'} or {timeZone: '+08:00'}. Note that Chinese zodiac will still be supported on term.zodiac.CN as before.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Bug Fixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fixed layout pattern resolution ordering to respect intended sequence. Enhanced timezone normalization for UTC offset handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Updated architecture documentation and configuration guidance. Clarified plugin/module callback parameter ordering in examples. Added v2.6.0 migration guide for season changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.5.0] - 2026-04-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Sandbox Factory pattern for isolated Tempo configurations via Tempo.create(options).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • User-defined aliases now evaluated before built-in aliases for custom precedence.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Support for shorthand duration construction: new Tempo({ hours: 2 }).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Debug option now accepts numeric log levels for granular control.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added fortnight event and half-hour period aliases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved compact time/date parsing for 6 and 8-digit inputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Documentation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enhanced installation guidance with Temporal polyfill details.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New modularity documentation and sandbox factory pattern guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added parsing cookbook with digit-only string precedence examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.4.0] - 2026-04-24 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Parsing Infrastructure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Order Resolver: Extracted layout-ordering decision logic into a dedicated engine.layout module (src/engine/engine.layout.ts), improving internal modularity and enabling future per-input classification support. The resolver maintains 100% behavior parity with prior ordering semantics (locale-based dmy↔mdy swaps).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Controller Framework: Introduced a minimal but extensible controller-map structure to support future input classifications (e.g., "6 digits only", "contains colon"). Currently ships with a single default classification that mirrors the existing layout order, ensuring zero overhead today and a clear path for Release B/C enhancements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Isolation & Sandboxing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Factory Mode: Introduced Tempo.create(), a static factory method that generates a completely isolated Tempo subclass. Each sandbox maintains its own independent configuration, registry, and plugin state while inheriting from the parent, enabling multi-tenant or modular configurations within a single process without global state collisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ Internal Refactoring & Type Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Separation: Extracted the core ordering logic from Tempo.#swapLayout, improving code organization and unit testability without affecting public APIs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symbol-Based Safety: Protected the default layout classification key with a Symbol('default'), reducing accidental tampering risk and improving internal API robustness.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Determinism Coverage: Added comprehensive tests for layout order resolution, classification fallback, and multi-pair swap handling to ensure predictable behavior across locales and configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Module Path Flattening: Relocated core modules (e.g., mutate, duration) from src/plugin/module/ to a top-level src/module/ directory. This simplifies the internal architecture and provides cleaner internal import paths, reflecting their role as core library features rather than just "plugins".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📊 Diagnostics & Debug Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Order Tracing: Added optional debug emission to show the final resolved layout order when debug: 5 is set, helping developers understand parse-order decisions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.3.0] - 2026-04-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Parsing Innovations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standalone Logic: Extracted the natural language engine into a dedicated parse() function, enabling independent datetime string resolution without requiring a full Tempo instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Noise Filtering: Introduced a configurable ignore option to strip "noise words" during parsing, significantly increasing the robustness of the natural language interpreter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Backtracking Security: Implemented a centralized regex safety guard (Match.backtrack) in the snippet registry to block potentially malicious patterns and prevent catastrophic backtracking.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ecosystem Installation: Released a comprehensive installation guide covering Node.js (npm/pnpm/yarn), Deno, standard browser ESM, and specialized "Lite" build configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Interactive Demo: Enhanced the browser-based playground with a live timezone selector and real-time clock updates to demonstrate Temporal integration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Quick Start Refinement: Streamlined the README and configuration documentation to highlight simplified entry points and noise-filtering capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Refactor & Type Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State Management: Optimized the internal parser state machine to reduce memory pressure and improve resolution speed for complex strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type Safety: Hardened the TypeScript definitions for all parse and term resolution functions, ensuring strict type-checking without consumer-side casting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic Context Sync: The engine now automatically synchronizes the hemisphere (sphere) configuration whenever the timezone is updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resilience: Hardened the resolution loop with safety-valves to prevent infinite loops during extreme date-range traversals and improved parse-error detection to prevent silent state corruption.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.6] - 2026-04-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚑 Emergency Hotfix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isomorphic Export Architecture: Refactored tempo.entry.ts and Rollup configuration to ensure the browser ESM bundle exports Tempo as both a default and a named export. This guarantees that import { Tempo } from '@magmacomputing/tempo' functions identically across Node.js and browser environments without throwing resolution errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dependency Resolution: Added jsbi explicitly to all documentation importmap examples to correctly resolve @js-temporal/polyfill internal bare module references and eliminate Failed to resolve module specifier "jsbi" errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation & UI: Fixed orphaned markdown script tags, formatted HTML browser usage blocks, and completely revamped the browser test UI pages with a premium jazzy aesthetic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.5] - 2026-04-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Modular Hardening ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Singleton Resilience: Replaced instanceof checks in TempoRuntime with a cross-bundle brand check, ensuring singletons are correctly adopted across bundle boundaries and HMR reloads.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Discovery: Consolidated internal storage for Term and extension plugins into a single, validated pluginsDb structure.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved Shadowing: Eliminated parameter shadowing in runtime hook methods to ensure reliable event emission.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Term Resolution Refinements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chronological Stability: Enforced chronological sorting in resolveCycleWindow for accurate cycle anchor identification.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Absolute vs Relative Years: Normalized year handling to allow templates to mix relative offsets and absolute historical years seamlessly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standards Mode: Modernized all public demonstration files with proper HTML5 skeletons and metadata.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Contextual Guidance: Updated architecture docs and READMEs with accurate module paths and functional importmap examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.4] - 2026-04-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Production Safety ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Immutable Compatibility: Added redefinition guards to TickerModule to prevent errors on already-frozen classes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ESM Integrity: Bundled tslib into granular ESM builds to resolve resolution failures in standard browser environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.3] - 2026-04-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ New Features ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Parsing: Initial decoupling of the parse engine to support standalone usage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Layout Snippets: Introduced pattern-based layout customization for granular formatting control.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Project Governance: Integrated the MIT license and established a dedicated release history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🐛 Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Match Propagation: Ensured parse results correctly propagate through instance clones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Drift Resolution: Corrected timezone and calendar drift during intensive mutation cycles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Chores ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Knowledge Architecture: Reorganized navigation into focused tracks: Cookbook, Advanced Reference, and Utility Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • API Reference: Expanded constructor documentation and added guidance for custom enum implementations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Diagnostics: Improved internal module-loading error messages for easier troubleshooting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.2.2] - 2026-04-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ Registry Stabilization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Globalized module and serialization registries using Symbol.for() on globalThis to ensure state consistency across module reloads, HMR, and bundled distributions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented secure, local Proxy wrapping for registries to prevent closure persistence across library reloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔍 Hardened Reflection ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed static property reflection for decorated classes by implementing recursive prototype chain traversal in getAccessors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Refined prototype walking logic to prevent leaks from Object.prototype and Function.prototype.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Production Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Achieved 100% build parity and test coverage in the production distribution (test:dist).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reduced NPM package size by nearly 50% by excluding non-essential documentation and image assets from the public package.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened Rollup build paths to be context-aware and defensive against missing artifacts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎨 Premium Documentation & UX ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Redesigned the documentation landing page with a custom, high-performance Hero section and a live Tempo-driven analog clock.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Harmonized branding across README and documentation sites with "Tempo Blue" styling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fixed routing and asset resolution for GitHub Pages deployments using VitePress base-path helpers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧬 Mutation Engine & State Preservation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Stabilized the mutation engine (.add(), .set()) to correctly accumulate and preserve parse results across instance clones.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented robust parse result propagation in MutateModule using the internal state.matches registry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized cross-module state access using the [sym.$Internal] symbol, enabling safe cloning without violating private encapsulation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved timezone and calendar drift during complex mutations by enforcing authoritative state-merging in the mutation pipeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧩 Modular Parse Engine ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Successfully decoupled internal parsing logic into ParseModule, reducing core class complexity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implemented a hybrid static Tempo.parse configuration/method pattern to maintain full backward compatibility while supporting modular delegation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hardened the interpret utility to ensure reliable method dispatching even when modules are loaded lazily or via HMR.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚙️ CI/CD & Tooling ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Upgraded GitHub Actions pipeline to Node.js 24 to resolve deprecation warnings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Restored separate "Full" and "Core" test suite isolation in local and workspace Vitest configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized documentation build order to ensure artifacts are compiled before generation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Achieved 100% Test Pass Rate (384/384) across all environments and distribution bundles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.1.3] - 2026-04-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • VitePress Migration: Launched a modern documentation system with integrated TypeDoc API references.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Loading Patterns: Introduced interactive browser demos for ESM, IIFE, and granular module resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized README: Refreshed the main project entry point with improved formatting and developer guides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Performance & Extensibility ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugin Refactor: Migrated the plugin system to a flexible object-based API for better extensibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cache Optimization: Enhanced memoization performance across the core engine.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modular Exports: Streamlined library entry points to improve tree-shaking and reduce bundle sizes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Temporal Utilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • High Precision: Expanded Temporal utility functions with native support for nanosecond-precision calculations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v2.1.2] - 2026-04-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v2.1.2 is a major milestone, delivering a more reactive architecture and rock-solid stability.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Modular Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo is now split into core and optional modules, allowing you to include only what you need. This reduces bundle size for users who only need the basic engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📝 Improved Logging ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Internal logging now uses context-aware Symbols. This decouples the logging logic from the core engine, allowing for cleaner diagnostics without performance overhead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️ Static API ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Added Tempo.duration() static method for convenient duration creation without instantiating a full Tempo date object first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌 Side Effect Registration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Plugins now support automatic registration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The full @magmacomputing/tempo package includes all modules by default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core users (@magmacomputing/tempo/core) can activate features simply by importing the corresponding module (e.g., import '@magmacomputing/tempo/ticker').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛡️ 100% Reliability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The engine passes all regression tests, ensuring complete stability across:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parsing complex date strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Calculation and relative math.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formatting routines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗓️ Unified Term Logic ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terms (like Quarters and Seasons) are now fully integrated:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use # in set() to jump to boundaries (e.g., t.set({ start: '#quarter' })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {#term} in format() to embed semantic labels (e.g. "Second Quarter") directly into strings (e.g., t.format('Today is {yyyy}-{mm}-{dd} in the {#quarter}').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ➗ Relational Term Math ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A category-first feature. Shift dates by semantic "steps" with .add({ '#quarter': 1 }). Tempo preserves your relative duration within the Term, jumping across gaps and handling overflows with mathematical precision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔗 Fluent Immutable Boundaries ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Term ranges now return fully functional, frozen Tempo instances for start and end. This allows for seamless chaining:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.term.qtr.start.format('{dd} {mmm}')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Ticker Reliability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fully stabilized the Ticker subsystem:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Resolved async generator hangs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Synchronized pulse counts (N pulses for limit: N), guaranteeing 100% predictable reactive streams.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Parsing Engine Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Re-engineered pattern generation for O(1) instance creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved support for custom layout literals in local/one-off parsers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Significant refinements to the natural language engine for even more intuitive relative-date handling ("next Friday", "two days ago", etc.).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/v3.x.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/v3.x.html new file mode 100644 index 00000000..a648e441 --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/v3.x.html @@ -0,0 +1,135 @@ + + + + + + 📜 Version 3.x History | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 3.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.11.1] - 2026-08-10 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Dedicated Config Subpath (@magmacomputing/tempo/config) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo configuration can now be authored with full IDE typing and autocomplete via the dedicated @magmacomputing/tempo/config entry point. It exports defineConfig for type-safe configuration authoring and resolveConfig for programmatic discovery:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { defineConfig } from '@magmacomputing/tempo/config';
+
+export default defineConfig({
+  timeZone: 'Australia/Sydney',
+  locale: 'en-AU',
+  cache: {
+    ttl: 3600000,
+    maxSize: 500,
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ JSONC Configuration Support ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The filesystem configuration resolver now natively parses JSON with comments (tempo.config.jsonc and tempo.config.json), supporting single-line (//), multi-line (/* */) comments, and trailing commas for clean, human-readable config files without requiring build steps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Timezone Abbreviations & Humanized Offsets ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The natural-language and layout parsers now natively recognize common 3–4 letter timezone abbreviations (e.g. AEST, PST, EST, CET, JST) as well as explicit GMT/UTC offset prefixes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('Aug 6, 2026 16:16 GMT+10');
+new Tempo('August 6, 2026 16:16 AEST');
+new Tempo('2026-08-08 10:30 +5:30'); // Fractional and half-hour offsets supported

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ SQL & Space-Delimited Timestamp Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo automatically detects and normalizes SQL and space-delimited timestamps (such as 2026-08-08 10:30:00 [America/New_York]) into standard ISO 8601 strings during initialization, collapsing extraneous whitespace while safely preserving complex timezone identifiers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Cache Inspection & Serialization (toJSON) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.cache and the underlying BoundedCache engine now support native .toJSON() serialization, allowing you to easily inspect active, non-expired cache entries or serialize them with JSON.stringify(Tempo.cache) for diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 AI Context & IDE Integration (llms.txt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Published official, standardized llms.txt and llms-full.txt context bundles at tempo.magmacomputing.com.au to provide rich, curated project context for modern AI coding tools (Cursor, Copilot, Antigravity, Claude, ChatGPT). Added a dedicated AI & IDE Integration guide to the documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.11.0] - 2026-07-31 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Centralized Cache Engine (Tempo.cache) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Introduced a high-performance BoundedCache singleton managing date resolution, layout compilation, and AI operations. It supports configurable LRU capacity eviction (maxSize) and time-to-live (ttl) expiration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  cache: {
+    maxSize: 1000,
+    ttl: 60 * 60 * 1000, // 1 hour TTL
+  },
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Glossary Seeding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now seed domain-specific terms or pre-resolved glossary mappings into the cache during initialization. Seeded glossary items remain permanently cached as immortal entries exempt from LRU eviction and TTL expiration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const glossary = new Map([
+  ['fiscal_kickoff', '2026-07-01T00:00:00Z'],
+  ['release_v3', '2026-08-10T12:00:00Z'],
+]);
+
+Tempo.init({ cache: glossary });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Multi-Provider AI Farm & Batching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Upgraded @magmacomputing/tempo-plugin-ai to support multi-provider orchestration modes (AiMode.Fallback, AiMode.Race, AiMode.Consensus, AiMode.Hedged, AiMode.RoundRobin, AiMode.Adaptive), bounded concurrency batch processing, and softErrors error boundaries for robust resilience in production environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scaffolded the Cache Management (tempo.cache.md) Core Concepts guide, detailing cache topology, glossary vs alias decision matrices, and integration across core and plugins.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.3] - 2026-07-29 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Zero-Overhead Instantiation & Lazy System Clock ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Construction of Tempo instances has been further optimized to deliver true zero-overhead instantiation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deferred System Clock (#now): System clock acquisition (Temporal.Instant.fromEpochNanoseconds) is deferred until relative duration math or parsing fallbacks explicitly require the current time. Constructing instances from explicit date strings, numbers, or objects skips system clock calls entirely.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lazy Delegators (#fmt, #term): Internal proxy delegator objects are constructed on-demand only when .fmt or .term properties are accessed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • High-Frequency Acceleration: Substantially boosts throughput for loops, high-volume data transformation, and Tempo.Interval boundary operations (overlaps, contains, intersection, union).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.2] - 2026-07-25 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Experimental AI Parsing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • parseAI Plugin: Officially introduced the @magmacomputing/tempo-plugin-ai experimental plugin for natural language date parsing via LLMs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Observability & Control: Added debug: true (development-only verbose logging of system prompts, localized context, and raw LLM responses; enable only with non-sensitive inputs) and force: true configuration flags to the AI plugin to easily monitor CoT (Chain-of-Thought) JSON schemas and bypass native parsing caching layers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fixes & Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Silent Native Parsing: Added a new silent: false configuration flag to Tempo Core (Tempo.init({ silent: true })). When enabled, this cleanly suppresses internal console error logging when native parsing throws a TempoError, providing a pristine terminal experience when falling back to AI parsers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Integrity: Hardened the internal enumify registry constructor in @magmacomputing/library to strictly verify its execution context (isFunction(this?.has)). This prevents prototype corruption when resolving ES Modules across mixed bundler environments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Test Environment Collisions: Resolved an isolated bug in Vitest workspace orchestration where duplicate core monorepo instances were loaded into memory, causing false-positive failures in plugin extensions (such as BatchPlugin).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.10.0] - 2026-07-19 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format Token Modifiers & Custom Tokens Introduced new capabilities for chained formatting modifiers and finalized the complete architecture for Custom Format Tokens. Developers can now register custom zero-overhead logic evaluators (like Fiscal Years or native Intl bridges) that seamlessly hook into the t.format() engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cookbook Refactoring: Trimmed architectural "bloat" from the Cookbook (including Localized Parsing, Slick Mutations, and Custom Tokens). This content has been moved into dedicated Core Concepts guides (tempo.parse.md, tempo.mutate.md, tempo.format.md) to provide a much punchier, fast-paced onboarding experience for new users, while keeping deep-dive details just one click away.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.9.0] - 2026-07-14 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Historical Era Support Introduced first-class support for historical dates. The new {era} formatting token automatically resolves to localized BC/AD or BCE/CE designations. Additionally, the core Tempo class now exposes .era and .eon zero-cost getters, providing immediate access to the underlying historical date components.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Typographical Auto-Meridiem Expanded the {h12} token modifiers with a new :space option. When chaining modifiers (like {h12:space:dots}), Tempo will now gracefully inject a readability space before the auto-appended meridiem, yielding typographically correct strings like "10:30 a.m." instead of "10:30a.m.".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Educational Guides: Created a brand new tempo.getters.md document in the Core Concepts section, serving as the definitive guide to Tempo's zero-cost lazy-evaluation properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ecosystem Alignment: Updated tempo.config.md to remove deprecated plugin references, replacing them with accurate examples from the current tempo-workspace (FinanceNamespace and CelestialPlugin).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fixes & Stability ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Core Typings: Resolved any leakage in Tempo core methods by injecting strict overloads for until() and since() directly into tempo.class.ts, ensuring full IDE type-inference flows through to .format().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Badges: Standardized the Shields.io badge layout across the monorepo to use <p> tags with inline-block styling, fixing horizontal alignment issues caused by VitePress CSS overrides and eliminating malformed HTML <table> hydration errors.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Vue Compiler Hydration: Fixed a rogue unclosed </p> tag in the Ticker plugin documentation that was silently causing downstream Vue SFC parsing errors during VitePress compilation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CLI Pipeline: Validated the magma-cli build pipeline to correctly propagate non-zero exit codes during workspace orchestration operations, preventing silent failures.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.8.0] - 2026-07-11 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interval Primitive Introduced Interval as a first-class, tree-shakeable core primitive. It provides mathematically pure, high-performance boundary evaluations (overlaps, abuts, contains) and set operations (union, intersection) for Temporal points. Interval is accessible ergonomically via Tempo.Interval or independently as a named export for strict tree-shaking purists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespace Architecture Introduced the defineNamespace plugin factory. While Terms (like quarter or season) teach Tempo how to parse natural language, Namespaces provide a clean way to attach grouped business logic directly to the Tempo instance without polluting the global scope. For example, t.finance.isFiscalYearStart() or t.finance.taxYear keeps financial computations neatly isolated from standard date mechanics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Plugin Discrimination: The plugin registry now enforces strict 'type' discrimination ('plugin' | 'namespace' | 'term' | 'module') across all plugin factories, replacing brittle object-sniffing and making introspection significantly more robust.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation Architecture: The documentation source code has been completely reorganized into numbered sub-directories (1-getting-started, 2-core-concepts, etc.) to map 1:1 with the visual VitePress sidebar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.7.1] - 2026-07-09 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🪲 Bug Fix ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • License Admin Isolation: Improved license handling so administrative access is tracked separately, reducing incorrect license/permission information appearing in the app.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Admin Cache Protection: Prevented outdated role information from lingering after license updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.7.0] - 2026-07-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Runtime Version Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo now features a fully automated runtime version registry accessible via Tempo.versions. This allows developers to instantly query exactly which core modules, terms, and community plugins are loaded into their current Tempo environment and what versions they are running. This system is completely zero-burden for plugin authors, utilizing a virtual build pipeline to auto-inject version strings without requiring manual updates or magic strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Architectural Security: The internal state management (including term registries and configuration variables) has been modernized to use true ECMAScript private fields (#), ensuring that Tempo's runtime state is strictly impenetrable from the outside.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.6.0] - 2026-07-05 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Shorthand Mutation Keys ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Added native support for Tempo's shorthand format tokens (e.g., mi, ss, yy, ww) across both .add() and .set() mutations, streamlining developer experience and aligning TypeScript definitions with the underlying runtime engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Shorthand Duration Keys ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Expanded shorthand token support directly into the DurationModule. You can now seamlessly use shorthand keys for duration instantiation (Tempo.duration({ mi: 5 })), comparisons (t.until(other, 'mi')), and strict balancing (t.until(other).balance({ largestUnit: 'mi' })), bringing total API consistency across the core library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.2] - 2026-07-04 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Minified Global Bundles ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The build pipeline now natively produces highly optimized, minified IIFE bundles (*.min.js) for both Tempo Core and all Community Plugins, significantly reducing payload size for developers using CDN <script> tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Additionally, the browser-global export strategy has been re-architected. Both the core library and all <script> tag plugins now elegantly attach to a single, collision-free window.Magma namespace (e.g., window.Magma.Tempo and window.Magma.plugins.astro), dramatically improving developer experience and eliminating global variable pollution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Timezone Formatting Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The {tz} format token now natively supports a full suite of lowercase modifiers (:z, :zz, :zzz, :zzzz, :zzzzz)! This seamlessly outputs various localized timezone names and standard offset formats directly from the native Intl engine, eliminating the need to rely purely on raw IANA Timezone IDs for UI rendering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Module Augmentation Typings: Hardened the "batteries-included" tempo.index.ts entry point by explicitly exporting core module types (e.g. DurationModule, FormatModule). This forces TypeScript to preserve their module augmentations in the compiled .d.ts bundle, guaranteeing that methods like .until() and .since() correctly appear in IDE autocomplete out-of-the-box.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.1] - 2026-06-28 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Registration Resilience: Hardened Tempo.extend with structural deduplication to safely ignore redundant registrations of identical core terms. This prevents edge-case term collisions (e.g., qtr) in mixed module-loader environments like Vitest where Node ESM and Vite may evaluate plugins multiple times.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.5.0] - 2026-06-28 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Unified Plugin API ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v3.5.0 introduces a brand new barrel export for plugin developers: @magmacomputing/tempo/plugin-api.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This new endpoint centralizes all plugin-authoring utilities (defineModule, definePlugin, defineTerm) and internal types into a single location. This architecture significantly cleans up application-level code by formally separating end-user imports from Plugin Developer imports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are developing a custom plugin, you simply update your imports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Old Way
+// import { defineModule } from '@magmacomputing/tempo/plugin';
+
+// New Way
+import { defineModule } from '@magmacomputing/tempo/plugin-api';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Static vs Smart CDNs: We have completely overhauled the installation documentation to clarify the distinction between using Smart CDNs (like esm.sh which automatically resolve dependencies) for prototyping, versus Static CDNs (with manual importmap configurations) for hardened production environments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evergreen Temporal Wording: Removed explicit version claims for upcoming Node.js native Temporal support, future-proofing our guides against shifting V8 release timelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.4.0] - 2026-06-26 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Dynamic Format Tokens ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's formatting engine now supports completely custom format evaluators via the registry.tokens configuration. This allows you to define your own syntax tokens that execute complex math or delegate deeply localized formatting directly to the native Intl API.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+	locale: 'fr-FR',
+	registry: {
+		tokens: {
+			'wkd-fr': (zdt, { config }) => {
+				const dtOptions = config?.intl?.dateTimeFormat ?? {};
+				return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
+			}
+		}
+	}
+});
+
+const t = new Tempo('2024-05-20');
+t.format('{wkd-fr}'); // "lundi"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ Compound Token Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The compound date tokens ({dmy}, {mdy}, {ymd}) now support the :yy modifier to easily truncate their internal year components to 2 digits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t.format('{dmy:yy}'); // "200524"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This officially supersedes the legacy *6 tokens (e.g., {dmy6}) which have now been deprecated from documentation to keep the API clean, though they remain fully supported in the engine for backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.3.1] - 2026-06-22 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Slick Object Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo has always allowed jumping to boundaries using the Slick Shorthand (#qtr.>2q1) or semantic strings (next Friday). v3.3.1 extends this power directly to .set() object properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now use SLICK_KEYS (yy, mm, ww, dd, hh, mi, ss, wkd) as object keys in .set(), passing a directional string payload:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2024-05-20'); // Monday
+
+// Jump forward two months
+t.set({ mm: '>2' }); // July 20
+
+// Jump to the next Friday
+t.set({ wkd: '>Fri' }); // May 24
+
+// "Double-negation" math is fully supported:
+t.set({ mm: '<-3' }); // Equivalent to >3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This makes relative programmatic date construction cleaner and keeps numeric jumps distinct from absolute assignments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Extended Shorthand Modifiers ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Slick Regex parser has been upgraded to natively support equality logic and aliases. Modifiers like >=, <=, =, + (alias for >), and - (alias for <) are now fully supported for both numeric offsets and semantic loops (like wkd).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Jump to next Monday, or stay on Monday if today is Monday
+t.set({ wkd: '>=Mon' });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.3.0] - 2026-06-21 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Localized Modifier Registry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo's relative-date keywords (next, last, this, ago, hence) were previously hardcoded as English-only constructs built into the core regex engine. v3.3.0 opens this up completely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can now register your own locale-specific words for any directional operator using registry.modifiers. These words integrate transparently with all standard parsing paths — prefix position, suffix position, and the high-performance # slick shorthand:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.init({
+  locale: 'fr-FR',            // teaches Tempo French months & weekdays via Intl
+  registry: {
+    modifiers: {
+      '>': ['prochain', 'suivant'],   // "next" synonyms
+      '<': ['dernier', 'passé'],      // "last / previous" synonyms
+      '=': ['ce', 'cette'],           // "this" synonyms
+    }
+  }
+});
+
+new Tempo('vendredi prochain');    // ✅ "next Friday" — fully French
+new Tempo('1 mai prochain');       // ✅ "next May 1st"
+new Tempo('#qtr.dernier');         // ✅ "previous quarter" via slick shorthand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    English keywords (next, last, ago, hence, this) remain active by default and are additively merged — you never lose built-in behaviour when adding your own.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Frozen Default Registry Fixed: The internal Default configuration object is wrapped in a deep-freeze Proxy (secure()). Previously, every Tempo.init() call silently failed to write formats, locales, and modifiers into the frozen registry sub-object, logging three setProperty warnings per call and abandoning the writes. The registry is now correctly shallow-cloned into a mutable copy on initialization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lexer Token Cleanup: All hardcoded English modifier keywords have been stripped from the core regex tokens (Match.modifier, Match.shorthand, Match.slick). The engine now operates purely on symbolic operators (>, <, =, +, -) internally and resolves all natural-language words through the registry at runtime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-filter Guard Accuracy: Refined the numeric-safety guard bypass to trigger only when the input actually contains a registered modifier keyword. Previously the guard was bypassed unconditionally whenever modifier config was present, which could silently accept invalid nanosecond epoch strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡ Slick Modifier Semantics ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Localized slick modifiers behave identically to their symbolic counterparts. #qtr.prochain is an exact alias for #qtr.>:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From inside Q2 (any day from April 1 to June 29) → July 1 (start of Q3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From June 30 (last day of Q2) → July 1 (start of Q3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • From July 1 (first day of Q3) → October 1 (start of Q4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This mirrors how next Friday works: from any non-Friday you get the very next Friday; if you are already on Friday, you get the following Friday. Fully deterministic — "next" always means "the start of the next occurrence of this term".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.3] - 2026-06-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New — Project Scaffolding ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tempo.config.ts Pattern: Introduced centralized project configuration via a discoverable tempo.config.ts / tempo.config.js file. This mirrors the vite.config.ts / tailwind.config.js convention — one file, one place, loaded once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.bootstrap(): A new async entry point that auto-discovers and loads your tempo.config.ts before any domain logic runs. Safe to await at application startup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CLI Scaffold: npx @magmacomputing/tempo scaffold:all bootstraps a tempo.config.ts and HTML sandbox into your project in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.2] - 2026-06-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Compact Date Tokens: New 6-digit compact format tokens {dmy6}, {mdy6}, {ymd6} (e.g. 200626), plus ISO week-of-year helpers {yywy} and {yyww}.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {wy} Rename: The former {ww} token is now {wy} (week-of-year) to eliminate visual ambiguity with structural format tokens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recursive deepMerge Hardened: The Intl options merge pipeline now uses a fully recursive deepMerge rather than a shallow spread, preventing nested keys like intl.dateTimeFormat from clobbering intl.relativeTimeFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Prototype Pollution Guards: Added strict guards against __proto__, constructor, and prototype key assignments in deepMerge and deepFreeze utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.1] - 2026-06-17 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinal Localization Fallback: Added support for custom Intl.PluralRules dictionaries. By supplying an ordinal dictionary inside your global locales registry, Tempo natively evaluates the active plural category (e.g., 'one', 'other') and appends the localized suffix automatically (such as '1er' and '15e' for French).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Improved Cookbook Ergonomics: Extensively reorganized the tempo.cookbook.md to make it easier to read. Related functionality is now logically grouped together—for example, merging native and semantic .add() math examples, and expanding on boundary .set() capabilities.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clarified Configurations: Updated tempo.config.md to remove outdated properties and explicitly document nested options like intl.durationFormat.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • REPL Traps: Added prominent warnings to the documentation about the strict idempotency of Tempo.init(), helping new developers avoid silent configuration failures in hot-reload and REPL environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Alias Collision Prevention: Hardened the sandbox alias detection engine to prevent redundant collision warnings in the console when Tempo.init is invoked in sandboxed contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.2.0] - 2026-06-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multi-lingual Parsing: The locale configuration property now officially accepts an array of strings (string | string[]). This enables the ParseModule to intelligently extract terminology from multiple languages simultaneously, generating a single engine capable of parsing dates from any of the specified locales interchangeably.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl.DateTimeFormatOptions Passthrough: The .format() method now officially supports passing a native Intl.DateTimeFormatOptions object. This provides a highly flexible, "humanized" wrapper around the rigid Temporal API for complex cultural formatting (e.g., Arabic numerals, Japanese Reiwa eras).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • BigInt Overload for Epoch Nanoseconds: The {nano} formatting token (epoch nanoseconds) correctly coerces to and returns a precision-preserving BigInt instead of a string, bypassing standard Number limits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📚 Documentation & Ecosystem ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Domain-Locked Licensing: Stabilized the premium plugin licensing engine with a robust domain-locked validation mechanism.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SSR & VitePress Fixes: Fixed Temporal is not defined crashes during SSR builds and simplified our documentation pipeline by removing heavy Markdown plugins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • New Locale Guides: Added comprehensive Internationalization (tempo.locale.md) guides to the primary navigation structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • O(1) Locale Traceability: Upgraded the internal dictionary architecture. The Normalizer can now resolve the winning language of a matched token in pure O(1) time without any expensive Regex sub-capture scanning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Polyfill Formatting Bypass: Bypassed a known bug in the Temporal polyfill's toLocaleString() method that incorrectly dropped Kanji constraints in Japanese formatting contexts, guaranteeing precise Intl fallback correctness.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parser Map Safety: Architecturally split the internal reverse-lookup into distinct monthMap and weekdayMap dictionaries, eliminating the risk of cross-locale abbreviation collisions (e.g., if "mai" is a month in one language but a weekday in another).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.1.0] - 2026-06-13 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Chained Formatting Modifiers: A powerful new format modifier engine ({mon:locale:upper}) allowing dynamic casing (:upper, :lower), ordinal suffixes (:ord), and deep localization (:locale) dynamically via the native Intl API.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Localization Engine: Global configurations for format: { localize: true } and parse: { localize: true } provide a massive leap forward in out-of-the-box internationalization. Tempo can now intelligently parse localized input (months, weekdays, relative terms like 'demain') and automatically format localized output using memoized, high-performance Intl strategies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global locales Registry: Centralized management for augmenting specific term strings per locale globally across instances via Tempo.init({ locale: 'fr-FR', registry: { locales: { ... } } }).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Intl Instantiation: Upgraded internal architectures to memoize and pool Intl.DateTimeFormat objects seamlessly, ensuring parsing localization generation and output formatting impose virtually zero performance hit on hot execution paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Localization: Upgraded the Term formatting resolution pipeline to support falling back across a strict precedence: Global Registry > Plugin Bundled Dictionary > term's existing label/value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v3.0.0] - 2026-06-08 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Major Breaking Changes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Registry Consolidation: Removed the legacy and deprecated term property from the Discovery configuration object. All Term-based plugins must now be registered via the terms (plural) array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shorthand Configuration Removal: Removed support for shorthand root-level properties in the Discovery object that have been superseded by nested configuration groups:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • relativeTime shorthand has been removed; use intl.relativeTime instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • term shorthand has been removed; use terms instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Parsing Mode: The parser now enforces a stricter guard check by default, reducing the likelihood of "false positive" matches on ambiguous strings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ticker Module Extraction: To lighten the core bundle, the TickerPlugin has been extracted into its own standalone Community plugin (@magmacomputing/tempo-plugin-ticker).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✨ What's New ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Formatting Module Additions: Added new compact date tokens ({dmy}, {mdy}, {ymd}) for generating 8-digit compact date strings (e.g. 24102026). {hhmiss} has been renamed to {hms} for consistency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordinal Tokens: Uppercase variants of standard date tokens ({DAY}, {WW}, {MM}) now output their ordinal string representation (e.g., 24th, 1st, 2nd).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 Migration Path for Tempo.ticker() Users ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are upgrading from v2.x and your application relies on Tempo.ticker(), you will need to update your integration:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Install the Plugin: npm install @magmacomputing/tempo-plugin-ticker
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Register the Plugin: Wire the plugin into your application during initialization:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { Tempo } from '@magmacomputing/tempo';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+
+// Register the extracted plugin
+Tempo.init({
+  plugins: [TickerPlugin]
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🏗️ Internal Refactoring ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero-Fallback Initialization: Cleaned up the Tempo.init() bootstrap logic to remove legacy compatibility layers, resulting in a cleaner internal state and reduced bundle size.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build Pipelines: Fully synchronized build pipelines and TS declarations to ensure vitest and tsc operate seamlessly across local and premium workspaces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/doc/8-project-and-support/releases/v4.x.html b/packages/tempo/public/v4/doc/8-project-and-support/releases/v4.x.html new file mode 100644 index 00000000..87bf247e --- /dev/null +++ b/packages/tempo/public/v4/doc/8-project-and-support/releases/v4.x.html @@ -0,0 +1,124 @@ + + + + + + 📜 Version 4.x History | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📜 Version 4.x History ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.7.0] - 2026-10-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.7.0 brings first-class Roman Numeral Date Support across parsing and formatting, full format-mask round-tripping, and canonical ISO Week-Numbering Getters (.woy and .yow) — providing developer-friendly date handling for archival publishing, epigraphy, and ISO week-calendar schedules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary of Highlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Symmetric Roman Numeral Formatting & Parsing: Format any date token as a Roman numeral using {token:roman} (e.g. {yy:roman}-{mm:roman}-{dd:roman} → XXVI-X-XVI) and round-trip parse it back cleanly with custom format masks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Archival & Epigraphic Date Parsing: Natively parse archival Roman date strings out-of-the-box, such as 14.X.2026, Copyright © MMXXVI, and anno domini MCMXCIV.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict Guard Pre-Filtering: Guard pre-filter prevents accidental false positives by intelligently differentiating Roman numerals from everyday lowercase English words (did, mix, civil).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ISO Week Getters & Tokens: Access ISO week numbering through canonical instance getters .woy (week of year) and .yow (ISO week-numbering year), complemented by {woy}, {woy:raw}, {woy:ord}, and {yow} format tokens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Developer Guide ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Roman Numeral Format Modifiers & Round-Trip Symmetry ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Formatting dates using Roman numerals is now as simple as adding the :roman modifier to any date component:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import { Tempo } from '@magmacomputing/tempo';
+
+const t = new Tempo('2026-10-16');
+
+// Format with Roman numerals
+const romanDate = t.format('{yy:roman}-{mm:roman}-{dd:roman}');
+// 'XXVI-X-XVI'
+
+// Parse it right back with mask symmetry!
+const restored = new Tempo(romanDate, { format: '{yy:roman}-{mm:roman}-{dd:roman}' });
+console.log(restored.format('iso')); // '2026-10-16'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Archival & Inscription Date Lexing ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Archival dates, book copyright lines, and European-style day-RomanMonth-year strings are recognized automatically by the parser:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    new Tempo('14.X.2026').format('iso'); // '2026-10-14'
+new Tempo('MMXXVI').format('iso');     // '2026-01-01'
+new Tempo('Copyright © MMXXVI').year;  // 2026
+new Tempo('anno domini MCMXCIV').year; // 1994

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The lexer introduces dedicated internal tokens:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Rm: Roman month numbers (I through XII).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Ry: Roman years (1–3999).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.dRy: Day-RomanMonth-Year structures (14.X.2026).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Token.Ryy: Archival year expressions (anno domini MMXXVI, Copyright © MMXXVI).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Smart Sequence Guard Validation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To avoid false-positive date matches during natural language parsing, Tempo includes enhanced sequence validation:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Valid uppercase Roman numerals (MMXXVI, XIV) and separator-adjacent Roman months (14.X.2026) are accepted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Common lowercase English words that coincide with Roman letters (did, mix, civil, dim, id) are rejected by the guard filter, preventing unwanted date triggers in standard prose.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Canonical ISO Week-Numbering Getters (.woy & .yow) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Working with ISO week-numbering schedules is now clearer with dedicated instance getters:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const t = new Tempo('2026-01-01');
+
+console.log(t.woy); // 1 (ISO week of year, 1-53)
+console.log(t.yow); // 2026 (4-digit ISO week-numbering year)
+
+// Native token formatting
+t.format('{yow}-W{woy}');     // '2026-W01'
+t.format('Week {woy:ord}');   // 'Week 1st'
+t.format('{woy:raw}');        // '1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: Legacy .ww is deprecated in favor of .woy and will be phased out in v5.0.0. Shorthand .wy and .yw remain available for internal compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Object Key Assertion Primitives & Disambiguation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Underlying utility helpers provide dedicated property assertion and narrowing primitives:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasKey(obj, key, ...guards): Verifies and narrows a single property key using optional type tags ('string', 'number') or predicate functions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasKeys(obj, ...keys): Conjunction check verifying all candidate keys exist simultaneously (AND).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasAnyOf(obj, ...keys): Disjunction check verifying at least one candidate key exists (OR).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • hasNoneOf(obj, ...keys): Exclusion check verifying none of the candidate keys exist (NOT).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.6.0] - 2026-10-11 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.6.0 introduces the Term Lifecycle Hooks Protocol, enabling domain plugins (such as fiscal quarters, seasons, academic calendars, and custom business cycles) to deeply integrate into Tempo's natural language parser, date arithmetic, range boundary snapping, difference calculation, and token formatting — all with zero overhead on standard ISO operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Summary of Highlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Plugins: Customize parsing, ordinal matching, step arithmetic, range boundaries, date spans (.until()/.since()), and formatting for domain terms (#).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standard & Celestial Terms: Standard terms (#qtr, #szn, #zdc, #tod, #sign) and celestial plugins (#solar, #moon, #tide, #astro) natively implement lifecycle hooks for ordinals, cycle diffs, boundary snapping, and sub-attribute formatting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Written & Negative Ordinals: Parse natural expressions like "first Wednesday of October" or "-2nd day of #qtr.2". Custom ordinals and number words can be registered globally or per-instance, with negative ordinals counting backward from month/cycle ends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Enums & Compatibility: Live enumerators are organized under Tempo.enums.*, while classic static getters remain directly accessible with deprecation notices for seamless backward compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dialect Precision & Boundary Shorthands: Escaped literal braces cleanly fall back to dialect parsers, and term boundary shortcuts (start, mid, end) provide fluent range snapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Protocol Architecture ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Well-Known Symbol Lifecycle Protocol (TermHook) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Protected Protocol Symbols: Protects term hooks against naming collisions and dual-package hazards using cross-realm well-known symbols (Symbol.for('magmacomputing/tempo/term/...')):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.parse]: Intercepts explicit #term expressions (e.g. new Tempo('#fiscal.q1')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.ordinal]: Powers anchored ordinal expressions (e.g. Tempo.from('3rd day of #sprint.2', { anchor })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.step]: Enables stepping arithmetic via dictionary mutations (t.add({ '#qtr': 1 }), t.sub({ '#qtr': 1 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.bound]: Snaps boundaries for custom term periods (t.set({ '#term': 'start' | 'mid' | 'end' }), t.set({ start: '#term' }), and t.set('#term.mid')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.diff]: Calculates differences in term units (t1.until(t2, '#term'), t1.since(t2, '#term')).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • [TermHook.format]: Dispatches custom term format tokens (e.g. t.format('{#academic}'), t.format('{#academic:upper}')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Native Term Units in .until() & .since() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Custom Term Differences: Tempo.Unit and Tempo.Until now accept custom term units (#${string}), providing full IDE autocompletion and compile-time type safety when calculating spans between dates:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const quartersRemaining = t1.until(t2, '#quarter');
+const elapsed = t2.since(t1, '#fiscal');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Standard & Celestial Terms Lifecycle Integration ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Natural Range Ordinals: Standard terms (#qtr, #szn, #zdc) implement [TermHook.ordinal], enabling natural ordinal offset expressions like Tempo.from('3rd day of #qtr.2', { anchor }), Tempo.from('-2nd day of #qtr.2', { anchor }), and Tempo.from('last day of #szn.summer', { anchor }) with strict cycle boundary guarding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Unit Differences (.until() & .since()): Standard terms implement [TermHook.diff] via resolveRangeDiff(), calculating elapsed cycle intervals:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      t1.until(t2, '#qtr'); // 3
+t2.since(t1, '#qtr'); // "-3 #qtr"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Token Formatting: Standard terms implement [TermHook.format] via resolveRangeFormat(), resolving top-level keys ({#qtr} → "Q2"), descriptive scopes ({#quarter} → "Second Quarter"), and arbitrary nested sub-attributes ({#qtr.label}, {#szn.symbol}, {#zdc.emoji}, {#sign.animal}, {#tod.hour}) with automatic modifier support ({#qtr.label:upper}).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shared Plugin SDK Utilities: Exported resolveRangeOrdinal, resolveRangeDiff, and resolveRangeFormat via @magmacomputing/tempo/plugin/sdk.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Celestial Plugin Support: Celestial terms (#solar, #moon, #tide, #astro) implement lifecycle hooks for boundary snapping, synodic stepping, interval calculations, and astrological/solar formatting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Unified Tempo.enums Namespace & Extensible Ordinals ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unified Tempo.enums Accessor: Consolidates all live enum dictionaries under Tempo.enums.*. For 100% backward compatibility with existing v4 call sites, legacy static getters on Tempo (ELEMENT, FORMAT, NUMBER, ORDINAL, TIMEZONE, MONTH_DAY, MODE, CACHE, LIMIT) remain available directly on the Tempo class with @deprecated notices.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native Written Word Ordinals: Natively parses natural ordinal expressions like "first Wednesday of October", "second day of next month", "tenth Friday of the year", and "last day of May".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ORDINAL Enumerator: Exported through @magmacomputing/tempo/enums and accessible via Tempo.enums.ORDINAL, mapping words to numeric offsets (current: 0, first: 1 through tenth: 10, last: -1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dynamic & Per-Instance Extensibility: Configure custom ordinals globally via Tempo.init({ registry: { ordinals: { ... } } }) or per-instance via constructor options (new Tempo('...', { registry: { ordinals: { ... } } })). Per-instance ordinals are dynamically compiled into instance regexes without polluting global state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Term Plugin Integration: Directly leveraged by [TermHook.ordinal] for resolving custom term offsets (such as sprint days or fiscal cycles).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. Shorthand Boundary Mutations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct Snap Shorthands: Term boundary selection (start, mid, end) can be expressed directly via dictionary mutations (t.set({ '#term': 'start' | 'mid' | 'end' }), t.set({ start: '#term' })) or property shorthand (t.set('#term.start'), t.set('#term.mid'), t.set('#term.end')).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6. Dialect Mask Precision & Engine Optimization ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dialect Literal Brace Escaping: Added hasNativeFormatBraces to strip dialect-specific escaped literals ([...] in Moment/Day.js, '...' in LDML/Luxon) before testing for native {token} masks, ensuring masks with escaped braces cleanly fall back to external dialect formatters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolated # Sigil Guards: Hook dispatch occurs strictly for domain term expressions (#), ensuring everyday ISO date parsing, standard formatting, and core unit arithmetic bypass hook execution paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Complete Backward Compatibility: Existing term plugins continue to function without any modifications.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.5.1] - 2026-10-05 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Developer Experience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.5.1 focuses on Seamless Dynamic Plugin Loading & Sandbox Resilience, ensuring interactive REPLs, browser playgrounds, and dynamically bundled micro-frontends can load and register plugins on-the-fly without friction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Improvements & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Plugin Registry Resilience ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Late-Loaded Plugin Support: When loading plugins asynchronously via import() inside dynamic environments or browser sandboxes, internal plugin tables are protected with extensible metadata symbols.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copy-on-Write Registrations: Registering terms and plugins after initialization safely falls back to copy-on-write updates on non-extensible registry arrays and pluginsDb objects when the parent container permits reassignment (replacing pluginsDb can still throw a TypeError if the owning state itself is frozen).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.5.0] - 2026-10-02 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.5.0 introduces the Structured t.intl Namespace (intl.info & intl.locale), the high-performance Tempo.intl Formatter Hub, and Hierarchical Translation Token Support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Structured t.intl Sub-Namespace (intl.info & intl.locale) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Clean Regional Metadata (t.intl.info): Regional insights are now cleanly grouped under .info, giving direct access to frozen locale characteristics:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('now', { locale: 'en-AU' });
+console.log(t.intl.info.firstDay);        // 1 (Monday)
+console.log(t.intl.info.weekend);         // [6, 7] (Saturday, Sunday)
+console.log(t.intl.info.hourCycle);       // 'h12'
+console.log(t.intl.info.direction);       // 'ltr'
+console.log(t.intl.info.numberingSystem); // 'latn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native Locale Inspection (t.intl.locale): Inspect the active Intl.Locale instance directly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Backward Compatibility: Top-level convenience properties (like t.intl.firstDay and t.intl.region) remain fully supported throughout the v4.x lifecycle with gentle deprecation notices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Tempo.intl Formatter Hub ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instant Pre-Bound Formatters: Perform standard internationalization formatting directly through static helpers without manually configuring Intl.* classes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Relative Time Formatting
+Tempo.intl.relativeTime(-2, 'days'); // "2 days ago"
+
+// Natural List Formatting
+Tempo.intl.list(['Sydney', 'Tokyo', 'London']); // "Sydney, Tokyo, and London"
+
+// Number & Currency Formatting
+Tempo.intl.number(1234567.89); // "1,234,567.89"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Fast Factory Getters: Access cached constructor factories for dtf() (DateTime), rtf() (RelativeTime), lf() (List), and nf() (Number).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Advanced Format & Translation Capabilities ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Hierarchical Translations: Formatting strings support nested tokens for namespaced plugin keys (e.g. {geo.sphere:locale}).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Combined Timezone Offset Styles: Enhanced time-zone offset formatting modifiers like {offset:iso}, {offset:gmt}, and composite modifiers like {tz:offset:short}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.4] - 2026-09-30 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.4 introduces the Reactive Stream Engine (Reactive<T>) in the utility library, ergonomic Type Casting Helpers (cast<T>()), and explicit Tempo.Interval Types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Reactive Stream Engine (Reactive<T>) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lightweight Event Streaming: Exported via @magmacomputing/tempo/library and the Plugin SDK, Reactive<T> offers push/pull streaming with zero external dependencies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { Reactive } from '@magmacomputing/tempo/library';
+
+const clockStream = new Reactive<string>();
+
+// Subscribe with automatic cleanup via TC39 explicit resource management:
+{
+  using sub = clockStream.on((iso) => console.log('Tick:', iso));
+  clockStream.cast(new Tempo().iso);
+} // Subscription automatically unsubscribes when exiting block!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Async Iteration: Consume events naturally using standard for await (const tick of clockStream) loops.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multicast Fan-Out: High-performance O(1) broadcasting across all active push subscribers and async waiters via stream.cast(value).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Ergonomic Type Casting (cast<T>()) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Replaces awkward (value as unknown as TargetType) double-assertions with a clean runtime and compile-time casting helper:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import { cast } from '@magmacomputing/tempo/library';
+const config = cast<CustomConfig>(rawPayload);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.3] - 2026-09-29 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Performance Boosts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.3 delivers Massive Parsing Speedups via automated regular expression memoization and introduces the public Tempo.cache.weak Object Cache Facade.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Performance ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Public Weak Object Cache (Tempo.cache.weak) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Attach temporary metadata or computed results to object instances without risking memory leaks:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const cache = Tempo.cache.weak<object, ComputedData>();
+cache.set(domElement, { lastUpdated: new Tempo() });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Automated Regular Expression & Date Interning ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto-Evicting Regex Cache: Dynamically compiled braced format masks and layout matchers are cached with garbage-collection-friendly weak maps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Up to 120x Faster Parsing Loops: Repeated ISO parsing and timezone offset conversions are memoized, reducing heap pressure by ~99.9% in high-throughput data processing pipelines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.2] - 2026-09-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.2 enhances Global Multi-Script Language Support in the natural language date parsing engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 Improvements & Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Unicode Multi-Script Keyword Matching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Global Script Support: Natural language relative date parsing (like "next Friday" or localized calendar terms) now uses Unicode character property matching and NFC normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Zero False Collision Warnings: Non-Latin scripts (such as Arabic, Japanese, Chinese, Cyrillic, and Hebrew) are preserved accurately without triggering duplicate alias warnings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.1] - 2026-09-20 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.1 introduces Braced Format Mask Parsing ({format: '...'}) & Wildcards ({*}), Evaluable<T> dynamic format & dialect configuration, and official launch integration for @magmacomputing/tempo-plugin-dialects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Core Braced Format Mask Parsing & Wildcard Matching ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parse structured date strings using Tempo's standard braced token format:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('24-10-2026', { format: '{dd}-{mm}-{yyyy}' });
+const t2 = Tempo.from('2026/10/24 15:30:45', { format: '{yyyy}/{mm}/{dd} {hh}:{mi}:{ss}' });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Candidate Format Arrays: Supply multiple candidate masks to match the first matching format:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo(input, { format: ['{yyyy}-{mm}-{dd}', '{dd}/{mm}/{yyyy}'] });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Wildcard Token {*}: Skip arbitrary substrings or log prefixes without complex regular expressions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo('Log entry [2026-10-24 15:30] server-01', {
+  format: '{*} [{yyyy}-{mm}-{dd} {hh}:{mi}] {*}'
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Actionable Dialect Guidance: Passing unbraced masks (e.g. 'yyyy-MM-dd') without the dialects plugin throws clear guidance directing users to @magmacomputing/tempo-plugin-dialects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dynamic Evaluable<T> Format & Dialect Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration and call-site options for format and dialect now accept dynamic resolver functions (() => string), seamlessly evaluated at runtime via evaluate():
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const t = new Tempo(input, {
+  format: () => getUserPreferredFormat()
+});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Dialects Plugin Integration (@magmacomputing/tempo-plugin-dialects) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Official v1.0.0 release of the Dialects plugin enabling Unicode LDML (Luxon/date-fns), POSIX strftime, and Moment.js mask translation, formatting, and parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.4.0] - 2026-09-18 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.4.0 introduces Order-Independent Plugin Auto-Installation (/install) and global pending queues, bringing zero-boilerplate side-effect imports for browser scripts, quick prototypes, and interactive REPLs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Zero-Boilerplate Side-Effect Imports (/install) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Official and community plugins can now be installed with a single import statement:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      import '@magmacomputing/tempo-plugin-geo/install';
+import '@magmacomputing/tempo-plugin-ai/install';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Order-Independent Registration ($pendingAutoInstalls): If a bundler or browser module loader evaluates a plugin's /install subpath before { Tempo } has finished initializing, registrations are safely buffered in an ambient queue and automatically drained as soon as Tempo boots.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tree-Shaking Preserved: Standard imports (import { GeoPlugin } from '@magmacomputing/tempo-plugin-geo') retain 100% tree-shakeability with zero automatic side-effects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.3.0] - 2026-09-16 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.3.0 brings Colocated Plugin Options & Hybrid Factories, deep Intl.LocaleInfo Regional Calendar Context, and a direct Native Temporal Gateway (t.zdt).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Colocated Plugin Options & Callable Factories ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Vite / Rollup Style Factory Invocations: Plugins constructed via definePlugin now function as hybrid callable factories. Pass options directly at call-site:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo.init({
+  plugins: [
+    TickerPlugin({ interval: 1000 }),
+    [GeoPlugin, { timeout: 5000 }] // Tuple syntax also fully supported!
+  ]
+});
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Uncalled Plugins Retained: Passing uncalled plugins (plugins: [CelestialPlugin]) continues to work seamlessly without breaking changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Intl.Locale Info & Culturally Authentic Calendars (t.intl) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • First-Class Regional Metadata: Direct access via t.intl (and Tempo.intl) providing frozen regional insights (firstDay, weekend, hourCycle, direction, numberingSystem), alongside t.intl.locale for native Intl.Locale inspection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Adaptive Week Arithmetic (localeInfo: true): With localeInfo: true, operations like t.set({ week: 'start' }) automatically align to the locale's culturally authentic first day (e.g. Sunday in the US, Monday in the UK, Saturday in Saudi Arabia).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dedicated ISO Invariants: Use isoWeek and wy (t.set({ isoWeek: 'start' })) to guarantee Monday-start snapping regardless of locale settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Localized Format Tokens: Added {dow:locale}, {hh:locale}, {time:locale}, and localized numeral formatting ({yyyy:locale} producing ٢٠٢٦ in Arabic locales).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Direct Native Temporal Gateway (t.zdt) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct read-only getter t.zdt exposing the underlying Temporal.ZonedDateTime instance for zero-overhead access to native Temporal properties (daysInMonth, inLeapYear, offset, hoursInDay) without method ceremony.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Day-of-Year Property & Token (t.doy, {doy}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Direct t.doy accessor (1..366) and formatting token {doy} with width padding support ({doy:3}).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.2.0] - 2026-09-09 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.2.0 introduces Dynamic Spatial & Namespace Format Tokens and Universal Geographic Context (options.geo).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Namespace & Spatial Tokens in t.format() ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Format strings can now dynamically interpolate active plugin namespaces and spatial properties:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      t.format('{geo.city}, {geo.country} — Fiscal Year: {finance.taxYear}');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supports formatting modifiers such as {geo.country:upper} and {geo.city:title} with graceful fallbacks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Universal Geographic Context & Hemisphere Inferences ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Provide geolocation coordinates directly on instantiation (new Tempo('today', { geo: { lat: -33.86, lng: 151.2 } })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatically infers hemisphere (t.sphere: 'north' | 'south' | 'equator') and exposes frozen t.geo configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Hardened Static Configuration Resolution ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decoupled configuration inheritance (extends) strictly to static data payloads, eliminating dynamic execution vectors and hardening supply chain boundaries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.1.0] - 2026-09-04 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Architectural Enhancements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.1.0 expands enterprise configuration governance and developer ergonomics with Remote & Cascading Configuration Resolution ("extends"), a dedicated pluginOptions Configuration Slot, and Overloaded Tempo.create() with Deterministic Resource Disposal (TC39 using).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Improvements ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Remote & Cascading Configuration Resolution (resolveConfig) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Remote URL Config Fetching: Enhanced resolveConfig() and Tempo.bootstrap() to fetch tempo.config.jsonc and tempo.config.json over http:// and https:// URLs (including http://localhost:... or http://127.0.0.1:... for dev servers, container environments, and central governance APIs).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • file:// URL Support: Added native support for file:// URLs in Node.js environments via fileURLToPath.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Cascading Inheritance ("extends"): Introduced recursive "extends" resolution in configuration files (string URL/path or array of URLs/paths). Parent configurations are resolved and merged under child local overrides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Security Boundaries & Loop Protection: HTTP requests are bounded by a 3-second timeout and 128KB payload size cap to prevent hangs and DoS attacks. Remote configs are restricted to static data-only JSON/JSONC payloads. Circular inheritance is detected and prevented.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Dedicated pluginOptions Configuration Slot ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced pluginOptions?: Record<string, any> across BaseOptions, Discovery, and Config.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enforces clean architectural separation:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • plugins: Strictly reserved for executable code registration (plugins, terms, modules).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • pluginOptions: Dedicated dictionary holding serializable runtime options and defaults for plugins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deep, recursive namespace merging across extends inheritance layers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supplying plain configuration dictionaries directly under plugins is marked @deprecated in favor of pluginOptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Overloaded Tempo.create() & Deterministic Resource Disposal ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Explicit Resource Management (TC39 using): Tempo.create() returns SandboxTempo subclasses that implement the TC39 Disposable protocol (Symbol.dispose) and expose an isDisposed getter. Disposing a sandbox clears its discovery slot from globalThis and cleans up internal registry state (ClassStates).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scoped Callback Mode (Tempo.create(fn) / Tempo.create(options, fn)): Overloaded Tempo.create() to accept an execution callback, automatically disposing the ephemeral sandbox upon completion (supporting both synchronous results and async Promises via try...finally).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Native using Block Scoping: Full support for TypeScript 5.2+ block-scoped disposable sandboxes: { using sb = Tempo.create({ ... }); ... }.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Architectural Separation of extends and plugins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extends: Strictly reserved for configuration inheritance via URLs or file paths (string | string[]), mirroring tsconfig.json and ESLint conventions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • plugins: Dedicated for registering executable plugins and terms ((Plugin | Term)[]).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.use() & Deprecation of Tempo.extend(): Standardized Tempo.use(...) as the runtime registration method. Marked Tempo.extend() as @deprecated Use Tempo.use(...) instead. while preserving backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🐛 Bug Fixes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sandbox Symbol.dispose Global State Leakage: Fixed a critical bug where invoking [Symbol.dispose]() on a sandbox class (e.g., via the TC39 using keyword or scoped callback mode) inherited Tempo[Symbol.dispose]() via the prototype chain and inadvertently executed Tempo.init(), wiping the global library configuration and registered plugins. Sandboxed classes now implement an isolated [Symbol.dispose]() that strictly cleans up local sandbox state and discovery slots without mutating global defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [v4.0.0] - 2026-08-27 ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚀 Key Highlights & Paradigm Shifts ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo v4.0.0 is a major architectural milestone introducing Dynamic Functional Context (DFC), a 100% Open-Source Community Core, zero-await Synchronous JSONC Config Discovery, standardized Plugin SDK Facade, and unified {Term: Value} Mutation Payloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚨 Major Breaking Changes ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 100% Open-Source Community Core: Completely removed commercial licensing enforcement, JWT verification, JWS claims validation, domain-locking, and premium plugin gating (license.manager.ts, license.validator.ts, Tempo.license, validateLicenseState, LICENSE enum, and $updateScopeStatus).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Commercial Package Decoupling: Relocated all enterprise licensing hooks and commercial plugin management to the @magmacomputing/tempo-pro wrapper package.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Config Auto-Discovery Modernization: Dropped .cjs configuration discovery support in favor of modern ES-preferred module extensions (.mts, .ts, .mjs, .js, .jsonc, .json).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tempo.ready() Return Signature: Simplified Tempo.ready() return value to a static 'none' status for community core compatibility.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuration Namespace Enforcement: Fully excised legacy root-level property access that was deprecated during v3.x.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • formats configuration key has been entirely removed from top-level Options and Discovery. Use registry: { formats: ... } instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • numbers configuration key has been entirely removed from top-level Options. Use registry: { numbers: ... } instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🌟 New Features & Architectural Modernizations ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Dynamic Functional Context (DFC) & Options Evaluation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Upgraded BaseOptions and Tempo options (timeZone, locale, calendar, sphere) to support Evaluable<T> suppliers (T | (() => T)).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Context options are dynamically evaluated on a per-request basis without requiring instantiation or re-building configuration state, perfect for multi-tenant applications (e.g., dynamic request headers or per-tenant session resolvers).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Synchronous JSON & JSONC Config Discovery (resolveConfigSync) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Introduced zero-await static startup configuration discovery (resolveConfigSync()) utilizing parseJSONC for .jsonc and .json files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ESM and TypeScript config modules (.mts, .ts, .mjs, .js) continue to utilize the asynchronous resolveConfig() path.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatically executed inside Tempo's static { ... } initialization block at module load time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Standardized Plugin SDK Facade (@magmacomputing/tempo/plugin/sdk) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized plugin development on @magmacomputing/tempo/plugin/sdk, replacing legacy plugin-api imports.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Exposes definePlugin, defineTerm, defineModule, defineNamespace, defineRange, and internal evaluation utilities via a single, CDN-friendly facade.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. Expanded Utility Stack Exports (@magmacomputing/tempo/library) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Re-exported core evaluation and runtime primitives (Evaluable, AsyncEvaluable, evaluate, evaluateAsync, evaluateConfig, evaluateConfigAsync, dynamicProxy, Pledge, cipher, webToken, enumify) via the @magmacomputing/tempo/library export surface for downstream plugins and custom extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5. API Standardization for Boundary & Mutation Payloads ({Term: Value}) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Standardized mutation object signatures across .set(), .add(), and plugin payloads to follow the unified {Term: Value} pattern (e.g., .set({ year: 'start' }), .set({ month: 'end' }), .set({ '#qtr': 1 })).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Legacy positional syntax (e.g., .set({ start: 'year' })) remains supported transparently for backwards compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🗑️ API Removals & Cleanups ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed Static Accessors: Removed Tempo.formats accessor; use Tempo.registry.formats instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removed Deprecated Subpaths: Removed #tempo/license export mapping.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/esm_core.index.html b/packages/tempo/public/v4/esm_core.index.html new file mode 100644 index 00000000..ea8de4ed --- /dev/null +++ b/packages/tempo/public/v4/esm_core.index.html @@ -0,0 +1,265 @@ + + + + + + Tempo ESM Lite Test + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ESM Lite Build
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + import { Tempo } from '@magmacomputing/tempo/core'; +import { MutateModule } from '@magmacomputing/tempo/mutate'; + +Tempo.extend(MutateModule); +const t = new Tempo().add({ days: 1 }); +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Result +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Temporal...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Output also available in the developer console. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/esm_full.index.html b/packages/tempo/public/v4/esm_full.index.html new file mode 100644 index 00000000..13f30542 --- /dev/null +++ b/packages/tempo/public/v4/esm_full.index.html @@ -0,0 +1,257 @@ + + + + + + Tempo ESM Lite Test + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ESM Lite Build
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + import { Tempo } from '@magmacomputing/tempo'; + +const t = new Tempo().add({ days: 1 }); +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Result +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Temporal...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Output also available in the developer console. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/esm_sh.index.html b/packages/tempo/public/v4/esm_sh.index.html new file mode 100644 index 00000000..ea6ea55e --- /dev/null +++ b/packages/tempo/public/v4/esm_sh.index.html @@ -0,0 +1,301 @@ + + + + + + + Tempo esm.sh Test + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    esm.sh Smart CDN Test
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + import '@js-temporal/polyfill'; +import { Tempo } from '@magmacomputing/tempo'; + +const t = new Tempo('next friday'); +t.format('{mon} {dd:raw}'); +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Result +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Temporal...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Output also available in the developer console. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/hashmap.json b/packages/tempo/public/v4/hashmap.json new file mode 100644 index 00000000..9ee71e9e --- /dev/null +++ b/packages/tempo/public/v4/hashmap.json @@ -0,0 +1 @@ +{"contributing.md":"CcocJclI","doc_1-getting-started_ai-integration.md":"BZMrNeW6","doc_1-getting-started_installation.md":"CJJI9Qtd","doc_1-getting-started_tempo.cookbook.md":"BTs_Rb_Y","doc_1-getting-started_tempo.repl.md":"Be6Mnegx","doc_2-core-concepts_tempo.cache.md":"DC5v2nZ0","doc_2-core-concepts_tempo.config.md":"CCVR1kyn","doc_2-core-concepts_tempo.duration.md":"C8tFRYva","doc_2-core-concepts_tempo.format.md":"CnjB55c2","doc_2-core-concepts_tempo.getters.md":"DNLIMJ-B","doc_2-core-concepts_tempo.interval.md":"ekIBwDM2","doc_2-core-concepts_tempo.mutate.md":"pL4xn7XU","doc_2-core-concepts_tempo.parse.md":"DjDPsHhD","doc_3-extending-tempo_ecosystem.md":"CVsJ_cls","doc_3-extending-tempo_tempo.extension.md":"DTm8-Lvc","doc_3-extending-tempo_tempo.layout.md":"BkxWkK6_","doc_3-extending-tempo_tempo.modularity.md":"BgMZMuGP","doc_3-extending-tempo_tempo.namespace.md":"N8lEDe0_","doc_3-extending-tempo_tempo.plugin.md":"BzPg5rhy","doc_3-extending-tempo_tempo.registry.md":"DETutRWD","doc_3-extending-tempo_tempo.term.md":"CEKveWAD","doc_4-advanced-reference_sandbox-factory.md":"CkHhycey","doc_4-advanced-reference_tempo.debugging.md":"IJqQ10ZR","doc_4-advanced-reference_tempo.intl.md":"CWGPkHoo","doc_4-advanced-reference_tempo.planner.md":"bxTXGqP7","doc_4-advanced-reference_tempo.shorthand.md":"Y4AXHmBr","doc_4-advanced-reference_tempo.weekday.md":"Ddy-N3v_","doc_5-architecture-and-internals_architecture.md":"0jD-ZGOD","doc_5-architecture-and-internals_lazy-evaluation-pattern.md":"CVU82iN_","doc_5-architecture-and-internals_soft_freeze_strategy.md":"CTiWNYBs","doc_5-architecture-and-internals_tempo.benchmarks.md":"CXZ3BzvK","doc_6-utility-library_tempo.enumerators.md":"Csq1zWUC","doc_6-utility-library_tempo.library.md":"CFDR8vK6","doc_6-utility-library_tempo.pledge.md":"Cb7-u_mT","doc_6-utility-library_tempo.reactive.md":"Cr92yDbJ","doc_6-utility-library_tempo.serializers.md":"CEZ8my07","doc_7-ecosystem_comparison.md":"B9HAtuQF","doc_7-ecosystem_extending-temporal.md":"DwO8Wlze","doc_7-ecosystem_vision.md":"D1ERmYL4","doc_8-project-and-support_commercial.md":"BiO4Lygj","doc_8-project-and-support_migration-guide.md":"DqJQcvlj","doc_8-project-and-support_releases_index.md":"GiHF45Dm","doc_8-project-and-support_releases_v0.x.md":"QAGHuEEy","doc_8-project-and-support_releases_v1.x.md":"Db-bMcxJ","doc_8-project-and-support_releases_v2.x.md":"DLrHz2MI","doc_8-project-and-support_releases_v3.x.md":"CK4PnQ-6","doc_8-project-and-support_releases_v4.x.md":"BIqG5RLx","doc_9-plugins__setup.index.md":"BnCV1I9W","doc_9-plugins_ai.architecture.md":"CCj_oaug","doc_9-plugins_ai.context.md":"CpTdp7nz","doc_9-plugins_ai.diff.md":"BYs4NFiQ","doc_9-plugins_ai.extract.md":"C5CeS4nG","doc_9-plugins_ai.format.md":"Coh7SWV_","doc_9-plugins_ai.grounding.md":"C_kPBIVa","doc_9-plugins_ai.index.md":"rTtq43n1","doc_9-plugins_ai.init.md":"hCf30wXQ","doc_9-plugins_ai.modes.md":"JT-kGfff","doc_9-plugins_ai.onboarding.md":"DZY17T47","doc_9-plugins_ai.parse.md":"DjpOjI9I","doc_9-plugins_ai.rate-limits.md":"b5TsWC2C","doc_9-plugins_ai.recurrence.md":"TD2CI-q_","doc_9-plugins_ai.schedule.md":"DLknXOHY","doc_9-plugins_ai.security.md":"DUzWk1EB","doc_9-plugins_ai.use-cases-and-patterns.md":"CMIx3E8I","doc_9-plugins_batch.index.md":"BsL4sRb1","doc_9-plugins_batch.use-cases-and-patterns.md":"B1JvH9aH","doc_9-plugins_batch.worker-architecture.md":"CdcNvo1Q","doc_9-plugins_celestial.astro.md":"BAuT_4-r","doc_9-plugins_celestial.index.md":"BEuS8lC9","doc_9-plugins_celestial.lunar.md":"De_P3K-r","doc_9-plugins_celestial.solar.md":"DC44WQqc","doc_9-plugins_celestial.tidal.md":"Bptft1Ks","doc_9-plugins_celestial.use-cases-and-patterns.md":"Bt45gZQ8","doc_9-plugins_dialects.design-philosophy-and-omissions.md":"9FbR7tUo","doc_9-plugins_dialects.index.md":"vhrHfiBB","doc_9-plugins_dialects.migration-and-compatibility.md":"BhzaGPKq","doc_9-plugins_dialects.token-specification.md":"BaBJmFN6","doc_9-plugins_dialects.use-cases-and-patterns.md":"BKd6k2jk","doc_9-plugins_finance.index.md":"CughzpD9","doc_9-plugins_geo.cultural-sync.md":"CPpBygZ9","doc_9-plugins_geo.index.md":"DxETixJP","doc_9-plugins_geo.provider-gateway.md":"Djynjt20","doc_9-plugins_geo.storage-and-caching.md":"CjgH3ITl","doc_9-plugins_geo.use-cases-and-patterns.md":"lWL9YkMu","doc_9-plugins_holidays.business-days.md":"BYOLhXcr","doc_9-plugins_holidays.index.md":"jPHTM0ST","doc_9-plugins_holidays.regional-calendars.md":"DW1vfRjd","doc_9-plugins_holidays.use-cases-and-patterns.md":"CHmR90E9","doc_9-plugins_ntp.algorithms-and-precision.md":"3JO-q5xY","doc_9-plugins_ntp.index.md":"BS3pht0N","doc_9-plugins_ntp.ticker-integration.md":"BysX5Afz","doc_9-plugins_ntp.use-cases-and-patterns.md":"BGQwe7LQ","doc_9-plugins_roman.calendar-mechanics.md":"Dxfr-GWH","doc_9-plugins_roman.index.md":"D6RGBtx3","doc_9-plugins_roman.use-cases-and-patterns.md":"BRabEtkW","doc_9-plugins_snap.index.md":"CCS6zQLh","doc_9-plugins_snap.use-cases-and-patterns.md":"B9Ns7Nr6","doc_9-plugins_spatial.geofencing.md":"COTSxksf","doc_9-plugins_spatial.index.md":"DgkWwXEr","doc_9-plugins_spatial.solar-offset.md":"BmjcYvEl","doc_9-plugins_spatial.transit-and-navigation.md":"Dh_dl4dL","doc_9-plugins_spatial.use-cases-and-patterns.md":"C630dCxp","doc_9-plugins_sync.atomic-architecture.md":"TRzGWYv8","doc_9-plugins_sync.index.md":"D7OIe-8G","doc_9-plugins_sync.use-cases-and-patterns.md":"Dewhm-VI","doc_9-plugins_ticker.index.md":"BdxzIC1U","doc_9-plugins_ticker.intervals-and-scheduling.md":"JNF-XJuK","doc_9-plugins_ticker.reactive-clocks-and-events.md":"oh5ZPvW6","doc_9-plugins_ticker.resource-management.md":"D--mENjq","doc_9-plugins_ticker.use-cases-and-patterns.md":"D3y-b9SZ","index.md":"BXrX0Bcg","readme.md":"BEdbpgCY","security.md":"CSgJK_tg","src_plugin_extend_readme.md":"kJGNE0p7","test_readme.md":"DVuOleBg"} diff --git a/packages/tempo/public/v4/index.html b/packages/tempo/public/v4/index.html new file mode 100644 index 00000000..39c76419 --- /dev/null +++ b/packages/tempo/public/v4/index.html @@ -0,0 +1,70 @@ + + + + + + Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Professional Date-Time Library for the Temporal API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Get StartedView on GitHub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Loading...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business & Financial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native support for fiscal quarters, zodiac cycles, and meteorological seasons for finance and analytics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Cost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lazy evaluation and smart matching ensure instantiation overhead is near-zero.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎯

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural Language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Semantic parsing for events and periods. Resolve human-readable strings with zero configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo AI Engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural language date parsing, multi-provider dispatch (OpenAI, Gemini, Groq, Mistral), and slot resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⏱️

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo.ticker()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Community Plugin: State-of-the-art timing engine with AsyncGenerator support and native Daylight Saving Time resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔌

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Modular Plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extend Tempo with specialized plugins for Snapping, High-Throughput Batching, and AI dispatch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🧭

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Humanizing Temporal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Transforming low-level Temporal complexity into intuitive, expressive APIs—anchored in a rock-solid ISO 8601 baseline with native regional calendar awareness.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🔄

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cycle Persistence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Shift by semantic terms while preserving your relative day-of-period offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📈

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Business & Financial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Native support for fiscal quarters, zodiac cycles, and meteorological seasons for finance and analytics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ⚡

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Zero-Cost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lazy evaluation and smart matching ensure instantiation overhead is near-zero.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🎯

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural Language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Semantic parsing for events and periods. Resolve human-readable strings with zero configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🤖

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo AI Engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Natural language date parsing, multi-provider dispatch (OpenAI, Gemini, Groq, Mistral), and slot resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/library-logo.svg b/packages/tempo/public/v4/library-logo.svg new file mode 100644 index 00000000..ec7fd7c4 --- /dev/null +++ b/packages/tempo/public/v4/library-logo.svg @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/tempo/public/v4/llms.txt b/packages/tempo/public/v4/llms.txt new file mode 100644 index 00000000..eeeb84b8 --- /dev/null +++ b/packages/tempo/public/v4/llms.txt @@ -0,0 +1,103 @@ +# Tempo: Immutable Date-Time Engine & AI Syntax Rules (v4.7.0) + +> Tempo (v4.7.0) is an immutable TypeScript date-time engine built around the ECMAScript Temporal API. It provides type-safe parsing, formatting, relative time arithmetic, and extensible layout matching across Browser and Node.js environments. + +## Core Architectural Rules & Philosophy +- **Temporal Engine**: Tempo uses native `Temporal` in modern runtimes or `@js-temporal/polyfill`. Never instantiate legacy JavaScript `Date`. +- **Strict Immutability**: `Tempo` instances are completely frozen (`Object.freeze`). All mutating operations (`add`, `subtract`, `set`) return a new `Tempo` instance. +- **Constructor & Static Factory**: Instantiation and string parsing use `new Tempo(...)` or static `Tempo.from(...)`. +- **Live Getters**: Core property accessors use short layout tokens: `.yy` (year), `.mm` (month), `.dd` or `.day` (day of month), `.hh` (hour), `.mi` (minute), `.ss` (second), `.ms` (millisecond), `.us` (microsecond), `.ns` (nanosecond), `.dow` (day of week 1-7), `.doy` (day of year 1-366), `.wy` (week of year), `.tz` (timeZone ID), `.cal` (calendar ID), `.ts` (timestamp ms), `.iso` (ISO 8601 UTC string), `.isValid`. *(Note: Long getters like `.year`, `.month`, `.hour`, `.minute`, `.second` do not exist directly on Tempo instances).* +- **Configuration & Plugins**: System options and plugin registration are configured via `Tempo.init({ timeZone: 'UTC', monthDay: true, plugins: [Plugin], registry: { layouts: { ... }, formats: { ... }, numbers: { ... } } })`. Cascading configuration is inherited via `extends: 'https://...'`. Core functionality can also be extended dynamically via `Tempo.use(Plugin)`. + +## Formatting & Parsing Tokens +| Token | Description | Sample Output | +| :--- | :--- | :--- | +| `{yyyy}` | 4-digit Year | `2026` | +| `{yy}` | 2-digit Year | `26` | +| `{mon}` | Full Month Name | `August` | +| `{mmm}` | Short / Abbreviated Month Name | `Aug` | +| `{mm}` | Zero-padded Month number (01-12) | `08` | +| `{dd}` | Zero-padded Day of month (01-31) | `04` | +| `{wkd}` | Full Weekday Name | `Tuesday` | +| `{www}` | Short / Abbreviated Weekday Name | `Tue` | +| `{dow}` | ISO Day of Week (1=Monday .. 7=Sunday) | `2` | +| `{doy}` | Day of year (1-366) | `216` | +| `{hh}` | Hour (00-24) | `15` | +| `{mi}` | Minute (00-59) | `30` | +| `{ss}` | Second (00-59) | `00` | +| `{tz}` | Time zone offset / identifier | `Z`, `+10:00`, `Australia/Sydney` | +| `{yw}` | ISO Week-Year number | `2026` | +| `{wy}` | Zero-padded ISO Week of Year (01-53) | `32` | +| `{unt}` | Time unit keyword | `day`, `month`, `year` | +| `{*}` | Wildcard placeholder in format masks | Matches any arbitrary substring | + +## Key Module Links +- [Full Documentation Concatenation](/llms-full.txt): Complete raw markdown documentation for RAG ingestion. +- [AI Plugin Capabilities](https://github.com/magmacomputing/magma/tree/main/packages/plugins/ai): Natural language parsing (`parseAI`), slot scheduling (`scheduleAI`), and recurrence rule resolution (`recurrenceAI`). +- [Dialects Plugin](https://github.com/magmacomputing/magma/tree/main/packages/plugins/dialects): Interoperability with Unicode LDML / Luxon, POSIX strftime, and Moment.js format masks, plus migration helper via `Tempo.dialects.explain()`. +- [Layout Patterns & Regex Snippets](https://github.com/magmacomputing/magma/tree/main/packages/tempo/doc/3-extending-tempo/tempo.layout.md): Guide to writing regex layouts and snippets. +- [Plugin Development](https://github.com/magmacomputing/magma/tree/main/packages/tempo/doc/3-extending-tempo/tempo.plugin.md): Rules for extending Tempo via plugins. +- [Utility Library](https://github.com/magmacomputing/magma/tree/main/packages/tempo/doc/6-utility-library/tempo.library.md): Type detection, serialization (`stringify`/`objectify`), reactive streams (`Reactive`), and deferred promises (`Pledge`). + +## Common Code Snippets & Patterns + +### 1. Basic Instantiation & Formatting +```typescript +import { Tempo } from '@magmacomputing/tempo'; + +// Create from current instant or ISO 8601 string +const t = new Tempo('2026-08-04T15:30:00Z'); + +// Format using layout tokens +t.format('{mon} {dd}, {yyyy}'); // "August 04, 2026" + +// Immutably manipulate date +const nextWeek = t.add({ days: 7 }); +``` + +### 2. Relative Shorthand & Arithmetic +```typescript +import { Tempo } from '@magmacomputing/tempo'; + +// Instantiation with relative expressions or durations +const t1 = new Tempo('next Friday'); +const t2 = new Tempo('in 3 days'); + +// Immutable boundary & arithmetic helpers via .set() +const startOfMonth = new Tempo().set({ month: 'start' }); +const endOfYear = new Tempo().set({ year: 'end' }); +const inTwoHours = new Tempo().add({ hours: 2 }); +``` + +### 3. Instance Options (Timezone & Locale) +```typescript +import { Tempo } from '@magmacomputing/tempo'; + +// ISO 8601 strings parse directly via constructor +const tIso = new Tempo('2026-08-04T15:30:00+10:00'); + +// Pass instance options as the second parameter +const tSydney = new Tempo('2026-08-04T15:30:00', { timeZone: 'Australia/Sydney' }); +``` + +### 4. System Initialization & Month-Day / Custom Layout Configuration +```typescript +import { Tempo } from '@magmacomputing/tempo'; + +// 1. Configure US Month-First Parsing for ambiguous slash dates ('08/04/2026' -> August 4th) +Tempo.init({ + timeZone: 'UTC', + monthDay: true // or locale: 'en-US' +}); +const usDate = new Tempo('08/04/2026'); // Month: 8 (August), Day: 4 + +// 2. Register custom layout patterns for non-standard formats via registry (escape regex meta-characters as needed, e.g. '\\*') +Tempo.init({ + registry: { + layouts: { + star_date: '{mm}\\*{dd}\\*{yy}' + } + } +}); +const customDate = new Tempo('08*04*2026'); // Automatically matched against star_date layout +``` diff --git a/packages/tempo/public/v4/plugin-logo.svg b/packages/tempo/public/v4/plugin-logo.svg new file mode 100644 index 00000000..53b62c27 --- /dev/null +++ b/packages/tempo/public/v4/plugin-logo.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/pro-logo.svg b/packages/tempo/public/v4/pro-logo.svg new file mode 100644 index 00000000..d0e3bc6f --- /dev/null +++ b/packages/tempo/public/v4/pro-logo.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/packages/tempo/public/v4/providers.v1.json b/packages/tempo/public/v4/providers.v1.json new file mode 100644 index 00000000..06b19a82 --- /dev/null +++ b/packages/tempo/public/v4/providers.v1.json @@ -0,0 +1,54 @@ +{ + "version": "1.1", + "updatedAt": "2026-10-07T00:00:00Z", + "providers": { + "groq": { + "url": "https://api.groq.com/openai/v1/chat/completions", + "models": { + "default": "openai/gpt-oss-120b", + "fast": "openai/gpt-oss-120b", + "large": "openai/gpt-oss-120b", + "reasoning": "openai/gpt-oss-120b" + }, + "tokenParam": "max_tokens" + }, + "openai": { + "url": "https://api.openai.com/v1/chat/completions", + "models": { + "default": "gpt-5.4-mini", + "fast": "gpt-5.4-mini", + "reasoning": "o3-mini" + }, + "tokenParam": "max_completion_tokens" + }, + "gemini": { + "url": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions", + "models": { + "default": "gemini-3.7-flash", + "fast": "gemini-3.7-flash", + "reasoning": "gemini-2.5-pro" + }, + "tokenParam": "max_tokens" + }, + "mistral": { + "url": "https://api.mistral.ai/v1/chat/completions", + "models": { + "default": "mistral-small-latest", + "fast": "mistral-small-latest", + "large": "mistral-large-latest" + }, + "tokenParam": "max_tokens" + }, + "tempo": { + "url": "https://tempo.magmacomputing.com.au/api/ai/tempo", + "models": { + "default": "openai/gpt-oss-120b", + "fast": "openai/gpt-oss-120b", + "large": "openai/gpt-oss-120b", + "reasoning": "openai/gpt-oss-120b" + }, + "tokenParam": "max_tokens", + "key": "tempo-public-sandbox-token" + } + } +} diff --git a/packages/tempo/public/v4/providers.v1.jsonc b/packages/tempo/public/v4/providers.v1.jsonc new file mode 100644 index 00000000..ffde04d8 --- /dev/null +++ b/packages/tempo/public/v4/providers.v1.jsonc @@ -0,0 +1,62 @@ +{ + // Tempo AI Plugin - Dynamic Remote Provider Manifest v1.1 + // Hosted at: https://tempo.magmacomputing.com.au/providers.v1.jsonc (and .json) + // Consumed automatically by @magmacomputing/tempo-plugin-ai during initAI() + "version": "1.1", + "updatedAt": "2026-10-07T00:00:00Z", + "providers": { + // Groq: High-speed open weights inference + "groq": { + "url": "https://api.groq.com/openai/v1/chat/completions", + "models": { + "default": "openai/gpt-oss-120b", + "fast": "openai/gpt-oss-120b", + "large": "openai/gpt-oss-120b", + "reasoning": "openai/gpt-oss-120b" + }, + "tokenParam": "max_tokens" + }, + // OpenAI: Modern GPT series + "openai": { + "url": "https://api.openai.com/v1/chat/completions", + "models": { + "default": "gpt-5.4-mini", + "fast": "gpt-5.4-mini", + "reasoning": "o3-mini" + }, + "tokenParam": "max_completion_tokens" + }, + // Google Gemini: Multimodal flash & reasoning + "gemini": { + "url": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions", + "models": { + "default": "gemini-3.7-flash", + "fast": "gemini-3.7-flash", + "reasoning": "gemini-2.5-pro" + }, + "tokenParam": "max_tokens" + }, + // Mistral AI: European low-latency models + "mistral": { + "url": "https://api.mistral.ai/v1/chat/completions", + "models": { + "default": "mistral-small-latest", + "fast": "mistral-small-latest", + "large": "mistral-large-latest" + }, + "tokenParam": "max_tokens" + }, + // Tempo: Zero-setup evaluation trial sandbox + "tempo": { + "url": "https://tempo.magmacomputing.com.au/api/ai/tempo", + "models": { + "default": "openai/gpt-oss-120b", + "fast": "openai/gpt-oss-120b", + "large": "openai/gpt-oss-120b", + "reasoning": "openai/gpt-oss-120b" + }, + "tokenParam": "max_tokens", + "key": "tempo-public-sandbox-token" + } + } +} \ No newline at end of file diff --git a/packages/tempo/public/v4/registry-logo.svg b/packages/tempo/public/v4/registry-logo.svg new file mode 100644 index 00000000..ed538966 --- /dev/null +++ b/packages/tempo/public/v4/registry-logo.svg @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/repl/index.html b/packages/tempo/public/v4/repl/index.html new file mode 100644 index 00000000..a934248e --- /dev/null +++ b/packages/tempo/public/v4/repl/index.html @@ -0,0 +1,1379 @@ + + + + + + + Tempo Interactive REPL + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + Tempo Live Sandbox +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + Full REPL ↗ + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + Tempo + Interactive REPL +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + ⚙️ + Setup: Default (Core + Geo + Celestial) +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Code Editor (JavaScript / ES Modules) + Preloaded: Tempo, + Temporal +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Evaluation Return Value +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 0 ms +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Sandbox...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Console Stream + 0 logs +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Loading Temporal & Tempo via esm.sh... +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Shortcut: Ctrl + Enter to run +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/repl/plugins.manifest.js b/packages/tempo/public/v4/repl/plugins.manifest.js new file mode 100644 index 00000000..27b05209 --- /dev/null +++ b/packages/tempo/public/v4/repl/plugins.manifest.js @@ -0,0 +1,67 @@ +/** + * Generated by `tempo-cli catalog-sync` — DO NOT EDIT DIRECTLY. + * Source: packages/plugins/.setup/catalog.json + */ + +export const SUPPORTED_EXTRA_PLUGINS = { + "celestial": { + name: "@magmacomputing/tempo-plugin-celestial", + version: "1.2.0", + loader: () => import("@magmacomputing/tempo-plugin-celestial").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-celestial" + "@1.2.0")) + }, + "batch": { + name: "@magmacomputing/tempo-plugin-batch", + version: "1.2.1", + loader: () => import("@magmacomputing/tempo-plugin-batch").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-batch" + "@1.2.1")) + }, + "finance": { + name: "@magmacomputing/tempo-plugin-finance", + version: "1.1.0", + loader: () => import("@magmacomputing/tempo-plugin-finance").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-finance" + "@1.1.0")) + }, + "snap": { + name: "@magmacomputing/tempo-plugin-snap", + version: "1.4.0", + loader: () => import("@magmacomputing/tempo-plugin-snap").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-snap" + "@1.4.0")) + }, + "sync": { + name: "@magmacomputing/tempo-plugin-sync", + version: "1.1.2", + loader: () => import("@magmacomputing/tempo-plugin-sync").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-sync" + "@1.1.2")) + }, + "ai": { + name: "@magmacomputing/tempo-plugin-ai", + version: "2.3.1", + loader: () => import("@magmacomputing/tempo-plugin-ai").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-ai" + "@2.3.1")) + }, + "ticker": { + name: "@magmacomputing/tempo-plugin-ticker", + version: "2.6.0", + loader: () => import("@magmacomputing/tempo-plugin-ticker").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-ticker" + "@2.6.0")) + }, + "geo": { + name: "@magmacomputing/tempo-plugin-geo", + version: "1.4.2", + loader: () => import("@magmacomputing/tempo-plugin-geo").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-geo" + "@1.4.2")) + }, + "dialects": { + name: "@magmacomputing/tempo-plugin-dialects", + version: "1.1.0", + loader: () => import("@magmacomputing/tempo-plugin-dialects").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-dialects" + "@1.1.0")) + }, + "holidays": { + name: "@magmacomputing/tempo-plugin-holidays", + version: "1.0.2", + loader: () => import("@magmacomputing/tempo-plugin-holidays").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-holidays" + "@1.0.2")) + }, + "spatial": { + name: "@magmacomputing/tempo-plugin-spatial", + version: "1.0.1", + loader: () => import("@magmacomputing/tempo-plugin-spatial").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-spatial" + "@1.0.1")) + }, + "ntp": { + name: "@magmacomputing/tempo-plugin-ntp", + version: "1.0.0", + loader: () => import("@magmacomputing/tempo-plugin-ntp").catch(() => import('https://esm.sh/' + "@magmacomputing/tempo-plugin-ntp" + "@1.0.0")) + } +}; diff --git a/packages/tempo/public/v4/repl/showcase.html b/packages/tempo/public/v4/repl/showcase.html new file mode 100644 index 00000000..968b1b52 --- /dev/null +++ b/packages/tempo/public/v4/repl/showcase.html @@ -0,0 +1,1665 @@ + + + + + + + Tempo Interactive Showcase & Workbench + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Tempo Showcase + Interactive Feature Workbench +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + ● + UTC +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 1. Anchor Date / Natural Expression + ⚡ Core Engine Active +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Evaluating... +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Presets: + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 2. Live Layout & Format String Tester + Instant Keystroke Preview +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Tokens: + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Presets: + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 3. Chained Mutation Bench (.add / .set) + None +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + Evaluating... +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 4. Duration & Relative Delta Engine + .until() / .since() +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Presets: + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + Evaluating... +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Days
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hours
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Minutes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Weeks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + 📄 + Generated TypeScript Code + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Initializing Tempo Engine...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Loading Tempo modules via esm.sh... +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Tempo v4.3.0 Client-Side Workbench +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/repl/snippets.manifest.js b/packages/tempo/public/v4/repl/snippets.manifest.js new file mode 100644 index 00000000..a048e6f6 --- /dev/null +++ b/packages/tempo/public/v4/repl/snippets.manifest.js @@ -0,0 +1,415 @@ +/** + * AUTO-GENERATED ASSET — DO NOT EDIT DIRECTLY. + * Source: packages/tempo/.vitepress/theme/data/snippets.manifest.js + * Synchronized by: node bin/build-catalog.mjs + */ +/** + * Tempo Central Snippets & REPL Presets + * Single Source of Truth for documentation live REPLs and the playground. + * + * @typedef {Object} SnippetPreset + * @property {string} label - Display label for preset dropdown menus + * @property {string} code - Executable JavaScript snippet code + * @property {boolean} [autoRun] - Set false to disable auto-running on keypress (e.g. AI token quota conservation) + * @property {string} [plugin] - Plugin package this preset demonstrates (omit for core, non-plugin presets) + */ + +/** @type {Record} */ +export const SNIPPETS = { + // ── 1. Core & Non-Plugin Features (Cookbook & Foundations) ─────────────── + quickstart: { + label: 'Preset: Quick Start (Core)', + code: `// ⚡ Quick Start with Tempo +const t = new Tempo('now'); + +console.log('ISO 8601 String:', t.iso); +console.log('Formatted:', t.format('{wkd}, {mon} {dd:ord}, {yyyy} at {h12}:{mi} [{tz}]')); +console.log('Days until next Friday:', t.until('next Friday').format()); + +// Return value displays in the top Result card: +return t.format('{yyyy}-{mmm}-{dd}');`, + }, + + weekend: { + label: 'Preset: Weekend Check (Cookbook)', + code: `// 🗓️ Weekend Checking (from Tempo Cookbook) +const today = new Tempo(); +console.log('Today:', today.format('{www}, {dd} {mon}')); +console.log('ISO Day of Week (1..7):', today.dow); + +// 1. Simple ISO check (Sat = 6, Sun = 7) +const isIsoWeekend = today.dow >= 6; +console.log('Is ISO Weekend?', isIsoWeekend); + +// 2. Locale-Aware check using t.intl.weekend +const us = new Tempo({ locale: 'en-US' }); +const sa = new Tempo({ locale: 'ar-SA' }); + +console.log('en-US Weekend Days:', JSON.stringify(us.intl.weekend)); // [6, 7] (Saturday, Sunday) +console.log('ar-SA Weekend Days:', JSON.stringify(sa.intl.weekend)); // [5, 6] (Friday, Saturday) + +return \`Today is \${today.format('{www}')}. Weekend in US? \${us.intl.weekend.includes(today.dow)}\`;`, + }, + + quarters: { + label: 'Preset: Fiscal Quarters & Math (Core)', + code: `// 💼 Fiscal Quarters and Tempo Math +const t = new Tempo('2026-02-15', { sphere: 'north' }); + +console.log('Quarter Key:', t.term.qtr); // "Q1" +console.log('Quarter Label:', t.term.quarter.label); // "First Quarter" +console.log('Quarter Start:', t.term.quarter.start.format('{yyyy}-{mm}-{dd}')); +console.log('Quarter End:', t.term.quarter.end.format('{yyyy}-{mm}-{dd}')); + +// Chainable Semantic Term Mutation: +const nextQtr = t.add({ '#quarter': 1 }); +console.log('Next Quarter (Key):', nextQtr.term.qtr); // "Q2" +console.log('Next Quarter (Label):', nextQtr.term.quarter.label); // "Second Quarter" + +return nextQtr.format('Next quarter: {#quarter}');`, + }, + + seasons: { + label: 'Preset: Seasons & Lunar Phases (Celestial)', + plugin: 'celestial', + code: `// 🌍 Hemispheric Seasons & Lunar Phases +// Tempo terms are hemisphere-aware based on geo coordinates or sphere setting: +const sydney = new Tempo('2026-07-01', { sphere: 'south' }); +const london = new Tempo('2026-07-01', { sphere: 'north' }); + +console.log('Sydney in July:', sydney.term.szn); // "Winter" +console.log('London in July:', london.term.szn); // "Summer" + +// Celestial Plugin (Lunar Phase): +const now = new Tempo(); +console.log('Moon Phase:', now.term.lunar.phase, now.term.lunar.emoji); +console.log('Illumination:', (now.term.lunar.illumination * 100).toFixed(1) + '%'); + +return \`Current Lunar Phase: \${now.term.lunar.phase}\`;`, + }, + + // ── 2. Official Plugins & Ecosystem Extensions ─────────────────────────── + spatial: { + label: 'Preset: Spatial & Navigation (GIS, Haversine, Transit)', + plugin: 'spatial', + code: `// 🧭 Great-Circle Navigation & Spatial Geofencing (@magmacomputing/tempo-plugin-spatial) +const { SpatialPlugin } = await import('@magmacomputing/tempo-plugin-spatial'); +Tempo.use(SpatialPlugin); + +const sydney = { lat: -33.8688, lng: 151.2093 }; +const london = { lat: 51.5074, lng: -0.1278 }; + +// 1. Haversine Distance & Initial Bearing +const distKm = Tempo.spatial.distance(sydney, london, 'km'); +const heading = Tempo.spatial.bearing(sydney, london); +console.log('Distance Sydney -> London:', distKm.toFixed(1), 'km'); +console.log('Compass Heading:', heading.toFixed(1) + '°'); + +// 2. Geographic Midpoint +const mid = Tempo.spatial.midpoint(sydney, london); +console.log('Great-Circle Midpoint:', \`\${mid.latitude.toFixed(2)}°, \${mid.longitude.toFixed(2)}° (\${mid.sphere})\`); + +// 3. Impossible Travel Anomaly Detection +const loginSydney = new Tempo('2026-03-31T08:00:00Z', { geo: sydney }); +const loginLondon = new Tempo('2026-03-31T09:30:00Z', { geo: london }); // 1.5h later +const speed = loginSydney.spatialVelocity(loginLondon); +const isAnomaly = Tempo.spatial.isImpossibleTravel(loginSydney, loginLondon); + +console.log('Transit Velocity:', speed.toFixed(1), 'km/h'); +console.log('Impossible Travel Alert?', isAnomaly); + +return \`Sydney -> London: \${distKm.toFixed(0)} km (Midpoint: \${mid.latitude.toFixed(1)}°, \${mid.longitude.toFixed(1)}°)\`;`, + }, + + geo: { + label: 'Preset: Live Geolocation & Providers (Geo)', + plugin: 'geo', + code: `// 🌍 Live Geolocation & Pluggable Providers (@magmacomputing/tempo-plugin-geo) +// Note: In browser sandbox, resolves browser GPS or IP-based coordinates + +const lookup = await Tempo.geo.lookup({ reverse: true }); +console.log('Detected City:', lookup.city ?? 'Local City', ',', lookup.country ?? 'Local Country'); +console.log('Coordinates:', lookup.lat, lookup.lng); + +// Attach coordinates to a Tempo instance: +const localTime = new Tempo('now', { geo: lookup }); +console.log('Astronomical Season:', localTime.term.szn); +console.log('Moon Phase:', localTime.term.lunar.phase, localTime.term.lunar.emoji); + +// Reverse Geocoding to place details: +const place = await Tempo.geo.reverse({ lat: -33.8688, lng: 151.2093 }); +console.log('Reverse Geocoded Place:', place.city, place.country); + +return \`Located at \${lookup.city ?? 'Local City'} (\${lookup.lat?.toFixed(2)}°, \${lookup.lng?.toFixed(2)}°)\`;`, + }, + + holidays: { + label: 'Preset: Regional Public Holidays & SLA Business Days', + plugin: 'holidays', + code: `// 🏖️ Regional Public Holidays & SLA Business Days (@magmacomputing/tempo-plugin-holidays) +const { HolidaysPlugin } = await import('@magmacomputing/tempo-plugin-holidays'); +Tempo.use(HolidaysPlugin); + +// 1. Evaluate holiday by country or instance geo metadata +const christmas = new Tempo('2026-12-25', { geo: { country: 'US' } }); +console.log('Is Christmas Day holiday in US?', christmas.holidays.isHoliday()); +console.log('Holiday Name:', christmas.holidays.name); +console.log('Is Business Day?', christmas.holidays.isBusinessDay()); + +// 2. Next & previous business day arithmetic +const nextWorkDay = christmas.holidays.nextBusinessDay(); +console.log('Next Business Day after Christmas:', nextWorkDay.format('{www}, {dd} {mon} {yyyy}')); + +// 3. Add N working business days +const deadline = christmas.holidays.addBusinessDays(5); +console.log('5 Business Days later:', deadline.format('{www}, {dd} {mon} {yyyy}')); + +// 4. SLA Working Hours calculation +const ticketOpened = new Tempo('2026-01-23 15:00:00', { geo: { country: 'AU' } }); +const ticketResolved = new Tempo('2026-01-27 11:00:00', { geo: { country: 'AU' } }); +const hours = ticketOpened.holidays.workingHoursUntil(ticketResolved); +console.log('SLA Working Hours (9am-5pm window):', hours, 'hours'); + +return \`Christmas: \${christmas.holidays.name} (Next work day: \${nextWorkDay.format('{www}, {dd} {mon}')})\`;`, + }, + + dialects: { + label: 'Preset: Dialects (LDML, strftime, Oracle, .NET, MySQL, Sheet)', + plugin: 'dialects', + code: `// 🌐 External Dialect Formatting, Parsing & Transpilation +// Dynamic import of @magmacomputing/tempo-plugin-dialects +const { DialectsPlugin, DIALECT } = await import('@magmacomputing/tempo-plugin-dialects'); +Tempo.use(DialectsPlugin); + +const t = new Tempo('2026-10-24T15:30:45.123'); + +// 1. Format across external ecosystems +console.log('Luxon / LDML:', t.toFormat('dd LLL yyyy, HH:mm')); +console.log('POSIX strftime:', t.dialects.strftime('%Y-%m-%d %H:%M:%S')); +console.log('Oracle / SQL TO_CHAR:', t.dialects.oracle('YYYY-MM-DD HH24:MI:SS')); +console.log('.NET DateTime:', t.dialects.dotnet('yyyy-MM-dd HH:mm:ss.fff')); +console.log('MySQL DATE_FORMAT:', t.dialects.mysql('%Y-%m-%d %H:%i:%s')); +console.log('Excel / Sheets:', t.dialects.sheet('yyyy-mm-dd hh:mm:ss')); + +// 2. Ingest & Explain legacy masks into native Tempo {token} syntax +const inspection = Tempo.dialects.explain('[Report for] MMMM Do, YYYY [at] hh:mm A', DIALECT.Moment); +console.log('Explained Moment -> Tempo IR:', inspection.pattern); + +// 3. Export canonical Tempo templates to external dialect models +const sqlExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', DIALECT.Oracle); +console.log('Exported Tempo -> SQL TO_CHAR model:', sqlExport.pattern); +const sheetExport = Tempo.dialects.export('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', DIALECT.Sheet); +console.log('Exported Tempo -> Spreadsheet mask:', sheetExport.pattern); + +// 4. Universal Cross-Dialect Transpilation (.convert) +const posixToOracle = Tempo.dialects.convert('%Y-%m-%d %H:%M:%S', DIALECT.Strftime, DIALECT.Oracle); +console.log('Converted POSIX -> Oracle:', posixToOracle.pattern); + +// 5. Multi-candidate fallback parser +const parsed = Tempo.fromFormats('24/10/2026 15:30', [ + 'yyyy-MM-dd HH:mm', + 'dd/MM/yyyy HH:mm', +]); +console.log('Parsed multi-candidate ISO:', parsed.iso); + +return \`Transpiled POSIX to Oracle: \${posixToOracle.pattern}\`;`, + }, + + celestial: { + label: 'Preset: Celestial Solar & Lunar Ephemeris', + plugin: 'celestial', + code: `// 🌙 Celestial Solar & Lunar Ephemeris Demo (@magmacomputing/tempo-plugin-celestial) +const now = new Tempo(); +console.log('Moon Phase:', now.term.lunar.phase); +console.log('Illumination:', (now.term.lunar.illumination * 100).toFixed(1) + '%'); +console.log('Is King Tide?', now.term.tides.isKingTide); + +return \`Phase: \${now.term.lunar.phase} (\${(now.term.lunar.illumination * 100).toFixed(0)}% illuminated)\`;`, + }, + + astro: { + label: 'Preset: Astronomical Seasons & Solstices', + plugin: 'celestial', + code: `// ☀️ Astronomical Seasons & Solstices Demo (@magmacomputing/tempo-plugin-celestial) +const sydney = new Tempo('2026-07-01', { sphere: 'south' }); +const london = new Tempo('2026-07-01', { sphere: 'north' }); + +console.log('Sydney in July:', sydney.term.astro, '-> Season:', sydney.term.szn); +console.log('London in July:', london.term.astro, '-> Season:', london.term.szn); + +const equinox = new Tempo('2026-03-20', { sphere: 'north' }); +console.log('March 20 Equinox:', equinox.term.equinox); + +return \`Sydney: \${sydney.term.szn} | London: \${london.term.szn}\`;`, + }, + + finance: { + label: 'Preset: Fiscal & Financial Math', + plugin: 'finance', + code: `// 💼 Fiscal & Financial Math Demo (@magmacomputing/tempo-plugin-finance) +const { FinanceNamespace } = await import('@magmacomputing/tempo-plugin-finance'); +Tempo.use(FinanceNamespace); + +const t = new Tempo('2026-07-15'); +console.log('Fiscal Quarter:', t.finance.fiscalQuarter); +console.log('Tax Year:', t.finance.taxYear); +console.log('Is Fiscal Year Start?', t.finance.isFiscalYearStart()); + +return \`Fiscal Q\${t.finance.fiscalQuarter} (Tax Year \${t.finance.taxYear})\`;`, + }, + + snap: { + label: 'Preset: Time Snapping & Quantization', + plugin: 'snap', + code: `// ⏱️ Time Snapping & Quantization Demo (@magmacomputing/tempo-plugin-snap) +const { SnapPlugin } = await import('@magmacomputing/tempo-plugin-snap'); +Tempo.use(SnapPlugin); + +const t = new Tempo('2026-06-01T14:08:23Z'); +console.log('Original time:', t.format('{hh}:{mi}:{ss}')); + +// Snap to nearest 15-minute block +const snapped15m = t.snap(); +console.log('Snapped (15m):', snapped15m.format('{hh}:{mi}:{ss}')); + +// Snap to 1-hour interval upward +const snapHourUp = t.snap({ hh: 1, direction: 'up' }); +console.log('Snapped Up (1h):', snapHourUp.format('{hh}:{mi}:{ss}')); + +return \`Snapped to \${snapped15m.format('{hh}:{mi}')}\`;`, + }, + + batch: { + label: 'Preset: Parallel Bulk Mutation', + plugin: 'batch', + code: `// ⚡ Parallel Bulk Mutation Demo (@magmacomputing/tempo-plugin-batch) +// Note: @magmacomputing/tempo-plugin-batch uses Node.js worker_threads for multi-threaded processing. +const timestamps = [1700000000000, 1700086400000, 1700172800000]; +console.log('Original timestamps count:', timestamps.length); + +let mutated; +const isNode = typeof process !== 'undefined' && Boolean(process.versions?.node); + +if (isNode) { + const { BatchPlugin } = await import('@magmacomputing/tempo-plugin-batch'); + Tempo.use(BatchPlugin); + mutated = await Tempo.batch(timestamps, '+1w'); +} else { + console.info('Running browser fallback (BatchPlugin worker_threads requires Node.js).'); + mutated = timestamps.map(ts => new Tempo(ts).add({ weeks: 1 }).epoch.ms); +} + +console.log('Mutated +1 week timestamps:', mutated); +return \`Batch processed \${mutated.length} timestamps successfully!\`;`, + }, + + sync: { + label: 'Preset: Cross-Thread Time Sync', + plugin: 'sync', + code: `// 🔄 Cross-Thread Time Sync Demo (@magmacomputing/tempo-plugin-sync) +const { SyncPlugin } = await import('@magmacomputing/tempo-plugin-sync'); +Tempo.use(SyncPlugin); + +// SharedArrayBuffer requires Cross-Origin Isolation (COOP/COEP) in browsers: +// Cross-Origin-Opener-Policy: same-origin +// Cross-Origin-Embedder-Policy: require-corp +if (typeof SharedArrayBuffer === 'undefined') { + console.warn('SharedArrayBuffer is unavailable in this environment.'); + console.info('To enable in browsers, serve with COOP/COEP cross-origin isolation headers.'); + return 'SharedArrayBuffer unavailable (requires cross-origin isolation or Node.js)'; +} + +Tempo.sync.startClock({ interval: 1 }); +try { + const buffer = Tempo.sync.getBuffer(); + console.log('Clock buffer byte length:', buffer.byteLength); + + const nowMs = Tempo.sync.now(buffer); + console.log('High-precision current epoch ms:', nowMs); + + return \`Sync read successful (Epoch: \${nowMs})\`; +} finally { + Tempo.sync.stopClock(); +}`, + }, + + ntp: { + label: 'Preset: Network Time Sync & Drift (NTP)', + plugin: 'ntp', + code: `// 🌐 Network Time Sync & Drift Calibration (@magmacomputing/tempo-plugin-ntp) +const { NtpPlugin } = await import('@magmacomputing/tempo-plugin-ntp'); +Tempo.use(NtpPlugin); + +console.log('Calibrating clock with remote time source...'); +const sample = await Tempo.ntp.sync('https://worldtimeapi.org/api/timezone/Etc/UTC'); + +console.log('Sync Result: Offset', sample.offsetMs, 'ms (Uncertainty: ±' + sample.uncertaintyMs + 'ms, Samples: ' + sample.sampleCount + ')'); +console.log('Calibrated Tempo:', Tempo.ntp.now().format('{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}.{ms}')); + +return \`Calibrated! Offset: \${Tempo.ntp.offset}ms | Local: \${new Tempo().format('{hh}:{mi}:{ss}.{ms}')} vs NTP: \${Tempo.ntp.now().format('{hh}:{mi}:{ss}.{ms}')}\`;`, + }, + + ticker: { + label: 'Preset: Continuous Temporal Ticker', + plugin: 'ticker', + code: `// ⏰ Continuous Temporal Ticker Demo (@magmacomputing/tempo-plugin-ticker) +const { TickerPlugin } = await import('@magmacomputing/tempo-plugin-ticker'); +Tempo.use(TickerPlugin); + +console.log('Starting 1-second cadence ticker...'); +let count = 0; +const ticker = Tempo.ticker({ seconds: 1 }, (t, stop) => { + count++; + console.log(\`Tick #\${count}:\`, t.format('{hh}:{mi}:{ss}')); + if (count >= 3) { + console.log('Ticker stopped after 3 ticks.'); + stop(); + } +}); + +return 'Ticker started (executes in console stream)';`, + }, + + dynamic: { + label: 'Preset: Dynamic Plugin (ESM import)', + plugin: 'ticker', + code: `// 📦 Dynamic Plugin Loading via native ESM +console.log('Dynamically importing @magmacomputing/tempo-plugin-ticker...'); +const { TickerPlugin } = await import('@magmacomputing/tempo-plugin-ticker'); + +// Register the dynamically imported plugin +Tempo.use(TickerPlugin); + +console.log('TickerPlugin loaded and active!'); +return 'Dynamic import successful!';`, + }, + + ai: { + label: 'Preset: AI Semantic Parsing & Scheduling', + plugin: 'ai', + autoRun: false, + code: `// 🤖 AI Semantic Parsing & Scheduling (@magmacomputing/tempo-plugin-ai) +const { AiPlugin } = await import('@magmacomputing/tempo-plugin-ai'); +Tempo.use(AiPlugin); + +// 1. Configure provider (Trial 'tempo' sandbox or BYOK: 'gemini', 'openai', 'groq') +await Tempo.ai.init({ provider: 'tempo', debug: true }); + +// 2. Parse complex cultural/relative calendar expression +// Note: { force: true } bypasses cached entries for live LLM reasoning +const t = await Tempo.ai.parse("The Friday before Melbourne Cup next year", { force: true }); + +console.log('📅 Parsed: ', t.format('{www}, {yyyy}-{mmm}-{dd}')); +console.log('🧠 Reasoning:', t.ai?.reasoning); +console.log('🎯 Provider: ', t.ai?.provider, \`(confidence: \${t.ai?.confidence})\`); + +if (t.ai?.limits?.remainingRequests !== undefined) { + const resetStr = t.ai.limits.resetAt ? t.ai.limits.resetAt.format('{hh}:{mi}:{ss}') : 'in 1h'; + console.log('⏱️ Quota: ', \`\${t.ai.limits.remainingRequests} req remaining (resets at \${resetStr})\`); +} + +return t.iso;`, + }, +}; + +export default SNIPPETS; diff --git a/packages/tempo/public/v4/script.index.html b/packages/tempo/public/v4/script.index.html new file mode 100644 index 00000000..fffc947b --- /dev/null +++ b/packages/tempo/public/v4/script.index.html @@ -0,0 +1,243 @@ + + + + + + Tempo Script Tag Test + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Script Test
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + const t = new Tempo('tomorrow'); +t.toString(); +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Result +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Initializing Temporal...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + Output also available in the developer console. +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/src/plugin/extend/README.html b/packages/tempo/public/v4/src/plugin/extend/README.html new file mode 100644 index 00000000..b7b325b9 --- /dev/null +++ b/packages/tempo/public/v4/src/plugin/extend/README.html @@ -0,0 +1,79 @@ + + + + + + 🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/) | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🛠️ Tempo Prototype Extension Mixins (src/plugin/extend/) ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This directory contains opt-in prototype extension mixins that augment Tempo.prototype and TypeScript's interface Tempo declaration merging.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    🚫 Why Barrel (index.ts) Files are Omitted ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mixins in this directory perform module-level side effects when loaded (e.g. assigning methods to Tempo.prototype).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To preserve strict tree-shaking and prevent accidental side-effect execution across the codebase, barrel index files (index.ts) are intentionally omitted from this directory. Importing a barrel file would eagerly load all mixins and mutate the prototype for consumers who did not request those extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    📦 How to Import Mixins ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Always import mixins via explicit subpath imports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Explicitly opt into the recurrence mixin (patches Tempo.prototype.nextOccurrence)
+import '#tempo/plugin/extend/extend.recurrence.js';
+
+// Or in external consumption:
+import '@magmacomputing/tempo/extend/recurrence';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ✍️ How to Author a Prototype Mixin ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When creating a new mixin in this directory:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. Augment the TypeScript Tempo interface:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      declare module '../../tempo.class.js' {
+  interface Tempo {
+    myCustomMethod(arg: string): Tempo;
+  }
+}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. Assign the implementation to Tempo.prototype:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tempo.prototype.myCustomMethod = function (this: Tempo, arg: string): Tempo {
+  // Implementation...
+  return this;
+};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. Avoid top-level barrel exports so the mixin remains strictly opt-in via subpath import.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/tempo-logo-cyan.svg b/packages/tempo/public/v4/tempo-logo-cyan.svg new file mode 100644 index 00000000..7d0da2e4 --- /dev/null +++ b/packages/tempo/public/v4/tempo-logo-cyan.svg @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/tempo-logo-white.svg b/packages/tempo/public/v4/tempo-logo-white.svg new file mode 100644 index 00000000..53ff1f88 --- /dev/null +++ b/packages/tempo/public/v4/tempo-logo-white.svg @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/tempo-logo.svg b/packages/tempo/public/v4/tempo-logo.svg new file mode 100644 index 00000000..dc052b0f --- /dev/null +++ b/packages/tempo/public/v4/tempo-logo.svg @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/test/README.html b/packages/tempo/public/v4/test/README.html new file mode 100644 index 00000000..214b8018 --- /dev/null +++ b/packages/tempo/public/v4/test/README.html @@ -0,0 +1,68 @@ + + + + + + Tempo Test Suite | Tempo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appearance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tempo Test Suite ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This directory contains the automated test suite for the @magmacomputing/tempo package, organized by functional domain.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Directory Structure ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DirectoryResponsibility
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    core/Tests for class mechanics: constructor, configuration, discovery, and state management.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    engine/The internal parsing engine: lexer, planner, layout resolution, and pattern matching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    instance/Public methods on the Tempo instance (e.g., add(), since(), format(), set()).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins/Extension modules and registries: Terms, Tickers, and Duration modules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module/Modules (Parse, Format, Duration, Mutate) that can operate on a Tempo instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    issues/Regression tests linked to specific bug reports or edge cases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    support/Infrastructure, Vitest setup files, and general test utilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Running Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All Tests ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specific Domain ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To run only a specific category of tests (e.g., the engine):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npx vitest test/engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CI Simulation ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To simulate the CI environment (Strict mode, specific timezones):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm run test:ci

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Conventions ​

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Isolation Assertions: Files ending in .core.test.ts or .lazy.test.ts are designed to assert behavior before modules are fully loaded. These are executed in isolation under the Tempo: Core test project to avoid cross-suite side-effects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Console Suppression: By default, console output is suppressed in tests via test/support/setup.console-spy.ts. To debug, you can use (console.log as any).mockRestore() within your test or comment out the suppression in the setup file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Anchoring: When testing relative dates, always provide a fixed anchor to ensure tests are deterministic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Released under the MIT License.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Copyright © 2026-present Magma Computing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    + + + + \ No newline at end of file diff --git a/packages/tempo/public/v4/vp-icons.css b/packages/tempo/public/v4/vp-icons.css new file mode 100644 index 00000000..ddc5bd8e --- /dev/null +++ b/packages/tempo/public/v4/vp-icons.css @@ -0,0 +1 @@ +.vpi-social-github{--icon:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' width='24' height='24'%3E%3Cpath fill='black' d='M12 .297c-6.63 0-12 5.373-12 12c0 5.303 3.438 9.8 8.205 11.385c.6.113.82-.258.82-.577c0-.285-.01-1.04-.015-2.04c-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729c1.205.084 1.838 1.236 1.838 1.236c1.07 1.835 2.809 1.305 3.495.998c.108-.776.417-1.305.76-1.605c-2.665-.3-5.466-1.332-5.466-5.93c0-1.31.465-2.38 1.235-3.22c-.135-.303-.54-1.523.105-3.176c0 0 1.005-.322 3.3 1.23c.96-.267 1.98-.399 3-.405c1.02.006 2.04.138 3 .405c2.28-1.552 3.285-1.23 3.285-1.23c.645 1.653.24 2.873.12 3.176c.765.84 1.23 1.91 1.23 3.22c0 4.61-2.805 5.625-5.475 5.92c.42.36.81 1.096.81 2.22c0 1.606-.015 2.896-.015 3.286c0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E")} \ No newline at end of file diff --git a/packages/tempo/src/engine/engine.lexer.ts b/packages/tempo/src/engine/engine.lexer.ts index 887991ce..da23a999 100644 --- a/packages/tempo/src/engine/engine.lexer.ts +++ b/packages/tempo/src/engine/engine.lexer.ts @@ -584,9 +584,9 @@ export function parseTime(groups: t.Groups = {}, dateTime: Temporal.ZonedDateTim export function parseZone(groups: t.Groups, dateTime: Temporal.ZonedDateTime, config?: any): Temporal.ZonedDateTime { if (!isTemporal(dateTime)) return dateTime; - const tzd = (groups["tz"] ?? groups["tzd"])?.replace(Match.zed, 'UTC'); + const tz = groups["tz"]?.replace(Match.zed, 'UTC'); const brk = groups["brk"]?.replace(Match.zed, 'UTC'); - let zone: string | undefined = brk || tzd; + let zone: string | undefined = brk || tz; if (zone) { const match = zone.match(RE_ZONE_OFFSET); @@ -597,7 +597,7 @@ export function parseZone(groups: t.Groups, dateTime: Temporal.ZonedDateTime, co let cal = groups["cal"]; if (zone?.startsWith('u-ca=')) { cal = zone; - zone = tzd; + zone = tz; } const zdt = dateTime as any; @@ -618,7 +618,6 @@ export function parseZone(groups: t.Groups, dateTime: Temporal.ZonedDateTime, co delete groups["brk"]; delete groups["cal"]; - delete groups["tzd"]; delete groups["tz"]; if (zone || cal) diff --git a/packages/tempo/src/engine/engine.pattern.ts b/packages/tempo/src/engine/engine.pattern.ts index eb825c32..1af39913 100644 --- a/packages/tempo/src/engine/engine.pattern.ts +++ b/packages/tempo/src/engine/engine.pattern.ts @@ -71,14 +71,6 @@ export class PatternCompiler { let res = customs ?? globals ?? stateLayout ?? defaultLayout; // get the snippet/layout source - if (isNullish(res) && (name === 'tzd' || token === Token.tzd)) { - res = snippet?.[Token.tz]?.source ?? snippet?.['tz' as unknown as keyof Snippet]?.source - ?? state.parse.snippet[Token.tz]?.source ?? state.parse.snippet['tz' as unknown as keyof Snippet]?.source; - } else if (isNullish(res) && (name === 'tz' || token === Token.tz)) { - res = snippet?.[Token.tzd]?.source ?? snippet?.['tzd' as any]?.source - ?? state.parse.snippet[Token.tzd]?.source ?? state.parse.snippet['tzd' as any]?.source; - } - if (isNullish(res) && name.includes('.')) { // if no definition found, try fallback const prefix = name.split('.')[0]; // get the base token name const pToken = getSymbol(prefix); diff --git a/packages/tempo/src/engine/engine.term.ts b/packages/tempo/src/engine/engine.term.ts index f76ebdd8..0a8ece14 100644 --- a/packages/tempo/src/engine/engine.term.ts +++ b/packages/tempo/src/engine/engine.term.ts @@ -1,7 +1,7 @@ import { toZonedDateTime, toInstant, getTemporalIds } from '#library/temporal.library.js'; import { isDefined, isString, isZonedDateTime, isNumeric, isFunction } from '#library/assertion.library.js'; import { asArray } from '#library/coercion.library.js'; -import type { LooseUnion } from '#library/type.library.js'; +import type { LooseUnion, ValueOf } from '#library/type.library.js'; import { sym, TermError, getLargestUnit, SCHEMA, Match, isTempo } from '#tempo/support'; import { getRange, getTermRange, resolveTermShift, findTermPlugin } from '../plugin/term/term.util.js'; @@ -362,10 +362,10 @@ export function resolveTermMutation(Tempo: TempoTermType, instance: Tempo, mutat list = list.filter(r => r.key?.toLowerCase() === rKey.toLowerCase()); } - const toZdt = (item: typeof rawList[number]): Temporal.ZonedDateTime => + const toZdt = (item: ValueOf): Temporal.ZonedDateTime => toZdtItem(item, jump.year, tz, cal); - const toEpochNs = (item: typeof rawList[number]): bigint => + const toEpochNs = (item: ValueOf): bigint => toZdt(item).epochNanoseconds as bigint; const chronological = [...rawList].sort((a, b) => { diff --git a/packages/tempo/src/module/module.format.ts b/packages/tempo/src/module/module.format.ts index a6c7790e..b77ad305 100644 --- a/packages/tempo/src/module/module.format.ts +++ b/packages/tempo/src/module/module.format.ts @@ -4,7 +4,7 @@ import { deepMerge } from '#library/object.library.js'; import { suffix, toRoman } from '#library/number.library.js'; import { isString, isObject, isZonedDateTime, isInstant, isPlainDate, isPlainDateTime, isUndefined, isDefined, isFunction, isSafeKey, isNullish, RE_DIGITS, isDigits, RE_INTEGER } from '#library/assertion.library.js'; import { evaluate, evaluateString } from '#library/evaluation.library.js'; -import { formatDayPeriod, getDTF, getPR, getISOWeekOfYear, getLocaleWeekOfYear, getLanguage, getLI, canonicalLocales, localizeDigits, isolateBidi } from '#library/international.library.js'; +import { formatDayPeriod, getDTF, getPR, getISOWeekOfYear, getLocaleWeekOfYear, getLanguage, getLI, getLC, canonicalLocales, localizeDigits, isolateBidi } from '#library/international.library.js'; import { delegator } from '#library/proxy.library.js'; import { hasOwn } from '#library/primitive.library.js'; import { cast } from '#library/type.library.js'; @@ -296,7 +296,6 @@ export function format(obj?: any, fmt?: any, options?: any): any { const result = template.replace(RE_FORMAT_BRACES, (_match: string, fullToken: string) => { let [token, ...modifiers] = fullToken.split(':'); const normMods = modifiers.map(m => m.toLowerCase()); - if (token === 'tzd') token = 'tz'; // @deprecated, will remove in v5.0.0 let res: any; switch (token) { @@ -330,13 +329,6 @@ export function format(obj?: any, fmt?: any, options?: any): any { res = (normMods.includes('zero') || normMods.includes('0') ? w - 1 : w).toString(); break; } - case 'yyww': case 'yywy': case 'yywoy': { - const { weekOfYear, yearOfWeek } = normMods.includes('locale') - ? getLocaleWeekOfYear(zdt, li) - : getISOWeekOfYear(zdt); - res = pad(yearOfWeek, 4) + pad(weekOfYear); - break; - } case 'era': { const dtfOptions = (config?.intl?.dateTimeFormat || {}) as any; res = getDTF(config?.locale, { @@ -465,7 +457,7 @@ export function format(obj?: any, fmt?: any, options?: any): any { case 'dmy': case 'mdy': case 'ymd': { - const isShort = normMods.includes('short') || normMods.includes('yy') || normMods.includes('year'); // :yy & :year @deprecated, will remove in v5.0.0 + const isShort = normMods.includes('short'); const y = pad(isShort ? zdt.year % 100 : zdt.year, isShort ? 2 : 4); const m = pad(zdt.month); const d = pad(zdt.day); @@ -532,7 +524,7 @@ export function format(obj?: any, fmt?: any, options?: any): any { : (termObj ?? `{${token}}`); } else if (token.includes('.')) { if (token.startsWith('intl.')) { - res = resolveNamespaceToken({ intl: { ...li, info: li, locale: li.locale } }, token); + res = resolveNamespaceToken({ intl: { ...li, info: li, locale: getLC(canonicalLocales(config?.locale)[0]) } }, token); } else if (isTempo(obj)) { res = resolveNamespaceToken(obj, token); } else { @@ -656,8 +648,8 @@ export function format(obj?: any, fmt?: any, options?: any): any { case 'longgeneric': { const modKey = mod.toLowerCase(); if (token === 'tz') { - if (normMods.includes('offset') || normMods.includes('offsetcompact')) { - // Handled by case 'offset' / 'offsetcompact' + if (normMods.includes('offset')) { + // Handled by case 'offset' } else { const styleMap: Record = { short: 'short', long: 'long', shortoffset: 'shortOffset', longoffset: 'longOffset', shortgeneric: 'shortGeneric', longgeneric: 'longGeneric' }; const parts = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, timeZoneName: styleMap[modKey] }).formatToParts(zdt.epochMilliseconds); @@ -675,10 +667,9 @@ export function format(obj?: any, fmt?: any, options?: any): any { } break; } - case 'offset': - case 'offsetcompact': { + case 'offset': { if (token === 'tz') { - const sep = (mod.toLowerCase() === 'offsetcompact' || normMods.includes('compact')) ? '' : ':'; + const sep = normMods.includes('compact') ? '' : ':'; const isUtc = zdt.offset === '+00:00' || zdt.offset === '-00:00' || zdt.offset === 'Z' || zdt.offsetNanoseconds === 0; const sign = zdt.offset.startsWith('-') ? '-' : '+'; const cleanOffset = (zdt.offset.startsWith('+') || zdt.offset.startsWith('-')) @@ -707,36 +698,9 @@ export function format(obj?: any, fmt?: any, options?: any): any { break; } case 'compact': - if (token !== 'tz' || (!normMods.includes('offset') && !normMods.includes('offsetcompact'))) + if (token !== 'tz' || !normMods.includes('offset')) res = String(res).replace(RE_COLON, ''); break; - case 'offsetshort': // @deprecated, will remove in v5.0.0 - if (token === 'tz') res = zdt.offset.endsWith(':00') ? zdt.offset.slice(0, -3) : zdt.offset; - break; - case 'z': // @deprecated, will remove in v5.0.0; use Tempo Dialects (LDML / Moment / Strftime) or canonical {tz:short}, {tz:offset}, etc. - if (token === 'tz') { - if (!normMods.includes('offset') && !normMods.includes('offsetcompact')) - res = zdt.offset.endsWith(':00') ? zdt.offset.slice(0, -3) : zdt.offset; - } - break; - case 'zz': // @deprecated, will remove in v5.0.0; use Tempo Dialects (LDML / Moment / Strftime) or canonical {tz:offset} - if (token === 'tz') res = zdt.offset; - break; - case 'zzz': // @deprecated, will remove in v5.0.0; use Tempo Dialects (LDML / Moment / Strftime) or canonical {tz:offsetcompact} - if (token === 'tz') res = zdt.offset.replace(':', ''); - break; - case 'zzzz': // @deprecated, will remove in v5.0.0; use Tempo Dialects (LDML / Moment / Strftime) or canonical {tz:short} - if (token === 'tz') { - const parts = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, timeZoneName: 'short' }).formatToParts(zdt.epochMilliseconds); - res = parts.find(p => p.type === 'timeZoneName')?.value ?? zdt.timeZoneId; - } - break; - case 'zzzzz': // @deprecated, will remove in v5.0.0; use Tempo Dialects (LDML / Moment / Strftime) or canonical {tz:long} - if (token === 'tz') { - const parts = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, timeZoneName: 'long' }).formatToParts(zdt.epochMilliseconds); - res = parts.find(p => p.type === 'timeZoneName')?.value ?? zdt.timeZoneId; - } - break; case 'space': { if (!normMods.some(m => RE_INTEGER.test(m) && m !== '0')) { const defaultWidth = (token === 'doy' || (token === 'dd' && normMods.includes('year'))) diff --git a/packages/tempo/src/plugin/plugin.sdk.ts b/packages/tempo/src/plugin/plugin.sdk.ts index b9e0c309..89f6aad5 100644 --- a/packages/tempo/src/plugin/plugin.sdk.ts +++ b/packages/tempo/src/plugin/plugin.sdk.ts @@ -19,3 +19,4 @@ export * from './term/term.index.js'; export { defineTerm, defineRange, getTermRange, resolveCycleWindow, resolveRangeOrdinal, resolveRangeDiff, resolveRangeFormat } from './term/term.index.js'; export { TermHook } from '../support/support.symbol.js'; export { logError, logWarn, logDebug } from '../support/support.util.js'; +export { getRuntime } from '../support/support.runtime.js'; diff --git a/packages/tempo/src/support/support.default.ts b/packages/tempo/src/support/support.default.ts index a8b21500..b5005b90 100644 --- a/packages/tempo/src/support/support.default.ts +++ b/packages/tempo/src/support/support.default.ts @@ -69,8 +69,6 @@ export const Snippet = looseIndex()({ [Token.sfx]: /((?:{sep}+|T)({tm}){tz}?)/, // time-pattern suffix 'T {tm} Z'; NOTE: {tm} resolves via Layout fallback in compileRegExp (cross-registry dependency: Snippet → Layout) [Token.wkd]: /(?Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)/, // day-name (abbrev or full) [Token.tz]: new RegExp(`\\s*(?:(?:GMT|UTC)(?=\\s*[+-]))?\\s*(?Z|(?:${Object.keys(TIMEZONE).map(w => Match.escape(w.toUpperCase())).join('|')})|${Match.offset.source})`, 'i'), // time-zone offset or abbreviation with optional GMT/UTC prefix (e.g. GMT+10, UTC+10:00, +10:00, AEST, PST) - /** @deprecated Deprecated in v4.2.0; to be removed in v5.0.0. Use `Token.tz` instead. */ - [Token.tzd]: new RegExp(`\\s*(?:(?:GMT|UTC)(?=\\s*[+-]))?\\s*(?Z|(?:${Object.keys(TIMEZONE).map(w => Match.escape(w.toUpperCase())).join('|')})|${Match.offset.source})`, 'i'), [Token.nbr]: new RegExp(`(?[0-9]+|${Object.keys(NUMBER).map(w => Match.escape(w)).join('|')})`), // modifier count; number-word keys are regex-escaped at construction time (setPatterns() also re-escapes, but defence-in-depth) [Token.afx]: new RegExp(`((s)? (?${Match.modifier.source}))?{sep}?`), // affix optional plural 's' and (ago|hence) [Token.mod]: new RegExp(`((?${Match.modifier.source})? *)`), diff --git a/packages/tempo/src/support/support.enum.ts b/packages/tempo/src/support/support.enum.ts index 652f3ce9..1e3fb89f 100644 --- a/packages/tempo/src/support/support.enum.ts +++ b/packages/tempo/src/support/support.enum.ts @@ -119,7 +119,7 @@ export const DEFAULTS = { /** display with Time */ dayTime: '{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}', /** useful for stamping logs */ logStamp: '{ymd}T{hms}.{ff}', /** useful for sorting display-strings */ sortTime: '{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}', - /** useful for sorting week order */ yearWeek: '{yw}{wy}', + /** useful for sorting week order */ yearWeek: '{yow}{woy}', /** useful for sorting month order */ yearMonth: '{yyyy}{mm}', /** useful for sorting date order */ yearMonthDay: '{ymd}', /** just Date portion */ date: '{yyyy}-{mm}-{dd}', @@ -308,7 +308,7 @@ export const REGISTRIES: Record = { } /** public-reachable enums */ -export default { +export const enums = { SEASON, COMPASS, WEEKDAY, @@ -332,9 +332,6 @@ export default { MONTH_DAY, LOCALE, Enum, -} +}; -/** - * @deprecated Deprecated in v4.7.0; to be removed in v5.0.0. Import from `@magmacomputing/tempo/library`. - */ -export { Enum } from '#library/enumerate.library.js'; +export default enums; diff --git a/packages/tempo/src/support/support.index.ts b/packages/tempo/src/support/support.index.ts index 3d4f453a..b67a0360 100644 --- a/packages/tempo/src/support/support.index.ts +++ b/packages/tempo/src/support/support.index.ts @@ -5,8 +5,7 @@ * These exports are primarily consumed by core modules or advanced Plugin API integrations. */ export { - default as enums, - Enum, + enums, STATE, DEFAULTS, REGISTRIES, @@ -41,7 +40,7 @@ export { $Tempo, $Register, $Interpreter, $guard, $errored, $Internal, $Bridge, export { registryUpdate, registryReset, onRegistryReset } from './support.register.js'; export { getRuntime, resetRuntime, TempoRuntime } from './support.runtime.js'; export { Match, Snippet, Layout, Event, Period, Ignore, Guard, Default } from './support.default.js'; -export { SCHEMA, getLargestUnit, logError, logWarn, logDebug, logTrace, setLogLevel, logTempo, hasOwn, hasNativeFormatBraces, MOMENT_DIALECTS, LDML_DIALECTS, raise } from './support.util.js'; +export { SCHEMA, getLargestUnit, logError, logWarn, logDebug, logTrace, setLogLevel, logTempo, hasNativeFormatBraces, MOMENT_DIALECTS, LDML_DIALECTS, raise } from './support.util.js'; export { setPatterns } from '../engine/engine.pattern.js'; export { init, extendState } from './support.init.js'; export { TempoError } from './support.error.js'; diff --git a/packages/tempo/src/support/support.symbol.ts b/packages/tempo/src/support/support.symbol.ts index 20232d4a..3232af20 100644 --- a/packages/tempo/src/support/support.symbol.ts +++ b/packages/tempo/src/support/support.symbol.ts @@ -103,11 +103,6 @@ export const Token = looseIndex()({ /** Tempo event */ evt: Symbol('evt'), /** Tempo period */ per: Symbol('per'), /** time zone offset or identifier */ tz: Symbol('tz'), - /** - * time zone offset - * @deprecated Deprecated in v4.2.0; to be removed in v5.0.0. Use `Token.tz` instead. - */ - tzd: Symbol('tzd'), /** historical era */ era: Symbol('era'), /** ordinal index (1st, 2nd, 3rd, last, etc) */ nth: Symbol('nth'), /** Roman month (I-XII) */ Rm: Symbol('romanMonth'), diff --git a/packages/tempo/src/support/support.util.ts b/packages/tempo/src/support/support.util.ts index 9f8bd4d3..db3ea970 100644 --- a/packages/tempo/src/support/support.util.ts +++ b/packages/tempo/src/support/support.util.ts @@ -12,12 +12,6 @@ import { getDTF, getLC } from '#library/international.library.js'; import { getRuntime } from './support.runtime.js'; import type * as t from '../tempo.type.js'; -/** - * @internal check if an object has an own property (respects Proxy/Shadowing) - * @deprecated Deprecated in v4.7.0; to be removed in v5.0.0. Import from `#library` or `@magmacomputing/tempo/plugin/sdk`. - */ -export { hasOwn } from '#library/primitive.library.js'; - /** @internal normalize layout-order options into a clean string array */ export function normalizeLayoutOrder(value: unknown): string[] { return asArray(value) diff --git a/packages/tempo/src/tempo.class.ts b/packages/tempo/src/tempo.class.ts index 52d3c5df..91cfba8d 100644 --- a/packages/tempo/src/tempo.class.ts +++ b/packages/tempo/src/tempo.class.ts @@ -113,16 +113,6 @@ export class Tempo { /** Quarterly Seasons */ static get SEASON() { return enums.SEASON } /** Compass cardinal points */ static get COMPASS() { return enums.COMPASS } - /** @deprecated Use Tempo.enums.ELEMENT */ static get ELEMENT() { return enums.ELEMENT } - /** @deprecated Use Tempo.enums.FORMAT */ static get FORMAT() { return enums.FORMAT } - /** @deprecated Use Tempo.enums.NUMBER */ static get NUMBER() { return enums.NUMBER } - /** @deprecated Use Tempo.enums.ORDINAL */ static get ORDINAL() { return enums.ORDINAL } - /** @deprecated Use Tempo.enums.TIMEZONE */ static get TIMEZONE() { return enums.TIMEZONE } - /** @deprecated Use Tempo.enums.MONTH_DAY */ static get MONTH_DAY() { return enums.MONTH_DAY } - /** @deprecated Use Tempo.enums.MODE */ static get MODE() { return enums.MODE } - /** @deprecated Use Tempo.enums.CACHE */ static get CACHE() { return enums.CACHE } - /** @deprecated Use Tempo.enums.LIMIT */ static get LIMIT() { return enums.LIMIT } - /** @internal check if Tempo is currently initializing */ static get isInitializing() { return !_lifecycle.ready } /** @internal check if Tempo is currently extending */ static get isExtending() { return _lifecycle.extendDepth > 0 } @@ -279,18 +269,15 @@ export class Tempo { logWarn(`Invalid locale encountered in #isMonthDay: ${locale}. Falling back to en-US.`, shape.config); } - const li = getLI(rawLocale); - const baseName = li.baseName; - const language = li.language ?? li.locale?.language; - const tz = String(timeZone); + const { baseName, language, timeZones } = getLI(rawLocale); const activeLocaleData = mdy.resolvedLocales?.find(l => l.locale === baseName || (language && l.locale === language)); return Boolean( (activeLocaleData?.timeZones?.includes(tz)) || (globalMdy.timezones?.[baseName]?.includes(tz)) || (language && globalMdy.timezones?.[language]?.includes(tz)) || - ((asArray(globalMdy.locales).includes(baseName) || (language && asArray(globalMdy.locales).includes(language))) && li.timeZones.includes(tz)) + ((asArray(globalMdy.locales).includes(baseName) || (language && asArray(globalMdy.locales).includes(language))) && timeZones.includes(tz)) ); } @@ -923,29 +910,6 @@ export class Tempo { return this; } - /** - * @deprecated Use Tempo.use(...) instead. - */ - static extend(discovery: t.Discovery, symbol?: symbol): typeof Tempo; - /** - * @deprecated Use Tempo.use(...) instead. - */ - static extend(plugin: TempoPlugin, options?: t.Options): typeof Tempo; - /** - * @deprecated Use Tempo.use(...) instead. - */ - static extend(plugins: (TempoPlugin | TermPlugin | any)[], options?: t.Options): typeof Tempo; - /** - * @deprecated Use Tempo.use(...) instead. - */ - static extend(...args: any[]): typeof Tempo; - /** - * @deprecated Use Tempo.use(...) instead. - */ - static extend(...args: any[]): typeof Tempo { - return (this.use as any)(...args); - } - /** * 🏭 Sandbox Factory Mode * Create a fresh, isolated Tempo subclass with its own configuration and registries. @@ -1851,27 +1815,12 @@ export class Tempo { /** 4-digit year (e.g., 2024) */ get yy() { return this.toDateTime().year } /** Era string for the calendar (e.g., 'ce', 'bce') */ get era() { return this.toDateTime().era; } /** Year within the era (positive integer) */ get eon() { return this.toDateTime().eraYear; } - /** - * Year within the era (positive integer). - * @deprecated Use `eon` (Tempo canonical) or `zdt.eraYear` instead. To be removed in v5.0.0. - */ - get eraYear() { return this.toDateTime().eraYear; } /** @internal 4-digit ISO week-numbering year */ get yw() { return getISOWeekOfYear(this.toDateTime()).yearOfWeek; } /** 4-digit ISO week-numbering year */ get yow() { return getISOWeekOfYear(this.toDateTime()).yearOfWeek; } - /** @internal ISO week number of the year */ get wy() { return getISOWeekOfYear(this.toDateTime()).weekOfYear as t.wy; } - /** ISO week number of the year */ get woy() { return getISOWeekOfYear(this.toDateTime()).weekOfYear as t.wy; } - /** - * ISO week number of the year. - * @deprecated Use `woy` (Tempo canonical) or `zdt.weekOfYear` instead. To be removed in v5.0.0. - */ - get ww() { return getISOWeekOfYear(this.toDateTime()).weekOfYear as t.wy; } + /** @internal ISO week number of the year */ get wy() { return getISOWeekOfYear(this.toDateTime()).weekOfYear as t.woy; } + /** ISO week number of the year */ get woy() { return getISOWeekOfYear(this.toDateTime()).weekOfYear as t.woy; } /** Month number: Jan=1, Dec=12 */ get mm() { return this.toDateTime().month as t.mm } /** Day of the month (1-31) */ get dd() { return this.toDateTime().day as t.dd } - /** - * Day of the month (1-31). - * @deprecated Use `dd` (Tempo canonical) or `zdt.day` instead. To be removed in v5.0.0. - */ - get day() { return this.toDateTime().day as t.dd } /** Internationalization namespace (info, locale, and cultural metadata) */ get intl(): TempoIntlNamespace { return getIntlNamespace(this.locale, this.tz); } /** Hour of the day (0-23) */ get hh() { return this.toDateTime().hour as t.hh } @@ -2039,11 +1988,6 @@ export class Tempo { /** @hidden */ sub(tempo?: t.MutateAdd, options?: t.Options): Tempo { return this.subtract(tempo, options); } /** @hidden */ minus(tempo?: t.MutateAdd, options?: t.Options): Tempo { return this.subtract(tempo, options); } /** returns a new `Tempo` with specific offsets. */ set(tempo?: t.MutateSet, options?: t.Options): Tempo { return this.#resolve(() => interpret(this, 'MutateModule', 'set', false, tempo, options) ?? this); } - /** - * Returns a clone of the current `Tempo` instance. - * @deprecated Tempo instances are immutable. Use `Tempo.from(instance)` instead. - */ - clone(): Tempo { return this.#Tempo.from(this, this.config); } /** returns the underlying Temporal.ZonedDateTime */ toDateTime() { return this.#resolve() as Temporal.ZonedDateTime; } /** returns a Temporal.PlainDate representation */ toPlainDate() { return this.toDateTime().toPlainDate() } @@ -2325,10 +2269,6 @@ export namespace Tempo { export type us = t.us; /** Nanosecond numeric value */ export type ns = t.ns; - /** ISO week-year numeric value */ - export type wy = t.wy; - /** @hidden prefer `wy` */ - export type ww = t.wy; /** Timestamp precision unit (ss, ms, us, ns) */ export type TimeStamp = t.Internal.TimeStamp; diff --git a/packages/tempo/src/tempo.type.ts b/packages/tempo/src/tempo.type.ts index ac5eb2b0..70912ae1 100644 --- a/packages/tempo/src/tempo.type.ts +++ b/packages/tempo/src/tempo.type.ts @@ -8,7 +8,7 @@ */ import type { DebugLevel } from '#library/logger.class.js'; import type { ScopedSet } from '#library/scopedset.class.js'; -import type { IntRange, NonOptional, Property, Plural, TemporalObject, TypeValue, RegistryOption, Branded, LooseUnion, Evaluable, MutableObject } from '#library/type.library.js'; +import type { IntRange, NonOptional, Property, Plural, TemporalObject, TypeValue, RegistryOption, Branded, LooseUnion, Evaluable, MutableObject, ValueOf } from '#library/type.library.js'; import type { GeoOptions, GeoConfig } from '#library/mapper.library.js'; import type { BoundedCache } from '#library/cache.class.js'; import type { WeakCache } from '#library/weakcache.class.js'; @@ -167,7 +167,7 @@ export type SetFields = { } & { [K in 'year' | 'month' | 'week' | 'isoWeek' | 'isoweek' | 'isoYear' | 'isoyear' | 'yw' | 'yow' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond' | 'nanosecond']?: number | Mutate | (string & {}); } -export type SlickKey = SLICK_KEYS[number]; +export type SlickKey = ValueOf; export type SlickOffset = { [K in SlickKey]?: string }; export type MutateShorthand = { @@ -181,8 +181,6 @@ export type MutateShorthand = { /** @internal */ wy?: LooseUnion; woy?: LooseUnion; - /** @deprecated Use `woy` instead. */ - ww?: LooseUnion; isoWeek?: LooseUnion; isoweek?: LooseUnion; dd?: LooseUnion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ; @@ -217,8 +215,6 @@ export type ns = IntRange<0, 999> export type woy = IntRange<1, 53> /** @internal alias for `woy` */ export type wy = woy; -/** @deprecated Use `woy` instead. */ -export type ww = woy; export type wkd = IntRange<1, 7> export type Duration = NonOptional & Record<"iso", string> & Record<"sign", number> & Record<"blank", boolean> & Record<"unit", string | undefined> & { @@ -249,20 +245,8 @@ export type FormatRegistry = enums.FormatEnum; export interface TempoFormatTokens { // ── year / week ─────────────────────────────────── yyyy: true; yy: true; yow: true; - /** @internal */ - yw: true; // ── week-of-year ───────────────────────────────── woy: true; - /** @deprecated Easily composed via `{yow}{woy}`. To be removed in v5.0.0. */ - yywoy: true; - /** @internal */ - wy: true; - /** @internal */ - yywy: true; - /** @deprecated Deprecated in v4.3.0; to be removed in v5.0.0. Use `woy` instead. */ - ww: true; - /** @deprecated Deprecated in v4.3.0; to be removed in v5.0.0. Use `{yow}{woy}` instead. */ - yyww: true; // ── era / eon ───────────────────────────────────── era: true; eon: true; // ── month ───────────────────────────────────────── @@ -280,8 +264,6 @@ export interface TempoFormatTokens { ts: true; nano: true; tz: true; cal: true; // ── specialized tokens & counters ───────────────── cen: true; century: true; dim: true; jj: true; julian: true; wom: true; - /** @deprecated Deprecated in v4.2.0; to be removed in v5.0.0. Use `tz` instead. */ - tzd: true; } /** All statically-known base token names (derived from TempoFormatTokens). */ diff --git a/packages/tempo/test/core/intl.locale-info.test.ts b/packages/tempo/test/core/intl.locale-info.test.ts index b6316cc9..36572b3a 100644 --- a/packages/tempo/test/core/intl.locale-info.test.ts +++ b/packages/tempo/test/core/intl.locale-info.test.ts @@ -481,7 +481,7 @@ describe('Intl.LocaleInfo & Regional Calendar Integration', () => { expect(sunUS.format('{woy:locale:0}')).toBe('00'); expect(sunUS.format('{yow:locale}')).toBe('2026'); expect(sunUS.format('{yow:locale:short}')).toBe('26'); - expect(sunUS.format('{yywoy:locale}')).toBe('202601'); + expect(sunUS.format('{yow:locale}{woy:locale}')).toBe('202601'); // Under ISO rules (en-GB, minimalDays=4), 2025-12-28 is still Week 52 of 2025 expect(sunUS.format('{woy:locale}', { locale: 'en-GB' })).toBe('52'); @@ -544,21 +544,24 @@ describe('Intl.LocaleInfo & Regional Calendar Integration', () => { }); }); - describe('9. Structured t.intl Namespace (info, locale, and backward compatibility)', () => { + describe('9. Structured t.intl Namespace (info and locale)', () => { it('exposes t.intl.info cultural metadata', () => { const t = new Tempo('2026-09-16', { locale: 'en-US' }); expect(t.intl.info.firstDay).toBe(7); expect(t.intl.info.minimalDays).toBe(1); - expect(t.intl.minimalDays).toBe(1); expect(t.intl.info.weekend).toEqual([6, 7]); expect(t.intl.info.direction).toBe('ltr'); expect(t.intl.info.region).toBe('US'); expect(t.intl.info.baseName).toBe('en-US'); + expect(t.intl.info.calendar).toBe('gregory'); + expect(t.intl.info.calendars).toContain('gregory'); + expect(Object.isFrozen(t.intl.info.calendars)).toBe(true); const tGB = new Tempo('2026-09-16', { locale: 'en-GB' }); expect(tGB.intl.info.firstDay).toBe(1); expect(tGB.intl.info.minimalDays).toBe(4); - expect(tGB.intl.minimalDays).toBe(4); + expect(tGB.intl.info.calendar).toBe('gregory'); + expect(tGB.intl.info.calendars).toContain('gregory'); }); it('exposes t.intl.locale native Intl.Locale instance', () => { @@ -573,6 +576,8 @@ describe('Intl.LocaleInfo & Regional Calendar Integration', () => { Tempo.init({ locale: 'fr-FR' }); expect(Tempo.intl.info.firstDay).toBe(1); expect(Tempo.intl.info.direction).toBe('ltr'); + expect(Tempo.intl.info.calendar).toBe('gregory'); + expect(Tempo.intl.info.calendars).toContain('gregory'); expect(Tempo.intl.locale?.baseName).toBe('fr-FR'); } finally { Tempo.init(); diff --git a/packages/tempo/test/core/sandbox_isolation.test.ts b/packages/tempo/test/core/sandbox_isolation.test.ts index a9c223d3..a2e3cc4e 100644 --- a/packages/tempo/test/core/sandbox_isolation.test.ts +++ b/packages/tempo/test/core/sandbox_isolation.test.ts @@ -38,7 +38,7 @@ describe('Sandbox Plugin Isolation (ScopedSet)', () => { const sandboxPlugin = (T: any) => { (T as any).sandboxOnly = true; }; const X = Tempo.create({}); - X.extend([sandboxPlugin]); + X.use([sandboxPlugin]); // Global rt.installed should be unaffected expect(getRuntime().installed.has(sandboxPlugin)).toBe(false); @@ -51,7 +51,7 @@ describe('Sandbox Plugin Isolation (ScopedSet)', () => { const plugin = (_T: any) => { calls++; }; const X = Tempo.create({}); - X.extend([plugin]); + X.use([plugin]); expect(calls).toBe(1); // sandbox installed it Tempo.use([plugin]); @@ -66,7 +66,7 @@ describe('Sandbox Plugin Isolation (ScopedSet)', () => { expect(calls).toBe(1); // global installed it const X = Tempo.create({}); - X.extend([plugin]); + X.use([plugin]); expect(calls).toBe(1); // ScopedSet.has() found it in parent → skipped ✓ }); @@ -88,11 +88,11 @@ describe('Sandbox Plugin Isolation (ScopedSet)', () => { const A = Tempo.create({}); const B = Tempo.create({}); - A.extend([pluginA]); + A.use([pluginA]); expect(callsA).toBe(1); expect(callsB).toBe(0); - B.extend([pluginB]); + B.use([pluginB]); expect(callsA).toBe(1); expect(callsB).toBe(1); diff --git a/packages/tempo/test/core/static.getters.test.ts b/packages/tempo/test/core/static.getters.test.ts index b4592cf0..d458f799 100644 --- a/packages/tempo/test/core/static.getters.test.ts +++ b/packages/tempo/test/core/static.getters.test.ts @@ -123,18 +123,6 @@ describe(`${label} enums`, () => { expect(Tempo.enums.CACHE).toBeDefined(); }) - test('restored static getters on Tempo match Tempo.enums for backward compatibility', () => { - expect(Tempo.ELEMENT).toBe(Tempo.enums.ELEMENT); - expect(Tempo.FORMAT).toBe(Tempo.enums.FORMAT); - expect(Tempo.NUMBER).toBe(Tempo.enums.NUMBER); - expect(Tempo.ORDINAL).toBe(Tempo.enums.ORDINAL); - expect(Tempo.TIMEZONE).toBe(Tempo.enums.TIMEZONE); - expect(Tempo.MONTH_DAY).toBe(Tempo.enums.MONTH_DAY); - expect(Tempo.MODE).toBe(Tempo.enums.MODE); - expect(Tempo.CACHE).toBe(Tempo.enums.CACHE); - expect(Tempo.LIMIT).toBe(Tempo.enums.LIMIT); - }) - }) describe(`${label} ELEMENT (via Tempo.enums)`, () => { diff --git a/packages/tempo/test/core/static.test.ts b/packages/tempo/test/core/static.test.ts index 40133d5a..e3cd2be9 100644 --- a/packages/tempo/test/core/static.test.ts +++ b/packages/tempo/test/core/static.test.ts @@ -8,10 +8,8 @@ const label = 'static:'; describe(`${label}`, () => { test(`${label} get the properties`, () => { - // Note: 'ww', 'day', and 'eraYear' are @deprecated and will be removed in the next breaking change (v5.0.0). - // They are preserved in Tempo.properties throughout v4.x for backward compatibility. expect(Tempo.properties.toSorted()) - .toEqual(['yy', 'yw', 'yow', 'mm', 'dd', 'hh', 'mi', 'ss', 'ms', 'us', 'ns', 'ff', 'fmt', 'ww', 'wy', 'woy', 'tz', 'cal', 'locale', 'intl', 'sphere', 'geo', 'ts', 'dow', 'doy', 'dim', 'jj', 'mmm', 'mon', 'www', 'wkd', 'day', 'nano', 'term', 'terms', 'config', 'epoch', 'parse', 'ranges', 'isValid', 'iso', 'era', 'eraYear', 'eon', 'zdt'].toSorted()) + .toEqual(['yy', 'yw', 'yow', 'mm', 'dd', 'hh', 'mi', 'ss', 'ms', 'us', 'ns', 'ff', 'fmt', 'wy', 'woy', 'tz', 'cal', 'locale', 'intl', 'sphere', 'geo', 'ts', 'dow', 'doy', 'dim', 'jj', 'mmm', 'mon', 'www', 'wkd', 'nano', 'term', 'terms', 'config', 'epoch', 'parse', 'ranges', 'isValid', 'iso', 'era', 'eon', 'zdt'].toSorted()) }) test(`${label} get the elements`, () => { diff --git a/packages/tempo/test/discrete/format.test.ts b/packages/tempo/test/discrete/format.test.ts index ff9fcf18..ff54b383 100644 --- a/packages/tempo/test/discrete/format.test.ts +++ b/packages/tempo/test/discrete/format.test.ts @@ -33,7 +33,6 @@ describe('Tempo.format() refinements', () => { expect(t3.woy).toBe(1); expect(t3.format('{yw}{ww}')).toBe('202501'); expect(t3.format('{yow}{woy}')).toBe('202501'); - expect(t3.format('{yywoy}')).toBe('202501'); expect(typeof t3.format('{yw}{ww}')).toBe('string'); }) @@ -356,57 +355,57 @@ describe('Tempo.format() refinements', () => { expect(dtUtc.format('{tz:offset:sec}')).toBe('+00:00:00'); expect(dtPos.format('{tz:offset:ss}')).toBe('+08:00:00'); expect(dtPos.format('{tz:offset:sec}')).toBe('+08:00:00'); - expect(dtPos.format('{tz:offsetcompact:ss}')).toBe('+080000'); expect(dtPos.format('{tz:offset:compact:ss}')).toBe('+080000'); - expect(dtPos.format('{tz:offsetcompact:sec}')).toBe('+080000'); expect(dtPos.format('{tz:offset:compact:sec}')).toBe('+080000'); + expect(dtPos.format('{tz:offset:ss:compact}')).toBe('+080000'); expect(dtHalf.format('{tz:offset:ss}')).toBe('+05:30:00'); - expect(dtHalf.format('{tz:offsetcompact:ss}')).toBe('+053000'); + expect(dtHalf.format('{tz:offset:compact:ss}')).toBe('+053000'); + expect(dtPos.format('{tz:offset:compact}')).toBe('+0800'); + expect(dtHalf.format('{tz:offset:compact}')).toBe('+0530'); + expect(dtPos.format('{time:compact}')).toBe('090703'); }) it('formats UTC Z indicator via canonical :utc and internal alias :z', () => { // Canonical :utc expect(dtUtc.format('{tz:offset:utc}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:utc}')).toBe('Z'); expect(dtUtc.format('{tz:offset:compact:utc}')).toBe('Z'); expect(dtUtc.format('{tz:offset:short:utc}')).toBe('Z'); expect(dtUtc.format('{tz:offset:ss:utc}')).toBe('Z'); expect(dtUtc.format('{tz:offset:sec:utc}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:ss:utc}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:sec:utc}')).toBe('Z'); + expect(dtUtc.format('{tz:offset:compact:ss:utc}')).toBe('Z'); + expect(dtUtc.format('{tz:offset:compact:sec:utc}')).toBe('Z'); expect(dtPos.format('{tz:offset:utc}')).toBe('+08:00'); - expect(dtPos.format('{tz:offsetcompact:utc}')).toBe('+0800'); + expect(dtPos.format('{tz:offset:compact:utc}')).toBe('+0800'); expect(dtPos.format('{tz:offset:short:utc}')).toBe('+08'); expect(dtPos.format('{tz:offset:ss:utc}')).toBe('+08:00:00'); expect(dtPos.format('{tz:offset:sec:utc}')).toBe('+08:00:00'); - expect(dtPos.format('{tz:offsetcompact:ss:utc}')).toBe('+080000'); - expect(dtPos.format('{tz:offsetcompact:sec:utc}')).toBe('+080000'); + expect(dtPos.format('{tz:offset:compact:ss:utc}')).toBe('+080000'); + expect(dtPos.format('{tz:offset:compact:sec:utc}')).toBe('+080000'); expect(dtHalf.format('{tz:offset:utc}')).toBe('+05:30'); - expect(dtHalf.format('{tz:offsetcompact:utc}')).toBe('+0530'); + expect(dtHalf.format('{tz:offset:compact:utc}')).toBe('+0530'); expect(dtHalf.format('{tz:offset:short:utc}')).toBe('+05:30'); // Internal alias :z expect(dtUtc.format('{tz:offset:z}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:z}')).toBe('Z'); expect(dtUtc.format('{tz:offset:compact:z}')).toBe('Z'); expect(dtUtc.format('{tz:offset:short:z}')).toBe('Z'); expect(dtUtc.format('{tz:offset:ss:z}')).toBe('Z'); expect(dtUtc.format('{tz:offset:sec:z}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:ss:z}')).toBe('Z'); - expect(dtUtc.format('{tz:offsetcompact:sec:z}')).toBe('Z'); + expect(dtUtc.format('{tz:offset:compact:ss:z}')).toBe('Z'); + expect(dtUtc.format('{tz:offset:compact:sec:z}')).toBe('Z'); expect(dtPos.format('{tz:offset:z}')).toBe('+08:00'); - expect(dtPos.format('{tz:offsetcompact:z}')).toBe('+0800'); + expect(dtPos.format('{tz:offset:compact:z}')).toBe('+0800'); expect(dtPos.format('{tz:offset:short:z}')).toBe('+08'); expect(dtPos.format('{tz:offset:ss:z}')).toBe('+08:00:00'); expect(dtPos.format('{tz:offset:sec:z}')).toBe('+08:00:00'); - expect(dtPos.format('{tz:offsetcompact:ss:z}')).toBe('+080000'); - expect(dtPos.format('{tz:offsetcompact:sec:z}')).toBe('+080000'); + expect(dtPos.format('{tz:offset:compact:ss:z}')).toBe('+080000'); + expect(dtPos.format('{tz:offset:compact:sec:z}')).toBe('+080000'); expect(dtHalf.format('{tz:offset:z}')).toBe('+05:30'); - expect(dtHalf.format('{tz:offsetcompact:z}')).toBe('+0530'); + expect(dtHalf.format('{tz:offset:compact:z}')).toBe('+0530'); expect(dtHalf.format('{tz:offset:short:z}')).toBe('+05:30'); }) }) diff --git a/packages/tempo/test/discrete/parse.locale.test.ts b/packages/tempo/test/discrete/parse.locale.test.ts index 2f93f47c..1a7a1c38 100644 --- a/packages/tempo/test/discrete/parse.locale.test.ts +++ b/packages/tempo/test/discrete/parse.locale.test.ts @@ -41,16 +41,16 @@ describe('Localized Parsing', () => { it('should parse French relative events (yesterday, today, tomorrow)', () => { const t1 = new Tempo('hier', { locale: 'fr-FR', anchor: '2024-01-15T12:00:00+00:00[UTC]' }); expect(t1.isValid).toBe(true); - expect(t1.day).toBe(14); + expect(t1.dd).toBe(14); const t2 = new Tempo("aujourd’hui", { locale: 'fr-FR', anchor: '2024-01-15T12:00:00+00:00[UTC]' }); expect(t2.isValid).toBe(true); const currentDay = Temporal.Now.zonedDateTimeISO('UTC').day; - expect(t2.day).toBe(currentDay); + expect(t2.dd).toBe(currentDay); const t3 = new Tempo('demain', { locale: 'fr-FR', anchor: '2024-01-15T12:00:00+00:00[UTC]' }); expect(t3.isValid).toBe(true); - expect(t3.day).toBe(16); + expect(t3.dd).toBe(16); }); it('should preserve English dates even if localized parsing is active for French', () => { diff --git a/packages/tempo/test/discrete/timezone_token.test.ts b/packages/tempo/test/discrete/timezone_token.test.ts index c543e01d..81330c57 100644 --- a/packages/tempo/test/discrete/timezone_token.test.ts +++ b/packages/tempo/test/discrete/timezone_token.test.ts @@ -1,7 +1,7 @@ import { Tempo } from '#tempo'; import { Token } from '#tempo/support'; -describe('Canonical {tz} and backwards-compatible {tzd} timezone token', () => { +describe('Canonical {tz} timezone token', () => { beforeEach(() => { Tempo.init(); }); @@ -10,11 +10,9 @@ describe('Canonical {tz} and backwards-compatible {tzd} timezone token', () => { Tempo.init(); }); - it('exposes Token.tz and Token.tzd symbols', () => { + it('exposes Token.tz symbol', () => { expect(Token.tz).toBeDefined(); expect(typeof Token.tz).toBe('symbol'); - expect(Token.tzd).toBeDefined(); - expect(typeof Token.tzd).toBe('symbol'); }); it('parses standard date-times with timezone offsets and abbreviations via default layouts', () => { @@ -49,25 +47,6 @@ describe('Canonical {tz} and backwards-compatible {tzd} timezone token', () => { expect(t.mi).toBe(30); }); - it('supports custom layouts using deprecated {tzd} for backwards compatibility', () => { - const layout = '{tzd}{sep}+{dt}{sep}+{tm}'; - const reg = Tempo.regexp(layout); - expect(reg.source).toContain('(?'); - - Tempo.init({ - locale: 'en-AU', - registry: { - layouts: { - leadingTzdLegacy: layout - } - } - }); - - const t = new Tempo('EST 8 Aug 2026 10:30'); - expect(t.isValid).toBe(true); - expect(t.tz).toBe('America/New_York'); - }); - it('formats with canonical {tz} and modifiers', () => { const t = new Tempo('2026-08-06T16:16:00+10:00[Australia/Sydney]', { locale: 'en-AU' }); expect(t.format('{tz}')).toBe('Australia/Sydney'); @@ -77,36 +56,5 @@ describe('Canonical {tz} and backwards-compatible {tzd} timezone token', () => { expect(t.format('{tz:offset:compact}')).toBe('+1000'); expect(t.format('{tz:short}')).toBe('AEST'); expect(t.format('{tz:long}')).toBe('Australian Eastern Standard Time'); - expect(t.format('{tz:z}')).toBe('+10'); - expect(t.format('{tz:zz}')).toBe('+10:00'); - expect(t.format('{tz:zzz}')).toBe('+1000'); - }); - - it('formats with legacy {tzd} and modifiers identically to {tz}', () => { - const t = new Tempo('2026-08-06T16:16:00+10:00[Australia/Sydney]', { locale: 'en-AU' }); - expect(t.format('{tzd}')).toBe('Australia/Sydney'); - expect(t.format('{tzd:offset}')).toBe('+10:00'); - expect(t.format('{tzd:offset:short}')).toBe('+10'); - expect(t.format('{tzd:offset:compact}')).toBe('+1000'); - expect(t.format('{tzd:short}')).toBe('AEST'); - }); - - it('resolves cross-fallback between tz and tzd custom snippets', () => { - // Custom snippet registered under Token.tz resolves when compiling a layout with {tzd} - const customSnippet = { - [Token.tz]: /(?UTC|Z)/ - } as any; - - const compiledLegacy = Tempo.regexp('{tzd}', customSnippet); - expect(compiledLegacy.test('UTC')).toBe(true); - expect(compiledLegacy.test('Z')).toBe(true); - - // Custom snippet registered under Token.tzd resolves when compiling a layout with {tz} - const customLegacySnippet = { - [Token.tzd]: /(?GMT)/ - } as any; - - const compiledModern = Tempo.regexp('{tz}', customLegacySnippet); - expect(compiledModern.test('GMT')).toBe(true); }); }); diff --git a/packages/tempo/test/engine/modifiers.test.ts b/packages/tempo/test/engine/modifiers.test.ts index 575b9aad..3edb6d49 100644 --- a/packages/tempo/test/engine/modifiers.test.ts +++ b/packages/tempo/test/engine/modifiers.test.ts @@ -40,19 +40,19 @@ describe('Localized Modifiers', () => { const now = new Tempo('2026-06-20T12:00:00+10:00', config); const nextMay = new Tempo('1 May prochain', { ...config, anchor: now }); - if (nextMay.yy !== 2027) throw new Error("nextMay.yy is " + nextMay.yy + " month: " + nextMay.mm + " day: " + nextMay.day); + if (nextMay.yy !== 2027) throw new Error("nextMay.yy is " + nextMay.yy + " month: " + nextMay.mm + " day: " + nextMay.dd); expect(nextMay.mm).toBe(5); - expect(nextMay.day).toBe(1); + expect(nextMay.dd).toBe(1); expect(nextMay.yy).toBeGreaterThan(2026); const pastMay = new Tempo('1 May dernier', { ...config, anchor: now }); expect(pastMay.mm).toBe(5); - expect(pastMay.day).toBe(1); + expect(pastMay.dd).toBe(1); expect(pastMay.yy).toBe(2026); const pastAugust = new Tempo('1 August dernier', { ...config, anchor: now }); expect(pastAugust.mm).toBe(8); - expect(pastAugust.day).toBe(1); + expect(pastAugust.dd).toBe(1); expect(pastAugust.yy).toBe(2025); }); @@ -71,7 +71,7 @@ describe('Localized Modifiers', () => { const futureDate = new Tempo('1 May dans la', { ...config, anchor: now }); expect(futureDate.mm).toBe(5); - expect(futureDate.day).toBe(1); + expect(futureDate.dd).toBe(1); expect(futureDate.yy).toBeGreaterThan(2026); }); diff --git a/packages/tempo/test/engine/month-day.test.ts b/packages/tempo/test/engine/month-day.test.ts index b8d6ec75..16b9ff29 100644 --- a/packages/tempo/test/engine/month-day.test.ts +++ b/packages/tempo/test/engine/month-day.test.ts @@ -6,14 +6,14 @@ describe('Tempo: Month-Day Parsing (Ambiguity Support)', () => { const t = new Tempo('04/01/2023', { locale: 'en-US', timeZone: 'America/New_York' }); expect(t.parse.monthDay.active, 'MDY should be active for America/New_York').toBe(true); expect(t.mm, 'Month should be April (4)').toBe(4); - expect(t.day, 'Day should be 1st').toBe(1); + expect(t.dd, 'Day should be 1st').toBe(1); }); it('should auto-detect DMY order for en-GB locale', () => { const t = new Tempo('04/01/2023', { locale: 'en-GB', timeZone: 'Europe/London' }); expect(t.parse.monthDay.active, 'MDY should NOT be active for Europe/London').toBe(false); expect(t.mm, 'Month should be January (1)').toBe(1); - expect(t.day, 'Day should be 4th').toBe(4); + expect(t.dd, 'Day should be 4th').toBe(4); }); it('should allow manual override to force MDY parsing (active: true)', () => {